> ## Documentation Index > Fetch the complete documentation index at: https://www.zkcompression.com/llms.txt > Use this file to discover all available pages before exploring further. # Payment Flows on Solana with Light Token > Learn how the Light Token SDK reduces SPL account creation cost for payment infrastructure by 99%. export const lightCreateAtaCpiCode = ["use light_token::instruction::CreateAssociatedAccountCpi;", "", "CreateAssociatedAccountCpi {", " payer: payer.clone(),", " owner: owner.clone(),", " mint: mint.clone(),", " ata: associated_token_account.clone(),", " bump,", "}", ".rent_free(", " compressible_config.clone(),", " rent_sponsor.clone(),", " system_program.clone(),", ")", ".invoke()?"].join("\n"); export const splCreateAtaCpiCode = ["use spl_associated_token_account::instruction::create_associated_token_account;", "", "let ix = create_associated_token_account(", " &payer.pubkey(),", " &owner.pubkey(),", " &mint,", " &spl_token::id(),", ");", "", "invoke(&ix, &[payer, owner, mint])?;"].join("\n"); export const lightCreateAtaMacroCode = ["#[light_account(", " init,", " associated_token::authority = ata_owner,", " associated_token::mint = ata_mint,", " associated_token::bump = params.ata_bump", ")]", "pub ata: UncheckedAccount<'info>,"].join("\n"); export const splCreateAtaMacroCode = ["#[account(", " init,", " payer = fee_payer,", " associated_token::mint = mint,", " associated_token::authority = owner,", ")]", "pub ata: Account<'info, TokenAccount>,"].join("\n"); export const lightCreateAtaRustCode = ["use light_token::instruction::CreateAssociatedTokenAccount;", "", "let ix = CreateAssociatedTokenAccount::new(", " payer.pubkey(),", " owner.pubkey(),", " mint,", ")", ".instruction()?;"].join("\n"); export const splCreateAtaRustCode = ["use spl_associated_token_account::instruction::create_associated_token_account;", "", "let ix = create_associated_token_account(", " &payer.pubkey(),", " &owner.pubkey(),", " &mint,", " &spl_token::id(),", ");"].join("\n"); export const lightCreateAtaIxCode = ['import { createAssociatedTokenAccountInterfaceInstruction } from "@lightprotocol/compressed-token";', "", "const ix = createAssociatedTokenAccountInterfaceInstruction(", " payer.publicKey,", " ata,", " owner.publicKey,", " mint", ");"].join("\n"); export const splCreateAtaIxCode = ['import { createAssociatedTokenAccountInstruction } from "@solana/spl-token";', "", "const ix = createAssociatedTokenAccountInstruction(", " payer.publicKey,", " ata,", " owner.publicKey,", " mint", ");"].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 =>
)}
; }; *** Payment flows on Solana include five core concepts: 1. wallets for sender and recipient 2. stablecoins as transferred asset type (USDC, USDG, ...) 3. token accounts to hold balances 4. fees for transactions and account creation 5. transactions to execute the transfer Our token APIs optimize the account creation cost component. You typically create an account (1) when onboarding a new user, and (2) when the recipient does not hold the transferred token yet. | | Light | SPL / Token 2022 | | :---------------------------------- | :--------------------------- | :------------------------ | | **Transfer** | *\~\$0.001* | *\~\$0.001* | | **Create Token Account** | **\~\$0.001** (0.000017 SOL) | **\~\$0.29** (0.0029 SOL) | | **Transfer + Create Token Account** | **\~\$0.001** (0.000017 SOL) | **\~\$0.29** (0.0029 SOL) | While transfer cost is identical, you can expect \~\$0.29 total when creating a new token account using SPL/Token 2022. With Light Token, the total cost will be around \$0.001, regardless of whether a new account is created. Your users use the same stablecoins, just stored more efficiently. The token standard pays rent-exemption cost for you. To prevent griefing, “rent” is paid over time to keep an account in memory. This is dealt with under the hood in a way that doesn’t disrupt the UX of what your users are used to with SPL-token. **Rent-exemption: paid by a rent sponsor PDA.** **Top-ups: paid by the fee payer.** The `feePayer` on the transaction bumps a small virtual rent balance (766 lamports by default) on each write to keep the account active (hot balance). Set your application as the fee payer so users never interact with SOL. **Hot-Cold Lifecycle of Accounts.** Accounts get auto-compressed (cold balance) when the virtual rent balance goes below a threshold (eg 24h without write bump). The cold account's state is cryptographically preserved on the Solana ledger. Users only interact with hot accounts and load the cold balance in-flight when using the account again.
Account lifecycle
Account lifecycle
You can abstract fees entirely so users never interact with SOL. See [gasless transactions](/light-token/wallets/gasless-transactions) to sponsor rent top-ups and transaction fees. ## API Comparison Transactions with Light Token APIs mirror SPL / Token 2022, so you can build transactions with a similar developer experience. For example, here is the creation of an associated token account: ## Interoperability The Light Token APIs cover every SPL Token operation and adds extra capabilities:
Category What it does
**Cross-program dispatch** `Interface` methods (e.g., `transferInterface`) auto-detect the token program and dispatch to SPL, Token 2022, or Light Token.
**Unified balance** `getAtaInterface` returns a unified balance for a given mint, aggregating Light Token (hot + cold), SPL, and Token 2022 sources.
**Wrap / Unwrap** For interoperability with applications that don't support Light Token yet, you can wrap / unwrap SPL or Token 2022 tokens into Light Token associated token accounts and back.
## Token Extensions Token extensions introduce optional features you can add to a token mint or token account through extra instructions. Light Token supports most Token 2022 extensions. ## Start Integrating ### Payment Skill for Agents Use the [payments](https://github.com/Lightprotocol/skills/tree/main/skills/payments) agent skill to add light-token payment support to your project: ``` 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 ``` ### Payment Flows ### Fee Abstraction ### Signing ### Go to Production *** ## Didn't find what you were looking for? Reach out! [Telegram](https://t.me/swen_light) | [email](mailto:support@lightprotocol.com) | [Discord](https://discord.com/invite/7cJ8BhAXhu)