وثائق سولاناالرموز على سولاناالإضافات

إغلاق العملة

كيفية تمكين امتداد MintCloseAuthority

يتيح امتداد MintCloseAuthority إغلاق حسابات mint واسترداد الـ rent الخاص بها. يجب تهيئة هذا الامتداد عند إنشاء الـ mint.

فقط السلطة المخولة بالإغلاق يمكنها إغلاق حساب mint. وبشكل مشابه لكيفية إغلاق حسابات الرموز فقط عندما يكون رصيد الرمز صفرًا، يمكن إغلاق حسابات mint التي تحتوي على هذا الامتداد فقط عندما يتم تخفيض إجمالي عرض الرموز إلى صفر.

تايبسكريبت

import {

  airdropFactory,

  appendTransactionMessageInstructions,

  createSolanaRpc,

  createSolanaRpcSubscriptions,

  createTransactionMessage,

  generateKeyPairSigner,

  getSignatureFromTransaction,

  lamports,

  pipe,

  sendAndConfirmTransactionFactory,

  setTransactionMessageFeePayerSigner,

  setTransactionMessageLifetimeUsingBlockhash,

  signTransactionMessageWithSigners

} from "@solana/kit";

import { getCreateAccountInstruction } from "@solana-program/system";

import {

  getInitializeMintInstruction,

  getMintSize,

  TOKEN_2022_PROGRAM_ADDRESS,

  extension,

  getInitializeMintCloseAuthorityInstruction,

  getCloseAccountInstruction

} from "@solana-program/token-2022";



// Create Connection, local validator in this example

const rpc = createSolanaRpc("http://localhost:8899");

const rpcSubscriptions = createSolanaRpcSubscriptions("ws://localhost:8900");



// Generate the authority for the mint, (will also act as the fee payer)

// and destination to receive recovered SOL after closing the mint

const authority = await generateKeyPairSigner();

const destination = await generateKeyPairSigner();



// Fund authority/fee payer

await airdropFactory({ rpc, rpcSubscriptions })({

  recipientAddress: authority.address,

  lamports: lamports(5_000_000_000n), // 5 SOL

  commitment: "confirmed"

});



// Generate keypair to use as address of mint

const mint = await generateKeyPairSigner();



// And a mint close authority extension.

const mintCloseAuthorityExtension = extension("MintCloseAuthority", {

  closeAuthority: authority.address

});



// Get default mint account size (in bytes), with the close mint extension

const space = BigInt(getMintSize([mintCloseAuthorityExtension]));



// Get minimum balance for rent exemption

const rent = await rpc.getMinimumBalanceForRentExemption(space).send();



// Get latest blockhash to include in transaction

const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();



// Instruction to create new account for mint (token program)

// Invokes the system program

const createAccountInstruction = getCreateAccountInstruction({

  payer: authority,

  newAccount: mint,

  lamports: rent,

  space,

  programAddress: TOKEN_2022_PROGRAM_ADDRESS

});



// Instruction to initialize the close mint authority extension

const initializeCloseMintInstruction =

  getInitializeMintCloseAuthorityInstruction({

    mint: mint.address,

    closeAuthority: mintCloseAuthorityExtension.closeAuthority

  });



// Instruction to initialize mint account data

// Invokes the token program

const initializeMintInstruction = getInitializeMintInstruction({

  mint: mint.address,

  decimals: 9,

  mintAuthority: authority.address

});



const instructions = [

  createAccountInstruction,

  initializeCloseMintInstruction,

  initializeMintInstruction

];



// Create transaction message

const transactionMessage = pipe(

  createTransactionMessage({ version: 0 }),

  (tx) => setTransactionMessageFeePayerSigner(authority, tx),

  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),

  (tx) => appendTransactionMessageInstructions(instructions, tx)

);



// Sign transaction message with all required signers

const signedTransaction =

  await signTransactionMessageWithSigners(transactionMessage);



// Send and confirm transaction

await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(

  signedTransaction,

  { commitment: "confirmed", skipPreflight: true }

);



// // Get transaction signature

const transactionSignature = getSignatureFromTransaction(signedTransaction);



console.log("Mint Address:", mint.address.toString());

console.log("Transaction Signature:", transactionSignature);



// Get a fresh blockhash for the close mint extension instruction

const { value: latestBlockhash2 } = await rpc.getLatestBlockhash().send();



const closeMintInstruction = getCloseAccountInstruction({

  account: mint.address,

  destination: destination.address,

  owner: authority

});



// Create transaction message for close mint extension

const closeMintMessage = pipe(

  createTransactionMessage({ version: 0 }),

  (tx) => setTransactionMessageFeePayerSigner(authority, tx),

  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash2, tx),

  (tx) => appendTransactionMessageInstructions([closeMintInstruction], tx)

);



// Sign transaction message with all required signers

const signedCloseMintTx =

  await signTransactionMessageWithSigners(closeMintMessage);



