Approve and Revoke Delegates

Rust client guide to approve and revoke delegates for light-token accounts. Includes step-by-step implementation and full code examples.

---

1. Approve grants a delegate permission to transfer up to a specified amount of tokens from your account.
   • Each token account can have only one delegate at a time.
   • Any new approval overwrites the previous one.
2. Revoke removes all delegate permissions from a light-token account.
3. Only the token account owner can approve or revoke delegates.

Rust Client

Approve

Revoke

1. Prerequisites

   Dependencies

   Cargo.toml

   [dependencies]
   light-compressed-token-sdk = "0.1"
   light-client = "0.1"
   light-token-types = "0.1"
   solana-sdk = "2.2"
   borsh = "0.10"
   tokio = { version = "1.36", features = ["full"] }
   
   [dev-dependencies]
   light-program-test = "0.1"  # For in-memory tests with LiteSVM
   

   Developer Environment

   In-Memory (LightProgramTest)

   Test with Lite-SVM (…)

   # Initialize project
   cargo init my-light-project
   cd my-light-project
   
   # Run tests
   cargo test
   

   use light_program_test::{LightProgramTest, ProgramTestConfig};
   use solana_sdk::signer::Signer;
   
   #[tokio::test]
   async fn test_example() {
       // In-memory test environment 
       let mut rpc = LightProgramTest::new(ProgramTestConfig::default())
           .await
           .unwrap();
   
       let payer = rpc.get_payer().insecure_clone();
       println!("Payer: {}", payer.pubkey());
   }
   

   Localnet (LightClient)

   Connects to a local test validator.

   npm

   npm install -g @lightprotocol/zk-compression-cli@alpha
   

   yarn

   yarn global add @lightprotocol/zk-compression-cli@alpha
   

   pnpm

   pnpm add -g @lightprotocol/zk-compression-cli@alpha
   

   # Initialize project
   cargo init my-light-project
   cd my-light-project
   
   # Start local test validator (in separate terminal)
   light test-validator
   

   use light_client::rpc::{LightClient, LightClientConfig, Rpc};
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       // Connects to http://localhost:8899
       let rpc = LightClient::new(LightClientConfig::local()).await?;
   
       let slot = rpc.get_slot().await?;
       println!("Current slot: {}", slot);
   
       Ok(())
   }
   

   Devnet (LightClient)

   Replace <your-api-key> with your actual API key. Get your API key here.

   use light_client::rpc::{LightClient, LightClientConfig, Rpc};
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       let rpc_url = "https://devnet.helius-rpc.com?api-key=<your_api_key>";
       let rpc = LightClient::new(
           LightClientConfig::new(rpc_url.to_string(), None, None)
       ).await?;
   
       println!("Connected to Devnet");
       Ok(())
   }
   
2. Approve or revoke delegates

   View Source Code or find full examples with tests: examples-light-token.

   Approve

   mod shared;
   
   use light_client::rpc::Rpc;
   use light_token_sdk::token::Approve;
   use shared::SetupContext;
   use solana_sdk::{signature::Keypair, signer::Signer};
   
   #[tokio::test(flavor = "multi_thread")]
   async fn approve_delegate() {
       // Setup creates mint and ATA with tokens
       let SetupContext {
           mut rpc,
           payer,
           ata,
           ..
       } = shared::setup().await;
   
       let delegate = Keypair::new();
       let delegate_amount = 500_000u64;
   
       let approve_ix = Approve {
           token_account: ata,
           delegate: delegate.pubkey(),
           owner: payer.pubkey(),
           amount: delegate_amount,
       }
       .instruction()
       .unwrap();
   
       rpc.create_and_send_transaction(&[approve_ix], &payer.pubkey(), &[&payer])
           .await
           .unwrap();
   }
   

   Revoke

   mod shared;
   
   use light_client::rpc::Rpc;
   use light_token_sdk::token::Revoke;
   use shared::SetupContext;
   use solana_sdk::signer::Signer;
   
   #[tokio::test(flavor = "multi_thread")]
   async fn revoke_delegation() {
       // Setup creates mint, ATA with tokens, and approves delegate
       let SetupContext {
           mut rpc,
           payer,
           ata,
           ..
       } = shared::setup().await;
   
       let revoke_ix = Revoke {
           token_account: ata,
           owner: payer.pubkey(),
       }
       .instruction()
       .unwrap();
   
       rpc.create_and_send_transaction(&[revoke_ix], &payer.pubkey(), &[&payer])
           .await
           .unwrap();
   }
   

