关闭代币账户

关闭代币账户有什么作用?

关闭代币账户会删除该账户并将代币账户的租金 lamport 返回到目标账户。

账户必须在代币余额为零的情况下才能关闭。如果冻结账户的代币余额为零,该冻结账户仍然可以被关闭。封装的 SOL 代币账户是个例外,即使有代币余额也可以关闭以收回底层的 SOL。账户所有者或账户的关闭权限签署关闭指令。

如何关闭代币账户

关闭代币账户使用 Token Program 的 CloseAccount 指令。

CloseAccount 指令将源账户的 lamport 转移到目标账户,清除源账户并删除源账户。Token Extensions Program 对某些扩展应用额外的关闭检查,但基本关闭流程是相同的。

源代码参考

项目	描述	Token Program	Token Extensions Program
`Account`	代币账户状态存储在账户关闭期间使用的余额、原生状态和关闭权限。	源代码	源代码
`CloseAccount`	关闭代币账户并将代币账户的 lamport 转移到目标账户的指令。	源代码	源代码
`process_close_account`	代币账户关闭的共享处理器逻辑。	源代码	源代码

Typescript

以下 Kit 示例展示了使用 @solana/kit 的推荐方法。同时包含使用 @solana/web3.js 的旧版示例以供参考。

Kit

import { generateKeyPairSigner } from "@solana/kit";
import { createLocalClient } from "@solana/kit-client-rpc";
import {
  findAssociatedTokenPda,
  getCreateAssociatedTokenInstructionAsync,
  tokenProgram,
  TOKEN_PROGRAM_ADDRESS
} from "@solana-program/token";

const client = await createLocalClient()
  .use(tokenProgram());

const mint = await generateKeyPairSigner();
const destination = client.payer.address;

const [tokenAccount] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: client.payer.address,
  tokenProgram: TOKEN_PROGRAM_ADDRESS
});


const result = await client.token.instructions
  .closeAccount({
    account: tokenAccount, // Token account to close.
    destination, // Account receiving the reclaimed SOL.
    owner: client.payer // Owner approving the account closure.
  })
  .sendTransaction();

const tokenAccountData =
  await client.token.accounts.token.fetchMaybe(tokenAccount);

console.log("Mint Address:", mint.address);
console.log("\nToken Account Address:", tokenAccount);
console.log("Token Account:", tokenAccountData);
console.log("\nDestination Address:", destination);
console.log("\nTransaction Signature:", result.context.signature);

Console

Click to execute the code.

import { generateKeyPairSigner } from "@solana/kit";
import { createLocalClient } from "@solana/kit-client-rpc";
import {
  findAssociatedTokenPda,
  getCreateAssociatedTokenInstructionAsync,
  tokenProgram,
  TOKEN_PROGRAM_ADDRESS
} from "@solana-program/token";

const client = await createLocalClient()
  .use(tokenProgram());

const mint = await generateKeyPairSigner();
const destination = client.payer.address;

const [tokenAccount] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: client.payer.address,
  tokenProgram: TOKEN_PROGRAM_ADDRESS
});


const result = await client.token.instructions
  .closeAccount({
    account: tokenAccount, // Token account to close.
    destination, // Account receiving the reclaimed SOL.
    owner: client.payer // Owner approving the account closure.
  })
  .sendTransaction();

const tokenAccountData =
  await client.token.accounts.token.fetchMaybe(tokenAccount);

console.log("Mint Address:", mint.address);
console.log("\nToken Account Address:", tokenAccount);
console.log("Token Account:", tokenAccountData);
console.log("\nDestination Address:", destination);
console.log("\nTransaction Signature:", result.context.signature);

Console

Click to execute the code.

Web3.js

import { Connection, Keypair, LAMPORTS_PER_SOL } from "@solana/web3.js";
import {
  createAssociatedTokenAccount,
  closeAccount,
  createMint,
  TOKEN_PROGRAM_ID
} from "@solana/spl-token";


const result = await closeAccount(
  connection, // Connection to the local validator.
  feePayer, // Account paying transaction fees.
  associatedTokenAccount, // Token account to close.
  destination, // Account receiving the reclaimed SOL.
  feePayer, // Owner approving the account closure.
  [], // Additional multisig signers.
  {
    commitment: "confirmed" // Confirmation options for the transaction.
  },
  TOKEN_PROGRAM_ID // Token program to invoke.
);

