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.

Rust Client

Freeze

Thaw

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. Freeze or thaw light-token accounts

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

   Freeze

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

   Thaw

   mod shared;
   
   use light_client::rpc::Rpc;
   use light_token_sdk::token::Thaw;
   use shared::SetupContext;
   use solana_sdk::signer::Signer;
   
   #[tokio::test(flavor = "multi_thread")]
   async fn thaw() {
       // Setup creates mint, ATA with tokens, and freezes account
       let SetupContext {
           mut rpc,
           payer,
           mint,
           ata,
           ..
       } = shared::setup_frozen().await;
   
       let thaw_ix = Thaw {
           token_account: ata,
           mint,
           freeze_authority: payer.pubkey(),
       }
       .instruction()
       .unwrap();
   
       rpc.create_and_send_transaction(&[thaw_ix], &payer.pubkey(), &[&payer])
           .await
           .unwrap();
   }
   

Program Guide

1. Freeze

   invoke (External Signer)

   use light_token_sdk::token::FreezeCpi;
   
   FreezeCpi {
       token_account: token_account.clone(),
       mint: mint.clone(),
       freeze_authority: freeze_authority.clone(),
   }
   .invoke()
   

   invoke_signed (PDA Authority)

   use light_token_sdk::token::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])
   
2. Thaw

   invoke (External Signer)

   use light_token_sdk::token::ThawCpi;
   
   ThawCpi {
       token_account: token_account.clone(),
       mint: mint.clone(),
       freeze_authority: freeze_authority.clone(),
   }
   .invoke()
   

   invoke_signed (PDA Authority)

   use light_token_sdk::token::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

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

Anchor

Native

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

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

    FreezeCpi {
        token_account: token_account.clone(),
        mint: mint.clone(),
        freeze_authority: freeze_authority.clone(),
    }
    .invoke()
}

pub fn freeze_invoke_signed(accounts: &[AccountInfo], data: &[u8]) -> ProgramResult {
    let [token_account, mint, freeze_authority, _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);

    FreezeCpi {
        token_account: token_account.clone(),
        mint: mint.clone(),
        freeze_authority: freeze_authority.clone(),
    }
    .invoke_signed(&[signer_seeds])
}

// ---

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

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

    ThawCpi {
        token_account: token_account.clone(),
        mint: mint.clone(),
        freeze_authority: freeze_authority.clone(),
    }
    .invoke()
}

pub fn thaw_invoke_signed(accounts: &[AccountInfo], data: &[u8]) -> ProgramResult {
    let [token_account, mint, freeze_authority, _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);

    ThawCpi {
        token_account: token_account.clone(),
        mint: mint.clone(),
        freeze_authority: freeze_authority.clone(),
    }
    .invoke_signed(&[signer_seeds])
}

Next Steps

Approve and Revoke Delegates for Light Token Accounts