Program Guide

1. Approve

   invoke (External Signer)

   use light_token_sdk::token::ApproveCpi;
   
   ApproveCpi {
       token_account: token_account.clone(),
       delegate: delegate.clone(),
       owner: owner.clone(),
       system_program: system_program.clone(),
       amount,
   }
   .invoke()
   

   invoke_signed (PDA Owner)

   use light_token_sdk::token::ApproveCpi;
   
   let signer_seeds = authority_seeds!(bump);
   
   ApproveCpi {
       token_account: token_account.clone(),
       delegate: delegate.clone(),
       owner: owner.clone(),
       system_program: system_program.clone(),
       amount,
   }
   .invoke_signed(&[signer_seeds])
   
2. Revoke

   invoke (External Signer)

   use light_token_sdk::token::RevokeCpi;
   
   RevokeCpi {
       token_account: token_account.clone(),
       owner: owner.clone(),
       system_program: system_program.clone(),
   }
   .invoke()
   

   invoke_signed (PDA Owner)

   use light_token_sdk::token::RevokeCpi;
   
   let signer_seeds = authority_seeds!(bump);
   
   RevokeCpi {
       token_account: token_account.clone(),
       owner: owner.clone(),
       system_program: system_program.clone(),
   }
   .invoke_signed(&[signer_seeds])
   

Full Code Example

View Source Code or full examples with tests: examples-light-token.

Anchor

Native

use super::authority_seeds;
use light_token_sdk::token::ApproveCpi;
use solana_program::{
    account_info::AccountInfo, entrypoint::ProgramResult,
    program_error::ProgramError,
};

pub fn approve_invoke(accounts: &[AccountInfo], data: &[u8]) -> ProgramResult {
    let [token_account, delegate, owner, system_program, _token_program] =
        accounts
    else {
        return Err(ProgramError::NotEnoughAccountKeys);
    };

    let amount = u64::from_le_bytes(
        data.try_into()
            .map_err(|_| ProgramError::InvalidInstructionData)?,
    );

    ApproveCpi {
        token_account: token_account.clone(),
        delegate: delegate.clone(),
        owner: owner.clone(),
        system_program: system_program.clone(),
        amount,
    }
    .invoke()
}

pub fn approve_invoke_signed(accounts: &[AccountInfo], data: &[u8]) -> ProgramResult {
    let [token_account, delegate, owner, system_program, _token_program] =
        accounts
    else {
        return Err(ProgramError::NotEnoughAccountKeys);
    };

    if data.len() < 9 {
        return Err(ProgramError::InvalidInstructionData);
    }

    let amount = u64::from_le_bytes(data[0..8].try_into().unwrap());
    let bump = data[8];
    let signer_seeds = authority_seeds!(bump);

    ApproveCpi {
        token_account: token_account.clone(),
        delegate: delegate.clone(),
        owner: owner.clone(),
        system_program: system_program.clone(),
        amount,
    }
    .invoke_signed(&[signer_seeds])
}

// ---

use super::authority_seeds;
use light_token_sdk::token::RevokeCpi;
use solana_program::{
    account_info::AccountInfo, entrypoint::ProgramResult,
    program_error::ProgramError,
};

pub fn revoke_invoke(accounts: &[AccountInfo], _data: &[u8]) -> ProgramResult {
    let [token_account, owner, system_program, _token_program] = accounts
    else {
        return Err(ProgramError::NotEnoughAccountKeys);
    };

    RevokeCpi {
        token_account: token_account.clone(),
        owner: owner.clone(),
        system_program: system_program.clone(),
    }
    .invoke()
}

pub fn revoke_invoke_signed(accounts: &[AccountInfo], data: &[u8]) -> ProgramResult {
    let [token_account, owner, system_program, _token_program] = accounts
    else {
        return Err(ProgramError::NotEnoughAccountKeys);
    };

    if data.is_empty() {
        return Err(ProgramError::InvalidInstructionData);
    }

    let bump = data[0];
    let signer_seeds = authority_seeds!(bump);

    RevokeCpi {
        token_account: token_account.clone(),
        owner: owner.clone(),
        system_program: system_program.clone(),
    }
    .invoke_signed(&[signer_seeds])
}

Next Steps

Use the Unified Transfer Interface for Light-Token, SPL and Token 22 Transfers