> ## 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. # Mint to Light Token Accounts > Client and program guide to mint tokens to a account. Includes step-by-step implementation and full code examples. export const lightMintToRustCode = ["use light_token::instruction::MintTo;", "", "let ix = MintTo {", " mint,", " destination,", " amount,", " authority: payer.pubkey(),", " max_top_up: None,", " fee_payer: None,", "}", ".instruction()?;"].join("\n"); export const splMintToRustCode = ["use spl_token::instruction::mint_to;", "", "let ix = mint_to(", " &spl_token::id(),", " &mint,", " &destination,", " &mint_authority,", " &[],", " amount,", ")?;"].join("\n"); export const lightMintToCode = ['import { mintToInterface } from "@lightprotocol/compressed-token";', "", "const tx = await mintToInterface(", " rpc,", " payer,", " mint,", " destination,", " mintAuthority,", " amount", ");"].join("\n"); export const splMintToCode = ['import { mintTo } from "@solana/spl-token";', "", "const tx = await mintTo(", " connection,", " payer,", " mint,", " destination,", " mintAuthority,", " amount", ");"].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 =>
)}
; }; export const CompressibleRentCalculator = () => { const [hours, setHours] = useState(24); const [lamportsPerWrite, setLamportsPerWrite] = useState(766); const [showCustomHours, setShowCustomHours] = useState(false); const [showCustomLamports, setShowCustomLamports] = useState(false); const [showFormula, setShowFormula] = useState(false); const DATA_LEN = 272; const BASE_RENT = 128; const LAMPORTS_PER_BYTE_PER_EPOCH = 1; const MINUTES_PER_EPOCH = 90; const COMPRESSION_COST = 11000; const LAMPORTS_PER_SOL = 1_000_000_000; const HOURS_MAX = 36; const LAMPORTS_MAX = 6400; const numEpochs = Math.ceil(hours * 60 / MINUTES_PER_EPOCH); const rentPerEpoch = BASE_RENT + DATA_LEN * LAMPORTS_PER_BYTE_PER_EPOCH; const totalPrepaidRent = rentPerEpoch * numEpochs; const totalCreationCost = totalPrepaidRent + COMPRESSION_COST; const handleHoursChange = value => { const num = Math.max(3, Math.min(168, Number.parseInt(value) || 3)); setHours(num); }; const handleLamportsChange = value => { const num = Math.max(0, Math.min(100000, Number.parseInt(value) || 0)); setLamportsPerWrite(num); }; const hoursPresets = [24]; const lamportsPresets = [766]; const SliderMarkers = ({max, step}) => { const marks = []; for (let i = step; i < max; i += step) { const percent = i / max * 100; marks.push(
); } return <>{marks}; }; return
{}
Prepaid Epochs in Hours
{hoursPresets.map(h => )} {showCustomHours ? handleHoursChange(e.target.value)} className="w-16 px-2 py-1 text-right text-xs font-mono font-medium bg-blue-500/10 dark:bg-blue-500/20 border border-blue-500/50 rounded-lg backdrop-blur-sm focus:outline-none focus:ring-2 focus:ring-blue-500/50" autoFocus /> : }
≈ {(hours * 60 / MINUTES_PER_EPOCH).toFixed(1)} epochs / {hours.toFixed(1)}h
{ setHours(Number.parseInt(e.target.value)); setShowCustomHours(false); }} className="relative w-full h-1.5 bg-black/[0.03] dark:bg-white/20 rounded-full appearance-none cursor-pointer backdrop-blur-sm z-10" />
{}
Lamports per Write
{lamportsPresets.map(l => )} {showCustomLamports ? handleLamportsChange(e.target.value)} className="w-20 px-2 py-1 text-right text-xs font-mono font-medium bg-blue-500/10 dark:bg-blue-500/20 border border-blue-500/50 rounded-lg backdrop-blur-sm focus:outline-none focus:ring-2 focus:ring-blue-500/50" autoFocus /> : }
≈ {(lamportsPerWrite / rentPerEpoch).toFixed(1)} epochs /{" "} {(lamportsPerWrite / rentPerEpoch * MINUTES_PER_EPOCH / 60).toFixed(1)}h
{ setLamportsPerWrite(Number.parseInt(e.target.value)); setShowCustomLamports(false); }} className="relative w-full h-1.5 bg-black/[0.03] dark:bg-white/20 rounded-full appearance-none cursor-pointer backdrop-blur-sm z-10" />
{}
Total Creation Cost
{totalCreationCost.toLocaleString()}
lamports
≈ {(totalCreationCost / LAMPORTS_PER_SOL).toFixed(6)} SOL
Top-up Amount
{lamportsPerWrite.toLocaleString()}
lamports
≈ {(lamportsPerWrite / LAMPORTS_PER_SOL).toFixed(6)} SOL
{}
{showFormula &&
Total cost for {DATA_LEN}-byte light-token account:
total_creation_cost = prepaid_rent + compression_cost

rent_per_epoch = base_rent + (data_len × lamports_per_byte_per_epoch)
rent_per_epoch = {BASE_RENT} + ({DATA_LEN} × {LAMPORTS_PER_BYTE_PER_EPOCH}) ={" "} {rentPerEpoch} lamports
compression_cost = {COMPRESSION_COST.toLocaleString()} lamports
}
; }; *** 1. Mint To creates new tokens of a mint and deposits them to a specified token account. 2. Before we can mint any tokens, we need an initialized mint account (SPL, Token 2022 or Light) for which we hold the mint authority. 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 ``` `mintToInterface` mints tokens to token accounts in a single call. The function auto-detects the token program (SPL, Token 2022, or Light) from the mint address. Compare to SPL: Find the source code [here](https://github.com/Lightprotocol/light-protocol/blob/main/js/compressed-token/src/v3/actions/mint-to-interface.ts). ### Mint Tokens to Light 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, mintToInterface, 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 recipient = Keypair.generate(); await createAtaInterface(rpc, payer, mint, recipient.publicKey); const destination = getAssociatedTokenAddressInterface( mint, recipient.publicKey ); const tx = await mintToInterface( rpc, payer, mint, destination, payer, 1_000_000_000 ); console.log("Tx:", tx); })(); ``` ```typescript theme={null} import "dotenv/config"; import { Keypair, ComputeBudgetProgram, Transaction, sendAndConfirmTransaction, } from "@solana/web3.js"; import { createRpc, bn, DerivationMode } from "@lightprotocol/stateless.js"; import { createMintInterface, createAtaInterface, createMintToInterfaceInstruction, getMintInterface, 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 recipient = Keypair.generate(); await createAtaInterface(rpc, payer, mint, recipient.publicKey); const destination = getAssociatedTokenAddressInterface( mint, recipient.publicKey ); const mintInterface = await getMintInterface(rpc, mint); let validityProof; if (mintInterface.merkleContext) { validityProof = await rpc.getValidityProofV2( [ { hash: bn(mintInterface.merkleContext.hash), leafIndex: mintInterface.merkleContext.leafIndex, treeInfo: mintInterface.merkleContext.treeInfo, proveByIndex: mintInterface.merkleContext.proveByIndex, }, ], [], DerivationMode.compressible ); } const ix = createMintToInterfaceInstruction( mintInterface, destination, payer.publicKey, payer.publicKey, 1_000_000_000, validityProof ); const tx = new Transaction().add( ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 }), ix ); const signature = await sendAndConfirmTransaction(rpc, tx, [payer]); 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, createMintToInstruction, getAtaAddress, } from "@lightprotocol/token-interface"; const rpc = createRpc(); const payer = Keypair.fromSecretKey(/* ... */); const mint = /* existing mint public key */; const recipient = Keypair.generate(); const destination = getAtaAddress({ mint, owner: recipient.publicKey }); const createAtaIx = createAtaInstruction({ payer: payer.publicKey, owner: recipient.publicKey, mint, programId: LIGHT_TOKEN_PROGRAM_ID, }); const mintToIx = createMintToInstruction({ mint, destination, authority: payer.publicKey, payer: payer.publicKey, amount: 1_000_000_000n, tokenProgramId: LIGHT_TOKEN_PROGRAM_ID, }); const tx = new Transaction().add(createAtaIx, mintToIx); const signature = await sendAndConfirmTransaction(rpc, tx, [payer]); console.log("Tx:", signature); ``` {`--- description: Mint tokens to Light Token account allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Mint tokens to Light Token account Context: - Guide: https://zkcompression.com/light-token/cookbook/mint-to - 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: mintTo() → Light Token: mintToInterface() ### 1. Index project - Grep \`@solana/spl-token|Connection|Keypair|mintTo|mintToInterface\` across src/ - Glob \`**/*.ts\` for project structure - Identify: RPC setup, existing mint logic, entry point for minting - 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 mint 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: Mint tokens to Light Token account allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Mint tokens to Light Token account Context: - Guide: https://zkcompression.com/light-token/cookbook/mint-to - 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: mintTo() → Light Token: mintToInterface() ### 1. Index project - Grep `@solana/spl-token|Connection|Keypair|mintTo|mintToInterface` across src/ - Glob `**/*.ts` for project structure - Identify: RPC setup, existing mint logic, entry point for minting - 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 mint 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 ``` Use `MintTo` to mint tokens to a Light Token account. 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(()) } ``` ### Mint to Light Token Accounts Find the source code [here](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/mint_to.rs). ```rust theme={null} use borsh::BorshDeserialize; use light_client::rpc::Rpc; use light_token_client::actions::{CreateAta, CreateMint, MintTo}; 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 (payer is also mint authority) 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?; // Mint tokens (payer is mint authority) let sig = MintTo { mint, destination: associated_token_account, amount: 1_000_000, } .execute(&mut rpc, &payer, &payer) .await?; let data = rpc.get_account(associated_token_account).await?.ok_or("Account not found")?; let token = light_token_interface::state::Token::deserialize(&mut &data.data[..])?; println!("Balance: {} Tx: {sig}", token.amount); Ok(()) } ``` ```rust theme={null} use borsh::BorshDeserialize; use light_client::rpc::Rpc; use light_token::instruction::MintTo; use rust_client::{setup_empty_associated_token_account, SetupContext}; use solana_sdk::signer::Signer; #[tokio::main] async fn main() -> Result<(), Box> { // Setup creates mint and empty associated token account let SetupContext { mut rpc, payer, mint, associated_token_account, .. } = setup_empty_associated_token_account().await; let mint_amount = 1_000_000_000u64; let mint_to_instruction = MintTo { mint, destination: associated_token_account, amount: mint_amount, authority: payer.pubkey(), fee_payer: payer.pubkey(), } .instruction()?; let sig = rpc .create_and_send_transaction(&[mint_to_instruction], &payer.pubkey(), &[&payer]) .await?; let data = rpc.get_account(associated_token_account).await?.ok_or("Account not found")?; let token = light_token_interface::state::Token::deserialize(&mut &data.data[..])?; println!("Balance: {} Tx: {sig}", token.amount); Ok(()) } ``` {`--- description: Mint tokens to Light Token account allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Mint tokens to Light Token account Context: - Guide: https://zkcompression.com/light-token/cookbook/mint-to - 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::mint_to → Light Token: MintTo ### 1. Index project - Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|MintTo|mint_to\` across src/ - Glob \`**/*.rs\` for project structure - Identify: RPC setup, existing token ops, entry point for minting - 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 mint 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: Mint tokens to Light Token account allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Mint tokens to Light Token account Context: - Guide: https://zkcompression.com/light-token/cookbook/mint-to - 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::mint_to → Light Token: MintTo ### 1. Index project - Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|MintTo|mint_to` across src/ - Glob `**/*.rs` for project structure - Identify: RPC setup, existing token ops, entry point for minting - 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 mint 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 ``` 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::MintToCpi; MintToCpi { mint: mint.clone(), destination: destination.clone(), amount, authority: authority.clone(), system_program: system_program.clone(), fee_payer: None, max_top_up: None, } .invoke() ``` ```rust theme={null} use light_token::instruction::MintToCpi; let signer_seeds: &[&[u8]] = &[MINT_AUTHORITY_SEED, &[bump]]; MintToCpi { mint: mint.clone(), destination: destination.clone(), amount, authority: authority.clone(), system_program: system_program.clone(), fee_payer: None, max_top_up: None, } .invoke_signed(&[signer_seeds]) ``` `fee_payer` and `max_top_up` are optional fields to customize rent top-ups. Set to `None` to use defaults. # Full Code Example View the [source code](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/mint_to.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/mint-to) with shared test utilities. ```rust lib.rs theme={null} #![allow(unexpected_cfgs, deprecated)] use anchor_lang::prelude::*; use light_token::instruction::MintToCpi; declare_id!("8bXEVmHLtAVqDLJp1dYWAZ61WQmqQKoTQ8LpPbRoUDCp"); #[program] pub mod light_token_anchor_mint_to { use super::*; pub fn mint_to(ctx: Context, amount: u64) -> Result<()> { MintToCpi { mint: ctx.accounts.mint.to_account_info(), destination: ctx.accounts.destination.to_account_info(), amount, authority: ctx.accounts.authority.to_account_info(), system_program: ctx.accounts.system_program.to_account_info(), fee_payer: ctx.accounts.fee_payer.to_account_info(), } .invoke()?; Ok(()) } } #[derive(Accounts)] pub struct MintToAccounts<'info> { /// CHECK: Light token program for CPI pub light_token_program: AccountInfo<'info>, /// CHECK: Validated by light-token CPI #[account(mut)] pub mint: AccountInfo<'info>, /// CHECK: Validated by light-token CPI #[account(mut)] pub destination: AccountInfo<'info>, pub authority: Signer<'info>, #[account(mut)] pub fee_payer: Signer<'info>, pub system_program: Program<'info, System>, } ``` ```rust test.rs theme={null} use anchor_lang::{InstructionData, ToAccountMetas}; use light_program_test::Rpc; use light_token::instruction::LIGHT_TOKEN_PROGRAM_ID; use light_token_anchor_mint_to::{accounts, instruction::MintTo, ID}; use anchor_lang::system_program; use solana_sdk::{instruction::Instruction, signer::Signer}; use test_utils::setup_test_env; #[tokio::test(flavor = "multi_thread")] async fn test_mint_to() { let mut env = setup_test_env("light_token_anchor_mint_to", ID).await; // No mint_tokens call - the test IS minting tokens via CPI. let amount = 1_000_000u64; let ix = Instruction { program_id: ID, accounts: accounts::MintToAccounts { light_token_program: LIGHT_TOKEN_PROGRAM_ID, mint: env.mint_pda, destination: env.associated_token_account, authority: env.payer.pubkey(), fee_payer: env.payer.pubkey(), system_program: system_program::ID, } .to_account_metas(Some(true)), data: MintTo { amount }.data(), }; env.rpc .create_and_send_transaction(&[ix], &env.payer.pubkey(), &[&env.payer]) .await .unwrap(); // Verify the account exists and has data let associated_token_account_data = env.rpc.get_account(env.associated_token_account).await.unwrap().unwrap(); assert!(!associated_token_account_data.data.is_empty(), "Associated token account should have data"); } ``` {`--- description: Add mint-to 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 mint-to CPI to an Anchor program Context: - Guide: https://zkcompression.com/light-token/cookbook/mint-to - 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 (MintToCpi) - Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/mint-to Key CPI struct: \`light_token::instruction::MintToCpi\` ### 1. Index project - Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|mint|supply|amount\` across src/ - Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure - Identify: program ID, existing instructions, account structs, mint accounts - 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 Program tab CPI code samples - WebFetch skill.md — check for a dedicated skill and resources matching this task - TaskCreate one todo per phase below to track progress ### 3. Clarify intention - AskUserQuestion: what is the goal? (add mint-to to existing program, new program from scratch, migrate from SPL mint_to) - AskUserQuestion: should the authority 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 MintToCpi struct → call .invoke() or .invoke_signed() - If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) - Present the plan to the user for approval before proceeding ### 5. Implement - Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` - Follow the guide and the approved plan - Write/Edit to create or modify files - TaskUpdate to mark each step done ### 6. Verify - Bash \`anchor build\` - Bash \`anchor test\` if tests exist - TaskUpdate to mark complete ### Tools - mcp__zkcompression__SearchLightProtocol("") 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 mint-to 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 mint-to CPI to an Anchor program Context: - Guide: https://zkcompression.com/light-token/cookbook/mint-to - 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 (MintToCpi) - Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/mint-to Key CPI struct: `light_token::instruction::MintToCpi` ### 1. Index project - Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|mint|supply|amount` across src/ - Glob `**/*.rs` and `**/Cargo.toml` for project structure - Identify: program ID, existing instructions, account structs, mint accounts - 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 Program tab CPI code samples - WebFetch skill.md — check for a dedicated skill and resources matching this task - TaskCreate one todo per phase below to track progress ### 3. Clarify intention - AskUserQuestion: what is the goal? (add mint-to to existing program, new program from scratch, migrate from SPL mint_to) - AskUserQuestion: should the authority 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 MintToCpi struct → call .invoke() or .invoke_signed() - If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) - Present the plan to the user for approval before proceeding ### 5. Implement - Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` - Follow the guide and the approved plan - Write/Edit to create or modify files - TaskUpdate to mark each step done ### 6. Verify - Bash `anchor build` - Bash `anchor test` if tests exist - TaskUpdate to mark complete ### Tools - mcp__zkcompression__SearchLightProtocol("") 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)