{ "schemaVersion": 1, "scope": "Transaction-related source, tests and dependency lockfile; not the entire application.", "files": { "lib/burn-domain.ts": "export const APP_FEE = 20_000n;\nexport const FEE_WALLET = \"Htj8rb2dH75AsBawvhQPCDtXBwL3FpAX5bS7SYWkaLEr\";\nexport const TOKEN_PROGRAM = \"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA\";\nexport const TOKEN_2022 = \"TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb\";\nexport const NATIVE_MINTS = [\"So11111111111111111111111111111111111111112\", \"9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP\"];\nexport type Network = \"mainnet\" | \"devnet\";\nexport interface TokenAccount { address: string; amount: string; lamports: string; closeAuthority: string | null; frozen: boolean; unsupported: boolean; withheldAmount?: string; }\nexport interface TokenHolding { mint: string; program: string; name: string; symbol: string; decimals: number; supply: string; balance: string; accounts: TokenAccount[]; reason?: string; notices?: string[]; closeReason?: string; }\nexport interface BurnReceipt { signature: string; network: Network; mint: string; owner: string; amount: string; decimals: number; timestamp: number | null; fee: string; networkFee: string; reclaimed: string; slot: number; }\nexport function networkOf(value: string): Network { if(value !== \"mainnet\" && value !== \"devnet\") throw Error(\"Choose mainnet or devnet.\"); return value; }\nexport function parseAmount(value: string, decimals: number): bigint {\n if(!Number.isInteger(decimals) || decimals < 0 || decimals > 255) throw Error(\"Unsupported token precision.\");\n if(!/^\\d+(\\.\\d*)?$/.test(value) || value.length > 280) throw Error(\"Enter a token amount using numbers and a decimal point.\");\n const [whole, fraction = \"\"] = value.split(\".\");\n if(fraction.length > decimals) throw Error(`This token supports ${decimals} decimal places.`);\n const amount = BigInt(whole) * 10n ** BigInt(decimals) + BigInt(fraction.padEnd(decimals, \"0\") || \"0\");\n if(amount <= 0n) throw Error(\"Enter an amount greater than zero.\");\n if(amount > 18446744073709551615n) throw Error(\"Amount exceeds the token limit.\");\n return amount;\n}\nexport function formatAmount(value: bigint | string, decimals: number): string {\n const n = BigInt(value); const sign = n < 0n ? \"-\" : \"\"; const digits = (n < 0n ? -n : n).toString().padStart(decimals + 1, \"0\");\n if(!decimals) return sign + digits;\n return sign + digits.slice(0, -decimals) + (digits.slice(-decimals).replace(/0+$/, \"\") ? \".\" + digits.slice(-decimals).replace(/0+$/, \"\") : \"\");\n}\nexport const short = (v: string) => v.length > 14 ? `${v.slice(0, 5)}…${v.slice(-5)}` : v;\nexport const sol = (v: bigint | string) => formatAmount(v, 9);\nexport function supplyPercent(amount: bigint, supply: string) { const s=BigInt(supply); if(!s) return \"—\"; const p=amount*100000000n/s; return p===0n&&amount>0n?\"<0.000001%\":formatAmount(p,6)+\"%\"; }\nexport function allocateBurn(token: TokenHolding, amount: bigint, owner: string, close: boolean) {\n if(token.reason) throw Error(token.reason);\n if(amount <= 0n || amount > BigInt(token.balance)) throw Error(\"Amount exceeds your available token balance.\");\n if(close && amount !== BigInt(token.balance)) throw Error(\"Only a full burn can close the token accounts.\");\n if(close && (token.closeReason || token.accounts.some(a=>BigInt(a.withheldAmount??\"0\")>0n))) throw Error(token.closeReason??\"Withheld transfer fees prevent closing this account. You can burn and keep it open.\");\n let left=amount;\n const burns: {account: TokenAccount; amount: bigint}[]=[];\n for(const account of [...token.accounts].sort((a,b)=>a.address.localeCompare(b.address))) {\n if(account.frozen || account.unsupported) throw Error(\"This token has a frozen or unsupported account.\");\n const take=left < BigInt(account.amount) ? left : BigInt(account.amount);\n if(take>0n) burns.push({account,amount:take});\n left-=take;\n }\n if(left) throw Error(\"Your balance changed. Refresh and review again.\");\n const closes=close ? token.accounts : [];\n if(closes.some(a=>a.closeAuthority && a.closeAuthority!==owner)) throw Error(\"Your wallet does not have authority to close this account.\");\n return {burns,closes,reclaimed:closes.reduce((n,a)=>n+BigInt(a.lamports),0n)};\n}\nexport const explorer = (signature: string, network: Network) => `https://explorer.solana.com/tx/${signature}${network === \"devnet\" ? \"?cluster=devnet\" : \"\"}`;\n", "lib/transactions.ts": "import { address, blockhash, createNoopSigner, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, compileTransaction, getTransactionEncoder, getTransactionDecoder, getCompiledTransactionMessageDecoder, getBase58Decoder } from \"@solana/kit\";\nimport { getBurnCheckedInstruction, getCloseAccountInstruction } from \"@solana-program/token\";\nimport { getTransferSolInstruction } from \"@solana-program/system\";\nimport { APP_FEE, FEE_WALLET, TOKEN_PROGRAM, TOKEN_2022, allocateBurn, type TokenHolding } from \"./burn-domain\";\nexport const toBase64 = (bytes: ArrayLike) => btoa(Array.from(bytes,b=>String.fromCharCode(b)).join(\"\"));\nexport const fromBase64 = (value: string) => Uint8Array.from(atob(value),c=>c.charCodeAt(0));\nexport function buildBurnTransaction(input: {token:TokenHolding;amount:bigint;owner:string;close:boolean;blockhash:string;lastValidBlockHeight:bigint}) {\n const {token,amount,owner,close}=input;\n if(![TOKEN_PROGRAM,TOKEN_2022].includes(token.program))throw Error(\"Unsupported token program.\");\n const allocation=allocateBurn(token,amount,owner,close);\n const signer=createNoopSigner(address(owner));\n const config={programAddress:address(token.program)};\n const instructions = [\n ...allocation.burns.map(b=>getBurnCheckedInstruction({account:address(b.account.address),mint:address(token.mint),authority:signer,amount:b.amount,decimals:token.decimals},config)),\n ...allocation.closes.map(a=>getCloseAccountInstruction({account:address(a.address),destination:address(owner),owner:signer},config)),\n getTransferSolInstruction({source:signer,destination:address(FEE_WALLET),amount:APP_FEE})\n ];\n const message=appendTransactionMessageInstructions(instructions,setTransactionMessageLifetimeUsingBlockhash({blockhash:blockhash(input.blockhash),lastValidBlockHeight:input.lastValidBlockHeight},setTransactionMessageFeePayer(address(owner),createTransactionMessage({version:\"legacy\"}))));\n const tx=compileTransaction(message);\n const bytes=new Uint8Array(getTransactionEncoder().encode(tx));\n if(bytes.length>1232) throw Error(\"These token accounts cannot fit in one transaction. Choose a smaller amount.\");\n return {transaction:toBase64(bytes),message:toBase64(tx.messageBytes),reclaimed:allocation.reclaimed.toString(),accountsClosed:allocation.closes.length};\n}\nexport function inspectWireTransaction(wire: Uint8Array, requireSignature=true) {\n if(wire.length>1232) throw Error(\"Transaction is too large.\");\n const tx=getTransactionDecoder().decode(wire);\n const message=getCompiledTransactionMessageDecoder().decode(tx.messageBytes);\n if(message.version!==\"legacy\" || message.header.numSignerAccounts!==1) throw Error(\"Unsupported transaction format.\");\n const owner=message.staticAccounts[0];\n let fees=0; let mint:string|undefined; const burns=new Set(); const closes=new Set();\n const burnDetails:{account:string;mint:string;program:string;amount:string;decimals:number}[]=[];\n for(const ix of message.instructions) {\n const program=message.staticAccounts[ix.programAddressIndex];\n const keys=(ix.accountIndices??[]).map(n=>message.staticAccounts[n]);\n const data=new Uint8Array(ix.data??[]); const view=new DataView(data.buffer);\n if(program===TOKEN_PROGRAM || program===TOKEN_2022) {\n if(data.length===10 && data[0]===15 && keys.length===3 && keys[2]===owner && view.getBigUint64(1,true)>0n) {\n if(mint && mint!==keys[1]) throw Error(\"Only one token can be burned at a time.\");\n mint=keys[1]; if(burns.has(keys[0])) throw Error(\"Duplicate burn instruction.\"); burns.add(keys[0]);\n burnDetails.push({account:keys[0],mint:keys[1],program,amount:view.getBigUint64(1,true).toString(),decimals:data[9]});\n } else if(data.length===1 && data[0]===9 && keys.length===3 && keys[1]===owner && keys[2]===owner && !closes.has(keys[0])) {closes.add(keys[0]);}\n else throw Error(\"Unsupported token instruction.\");\n } else if(program===\"11111111111111111111111111111111\" && data.length===12 && view.getUint32(0,true)===2 && view.getBigUint64(4,true)===APP_FEE && keys.length===2 && keys[0]===owner && keys[1]===FEE_WALLET) {fees++;}\n else throw Error(\"Unexpected transaction instruction.\");\n }\n if(fees!==1 || !burns.size) throw Error(\"A SolanaBurner transaction requires a burn and exactly one app fee.\");\n const sig=tx.signatures[owner];\n if(requireSignature && (!sig || !Array.from(sig).some(Boolean))) throw Error(\"The wallet has not signed this transaction.\");\n if(burnDetails.some(b=>b.program!==burnDetails[0].program||b.decimals!==burnDetails[0].decimals))throw Error(\"Inconsistent token program or decimals.\");\n return {owner,signature:sig?getBase58Decoder().decode(sig):null,messageBytes:tx.messageBytes,mint,closes:[...closes],burns:burnDetails,appFee:APP_FEE.toString(),feeRecipient:FEE_WALLET};\n}\n/** Rebuild locally from the user's selection, then compare the complete serialized message. */\nexport function assertMatchesBurnIntent(transaction:string,input:{token:TokenHolding;amount:bigint;owner:string;close:boolean}){\n const decoded=getTransactionDecoder().decode(fromBase64(transaction));\n const message=getCompiledTransactionMessageDecoder().decode(decoded.messageBytes);\n const expected=buildBurnTransaction({...input,blockhash:message.lifetimeToken,lastValidBlockHeight:0n});\n if(toBase64(decoded.messageBytes)!==expected.message)throw Error(\"The prepared transaction does not match your chosen burn. Nothing was sent to your wallet.\");\n return inspectWireTransaction(fromBase64(transaction),false);\n}\nexport function assertUnchangedTransaction(unsigned: string, signed: Uint8Array) {\n const before=inspectWireTransaction(fromBase64(unsigned),false);\n const after=inspectWireTransaction(signed);\n if(toBase64(before.messageBytes)!==toBase64(after.messageBytes)) throw Error(\"The wallet changed the transaction. Review a fresh burn instead.\");\n return after.signature!;\n}\n\r\n", "lib/proof.ts": "import { APP_FEE, FEE_WALLET, TOKEN_PROGRAM, TOKEN_2022, type BurnReceipt, type Network } from \"./burn-domain\";\nexport interface ParsedInstruction { programId: string; parsed?:{type:string;info:Record}; }\ninterface TokenBalance {accountIndex:number;mint:string;owner?:string;uiTokenAmount:{amount:string;decimals:number};}\nexport interface ParsedTransaction {\n slot:number;blockTime:number|null;\n transaction:{signatures:string[];message:{accountKeys:{pubkey:string;signer:boolean}[];instructions:ParsedInstruction[]}};\n meta:{err:unknown;fee:number;preBalances:number[];postBalances:number[];preTokenBalances:TokenBalance[];postTokenBalances:TokenBalance[]}|null;\n}\nexport function verifyReceipt(tx:ParsedTransaction,signature:string,network:Network): BurnReceipt {\n if(!tx.meta || tx.meta.err!==null || tx.transaction.signatures[0]!==signature) throw Error(\"This is not a successful burn transaction.\");\n const keys=tx.transaction.message.accountKeys;const owner=keys[0]?.pubkey;\n if(!owner||!keys[0].signer||keys.filter(k=>k.signer).length!==1)throw Error(\"Unsupported burn authority.\");\n let mint=\"\";let amount=0n;let decimals=-1;let feeCount=0;let reclaimed=0n;\n const burns=new Set();const closes=new Set();\n for(const ix of tx.transaction.message.instructions) {\n const p=ix.parsed; if(!p)throw Error(\"Unrecognized transaction instruction.\");\n const i=p.info;\n if([TOKEN_PROGRAM,TOKEN_2022].includes(ix.programId)&&p.type===\"burnChecked\") {\n const a=i.tokenAmount as {amount:string;decimals:number}|undefined;\n if(typeof i.account!==\"string\"||typeof i.mint!==\"string\"||i.authority!==owner||!a||!/^\\d+$/.test(a.amount)||BigInt(a.amount)<=0n||!Number.isInteger(a.decimals)||a.decimals<0||a.decimals>255)throw Error(\"Invalid burn details.\");\n if(mint && (mint!==i.mint||decimals!==a.decimals))throw Error(\"Receipt requires a single token mint.\");\n if(burns.has(i.account))throw Error(\"Duplicate burn account.\");\n burns.add(i.account);mint=i.mint;decimals=a.decimals;amount+=BigInt(a.amount);\n const index=keys.findIndex(k=>k.pubkey===i.account);\n const pre=tx.meta.preTokenBalances.find(b=>b.accountIndex===index);\n const post=tx.meta.postTokenBalances.find(b=>b.accountIndex===index);\n if(!pre||pre.owner!==owner||pre.mint!==mint||pre.uiTokenAmount.decimals!==decimals||(post&&(post.mint!==mint||post.owner!==owner||post.uiTokenAmount.decimals!==decimals))||BigInt(pre.uiTokenAmount.amount)-BigInt(post?.uiTokenAmount.amount??\"0\")!==BigInt(a.amount))throw Error(\"Token balance change does not match the burn.\");\n } else if(ix.programId===\"11111111111111111111111111111111\"&&p.type===\"transfer\"&&i.source===owner&&i.destination===FEE_WALLET&&String(i.lamports)===APP_FEE.toString()) {feeCount++;}\n else if([TOKEN_PROGRAM,TOKEN_2022].includes(ix.programId)&&p.type===\"closeAccount\"&&i.destination===owner&&i.owner===owner&&typeof i.account===\"string\"){\n if(closes.has(i.account))throw Error(\"Duplicate closure.\");closes.add(i.account);\n const index=keys.findIndex(k=>k.pubkey===i.account);\n if(index<0||tx.meta.postBalances[index]!==0)throw Error(\"Account closure could not be verified.\");\n reclaimed+=BigInt(tx.meta.preBalances[index]);\n } else throw Error(\"This transaction is not a supported SolanaBurner burn.\");\n }\n if(!amount||feeCount!==1)throw Error(\"No verified SolanaBurner burn and fee were found.\");\n for(const closed of closes){const index=keys.findIndex(k=>k.pubkey===closed);const pre=tx.meta.preTokenBalances.find(b=>b.accountIndex===index);if(!pre||pre.owner!==owner||pre.mint!==mint||(!burns.has(closed)&&BigInt(pre.uiTokenAmount.amount)!==0n))throw Error(\"Unrelated account closure.\");}\n return {signature,network,mint,owner,amount:amount.toString(),decimals,timestamp:tx.blockTime,fee:APP_FEE.toString(),networkFee:String(tx.meta.fee),reclaimed:reclaimed.toString(),slot:tx.slot};\n}\n", "lib/holdings.server.ts": "import { address, getProgramDerivedAddress, getAddressEncoder, getUtf8Encoder } from \"@solana/kit\";\nimport { rpc, validAddress } from \"./rpc.server\";\nimport { TOKEN_PROGRAM, TOKEN_2022, NATIVE_MINTS, short, formatAmount, type TokenHolding, type Network } from \"./burn-domain\";\ntype Extension={extension:string;state?:Record};\ntype Info={mint?:string;owner?:string;tokenAmount?:{amount:string;decimals:number};decimals?:number;supply?:string;state?:string;closeAuthority?:string;mintAuthority?:string|null;freezeAuthority?:string|null;extensions?:Extension[]};\ntype Account={lamports:number;owner:string;data:{parsed?:{type:string;info:Info}}};\nconst mintExtensions=new Set([\"metadataPointer\",\"tokenMetadata\",\"mintCloseAuthority\",\"transferFeeConfig\"]);\nconst accountExtensions=new Set([\"immutableOwner\",\"transferFeeAmount\"]);\nconst META=address(\"metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s\");\nexport function unsupportedExtensions(extensions: Extension[] = [], mint=false) {return extensions.some(e=>!(mint?mintExtensions:accountExtensions).has(e.extension));}\nfunction decodeMetadata(data:string): {name:string;symbol:string;standard?:number} {\n const b=Uint8Array.from(atob(data),c=>c.charCodeAt(0)); const v=new DataView(b.buffer);let o=65;\n const str=()=>{const n=v.getUint32(o,true);o+=4;if(n>1000||o+n>b.length)throw Error(\"Invalid metadata\");const s=new TextDecoder().decode(b.slice(o,o+n)).replace(/\\0/g,\"\").trim();o+=n;return s;};\n const name=str();const symbol=str();str();o+=2;\n if(b[o++]){const n=v.getUint32(o,true);o+=4+n*34;}\n o+=2;if(b[o++])o++;const standard=b[o++]?b[o]:undefined;\n return {name:name.slice(0,60),symbol:symbol.slice(0,16),standard};\n}\nexport async function getHoldings(network:Network,owner:string,onlyMint?:string) {\n validAddress(owner); if(onlyMint)validAddress(onlyMint);\n const results=await Promise.all([TOKEN_PROGRAM,TOKEN_2022].map(program=>rpc<{value:{pubkey:string;account:Account}[];context:{slot:number}}>(network,\"getTokenAccountsByOwner\",[owner,{programId:program},{encoding:\"jsonParsed\",commitment:\"confirmed\"}])));\n const groups=new Map();\n for(const result of results)for(const {pubkey,account} of result.value) {\n const info=account.data.parsed?.info; if(!info?.mint||!info.tokenAmount||info.owner!==owner||NATIVE_MINTS.includes(info.mint)||onlyMint&&onlyMint!==info.mint)continue;\n const token=groups.get(info.mint)??{mint:info.mint,program:account.owner,name:`Token ${short(info.mint)}`,symbol:short(info.mint),decimals:info.tokenAmount.decimals,supply:\"0\",balance:\"0\",accounts:[]};\n token.balance=(BigInt(token.balance)+BigInt(info.tokenAmount.amount)).toString();\n const withheld=info.extensions?.find(e=>e.extension===\"transferFeeAmount\")?.state?.withheldAmount;\n token.accounts.push({address:pubkey,amount:info.tokenAmount.amount,lamports:String(account.lamports),closeAuthority:info.closeAuthority??null,frozen:info.state===\"frozen\",unsupported:unsupportedExtensions(info.extensions),withheldAmount:String(withheld??\"0\")});\n groups.set(info.mint,token);\n }\n const tokens=[...groups.values()].filter(t=>BigInt(t.balance)>0n);\n let currentEpoch:number|undefined;\n for(let i=0;i(network,\"getMultipleAccounts\",[batch.map(t=>t.mint),{encoding:\"jsonParsed\",commitment:\"confirmed\"}]);\n if(currentEpoch===undefined&&mints.value.some(m=>m?.data.parsed?.info.extensions?.some(e=>e.extension===\"transferFeeConfig\")))currentEpoch=(await rpc<{epoch:number}>(network,\"getEpochInfo\",[{commitment:\"confirmed\"}])).epoch;\n const metadataAddresses=await Promise.all(batch.map(async t=>(await getProgramDerivedAddress({programAddress:META,seeds:[getUtf8Encoder().encode(\"metadata\"),getAddressEncoder().encode(META),getAddressEncoder().encode(address(t.mint))]}))[0]));\n const metadata=await rpc<{value:({owner:string;data:[string,string]}|null)[]}>(network,\"getMultipleAccounts\",[metadataAddresses,{encoding:\"base64\",commitment:\"confirmed\"}]);\n batch.forEach((t,j)=>{\n const mint=mints.value[j]; const info=mint?.data.parsed?.info;\n if(!info||info.supply===undefined||info.decimals===undefined||mint?.owner!==t.program){t.reason=\"This mint could not be verified.\";return;}\n t.supply=info.supply;t.decimals=info.decimals;\n t.notices=[];\n const transferFee=info.extensions?.find(e=>e.extension===\"transferFeeConfig\")?.state;\n if(transferFee){\n const newer=transferFee.newerTransferFee as {epoch:string;maximumFee:string;transferFeeBasisPoints:number}|undefined;\n const older=transferFee.olderTransferFee as typeof newer;\n const active=newer&¤tEpoch!==undefined&&BigInt(currentEpoch)>=BigInt(newer.epoch)?newer:older;\n t.notices.push(active?`This token charges ${formatAmount(String(active.transferFeeBasisPoints),2)}% on transfers (capped at ${formatAmount(active.maximumFee,t.decimals)} tokens). SolanaBurner burns in place: no token transfer tax is charged on this burn.`:\"This token has transfer fees. SolanaBurner burns in place, so its transfer tax is not charged on this burn.\");\n }\n const withheld=t.accounts.reduce((n,a)=>n+BigInt(a.withheldAmount??\"0\"),0n);\n if(withheld>0n){t.closeReason=`${formatAmount(withheld,t.decimals)} tokens are withheld transfer fees. They are separate from your spendable balance and cannot be burned by you. Burn normally and keep these accounts open; closure is unavailable until withheld fees are cleared.`;t.notices.push(t.closeReason);}\n if(info.mintAuthority)t.notices.push(\"The mint authority can create more tokens. Burning reduces today's supply; it does not prevent future minting.\");\n if(info.freezeAuthority)t.notices.push(\"This token has a freeze authority. It can freeze accounts; SolanaBurner checks the current state before signing.\");\n const unsupported=(info.extensions??[]).filter(e=>!mintExtensions.has(e.extension)).map(e=>e.extension.replace(/([a-z])([A-Z])/g,\"$1 $2\").toLowerCase());\n if(unsupported.length||t.accounts.some(a=>a.unsupported))t.reason=`Unsupported token rules${unsupported.length?`: ${unsupported.join(\", \")}`:\" on a token account\"}. SolanaBurner cannot safely prepare this burn yet.`;\n if(t.accounts.some(a=>a.frozen))t.reason=\"This token has a frozen account and cannot be burned here.\";\n if(t.decimals===0&&BigInt(t.supply)<=1n)t.reason=\"NFTs and single-unit tokens are not supported.\";\n const embedded=info.extensions?.find(e=>e.extension===\"tokenMetadata\")?.state;\n if(embedded){if(typeof embedded.name===\"string\")t.name=embedded.name.slice(0,60);if(typeof embedded.symbol===\"string\")t.symbol=embedded.symbol.slice(0,16);}\n const meta=metadata.value[j];\n if(meta?.owner===META)try{const m=decodeMetadata(meta.data[0]);if(m.name)t.name=m.name;if(m.symbol)t.symbol=m.symbol;if(m.standard!==undefined&&![1,2].includes(m.standard))t.reason=\"NFTs are not supported.\";}catch{/* Mint address remains visible when metadata is malformed. */}\n });\n }\n return tokens.sort((a,b)=>Number(!!a.reason)-Number(!!b.reason)||a.name.localeCompare(b.name));\n}\n", "lib/rpc.server.ts": "import { address } from \"@solana/kit\";\nimport type { Network } from \"./burn-domain\";\nexport type Rpc = (network: Network,method:string,params?:unknown[])=>Promise;\nasync function endpoint(network: Network) {\n const vars:Record=process.env;\n const key=network===\"mainnet\"?\"SOLANA_MAINNET_RPC_URL\":\"SOLANA_DEVNET_RPC_URL\";\n const override=typeof vars[key]===\"string\"?(vars[key] as string).trim():\"\";\n if(override){if(!override.startsWith(\"https://\"))throw Error(\"The Solana connection must use HTTPS.\");return override;}\n const helius=typeof vars.HELIUS_API_KEY===\"string\"?vars.HELIUS_API_KEY.trim():\"\";\n if(helius)return `https://${network===\"mainnet\"?\"mainnet\":\"devnet\"}.helius-rpc.com/?api-key=${encodeURIComponent(helius)}`;\n throw Error(\"SolanaBurner’s Solana connection is not configured yet.\");\n}\nexport const rpc: Rpc = async (network:Network,method:string,params:unknown[]=[]) => {\n const url=await endpoint(network);\n let response:Response;\n try {response=await fetch(url,{method:\"POST\",headers:{\"Content-Type\":\"application/json\"},body:JSON.stringify({jsonrpc:\"2.0\",id:1,method,params}),signal:AbortSignal.timeout(18000)});}\n catch {throw Error(\"Solana is taking too long to respond. Try again shortly.\");}\n if(!response.ok) console.warn(\"RPC unavailable\",method,response.status); if(!response.ok) throw Error(response.status===429?\"Solana is busy. Wait a moment, then retry.\":\"The Solana connection is unavailable. Please retry shortly.\");\n const body=await response.json() as {result:T;error?:{code:number;message:string}};\n if(body.error) {\n if(body.error.code===-32002) throw Error(\"Simulation failed. Your balance or token permissions may have changed. Refresh and review again.\");\n throw Error(\"Solana could not complete this request. Refresh and try again.\");\n }\n return body.result;\n};\nexport function validAddress(value: string) {address(value);return value;}\nexport function validSignature(value:string) {if(!/^[1-9A-HJ-NP-Za-km-z]{64,88}$/.test(value))throw Error(\"Invalid transaction signature.\");return value;}\n\r\n\r\n\r\n\r\n\r\n\r\n", "lib/http.server.ts": "const limits=new Map();\nexport function guard(req:Request){\n const origin=req.headers.get(\"origin\");\n if(origin&&origin!==new URL(req.url).origin)throw Error(\"Please use SolanaBurner from its own website.\");\n const ip=req.headers.get(\"x-vercel-forwarded-for\")?.split(\",\")[0]?.trim()??req.headers.get(\"cf-connecting-ip\")??\"local\";const now=Date.now();\n if(limits.size>2000)for(const [key,v] of limits)if(v.untilnow){if(b.n++>120)throw Error(\"Too many requests. Please wait a minute.\");}else limits.set(ip,{n:1,until:now+60000});\n}\nexport async function readBody(req:Request){guard(req);if(!req.headers.get(\"content-type\")?.includes(\"application/json\"))throw Error(\"JSON required.\");const body=await req.text();if(body.length>6000)throw Error(\"Request too large.\");return JSON.parse(body);}\nexport const json=(value:unknown,status=200)=>Response.json(value,{status,headers:{\"Cache-Control\":\"no-store\",\"X-Content-Type-Options\":\"nosniff\"}});\nexport const fail=(error:unknown)=>json({error:error instanceof Error?error.message:\"Something went wrong. Please try again.\"},400);\n", "lib/receipt.server.ts": "import {rpc,validSignature} from \"./rpc.server\";\nimport {verifyReceipt,type ParsedTransaction} from \"./proof\";\nimport type {Network} from \"./burn-domain\";\nexport async function getReceipt(network:Network,signature:string){\n validSignature(signature);\n const tx=await rpc(network,\"getTransaction\",[signature,{encoding:\"jsonParsed\",commitment:\"finalized\",maxSupportedTransactionVersion:0}]);\n if(!tx)throw Error(\"This transaction is not finalized yet, or is unavailable on this network.\");\n return verifyReceipt(tx,signature,network);\n}\n", "lib/use-wallet.ts": "\"use client\";\nimport {useEffect,useState} from \"react\";\nimport {getWallets} from \"@wallet-standard/app\";\nimport type {Wallet,WalletAccount} from \"@wallet-standard/base\";\nimport type {StandardConnectFeature,StandardDisconnectFeature,StandardEventsFeature} from \"@wallet-standard/features\";\nimport type {SolanaSignTransactionFeature} from \"@solana/wallet-standard-features\";\nexport type BurnWallet=Wallet&{features:StandardConnectFeature&StandardEventsFeature&SolanaSignTransactionFeature&Partial};\nexport function useWallet(){\n const [wallets,setWallets]=useState([]);const [wallet,setWallet]=useState(null);const [account,setAccount]=useState(null);\n useEffect(()=>{const registry=getWallets();const sync=()=>setWallets(registry.get().filter(w=>w.features[\"standard:connect\"]&&w.features[\"standard:events\"]&&w.features[\"solana:signTransaction\"]&&w.chains.some(c=>c.startsWith(\"solana:\"))) as BurnWallet[]);sync();const off=[registry.on(\"register\",sync),registry.on(\"unregister\",sync)];return()=>off.forEach(fn=>fn());},[]);\n useEffect(()=>{if(!wallet)return;return wallet.features[\"standard:events\"].on(\"change\",e=>{if(e.accounts)setAccount(e.accounts.find(a=>a.chains.some(c=>c.startsWith(\"solana:\")))??null);});},[wallet]);\n async function connect(w:BurnWallet){const r=await w.features[\"standard:connect\"].connect();const a=r.accounts.find(a=>a.chains.some(c=>c.startsWith(\"solana:\")));if(!a)throw Error(\"This wallet did not provide a Solana account.\");setWallet(w);setAccount(a);}\n async function disconnect(){try{await wallet?.features[\"standard:disconnect\"]?.disconnect();}finally{setWallet(null);setAccount(null);}}\n return {wallets,wallet,account,connect,disconnect};\n}\n", "components/burner.tsx": "\"use client\";\nimport Link from \"next/link\";\r\nimport Image from \"next/image\";\r\nimport {useEffect,useLayoutEffect,useRef,useState} from \"react\";\nimport {Flame,Wallet,ArrowUpRight,ShieldCheck,Sparkles,ChevronDown,RefreshCw,LoaderCircle,LogOut} from \"lucide-react\";\nimport {Button} from \"@/components/ui/button\";\nimport {Input} from \"@/components/ui/input\";\nimport {Checkbox} from \"@/components/ui/checkbox\";\nimport {Dialog,DialogContent,DialogTitle,DialogDescription} from \"@/components/ui/dialog\";\nimport {AlertDialog,AlertDialogContent,AlertDialogTitle,AlertDialogDescription,AlertDialogFooter,AlertDialogCancel} from \"@/components/ui/alert-dialog\";\nimport {Command,CommandInput,CommandList,CommandEmpty,CommandGroup,CommandItem} from \"@/components/ui/command\";\nimport {APP_FEE,FEE_WALLET,allocateBurn,formatAmount,parseAmount,short,sol,supplyPercent,explorer,type Network,type TokenHolding,type BurnReceipt} from \"@/lib/burn-domain\";\nimport {assertMatchesBurnIntent,assertUnchangedTransaction,fromBase64,toBase64} from \"@/lib/transactions\";\nimport {useWallet,type BurnWallet} from \"@/lib/use-wallet\";\nimport {ReceiptActions} from \"@/components/receipt-actions\";\nimport {TokenNotices} from \"@/components/token-notices\";\ntype Preview={transaction:string;networkFee:string;appFee:string;reclaimed:string;accountsClosed:number;token:TokenHolding;burnAmount:string;lastValidBlockHeight:number;createdAt:number};\ntype Pending={signature:string;network:Network;owner:string;expires:number};\nasync function api(url:string,body?:unknown):Promise{const r=await fetch(url,body?{method:\"POST\",headers:{\"Content-Type\":\"application/json\"},body:JSON.stringify(body)}:{cache:\"no-store\"});const data=await r.json() as T & {error?:string};if(!r.ok)throw Error(data.error??\"Request failed. Please try again.\");return data;}\nconst message=(e:unknown)=>e instanceof Error?e.message:\"Something went wrong. Please try again.\";\nconst pendingKey=(owner:string,network:Network)=>`poof:pending:${network}:${owner}`;\nexport default function Burner(){\n const {wallets,wallet,account,connect,disconnect}=useWallet();\n const network=\"mainnet\" as const;\n const [walletOpen,setWalletOpen]=useState(false),[tokenOpen,setTokenOpen]=useState(false);\n const [tokens,setTokens]=useState([]),[mint,setMint]=useState(\"\"),[amount,setAmount]=useState(\"\"),[close,setClose]=useState(false);\n const [loading,setLoading]=useState(false),[busy,setBusy]=useState(false),[error,setError]=useState(\"\"),[walletError,setWalletError]=useState(\"\");\n const [preview,setPreview]=useState(null),[pending,setPending]=useState(null),[status,setStatus]=useState(\"pending\"),[receipt,setReceipt]=useState(null);\n const [reload,setReload]=useState(0),[statusReload,setStatusReload]=useState(0);\n const owner=account?.address??\"\";const context=`${network}:${owner}`;const contextRef=useRef(context);useLayoutEffect(()=>{contextRef.current=context;},[context]);\n const token=tokens.find(t=>t.mint===mint);let atomic=0n,amountError=\"\";\n if(amount&&token)try{atomic=parseAmount(amount,token.decimals);if(atomic>BigInt(token.balance))amountError=\"That is more than your wallet balance.\";}catch(e){amountError=message(e);}\n const full=!!token&&atomic===BigInt(token.balance)&&atomic>0n;\n\n useEffect(()=>{\n // A wallet/network change invalidates all chain-derived state and restores its own pending signature.\r\n // eslint-disable-next-line react-hooks/set-state-in-effect\r\n setTokens([]);setMint(\"\");setAmount(\"\");setClose(false);setPreview(null);setError(\"\");setPending(null);setReceipt(null);setStatus(\"pending\");\n if(!owner)return;\n try{const stored=localStorage.getItem(pendingKey(owner,network));if(stored){const p=JSON.parse(stored);if(p.owner===owner&&p.network===network&&typeof p.signature===\"string\"&&/^\\d+$/.test(String(p.expires)))setPending(p);}}catch{}\n const abort=new AbortController();setLoading(true);\n fetch(`/api/tokens?network=${network}&owner=${owner}`,{signal:abort.signal}).then(async r=>{const d=await r.json() as {tokens:TokenHolding[];error?:string};if(!r.ok)throw Error(d.error);return d;}).then(d=>setTokens(d.tokens)).catch(e=>{if(!abort.signal.aborted)setError(message(e));}).finally(()=>{if(!abort.signal.aborted)setLoading(false);});\n return()=>abort.abort();\n },[owner,network,reload]);\n useEffect(()=>{\n if(!pending)return;let canceled=false;let timer:ReturnType;let failures=0;\n async function poll(){try{const r=await api<{status:string;receipt?:BurnReceipt}>(`/api/status?network=${pending!.network}&signature=${pending!.signature}&expires=${pending!.expires}`);if(canceled)return;setStatus(r.status);setError(\"\");failures=0;if(r.receipt)setReceipt(r.receipt);if([\"finalized\",\"failed\",\"expired\"].includes(r.status))return;}catch(e){if(canceled)return;failures++;setError(`Status could not be checked. ${message(e)} Your transaction has not been sent again.`);}if(!canceled)timer=setTimeout(poll,failures?12000:4000);}\n void poll();return()=>{canceled=true;clearTimeout(timer);};\n },[pending,statusReload]);\n async function chooseWallet(w:BurnWallet){setWalletError(\"\");try{await connect(w);setWalletOpen(false);}catch(e){setWalletError(message(e));}}\n function checkPreview(p:Preview){if(!token)return;const chosen=parseAmount(amount,token.decimals);const allocation=allocateBurn(token,chosen,owner,close&&full);assertMatchesBurnIntent(p.transaction,{token,amount:chosen,owner,close:close&&full});if(p.appFee!==APP_FEE.toString()||p.burnAmount!==chosen.toString()||p.token.mint!==token.mint||p.token.decimals!==token.decimals||p.token.balance!==token.balance||p.reclaimed!==allocation.reclaimed.toString()||p.accountsClosed!==allocation.closes.length)throw Error(\"The review does not match your selection. Refresh your balance and try again.\");}\n async function prepare(){if(!token||!owner)return;const current=context;setBusy(true);setError(\"\");try{const p=await api(\"/api/burn\",{action:\"prepare\",network,owner,mint,amount,balance:token.balance,close:close&&full});checkPreview(p);if(contextRef.current===current)setPreview(p);}catch(e){if(contextRef.current===current)setError(message(e));}finally{setBusy(false);}}\n async function burn(){\n if(!preview||!wallet||!account||!token)return;const current=context;setBusy(true);setError(\"\");\n try{\n const chain=\"solana:mainnet\" as const;\n if(!account.chains.includes(chain))throw Error(`Switch your wallet to ${network} and reconnect.`);\n if(!wallet.features[\"solana:signTransaction\"].supportedTransactionVersions.includes(\"legacy\"))throw Error(\"This wallet does not support the transaction format used by SolanaBurner.\");\n const fresh=await api(\"/api/burn\",{action:\"prepare\",network,owner,mint,amount,balance:token.balance,close:close&&full});\n if(contextRef.current!==current)return;\n checkPreview(fresh);\n if(fresh.networkFee!==preview.networkFee||fresh.reclaimed!==preview.reclaimed||fresh.burnAmount!==preview.burnAmount||fresh.token.decimals!==preview.token.decimals||JSON.stringify(fresh.token.notices)!==JSON.stringify(preview.token.notices)||fresh.token.closeReason!==preview.token.closeReason){setPreview(fresh);throw Error(\"Transaction details changed. Please review the updated amounts before signing.\");}\n const [signed]=await wallet.features[\"solana:signTransaction\"].signTransaction({account,transaction:fromBase64(fresh.transaction),chain,options:{preflightCommitment:\"confirmed\"}});\n if(contextRef.current!==current)throw Error(\"Your wallet or network changed. Nothing was submitted.\");\n if(!signed)throw Error(\"Your wallet did not sign the transaction.\");\n const signature=assertUnchangedTransaction(fresh.transaction,signed.signedTransaction);\n const p={signature,network,owner,expires:fresh.lastValidBlockHeight};\n // Persist the known signature before submission; a timeout must never trigger a second burn.\n localStorage.setItem(pendingKey(owner,network),JSON.stringify(p));setPending(p);setStatus(\"pending\");setPreview(null);\n try{await api(\"/api/burn\",{action:\"submit\",network,transaction:toBase64(signed.signedTransaction)});}catch(e){setError(`Submission could not be confirmed. ${message(e)} We are checking this signature; do not submit another burn.`);}\n }catch(e){setError(message(e));}finally{setBusy(false);}\n }\n function resetBurn(){if(pending)localStorage.removeItem(pendingKey(pending.owner,pending.network));setPending(null);setReceipt(null);setStatus(\"pending\");setReload(n=>n+1);}\n const locking=busy||!!pending;\n return
\n
solanaburner*
Solana mainnet
\n
Solana burner. Meet Poofie.

Burn Solana tokens.
Yours to prove.

Burn a little. Burn a lot.
You choose the amount. We bring the poof.

\"ASmall burn.
Big energy.

Your wallet. Your call.
Every burn is recorded on Solana.

\n

Make it poof.

Real tokens. Your exact amount.

\n {pending?
\"\"/

{status===\"finalized\"?\"Officially poofed.\":status===\"confirmed\"?\"Burn confirmed!\":status===\"failed\"?\"Burn did not complete.\":status===\"expired\"?\"Transaction expired.\":\"Waiting for Solana…\"}

{status===\"finalized\"&&receipt?`${formatAmount(receipt.amount,receipt.decimals)} tokens permanently burned.`:status===\"confirmed\"?\"Your burn is confirmed. We’re waiting for finalization before unlocking your verified receipt.\":status===\"failed\"?\"The burn and app fee were rolled back. A network fee may still have been charged.\":status===\"expired\"?\"This signature was not found before its transaction expired. Check your wallet activity before trying again.\":\"Your transaction is being checked. You can leave this page and reconnect your wallet to check it later.\"}

View transaction {receipt&&}
{[\"finalized\",\"failed\",\"expired\"].includes(status)?:}
:<>\n
1{owner&&}
\n
2
Balance: {token?formatAmount(token.balance,token.decimals):\"—\"}
{setClose(false);setAmount(e.target.value);setPreview(null);setError(\"\");}} disabled={!token||locking} aria-invalid={!!amountError} aria-describedby={amountError?\"amount-error\":\"connect-note\"}/>
{[25,50,100].map(p=>)}
\n {amountError&&

{amountError}

}
You keep {token&&!amountError?formatAmount(BigInt(token.balance)-atomic,token.decimals):\"—\"}Supply burned · estimate{token&&atomic>0n&&!amountError?supplyPercent(atomic,token.supply):\"—\"}
\n {token&&}\n {full&&!amountError&&
!!a.closeAuthority&&a.closeAuthority!==owner)} onCheckedChange={v=>setClose(v===true)}/>
}\n
SolanaBurner fee{sol(APP_FEE)} SOL
Network feeEstimated before you sign
{close&&full&&
Account rentReturned to your wallet
}
\n

Burns are permanent. Always double-check your amount.

\n }{error&&
{error}{owner&&!pending&&!busy&&}
}
\n
Does my token’s transfer tax apply to a burn?

SolanaBurner destroys tokens directly in your account. There is no token transfer, so Token-2022’s transfer fee is not charged. Trading fees charged by exchanges also do not apply. You pay the displayed SolanaBurner fee and Solana network fee.

Fees withheld by earlier transfers are separate from your spendable balance. They cannot be burned by you and can prevent closing the account. We check this, frozen accounts, and unsupported rules before you sign.

Read Solana’s transfer-fee documentation ↗

Do the burn. Keep the receipt.

Your on-chain proof, with a little extra personality.

Preview your receipt
Less tokens. Same you.Built on \"Solana\" Solana
\n {owner?\"Your wallet\":\"Connect your wallet\"}{owner?`${wallet?.name} · ${owner}`:\"Your tokens stay in your wallet until you approve a burn.\"}
{owner?:wallets.length?wallets.map(w=>):
No compatible wallet was detected. Open SolanaBurner in a browser with Phantom or Solflare installed, or inside your wallet’s browser. Then return here to connect.
}
{walletError&&
{walletError}
}\n Choose a tokenCheck the mint address. Token names can be copied.{tokens.length?\"No matching tokens.\":`No tokens found on ${network}. Refresh your wallet or connect another wallet.`}{tokens.map(t=>{setMint(t.mint);setAmount(\"\");setClose(false);setPreview(null);setError(\"\");setTokenOpen(false);}}>{t.name}{t.symbol} · {short(t.mint)}{t.reason&&{t.reason}}{formatAmount(t.balance,t.decimals)})}\n {if(!v&&!busy)setPreview(null);}}>Ready to make it poof?This permanently destroys the selected tokens. It cannot be undone.{preview&&<>
Solana mainnet — real tokens
Burn{formatAmount(preview.burnAmount,preview.token.decimals)} {preview.token.symbol}
You keep{formatAmount(BigInt(preview.token.balance)-BigInt(preview.burnAmount),preview.token.decimals)}
SolanaBurner fee{sol(preview.appFee)} SOL
Network fee{sol(preview.networkFee)} SOL
Close accounts{preview.accountsClosed?`${preview.accountsClosed} · reclaim ${sol(preview.reclaimed)} SOL`:\"No\"}
Total fees{sol(BigInt(preview.appFee)+BigInt(preview.networkFee))} SOL
Verify this transaction

Before signing, your browser reconstructs this transaction from your chosen amount and compares every message byte. Copy these unsigned bytes into the local transaction inspector.