> ## 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. # Toolkit for Stablecoin Payments > Guide to integrate light-token APIs for stablecoin payments with comparison to SPL. export const CodeCompare = ({firstCode = "", secondCode = "", firstLabel = "Light Token", secondLabel = "SPL", language = "javascript"}) => { const [sliderPercent, setSliderPercent] = useState(100); const [isDragging, setIsDragging] = useState(false); const [isAnimating, setIsAnimating] = useState(false); const [copied, setCopied] = useState(false); const containerRef = useRef(null); const animationRef = useRef(null); const firstPreRef = useRef(null); const secondPreRef = useRef(null); const [containerHeight, setContainerHeight] = useState(null); const showingFirst = sliderPercent > 50; const handleCopy = async () => { const codeToCopy = showingFirst ? firstCode : secondCode; await navigator.clipboard.writeText(codeToCopy); setCopied(true); setTimeout(() => setCopied(false), 2000); }; const highlightCode = code => { let escaped = code.replace(/&/g, "&").replace(//g, ">"); if (language === "rust") { const rustPattern = /(\/\/.*$)|(["'])(?:(?!\2)[^\\]|\\.)*?\2|\b(use|let|mut|pub|fn|struct|impl|enum|mod|const|static|trait|type|where|for|in|if|else|match|loop|while|return|self|Self|true|false|Some|None|Ok|Err|Result|Option|vec!)\b|::([a-zA-Z_][a-zA-Z0-9_]*)|&([a-zA-Z_][a-zA-Z0-9_]*)|\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()|(\?)/gm; return escaped.replace(rustPattern, (match, comment, stringQuote, keyword, pathSegment, reference, func, questionMark) => { if (comment) return `${match}`; if (stringQuote) return `${match}`; if (keyword) return `${match}`; if (pathSegment) return `::${pathSegment}`; if (reference) return `&${reference}`; if (func) return `${match}`; if (questionMark) return `?`; return match; }); } const pattern = /(\/\/.*$)|(["'`])(?:(?!\2)[^\\]|\\.)*?\2|\b(const|let|var|await|async|import|from|export|return|if|else|function|class|new|throw|try|catch)\b|\.([a-zA-Z_][a-zA-Z0-9_]*)\b|\b([a-zA-Z_][a-zA-Z0-9_]*)\s*(?=\()/gm; return escaped.replace(pattern, (match, comment, stringQuote, keyword, property, func) => { if (comment) return `${match}`; if (stringQuote) return `${match}`; if (keyword) return `${match}`; if (property) return `.${property}`; if (func) return `${match}`; return match; }); }; const animateTo = target => { if (animationRef.current) cancelAnimationFrame(animationRef.current); setIsAnimating(true); const start = sliderPercent; const startTime = performance.now(); const duration = 400; const animate = currentTime => { const elapsed = currentTime - startTime; const progress = Math.min(elapsed / duration, 1); const eased = 1 - Math.pow(1 - progress, 3); const current = start + (target - start) * eased; setSliderPercent(current); if (progress < 1) { animationRef.current = requestAnimationFrame(animate); } else { setSliderPercent(target); setIsAnimating(false); animationRef.current = null; } }; animationRef.current = requestAnimationFrame(animate); }; const handleToggle = () => { animateTo(showingFirst ? 0 : 100); }; const handleMouseDown = e => { if (isAnimating) { cancelAnimationFrame(animationRef.current); setIsAnimating(false); } e.preventDefault(); setIsDragging(true); }; const handleMouseUp = () => { setIsDragging(false); }; const handleMouseMove = e => { if (!isDragging || !containerRef.current) return; const rect = containerRef.current.getBoundingClientRect(); const x = e.clientX - rect.left; const percent = Math.max(0, Math.min(100, x / rect.width * 100)); setSliderPercent(percent); }; const handleTouchMove = e => { if (!containerRef.current) return; if (isAnimating) { cancelAnimationFrame(animationRef.current); setIsAnimating(false); } const rect = containerRef.current.getBoundingClientRect(); const x = e.touches[0].clientX - rect.left; const percent = Math.max(0, Math.min(100, x / rect.width * 100)); setSliderPercent(percent); }; const handleKeyDown = e => { if (e.key === "ArrowLeft") { setSliderPercent(p => Math.max(0, p - 5)); } else if (e.key === "ArrowRight") { setSliderPercent(p => Math.min(100, p + 5)); } }; useEffect(() => { if (isDragging) { document.addEventListener("mousemove", handleMouseMove); document.addEventListener("mouseup", handleMouseUp); return () => { document.removeEventListener("mousemove", handleMouseMove); document.removeEventListener("mouseup", handleMouseUp); }; } }, [isDragging]); useEffect(() => { return () => { if (animationRef.current) cancelAnimationFrame(animationRef.current); }; }, []); useEffect(() => { const activeRef = showingFirst ? firstPreRef : secondPreRef; if (activeRef.current) { setContainerHeight(activeRef.current.scrollHeight); } }, [showingFirst]); return <>
{}
{showingFirst ? firstLabel : secondLabel}
{} {}
{}
{}
{}
{} 

              {}
{}
{}
{[0, 1, 2].map(i =>
)}
{[0, 1, 2].map(i =>
)}
; }; 1. The light-token API matches the SPL-token API almost entirely, and extends their functionality to include the light token program in addition to the SPL-token and Token-2022 programs. 2. Your users use the same stablecoins, just stored more efficiently. | Creation Cost | SPL | light-token | | :---------------- | :------------------- | :-------------------- | | **Token Account** | \~2,000,000 lamports | \~**11,000** lamports | ### What you will implement
SPL Light
**Receive** getOrCreateAssociatedTokenAccount() createLoadAtaInstructions()
**Transfer** createTransferInstruction() createTransferInterfaceInstructions()
**Get Balance** getAccount() getAtaInterface()
**Tx History** getSignaturesForAddress() rpc.getSignaturesForOwnerInterface()
**Wrap from SPL** N/A createWrapInstruction()
**Unwrap to SPL** N/A createUnwrapInstructions() / unwrap()
Find full runnable code examples [here](https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets). Use the [payments-and-wallets](https://github.com/Lightprotocol/skills/tree/main/skills/payments-and-wallets) agent skill to add light-token payment support to your project: Add the marketplace and install: ``` /plugin marketplace add Lightprotocol/skills /plugin install solana-rent-free-dev ``` 1. Open Settings (**Cmd+Shift+J** / **Ctrl+Shift+J**) 2. Navigate to **Rules & Commands** → **Project Rules** → **Add Rule** → **Remote Rule (GitHub)** 3. Enter: `https://github.com/Lightprotocol/skills.git` ``` npx skills add Lightprotocol/skills ``` For orchestration, install the [general skill](https://zkcompression.com/skill.md): ```bash theme={null} npx skills add https://zkcompression.com ``` ## Setup ```bash theme={null} npm install @lightprotocol/compressed-token@beta \ @lightprotocol/stateless.js@beta ``` Snippets below assume `rpc`, `payer`, `mint`, `owner`, `recipient`, and `amount` are defined. See the [full examples](https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets) for runnable setup. ```typescript theme={null} import { createRpc } from "@lightprotocol/stateless.js"; import { createLoadAtaInstructions, loadAta, createTransferInterfaceInstructions, transferInterface, createUnwrapInstructions, unwrap, getAssociatedTokenAddressInterface, getAtaInterface, wrap, } from "@lightprotocol/compressed-token/unified"; const rpc = createRpc(RPC_ENDPOINT); ``` ## One-time: Create interface PDA to existing SPL Mint For existing SPL mints (e.g. USDC), register the SPL interface once. This creates the omnibus PDA that holds SPL tokens when wrapped to light-token. Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/register-spl-mint.ts). Check if the interface already exists: ```typescript theme={null} import { getSplInterfaceInfos } from "@lightprotocol/compressed-token"; try { const infos = await getSplInterfaceInfos(rpc, mint); const exists = infos.some((i) => i.isInitialized); console.log("Interface exists:", exists); } catch { console.log("No interface registered for this mint."); } ``` Register: ```typescript theme={null} import { Transaction, sendAndConfirmTransaction } from "@solana/web3.js"; import { LightTokenProgram } from "@lightprotocol/compressed-token"; import { TOKEN_PROGRAM_ID } from "@solana/spl-token"; const ix = await LightTokenProgram.createSplInterface({ feePayer: payer.publicKey, mint, tokenProgramId: TOKEN_PROGRAM_ID, }); const tx = new Transaction().add(ix); await sendAndConfirmTransaction(rpc, tx, [payer]); ``` ```typescript theme={null} import { createSplInterface } from "@lightprotocol/compressed-token"; await createSplInterface(rpc, payer, mint); ``` Use `createMintInterface` with `TOKEN_PROGRAM_ID` to create a new SPL mint and register the interface in one transaction: ```typescript theme={null} import { createMintInterface } from "@lightprotocol/compressed-token/unified"; import { TOKEN_PROGRAM_ID } from "@solana/spl-token"; const { mint } = await createMintInterface( rpc, payer, payer, null, 9, undefined, undefined, TOKEN_PROGRAM_ID ); ``` ### Receive Payments Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/receive.ts). Load creates the associated token account (ATA) if needed and loads any compressed state into it. Share the ATA address with the sender. **About loading**: Light Token accounts reduce account rent \~200x by auto-compressing inactive accounts. Before any action, the SDK detects cold balances and adds instructions to load them. This almost always fits in a single atomic transaction with your regular transfer. APIs return `TransactionInstruction[][]` so the same loop handles the rare multi-transaction case automatically. ```typescript theme={null} import { Transaction } from "@solana/web3.js"; import { createLoadAtaInstructions, getAssociatedTokenAddressInterface, } from "@lightprotocol/compressed-token/unified"; const ata = getAssociatedTokenAddressInterface(mint, recipient); // Returns TransactionInstruction[][]. // Each inner array is one transaction. // Almost always returns just one. const instructions = await createLoadAtaInstructions( rpc, ata, recipient, mint, payer.publicKey ); for (const ixs of instructions) { const tx = new Transaction().add(...ixs); // sign and send ... } ``` ```typescript theme={null} import { loadAta, getAssociatedTokenAddressInterface, } from "@lightprotocol/compressed-token/unified"; const ata = getAssociatedTokenAddressInterface(mint, recipient); const sig = await loadAta(rpc, ata, recipient, mint, payer); if (sig) console.log("Loaded:", sig); ``` ```typescript theme={null} import { createAssociatedTokenAccountInstruction, getAssociatedTokenAddressSync, getOrCreateAssociatedTokenAccount, } from "@solana/spl-token"; const ata = getAssociatedTokenAddressSync(mint, recipient); // Instruction: const tx = new Transaction().add( createAssociatedTokenAccountInstruction(payer.publicKey, ata, recipient, mint) ); // Action: const ata = await getOrCreateAssociatedTokenAccount( connection, payer, mint, recipient ); ``` ### Send Payments Find a full code example: [instruction](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/send-instruction.ts) | [action](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/send-action.ts). ```typescript theme={null} import { Transaction } from "@solana/web3.js"; import { createTransferInterfaceInstructions } from "@lightprotocol/compressed-token/unified"; // Returns TransactionInstruction[][]. // Each inner array is one transaction. // Almost always returns just one. const instructions = await createTransferInterfaceInstructions( rpc, payer.publicKey, mint, amount, owner.publicKey, recipient ); for (const ixs of instructions) { const tx = new Transaction().add(...ixs); // sign and send ... } ``` Your app logic may require you to create a single sign request for your user. Here's how to do this: ```typescript theme={null} const transactions = instructions.map((ixs) => new Transaction().add(...ixs)); // One approval for all const signed = await wallet.signAllTransactions(transactions); for (const tx of signed) { // send... await sendAndConfirmTransaction(rpc, tx); } ``` While almost always you will have only one transfer transaction, you can optimize sending in the rare cases where you have multiple transactions. parallelize the loads, confirm them, and then send the transfer instruction after. ```typescript theme={null} import { createTransferInterfaceInstructions, sliceLast, } from "@lightprotocol/compressed-token/unified"; const instructions = await createTransferInterfaceInstructions( rpc, payer.publicKey, mint, amount, owner.publicKey, recipient ); const { rest: loadInstructions, last: transferInstructions } = sliceLast(instructions); // empty = nothing to load, will no-op. await Promise.all( loadInstructions.map((ixs) => { const tx = new Transaction().add(...ixs); tx.sign(payer, owner); return sendAndConfirmTransaction(rpc, tx); }) ); const transferTx = new Transaction().add(...transferInstructions); transferTx.sign(payer, owner); await sendAndConfirmTransaction(rpc, transferTx); ``` ```typescript theme={null} import { getAssociatedTokenAddressSync, createAssociatedTokenAccountIdempotentInstruction, createTransferInstruction, } from "@solana/spl-token"; const sourceAta = getAssociatedTokenAddressSync(mint, owner.publicKey); const destinationAta = getAssociatedTokenAddressSync(mint, recipient); const tx = new Transaction().add( createAssociatedTokenAccountIdempotentInstruction( payer.publicKey, destinationAta, recipient, mint ), createTransferInstruction(sourceAta, destinationAta, owner.publicKey, amount) ); ``` ```typescript theme={null} import { getAssociatedTokenAddressInterface, transferInterface, } from "@lightprotocol/compressed-token/unified"; const sourceAta = getAssociatedTokenAddressInterface(mint, owner.publicKey); // Handles loading, creates recipient ATA, transfers. await transferInterface(rpc, payer, sourceAta, mint, recipient, owner, amount); ``` ```typescript theme={null} import { getAssociatedTokenAddressSync, getOrCreateAssociatedTokenAccount, transfer, } from "@solana/spl-token"; await getOrCreateAssociatedTokenAccount(connection, payer, mint, recipient); const sourceAta = getAssociatedTokenAddressSync(mint, owner.publicKey); const destinationAta = getAssociatedTokenAddressSync(mint, recipient); await transfer(connection, payer, sourceAta, destinationAta, owner, amount); ``` ### Show Balance Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/get-balance.ts). ```typescript theme={null} import { getAssociatedTokenAddressInterface, getAtaInterface, } from "@lightprotocol/compressed-token/unified"; const ata = getAssociatedTokenAddressInterface(mint, owner); const account = await getAtaInterface(rpc, ata, owner, mint); console.log(account.parsed.amount); ``` ```typescript theme={null} import { getAccount } from "@solana/spl-token"; const account = await getAccount(connection, ata); console.log(account.amount); ``` ### Transaction History Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/get-history.ts). ```typescript theme={null} const result = await rpc.getSignaturesForOwnerInterface(owner); console.log(result.signatures); // Merged + deduplicated console.log(result.solana); // On-chain txs only console.log(result.compressed); // Compressed txs only ``` Use `getSignaturesForAddressInterface(address)` if you want address-specific rather than owner-wide history. ```typescript theme={null} const signatures = await connection.getSignaturesForAddress(ata); ``` ### Wrap from SPL Wrap tokens from SPL/Token-2022 accounts to light-token ATA. Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/wrap.ts). ```typescript theme={null} import { Transaction } from "@solana/web3.js"; import { getAssociatedTokenAddressSync } from "@solana/spl-token"; import { createWrapInstruction, getAssociatedTokenAddressInterface, } from "@lightprotocol/compressed-token/unified"; import { getSplInterfaceInfos } from "@lightprotocol/compressed-token"; const splAta = getAssociatedTokenAddressSync(mint, owner.publicKey); const tokenAta = getAssociatedTokenAddressInterface(mint, owner.publicKey); const splInterfaceInfos = await getSplInterfaceInfos(rpc, mint); const splInterfaceInfo = splInterfaceInfos.find((i) => i.isInitialized); const tx = new Transaction().add( createWrapInstruction( splAta, tokenAta, owner.publicKey, mint, amount, splInterfaceInfo, decimals, payer.publicKey ) ); ``` ```typescript theme={null} import { getAssociatedTokenAddressSync } from "@solana/spl-token"; import { wrap, getAssociatedTokenAddressInterface, } from "@lightprotocol/compressed-token/unified"; const splAta = getAssociatedTokenAddressSync(mint, owner.publicKey); const tokenAta = getAssociatedTokenAddressInterface(mint, owner.publicKey); await wrap(rpc, payer, splAta, tokenAta, owner, mint, amount); ``` ### Unwrap to SPL Unwrap moves the token balance from a light-token account to a SPL-token account. Use this to compose with applications that do not yet support light-token. Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/unwrap.ts). ```typescript theme={null} import { Transaction } from "@solana/web3.js"; import { getAssociatedTokenAddressSync } from "@solana/spl-token"; import { createUnwrapInstructions } from "@lightprotocol/compressed-token/unified"; const splAta = getAssociatedTokenAddressSync(mint, owner.publicKey); // Each inner array = one transaction. Handles loading + unwrapping together. const instructions = await createUnwrapInstructions( rpc, splAta, owner.publicKey, mint, amount, payer.publicKey ); for (const ixs of instructions) { const tx = new Transaction().add(...ixs); await sendAndConfirmTransaction(rpc, tx, [payer, owner]); } ``` ```typescript theme={null} import { getAssociatedTokenAddressSync } from "@solana/spl-token"; import { unwrap } from "@lightprotocol/compressed-token/unified"; const splAta = getAssociatedTokenAddressSync(mint, owner.publicKey); await unwrap(rpc, payer, splAta, owner, mint, amount); ``` {`--- description: Integrate light-token APIs for stablecoin payments allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Integrate light-token APIs for stablecoin payments Context: - Guide: https://zkcompression.com/light-token/toolkits/for-payments - Skills and resources index: https://zkcompression.com/skill.md - Dedicated skill: https://github.com/Lightprotocol/skills/tree/main/skills/payments-and-wallets - Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js - Full examples: https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets SPL → Light Token API mapping: | Operation | SPL | Light Token | | Receive | getOrCreateAssociatedTokenAccount() | createLoadAtaInstructions() / loadAta() | | Transfer | createTransferInstruction() | createTransferInterfaceInstructions() | | Get Balance | getAccount() | getAtaInterface() | | Tx History | getSignaturesForAddress() | getSignaturesForOwnerInterface() | | Wrap SPL | N/A | createWrapInstruction() / wrap() | | Unwrap | N/A | createUnwrapInstructions() / unwrap() | ### 1. Index project - Grep \`@solana/spl-token|@lightprotocol|createTransferInstruction|getAccount|Connection|Keypair|stablecoin|payment\` across src/ - Glob \`**/*.ts\` and \`**/*.tsx\` for project structure - Identify: RPC setup, existing token operations, payment flow, wallet signing pattern - Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies - Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel ### 2. Read references - WebFetch the guide above — review Instruction and Action tabs for each operation - 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 payment integration, migrate existing SPL payment flow, add alongside existing SPL) - AskUserQuestion: which operations? (receive, send, balance, history, wrap, unwrap — or all) - AskUserQuestion: instruction-level API (build your own transactions) or action-level API (high-level, fewer lines)? - 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 (createRpc with ZK Compression endpoint) - Key pattern: import from \`@lightprotocol/compressed-token/unified\` for all interface APIs - 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\` - Set up RPC: \`createRpc(RPC_ENDPOINT)\` with a ZK Compression endpoint (Helius, Triton) - Import from \`@lightprotocol/compressed-token/unified\` for the interface APIs - Follow the 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: Integrate light-token APIs for stablecoin payments allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression --- ## Integrate light-token APIs for stablecoin payments Context: - Guide: https://zkcompression.com/light-token/toolkits/for-payments - Skills and resources index: https://zkcompression.com/skill.md - Dedicated skill: https://github.com/Lightprotocol/skills/tree/main/skills/payments-and-wallets - Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js - Full examples: https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets SPL → Light Token API mapping: | Operation | SPL | Light Token | | Receive | getOrCreateAssociatedTokenAccount() | createLoadAtaInstructions() / loadAta() | | Transfer | createTransferInstruction() | createTransferInterfaceInstructions() | | Get Balance | getAccount() | getAtaInterface() | | Tx History | getSignaturesForAddress() | getSignaturesForOwnerInterface() | | Wrap SPL | N/A | createWrapInstruction() / wrap() | | Unwrap | N/A | createUnwrapInstructions() / unwrap() | ### 1. Index project - Grep `@solana/spl-token|@lightprotocol|createTransferInstruction|getAccount|Connection|Keypair|stablecoin|payment` across src/ - Glob `**/*.ts` and `**/*.tsx` for project structure - Identify: RPC setup, existing token operations, payment flow, wallet signing pattern - Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies - Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel ### 2. Read references - WebFetch the guide above — review Instruction and Action tabs for each operation - 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 payment integration, migrate existing SPL payment flow, add alongside existing SPL) - AskUserQuestion: which operations? (receive, send, balance, history, wrap, unwrap — or all) - AskUserQuestion: instruction-level API (build your own transactions) or action-level API (high-level, fewer lines)? - 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 (createRpc with ZK Compression endpoint) - Key pattern: import from `@lightprotocol/compressed-token/unified` for all interface APIs - 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` - Set up RPC: `createRpc(RPC_ENDPOINT)` with a ZK Compression endpoint (Helius, Triton) - Import from `@lightprotocol/compressed-token/unified` for the interface APIs - Follow the 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 ```