Odmrożenie konta

Co robi odblokowanie konta tokenów?

Odblokowanie zmienia stan konta tokenów ze stanu zamrożonego z powrotem do stanu zainicjowanego.

Po pomyślnym odblokowaniu konto może ponownie transferować, spalać i zamykać tokeny. Tylko uprawniony do zamrażania (freeze authority) może odblokowywać konta tokenów.

Jak odblokować konto tokenów

Odblokowanie konta tokenów wykorzystuje instrukcję ThawAccount Token Program.

Instrukcja ThawAccount weryfikuje, że konto tokenów należy do mintu oraz że podpisujący jest uprawniony do zamrażania (freeze authority) mintu, a następnie zmienia stan konta tokenów z zamrożonego z powrotem na zainicjowany.

Natywne konta tokenów nie obsługują odblokowywania.

Odnośnik do źródła

Element	Opis	Token Program	Token Extensions Program
`Mint`	Stan mintu przechowuje opcjonalny freeze authority używany do odblokowywania kont tokenów.	Źródło	Źródło
`AccountState`	Stany konta tokenów, w tym `Frozen` i `Initialized`.	Źródło	Źródło
`ThawAccount`	Instrukcja, która zmienia zamrożone konto tokenów z powrotem do stanu zainicjowanego.	Źródło	Źródło
`process_toggle_freeze_account`	Wspólna logika procesora do zamrażania i odblokowywania kont tokenów.	Źródło	Źródło

Typescript

Poniższe przykłady Kit pokazują zalecane podejście wykorzystujące @solana/kit. Przykłady legacy wykorzystujące @solana/web3.js zostały dołączone jako odniesienie.

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.

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.

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

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.

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

#!/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.

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.

Spis treści