Documentación de SolanaTokens en SolanaConceptos básicos

Revocar delegado

¿Qué Hace la Revocación de un Delegado?

La revocación de un delegado elimina el delegado actual de la cuenta de tokens y restablece la cantidad delegada a cero.

Después de la revocación, el delegado anterior ya no tiene autoridad para transferir o quemar tokens en nombre de la cuenta de tokens.

Cómo Revocar un Delegado

La revocación de un delegado utiliza la instrucción Revoke del Token Program.

La instrucción Revoke borra los campos del delegado en la cuenta de tokens de origen. En el Token Program, el propietario de la cuenta de tokens firma la revocación. En el Token Extensions Program, el delegado actual también puede revocar la delegación.

Referencia de Código Fuente

ElementoDescripciónToken ProgramToken Extensions Program
AccountEl estado de la cuenta de tokens almacena el delegado y la cantidad delegada.FuenteFuente
RevokeUna instrucción que elimina el delegado actual de una cuenta de tokens.FuenteFuente
process_revokeLógica compartida del procesador para la revocación del delegado.FuenteFuente

Typescript

Los ejemplos de Kit a continuación muestran el enfoque recomendado usando @solana/kit. Se incluyen ejemplos heredados usando @solana/web3.js como referencia.

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?

Anterior

Aprobar Delegado

Siguiente

Establecer autoridad

Tabla de Contenidos

Editar Página

Gestionado por

© 2026 Fundación Solana.
Todos los derechos reservados.
Solana
Conéctate