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

إلغاء تجميد الحساب

ماذا يفعل إلغاء تجميد حساب رمزي؟

يُغيّر إلغاء التجميد حالة حساب رمزي من الحالة المجمّدة إلى الحالة المُهيأة.

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

كيفية إلغاء تجميد حساب رمزي

يستخدم إلغاء تجميد حساب رمزي تعليمة ThawAccount من Token Program.

تتحقق تعليمة ThawAccount من أن الحساب الرمزي ينتمي إلى النعناع وأن الموقّع هو صلاحية التجميد الخاصة بالنعناع، ثم تُغيّر حالة الحساب الرمزي من مجمّد إلى مُهيأ.

الحسابات الرمزية الأصلية لا تدعم إلغاء التجميد.

مرجع المصدر

العنصرالوصفToken ProgramToken Extension Program
Mintتُخزّن حالة النعناع صلاحية التجميد الاختيارية المُستخدمة لإلغاء تجميد الحسابات الرمزية.المصدرالمصدر
AccountStateحالات الحساب الرمزي، بما في ذلك Frozen و Initialized.المصدرالمصدر
ThawAccountتعليمة تُغيّر حساباً رمزياً مجمّداً إلى الحالة المُهيأة.المصدرالمصدر
process_toggle_freeze_accountمنطق المعالج المشترك لتجميد وإلغاء تجميد الحسابات الرمزية.المصدرالمصدر

Typescript

توضح الأمثلة أدناه Kit النهج الموصى به باستخدام @solana/kit. تم تضمين الأمثلة القديمة باستخدام @solana/web3.js كمرجع.

Kit

import { generateKeyPairSigner } from "@solana/kit";

import { createLocalClient } from "@solana/kit-client-rpc";

import {

  findAssociatedTokenPda,

  tokenProgram,

  TOKEN_PROGRAM_ADDRESS

} from "@solana-program/token";



const client = await createLocalClient()

  .use(tokenProgram());



const mint = await generateKeyPairSigner();



const [tokenAccount] = await findAssociatedTokenPda({

  mint: mint.address,

  owner: client.payer.address,

  tokenProgram: TOKEN_PROGRAM_ADDRESS

});





const result = await client.token.instructions

  .thawAccount({

    account: tokenAccount, // Token account to thaw.

    mint: mint.address, // Mint for the token account being thawed.

    owner: client.payer // Freeze authority approving this change.

  })

  .sendTransaction();



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



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

console.log("\nToken Account Address:", tokenAccount);

console.log("Token Account:", tokenAccountData.data);

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,

  freezeAccount,

  createMint,

  getAccount,

  mintToChecked,

  thawAccount,

  TOKEN_PROGRAM_ID

} from "@solana/spl-token";





const result = await thawAccount(

  connection, // Connection to the local validator.

  feePayer, // Account paying transaction fees.

  associatedTokenAccount, // Token account to thaw.

  mintPubkey, // Mint for the token account being thawed.

  feePayer, // Freeze authority approving this change.

  [], // Additional multisig signers.

  {

    commitment: "confirmed" // Confirmation options for the transaction.

  },

  TOKEN_PROGRAM_ID // Token program to invoke.

);



const tokenAccountData = await getAccount(

  connection,

  associatedTokenAccount,

  "confirmed",

  TOKEN_PROGRAM_ID

);



console.log("Mint Address:", mintPubkey.toBase58());

console.log(

  "\nAssociated Token Account Address:",

  associatedTokenAccount.toBase58()

);

console.log("Associated Token Account:", tokenAccountData);

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::{freeze_account, initialize_mint, mint_to_checked, thaw_account},

    state::{Account, Mint},

};



#[tokio::main]

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

    let client = RpcClient::new_with_commitment(

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

        CommitmentConfig::confirmed(),

    );





    let transaction = Transaction::new_signed_with_payer(

        &[

            thaw_account(

                &token_program_id(), // Token program to invoke.

                &associated_token_address, // Token account to thaw.

                &mint.pubkey(), // Mint for the token account being thawed.

                &fee_payer.pubkey(), // Freeze authority approving this change.

                &[], // Additional multisig signers.

            )?,

        ],

        Some(&fee_payer.pubkey()),

        &[&fee_payer],

        latest_blockhash,

    );



    let transaction_signature = client.send_and_confirm_transaction(&transaction).await?;

    let token_account = client.get_account(&associated_token_address).await?;

    let token_data = Account::unpack(&token_account.data)?;



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

    println!("\nToken Account Address: {}", associated_token_address);

    println!("Token Account: {:#?}", token_data);

    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.pubkey import Pubkey

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 (

    create_associated_token_account,

    freeze_account,

    FreezeAccountParams,

    get_associated_token_address,

    initialize_mint,

    InitializeMintParams,

    mint_to_checked,

    MintToCheckedParams,

    thaw_account,

    ThawAccountParams,

)

from spl.token.constants import MINT_LEN, TOKEN_PROGRAM_ID



DECIMALS = 2

AMOUNT_TO_MINT = 100



async def main():

    rpc = AsyncClient("http://localhost:8899")



    async with rpc:



        thaw_account_instruction = thaw_account(

            ThawAccountParams(

                program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.

                account=token_account_address,  # Token account to thaw.

                mint=mint.pubkey(),  # Mint for the token account being thawed.

                authority=fee_payer.pubkey(),  # Freeze authority approving the thaw.

            )

        )

        latest_blockhash = await rpc.get_latest_blockhash()

        transaction = Transaction(

            [fee_payer],

            Message([thaw_account_instruction], fee_payer.pubkey()),

            latest_blockhash.value.blockhash,

        )

        result = await rpc.send_transaction(transaction)



        token_account_info = await token.get_account_info(token_account_address)

        token_account = {

            key: str(value) if isinstance(value, Pubkey) else value

            for key, value in token_account_info._asdict().items()

        }



        print("Mint Address:", mint.pubkey())

        print("\nToken Account Address:", token_account_address)

        print("Token Account:")

        print(json.dumps(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?

السابق

تجميد الحساب

التالي

الإضافات

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

تعديل الصفحة

تدار بواسطة

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