Tài liệu SolanaToken trên SolanaCơ bản

Thu hồi Ủy quyền

Thu hồi quyền ủy quyền làm gì?

Thu hồi quyền ủy quyền sẽ xóa người được ủy quyền hiện tại của token account và đặt lại số lượng được ủy quyền về không.

Sau khi thu hồi, người được ủy quyền trước đó sẽ không còn quyền chuyển hoặc đốt token thay mặt cho token account.

Cách thu hồi quyền ủy quyền

Thu hồi quyền ủy quyền sử dụng lệnh Revoke của Token Program.

Lệnh Revoke xóa các trường người được ủy quyền trên token account nguồn. Trong Token Program, chủ sở hữu token account ký xác nhận việc thu hồi. Trong Token Extensions Program, người được ủy quyền hiện tại cũng có thể thu hồi quyền ủy quyền.

Tài liệu tham khảo nguồn

MụcMô tảToken ProgramToken Extensions Program
AccountTrạng thái token account lưu trữ người được ủy quyền và số lượng được ủy quyền.NguồnNguồn
RevokeLệnh xóa người được ủy quyền hiện tại khỏi token account.NguồnNguồn
process_revokeLogic xử lý chung cho việc thu hồi quyền ủy quyền.NguồnNguồn

Typescript

Các ví dụ Kit bên dưới cho thấy cách tiếp cận được khuyến nghị khi sử dụng @solana/kit. Các ví dụ cũ sử dụng @solana/web3.js được đưa vào để tham khảo.

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 delegate = await generateKeyPairSigner();



const [tokenAccount] = await findAssociatedTokenPda({

  mint: mint.address,

  owner: client.payer.address,

  tokenProgram: TOKEN_PROGRAM_ADDRESS

});





const result = await client.token.instructions

  .revoke({

    source: tokenAccount, // Token account whose delegate approval changes.

    owner: client.payer // Owner approving this delegate 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("\nDelegate Address:", delegate.address);

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,

  approveChecked,

  createMint,

  getAccount,

  mintToChecked,

  revoke,

  TOKEN_PROGRAM_ID

} from "@solana/spl-token";





const result = await revoke(

  connection, // Connection to the local validator.

  feePayer, // Account paying transaction fees.

  associatedTokenAccount, // Token account whose delegate approval changes.

  feePayer, // Owner approving this delegate 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("\nDelegate Address:", delegate.publicKey.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::{approve_checked, initialize_mint, mint_to_checked, revoke},

    state::{Account, Mint},

};



#[tokio::main]

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

    let client = RpcClient::new_with_commitment(

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

        CommitmentConfig::confirmed(),

    );

    let delegate = Keypair::new();





    let transaction = Transaction::new_signed_with_payer(

        &[

            revoke(

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

                &associated_token_address, // Token account whose delegate approval changes.

                &fee_payer.pubkey(), // Owner approving this delegate 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!(

        "\nAssociated Token Account Address: {}",

        associated_token_address

    );

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

    println!("\nDelegate Address: {}", delegate.pubkey());

    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 (

    approve_checked,

    ApproveCheckedParams,

    create_associated_token_account,

    get_associated_token_address,

    initialize_mint,

    InitializeMintParams,

    mint_to_checked,

    MintToCheckedParams,

    revoke,

    RevokeParams,

)

from spl.token.constants import MINT_LEN, TOKEN_PROGRAM_ID



DECIMALS = 2

AMOUNT_TO_MINT = 100

AMOUNT_TO_APPROVE = 25



async def main():

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



    delegate = Keypair()



    async with rpc:



        revoke_delegate_instruction = revoke(

            RevokeParams(

                program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.

                account=token_account_address,  # Token account whose delegate approval changes.

                owner=fee_payer.pubkey(),  # Account that owns the token account.

            )

        )

        latest_blockhash = await rpc.get_latest_blockhash()

        transaction = Transaction(

            [fee_payer],

            Message([revoke_delegate_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("\nDelegate Address:", delegate.pubkey())

        print("\nTransaction Signature:", result.value)



if __name__ == "__main__":

    asyncio.run(main())
Console
Click to execute the code.

Is this page helpful?

Trước

Phê Duyệt Người Được Ủy Quyền

Tiếp theo

Thiết lập quyền hạn

Mục lục

Chỉnh sửa trang

Quản lý bởi

© 2026 Solana Foundation.
Đã đăng ký bản quyền.
Solana
Kết nối
Thu hồi Ủy quyền | Solana