Create Light Token Account

Client and program guide to create Light Token accounts. Includes step-by-step implementation and full code examples.

---

1. Light token accounts are Solana accounts that hold token balances of light, SPL, or Token 2022 mints.
2. Light token accounts are on-chain accounts like SPL ATA’s, but the light token program sponsors the rent-exemption cost for you.

Light Rent Config Explained

1. A rent sponsor PDA by Light Protocol pays the rent-exemption cost for the account.
2. Transaction fee payers bump a virtual rent balance when writing to the account, which keeps the account “hot”.
3. “Cold” accounts virtual rent balance below threshold (eg 24h without write bump) get auto-compressed.
4. The cold account’s state is cryptographically preserved on the Solana ledger. Users can load a cold account into hot state in-flight when using the account again.

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

CreateTokenAccount creates an on-chain token account to store token balances of light, SPL, or Token 2022 mints.

Compare to SPL:

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. Create Token Account

   Find the source code here.

   Instruction

   use light_client::rpc::Rpc;
   use light_token::instruction::CreateTokenAccount;
   use rust_client::{setup_spl_mint_context, SplMintContext};
   use solana_sdk::{signature::Keypair, signer::Signer};
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       // Setup creates mint
       // You can use Light, SPL, or Token-2022 mints to create a light token account.
       let SplMintContext {
           mut rpc,
           payer,
           mint,
       } = setup_spl_mint_context().await;
   
       let account = Keypair::new();
   
       let create_token_account_instruction =
           CreateTokenAccount::new(payer.pubkey(), account.pubkey(), mint, payer.pubkey())
               .instruction()?;
   
       let sig = rpc
           .create_and_send_transaction(&[create_token_account_instruction], &payer.pubkey(), &[&payer, &account])
           .await?;
   
       let data = rpc.get_account(account.pubkey()).await?;
       println!(
           "Account: {} exists: {} Tx: {sig}",
           account.pubkey(),
           data.is_some()
       );
   
       Ok(())
   }
   

AI Prompt

Create Light Token account

CopiedCopy promptOpen in Cursor

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

## Create Light Token account

Context:
- Guide: https://zkcompression.com/light-token/cookbook/create-token-account
- 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::initialize_account → Light Token: CreateTokenAccount

