وثائق سولاناالرموز على سولاناالأساسيات

إغلاق حساب الرمز المميز

ماذا يفعل إغلاق حساب الرمز المميز؟

يؤدي إغلاق token account إلى حذف الحساب وإرجاع lamports الخاصة بـ rent إلى حساب الوجهة.

يجب أن يكون رصيد الرموز المميزة صفراً قبل إمكانية إغلاق الحساب. يمكن إغلاق الحساب المجمد إذا كان رصيد الرموز المميزة للحساب المجمد صفراً. حسابات الرموز المميزة لـ SOL الملتفة هي الاستثناء ويمكن إغلاقها مع رصيد رمزي لاستعادة SOL الأساسي. يقوم مالك الحساب أو سلطة الإغلاق الخاصة بالحساب بالتوقيع على تعليمة الإغلاق.

كيفية إغلاق حساب رمز مميز

يستخدم إغلاق token account تعليمة CloseAccount من Token Program.

تقوم تعليمة CloseAccount بنقل lamports الحساب المصدر إلى حساب الوجهة، ومسح الحساب المصدر، وحذف الحساب المصدر. يطبق Token Extensions Program فحوصات إغلاق إضافية لبعض Token Extensions، لكن تدفق الإغلاق الأساسي هو نفسه.

مرجع المصدر

العنصرالوصفToken ProgramToken Extensions Program
Accountتخزن حالة token account الرصيد والحالة الأصلية وسلطة الإغلاق المستخدمة أثناء إغلاق الحساب.المصدرالمصدر
CloseAccountتعليمة تغلق token account وتنقل lamports الحساب إلى حساب الوجهة.المصدرالمصدر
process_close_accountمنطق المعالج المشترك لإغلاق token account.المصدرالمصدر

تايب سكريبت

توضح الأمثلة أدناه في 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.

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.

Rust

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

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.

Is this page helpful?

السابق

مزامنة SOL الأصلي

التالي

تجميد الحساب

جدول المحتويات

تعديل الصفحة

تدار بواسطة

© 2026 مؤسسة سولانا.
جميع الحقوق محفوظة.
سولانا
تواصل معنا