> ## 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 Associated Light Token Accounts > Client and program guide to create associated Light Token accounts. Includes step-by-step implementation and full code examples. export const lightCreateAtaCpiCode = ["use light_token::instruction::CreateAssociatedAccountCpi;", "", "CreateAssociatedAccountCpi {", " payer: payer.clone(),", " owner: owner.clone(),", " mint: mint.clone(),", " ata: associated_token_account.clone(),", " bump,", "}", ".rent_free(", " compressible_config.clone(),", " rent_sponsor.clone(),", " system_program.clone(),", ")", ".invoke()?"].join("\n"); export const splCreateAtaCpiCode = ["use spl_associated_token_account::instruction::create_associated_token_account;", "", "let ix = create_associated_token_account(", " &payer.pubkey(),", " &owner.pubkey(),", " &mint,", " &spl_token::id(),", ");", "", "invoke(&ix, &[payer, owner, mint])?;"].join("\n"); export const lightCreateAtaMacroCode = ["#[light_account(", " init,", " associated_token::authority = ata_owner,", " associated_token::mint = ata_mint,", " associated_token::bump = params.ata_bump", ")]", "pub ata: UncheckedAccount<'info>,"].join("\n"); export const splCreateAtaMacroCode = ["#[account(", " init,", " payer = fee_payer,", " associated_token::mint = mint,", " associated_token::authority = owner,", ")]", "pub ata: Account<'info, TokenAccount>,"].join("\n"); export const lightCreateAtaRustCode = ["use light_token::instruction::CreateAssociatedTokenAccount;", "", "let ix = CreateAssociatedTokenAccount::new(", " payer.pubkey(),", " owner.pubkey(),", " mint,", ")", ".instruction()?;"].join("\n"); export const splCreateAtaRustCode = ["use spl_associated_token_account::instruction::create_associated_token_account;", "", "let ix = create_associated_token_account(", " &payer.pubkey(),", " &owner.pubkey(),", " &mint,", " &spl_token::id(),", ");"].join("\n"); export const lightCreateAtaCode = ['import { getOrCreateAtaInterface } from "@lightprotocol/compressed-token/unified";', "", "const ata = await getOrCreateAtaInterface(", " rpc,", " payer,", " mint,", " owner", ");"].join("\n"); export const splCreateAtaCode = ['import { getOrCreateAssociatedTokenAccount } from "@solana/spl-token";', "", "const ata = await getOrCreateAssociatedTokenAccount(", " connection,", " payer,", " 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. Associated Light Token accounts can hold token balances of light, SPL, or Token 2022 mints. 2. Light-ATAs 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 ``` The `createAtaInterface` function creates an associated Light Token account in a single call. Compare to SPL: Find the source code [here](https://github.com/Lightprotocol/light-protocol/blob/main/js/compressed-token/src/v3/actions/create-ata-interface.ts). ### Create Associated Token Account Install packages in your working directory: ```bash theme={null} npm install @lightprotocol/stateless.js@^0.23.0 \ @lightprotocol/compressed-token@^0.23.0 ``` Install the CLI globally: ```bash theme={null} npm install -g @lightprotocol/zk-compression-cli ``` Install packages in your working directory: ```bash theme={null} yarn add @lightprotocol/stateless.js@^0.23.0 \ @lightprotocol/compressed-token@^0.23.0 ``` Install the CLI globally: ```bash theme={null} yarn global add @lightprotocol/zk-compression-cli ``` Install packages in your working directory: ```bash theme={null} pnpm add @lightprotocol/stateless.js@^0.23.0 \ @lightprotocol/compressed-token@^0.23.0 ``` Install the CLI globally: ```bash theme={null} pnpm add -g @lightprotocol/zk-compression-cli ``` Install packages in your working directory: ```bash theme={null} # npm npm install @lightprotocol/stateless.js@^0.23.0 \ @lightprotocol/token-interface@^0.1.2 # yarn yarn add @lightprotocol/stateless.js@^0.23.0 \ @lightprotocol/token-interface@^0.1.2 # pnpm pnpm add @lightprotocol/stateless.js@^0.23.0 \ @lightprotocol/token-interface@^0.1.2 ``` Install the CLI globally: ```bash theme={null} npm install -g @lightprotocol/zk-compression-cli ``` ```bash theme={null} # start local test-validator in a separate terminal light test-validator ``` In the code examples, use `createRpc()` without arguments for localnet. Get an API key from [Helius](https://helius.dev) and add to `.env`: ```bash title=".env" theme={null} API_KEY= ``` In the code examples, use `createRpc(RPC_URL)` with the devnet URL. ```typescript theme={null} import "dotenv/config"; import { Keypair } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { createMintInterface, createAtaInterface, } from "@lightprotocol/compressed-token"; import { homedir } from "os"; import { readFileSync } from "fs"; // devnet: // const RPC_URL = `https://devnet.helius-rpc.com?api-key=${process.env.API_KEY!}`; // const rpc = createRpc(RPC_URL); // localnet: const rpc = createRpc(); const payer = Keypair.fromSecretKey( new Uint8Array( JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8")) ) ); (async function () { const { mint } = await createMintInterface(rpc, payer, payer, null, 9); const owner = Keypair.generate(); const ata = await createAtaInterface(rpc, payer, mint, owner.publicKey); console.log("ATA:", ata.toBase58()); })(); ``` ```typescript theme={null} import "dotenv/config"; import { Keypair, Transaction, sendAndConfirmTransaction, } from "@solana/web3.js"; import { createRpc, LIGHT_TOKEN_PROGRAM_ID } from "@lightprotocol/stateless.js"; import { createMintInterface, createAssociatedTokenAccountInterfaceInstruction, getAssociatedTokenAddressInterface, } from "@lightprotocol/compressed-token"; import { homedir } from "os"; import { readFileSync } from "fs"; // devnet: // const RPC_URL = `https://devnet.helius-rpc.com?api-key=${process.env.API_KEY!}`; // const rpc = createRpc(RPC_URL); // localnet: const rpc = createRpc(); const payer = Keypair.fromSecretKey( new Uint8Array( JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8")) ) ); (async function () { const { mint } = await createMintInterface(rpc, payer, payer, null, 9); const owner = Keypair.generate(); const associatedToken = getAssociatedTokenAddressInterface( mint, owner.publicKey ); const ix = createAssociatedTokenAccountInterfaceInstruction( payer.publicKey, associatedToken, owner.publicKey, mint, LIGHT_TOKEN_PROGRAM_ID ); const tx = new Transaction().add(ix); const signature = await sendAndConfirmTransaction(rpc, tx, [payer]); console.log("ATA:", associatedToken.toBase58()); console.log("Tx:", signature); })(); ``` ```typescript theme={null} import { Keypair, Transaction, sendAndConfirmTransaction } from "@solana/web3.js"; import { createRpc, LIGHT_TOKEN_PROGRAM_ID } from "@lightprotocol/stateless.js"; import { createAtaInstruction, getAtaAddress } from "@lightprotocol/token-interface"; const rpc = createRpc(); const payer = Keypair.fromSecretKey(/* ... */); const mint = /* existing mint public key */; const owner = Keypair.generate(); const associatedToken = getAtaAddress({ mint, owner: owner.publicKey }); const ix = createAtaInstruction({ payer: payer.publicKey, owner: owner.publicKey, mint, programId: LIGHT_TOKEN_PROGRAM_ID, }); const tx = new Transaction().add(ix); const signature = await sendAndConfirmTransaction(rpc, tx, [payer]); console.log("ATA:", associatedToken.toBase58()); console.log("Tx:", signature); ``` {`--- description: Create rent-free associated token account allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Create rent-free associated token account Context: - Guide: https://zkcompression.com/light-token/cookbook/create-ata - 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: createAssociatedTokenAccount() → Light Token: createAtaInterface() ### 1. Index project - Grep \`@solana/spl-token|Connection|Keypair|createAssociatedTokenAccount|createAtaInterface\` across src/ - Glob \`**/*.ts\` for project structure - Identify: RPC setup, existing ATA logic, entry point for ATA creation - 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 ATA 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`} ```text theme={null} --- description: Create rent-free associated token account allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Create rent-free associated token account Context: - Guide: https://zkcompression.com/light-token/cookbook/create-ata - 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: createAssociatedTokenAccount() → Light Token: createAtaInterface() ### 1. Index project - Grep `@solana/spl-token|Connection|Keypair|createAssociatedTokenAccount|createAtaInterface` across src/ - Glob `**/*.ts` for project structure - Identify: RPC setup, existing ATA logic, entry point for ATA creation - 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 ATA 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 ``` `CreateAssociatedTokenAccount` creates an on-chain ATA 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 ATA Find the source code [here](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_ata.rs). ```rust theme={null} use light_token_client::actions::{CreateAta, CreateMint}; use rust_client::setup_rpc_and_payer; use solana_sdk::signer::Signer; #[tokio::main] async fn main() -> Result<(), Box> { let (mut rpc, payer) = setup_rpc_and_payer().await; // Create mint let (_signature, mint) = CreateMint { decimals: 9, freeze_authority: None, token_metadata: None, seed: None, } .execute(&mut rpc, &payer, &payer) .await?; // Create associated token account let (_signature, associated_token_account) = CreateAta { mint, owner: payer.pubkey(), idempotent: true, } .execute(&mut rpc, &payer) .await?; println!("Associated token account: {associated_token_account}"); Ok(()) } ``` ```rust theme={null} use light_client::rpc::Rpc; use light_token::instruction::{get_associated_token_address, CreateAssociatedTokenAccount}; use rust_client::{setup_spl_mint_context, SplMintContext}; use solana_sdk::{signature::Keypair, signer::Signer}; #[tokio::main] async fn main() -> Result<(), Box> { // You can use Light, SPL, or Token-2022 mints to create a Light associated token account. let SplMintContext { mut rpc, payer, mint, } = setup_spl_mint_context().await; let owner = Keypair::new(); let create_associated_token_account_instruction = CreateAssociatedTokenAccount::new(payer.pubkey(), owner.pubkey(), mint).instruction()?; let sig = rpc .create_and_send_transaction(&[create_associated_token_account_instruction], &payer.pubkey(), &[&payer]) .await?; let associated_token_account = get_associated_token_address(&owner.pubkey(), &mint); let data = rpc.get_account(associated_token_account).await?; println!("Associated token account: {associated_token_account} exists: {} Tx: {sig}", data.is_some()); Ok(()) } ``` {`--- description: Create rent-free associated token account allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Create rent-free associated token account Context: - Guide: https://zkcompression.com/light-token/cookbook/create-ata - 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_associated_token_account::create → Light Token: CreateAta ### 1. Index project - Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|CreateAta|create_associated_token_account\` across src/ - Glob \`**/*.rs\` for project structure - Identify: RPC setup, existing token ops, entry point for ATA 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 ATA 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 rent-free associated token account allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Create rent-free associated token account Context: - Guide: https://zkcompression.com/light-token/cookbook/create-ata - 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_associated_token_account::create → Light Token: CreateAta ### 1. Index project - Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|CreateAta|create_associated_token_account` across src/ - Glob `**/*.rs` for project structure - Identify: RPC setup, existing token ops, entry point for ATA 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 ATA 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 1. Pass ATA accounts and call `.rent_free()` with rent config accounts. 2. Use `invoke` or `invoke_signed`: * When the `payer` is an external wallet, use `invoke`. * When the `payer` is a PDA, use `invoke_signed` with its seeds. The light-ATA address is derived from `[owner, light_token_program_id, mint]`. Unlike Light Token accounts, owner and mint are passed as accounts, not in instruction data. ```rust theme={null} use light_token::instruction::CreateAssociatedAccountCpi; CreateAssociatedAccountCpi { payer: payer.clone(), owner: owner.clone(), mint: mint.clone(), ata: associated_token_account.clone(), bump, } .rent_free( compressible_config.clone(), rent_sponsor.clone(), system_program.clone(), ) .invoke() ``` ```rust theme={null} use light_token::instruction::CreateAssociatedAccountCpi; let signer_seeds: &[&[u8]] = &[ATA_SEED, &[authority_bump]]; CreateAssociatedAccountCpi { payer: payer.clone(), owner: owner.clone(), mint: mint.clone(), ata: associated_token_account.clone(), bump, } .rent_free( compressible_config.clone(), rent_sponsor.clone(), system_program.clone(), ) .invoke_signed(&[signer_seeds]) ```
Owner - * The wallet that will own this light-ATA.
* Used to derive the light-ATA address deterministically.
Mint - * The SPL or light-mint token mint.
* Used to derive the light-ATA address deterministically.
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-ATA Account mutable * The light-ATA being created.
* Address is derived from `[owner, light_token_program_id, mint]`.
System Program - Solana System Program. Required for CPI to create the on-chain account.
Bump u8 The PDA bump seed for the light-ATA address derivation.
Idempotent bool * When `true`, silently succeeds if account already exists.
* When `false`, fails if account already exists.
# Full Code Example View the [source code](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_ata.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-associated-token-account) with shared test utilities. ```rust lib.rs theme={null} #![allow(unexpected_cfgs, deprecated)] use anchor_lang::prelude::*; use light_token::instruction::CreateAssociatedAccountCpi; declare_id!("35MukgdfpNUbPMhTmEk63ECV8vjgpNVFRH9nP8ovMN58"); #[program] pub mod light_token_anchor_create_associated_token_account { use super::*; pub fn create_associated_token_account(ctx: Context, idempotent: bool) -> Result<()> { let cpi = CreateAssociatedAccountCpi { payer: ctx.accounts.payer.to_account_info(), owner: ctx.accounts.owner.to_account_info(), mint: ctx.accounts.mint.to_account_info(), ata: ctx.accounts.associated_token_account.to_account_info(), }; if idempotent { cpi.idempotent().rent_free( ctx.accounts.compressible_config.to_account_info(), ctx.accounts.rent_sponsor.to_account_info(), ctx.accounts.system_program.to_account_info(), ) } else { cpi.rent_free( ctx.accounts.compressible_config.to_account_info(), ctx.accounts.rent_sponsor.to_account_info(), ctx.accounts.system_program.to_account_info(), ) } .invoke()?; Ok(()) } } #[derive(Accounts)] pub struct CreateAssociatedTokenAccountAccounts<'info> { /// CHECK: Light token program for CPI pub light_token_program: AccountInfo<'info>, /// CHECK: Validated by light-token CPI pub owner: AccountInfo<'info>, /// CHECK: Validated by light-token CPI pub mint: AccountInfo<'info>, #[account(mut)] pub payer: Signer<'info>, /// CHECK: Validated by light-token CPI #[account(mut)] pub associated_token_account: AccountInfo<'info>, pub system_program: Program<'info, System>, /// CHECK: Validated by light-token CPI pub compressible_config: AccountInfo<'info>, /// CHECK: Validated by light-token CPI #[account(mut)] pub rent_sponsor: 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_associated_token_account::{accounts, instruction::CreateAssociatedTokenAccount, ID}; use light_token::instruction::{ CreateMint, CreateMintParams, config_pda, derive_mint_compressed_address, derive_token_ata, 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_associated_token_account() { let config = ProgramTestConfig::new_v2(true, Some(vec![("light_token_anchor_create_associated_token_account", ID)])); let mut rpc = LightProgramTest::new(config).await.unwrap(); let payer = rpc.get_payer().insecure_clone(); 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 associated token account. // Derive associated token account address and bump let associated_token_account = derive_token_ata(&payer.pubkey(), &mint_pda); // Call the anchor program to create associated token account let compressible_config = config_pda(); let rent_sponsor = rent_sponsor_pda(); let ix = Instruction { program_id: ID, accounts: accounts::CreateAssociatedTokenAccountAccounts { light_token_program: LIGHT_TOKEN_PROGRAM_ID, owner: payer.pubkey(), mint: mint_pda, payer: payer.pubkey(), associated_token_account: associated_token_account, system_program: system_program::ID, compressible_config, rent_sponsor, } .to_account_metas(Some(true)), data: CreateAssociatedTokenAccount { idempotent: false, } .data(), }; let sig = rpc.create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer]) .await .unwrap(); println!("Tx: {}", sig); } ``` {`--- description: Add create-ATA 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-ATA CPI to an Anchor program Context: - Guide: https://zkcompression.com/light-token/cookbook/create-ata - 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 (CreateAssociatedAccountCpi) - Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-associated-token-account Key CPI struct: \`light_token::instruction::CreateAssociatedAccountCpi\` ### 1. Index project - Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|ata|associated|owner|mint\` across src/ - Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure - Identify: program ID, existing instructions, account structs, ATA derivation - 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: ATA 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-ATA to existing program, new program from scratch, migrate from SPL create_associated_token_account) - 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 CreateAssociatedAccountCpi → .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-ATA 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-ATA CPI to an Anchor program Context: - Guide: https://zkcompression.com/light-token/cookbook/create-ata - 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 (CreateAssociatedAccountCpi) - Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-associated-token-account Key CPI struct: `light_token::instruction::CreateAssociatedAccountCpi` ### 1. Index project - Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|ata|associated|owner|mint` across src/ - Glob `**/*.rs` and `**/Cargo.toml` for project structure - Identify: program ID, existing instructions, account structs, ATA derivation - 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: ATA 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-ATA to existing program, new program from scratch, migrate from SPL create_associated_token_account) - 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 CreateAssociatedAccountCpi → .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_ata { use super::*; pub fn create_ata<'info>( ctx: Context<'_, '_, '_, 'info, CreateAta<'info>>, params: CreateAtaParams, ) -> 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)] #[light_account( init, associated_token::authority = ata_owner, associated_token::mint = ata_mint, associated_token::bump = params.ata_bump )] pub ata: UncheckedAccount<'info>, ``` # Full code example View the [source code](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_ata.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-associated-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, LIGHT_TOKEN_PROGRAM_ID, }; use light_token::instruction::{LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR}; declare_id!("CLsn9MTFv97oMTsujRoQAw1u2rSm2HnKtGuWUbbc8Jfn"); pub const LIGHT_CPI_SIGNER: CpiSigner = derive_light_cpi_signer!("CLsn9MTFv97oMTsujRoQAw1u2rSm2HnKtGuWUbbc8Jfn"); #[light_program] #[program] pub mod light_token_macro_create_associated_token_account { use super::*; #[allow(unused_variables)] pub fn create_associated_token_account<'info>( ctx: Context<'_, '_, '_, 'info, CreateAssociatedTokenAccount<'info>>, params: CreateAssociatedTokenAccountParams, ) -> Result<()> { Ok(()) } } #[derive(AnchorSerialize, AnchorDeserialize, Clone)] pub struct CreateAssociatedTokenAccountParams { pub create_accounts_proof: CreateAccountsProof, } #[derive(Accounts, LightAccounts)] #[instruction(params: CreateAssociatedTokenAccountParams)] pub struct CreateAssociatedTokenAccount<'info> { #[account(mut)] pub fee_payer: Signer<'info>, /// CHECK: Token mint for the associated token account pub associated_token_account_mint: AccountInfo<'info>, /// CHECK: Owner of the associated token account pub associated_token_account_owner: AccountInfo<'info>, /// CHECK: Validated by light_account macro #[account(mut)] #[light_account(init, associated_token::authority = associated_token_account_owner, associated_token::mint = associated_token_account_mint)] pub associated_token_account: 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 program for CPI #[account(address = LIGHT_TOKEN_PROGRAM_ID.into())] pub light_token_program: AccountInfo<'info>, pub system_program: Program<'info, System>, } ``` ```rust test.rs theme={null} use anchor_lang::{InstructionData, ToAccountMetas}; use light_client::interface::{get_create_accounts_proof, InitializeRentFreeConfig}; use light_program_test::{ program_test::{setup_mock_program_data, LightProgramTest}, ProgramTestConfig, Rpc, }; use light_account::{derive_rent_sponsor_pda, LIGHT_TOKEN_PROGRAM_ID}; use light_token::instruction::{LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR}; use solana_instruction::Instruction; use solana_signer::Signer; use test_utils::create_mint; /// Test creating a Light Protocol associated token account using the macro. #[tokio::test] async fn test_create_associated_token_account() { use light_token_macro_create_associated_token_account::CreateAssociatedTokenAccountParams; let program_id = light_token_macro_create_associated_token_account::ID; let mut config = ProgramTestConfig::new_v2(true, Some(vec![("light_token_macro_create_associated_token_account", program_id)])); config = config.with_light_protocol_events(); let mut rpc = LightProgramTest::new(config).await.unwrap(); let payer = rpc.get_payer().insecure_clone(); let program_data_pda = setup_mock_program_data(&mut rpc, &payer, &program_id); let (rent_sponsor, _) = derive_rent_sponsor_pda(&program_id); let (init_config_ix, _config_pda) = InitializeRentFreeConfig::new( &program_id, &payer.pubkey(), &program_data_pda, rent_sponsor, payer.pubkey(), ) .build(); rpc.create_and_send_transaction(&[init_config_ix], &payer.pubkey(), &[&payer]) .await .expect("Initialize config should succeed"); let (mint, _mint_seed) = create_mint(&mut rpc, &payer, None).await; // The associated token account owner will be the payer let associated_token_account_owner = payer.pubkey(); // Derive the associated token account address using Light Token SDK's derivation let associated_token_account = light_token::instruction::derive_token_ata(&associated_token_account_owner, &mint); // Get proof (no PDA accounts for associated token account-only instruction) let proof_result = get_create_accounts_proof(&rpc, &program_id, vec![]) .await .unwrap(); // Build instruction let accounts = light_token_macro_create_associated_token_account::accounts::CreateAssociatedTokenAccount { fee_payer: payer.pubkey(), associated_token_account_mint: mint, associated_token_account_owner, associated_token_account, light_token_config: LIGHT_TOKEN_CONFIG, light_token_rent_sponsor: LIGHT_TOKEN_RENT_SPONSOR, light_token_program: LIGHT_TOKEN_PROGRAM_ID.into(), system_program: solana_sdk::system_program::ID, }; let instruction_data = light_token_macro_create_associated_token_account::instruction::CreateAssociatedTokenAccount { params: CreateAssociatedTokenAccountParams { create_accounts_proof: proof_result.create_accounts_proof, }, }; let instruction = Instruction { program_id, accounts: [ accounts.to_account_metas(None), proof_result.remaining_accounts, ] .concat(), data: instruction_data.data(), }; rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer]) .await .expect("CreateAssociatedTokenAccount instruction should succeed"); // Verify associated token account exists on-chain let associated_token_account_data = rpc .get_account(associated_token_account) .await .unwrap() .expect("Associated token account should exist on-chain"); // Parse and verify token data use light_token_interface::state::Token; let token: Token = borsh::BorshDeserialize::deserialize(&mut &associated_token_account_data.data[..]) .expect("Failed to deserialize Token"); // Verify owner assert_eq!(token.owner, associated_token_account_owner.to_bytes(), "Associated token account owner should match"); // Verify mint assert_eq!(token.mint, mint.to_bytes(), "Associated token account mint should match"); // Verify initial amount is 0 assert_eq!(token.amount, 0, "Associated token account amount should be 0 initially"); } ``` {`--- description: Create a rent-free ATA 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 ATA with Anchor macros Context: - Guide: https://zkcompression.com/light-token/cookbook/create-ata - 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-associated-token-account Key macros: \`#[light_program]\`, \`LightAccounts\`, \`#[light_account(init, associated_token::...)]\` ### 1. Index project - Grep \`#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|ata|associated\` across src/ - Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure - Identify: existing program module, account structs, ATA 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 ATA to existing program, migrate from SPL create_associated_token_account) - 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, associated_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 ATA 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 ATA with Anchor macros Context: - Guide: https://zkcompression.com/light-token/cookbook/create-ata - 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-associated-token-account Key macros: `#[light_program]`, `LightAccounts`, `#[light_account(init, associated_token::...)]` ### 1. Index project - Grep `#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|ata|associated` across src/ - Glob `**/*.rs` and `**/Cargo.toml` for project structure - Identify: existing program module, account structs, ATA 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 ATA to existing program, migrate from SPL create_associated_token_account) - 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, associated_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)