### 1. Index project
- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|CreateTokenAccount|initialize_account` across src/
- Glob `**/*.rs` for project structure
- Identify: RPC setup, existing token ops, entry point for token account creation
- 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 token account 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

CPI

Guide

Compare to SPL:

Find a full code example at the end.

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::CreateTokenAccountCpi;
   
   CreateTokenAccountCpi {
       payer: payer.clone(),
       account: account.clone(),
       mint: mint.clone(),
       owner,
   }
   .rent_free(
       compressible_config.clone(),
       rent_sponsor.clone(),
       system_program.clone(),
       token_program.key, // light token program
   )
   .invoke()
   

   Payer	signer, mutable	Pays initial rent per epoch, transaction fee and compression incentive. Does NOT pay rent exemption (paid by the light token program, rent_sponsor).
   light-token Account	signer*, mutable	The light-token account being created. *Must be signer for invoke(). For invoke_signed(), program signs via PDA seeds.
   Mint	-	The SPL or light-mint token mint.
   Owner	Pubkey	The owner of the token account. Controls transfers and other operations.

   invoke_signed (PDA signer)

   use light_token::instruction::CreateTokenAccountCpi;
   
   let signer_seeds = authority_seeds!(authority_bump);
   
   CreateTokenAccountCpi {
       payer: payer.clone(),
       account: account.clone(),
       mint: mint.clone(),
       owner,
   }
   .rent_free(
       compressible_config.clone(),
       rent_sponsor.clone(),
       system_program.clone(),
       program_id,
   )
   .invoke_signed(signer_seeds)
   

Full Code Example

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::CreateTokenAccountCpi;

declare_id!("zXK1CnWj4WFfFHCArxxr4sh3Qqx2p3oui8ahqpjArgS");

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

    pub fn create_token_account(ctx: Context<CreateTokenAccountAccounts>, owner: Pubkey) -> Result<()> {
        CreateTokenAccountCpi {
            payer: ctx.accounts.payer.to_account_info(),
            account: ctx.accounts.account.to_account_info(),
            mint: ctx.accounts.mint.to_account_info(),
            owner,
        }
        .rent_free(
            ctx.accounts.compressible_config.to_account_info(),
            ctx.accounts.rent_sponsor.to_account_info(),
            ctx.accounts.system_program.to_account_info(),
            &ctx.accounts.light_token_program.key(),
        )
        .invoke()?;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct CreateTokenAccountAccounts<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,
    /// CHECK: Validated by light-token CPI
    #[account(mut)]
    pub account: Signer<'info>,
    /// CHECK: Validated by light-token CPI
    pub mint: AccountInfo<'info>,
    /// CHECK: Validated by light-token CPI
    pub compressible_config: AccountInfo<'info>,
    /// CHECK: Validated by light-token CPI
    #[account(mut)]
    pub rent_sponsor: AccountInfo<'info>,
    pub system_program: Program<'info, System>,
    /// CHECK: Light token program for CPI
    pub light_token_program: AccountInfo<'info>,
}

use anchor_lang::{InstructionData, ToAccountMetas};
use light_client::indexer::AddressWithTree;
use light_program_test::{Indexer, LightProgramTest, ProgramTestConfig, Rpc};
use light_token_anchor_create_token_account::{accounts, instruction::CreateTokenAccount, ID};
use light_token::instruction::{
    CreateMint, CreateMintParams, config_pda, derive_mint_compressed_address,
    find_mint_address, rent_sponsor_pda, LIGHT_TOKEN_PROGRAM_ID,
    DEFAULT_RENT_PAYMENT, DEFAULT_WRITE_TOP_UP,
};
use anchor_lang::system_program;
use solana_sdk::{
    instruction::Instruction,
    signature::Keypair,
    signer::Signer,
};

#[tokio::test]
async fn test_create_token_account() {
    let config = ProgramTestConfig::new_v2(
        true,
        Some(vec![("light_token_anchor_create_token_account", ID)]),
    );
    let mut rpc = LightProgramTest::new(config).await.unwrap();
    let payer = rpc.get_payer().insecure_clone();

    // Create a mint first
    let mint_seed = Keypair::new();
    let mint_authority = payer.pubkey();
    let decimals = 9u8;

    let address_tree = rpc.get_address_tree_v2();
    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;

    let compression_address =
        derive_mint_compressed_address(&mint_seed.pubkey(), &address_tree.tree);
    let (mint_pda, bump) = find_mint_address(&mint_seed.pubkey());

    let rpc_result = rpc
        .get_validity_proof(
            vec![],
            vec![AddressWithTree {
                address: compression_address,
                tree: address_tree.tree,
            }],
            None,
        )
        .await
        .unwrap()
        .value;

    let params = CreateMintParams {
        decimals,
        address_merkle_tree_root_index: rpc_result.addresses[0].root_index,
        mint_authority,
        proof: rpc_result.proof.0.unwrap(),
        compression_address,
        mint: mint_pda,
        bump,
        freeze_authority: None,
        extensions: None,
        rent_payment: DEFAULT_RENT_PAYMENT,
        write_top_up: DEFAULT_WRITE_TOP_UP,
    };

    let create_mint_ix = CreateMint::new(
        params,
        mint_seed.pubkey(),
        payer.pubkey(),
        address_tree.tree,
        output_queue,
    )
    .instruction()
    .unwrap();

    rpc.create_and_send_transaction(&[create_mint_ix], &payer.pubkey(), &[&payer, &mint_seed])
        .await
        .unwrap();

    // You can use light, spl, t22 mints to create a light token account.
    // Create a token account
    let token_account = Keypair::new();
    let owner = payer.pubkey();
    let compressible_config = config_pda();
    let rent_sponsor = rent_sponsor_pda();

    let ix = Instruction {
        program_id: ID,
        accounts: accounts::CreateTokenAccountAccounts {
            payer: payer.pubkey(),
            account: token_account.pubkey(),
            mint: mint_pda,
            compressible_config,
            rent_sponsor,
            system_program: system_program::ID,
            light_token_program: LIGHT_TOKEN_PROGRAM_ID,
        }
        .to_account_metas(Some(true)),
        data: CreateTokenAccount { owner }.data(),
    };

    let sig = rpc
        .create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer, &token_account])
        .await
        .unwrap();

    println!("Tx: {}", sig);
}

AI Prompt

Add create-token-account CPI to an Anchor program

CopiedCopy promptOpen in Cursor

---
description: Add create-token-account 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 create-token-account CPI to an Anchor program

Context:
- Guide: https://zkcompression.com/light-token/cookbook/create-token-account
- 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 (CreateTokenAccountCpi)
- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-token-account

Key CPI struct: `light_token::instruction::CreateTokenAccountCpi`

### 1. Index project
- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|token_account|vault|owner|mint` across src/
- Glob `**/*.rs` and `**/Cargo.toml` for project structure
- Identify: program ID, existing instructions, account structs, vault/token account patterns
- 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 the CPI tab under Program: token account creation with .rent_free() chain
- 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 create-token-account to existing program, new program from scratch, migrate from SPL token account init)
- AskUserQuestion: should the payer be an external signer or a PDA? (determines invoke vs invoke_signed)
- 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 CreateTokenAccountCpi → .rent_free() → .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

Anchor Macros

Guide

Compare to SPL:

Find a full code example at the end.

1. Dependencies

   [dependencies]
   light-sdk = { version = "0.23.0", features = ["anchor", "v2", "cpi-context"] }
   light-sdk-macros = "0.23.0"
   light-compressible = "0.6.0"
   anchor-lang = "0.31"
   
2. Program

   Add #[light_program] above #[program]:

   use light_sdk_macros::light_program;
   
   #[light_program]
   #[program]
   pub mod light_token_macro_create_token_account {
       use super::*;
   
       pub fn create_token_account<'info>(
           ctx: Context<'_, '_, '_, 'info, CreateTokenAccount<'info>>,
           params: CreateTokenAccountParams,
       ) -> Result<()> {
           Ok(())
       }
   }
   
3. Accounts struct

   Derive LightAccounts on your Accounts struct and add #[light_account(...)] next to #[account(...)].

   /// CHECK: Validated by light-token CPI
   #[account(
       mut,
       seeds = [VAULT_SEED, mint.key().as_ref()],
       bump,
   )]
   #[light_account(init,
       token::authority = [VAULT_SEED, self.mint.key()],
       token::mint = mint,
       token::owner = vault_authority,
       token::bump = params.vault_bump
   )]
   pub vault: UncheckedAccount<'info>,
   

Full code example

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

lib.rs

#![allow(deprecated)]

use anchor_lang::prelude::*;
use light_account::{
    derive_light_cpi_signer, light_program, CreateAccountsProof, CpiSigner, LightAccounts,
};
use light_token::instruction::{LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR};

declare_id!("9p5BUDtVmRRJqp2sN73ZUZDbaYtYvEWuxzrHH3A2ni9y");

pub const LIGHT_CPI_SIGNER: CpiSigner =
    derive_light_cpi_signer!("9p5BUDtVmRRJqp2sN73ZUZDbaYtYvEWuxzrHH3A2ni9y");

pub const VAULT_AUTH_SEED: &[u8] = b"vault_auth";
pub const VAULT_SEED: &[u8] = b"vault";

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct CreateTokenVaultParams {
    pub create_accounts_proof: CreateAccountsProof,
    pub vault_bump: u8,
}

#[derive(Accounts, LightAccounts)]
#[instruction(params: CreateTokenVaultParams)]
pub struct CreateTokenVault<'info> {
    #[account(mut)]
    pub fee_payer: Signer<'info>,

    /// CHECK: Token mint for the vault
    pub mint: AccountInfo<'info>,

    /// CHECK: Validated by seeds constraint
    #[account(
        seeds = [VAULT_AUTH_SEED],
        bump,
    )]
    pub vault_authority: UncheckedAccount<'info>,

    /// CHECK: Validated by seeds constraint and light_account macro
    #[account(
        mut,
        seeds = [VAULT_SEED, mint.key().as_ref()],
        bump,
    )]
    #[light_account(
        init,
        token::seeds = [VAULT_SEED, self.mint.key()],
        token::mint = mint,
        token::owner = vault_authority,
        token::owner_seeds = [VAULT_AUTH_SEED],
        token::bump = params.vault_bump
    )]
    pub vault: UncheckedAccount<'info>,

    /// CHECK: Validated by address constraint
    #[account(address = LIGHT_TOKEN_CONFIG)]
    pub light_token_config: AccountInfo<'info>,

    /// CHECK: Validated by address constraint
    #[account(mut, address = LIGHT_TOKEN_RENT_SPONSOR)]
    pub light_token_rent_sponsor: AccountInfo<'info>,

    /// CHECK: Light token CPI authority
    pub light_token_cpi_authority: AccountInfo<'info>,

    /// CHECK: Light token program for CPI
    pub light_token_program: AccountInfo<'info>,

    pub system_program: Program<'info, System>,
}

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

    #[allow(unused_variables)]
    pub fn create_token_vault<'info>(
        ctx: Context<'_, '_, '_, 'info, CreateTokenVault<'info>>,
        params: CreateTokenVaultParams,
    ) -> Result<()> {
        Ok(())
    }
}

use anchor_lang::{InstructionData, ToAccountMetas};
use light_client::interface::get_create_accounts_proof;
use light_program_test::{LightProgramTest, ProgramTestConfig, Rpc};
use light_token::instruction::LIGHT_TOKEN_PROGRAM_ID;
use solana_instruction::Instruction;
use solana_pubkey::Pubkey;
use solana_signer::Signer;
use test_utils::create_mint;

/// Test creating a token vault using the `#[light_account(init, token, ...)]` macro.
///
/// This test verifies:
/// 1. The macro-annotated program compiles correctly
/// 2. A token vault can be created via the generated CPI
/// 3. The vault has the correct owner and mint
#[tokio::test]
async fn test_create_token_vault() {
    use light_token::instruction::{LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR};
    use light_token_macro_create_token_account::{
        CreateTokenVaultParams, VAULT_AUTH_SEED, VAULT_SEED,
    };
    use light_token::constants::LIGHT_TOKEN_CPI_AUTHORITY;

    let program_id = light_token_macro_create_token_account::ID;
    let config = ProgramTestConfig::new_v2(
        true,
        Some(vec![("light_token_macro_create_token_account", program_id)]),
    );

    let mut rpc = LightProgramTest::new(config).await.unwrap();
    let payer = rpc.get_payer().insecure_clone();

    let (mint, _mint_seed) = create_mint(&mut rpc, &payer, None).await;

    // Derive PDAs
    let (vault_authority, _auth_bump) =
        Pubkey::find_program_address(&[VAULT_AUTH_SEED], &program_id);
    let (vault, vault_bump) =
        Pubkey::find_program_address(&[VAULT_SEED, mint.as_ref()], &program_id);

    // Get proof for token-only instruction (empty inputs)
    let proof_result = get_create_accounts_proof(&rpc, &program_id, vec![])
        .await
        .unwrap();

    // Build instruction accounts
    let accounts = light_token_macro_create_token_account::accounts::CreateTokenVault {
        fee_payer: payer.pubkey(),
        mint,
        vault_authority,
        vault,
        light_token_config: LIGHT_TOKEN_CONFIG,
        light_token_rent_sponsor: LIGHT_TOKEN_RENT_SPONSOR,
        light_token_cpi_authority: LIGHT_TOKEN_CPI_AUTHORITY,
        light_token_program: LIGHT_TOKEN_PROGRAM_ID,
        system_program: solana_sdk::system_program::ID,
    };

    // Build instruction data
    let instruction_data = light_token_macro_create_token_account::instruction::CreateTokenVault {
        params: CreateTokenVaultParams {
            create_accounts_proof: proof_result.create_accounts_proof,
            vault_bump,
        },
    };

    let instruction = Instruction {
        program_id,
        accounts: [
            accounts.to_account_metas(None),
            proof_result.remaining_accounts,
        ]
        .concat(),
        data: instruction_data.data(),
    };

    // Execute the instruction
    // Note: This may fail without InitializeRentFreeConfig setup.
    // The full test requires rent-free config initialization.
    let result = rpc
        .create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
        .await;

    // For now, we verify the instruction builds correctly.
    // Full execution requires additional setup (InitializeRentFreeConfig, etc.)
    println!("Transaction result: {:?}", result);
}

