> ## 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 Mint Account with Token Metadata > Create a Light mint with token metadata, or create SPL and Token 2022 mints with interface PDA for interoperability. export const lightCreateMintMetadataCpiCode = ["use light_token::instruction::CreateMintCpi;", "", "let extensions = Some(vec![", " ExtensionInstructionData::TokenMetadata(", " TokenMetadataInstructionData {", " update_authority: Some(authority.key.to_bytes().into()),", ' name: b"Example Token".to_vec(),', ' symbol: b"EXT".to_vec(),', ' uri: b"https://example.com/metadata.json".to_vec(),', " additional_metadata: None,", " },", " ),", "]);", "", "CreateMintCpi {", " mint_seed: mint_seed.clone(),", " authority: authority.clone(),", " payer: payer.clone(),", " address_tree: address_tree.clone(),", " output_queue: output_queue.clone(),", " compressible_config: compressible_config.clone(),", " mint: mint.clone(),", " rent_sponsor: rent_sponsor.clone(),", " system_accounts,", " cpi_context: None,", " cpi_context_account: None,", " params, // includes extensions", "}", ".invoke()?"].join("\n"); export const splCreateMintMetadataCpiCode = ["use spl_token_2022::instruction::initialize_mint;", "use spl_token_metadata_interface::instruction::initialize as init_metadata;", "", "let ix_mint = initialize_mint(", " &spl_token_2022::id(),", " &mint.pubkey(),", " &mint_authority,", " Some(&freeze_authority),", " decimals,", ")?;", "invoke(&ix_mint, &[mint.clone(), rent_sysvar.clone()])?;", "", "let ix_meta = init_metadata(", " &spl_token_2022::id(),", " &mint.pubkey(),", " &update_authority,", " &mint.pubkey(),", " &mint_authority,", " name, symbol, uri,", ")?;", "invoke(&ix_meta, &[mint, update_auth])?;"].join("\n"); export const lightCreateMintCpiCode = ["use light_token::instruction::CreateMintCpi;", "", "CreateMintCpi {", " mint_seed: mint_seed.clone(),", " authority: authority.clone(),", " payer: payer.clone(),", " address_tree: address_tree.clone(),", " output_queue: output_queue.clone(),", " compressible_config: compressible_config.clone(),", " mint: mint.clone(),", " rent_sponsor: rent_sponsor.clone(),", " system_accounts,", " cpi_context: None,", " cpi_context_account: None,", " params,", "}", ".invoke()?"].join("\n"); export const splCreateMintCpiCode = ["use spl_token::instruction::initialize_mint;", "", "let ix = initialize_mint(", " &spl_token::id(),", " &mint.pubkey(),", " &mint_authority,", " Some(&freeze_authority),", " decimals,", ")?;", "", "invoke(&ix, &[mint, rent_sysvar])?;"].join("\n"); export const lightCreateMintMetadataMacroCode = ["#[light_account(init,", " mint::signer = mint_signer,", " mint::authority = fee_payer,", " mint::decimals = 9,", " mint::seeds = &[MINT_SIGNER_SEED, self.authority.to_account_info().key.as_ref()],", " mint::bump = params.mint_signer_bump,", " mint::name = params.name.clone(),", " mint::symbol = params.symbol.clone(),", " mint::uri = params.uri.clone(),", " mint::update_authority = authority", ")]", "pub mint: UncheckedAccount<'info>,"].join("\n"); export const splCreateMintMetadataMacroCode = ["#[account(", " init,", " payer = fee_payer,", " mint::decimals = 9,", " mint::authority = fee_payer,", " extensions::metadata_pointer::authority = fee_payer,", " extensions::metadata_pointer::metadata_address = mint_account,", ")]", "pub mint_account: InterfaceAccount<'info, Mint>,", "", "// Metadata requires a separate CPI:", "token_metadata_initialize(", " cpi_ctx,", " params.name,", " params.symbol,", " params.uri,", ")?;"].join("\n"); export const lightCreateMintMacroCode = ["#[light_account(init,", " mint::signer = mint_signer,", " mint::authority = fee_payer,", " mint::decimals = 9,", " mint::seeds = &[MINT_SIGNER_SEED, self.authority.to_account_info().key.as_ref()],", " mint::bump = params.mint_signer_bump", ")]", "pub mint: UncheckedAccount<'info>,"].join("\n"); export const splCreateMintMacroCode = ["#[account(", " init,", " payer = fee_payer,", " mint::decimals = 9,", " mint::authority = fee_payer,", ")]", "pub mint: InterfaceAccount<'info, Mint>,"].join("\n"); export const lightCreateMintRustCode = ["use light_token::instruction::CreateMint;", "", "let ix = CreateMint::new(", " params,", " mint_seed.pubkey(),", " payer.pubkey(),", " address_tree.tree,", " output_queue,", ")", ".instruction()?;"].join("\n"); export const splCreateMintRustCode = ["use spl_token::instruction::initialize_mint;", "", "let ix = initialize_mint(", " &spl_token::id(),", " &mint.pubkey(),", " &mint_authority,", " Some(&freeze_authority),", " decimals,", ")?;"].join("\n"); export const lightCreateMintCode = ['import { createMintInterface } from "@lightprotocol/compressed-token";', "", "const { mint } = await createMintInterface(", " rpc,", " payer,", " mintAuthority,", " freezeAuthority,", " decimals,", " mintKeypair", ");"].join("\n"); export const splCreateMintCode = ['import { createMint } from "@solana/spl-token";', "", "const mint = await createMint(", " connection,", " payer,", " mintAuthority,", " freezeAuthority,", " decimals", ");"].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 accounts uniquely represent a token on Solana and store its global metadata. 2. Light mints are on-chain accounts like SPL mints, but the light token program sponsors the rent-exemption cost for you. 3. [Add an interface PDA](/light-token/cookbook/add-interface-pda) to existing SPL or Token 2022 mints for interoperability with Light Token. The interface PDA holds SPL or Token 2022 tokens when wrapped to Light Token. 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 ``` `createMintInterface` is a unified interface that dispatches to different mint creation paths based on programId: * `TOKEN_PROGRAM_ID` or `TOKEN_2022_PROGRAM_ID` → delegates to SPL or Token 2022 `createMint` * Otherwise it defaults to `LIGHT_TOKEN_PROGRAM_ID` → creates a Light Token mint You can use the same interface regardless of mint type. Compare to SPL: Find the source code [here](https://github.com/Lightprotocol/light-protocol/blob/main/js/compressed-token/src/v3/actions/create-mint-interface.ts). ### Create Mint with Token Metadata 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. The `mintAuthority` must be a `Signer` for light-mints but can be just a `PublicKey` for SPL/Token 2022. ```typescript theme={null} import "dotenv/config"; import { Keypair } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { createMintInterface, createTokenMetadata, } 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, transactionSignature } = await createMintInterface( rpc, payer, payer, null, 9, undefined, // keypair undefined, // confirmOptions (default) undefined, // programId (LIGHT_TOKEN_PROGRAM_ID) createTokenMetadata( "Example Token", "EXT", "https://example.com/metadata.json" ) ); console.log("Mint:", mint.toBase58()); console.log("Tx:", transactionSignature); })(); ``` ```typescript theme={null} import "dotenv/config"; import { Keypair, ComputeBudgetProgram, PublicKey, Transaction, sendAndConfirmTransaction, } from "@solana/web3.js"; import { createRpc, getBatchAddressTreeInfo, selectStateTreeInfo, LIGHT_TOKEN_PROGRAM_ID, } from "@lightprotocol/stateless.js"; import { createMintInstruction, createTokenMetadata, } from "@lightprotocol/compressed-token"; import { homedir } from "os"; import { readFileSync } from "fs"; const COMPRESSED_MINT_SEED = Buffer.from("compressed_mint"); function findMintAddress(mintSigner: PublicKey): [PublicKey, number] { return PublicKey.findProgramAddressSync( [COMPRESSED_MINT_SEED, mintSigner.toBuffer()], LIGHT_TOKEN_PROGRAM_ID ); } // 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 mintSigner = Keypair.generate(); const addressTreeInfo = getBatchAddressTreeInfo(); const stateTreeInfo = selectStateTreeInfo(await rpc.getStateTreeInfos()); const [mintPda] = findMintAddress(mintSigner.publicKey); const validityProof = await rpc.getValidityProofV2( [], [{ address: mintPda.toBytes(), treeInfo: addressTreeInfo }] ); const ix = createMintInstruction( mintSigner.publicKey, 9, payer.publicKey, null, payer.publicKey, validityProof, addressTreeInfo, stateTreeInfo, createTokenMetadata( "Example Token", "EXT", "https://example.com/metadata.json" ) ); const tx = new Transaction().add( ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix ); const signature = await sendAndConfirmTransaction(rpc, tx, [ payer, mintSigner, ]); console.log("Mint:", mintPda.toBase58()); console.log("Tx:", signature); })(); ``` ```typescript theme={null} import { Buffer } from "buffer"; import { Keypair, PublicKey, Transaction, sendAndConfirmTransaction, } from "@solana/web3.js"; import { createRpc, LIGHT_TOKEN_PROGRAM_ID } from "@lightprotocol/stateless.js"; import { createMintInstructions } from "@lightprotocol/token-interface"; const COMPRESSED_MINT_SEED = Buffer.from("compressed_mint"); const rpc = createRpc(); const payer = Keypair.fromSecretKey(/* ... */); function findMintAddress(mintSigner: PublicKey): [PublicKey, number] { return PublicKey.findProgramAddressSync( [COMPRESSED_MINT_SEED, mintSigner.toBuffer()], LIGHT_TOKEN_PROGRAM_ID ); } const mintSigner = Keypair.generate(); const [mintPda] = findMintAddress(mintSigner.publicKey); const instructions = await createMintInstructions({ rpc, payer: payer.publicKey, keypair: mintSigner, decimals: 9, mintAuthority: payer.publicKey, tokenProgramId: LIGHT_TOKEN_PROGRAM_ID, }); const tx = new Transaction().add(...instructions); const signature = await sendAndConfirmTransaction(rpc, tx, [payer, mintSigner]); console.log("Mint:", mintPda.toBase58()); console.log("Tx:", signature); ``` {`--- description: Add rent-free mint with token metadata allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Add rent-free mint with token metadata Context: - Guide: https://zkcompression.com/light-token/cookbook/create-mint - 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: createMint() → Light Token: createMintInterface() ### 1. Index project - Grep \`@solana/spl-token|Connection|Keypair|createMint\` across src/ - Glob \`**/*.ts\` for project structure - Identify: RPC setup, existing mint logic, entry point for mint 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 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: Add rent-free mint with token metadata allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Add rent-free mint with token metadata Context: - Guide: https://zkcompression.com/light-token/cookbook/create-mint - 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: createMint() → Light Token: createMintInterface() ### 1. Index project - Grep `@solana/spl-token|Connection|Keypair|createMint` across src/ - Glob `**/*.ts` for project structure - Identify: RPC setup, existing mint logic, entry point for mint 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 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 ``` ## Create SPL mint with interface PDA Pass `TOKEN_PROGRAM_ID` to create a standard SPL mint with an interface PDA in one transaction for interoperability with Light Token. ```typescript theme={null} import "dotenv/config"; import { Keypair } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { createMintInterface } from "@lightprotocol/compressed-token"; import { TOKEN_PROGRAM_ID } from "@solana/spl-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 () { // Creates SPL mint + SPL Interface PDA in one transaction const mintKeypair = Keypair.generate(); const { mint, transactionSignature } = await createMintInterface( rpc, payer, payer, null, 9, mintKeypair, undefined, TOKEN_PROGRAM_ID ); console.log("Mint:", mint.toBase58()); console.log("Tx:", transactionSignature); })(); ``` ```typescript theme={null} import "dotenv/config"; import { Keypair, SystemProgram, Transaction, sendAndConfirmTransaction, } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { LightTokenProgram } from "@lightprotocol/compressed-token"; import { MINT_SIZE, TOKEN_PROGRAM_ID, createInitializeMint2Instruction, } from "@solana/spl-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 mintKeypair = Keypair.generate(); const decimals = 9; // Get rent for mint account const rentExemptBalance = await rpc.getMinimumBalanceForRentExemption(MINT_SIZE); // Instruction 1: Create mint account const createMintAccountIx = SystemProgram.createAccount({ fromPubkey: payer.publicKey, lamports: rentExemptBalance, newAccountPubkey: mintKeypair.publicKey, programId: TOKEN_PROGRAM_ID, space: MINT_SIZE, }); // Instruction 2: Initialize mint const initializeMintIx = createInitializeMint2Instruction( mintKeypair.publicKey, decimals, payer.publicKey, // mint authority null, // freeze authority TOKEN_PROGRAM_ID ); // Instruction 3: Create SPL Interface PDA (enables compression for this mint) const createSplInterfaceIx = await LightTokenProgram.createSplInterface({ feePayer: payer.publicKey, mint: mintKeypair.publicKey, tokenProgramId: TOKEN_PROGRAM_ID, }); const tx = new Transaction().add( createMintAccountIx, initializeMintIx, createSplInterfaceIx ); const signature = await sendAndConfirmTransaction(rpc, tx, [ payer, mintKeypair, ]); console.log("Mint:", mintKeypair.publicKey.toBase58()); console.log("Tx:", signature); })(); ``` ```typescript theme={null} import { Keypair, Transaction, sendAndConfirmTransaction } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { createMintInstructions } from "@lightprotocol/token-interface"; import { TOKEN_PROGRAM_ID } from "@solana/spl-token"; const rpc = createRpc(); const payer = Keypair.fromSecretKey(/* ... */); const mintKeypair = Keypair.generate(); const instructions = await createMintInstructions({ rpc, payer: payer.publicKey, keypair: mintKeypair, decimals: 9, mintAuthority: payer.publicKey, tokenProgramId: TOKEN_PROGRAM_ID, }); const tx = new Transaction().add(...instructions); const signature = await sendAndConfirmTransaction(rpc, tx, [payer, mintKeypair]); console.log("Mint:", mintKeypair.publicKey.toBase58()); console.log("Tx:", signature); ``` ## Create Token 2022 mint with interface PDA Pass `TOKEN_2022_PROGRAM_ID` to create a Token-2022 mint with an interface PDA in one transaction for interoperability with Light Token. ```typescript theme={null} import "dotenv/config"; import { Keypair } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { createMintInterface } from "@lightprotocol/compressed-token"; import { TOKEN_2022_PROGRAM_ID } from "@solana/spl-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 () { // Creates Token-2022 mint and SPL interface PDA in one transaction // SPL interface PDA holds Token-2022 tokens when wrapped to light-token const mintKeypair = Keypair.generate(); const { mint, transactionSignature } = await createMintInterface( rpc, payer, payer, null, 9, mintKeypair, undefined, TOKEN_2022_PROGRAM_ID ); console.log("Mint:", mint.toBase58()); console.log("Tx:", transactionSignature); })(); ``` ```typescript theme={null} import "dotenv/config"; import { Keypair, SystemProgram, Transaction, sendAndConfirmTransaction, } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { LightTokenProgram } from "@lightprotocol/compressed-token"; import { MINT_SIZE, TOKEN_2022_PROGRAM_ID, createInitializeMint2Instruction, } from "@solana/spl-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 mintKeypair = Keypair.generate(); const decimals = 9; // Get rent for mint account const rentExemptBalance = await rpc.getMinimumBalanceForRentExemption(MINT_SIZE); // Instruction 1: Create mint account const createMintAccountIx = SystemProgram.createAccount({ fromPubkey: payer.publicKey, lamports: rentExemptBalance, newAccountPubkey: mintKeypair.publicKey, programId: TOKEN_2022_PROGRAM_ID, space: MINT_SIZE, }); // Instruction 2: Initialize mint const initializeMintIx = createInitializeMint2Instruction( mintKeypair.publicKey, decimals, payer.publicKey, // mint authority null, // freeze authority TOKEN_2022_PROGRAM_ID ); // Instruction 3: Create SPL interface PDA // Holds Token-2022 tokens when wrapped to light-token const createSplInterfaceIx = await LightTokenProgram.createSplInterface({ feePayer: payer.publicKey, mint: mintKeypair.publicKey, tokenProgramId: TOKEN_2022_PROGRAM_ID, }); const tx = new Transaction().add( createMintAccountIx, initializeMintIx, createSplInterfaceIx ); const signature = await sendAndConfirmTransaction(rpc, tx, [ payer, mintKeypair, ]); console.log("Mint:", mintKeypair.publicKey.toBase58()); console.log("Tx:", signature); })(); ``` ```typescript theme={null} import { Keypair, Transaction, sendAndConfirmTransaction } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { createMintInstructions } from "@lightprotocol/token-interface"; import { TOKEN_2022_PROGRAM_ID } from "@solana/spl-token"; const rpc = createRpc(); const payer = Keypair.fromSecretKey(/* ... */); const mintKeypair = Keypair.generate(); const instructions = await createMintInstructions({ rpc, payer: payer.publicKey, keypair: mintKeypair, decimals: 9, mintAuthority: payer.publicKey, tokenProgramId: TOKEN_2022_PROGRAM_ID, }); const tx = new Transaction().add(...instructions); const signature = await sendAndConfirmTransaction(rpc, tx, [payer, mintKeypair]); console.log("Mint:", mintKeypair.publicKey.toBase58()); console.log("Tx:", signature); ``` `CreateMint` creates an on-chain mint account that can optionally include token metadata. The instruction also writes a compressed mint address to the address Merkle tree, which preserves the mint state when the on-chain account is compressed. 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 Light Token Mint with Token Metadata Find the source code [here](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_mint.rs). ```rust theme={null} use light_client::rpc::Rpc; use light_token_client::actions::{CreateMint, TokenMetadata}; 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; let (signature, mint) = CreateMint { decimals: 9, freeze_authority: None, token_metadata: Some(TokenMetadata { name: "Example Token".to_string(), symbol: "EXT".to_string(), uri: "https://example.com/metadata.json".to_string(), update_authority: Some(payer.pubkey()), additional_metadata: Some(vec![("type".to_string(), "example".to_string())]), }), seed: None, } .execute(&mut rpc, &payer, &payer) .await?; let data = rpc.get_account(mint).await?; println!("Mint: {mint} exists: {} Tx: {signature}", data.is_some()); Ok(()) } ``` ```rust theme={null} use light_client::{ indexer::{AddressWithTree, Indexer}, rpc::Rpc, }; use light_program_test::{LightProgramTest, ProgramTestConfig}; use light_token::instruction::{ derive_mint_compressed_address, find_mint_address, CreateMint, CreateMintParams, DEFAULT_RENT_PAYMENT, DEFAULT_WRITE_TOP_UP, }; use light_token_interface::{ instructions::extensions::{ token_metadata::TokenMetadataInstructionData, ExtensionInstructionData, }, state::AdditionalMetadata, }; use solana_sdk::{signature::Keypair, signer::Signer}; #[tokio::main] async fn main() -> Result<(), Box> { let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None)).await?; let payer = rpc.get_payer().insecure_clone(); let mint_seed = Keypair::new(); let decimals = 9u8; // Get address tree to store compressed address for when mint turns inactive // We must create a compressed address at creation to ensure the mint does not exist yet let address_tree = rpc.get_address_tree_v2(); // Get state tree to store mint when inactive let output_queue = rpc.get_random_state_tree_info().unwrap().queue; // Derive mint addresses let compression_address = derive_mint_compressed_address(&mint_seed.pubkey(), &address_tree.tree); let mint = find_mint_address(&mint_seed.pubkey()).0; // on-chain Mint PDA // Fetch validity proof to proof address does not exist yet let rpc_result = rpc .get_validity_proof( vec![], vec![AddressWithTree { address: compression_address, tree: address_tree.tree, }], None, ) .await .unwrap() .value; // Build CreateMintParams with token metadata extension let params = CreateMintParams { decimals, address_merkle_tree_root_index: rpc_result.addresses[0].root_index, // stores mint compressed address mint_authority: payer.pubkey(), proof: rpc_result.proof.0.unwrap(), compression_address, // address for compression when mint turns inactive mint, bump: find_mint_address(&mint_seed.pubkey()).1, freeze_authority: None, extensions: Some(vec![ExtensionInstructionData::TokenMetadata( TokenMetadataInstructionData { update_authority: Some(payer.pubkey().to_bytes().into()), name: b"Example Token".to_vec(), symbol: b"EXT".to_vec(), uri: b"https://example.com/metadata.json".to_vec(), additional_metadata: Some(vec![AdditionalMetadata { key: b"type".to_vec(), value: b"example".to_vec(), }]), }, )]), rent_payment: DEFAULT_RENT_PAYMENT, // 24h of rent write_top_up: DEFAULT_WRITE_TOP_UP, // 3h of rent }; // Build and send instruction (mint_seed must sign) let create_mint_instruction = CreateMint::new( params, mint_seed.pubkey(), payer.pubkey(), address_tree.tree, output_queue, ) .instruction()?; let sig = rpc .create_and_send_transaction(&[create_mint_instruction], &payer.pubkey(), &[&payer, &mint_seed]) .await?; let data = rpc.get_account(mint).await?; println!("Mint: {} exists: {} Tx: {sig}", mint, data.is_some()); Ok(()) } ``` {`--- description: Create rent-free mint with token metadata allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Create rent-free mint with token metadata Context: - Guide: https://zkcompression.com/light-token/cookbook/create-mint - 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_mint → Light Token: CreateMint ### 1. Index project - Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|CreateMint|initialize_mint\` across src/ - Glob \`**/*.rs\` for project structure - Identify: RPC setup, existing token ops, entry point for mint 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 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: Create rent-free mint with token metadata allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Create rent-free mint with token metadata Context: - Guide: https://zkcompression.com/light-token/cookbook/create-mint - 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_mint → Light Token: CreateMint ### 1. Index project - Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|CreateMint|initialize_mint` across src/ - Glob `**/*.rs` for project structure - Identify: RPC setup, existing token ops, entry point for mint 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 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 ``` Compare to SPL: Find [a full code example at the end](#full-code-example). ### Configure Token Metadata ```rust theme={null} use light_token_interface::instructions::extensions::{ token_metadata::TokenMetadataInstructionData, ExtensionInstructionData, }; let extensions = Some(vec![ExtensionInstructionData::TokenMetadata( TokenMetadataInstructionData { update_authority: Some(authority.key.to_bytes().into()), name: b"Example Token".to_vec(), symbol: b"EXT".to_vec(), uri: b"https://example.com/metadata.json".to_vec(), additional_metadata: None, }, )]); ``` **Fields must be set at light-mint creation.** Standard fields (`name`, `symbol`, `uri`) can be updated by `update_authority`. For `additional_metadata`, only existing keys can be modified or removed. New keys cannot be added after creation. ### Configure Mint Configure mint parameters including `decimals`, authorities, rent settings, and pass `extensions` from the previous step. ```rust theme={null} use light_token::instruction::CreateMintParams; let params = CreateMintParams { decimals, address_merkle_tree_root_index, mint_authority: *ctx.accounts.authority.key, proof, compression_address, mint, bump, freeze_authority, extensions, rent_payment: rent_payment.unwrap_or(16), // ~24 hours rent write_top_up: write_top_up.unwrap_or(766), // ~3 hours rent }; ``` The address of the mint account is stored in an address Merkle tree , which is maintained by the protocol. The client passes a validity proof that proves the mint address does not exist yet. ### System Accounts Include system accounts such as the Light System Program to verify the proof and write the mint address to the address tree.
Account Description
1 Light System Program Verifies validity proofs and executes compressed account state transitions.
2 CPI Authority PDA PDA that authorizes CPIs from the Light Token Program to the Light System Program.
3 Registered Program PDA Proves the Light Token Program is registered to use compression.
4 Account Compression Authority Signs CPI calls from the Light System Program to the Account Compression Program.
5 Account Compression Program Writes to state and address Merkle tree accounts.
6 System Program Solana System Program.
```rust theme={null} use light_token::instruction::SystemAccountInfos; let system_accounts = SystemAccountInfos { light_system_program: ctx.accounts.light_system_program.to_account_info(), cpi_authority_pda: ctx.accounts.cpi_authority_pda.to_account_info(), registered_program_pda: ctx.accounts.registered_program_pda.to_account_info(), account_compression_authority: ctx.accounts.account_compression_authority.to_account_info(), account_compression_program: ctx.accounts.account_compression_program.to_account_info(), system_program: ctx.accounts.system_program.to_account_info(), }; ``` ### Build Account Infos and CPI the Light Token Program Use `invoke` or `invoke_signed`: * When `mint_seed` is an external keypair, use `invoke`. * When `mint_seed` is a PDA, use `invoke_signed` with its seeds. * When both `mint_seed` and `authority` are PDAs, use `invoke_signed` with both seeds. ```rust theme={null} use light_token::instruction::CreateMintCpi; CreateMintCpi::new( mint_seed.clone(), authority.clone(), payer.clone(), address_tree.clone(), // stores address output_queue.clone(), // stores account when inactive compressible_config.clone(), // rent settings mint.clone(), rent_sponsor.clone(), system_accounts, params, ) .invoke() ``` ```rust theme={null} use light_token::instruction::CreateMintCpi; let signer_seeds: &[&[u8]] = &[MINT_SIGNER_SEED, &[bump]]; CreateMintCpi::new( mint_seed.clone(), authority.clone(), payer.clone(), address_tree.clone(), output_queue.clone(), compressible_config.clone(), mint.clone(), rent_sponsor.clone(), system_accounts, params, ) .invoke_signed(&[signer_seeds]) ``` ```rust theme={null} use light_token::instruction::CreateMintCpi; let mint_seed_seeds: &[&[u8]] = &[MINT_SIGNER_SEED, &[mint_seed_bump]]; let authority_seeds: &[&[u8]] = &[MINT_AUTHORITY_SEED, &[authority_bump]]; CreateMintCpi::new( mint_seed.clone(), authority.clone(), payer.clone(), address_tree.clone(), output_queue.clone(), compressible_config.clone(), mint.clone(), rent_sponsor.clone(), system_accounts, params, ) .invoke_signed(&[mint_seed_seeds, authority_seeds]) ``` # Full Code Example View the [source code](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_mint.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-mint) with shared test utilities. ```rust lib.rs theme={null} #![allow(unexpected_cfgs, deprecated)] use anchor_lang::prelude::*; use light_token::instruction::{ CreateMintCpi, CreateMintParams, SystemAccountInfos, DEFAULT_RENT_PAYMENT, DEFAULT_WRITE_TOP_UP, }; use light_token::{CompressedProof, ExtensionInstructionData, TokenMetadataInstructionData}; declare_id!("A1rJEoepgKYWZYZ8KVFpxgeeRGwBrU7xk8S39srjVkUX"); /// Token metadata parameters for creating a mint with metadata. #[derive(AnchorSerialize, AnchorDeserialize, Clone)] pub struct TokenMetadataParams { pub name: Vec, pub symbol: Vec, pub uri: Vec, pub update_authority: Option, } #[program] pub mod light_token_anchor_create_mint { use super::*; pub fn create_mint( ctx: Context, decimals: u8, address_merkle_tree_root_index: u16, compression_address: [u8; 32], proof: CompressedProof, freeze_authority: Option, bump: u8, rent_payment: Option, write_top_up: Option, metadata: Option, ) -> Result<()> { let mint = light_token::instruction::find_mint_address(ctx.accounts.mint_seed.key).0; let extensions = metadata.map(|m| { vec![ExtensionInstructionData::TokenMetadata( TokenMetadataInstructionData { update_authority: m .update_authority .map(|p| p.to_bytes().into()), name: m.name, symbol: m.symbol, uri: m.uri, additional_metadata: None, }, )] }); let params = CreateMintParams { decimals, address_merkle_tree_root_index, mint_authority: *ctx.accounts.authority.key, proof, compression_address, mint, bump, freeze_authority, extensions, rent_payment: rent_payment.unwrap_or(DEFAULT_RENT_PAYMENT), write_top_up: write_top_up.unwrap_or(DEFAULT_WRITE_TOP_UP), }; let system_accounts = SystemAccountInfos { light_system_program: ctx.accounts.light_system_program.to_account_info(), cpi_authority_pda: ctx.accounts.cpi_authority_pda.to_account_info(), registered_program_pda: ctx.accounts.registered_program_pda.to_account_info(), account_compression_authority: ctx.accounts.account_compression_authority.to_account_info(), account_compression_program: ctx.accounts.account_compression_program.to_account_info(), system_program: ctx.accounts.system_program.to_account_info(), }; CreateMintCpi { mint_seed: ctx.accounts.mint_seed.to_account_info(), authority: ctx.accounts.authority.to_account_info(), payer: ctx.accounts.payer.to_account_info(), address_tree: ctx.accounts.address_tree.to_account_info(), output_queue: ctx.accounts.output_queue.to_account_info(), compressible_config: ctx.accounts.compressible_config.to_account_info(), mint: ctx.accounts.mint.to_account_info(), rent_sponsor: ctx.accounts.rent_sponsor.to_account_info(), system_accounts, cpi_context: None, cpi_context_account: None, params, } .invoke()?; Ok(()) } } #[derive(Accounts)] pub struct CreateMintAccounts<'info> { /// CHECK: Light token program for CPI pub light_token_program: AccountInfo<'info>, pub mint_seed: Signer<'info>, /// CHECK: Validated by light-token CPI pub authority: AccountInfo<'info>, #[account(mut)] pub payer: Signer<'info>, /// CHECK: Validated by light-token CPI #[account(mut)] pub address_tree: AccountInfo<'info>, /// CHECK: Validated by light-token CPI #[account(mut)] pub output_queue: AccountInfo<'info>, /// CHECK: Validated by light-token CPI pub light_system_program: AccountInfo<'info>, /// CHECK: Validated by light-token CPI pub cpi_authority_pda: AccountInfo<'info>, /// CHECK: Validated by light-token CPI pub registered_program_pda: AccountInfo<'info>, /// CHECK: Validated by light-token CPI pub account_compression_authority: AccountInfo<'info>, /// CHECK: Validated by light-token CPI pub account_compression_program: AccountInfo<'info>, pub system_program: Program<'info, System>, /// CHECK: Validated by light-token CPI - use light_token::token::config_pda() pub compressible_config: AccountInfo<'info>, /// CHECK: Validated by light-token CPI - derived from find_mint_address(mint_seed) #[account(mut)] pub mint: AccountInfo<'info>, /// CHECK: Validated by light-token CPI - use light_token::token::rent_sponsor_pda() #[account(mut)] pub rent_sponsor: AccountInfo<'info>, } ``` ```rust test.rs theme={null} use anchor_lang::{InstructionData, ToAccountMetas}; use light_program_test::{Indexer, LightProgramTest, ProgramTestConfig, Rpc}; use light_token_anchor_create_mint::{accounts, instruction::CreateMint, ID}; use light_token::instruction::{ config_pda, derive_mint_compressed_address, find_mint_address, rent_sponsor_pda, SystemAccounts, 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_mint() { let config = ProgramTestConfig::new_v2(true, Some(vec![("light_token_anchor_create_mint", 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![light_client::indexer::AddressWithTree { address: compression_address, tree: address_tree.tree, }], None, ) .await .unwrap() .value; let system_accounts = SystemAccounts::default(); // Call the anchor program to create mint let ix = Instruction { program_id: ID, accounts: accounts::CreateMintAccounts { light_token_program: LIGHT_TOKEN_PROGRAM_ID, mint_seed: mint_seed.pubkey(), authority: mint_authority, payer: payer.pubkey(), address_tree: address_tree.tree, output_queue, light_system_program: system_accounts.light_system_program, cpi_authority_pda: system_accounts.cpi_authority_pda, registered_program_pda: system_accounts.registered_program_pda, account_compression_authority: system_accounts.account_compression_authority, account_compression_program: system_accounts.account_compression_program, system_program: system_program::ID, compressible_config: config_pda(), mint: mint_pda, rent_sponsor: rent_sponsor_pda(), } .to_account_metas(Some(true)), data: CreateMint { decimals, address_merkle_tree_root_index: rpc_result.addresses[0].root_index, compression_address: compression_address.into(), proof: rpc_result.proof.0.unwrap(), freeze_authority: None, bump, rent_payment: Some(DEFAULT_RENT_PAYMENT), write_top_up: Some(DEFAULT_WRITE_TOP_UP), metadata: None, } .data(), }; let sig = rpc .create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer, &mint_seed]) .await .unwrap(); let compressed_account = rpc .get_compressed_account(compression_address, None) .await .unwrap() .value; assert!(compressed_account.is_some(), "Light-mint should exist"); println!("Tx: {}", sig); } ``` {`--- description: Add create-mint 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-mint CPI to an Anchor program Context: - Guide: https://zkcompression.com/light-token/cookbook/create-mint - 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 (CreateMintCpi, CreateMintParams, SystemAccountInfos) - Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-mint Key CPI struct: \`light_token::instruction::CreateMintCpi\` ### 1. Index project - Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|mint|decimals|authority|metadata\` across src/ - Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure - Identify: program ID, existing instructions, account structs, mint seeds - 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 metadata config, mint params, system accounts, invoke patterns - 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-mint to existing program, new program from scratch, migrate from SPL create_mint) - AskUserQuestion: should the mint seed be an external keypair or a PDA? (determines invoke vs invoke_signed) - AskUserQuestion: do you need token metadata (name, symbol, uri)? - 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: Configure Token Metadata → Configure Mint Params → System Accounts → Build CPI and invoke - 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-mint 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-mint CPI to an Anchor program Context: - Guide: https://zkcompression.com/light-token/cookbook/create-mint - 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 (CreateMintCpi, CreateMintParams, SystemAccountInfos) - Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-mint Key CPI struct: `light_token::instruction::CreateMintCpi` ### 1. Index project - Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|mint|decimals|authority|metadata` across src/ - Glob `**/*.rs` and `**/Cargo.toml` for project structure - Identify: program ID, existing instructions, account structs, mint seeds - 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 metadata config, mint params, system accounts, invoke patterns - 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-mint to existing program, new program from scratch, migrate from SPL create_mint) - AskUserQuestion: should the mint seed be an external keypair or a PDA? (determines invoke vs invoke_signed) - AskUserQuestion: do you need token metadata (name, symbol, uri)? - 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: Configure Token Metadata → Configure Mint Params → System Accounts → Build CPI and invoke - 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). ### 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 my_program { use super::*; pub fn create_mint<'info>( ctx: Context<'_, '_, '_, 'info, CreateMint<'info>>, params: CreateMintParams, ) -> 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, mint::signer = mint_signer, mint::authority = fee_payer, mint::decimals = 9, mint::seeds = &[MINT_SIGNER_SEED, self.authority.to_account_info().key.as_ref()], mint::bump = params.mint_signer_bump )] pub mint: UncheckedAccount<'info>, ``` ```rust theme={null} /// CHECK: Validated by light-token CPI #[account(mut)] #[light_account(init, mint::signer = mint_signer, mint::authority = fee_payer, mint::decimals = 9, mint::seeds = &[MINT_SIGNER_SEED, self.authority.to_account_info().key.as_ref()], mint::bump = params.mint_signer_bump, mint::name = params.name.clone(), mint::symbol = params.symbol.clone(), mint::uri = params.uri.clone(), mint::update_authority = authority, mint::additional_metadata = params.additional_metadata.clone() )] pub mint: UncheckedAccount<'info>, ``` # Full code example View the [source code](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_mint.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-mint) 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, }; declare_id!("HVmVqSJyMejBeUigePMSfX4aENJzCGHNxAJuT2PDMPRx"); pub const LIGHT_CPI_SIGNER: CpiSigner = derive_light_cpi_signer!("HVmVqSJyMejBeUigePMSfX4aENJzCGHNxAJuT2PDMPRx"); pub const MINT_SIGNER_SEED: &[u8] = b"mint_signer"; #[derive(AnchorSerialize, AnchorDeserialize, Clone)] pub struct CreateMintParams { pub create_accounts_proof: CreateAccountsProof, pub mint_signer_bump: u8, } #[derive(AnchorSerialize, AnchorDeserialize, Clone)] pub struct CreateMintWithMetadataParams { pub create_accounts_proof: CreateAccountsProof, pub mint_signer_bump: u8, pub name: Vec, pub symbol: Vec, pub uri: Vec, } #[derive(Accounts, LightAccounts)] #[instruction(params: CreateMintParams)] pub struct CreateMint<'info> { #[account(mut)] pub fee_payer: Signer<'info>, pub authority: Signer<'info>, /// CHECK: PDA derived from authority #[account( seeds = [MINT_SIGNER_SEED, authority.key().as_ref()], bump, )] pub mint_signer: UncheckedAccount<'info>, /// CHECK: Initialized by light_mint CPI #[account(mut)] #[light_account(init, mint::signer = mint_signer, mint::authority = fee_payer, mint::decimals = 9, mint::seeds = &[MINT_SIGNER_SEED, self.authority.to_account_info().key.as_ref()], mint::bump = params.mint_signer_bump )] pub mint: UncheckedAccount<'info>, /// CHECK: Compression config PDA pub compression_config: AccountInfo<'info>, /// CHECK: Light Token config pub light_token_config: AccountInfo<'info>, /// CHECK: Rent sponsor #[account(mut)] pub light_token_rent_sponsor: AccountInfo<'info>, /// CHECK: Light Token program pub light_token_program: AccountInfo<'info>, /// CHECK: Light Token CPI authority pub light_token_cpi_authority: AccountInfo<'info>, pub system_program: Program<'info, System>, } #[derive(Accounts, LightAccounts)] #[instruction(params: CreateMintWithMetadataParams)] pub struct CreateMintWithMetadata<'info> { #[account(mut)] pub fee_payer: Signer<'info>, pub authority: Signer<'info>, /// CHECK: PDA derived from authority #[account( seeds = [MINT_SIGNER_SEED, authority.key().as_ref()], bump, )] pub mint_signer: UncheckedAccount<'info>, /// CHECK: Initialized by light_mint CPI #[account(mut)] #[light_account(init, mint::signer = mint_signer, mint::authority = fee_payer, mint::decimals = 9, mint::seeds = &[MINT_SIGNER_SEED, self.authority.to_account_info().key.as_ref()], mint::bump = params.mint_signer_bump, mint::name = params.name.clone(), mint::symbol = params.symbol.clone(), mint::uri = params.uri.clone(), mint::update_authority = authority )] pub mint: UncheckedAccount<'info>, /// CHECK: Compression config PDA pub compression_config: AccountInfo<'info>, /// CHECK: Light Token config pub light_token_config: AccountInfo<'info>, /// CHECK: Rent sponsor #[account(mut)] pub light_token_rent_sponsor: AccountInfo<'info>, /// CHECK: Light Token program pub light_token_program: AccountInfo<'info>, /// CHECK: Light Token CPI authority pub light_token_cpi_authority: AccountInfo<'info>, pub system_program: Program<'info, System>, } #[light_program] #[program] pub mod light_token_macro_create_mint { use super::*; #[allow(unused_variables)] pub fn create_mint<'info>( ctx: Context<'_, '_, '_, 'info, CreateMint<'info>>, params: CreateMintParams, ) -> Result<()> { Ok(()) } #[allow(unused_variables)] pub fn create_mint_with_metadata<'info>( ctx: Context<'_, '_, '_, 'info, CreateMintWithMetadata<'info>>, params: CreateMintWithMetadataParams, ) -> Result<()> { Ok(()) } } ``` ```rust test.rs theme={null} use anchor_lang::{prelude::borsh, InstructionData, ToAccountMetas}; use light_client::interface::{ get_create_accounts_proof, CreateAccountsProofInput, 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::{find_mint_address, LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR}; use solana_instruction::Instruction; use solana_keypair::Keypair; use solana_pubkey::Pubkey; use solana_signer::Signer; use light_token_macro_create_mint::MINT_SIGNER_SEED; async fn setup() -> (light_program_test::LightProgramTest, Keypair, Pubkey, Pubkey) { let program_id = light_token_macro_create_mint::ID; let mut config = ProgramTestConfig::new_v2(true, Some(vec![("light_token_macro_create_mint", 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"); (rpc, payer, config_pda, program_id) } #[tokio::test] async fn test_create_mint() { use light_token_macro_create_mint::CreateMintParams; let (mut rpc, payer, config_pda, program_id) = setup().await; let authority = Keypair::new(); let (mint_signer_pda, mint_signer_bump) = Pubkey::find_program_address( &[MINT_SIGNER_SEED, authority.pubkey().as_ref()], &program_id, ); let (mint_pda, _) = find_mint_address(&mint_signer_pda); let proof_result = get_create_accounts_proof( &rpc, &program_id, vec![CreateAccountsProofInput::mint(mint_signer_pda)], ) .await .unwrap(); let accounts = light_token_macro_create_mint::accounts::CreateMint { fee_payer: payer.pubkey(), authority: authority.pubkey(), mint_signer: mint_signer_pda, mint: mint_pda, compression_config: config_pda, light_token_config: LIGHT_TOKEN_CONFIG, light_token_rent_sponsor: LIGHT_TOKEN_RENT_SPONSOR, light_token_program: LIGHT_TOKEN_PROGRAM_ID.into(), light_token_cpi_authority: light_token::constants::LIGHT_TOKEN_CPI_AUTHORITY, system_program: solana_sdk::system_program::ID, }; let instruction_data = light_token_macro_create_mint::instruction::CreateMint { params: CreateMintParams { create_accounts_proof: proof_result.create_accounts_proof, mint_signer_bump, }, }; 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, &authority]) .await .expect("CreateMint should succeed"); let mint_account = rpc .get_account(mint_pda) .await .unwrap() .expect("Mint should exist on-chain"); use light_token_interface::state::Mint; let mint: Mint = borsh::BorshDeserialize::deserialize(&mut &mint_account.data[..]) .expect("Failed to deserialize Mint"); assert_eq!(mint.base.decimals, 9); assert_eq!( mint.base.mint_authority, Some(payer.pubkey().to_bytes().into()), ); } #[tokio::test] async fn test_create_mint_with_metadata() { use light_token_macro_create_mint::CreateMintWithMetadataParams; let (mut rpc, payer, config_pda, program_id) = setup().await; let authority = Keypair::new(); let (mint_signer_pda, mint_signer_bump) = Pubkey::find_program_address( &[MINT_SIGNER_SEED, authority.pubkey().as_ref()], &program_id, ); let (mint_pda, _) = find_mint_address(&mint_signer_pda); let proof_result = get_create_accounts_proof( &rpc, &program_id, vec![CreateAccountsProofInput::mint(mint_signer_pda)], ) .await .unwrap(); let accounts = light_token_macro_create_mint::accounts::CreateMintWithMetadata { fee_payer: payer.pubkey(), authority: authority.pubkey(), mint_signer: mint_signer_pda, mint: mint_pda, compression_config: config_pda, light_token_config: LIGHT_TOKEN_CONFIG, light_token_rent_sponsor: LIGHT_TOKEN_RENT_SPONSOR, light_token_program: LIGHT_TOKEN_PROGRAM_ID.into(), light_token_cpi_authority: light_token::constants::LIGHT_TOKEN_CPI_AUTHORITY, system_program: solana_sdk::system_program::ID, }; let instruction_data = light_token_macro_create_mint::instruction::CreateMintWithMetadata { params: CreateMintWithMetadataParams { create_accounts_proof: proof_result.create_accounts_proof, mint_signer_bump, name: b"Test Token".to_vec(), symbol: b"TST".to_vec(), uri: b"https://example.com/metadata.json".to_vec(), }, }; 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, &authority]) .await .expect("CreateMintWithMetadata should succeed"); let mint_account = rpc .get_account(mint_pda) .await .unwrap() .expect("Mint should exist on-chain"); use light_token_interface::state::Mint; let mint: Mint = borsh::BorshDeserialize::deserialize(&mut &mint_account.data[..]) .expect("Failed to deserialize Mint"); assert_eq!(mint.base.decimals, 9); assert_eq!( mint.base.mint_authority, Some(payer.pubkey().to_bytes().into()), ); } ``` {`--- description: Create a rent-free mint 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 mint with Anchor macros Context: - Guide: https://zkcompression.com/light-token/cookbook/create-mint - 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-mint Key macros: \`#[light_program]\`, \`LightAccounts\`, \`#[light_account(init, mint::...)]\` ### 1. Index project - Grep \`#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|mint\` across src/ - Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure - Identify: existing program module, account structs, mint patterns, PDA seeds - 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 mint to existing program, migrate from SPL create_mint) - AskUserQuestion: do you need token metadata (name, symbol, uri)? - 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, mint::...)]) - 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 mint 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 mint with Anchor macros Context: - Guide: https://zkcompression.com/light-token/cookbook/create-mint - 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-mint Key macros: `#[light_program]`, `LightAccounts`, `#[light_account(init, mint::...)]` ### 1. Index project - Grep `#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|mint` across src/ - Glob `**/*.rs` and `**/Cargo.toml` for project structure - Identify: existing program module, account structs, mint patterns, PDA seeds - 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 mint to existing program, migrate from SPL create_mint) - AskUserQuestion: do you need token metadata (name, symbol, uri)? - 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, mint::...)]) - 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)