Freeze and Thaw Light Token Accounts

Rust client guide to freeze and thaw Light Token accounts. Includes step-by-step implementation and full code examples.

---

1. Freeze prevents all transfers or token burns from a specific Light Token account.
2. Once frozen, the account cannot send tokens, receive tokens, or be closed until it is thawed.
3. Thaw re-enables transfers on a frozen Light Token account.
4. Only the freeze authority (set at mint creation) can freeze or thaw accounts.
5. If the freeze authority is revoked (set to null) on the mint account, tokens can never be frozen.

Agent skill

Install or view dedicated agent skills.

npx skills add Lightprotocol/skills

Install orchestrator agent skill or view skill.md:

npx skills add https://zkcompression.com

Rust Client

Freeze

Thaw

Guide

1. Prerequisites

   Dependencies

   Cargo.toml

   [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"] }
   

   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
   

   yarn

   yarn global add @lightprotocol/zk-compression-cli
   

   pnpm

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

   # 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. Freeze or thaw Light Token accounts

   Find the source code here.

   Freeze

   Instruction

   use borsh::BorshDeserialize;
   use light_client::rpc::Rpc;
   use light_token::instruction::Freeze;
   use rust_client::{setup, SetupContext};
   use solana_sdk::signer::Signer;
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       // Setup creates mint, associated token account with tokens, and approves delegate
       let SetupContext {
           mut rpc,
           payer,
           mint,
           associated_token_account,
           ..
       } = setup().await;
   
       // freeze_authority must match what was set during mint creation.
       let freeze_instruction = Freeze {
           token_account: associated_token_account,
           mint,
           freeze_authority: payer.pubkey(),
       }
       .instruction()?;
   
       let sig = rpc
           .create_and_send_transaction(&[freeze_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!("State: {:?} Tx: {sig}", token.state);
   
       Ok(())
   }
   

   Thaw

   Instruction

   use borsh::BorshDeserialize;
   use light_client::rpc::Rpc;
   use light_token::instruction::Thaw;
   use rust_client::{setup_frozen, SetupContext};
   use solana_sdk::signer::Signer;
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       // Setup creates mint, associated token account with tokens, and freezes account
       let SetupContext {
           mut rpc,
           payer,
           mint,
           associated_token_account,
           ..
       } = setup_frozen().await;
   
       let thaw_instruction = Thaw {
           token_account: associated_token_account,
           mint,
           freeze_authority: payer.pubkey(),
       }
       .instruction()?;
   
       let sig = rpc
           .create_and_send_transaction(&[thaw_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!("State: {:?} Tx: {sig}", token.state);
   
       Ok(())
   }
   

AI Prompt

Freeze and thaw Light Token accounts

CopiedCopy promptOpen in Cursor

---
description: Freeze and thaw Light Token accounts
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---

## Freeze and thaw Light Token accounts

Context:
- Guide: https://zkcompression.com/light-token/cookbook/freeze-thaw
- 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)

- Freeze: prevents all transfers or token burns from a specific Light Token account
- Thaw: re-enables transfers on a frozen Light Token account
- Only the freeze authority (set at mint creation) can freeze or thaw accounts

SPL equivalent: spl_token::instruction::freeze_account / thaw_account → Light Token: Freeze / Thaw

### 1. Index project
- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|Freeze|Thaw|freeze_account|thaw_account` across src/
- Glob `**/*.rs` for project structure
- Identify: RPC setup, existing token ops, entry point for freeze/thaw
- 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 freeze/thaw 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("<query>") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "<q>") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work

Program

Guide

Find a full code example at the end.

Freeze

1. Build Account Infos and CPI the Light Token Program

   Use invoke for external signers or invoke_signed when the authority is a PDA.

   invoke (External signer)

   use light_token::instruction::FreezeCpi;
   
   FreezeCpi {
       token_account: ctx.accounts.token_account.to_account_info(),
       mint: ctx.accounts.mint.to_account_info(),
       freeze_authority: ctx.accounts.freeze_authority.to_account_info(),
   }
   .invoke()?;
   

   invoke_signed (PDA authority)

   use light_token::instruction::FreezeCpi;
   
   let signer_seeds = authority_seeds!(bump);
   
   FreezeCpi {
       token_account: token_account.clone(),
       mint: mint.clone(),
       freeze_authority: freeze_authority.clone(),
   }
   .invoke_signed(&[signer_seeds])
   

Thaw

1. Build Account Infos and CPI the Light Token Program

   Use invoke for external signers or invoke_signed when the authority is a PDA.

   invoke (External signer)

   use light_token::instruction::ThawCpi;
   
   ThawCpi {
       token_account: ctx.accounts.token_account.to_account_info(),
       mint: ctx.accounts.mint.to_account_info(),
       freeze_authority: ctx.accounts.freeze_authority.to_account_info(),
   }
   .invoke()?;
   

   invoke_signed (PDA authority)

   use light_token::instruction::ThawCpi;
   
   let signer_seeds = authority_seeds!(bump);
   
   ThawCpi {
       token_account: token_account.clone(),
       mint: mint.clone(),
       freeze_authority: freeze_authority.clone(),
   }
   .invoke_signed(&[signer_seeds])
   

Full Code Example

Freeze

View the source code and full example with shared test utilities.

lib.rs

#![allow(unexpected_cfgs, deprecated)]

use anchor_lang::prelude::*;
use light_token::instruction::FreezeCpi;

declare_id!("JBMzMJX4sqCQfNVbosP2oqP1KZ5ZDWiwYTrupk687qXZ");

#[program]
pub mod light_token_anchor_freeze {
    use super::*;

    pub fn freeze(ctx: Context<FreezeAccounts>) -> Result<()> {
        FreezeCpi {
            token_account: ctx.accounts.token_account.to_account_info(),
            mint: ctx.accounts.mint.to_account_info(),
            freeze_authority: ctx.accounts.freeze_authority.to_account_info(),
        }
        .invoke()?;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct FreezeAccounts<'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 mint: AccountInfo<'info>,
    pub freeze_authority: Signer<'info>,
}

Thaw

View the source code and full example with shared test utilities.

lib.rs

#![allow(unexpected_cfgs, deprecated)]

use anchor_lang::prelude::*;
use light_token::instruction::ThawCpi;

declare_id!("7j94EF5hSkDLf7R26bjrd8Qc6s3oLAQpcKiF3re8JYw9");

#[program]
pub mod light_token_anchor_thaw {
    use super::*;

    pub fn thaw(ctx: Context<ThawAccounts>) -> Result<()> {
        ThawCpi {
            token_account: ctx.accounts.token_account.to_account_info(),
            mint: ctx.accounts.mint.to_account_info(),
            freeze_authority: ctx.accounts.freeze_authority.to_account_info(),
        }
        .invoke()?;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct ThawAccounts<'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 mint: AccountInfo<'info>,
    pub freeze_authority: Signer<'info>,
}

AI Prompt

Add freeze and thaw CPI to an Anchor program

CopiedCopy promptOpen in Cursor

---
description: Add freeze and thaw 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 freeze and thaw CPI to an Anchor program

Context:
- Guide: https://zkcompression.com/light-token/cookbook/freeze-thaw
- 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 (FreezeCpi, ThawCpi)
- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/freeze

Key CPI structs: `light_token::instruction::FreezeCpi`, `light_token::instruction::ThawCpi`

### 1. Index project
- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|freeze|thaw|authority` across src/
- Glob `**/*.rs` and `**/Cargo.toml` for project structure
- Identify: program ID, existing instructions, account structs, freeze authority
- 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 Freeze and Thaw 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 freeze/thaw to existing program, new program from scratch, migrate from SPL freeze/thaw)
- AskUserQuestion: should the freeze authority be an external signer or a PDA? (determines invoke vs invoke_signed)
- AskUserQuestion: do you need both freeze and thaw, 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 FreezeCpi/ThawCpi 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("<query>") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "<q>") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work

Related Guides

Approve and revoke

Delegated transfer

---

Didn’t find what you were looking for?

Reach out! Telegram | email | Discord