AI Prompt

Create a rent-free token account with Anchor macros

CopiedCopy promptOpen in Cursor

---
description: Create a rent-free token account with Anchor macros
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---

## Create a rent-free token account with Anchor macros

Context:
- Guide: https://zkcompression.com/light-token/cookbook/create-token-account
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Crates: light-sdk, light-sdk-macros, light-compressible, anchor-lang
- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-token-account

Key macros: `#[light_program]`, `LightAccounts`, `#[light_account(init, token::...)]`

### 1. Index project
- Grep `#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|vault|token_account` across src/
- Glob `**/*.rs` and `**/Cargo.toml` for project structure
- Identify: existing program module, account structs, vault/token account patterns
- 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 the Anchor Macros tab under Program
- 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 program from scratch, add rent-free token account to existing program, migrate from SPL token account init)
- Summarize findings and wait for user confirmation before implementing

### 4. Create plan
- Based on steps 1–3, draft an implementation plan
- Follow the guide's step order: Dependencies → Program Module (#[light_program]) → Accounts Struct (#[light_account(init, token::...)])
- 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-sdk@0.23 --features anchor,v2,cpi-context` and `cargo add light-sdk-macros@0.23 light-compressible@0.6 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

Transfer interface

Wrap and unwrap

---

Didn’t find what you were looking for?

Reach out! Telegram | email | Discord