> ## 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. # Create Light Token Account > Client and program guide to create Light Token accounts. Includes step-by-step implementation and full code examples. export const lightCreateTokenAccountCpiCode = ["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,", ")", ".invoke()?"].join("\n"); export const splCreateTokenAccountCpiCode = ["use spl_token::instruction::initialize_account;", "", "let ix = initialize_account(", " &spl_token::id(),", " &account,", " &mint,", " &owner,", ")?;", "", "invoke(&ix, &[account, mint, owner])?;"].join("\n"); export const lightCreateTokenAccountMacroCode = ["#[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>,"].join("\n"); export const splCreateTokenAccountMacroCode = ["#[account(", " init,", " payer = fee_payer,", " token::mint = mint,", " token::authority = authority,", ")]", "pub vault: Account<'info, TokenAccount>,"].join("\n"); export const lightCreateTokenAccountRustCode = ["use light_token::instruction::CreateTokenAccount;", "", "let ix = CreateTokenAccount::new(", " payer.pubkey(),", " account.pubkey(),", " mint,", " owner,", ")", ".instruction()?;"].join("\n"); export const splCreateTokenAccountRustCode = ["use spl_token::instruction::initialize_account;", "", "let ix = initialize_account(", " &spl_token::id(),", " &account,", " &mint,", " &owner,", ")?;"].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}
{} {}
{}
{}
{}
{} 

              {}
{}
{}
{[0, 1, 2].map(i =>
)}
{[0, 1, 2].map(i =>
)}
; }; *** 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. 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. Install or view [dedicated agent skills](/ai-tools/overview#agent-skills). ``` npx skills add Lightprotocol/skills ``` Install orchestrator agent skill or view [skill.md](https://www.zkcompression.com/skill.md): ```bash theme={null} npx skills add https://zkcompression.com ``` `CreateTokenAccount` creates an on-chain token account to store token balances of light, SPL, or Token 2022 mints. Compare to SPL: ### 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(()) } ``` ### Create Token Account Find the source code [here](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_associated_token_account.rs). ```rust theme={null} 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> { // 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(()) } ``` {`--- 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("") 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: 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("") 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 ``` Compare to SPL: 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::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.
```rust theme={null} 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](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_associated_token_account.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-token-account) with shared test utilities. ```rust lib.rs theme={null} #![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, 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>, } ``` ```rust test.rs theme={null} 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); } ``` {`--- 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("") 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 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("") 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 ``` Compare to SPL: Find [a full code example at the end](#full-code-example-1). ### Dependencies ```toml theme={null} [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" ``` ### Program Add `#[light_program]` above `#[program]`: ```rust theme={null} 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(()) } } ``` ### Accounts struct Derive `LightAccounts` on your `Accounts` struct and add `#[light_account(...)]` next to `#[account(...)]`. ```rust theme={null} /// 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](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_associated_token_account.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-token-account) with shared test utilities. ```rust lib.rs theme={null} #![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(()) } } ``` ```rust test.rs theme={null} 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); } ``` {`--- 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("") 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: 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("") 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)