> ## Documentation Index
> Fetch the complete documentation index at: https://www.zkcompression.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Approve and Revoke Delegates
> Guide to approve and revoke delegates for Light Token accounts. Includes step-by-step implementation and full code examples.
export const lightRevokeRustCode = ["use light_token::instruction::Revoke;", "", "let ix = Revoke {", " token_account: ata,", " owner: payer.pubkey(),", "}", ".instruction()?;"].join("\n");
export const splRevokeRustCode = ["use spl_token::instruction::revoke;", "", "let ix = revoke(", " &spl_token::id(),", " &source,", " &owner,", " &[],", ")?;"].join("\n");
export const lightApproveRustCode = ["use light_token::instruction::Approve;", "", "let ix = Approve {", " token_account: ata,", " delegate: delegate.pubkey(),", " owner: payer.pubkey(),", " amount,", "}", ".instruction()?;"].join("\n");
export const splApproveRustCode = ["use spl_token::instruction::approve;", "", "let ix = approve(", " &spl_token::id(),", " &source,", " &delegate,", " &owner,", " &[],", " amount,", ")?;"].join("\n");
export const lightRevokeCode = ['import { revokeInterface } from "@lightprotocol/compressed-token";', "", "const tx = await revokeInterface(", " rpc,", " payer,", " tokenAccount,", " mint,", " owner", ");"].join("\n");
export const splRevokeCode = ['import { revoke } from "@solana/spl-token";', "", "const tx = await revoke(", " connection,", " payer,", " source,", " owner", ");"].join("\n");
export const lightApproveCode = ['import { approveInterface } from "@lightprotocol/compressed-token";', "", "const tx = await approveInterface(", " rpc,", " payer,", " tokenAccount,", " mint,", " delegate,", " amount,", " owner", ");"].join("\n");
export const splApproveCode = ['import { approve } from "@solana/spl-token";', "", "const tx = await approve(", " connection,", " payer,", " source,", " delegate,", " owner,", " amount", ");"].join("\n");
export const CodeCompare = ({firstCode = "", secondCode = "", firstLabel = "Light Token", secondLabel = "SPL", language = "javascript"}) => {
const [sliderPercent, setSliderPercent] = useState(100);
const [isDragging, setIsDragging] = useState(false);
const [isAnimating, setIsAnimating] = useState(false);
const [copied, setCopied] = useState(false);
const containerRef = useRef(null);
const animationRef = useRef(null);
const firstPreRef = useRef(null);
const secondPreRef = useRef(null);
const [containerHeight, setContainerHeight] = useState(null);
const showingFirst = sliderPercent > 50;
const handleCopy = async () => {
const codeToCopy = showingFirst ? firstCode : secondCode;
await navigator.clipboard.writeText(codeToCopy);
setCopied(true);
setTimeout(() => setCopied(false), 2000);
};
const highlightCode = code => {
let escaped = code.replace(/&/g, "&").replace(//g, ">");
if (language === "rust") {
const rustPattern = /(\/\/.*$)|(["'])(?:(?!\2)[^\\]|\\.)*?\2|\b(use|let|mut|pub|fn|struct|impl|enum|mod|const|static|trait|type|where|for|in|if|else|match|loop|while|return|self|Self|true|false|Some|None|Ok|Err|Result|Option|vec!)\b|::([a-zA-Z_][a-zA-Z0-9_]*)|&([a-zA-Z_][a-zA-Z0-9_]*)|\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()|(\?)/gm;
return escaped.replace(rustPattern, (match, comment, stringQuote, keyword, pathSegment, reference, func, questionMark) => {
if (comment) return `${match}`;
if (stringQuote) return `${match}`;
if (keyword) return `${match}`;
if (pathSegment) return `::${pathSegment}`;
if (reference) return `&${reference}`;
if (func) return `${match}`;
if (questionMark) return `?`;
return match;
});
}
const pattern = /(\/\/.*$)|(["'`])(?:(?!\2)[^\\]|\\.)*?\2|\b(const|let|var|await|async|import|from|export|return|if|else|function|class|new|throw|try|catch)\b|\.([a-zA-Z_][a-zA-Z0-9_]*)\b|\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/gm;
return escaped.replace(pattern, (match, comment, stringQuote, keyword, property, func) => {
if (comment) return `${match}`;
if (stringQuote) return `${match}`;
if (keyword) return `${match}`;
if (property) return `.${property}`;
if (func) return `${match}`;
return match;
});
};
const animateTo = target => {
if (animationRef.current) cancelAnimationFrame(animationRef.current);
setIsAnimating(true);
const start = sliderPercent;
const startTime = performance.now();
const duration = 400;
const animate = currentTime => {
const elapsed = currentTime - startTime;
const progress = Math.min(elapsed / duration, 1);
const eased = 1 - Math.pow(1 - progress, 3);
const current = start + (target - start) * eased;
setSliderPercent(current);
if (progress < 1) {
animationRef.current = requestAnimationFrame(animate);
} else {
setSliderPercent(target);
setIsAnimating(false);
animationRef.current = null;
}
};
animationRef.current = requestAnimationFrame(animate);
};
const handleToggle = () => {
animateTo(showingFirst ? 0 : 100);
};
const handleMouseDown = e => {
if (isAnimating) {
cancelAnimationFrame(animationRef.current);
setIsAnimating(false);
}
e.preventDefault();
setIsDragging(true);
};
const handleMouseUp = () => {
setIsDragging(false);
};
const handleMouseMove = e => {
if (!isDragging || !containerRef.current) return;
const rect = containerRef.current.getBoundingClientRect();
const x = e.clientX - rect.left;
const percent = Math.max(0, Math.min(100, x / rect.width * 100));
setSliderPercent(percent);
};
const handleTouchMove = e => {
if (!containerRef.current) return;
if (isAnimating) {
cancelAnimationFrame(animationRef.current);
setIsAnimating(false);
}
const rect = containerRef.current.getBoundingClientRect();
const x = e.touches[0].clientX - rect.left;
const percent = Math.max(0, Math.min(100, x / rect.width * 100));
setSliderPercent(percent);
};
const handleKeyDown = e => {
if (e.key === "ArrowLeft") {
setSliderPercent(p => Math.max(0, p - 5));
} else if (e.key === "ArrowRight") {
setSliderPercent(p => Math.min(100, p + 5));
}
};
useEffect(() => {
if (isDragging) {
document.addEventListener("mousemove", handleMouseMove);
document.addEventListener("mouseup", handleMouseUp);
return () => {
document.removeEventListener("mousemove", handleMouseMove);
document.removeEventListener("mouseup", handleMouseUp);
};
}
}, [isDragging]);
useEffect(() => {
return () => {
if (animationRef.current) cancelAnimationFrame(animationRef.current);
};
}, []);
useEffect(() => {
const activeRef = showingFirst ? firstPreRef : secondPreRef;
if (activeRef.current) {
setContainerHeight(activeRef.current.scrollHeight);
}
}, [showingFirst]);
return <>
{}
{showingFirst ? firstLabel : secondLabel}
{}
") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work`}
```text theme={null}
---
description: Approve and revoke token delegates
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---
## Approve and revoke token delegates
Context:
- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js
SPL equivalent: approve() / revoke() → Light Token: approve() / revoke()
### 1. Index project
- Grep `@solana/spl-token|Connection|Keypair|approve|revoke|delegate` across src/
- Glob `**/*.ts` for project structure
- Identify: RPC setup, existing delegation logic, entry point for delegation
- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel
### 2. Read references
- WebFetch the guide above — follow the TypeScript Client tab
- WebFetch skill.md — check for a dedicated skill and resources matching this task
- TaskCreate one todo per phase below to track progress
### 3. Clarify intention
- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing)
- AskUserQuestion: does the project already have delegate operations to extend, or is this greenfield?
- Summarize findings and wait for user confirmation before implementing
### 4. Create plan
- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes
- Verify existing connection/signer setup is compatible with the cookbook prerequisites
- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion)
- Present the plan to the user for approval before proceeding
### 5. Implement
- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js`
- Follow the cookbook guide and the approved plan
- Write/Edit to create or modify files
- TaskUpdate to mark each step done
### 6. Verify
- Bash `tsc --noEmit`
- Bash run existing test suite if present
- TaskUpdate to mark complete
### Tools
- mcp__zkcompression__SearchLightProtocol("") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work
```
### Prerequisites
```toml Cargo.toml theme={null}
[dependencies]
light-token = "0.23.0"
light-client = { version = "0.23.0", features = ["v2"] }
solana-sdk = "2"
borsh = "0.10.4"
tokio = { version = "1", features = ["full"] }
```
Test with Lite-SVM (...)
```bash theme={null}
# Initialize project
cargo init my-light-project
cd my-light-project
# Run tests
cargo test
```
```rust theme={null}
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());
}
```
Connects to a local test validator.
```bash theme={null}
npm install -g @lightprotocol/zk-compression-cli
```
```bash theme={null}
yarn global add @lightprotocol/zk-compression-cli
```
```bash theme={null}
pnpm add -g @lightprotocol/zk-compression-cli
```
```bash theme={null}
# Initialize project
cargo init my-light-project
cd my-light-project
# Start local test validator (in separate terminal)
light test-validator
```
```rust theme={null}
use light_client::rpc::{LightClient, LightClientConfig, Rpc};
#[tokio::main]
async fn main() -> Result<(), Box> {
// Connects to http://localhost:8899
let rpc = LightClient::new(LightClientConfig::local()).await?;
let slot = rpc.get_slot().await?;
println!("Current slot: {}", slot);
Ok(())
}
```
Replace `` with your actual API key. [Get your API key here](https://www.helius.dev/zk-compression).
```rust theme={null}
use light_client::rpc::{LightClient, LightClientConfig, Rpc};
#[tokio::main]
async fn main() -> Result<(), Box> {
let rpc_url = "https://devnet.helius-rpc.com?api-key=";
let rpc = LightClient::new(
LightClientConfig::new(rpc_url.to_string(), None, None)
).await?;
println!("Connected to Devnet");
Ok(())
}
```
### Approve or revoke delegates
Find the source code [here](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/approve.rs).
```rust theme={null}
use borsh::BorshDeserialize;
use light_client::rpc::Rpc;
use light_token_client::actions::Approve;
use rust_client::{setup, SetupContext};
use solana_sdk::{signature::Keypair, signer::Signer};
#[tokio::main]
async fn main() -> Result<(), Box> {
// Setup creates mint and associated token account with tokens
let SetupContext {
mut rpc,
payer,
associated_token_account,
..
} = setup().await;
let delegate = Keypair::new();
let sig = Approve {
token_account: associated_token_account,
delegate: delegate.pubkey(),
amount: 500_000,
owner: Some(payer.pubkey()),
}
.execute(&mut rpc, &payer)
.await?;
let data = rpc.get_account(associated_token_account).await?.ok_or("Account not found")?;
let token = light_token_interface::state::Token::deserialize(&mut &data.data[..])?;
println!("Delegate: {:?} Tx: {sig}", token.delegate);
Ok(())
}
```
```rust theme={null}
use borsh::BorshDeserialize;
use light_client::rpc::Rpc;
use light_token::instruction::Approve;
use rust_client::{setup, SetupContext};
use solana_sdk::{signature::Keypair, signer::Signer};
#[tokio::main]
async fn main() -> Result<(), Box> {
// Setup creates mint and associated token account with tokens
let SetupContext {
mut rpc,
payer,
associated_token_account,
..
} = setup().await;
let delegate = Keypair::new();
let delegate_amount = 500_000u64;
let approve_instruction = Approve {
token_account: associated_token_account,
delegate: delegate.pubkey(),
owner: payer.pubkey(),
amount: delegate_amount,
fee_payer: payer.pubkey(),
}
.instruction()?;
let sig = rpc
.create_and_send_transaction(&[approve_instruction], &payer.pubkey(), &[&payer])
.await?;
let data = rpc.get_account(associated_token_account).await?.ok_or("Account not found")?;
let token = light_token_interface::state::Token::deserialize(&mut &data.data[..])?;
println!("Delegate: {:?} Tx: {sig}", token.delegate);
Ok(())
}
```
```rust theme={null}
use borsh::BorshDeserialize;
use light_client::rpc::Rpc;
use light_token_client::actions::Revoke;
use rust_client::{setup, SetupContext};
use solana_sdk::signer::Signer;
#[tokio::main]
async fn main() -> Result<(), Box> {
// Setup creates mint and associated token account with approved delegate
let SetupContext {
mut rpc,
payer,
associated_token_account,
..
} = setup().await;
let sig = Revoke {
token_account: associated_token_account,
owner: Some(payer.pubkey()),
}
.execute(&mut rpc, &payer)
.await?;
let data = rpc.get_account(associated_token_account).await?.ok_or("Account not found")?;
let token = light_token_interface::state::Token::deserialize(&mut &data.data[..])?;
println!("Delegate: {:?} Tx: {sig}", token.delegate);
Ok(())
}
```
```rust theme={null}
use borsh::BorshDeserialize;
use light_client::rpc::Rpc;
use light_token::instruction::Revoke;
use rust_client::{setup, SetupContext};
use solana_sdk::signer::Signer;
#[tokio::main]
async fn main() -> Result<(), Box> {
// Setup creates mint, associated token account with tokens, and approves delegate
let SetupContext {
mut rpc,
payer,
associated_token_account,
..
} = setup().await;
let revoke_instruction = Revoke {
token_account: associated_token_account,
owner: payer.pubkey(),
fee_payer: payer.pubkey(),
}
.instruction()?;
let sig = rpc
.create_and_send_transaction(&[revoke_instruction], &payer.pubkey(), &[&payer])
.await?;
let data = rpc.get_account(associated_token_account).await?.ok_or("Account not found")?;
let token = light_token_interface::state::Token::deserialize(&mut &data.data[..])?;
println!("Delegate: {:?} Tx: {sig}", token.delegate);
Ok(())
}
```
{`---
description: Approve and revoke token delegates
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---
## Approve and revoke token delegates
Context:
- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Crates: light-token-client (actions), light-token (instructions), light-client (RPC)
SPL equivalent: spl_token::instruction::approve / revoke → Light Token: Approve / Revoke
### 1. Index project
- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|Approve|Revoke|delegate\` across src/
- Glob \`**/*.rs\` for project structure
- Identify: RPC setup, existing token ops, entry point for delegation
- Check Cargo.toml for existing light-* dependencies and solana-sdk version
- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel
### 2. Read references
- WebFetch the guide above — follow the Rust Client tab
- WebFetch skill.md — check for a dedicated skill and resources matching this task
- TaskCreate one todo per phase below to track progress
### 3. Clarify intention
- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing)
- AskUserQuestion: does the project already have delegation operations to extend, or is this greenfield?
- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)?
- Summarize findings and wait for user confirmation before implementing
### 4. Create plan
- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes
- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair)
- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion)
- Present the plan to the user for approval before proceeding
### 5. Implement
- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\`
- Follow the cookbook guide and the approved plan
- Write/Edit to create or modify files
- TaskUpdate to mark each step done
### 6. Verify
- Bash \`cargo check\`
- Bash \`cargo test\` if tests exist
- TaskUpdate to mark complete
### Tools
- mcp__zkcompression__SearchLightProtocol("") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work`}
```text theme={null}
---
description: Approve and revoke token delegates
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---
## Approve and revoke token delegates
Context:
- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Crates: light-token-client (actions), light-token (instructions), light-client (RPC)
SPL equivalent: spl_token::instruction::approve / revoke → Light Token: Approve / Revoke
### 1. Index project
- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|Approve|Revoke|delegate` across src/
- Glob `**/*.rs` for project structure
- Identify: RPC setup, existing token ops, entry point for delegation
- Check Cargo.toml for existing light-* dependencies and solana-sdk version
- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel
### 2. Read references
- WebFetch the guide above — follow the Rust Client tab
- WebFetch skill.md — check for a dedicated skill and resources matching this task
- TaskCreate one todo per phase below to track progress
### 3. Clarify intention
- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing)
- AskUserQuestion: does the project already have delegation operations to extend, or is this greenfield?
- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)?
- Summarize findings and wait for user confirmation before implementing
### 4. Create plan
- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes
- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair)
- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion)
- Present the plan to the user for approval before proceeding
### 5. Implement
- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2`
- Follow the cookbook guide and the approved plan
- Write/Edit to create or modify files
- TaskUpdate to mark each step done
### 6. Verify
- Bash `cargo check`
- Bash `cargo test` if tests exist
- TaskUpdate to mark complete
### Tools
- mcp__zkcompression__SearchLightProtocol("") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work
```
Find [a full code example at the end](#full-code-example).
### Build Account Infos and CPI the Light Token Program
Use `invoke` for external signers or `invoke_signed` when the authority is a PDA.
```rust theme={null}
use light_token::instruction::ApproveCpi;
ApproveCpi {
token_account: token_account.clone(),
delegate: delegate.clone(),
owner: owner.clone(),
system_program: system_program.clone(),
amount,
}
.invoke()?;
```
```rust theme={null}
use light_token::instruction::ApproveCpi;
let approve_cpi = ApproveCpi {
token_account: token_account.clone(),
delegate: delegate.clone(),
owner: owner.clone(),
system_program: system_program.clone(),
amount,
};
let signer_seeds: &[&[u8]] = &[TOKEN_ACCOUNT_SEED, &[bump]];
approve_cpi.invoke_signed(&[signer_seeds])?;
```
### Build Account Infos and CPI the Light Token Program
Use `invoke` for external signers or `invoke_signed` when the authority is a PDA.
```rust theme={null}
use light_token::instruction::RevokeCpi;
RevokeCpi {
token_account: token_account.clone(),
owner: owner.clone(),
system_program: system_program.clone(),
}
.invoke()?;
```
```rust theme={null}
use light_token::instruction::RevokeCpi;
let revoke_cpi = RevokeCpi {
token_account: token_account.clone(),
owner: owner.clone(),
system_program: system_program.clone(),
};
let signer_seeds: &[&[u8]] = &[TOKEN_ACCOUNT_SEED, &[bump]];
revoke_cpi.invoke_signed(&[signer_seeds])?;
```
# Full Code Example
View the [source code](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/approve.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/approve) with shared test utilities.
```rust lib.rs theme={null}
#![allow(unexpected_cfgs, deprecated)]
use anchor_lang::prelude::*;
use light_token::instruction::ApproveCpi;
declare_id!("37XmzKqSG2VD1ZBvzyfbt1HN1mT1bqVAmfzX2ziB3KT1");
#[program]
pub mod light_token_anchor_approve {
use super::*;
pub fn approve(ctx: Context, amount: u64) -> Result<()> {
ApproveCpi {
token_account: ctx.accounts.token_account.to_account_info(),
delegate: ctx.accounts.delegate.to_account_info(),
owner: ctx.accounts.owner.to_account_info(),
system_program: ctx.accounts.system_program.to_account_info(),
amount,
fee_payer: ctx.accounts.fee_payer.to_account_info(),
}
.invoke()?;
Ok(())
}
}
#[derive(Accounts)]
pub struct ApproveAccounts<'info> {
/// CHECK: Light token program for CPI
pub light_token_program: AccountInfo<'info>,
/// CHECK: Validated by light-token CPI
#[account(mut)]
pub token_account: AccountInfo<'info>,
/// CHECK: Validated by light-token CPI
pub delegate: AccountInfo<'info>,
pub owner: Signer<'info>,
#[account(mut)]
pub fee_payer: Signer<'info>,
pub system_program: Program<'info, System>,
}
```
```rust test.rs theme={null}
use anchor_lang::{InstructionData, ToAccountMetas};
use light_program_test::Rpc;
use light_token::instruction::LIGHT_TOKEN_PROGRAM_ID;
use light_token_anchor_approve::{accounts, instruction::Approve, ID};
use anchor_lang::system_program;
use solana_sdk::{instruction::Instruction, signature::Keypair, signer::Signer};
use test_utils::{mint_tokens, setup_test_env};
#[tokio::test]
async fn test_approve() {
let mut env = setup_test_env("light_token_anchor_approve", ID).await;
// Mint tokens first
let mint_amount = 1_000_000u64;
mint_tokens(&mut env.rpc, &env.payer, env.mint_pda, env.associated_token_account, mint_amount).await;
// Call the anchor program to approve delegate
let delegate = Keypair::new();
let approve_amount = 500_000u64;
let ix = Instruction {
program_id: ID,
accounts: accounts::ApproveAccounts {
light_token_program: LIGHT_TOKEN_PROGRAM_ID,
token_account: env.associated_token_account,
delegate: delegate.pubkey(),
owner: env.payer.pubkey(),
fee_payer: env.payer.pubkey(),
system_program: system_program::ID,
}
.to_account_metas(Some(true)),
data: Approve { amount: approve_amount }.data(),
};
let sig = env
.rpc
.create_and_send_transaction(&[ix], &env.payer.pubkey(), &[&env.payer])
.await
.unwrap();
println!("Tx: {}", sig);
}
```
View the [source code](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/revoke.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/revoke) with shared test utilities.
```rust lib.rs theme={null}
#![allow(unexpected_cfgs, deprecated)]
use anchor_lang::prelude::*;
use light_token::instruction::RevokeCpi;
declare_id!("G3ph4MK5qaSdxYnfxToETg31AHEMMqVhPuMRgBhk38tQ");
#[program]
pub mod light_token_anchor_revoke {
use super::*;
pub fn revoke(ctx: Context) -> Result<()> {
RevokeCpi {
token_account: ctx.accounts.token_account.to_account_info(),
owner: ctx.accounts.owner.to_account_info(),
system_program: ctx.accounts.system_program.to_account_info(),
fee_payer: ctx.accounts.fee_payer.to_account_info(),
}
.invoke()?;
Ok(())
}
}
#[derive(Accounts)]
pub struct RevokeAccounts<'info> {
/// CHECK: Light token program for CPI
pub light_token_program: AccountInfo<'info>,
/// CHECK: Validated by light-token CPI
#[account(mut)]
pub token_account: AccountInfo<'info>,
pub owner: Signer<'info>,
#[account(mut)]
pub fee_payer: Signer<'info>,
pub system_program: Program<'info, System>,
}
```
```rust test.rs theme={null}
use anchor_lang::{InstructionData, ToAccountMetas};
use light_program_test::Rpc;
use light_token::instruction::{Approve, LIGHT_TOKEN_PROGRAM_ID};
use light_token_anchor_revoke::{accounts, instruction::Revoke, ID};
use anchor_lang::system_program;
use solana_sdk::{instruction::Instruction, signature::Keypair, signer::Signer};
use test_utils::{mint_tokens, setup_test_env};
#[tokio::test]
async fn test_revoke() {
let mut env = setup_test_env("light_token_anchor_revoke", ID).await;
// Mint tokens first
let mint_amount = 1_000_000u64;
mint_tokens(&mut env.rpc, &env.payer, env.mint_pda, env.associated_token_account, mint_amount).await;
// Approve delegate first using SDK
let delegate = Keypair::new();
let approve_ix = Approve {
token_account: env.associated_token_account,
delegate: delegate.pubkey(),
owner: env.payer.pubkey(),
amount: 500_000,
fee_payer: env.payer.pubkey(),
}
.instruction()
.unwrap();
env.rpc
.create_and_send_transaction(&[approve_ix], &env.payer.pubkey(), &[&env.payer])
.await
.unwrap();
// Call the anchor program to revoke delegation
let ix = Instruction {
program_id: ID,
accounts: accounts::RevokeAccounts {
light_token_program: LIGHT_TOKEN_PROGRAM_ID,
token_account: env.associated_token_account,
owner: env.payer.pubkey(),
fee_payer: env.payer.pubkey(),
system_program: system_program::ID,
}
.to_account_metas(Some(true)),
data: Revoke {}.data(),
};
let sig = env
.rpc
.create_and_send_transaction(&[ix], &env.payer.pubkey(), &[&env.payer])
.await
.unwrap();
println!("Tx: {}", sig);
}
```
{`---
description: Add approve and revoke CPI to an Anchor program
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---
## Add approve and revoke CPI to an Anchor program
Context:
- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Crate: light-token (ApproveCpi, RevokeCpi)
- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/approve
Key CPI structs: \`light_token::instruction::ApproveCpi\`, \`light_token::instruction::RevokeCpi\`
### 1. Index project
- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|approve|revoke|delegate\` across src/
- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure
- Identify: program ID, existing instructions, account structs, delegate accounts
- Read Cargo.toml — note existing dependencies and framework version
- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel
### 2. Read references
- WebFetch the guide above — review both Approve and Revoke CPI code samples
- WebFetch skill.md — check for a dedicated skill and resources matching this task
- TaskCreate one todo per phase below to track progress
### 3. Clarify intention
- AskUserQuestion: what is the goal? (add approve/revoke to existing program, new program from scratch, migrate from SPL approve/revoke)
- AskUserQuestion: should the owner be an external signer or a PDA? (determines invoke vs invoke_signed)
- AskUserQuestion: do you need both approve and revoke, or just one?
- Summarize findings and wait for user confirmation before implementing
### 4. Create plan
- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes
- Follow the guide's step order: Build ApproveCpi/RevokeCpi structs → call .invoke() or .invoke_signed()
- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion)
- Present the plan to the user for approval before proceeding
### 5. Implement
- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\`
- Follow the guide and the approved plan
- Write/Edit to create or modify files
- TaskUpdate to mark each step done
### 6. Verify
- Bash \`anchor build\`
- Bash \`anchor test\` if tests exist
- TaskUpdate to mark complete
### Tools
- mcp__zkcompression__SearchLightProtocol("") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work`}
```text theme={null}
---
description: Add approve and revoke CPI to an Anchor program
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---
## Add approve and revoke CPI to an Anchor program
Context:
- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Crate: light-token (ApproveCpi, RevokeCpi)
- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/approve
Key CPI structs: `light_token::instruction::ApproveCpi`, `light_token::instruction::RevokeCpi`
### 1. Index project
- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|approve|revoke|delegate` across src/
- Glob `**/*.rs` and `**/Cargo.toml` for project structure
- Identify: program ID, existing instructions, account structs, delegate accounts
- Read Cargo.toml — note existing dependencies and framework version
- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel
### 2. Read references
- WebFetch the guide above — review both Approve and Revoke CPI code samples
- WebFetch skill.md — check for a dedicated skill and resources matching this task
- TaskCreate one todo per phase below to track progress
### 3. Clarify intention
- AskUserQuestion: what is the goal? (add approve/revoke to existing program, new program from scratch, migrate from SPL approve/revoke)
- AskUserQuestion: should the owner be an external signer or a PDA? (determines invoke vs invoke_signed)
- AskUserQuestion: do you need both approve and revoke, or just one?
- Summarize findings and wait for user confirmation before implementing
### 4. Create plan
- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes
- Follow the guide's step order: Build ApproveCpi/RevokeCpi structs → call .invoke() or .invoke_signed()
- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion)
- Present the plan to the user for approval before proceeding
### 5. Implement
- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31`
- Follow the guide and the approved plan
- Write/Edit to create or modify files
- TaskUpdate to mark each step done
### 6. Verify
- Bash `anchor build`
- Bash `anchor test` if tests exist
- TaskUpdate to mark complete
### Tools
- mcp__zkcompression__SearchLightProtocol("") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work
```
## Related Guides
***
## Didn't find what you were looking for?
Reach out! [Telegram](https://t.me/swen_light) | [email](mailto:support@lightprotocol.com) | [Discord](https://discord.com/invite/7cJ8BhAXhu)