const tokenAccountData = await connection.getAccountInfo(
  associatedTokenAccount,
  "confirmed"
);

console.log("Mint Address:", mintPubkey.toBase58());
console.log(
  "\nAssociated Token Account Address:",
  associatedTokenAccount.toBase58()
);
console.log("Associated Token Account:", tokenAccountData);
console.log("\nDestination Address:", destination.toBase58());
console.log("\nTransaction Signature:", result);

Console

Click to execute the code.

import { Connection, Keypair, LAMPORTS_PER_SOL } from "@solana/web3.js";
import {
  createAssociatedTokenAccount,
  closeAccount,
  createMint,
  TOKEN_PROGRAM_ID
} from "@solana/spl-token";


const result = await closeAccount(
  connection, // Connection to the local validator.
  feePayer, // Account paying transaction fees.
  associatedTokenAccount, // Token account to close.
  destination, // Account receiving the reclaimed SOL.
  feePayer, // Owner approving the account closure.
  [], // Additional multisig signers.
  {
    commitment: "confirmed" // Confirmation options for the transaction.
  },
  TOKEN_PROGRAM_ID // Token program to invoke.
);

const tokenAccountData = await connection.getAccountInfo(
  associatedTokenAccount,
  "confirmed"
);

console.log("Mint Address:", mintPubkey.toBase58());
console.log(
  "\nAssociated Token Account Address:",
  associatedTokenAccount.toBase58()
);
console.log("Associated Token Account:", tokenAccountData);
console.log("\nDestination Address:", destination.toBase58());
console.log("\nTransaction Signature:", result);

Console

Click to execute the code.

Rust

use anyhow::Result;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_commitment_config::CommitmentConfig;
use solana_sdk::{
    program_pack::Pack,
    signature::{Keypair, Signer},
    transaction::Transaction,
};
use solana_system_interface::instruction::create_account;
use spl_associated_token_account_interface::{
    address::get_associated_token_address, instruction::create_associated_token_account,
};
use spl_token_interface::{
    id as token_program_id,
    instruction::{close_account, initialize_mint},
    state::{Account, Mint},
};

