> ## Documentation Index > Fetch the complete documentation index at: https://luminouslabs-cc5545c6-docs-main-reorder.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Create Mint Account with Token Metadata > Program and client guides to create a mint with token metadata. For existing SPL or Token 2022 mints add an interface PDA for interoperability. Includes step-by-step implementation and full code examples. 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 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 the [agent skill](https://zkcompression.com/skill.md): ```bash theme={null} npx skills add https://zkcompression.com ``` See the [AI tools guide](/ai-tools/guide) for dedicated skills. `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 T22 `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@beta \ @lightprotocol/compressed-token@beta ``` Install the CLI globally: ```bash theme={null} npm install -g @lightprotocol/zk-compression-cli@beta ``` Install packages in your working directory: ```bash theme={null} yarn add @lightprotocol/stateless.js@beta \ @lightprotocol/compressed-token@beta ``` Install the CLI globally: ```bash theme={null} yarn global add @lightprotocol/zk-compression-cli@beta ``` Install packages in your working directory: ```bash theme={null} pnpm add @lightprotocol/stateless.js@beta \ @lightprotocol/compressed-token@beta ``` Install the CLI globally: ```bash theme={null} pnpm add -g @lightprotocol/zk-compression-cli@beta ``` ```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/T22. ```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, undefined, undefined, 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, CTOKEN_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()], CTOKEN_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); })(); ``` {`--- 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 - 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 - 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 ``` ### Add Interface PDA to SPL / Token 2022 mints Register an interface PDA for an existing SPL mint for interoperability with Light Token. No mint authority required. ```typescript theme={null} import "dotenv/config"; import { Keypair, PublicKey } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { createSplInterface } 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 existingMint = new PublicKey("YOUR_EXISTING_MINT_ADDRESS"); const tx = await createSplInterface(rpc, payer, existingMint); console.log("Mint:", existingMint.toBase58()); console.log("Tx:", tx); })(); ``` ```typescript theme={null} import "dotenv/config"; import { Keypair, PublicKey, Transaction, sendAndConfirmTransaction, } from "@solana/web3.js"; import { createRpc } from "@lightprotocol/stateless.js"; import { LightTokenProgram } 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 () { const existingMint = new PublicKey("YOUR_EXISTING_MINT_ADDRESS"); const ix = await LightTokenProgram.createSplInterface({ feePayer: payer.publicKey, mint: existingMint, tokenProgramId: TOKEN_PROGRAM_ID, }); const tx = new Transaction().add(ix); const signature = await sendAndConfirmTransaction(rpc, tx, [payer]); console.log("Mint:", existingMint.toBase58()); console.log("Tx:", signature); })(); ``` 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); })(); ``` 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); })(); ``` `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.4.0" light-client = { version = "0.19.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@beta ``` ```bash theme={null} yarn global add @lightprotocol/zk-compression-cli@beta ``` ```bash theme={null} pnpm add -g @lightprotocol/zk-compression-cli@beta ``` ```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_v2(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 - 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 - 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 - 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 - 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.18.0", features = ["anchor", "v2", "cpi-context"] } light-sdk-macros = "0.18.0" light-compressible = "0.1.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_compressible::CreateAccountsProof; use light_sdk::derive_light_cpi_signer; use light_sdk_macros::{light_program, LightAccounts}; use light_sdk_types::CpiSigner; 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 compressible config pub light_token_compressible_config: AccountInfo<'info>, /// CHECK: Rent sponsor #[account(mut)] pub 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 compressible config pub light_token_compressible_config: AccountInfo<'info>, /// CHECK: Rent sponsor #[account(mut)] pub 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_sdk_types::LIGHT_TOKEN_PROGRAM_ID; use light_token::instruction::{find_mint_address, COMPRESSIBLE_CONFIG_V1, 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 (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_compressible_config: COMPRESSIBLE_CONFIG_V1, rent_sponsor: RENT_SPONSOR, light_token_program: LIGHT_TOKEN_PROGRAM_ID.into(), light_token_cpi_authority: light_token_types::CPI_AUTHORITY_PDA.into(), 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_compressible_config: COMPRESSIBLE_CONFIG_V1, rent_sponsor: RENT_SPONSOR, light_token_program: LIGHT_TOKEN_PROGRAM_ID.into(), light_token_cpi_authority: light_token_types::CPI_AUTHORITY_PDA.into(), 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 - 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.18 --features anchor,v2,cpi-context\` and \`cargo add light-sdk-macros@0.18 light-compressible@0.1 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 - 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.18 --features anchor,v2,cpi-context` and `cargo add light-sdk-macros@0.18 light-compressible@0.1 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 ``` # Next Steps