// Send and confirm transaction

await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(

  signedCloseMintTx,

  { commitment: "confirmed" }

);



// Get transaction signature

const closeMintTxSig = getSignatureFromTransaction(signedCloseMintTx);



console.log("\nDestination Address:", destination.address.toString());

console.log("Transaction Signature:", closeMintTxSig);
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::{

    signature::{Keypair, Signer},

    transaction::Transaction,

};

use solana_system_interface::instruction::create_account;

use spl_token_2022_interface::{

    extension::{

        mint_close_authority::MintCloseAuthority, BaseStateWithExtensions, ExtensionType,

        StateWithExtensions,

    },

    instruction::{close_account, initialize_mint, initialize_mint_close_authority},

    state::Mint,

    ID as TOKEN_2022_PROGRAM_ID,

};



#[tokio::main]

async fn main() -> Result<()> {

    // Create connection to local validator

    let client = RpcClient::new_with_commitment(

        String::from("http://localhost:8899"),

        CommitmentConfig::confirmed(),

    );

    let latest_blockhash = client.get_latest_blockhash().await?;



    // Generate a new keypair for the fee payer

    let fee_payer = Keypair::new();



    // Generate a keypair for the destination

    let destination = Keypair::new();



    // Airdrop 5 SOL to fee payer

    let airdrop_signature = client

        .request_airdrop(&fee_payer.pubkey(), 5_000_000_000)

        .await?;



    loop {

        let confirmed = client.confirm_transaction(&airdrop_signature).await?;

        if confirmed {

            break;

        }

    }



    // Generate keypair to use as address of mint

    let mint = Keypair::new();



    // Get default mint account size (in bytes),

    let mint_space =

        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::MintCloseAuthority])?;



    // get the rent in lamports for the mint account

    let mint_rent = client

        .get_minimum_balance_for_rent_exemption(mint_space)

        .await?;



    // Instruction to create new account for mint

    let create_account_instruction = create_account(

        &fee_payer.pubkey(),    // payer

        &mint.pubkey(),         // new account (mint)

        mint_rent,              // lamports

        mint_space as u64,      // space

        &TOKEN_2022_PROGRAM_ID, // program id

    );



    let initialize_close_mint_instruction = initialize_mint_close_authority(

        &TOKEN_2022_PROGRAM_ID,    // token program

        &mint.pubkey(),            // mint

        Some(&fee_payer.pubkey()), // close authority

    )?;



    // Instruction to initialize mint account data

    let initialize_mint_instruction = initialize_mint(

        &TOKEN_2022_PROGRAM_ID,    // token program

        &mint.pubkey(),            // mint

        &fee_payer.pubkey(),       // mint authority

        Some(&fee_payer.pubkey()), // freeze authority

        9,                         // decimals

    )?;



    // Create transaction and add instructions

    let transaction = Transaction::new_signed_with_payer(

        &[

            create_account_instruction,

            initialize_close_mint_instruction,

            initialize_mint_instruction,

        ],

        Some(&fee_payer.pubkey()),

        &[&fee_payer, &mint],

        latest_blockhash,

    );



    // Send and confirm transaction

    client.send_and_confirm_transaction(&transaction).await?;



    println!("Mint Address: {}", mint.pubkey());



    // Fetch mint account

    let mint_account = client.get_account(&mint.pubkey()).await?;

    // Deserialize the mint account with extensions

    let mint_state = StateWithExtensions::<Mint>::unpack(&mint_account.data)?;



    // Get all extension types enabled on this mint

    let mint_extension_types = mint_state.get_extension_types()?;

    println!("\nMint extensions enabled: {:?}", mint_extension_types);



    // Deserialize the MintCloseAuthority extension data

    let mint_close_authority = mint_state.get_extension::<MintCloseAuthority>()?;

    println!("\n{:#?}", mint_close_authority);



    let close_mint_instruction = close_account(

        &TOKEN_2022_PROGRAM_ID, // token program

        &mint.pubkey(),         // mint

        &destination.pubkey(),  // destination

        &fee_payer.pubkey(),    // authority

        &[&fee_payer.pubkey()], // signer keys

    )?;



    // Create transaction for closing the mint account

    let transaction = Transaction::new_signed_with_payer(

        &[close_mint_instruction],

        Some(&fee_payer.pubkey()),

        &[&fee_payer],

        latest_blockhash,

    );



    // Send and confirm transaction

    client.send_and_confirm_transaction(&transaction).await?;



    // Try to fetch the mint account (should fail)

    match client.get_account(&mint.pubkey()).await {

        Ok(_) => println!("\nMint account still exists (unexpected)"),

        Err(e) => println!("\nMint account successfully closed: {:#?}", e),

    }



    Ok(())

}
Console
Click to execute the code.

Is this page helpful?

السابق

المفوض الدائم

التالي

مجموعات الرموز والأعضاء

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

تعديل الصفحة

تدار بواسطة

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