#[tokio::main]
async fn main() -> Result<()> {
    let client = RpcClient::new_with_commitment(
        String::from("http://localhost:8899"),
        CommitmentConfig::confirmed(),
    );


    let associated_token_address = get_associated_token_address(&fee_payer.pubkey(), &mint.pubkey());
    let destination = fee_payer.pubkey();
    let transaction = Transaction::new_signed_with_payer(
        &[
            close_account(
                &token_program_id(), // Token program to invoke.
                &associated_token_address, // Token account to close.
                &destination, // Account receiving the reclaimed SOL.
                &fee_payer.pubkey(), // Owner approving the account closure.
                &[], // Additional multisig signers.
            )?,
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

    let transaction_signature = client.send_and_confirm_transaction(&transaction).await?;
    let token_data = match client.get_account(&associated_token_address).await {
        Ok(account) => Some(Account::unpack(&account.data)?),
        Err(_) => None,
    };

    println!("Mint Address: {}", mint.pubkey());
    println!(
        "\nAssociated Token Account Address: {}",
        associated_token_address
    );
    println!("Associated Token Account: {:#?}", token_data);
    println!("\nDestination Address: {}", destination);
    println!("\nTransaction Signature: {}", transaction_signature);

    Ok(())
}

Console

Click to execute the code.

Rust

use anyhow::Result;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_commitment_config::CommitmentConfig;
use solana_sdk::{
    program_pack::Pack,
    signature::{Keypair, Signer},
    transaction::Transaction,
};
use solana_system_interface::instruction::create_account;
use spl_associated_token_account_interface::{
    address::get_associated_token_address, instruction::create_associated_token_account,
};
use spl_token_interface::{
    id as token_program_id,
    instruction::{close_account, initialize_mint},
    state::{Account, Mint},
};

#[tokio::main]
async fn main() -> Result<()> {
    let client = RpcClient::new_with_commitment(
        String::from("http://localhost:8899"),
        CommitmentConfig::confirmed(),
    );


    let associated_token_address = get_associated_token_address(&fee_payer.pubkey(), &mint.pubkey());
    let destination = fee_payer.pubkey();
    let transaction = Transaction::new_signed_with_payer(
        &[
            close_account(
                &token_program_id(), // Token program to invoke.
                &associated_token_address, // Token account to close.
                &destination, // Account receiving the reclaimed SOL.
                &fee_payer.pubkey(), // Owner approving the account closure.
                &[], // Additional multisig signers.
            )?,
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

    let transaction_signature = client.send_and_confirm_transaction(&transaction).await?;
    let token_data = match client.get_account(&associated_token_address).await {
        Ok(account) => Some(Account::unpack(&account.data)?),
        Err(_) => None,
    };

    println!("Mint Address: {}", mint.pubkey());
    println!(
        "\nAssociated Token Account Address: {}",
        associated_token_address
    );
    println!("Associated Token Account: {:#?}", token_data);
    println!("\nDestination Address: {}", destination);
    println!("\nTransaction Signature: {}", transaction_signature);

    Ok(())
}

Console

Click to execute the code.

Python

#!/usr/bin/env python3

import asyncio
import json
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from solders.message import Message
from solders.system_program import create_account, CreateAccountParams
from solders.transaction import Transaction
from spl.token.async_client import AsyncToken
from spl.token.instructions import (
    close_account,
    CloseAccountParams,
    create_associated_token_account,
    get_associated_token_address,
    initialize_mint,
    InitializeMintParams,
)
from spl.token.constants import MINT_LEN, TOKEN_PROGRAM_ID

async def main():
    rpc = AsyncClient("http://localhost:8899")

    async with rpc:

        close_account_instruction = close_account(
            CloseAccountParams(
                program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.
                account=token_account_address,  # Token account to close.
                dest=fee_payer.pubkey(),  # Account receiving the reclaimed lamports.
                owner=fee_payer.pubkey(),  # Account allowed to close the token account.
            )
        )
        latest_blockhash = await rpc.get_latest_blockhash()
        transaction = Transaction(
            [fee_payer],
            Message([close_account_instruction], fee_payer.pubkey()),
            latest_blockhash.value.blockhash,
        )
        result = await rpc.send_transaction(transaction)

        closed_token_account = (await rpc.get_account_info(token_account_address)).value

        print("Mint Address:", mint.pubkey())
        print("\nToken Account Address:", token_account_address)
        print("Token Account:")
        print(json.dumps(closed_token_account, indent=2))
        print("\nTransaction Signature:", result.value)

if __name__ == "__main__":
    asyncio.run(main())

Console

Click to execute the code.

Python

#!/usr/bin/env python3

import asyncio
import json
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from solders.message import Message
from solders.system_program import create_account, CreateAccountParams
from solders.transaction import Transaction
from spl.token.async_client import AsyncToken
from spl.token.instructions import (
    close_account,
    CloseAccountParams,
    create_associated_token_account,
    get_associated_token_address,
    initialize_mint,
    InitializeMintParams,
)
from spl.token.constants import MINT_LEN, TOKEN_PROGRAM_ID

async def main():
    rpc = AsyncClient("http://localhost:8899")

    async with rpc:

        close_account_instruction = close_account(
            CloseAccountParams(
                program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.
                account=token_account_address,  # Token account to close.
                dest=fee_payer.pubkey(),  # Account receiving the reclaimed lamports.
                owner=fee_payer.pubkey(),  # Account allowed to close the token account.
            )
        )
        latest_blockhash = await rpc.get_latest_blockhash()
        transaction = Transaction(
            [fee_payer],
            Message([close_account_instruction], fee_payer.pubkey()),
            latest_blockhash.value.blockhash,
        )
        result = await rpc.send_transaction(transaction)

        closed_token_account = (await rpc.get_account_info(token_account_address)).value

        print("Mint Address:", mint.pubkey())
        print("\nToken Account Address:", token_account_address)
        print("Token Account:")
        print(json.dumps(closed_token_account, indent=2))
        print("\nTransaction Signature:", result.value)

if __name__ == "__main__":
    asyncio.run(main())

Console

Click to execute the code.

Table of Contents