Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
feat(pump): compose a plain-English launch receipt for every pump.fun coin
nirholas9b782dfeeb16
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex e6315591a..b34ace9cd 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -10,6 +10,7 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr- **Atomic is now a six-tab Transaction V1 lab, not just an inspector**: /atomic grew five tabs beyond the Inspector, each reachable by click, arrow-key/Home/End tab navigation, or a deep link (?tab=mask, ?tab=sponsor, ?tab=planner, ?tab=diff, ?tab=wallet). The config mask decoder reads a V1 transaction's real TransactionConfigMask u32 and its fixed-width ConfigValues byte by byte, flagging a half-set priority-fee pair or a reserved bit SIMD-0385 has not assigned yet. The sponsor cap view shows a paymaster exactly what it is agreeing to pay, reading V1's inline config instead of a Compute Budget instruction scan that sees nothing on a V1 transaction. The size and budget planner compiles a pasted instruction set with @solana/kit to an exact byte count against legacy, V0, or V1's ceiling, including an exact lamport total for a chosen priority fee. The legacy/V0/V1 diff compiles the same instructions three ways and reports the real byte deltas, honestly, including the case where V1's inline config makes it larger than legacy. The wallet V1 capability check connects the browser's injected wallet and reports the same verdict the rest of three.ws would get from findV1WalletStandardSigner before ever requesting a real V1 signature. Nothing here is estimated: every number comes from compiling and decoding real transactions, and nothing is ever signed, simulated, or broadcast. (`/atomic`) `[feature]`- **Atomic now replays a pump.fun transaction step by step**: Atomic (/atomic) decodes every Pump, PumpSwap, and PumpFees event in a transaction's logs, oldest first, and renders it as a Replay panel: a bonding-curve-position bar, a human-readable description of each step (create, buy/sell, graduation, creator-fee collection and distribution, GitHub social-fee claims, and post-graduation PumpSwap swaps), and the SOL/token amounts that moved. An event the installed SDK does not recognize still renders, labeled unrecognized, instead of silently disappearing. For a create transaction, the panel also pages through the earliest trades on that mint since launch, walking Solana's signature history backward in bounded pages since RPC has no forward cursor. `[feature]`- **Deep links to a specific avatar now actually load that avatar**: @three-ws/walk's ?walk=play&avatar=<id> deep link and the drop-in resume path read the saved avatar preference straight out of storage and never looked at the query string, so sharing a link to a specific avatar silently loaded the stored (or default) one instead. A new deepLinkAvatarId resolver gives the query param precedence and persists it, the same way picking an avatar in the UI does. `[fix, sdk]`+- **Every pump.fun launch now carries a plain-English receipt**: /launches/<mint> gained a Launch receipt panel composing five on-chain facts into one readable object: whether the mint or freeze authority can still act (with a plain sentence for each, not just enabled/disabled), supply and decimals, the top-10 holder share, where trading fees route (a creator wallet, a fee-sharing config, cashback, or holder rewards), the creation transaction's version and byte size, and the Trade Safety Firewall's verdict. A coin that never launched through pump.fun gets an honest 'not a pump.fun launch' instead of an error, and a source that fails marks only its own section unavailable, never an invented number. Copy the receipt as text or download it as JSON; both carry a SHA-256 content hash of the response so a saved copy can be checked against a fresh read. A shareable 1200x630 card is available via GET /api/pump/launch-og?mint=<mint>&variant=receipt, and the composition itself is a new public endpoint, GET /api/pump/launch-receipt?mint=<mint>. (`/launches`) `[feature]`- **GitHub fee-claim channel now attributes withdrawals to a coin, or says plainly it cannot**: A GitHub identity withdrawing pump.fun fees through the claim_social_fee_pda instruction only proves payment to that identity, not which coin paid it: one GitHub fee account can be a shareholder on more than one coin, and its address can be pasted into a copycat coin's metadata. The claims feed and its Telegram channel now classify every such withdrawal with on-chain evidence: a same-transaction distribution to the exact account, or a 90%-dominant distribution history since the previous claim, then a repository-owner or creator-wallet match, down to an honest unresolved or unverified label when nothing proves a coin. A new-GitHub-account-plus-copycat-coin pattern holds the claim for review instead of posting it with a celebratory card. `[feature, security]`- **GitHub fee-claim feed now reads from a real-time listener, not just an on-demand RPC scan**: The claims feed's GitHub-attribution path used to walk Solana RPC history fresh on every request, the same cost every time, with nothing persisted in between. services/pump-claims is a standalone process that subscribes to PumpFees program logs directly, decodes and attributes each claim as it happens, and writes it to a new pump_fee_claims table with a watchdog that resubscribes on a stalled connection and gap-fills whatever a drop missed. The claims route now reads that table first and only falls back to the RPC scan when the table has nothing for the requested window, so PUMPFUN_BOT_URL is no longer required for GitHub claims specifically (ordinary wallet claims still use it). `[feature, infra]`- **Robinhood Chain feed worker now runs the published SDK, not a stale local snapshot**: workers/robinhood-feed depended on robinhood/robinhood-chain-sdk through a file: link, a reference copy that drifts from the standalone robinhood-chain-sdk repo it mirrors. The worker now installs hoodchain from npm like any other dependency, so it always runs the released SDK. Also fixed: seven pointer READMEs staged for duplicate or superseded standalone repos (three-ui, crypto-market-data, crypto-market-data-ts, crypto-data-aggregator, memescope-monday-directory, and one of each duplicate Robinhood Chain repo pair), ready for the owner to push and archive. `[fix, infra]`diff --git a/api/pump/[action].js b/api/pump/[action].jsindex 5ad003fc6..b56139134 100644--- a/api/pump/[action].js+++ b/api/pump/[action].js@@ -5300,6 +5300,146 @@ async function handleCreateSocialFeePdaPrep(req, res) {const MIN_RENT_EXEMPTION_LAMPORTS = 890_880n;+/**+ * Pure fee-routing read for `mintPk`: returns the same object handleFeeInfo+ * serves, or null when the mint has no bonding curve. Exported so other+ * composed read surfaces (the launch receipt) can reuse this without an+ * internal HTTP round trip. Throws on an on-chain read failure; the caller+ * decides how to surface that.+ */+export async function computeFeeInfo(mintPk, network) {+ const connection = getConnection({ network });+ const [+ { PumpSdk, OnlinePumpSdk, canonicalPumpPoolPdaWithQuote, normalizeQuoteMint, creatorVaultPda, feeSharingConfigPda },+ { OnlinePumpAmmSdk, coinCreatorVaultAuthorityPda, coinCreatorVaultAtaPda },+ { AccountLayout, NATIVE_MINT, TOKEN_PROGRAM_ID },+ ] = await Promise.all([+ import('@pump-fun/pump-sdk'),+ import('@pump-fun/pump-swap-sdk'),+ import('@solana/spl-token'),+ ]);++ const onlineSdk = new OnlinePumpSdk(connection);+ const offlineSdk = new PumpSdk();+ const bondingCurve = await onlineSdk.fetchBondingCurve(mintPk).catch(() => null);+ if (!bondingCurve) return null;+ const isHolderReward = bondingCurve.isHolderReward === true;++ const poolPda = canonicalPumpPoolPdaWithQuote(mintPk, normalizeQuoteMint(bondingCurve.quoteMint));+ const poolInfo = await connection.getAccountInfo(poolPda);+ let isGraduated = false;+ let poolCoinCreator = null;+ let isCashbackCoin = false;++ if (poolInfo) {+ isGraduated = true;+ try {+ const pool = await new OnlinePumpAmmSdk(connection).fetchPool(poolPda);+ poolCoinCreator = pool.coinCreator;+ isCashbackCoin =+ pool.isCashbackCoin === true ||+ (Array.isArray(pool.is_cashback_coin) && pool.is_cashback_coin[0] === true);+ } catch {+ /* pool not fully initialized */+ }+ } else {+ isCashbackCoin =+ bondingCurve.isCashbackCoin === true ||+ (Array.isArray(bondingCurve.is_cashback_coin) &&+ bondingCurve.is_cashback_coin[0] === true);+ }++ const effectiveCreator = poolCoinCreator ?? new PublicKey(bondingCurve.creator);++ let hasSharingConfig = false;+ let sharingConfig = null;+ if (!isCashbackCoin && !isHolderReward) {+ // When a creator migrates to a fee-sharing config, the on-chain creator+ // field (pool.coinCreator / bondingCurve.creator) becomes the config PDA.+ const cfgPda = feeSharingConfigPda(mintPk);+ hasSharingConfig = effectiveCreator.equals(cfgPda);+ if (hasSharingConfig) {+ const cfgInfo = await connection.getAccountInfo(cfgPda);+ if (cfgInfo) {+ const cfg = offlineSdk.decodeSharingConfig(cfgInfo);+ sharingConfig = {+ address: cfgPda.toBase58(),+ admin: cfg.admin.toBase58(),+ admin_revoked: cfg.adminRevoked ?? false,+ shareholders: cfg.shareholders.map((s) => ({+ address: s.address.toBase58(),+ bps: Number(s.shareBps),+ })),+ };+ } else {+ hasSharingConfig = false;+ }+ }+ }++ // Vault balance = pump native creator vault (minus rent) + AMM WSOL vault,+ // plus the SOL creator fees v3 / PumpSwap v2 trades left on this coin's+ // curve and pool, which a claim sweeps into the vault first.+ // When a sharing config exists, fees accrue under the config PDA.+ let claimableLamports = 0n;+ let unsweptLamports = 0n;+ if (!isCashbackCoin) {+ const vaultCreator = hasSharingConfig ? feeSharingConfigPda(mintPk) : effectiveCreator;+ const buckets = await readCreatorFeeBuckets(connection, [mintPk.toBase58()]);+ for (const leg of unsweptCreatorFees(buckets.values(), vaultCreator.toBase58())) {+ if (leg.quoteMint === SOL_QUOTE_MINT) unsweptLamports += leg.amount;+ }+ claimableLamports += unsweptLamports;+ const nativeVault = creatorVaultPda(vaultCreator);+ const nativeInfo = await connection.getAccountInfo(nativeVault);+ if (nativeInfo) {+ const adjusted = BigInt(nativeInfo.lamports) - MIN_RENT_EXEMPTION_LAMPORTS;+ if (adjusted > 0n) claimableLamports += adjusted;+ }+ try {+ const ammAuthority = coinCreatorVaultAuthorityPda(vaultCreator);+ const ammAta = coinCreatorVaultAtaPda(ammAuthority, NATIVE_MINT, TOKEN_PROGRAM_ID);+ const ammInfo = await connection.getAccountInfo(ammAta);+ if (ammInfo) {+ const parsed = AccountLayout.decode(+ new Uint8Array(+ ammInfo.data.buffer,+ ammInfo.data.byteOffset,+ ammInfo.data.byteLength,+ ),+ );+ claimableLamports += BigInt(parsed.amount.toString());+ }+ } catch {+ /* no AMM vault yet */+ }+ }++ const feeDestination = isHolderReward+ ? 'holder_rewards'+ : isCashbackCoin+ ? 'cashback'+ : hasSharingConfig+ ? 'sharing_config'+ : 'creator';++ return {+ mint: mintPk.toBase58(),+ network,+ is_graduated: isGraduated,+ is_cashback_coin: isCashbackCoin,+ is_holder_reward: isHolderReward,+ has_sharing_config: hasSharingConfig,+ creator: effectiveCreator.toBase58(),+ claimable_lamports: claimableLamports.toString(),+ claimable_sol: Number(claimableLamports) / LAMPORTS_PER_SOL,+ // The part of claimable still on the curve or pool (swept by the claim).+ unswept_lamports: unsweptLamports.toString(),+ fee_destination: feeDestination,+ sharing_config: sharingConfig,+ };+}+async function handleFeeInfo(req, res) {if (cors(req, res, { methods: 'GET,OPTIONS', origins: '*' })) return;if (!method(req, res, ['GET'])) return;@@ -5314,136 +5454,9 @@ async function handleFeeInfo(req, res) {if (!mintPk) return error(res, 400, 'validation_error', 'valid mint required');try {- const connection = getConnection({ network });- const [- { PumpSdk, OnlinePumpSdk, canonicalPumpPoolPdaWithQuote, normalizeQuoteMint, creatorVaultPda, feeSharingConfigPda },- { OnlinePumpAmmSdk, coinCreatorVaultAuthorityPda, coinCreatorVaultAtaPda },- { AccountLayout, NATIVE_MINT, TOKEN_PROGRAM_ID },- ] = await Promise.all([- import('@pump-fun/pump-sdk'),- import('@pump-fun/pump-swap-sdk'),- import('@solana/spl-token'),- ]);-- const onlineSdk = new OnlinePumpSdk(connection);- const offlineSdk = new PumpSdk();- const bondingCurve = await onlineSdk.fetchBondingCurve(mintPk).catch(() => null);- if (!bondingCurve) return error(res, 404, 'not_found', 'no bonding curve for this mint');- const isHolderReward = bondingCurve.isHolderReward === true;-- const poolPda = canonicalPumpPoolPdaWithQuote(mintPk, normalizeQuoteMint(bondingCurve.quoteMint));- const poolInfo = await connection.getAccountInfo(poolPda);- let isGraduated = false;- let poolCoinCreator = null;- let isCashbackCoin = false;-- if (poolInfo) {- isGraduated = true;- try {- const pool = await new OnlinePumpAmmSdk(connection).fetchPool(poolPda);- poolCoinCreator = pool.coinCreator;- isCashbackCoin =- pool.isCashbackCoin === true ||- (Array.isArray(pool.is_cashback_coin) && pool.is_cashback_coin[0] === true);- } catch {- /* pool not fully initialized */- }- } else {- isCashbackCoin =- bondingCurve.isCashbackCoin === true ||- (Array.isArray(bondingCurve.is_cashback_coin) &&- bondingCurve.is_cashback_coin[0] === true);- }-- const effectiveCreator = poolCoinCreator ?? new PublicKey(bondingCurve.creator);-- let hasSharingConfig = false;- let sharingConfig = null;- if (!isCashbackCoin && !isHolderReward) {- // When a creator migrates to a fee-sharing config, the on-chain creator- // field (pool.coinCreator / bondingCurve.creator) becomes the config PDA.- const cfgPda = feeSharingConfigPda(mintPk);- hasSharingConfig = effectiveCreator.equals(cfgPda);- if (hasSharingConfig) {- const cfgInfo = await connection.getAccountInfo(cfgPda);- if (cfgInfo) {- const cfg = offlineSdk.decodeSharingConfig(cfgInfo);- sharingConfig = {- address: cfgPda.toBase58(),- admin: cfg.admin.toBase58(),- admin_revoked: cfg.adminRevoked ?? false,- shareholders: cfg.shareholders.map((s) => ({- address: s.address.toBase58(),- bps: Number(s.shareBps),- })),- };- } else {- hasSharingConfig = false;- }- }- }-- // Vault balance = pump native creator vault (minus rent) + AMM WSOL vault,- // plus the SOL creator fees v3 / PumpSwap v2 trades left on this coin's- // curve and pool, which a claim sweeps into the vault first.- // When a sharing config exists, fees accrue under the config PDA.- let claimableLamports = 0n;- let unsweptLamports = 0n;- if (!isCashbackCoin) {- const vaultCreator = hasSharingConfig ? feeSharingConfigPda(mintPk) : effectiveCreator;- const buckets = await readCreatorFeeBuckets(connection, [mintPk.toBase58()]);- for (const leg of unsweptCreatorFees(buckets.values(), vaultCreator.toBase58())) {- if (leg.quoteMint === SOL_QUOTE_MINT) unsweptLamports += leg.amount;- }- claimableLamports += unsweptLamports;- const nativeVault = creatorVaultPda(vaultCreator);- const nativeInfo = await connection.getAccountInfo(nativeVault);- if (nativeInfo) {- const adjusted = BigInt(nativeInfo.lamports) - MIN_RENT_EXEMPTION_LAMPORTS;- if (adjusted > 0n) claimableLamports += adjusted;- }- try {- const ammAuthority = coinCreatorVaultAuthorityPda(vaultCreator);- const ammAta = coinCreatorVaultAtaPda(ammAuthority, NATIVE_MINT, TOKEN_PROGRAM_ID);- const ammInfo = await connection.getAccountInfo(ammAta);- if (ammInfo) {- const parsed = AccountLayout.decode(- new Uint8Array(- ammInfo.data.buffer,- ammInfo.data.byteOffset,- ammInfo.data.byteLength,- ),- );- claimableLamports += BigInt(parsed.amount.toString());- }- } catch {- /* no AMM vault yet */- }- }-- const feeDestination = isHolderReward- ? 'holder_rewards'- : isCashbackCoin- ? 'cashback'- : hasSharingConfig- ? 'sharing_config'- : 'creator';-- return json(res, 200, {- mint: mintPk.toBase58(),- network,- is_graduated: isGraduated,- is_cashback_coin: isCashbackCoin,- is_holder_reward: isHolderReward,- has_sharing_config: hasSharingConfig,- creator: effectiveCreator.toBase58(),- claimable_lamports: claimableLamports.toString(),- claimable_sol: Number(claimableLamports) / LAMPORTS_PER_SOL,- // The part of claimable still on the curve or pool (swept by the claim).- unswept_lamports: unsweptLamports.toString(),- fee_destination: feeDestination,- sharing_config: sharingConfig,- });+ const info = await computeFeeInfo(mintPk, network);+ if (!info) return error(res, 404, 'not_found', 'no bonding curve for this mint');+ return json(res, 200, info);} catch (e) {return error(res,diff --git a/api/pump/launch-og.js b/api/pump/launch-og.jsindex bb7c55d7f..68a2ed966 100644--- a/api/pump/launch-og.js+++ b/api/pump/launch-og.js@@ -1,5 +1,6 @@/*** GET /api/pump/launch-og?mint=<mint>+ * GET /api/pump/launch-og?mint=<mint>&variant=receipt** Dynamic OG image card for the /launches/<mint> coin detail page.* Returns an SVG-based social card (1200×630) that renders the coin's identity@@ -23,6 +24,12 @@* such as "rugged". A shared card is a statement about someone's coin, and a* number on it reads as investment advice when high and as FUD when low.* footer — three.ws branding+ *+ * `variant=receipt` swaps the activity/market-cap card for a shareable summary+ * of /api/pump/launch-receipt: authorities, supply, top-10 holders, fee routing+ * and the firewall verdict, so a trader can share the receipt itself rather+ * than a screenshot of the page. Same neutral-facts rule: every field is a+ * fact already published by the receipt endpoint, never a score computed here.*/import { cors, method, wrap } from '../_lib/http.js';@@ -30,6 +37,7 @@ import { sql } from '../_lib/db.js';import { fetchOgImage } from '../_lib/og-avatar.js';import { pumpFetchJson } from '../_lib/pump-feed-fetch.js';import { resolveURI } from '../../src/ipfs.js';+import { buildReceipt } from './launch-receipt.js';const MINT_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;const PUMP_FRONTEND_V3 = 'https://frontend-api-v3.pump.fun';@@ -244,6 +252,103 @@ export function renderCard(mint, d) {</svg>`;}+function compactNum(n) {+ if (!Number.isFinite(n)) return '';+ if (n >= 1_000_000_000) return `${(n / 1_000_000_000).toFixed(2)}B`;+ if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(2)}M`;+ if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;+ return n.toFixed(0);+}++function feeRoutingLabel(fr) {+ if (!fr?.available) return 'Unavailable';+ if (!fr.applicable) return 'Not pump.fun';+ if (fr.sentence.includes('holder rewards')) return 'Holder rewards';+ if (fr.sentence.includes('cashback')) return 'Cashback';+ if (fr.sentence.includes('fee-sharing')) return 'Fee-sharing';+ return 'Creator wallet';+}++export function renderReceiptCard(mint, d, r) {+ const { name, symbol, logoBase64 } = d;+ const displayName = trunc(name || 'Unknown coin', 30);+ const displaySym = symbol ? `$${symbol.toUpperCase()}` : '';+ const accent = '#818cf8';++ const imgBlock = logoBase64+ ? `<image href="${logoBase64}" x="80" y="88" width="96" height="96" clip-path="url(#imgCircle)"/>`+ : `<rect x="80" y="88" width="96" height="96" rx="48" fill="#1e2030"/>+ <text x="128" y="152" text-anchor="middle" fill="#6b7280" font-size="40">${x((displaySym || displayName)[0] || '?')}</text>`;++ const mintEnabled = r?.authorities?.available ? r.authorities.mint_authority.enabled : null;+ const freezeEnabled = r?.authorities?.available ? r.authorities.freeze_authority.enabled : null;+ const supplyText = r?.supply?.available ? compactNum(r.supply.formatted) : '-';+ const top10Text = r?.holders?.available && r.holders.top10_pct != null ? `${(r.holders.top10_pct * 100).toFixed(1)}%` : '-';+ const feeText = feeRoutingLabel(r?.fee_routing);+ const riskVerdict = r?.risk?.available ? r.risk.verdict : null;+ const hashShort = r?.content_hash ? `${r.content_hash.slice(0, 16)}…` : '';++ const fact = (fx, label, value, valueColor = '#e5e5e5') => `+ <text x="${fx}" y="356" fill="rgba(229,229,229,0.4)" font-size="13" letter-spacing="1.5">${x(label)}</text>+ <text x="${fx}" y="396" fill="${valueColor}" font-family="Inter,-apple-system,system-ui,sans-serif" font-size="26" font-weight="400">${x(value)}</text>`;++ const riskColor = riskVerdict === 'block' ? '#f87171' : riskVerdict === 'warn' ? '#fbbf24' : riskVerdict ? '#4ade80' : '#9ca3af';++ return `<?xml version="1.0" encoding="UTF-8"?>+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"+ width="1200" height="630" viewBox="0 0 1200 630" role="img"+ aria-label="${x(displayName)} launch receipt">+ <defs>+ <clipPath id="imgCircle"><circle cx="128" cy="136" r="48"/></clipPath>+ <linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">+ <stop offset="0%" stop-color="#0a0b0f"/>+ <stop offset="100%" stop-color="#0f1119"/>+ </linearGradient>+ </defs>++ <rect width="1200" height="630" fill="url(#bg)"/>+ <rect x="0" y="0" width="1200" height="3" fill="${accent}" opacity="0.7"/>++ <text x="80" y="40" fill="rgba(229,229,229,0.9)"+ font-family="Inter,-apple-system,system-ui,sans-serif"+ font-size="22" font-weight="600" letter-spacing="1">three.ws</text>+ <rect x="215" y="22" width="150" height="26" rx="6" fill="rgba(99,102,241,0.2)"/>+ <text x="228" y="40" fill="#818cf8" font-size="13" font-weight="500">LAUNCH RECEIPT</text>+ <text x="1120" y="40" text-anchor="end" fill="rgba(229,229,229,0.3)"+ font-family="Inter,-apple-system,system-ui,sans-serif"+ font-size="18" font-weight="400">${x(shortMint(mint))}</text>++ ${imgBlock}++ <text x="196" y="130" fill="#e5e5e5"+ font-family="Inter,-apple-system,system-ui,sans-serif"+ font-size="42" font-weight="300" letter-spacing="-1">${x(displayName)}</text>+ <text x="196" y="166" fill="rgba(229,229,229,0.5)"+ font-family="Inter,-apple-system,system-ui,sans-serif"+ font-size="24" font-weight="400" letter-spacing="1">${x(displaySym)}</text>++ <line x1="80" y1="210" x2="1120" y2="210" stroke="rgba(255,255,255,0.07)" stroke-width="1"/>++ ${fact(80, 'MINT AUTHORITY', mintEnabled == null ? '-' : mintEnabled ? 'Enabled' : 'Disabled', mintEnabled === true ? '#fbbf24' : '#e5e5e5')}+ ${fact(288, 'FREEZE AUTHORITY', freezeEnabled == null ? '-' : freezeEnabled ? 'Enabled' : 'Disabled', freezeEnabled === true ? '#fbbf24' : '#e5e5e5')}+ ${fact(496, 'SUPPLY', supplyText)}+ ${fact(704, 'TOP 10 HOLDERS', top10Text)}+ ${fact(912, 'FEE ROUTING', trunc(feeText, 14))}++ <line x1="80" y1="430" x2="1120" y2="430" stroke="rgba(255,255,255,0.07)" stroke-width="1"/>++ <text x="80" y="470" fill="rgba(229,229,229,0.4)" font-size="13" letter-spacing="1.5">TRADE SAFETY FIREWALL</text>+ <text x="80" y="510" fill="${riskColor}" font-family="Inter,-apple-system,system-ui,sans-serif" font-size="32" font-weight="500">${x(riskVerdict ? riskVerdict.toUpperCase() : 'UNAVAILABLE')}</text>++ <text x="1120" y="470" text-anchor="end" fill="rgba(229,229,229,0.4)" font-size="13" letter-spacing="1.5">CONTENT HASH</text>+ <text x="1120" y="500" text-anchor="end" fill="rgba(229,229,229,0.7)" font-family="ui-monospace,monospace" font-size="18">${x(hashShort)}</text>++ <text x="80" y="592" fill="rgba(229,229,229,0.2)"+ font-family="Inter,-apple-system,system-ui,sans-serif"+ font-size="18" letter-spacing="5">THREE.WS · VERIFY AT THREE.WS/LAUNCHES</text>+</svg>`;+}+export default wrap(async (req, res) => {if (cors(req, res, { methods: 'GET,OPTIONS' })) return;// Crawlers fetch og:image with GET, and several (Slack, iMessage) HEAD it@@ -253,6 +358,7 @@ export default wrap(async (req, res) => {const url = new URL(req.url, 'http://x');const mint = (url.searchParams.get('mint') || '').trim();+ const variant = url.searchParams.get('variant') === 'receipt' ? 'receipt' : 'card';if (!MINT_RE.test(mint)) {res.statusCode = 400;@@ -272,7 +378,22 @@ export default wrap(async (req, res) => {data = { name: '', symbol: '', logoBase64: null, category: '', isThreeWsLaunch: false, intel: null, outcome: null, liveMcap: null };}- const svg = renderCard(mint, data);+ let svg;+ if (variant === 'receipt') {+ // buildReceipt isolates each of its own sources (Promise.allSettled), so it+ // resolves even when every upstream fact fails; this try/catch only guards+ // against a genuinely unexpected throw, same contract as buildCardData above.+ let receipt = null;+ try {+ receipt = await buildReceipt(mint, 'mainnet');+ } catch (err) {+ console.warn('[launch-og] receipt data failed for %s: %s', mint, err?.message || err);+ }+ svg = renderReceiptCard(mint, data, receipt);+ } else {+ svg = renderCard(mint, data);+ }+res.statusCode = 200;res.setHeader('content-type', 'image/svg+xml; charset=utf-8');res.setHeader('cache-control', CACHE);diff --git a/api/pump/launch-receipt.js b/api/pump/launch-receipt.jsnew file mode 100644index 000000000..c1b96ad1a--- /dev/null+++ b/api/pump/launch-receipt.js@@ -0,0 +1,247 @@+/**+ * GET /api/pump/launch-receipt?mint=<mint>+ *+ * A plain-English receipt for a pump.fun launch: what the mint and freeze+ * authorities actually let someone do, supply and decimals, the top-10+ * holder share, where trading fees are routed, the creation transaction's+ * version and size, and the Trade Safety Firewall's risk flags. Every input+ * already exists elsewhere on the platform (api/pump/token-stats.js,+ * the fee-info action in api/pump/[action].js, api/_lib/trade-firewall.js,+ * inspectWireTransaction): this endpoint composes them into one object+ * instead of sending a trader to five different panels.+ *+ * Each section is independent: when one source fails, that section alone is+ * marked `{ available: false, reason }`. The rest of the receipt still+ * renders: never an invented figure, never a 5xx for one missing signal.+ *+ * `content_hash` is a SHA-256 of the canonical (sorted-key) JSON of the+ * receipt body, so a downloaded or shared copy can be checked against a+ * fresh read of this endpoint.+ */++import { createHash } from 'node:crypto';+import { PublicKey } from '@solana/web3.js';+import { cors, json, method, wrap, error, rateLimited } from '../_lib/http.js';+import { limits, clientIp } from '../_lib/rate-limit.js';+import { cacheWrapLastGood } from '../_lib/cache.js';+import { getConnection } from '../_lib/pump.js';+import { assessTradeSafety } from '../_lib/trade-firewall.js';+import { inspectWireTransaction } from '../_lib/solana/transaction-v1.js';+import { stableStringify } from '../_lib/asset-provenance.js';+import { buildStats } from './token-stats.js';+import { computeFeeInfo } from './[action].js';++const MINT_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;+const CACHE_TTL_S = 60;+// Mirrors api/pump/safety.js's public-read probe: no payer on this path, so+// the round-trip simulation degrades to a `skip` and only the authority,+// venue and intel checks run.+const DEFAULT_PROBE_LAMPORTS = 50_000_000n; // 0.05 SOL++// Bounded walk-back for the creation signature: getSignaturesForAddress has+// no forward cursor, so finding the first transaction on a mint means paging+// backward from the newest. A heavily-traded coin can have far more history+// than is worth walking on a 60s-cached read, so this caps the cost rather+// than ever hanging the request.+const SIG_PAGE = 1000;+const CREATION_PAGE_BUDGET = 8;++function unavailable(reason) {+ return { available: false, reason };+}++function authoritiesSection(authorities) {+ if (!authorities) return unavailable('could not read the mint account from chain');+ const mintEnabled = !!authorities.mint_authority;+ const freezeEnabled = !!authorities.freeze_authority;+ return {+ available: true,+ mint_authority: {+ address: authorities.mint_authority,+ enabled: mintEnabled,+ sentence: mintEnabled+ ? 'An account can still mint new tokens, so total supply is not fixed.'+ : 'No account can mint new tokens; total supply is fixed.',+ },+ freeze_authority: {+ address: authorities.freeze_authority,+ enabled: freezeEnabled,+ sentence: freezeEnabled+ ? "An account can freeze any holder's tokens, blocking them from moving or selling."+ : 'No account can freeze token accounts.',+ },+ };+}++function supplySection(authorities) {+ if (!authorities || authorities.supply == null || authorities.decimals == null) {+ return unavailable('could not read supply and decimals from the mint account');+ }+ const decimals = authorities.decimals;+ const raw = authorities.supply;+ let formatted = null;+ try {+ formatted = Number(BigInt(raw)) / 10 ** decimals;+ } catch {+ formatted = null;+ }+ return { available: true, raw, decimals, formatted };+}++function holdersSection(holders) {+ if (!holders) return unavailable('holder set could not be read (indexer and fallback RPC both failed)');+ if (holders.top10_pct == null) {+ return { available: true, top10_pct: null, holder_count: holders.count, sentence: 'Top-10 holder share could not be computed from the available holder set.' };+ }+ const pct = (holders.top10_pct * 100).toFixed(2);+ return {+ available: true,+ top10_pct: holders.top10_pct,+ holder_count: holders.count,+ sentence: `The ten largest wallets (excluding the bonding curve and AMM pool) hold ${pct}% of supply.`,+ };+}++function feeRoutingSection(feeInfo) {+ if (feeInfo === null) {+ return { available: true, applicable: false, sentence: 'This coin did not launch through pump.fun, so there is no fee-routing data to report.' };+ }+ const sentence = feeInfo.is_holder_reward+ ? 'Trading fees are distributed to holders as rewards rather than to a creator wallet.'+ : feeInfo.is_cashback_coin+ ? 'Trading fees are routed back to traders as cashback rather than to a creator wallet.'+ : feeInfo.has_sharing_config+ ? "Trading fees are split among a fee-sharing configuration's listed shareholders."+ : "Trading fees flow directly to the coin's creator wallet.";+ return {+ available: true,+ applicable: true,+ destination: feeInfo.fee_destination,+ creator: feeInfo.creator,+ is_graduated: feeInfo.is_graduated,+ claimable_sol: feeInfo.claimable_sol,+ sharing_config: feeInfo.sharing_config,+ sentence,+ };+}++function riskSection(assessment) {+ if (!assessment) return unavailable('the trade safety firewall could not complete its checks');+ return {+ available: true,+ verdict: assessment.verdict,+ score: assessment.score,+ reasons: assessment.reasons,+ checks: assessment.checks,+ };+}++/** Walk getSignaturesForAddress backward to the mint's first transaction, then inspect its wire bytes. Never throws: every failure mode returns `{ available: false, reason }`. */+async function findCreation(connection, mint) {+ try {+ let before;+ let earliestSig = null;+ let reachedGenesis = false;+ for (let page = 0; page < CREATION_PAGE_BUDGET; page++) {+ const params = before+ ? [mint, { limit: SIG_PAGE, commitment: 'confirmed', before }]+ : [mint, { limit: SIG_PAGE, commitment: 'confirmed' }];+ const rpc = await connection._rpcRequest('getSignaturesForAddress', params);+ if (rpc.error) throw new Error(rpc.error.message || 'Solana RPC rejected getSignaturesForAddress');+ const sigs = Array.isArray(rpc.result) ? rpc.result : [];+ if (!sigs.length) {+ reachedGenesis = true;+ break;+ }+ earliestSig = sigs[sigs.length - 1];+ if (sigs.length < SIG_PAGE) {+ reachedGenesis = true;+ break;+ }+ before = earliestSig.signature;+ }+ if (!earliestSig) return unavailable('this mint has no transaction history on this RPC');+ if (!reachedGenesis) {+ return unavailable('this coin has too much trade history to walk back to its creation transaction within the lookup budget');+ }++ const txRpc = await connection._rpcRequest('getTransaction', [+ earliestSig.signature,+ { encoding: 'base64', commitment: 'confirmed', maxSupportedTransactionVersion: 1 },+ ]);+ if (txRpc.error) throw new Error(txRpc.error.message || 'Solana RPC rejected getTransaction');+ if (!txRpc.result) {+ return { available: false, reason: 'the creation transaction is too old for this RPC to serve', signature: earliestSig.signature };+ }+ const encoded = txRpc.result.transaction?.[0];+ if (typeof encoded !== 'string') {+ return { available: false, reason: 'the creation transaction came back in an unsupported encoding', signature: earliestSig.signature };+ }+ const inspection = inspectWireTransaction(encoded);+ return {+ available: true,+ signature: earliestSig.signature,+ slot: txRpc.result.slot ?? null,+ block_time: txRpc.result.blockTime ?? null,+ version: inspection.version,+ version_label: inspection.versionLabel,+ bytes: inspection.bytes,+ limit_bytes: inspection.limitBytes,+ utilization_pct: inspection.utilizationPct,+ };+ } catch (e) {+ return { available: false, reason: e?.message || 'creation lookup failed' };+ }+}++export async function buildReceipt(mint, network) {+ const connection = getConnection({ network });++ const [statsResult, feeResult, riskResult, creationResult] = await Promise.allSettled([+ buildStats(mint),+ computeFeeInfo(new PublicKey(mint), network),+ assessTradeSafety({ network, mint, side: 'buy', quoteAmount: DEFAULT_PROBE_LAMPORTS }),+ findCreation(connection, mint),+ ]);++ const stats = statsResult.status === 'fulfilled' ? statsResult.value : null;+ const creation =+ creationResult.status === 'fulfilled' ? creationResult.value : unavailable(creationResult.reason?.message || 'creation lookup failed');++ const receiptCore = {+ mint,+ network,+ authorities: authoritiesSection(stats?.authorities),+ supply: supplySection(stats?.authorities),+ holders: holdersSection(stats?.holders),+ fee_routing:+ feeResult.status === 'fulfilled'+ ? feeRoutingSection(feeResult.value)+ : unavailable(feeResult.reason?.message || 'fee routing could not be read from chain'),+ creation,+ risk:+ riskResult.status === 'fulfilled'+ ? riskSection(riskResult.value)+ : unavailable(riskResult.reason?.message || 'the trade safety firewall could not complete its checks'),+ generated_at: new Date().toISOString(),+ };+ const content_hash = createHash('sha256').update(stableStringify(receiptCore)).digest('hex');+ return { ...receiptCore, content_hash };+}++export default wrap(async (req, res) => {+ if (cors(req, res, { methods: 'GET,OPTIONS', origins: '*' })) return;+ if (!method(req, res, ['GET'])) return;++ const rl = await limits.publicIp(clientIp(req));+ if (!rl.success) return rateLimited(res, rl);++ const url = new URL(req.url, `http://${req.headers.host || 'x'}`);+ const mint = (url.searchParams.get('mint') || '').trim();+ if (!MINT_RE.test(mint)) return error(res, 400, 'invalid_mint', 'mint must be a base58 address');+ const network = url.searchParams.get('network') === 'devnet' ? 'devnet' : 'mainnet';++ const body = await cacheWrapLastGood(`pump:launch-receipt:${network}:${mint}`, CACHE_TTL_S, () => buildReceipt(mint, network));+ res.setHeader('cache-control', 'public, max-age=60, s-maxage=300');+ return json(res, 200, body);+});diff --git a/api/pump/token-stats.js b/api/pump/token-stats.jsindex bbb32435f..c9588719f 100644--- a/api/pump/token-stats.js+++ b/api/pump/token-stats.js@@ -244,6 +244,8 @@ async function readAuthorities(mint) {return {mint_authority: m.mintAuthority ? m.mintAuthority.toBase58() : null,freeze_authority: m.freezeAuthority ? m.freezeAuthority.toBase58() : null,+ decimals: m.decimals,+ supply: m.supply.toString(),};} catch {return null;@@ -265,7 +267,8 @@ async function readDexScreener(mint) {};}-async function buildStats(mint) {+/** Exported so other composed read surfaces (the launch receipt) can reuse the same fact sheet without an internal HTTP round trip. */+export async function buildStats(mint) {const now = Math.floor(Date.now() / 1000);const metaRes = await pumpFetchJson(`${PUMP_FRONTEND_BASE}/coins-v2/${mint}`, { timeoutMs: 5000 });const coin = metaRes.ok ? metaRes.body : null;diff --git a/data/changelog.json b/data/changelog.jsonindex f38988ee4..5adee3f31 100644--- a/data/changelog.json+++ b/data/changelog.json@@ -1,6 +1,15 @@{"$comment": "Curated changelog entries for three.ws, the editorial layer of the public changelog. New PAGE launches are tracked automatically via the `added` field in data/pages.json; this file is for everything else holders care about: improvements, fixes, SDK releases, trading/payments capabilities, security work. scripts/build-page-index.mjs merges both sources into CHANGELOG.md, public/changelog.json, and public/changelog.xml. Newest first. Allowed tags: feature, improvement, fix, sdk, infra, docs, security, desktop (desktop entries become the desktop app's release notes). `link` is optional and must be a live three.ws path.","entries": [+ {+ "date": "2026-10-14",+ "title": "Every pump.fun launch now carries a plain-English receipt",+ "summary": "/launches/<mint> gained a Launch receipt panel composing five on-chain facts into one readable object: whether the mint or freeze authority can still act (with a plain sentence for each, not just enabled/disabled), supply and decimals, the top-10 holder share, where trading fees route (a creator wallet, a fee-sharing config, cashback, or holder rewards), the creation transaction's version and byte size, and the Trade Safety Firewall's verdict. A coin that never launched through pump.fun gets an honest 'not a pump.fun launch' instead of an error, and a source that fails marks only its own section unavailable, never an invented number. Copy the receipt as text or download it as JSON; both carry a SHA-256 content hash of the response so a saved copy can be checked against a fresh read. A shareable 1200x630 card is available via GET /api/pump/launch-og?mint=<mint>&variant=receipt, and the composition itself is a new public endpoint, GET /api/pump/launch-receipt?mint=<mint>.",+ "tags": [+ "feature"+ ],+ "link": "/launches"+ },{"date": "2026-10-14","title": "Atomic is now a six-tab Transaction V1 lab, not just an inspector",diff --git a/docs/ALL.md b/docs/ALL.mdindex be531ebe6..d13a3ee1d 100644--- a/docs/ALL.md+++ b/docs/ALL.md@@ -1,7 +1,7 @@<!-- GENERATED by scripts/combine-docs.mjs — do not edit by hand. Edit the source files under docs/ and re-run. --># three.ws — Combined Documentation-> Single-file snapshot of every document under [`docs/`](.). Generated 2026-10-14 from **882 files** (~13434 KB).+> Single-file snapshot of every document under [`docs/`](.). Generated 2026-10-14 from **882 files** (~13453 KB).> The individual source files remain the canonical, editable copies — this file is a read-only aggregate.## Table of contents@@ -36213,6 +36213,35 @@ No auth. `GET` returns `{ network, win, leaders[], starter_caps, eligibility_bar| `invalid_config` | 400 | a `starter: true` subscription past a starter cap (the reason is in `error_description`) || `rate_limited` | 429 | over the IP limit |+### Launch receipt++```+GET /api/pump/launch-receipt?mint=<mint>&network=<mainnet|devnet>+```++No auth, CORS-open, IP rate-limited, cached `public, max-age=60, s-maxage=300`.+Composes authorities, supply, top-10 holder share, fee routing, the creation+transaction's version and byte size, and the Trade Safety Firewall's verdict+into one plain-English object for a pump.fun launch, each with a `sentence`+field in addition to its raw value. Every section fails independently: a+source that can't be read answers `{ available: false, reason }` for that+section alone, and a mint that never launched through pump.fun gets+`fee_routing: { available: true, applicable: false }` rather than an error.+`content_hash` is a SHA-256 of the response's own canonical JSON, so a saved+or shared copy can be checked against a fresh read. Rendered on+`/launches/<mint>` as the "Launch receipt" panel, and as a shareable card via+`GET /api/pump/launch-og?mint=<mint>&variant=receipt`. Guide:+[coin-launches.md](coin-launches.md#launch-receipt).++```bash+curl -s 'https://three.ws/api/pump/launch-receipt?mint=FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump'+```++| Error | Status | Meaning |+| --- | --- | --- |+| `invalid_mint` | 400 | `mint` is not a base58 address |+| `rate_limited` | 429 | over the IP limit |+## Home APIRead and act on a Home Assistant house the account has connected. Session-authenticated from a@@ -39250,14 +39279,15 @@ searching for "embed".> **Source:** `docs/atomic.md` · [↑ table of contents](#table-of-contents)-# Atomic: Solana Transaction V1 inspector+# Atomic: Solana Transaction V1 lab-[Atomic](/atomic) is three.ws's read-only flight recorder for Solana transactions. It accepts either a confirmed mainnet signature or signed wire bytes and returns the same normalized inspection for legacy, V0, and V1 transactions.+[Atomic](/atomic) is three.ws's read-only lab for Solana transactions: a tabbed flight recorder, size and budget planner, config mask decoder, legacy/V0/V1 diff, sponsor cap view, and wallet V1 capability check. The Inspector tab accepts either a confirmed mainnet signature or signed wire bytes and returns the same normalized inspection for legacy, V0, and V1 transactions; the other five tabs are documented below in "The lab: five more tools."-It is built for two jobs:+It is built for three jobs:-- Developers can see whether a payload needs V1's 4,096-byte envelope.+- Developers can see whether a payload needs V1's 4,096-byte envelope, and plan an exact byte budget before they build one.- Wallets, relayers, and fee sponsors can read the limits they are actually agreeing to before they co-sign.+- Anyone can check whether their own wallet honestly advertises V1 signing before they rely on it.Atomic never signs, simulates, or broadcasts a transaction.@@ -39299,6 +39329,74 @@ curl https://three.ws/api/solana/atomic \The response is JSON-safe. Priority fees and other wide integers are returned as numbers when they fit safely, otherwise as decimal strings.+## Replay: pump.fun lifecycle events++When a confirmed transaction invoked Pump, PumpSwap, or PumpFees, Atomic decodes every typed event in its logs, oldest first, and the page renders them as a step-by-step **Replay**: a curve-position bar, a human-readable description of each step, and the SOL/token amounts that moved.++The decoder covers a coin's full lifecycle:++- `create`: a new bonding curve launches.+- `trade`: a buy or sell against the bonding curve, with the post-trade curve-fill percentage.+- `complete`: the curve graduates; liquidity migrates to PumpSwap.+- `ammBuy` / `ammSell`: a swap against the graduated PumpSwap pool.+- `collectCreatorFee` / `distributeCreatorFees`: creator-fee collection and its split across shareholders.+- `socialFeePdaClaimed`: a GitHub social-fee PDA claim.++An event whose 8-byte discriminator is not in the installed `@nirholas/pump-sdk`'s IDLs (a program upgrade this install predates) still renders, as `unrecognized`, with its raw program ID and bytes. The replay never silently drops a step.++For a `create` transaction, the response also carries `replay`: the earliest trades on that mint since launch. Solana's `getSignaturesForAddress` has no forward cursor, only a `before` cursor walking backward from "now," so the server walks backward in capped pages (5 pages of 1,000 signatures) looking for the create signature, then returns the trades between it and the oldest page reached. A caller that gets `hasMore: true` back pages deeper with the returned `nextBefore`; the page's "Load earlier trades" button does this automatically.++Try it against a real $THREE trade:++```bash+curl https://three.ws/api/solana/atomic \+ -H 'content-type: application/json' \+ -d '{"signature":"3mmfm7wj9CtC5QutckLKvYQZDhQcaVBrbYD8sZFwKHW7efN9E3ETz9yMeMNfYw8coodpNfYzpM6wfzr5RUf1CYo"}'+```++$THREE graduated its bonding curve some time ago, so this particular signature decodes as PumpSwap AMM events (`ammInitUserVolumeAccumulator`, `ammBuy`, `ammCloseUserVolumeAccumulator`) rather than bonding-curve `trade` events; both shapes render in the same Replay panel. AMM buy/sell events carry a `pool` address but no `mint` field in the installed IDL, so the panel's "View launch" link only appears when the transaction includes a bonding-curve event (`create`, `trade`, or `complete`), which does carry one.++A transaction with no pump.fun events (most Solana transactions) shows a plain "no pump.fun events in this transaction" state instead of an empty panel.++## The lab: five more tools++`/atomic` is a tabbed lab, not a single tool. The Inspector above is the first tab; the other five share its read-only guarantee (nothing is ever signed, simulated, or broadcast) and are reachable by click, by arrow-key/Home/End navigation on the tab bar, or by a deep link: `/atomic?tab=mask`, `?tab=sponsor`, `?tab=planner`, `?tab=diff`, `?tab=wallet`.++### Config mask decoder++Every V1 transaction carries a 4-byte `TransactionConfigMask` (a little-endian `u32`) immediately after the version byte and legacy header, followed by fixed-width `ConfigValues` for each set bit. This tab decodes those exact bytes from a pasted signature or wire transaction, independently of the higher-level `budget` field the Inspector shows, and reports:++- the mask as hex, as a 32-character binary string, and as a bit popcount;+- each of the five known bits (priority fee spans bits 0-1 as one 8-byte value; compute unit limit, loaded accounts data size, and heap size each own one bit and one 4-byte value), whether it is present, and its raw bytes and decoded value;+- a priority-fee mask with only one of its two bits set, flagged as a partial, invalid encoding (SIMD-0385 requires both or neither);+- any set bit above bit 4, flagged as reserved, since a future SIMD may assign it a meaning this decoder does not yet know;+- the exact byte offset range `ConfigValues` occupies in the message.++A legacy or V0 transaction has no config mask; the tab states that plainly instead of showing an empty table.++### Sponsor cap view++A paymaster or co-signer reads this before it agrees to pay. For the same pasted signature or wire transaction, it shows only what a sponsor needs: the resolved priority fee, compute unit limit, loaded-accounts data size limit, and heap size (reading V1's `transactionConfig` directly, never a Compute Budget instruction scan that would see nothing on a V1 transaction), plus a duplicate-static-account check. SIMD-0385 makes a duplicate entry in the static address table a sanitization failure; this view lists any duplicate it finds and states plainly when there is none.++### Size and budget planner++Paste a fee payer address and a JSON array of instructions (`{programId, keys: [{pubkey, isSigner, isWritable}], data}`, `data` as base64 or a byte array), pick a target version, and optionally a compute unit limit, loaded-accounts data size limit, heap size, and priority fee in micro-lamports per CU. The planner compiles that exact instruction set with `@solana/kit`, the same encoder three.ws ships to real callers, and reports:++- the exact wire byte count, headroom or overage against the chosen version's ceiling, and a visual ruler;+- inline account count, instruction count, required signer count, and message byte count;+- the resolved resource budget, including the priority fee as an exact total in lamports (compute unit limit times the micro-lamports price, rounded up to the nearest lamport, matching the runtime's own cost accounting);+- the duplicate-static-account check described above.++"Load example instruction" fills the form with a System Program transfer using `$THREE`'s mint as a clearly-synthetic placeholder account; it is never auto-filled on page load.++### Legacy vs V0 vs V1 diff++Same form as the planner, minus the version picker: it compiles the identical instruction set three ways (legacy, V0, V1) and reports each version's exact byte count, ceiling, headroom, and fit side by side, plus the byte delta V1 saves (or costs) against legacy and against V0. V1 is not assumed to always win: its inline config mask and fixed-width values can make a very small transaction larger than the same payload on legacy or V0, and the diff reports whichever is actually true for the pasted instructions.++### Wallet V1 capability check++Connects the browser's injected Solana wallet (a plain `connect()`, with no SIWS account-linking and no three.ws login as a side effect) and reads its real [Wallet Standard](https://github.com/wallet-standard/wallet-standard) `solana:signTransaction` feature. The pass/fail verdict comes from the same `findV1WalletStandardSigner` helper three.ws calls before it ever asks a wallet for a real V1 signature, so this tab reports exactly what the rest of the platform would see, not a separate approximation. If the wallet is V1-capable, the tab also lists every transaction version its own feature set advertises, verbatim.+## API### Mainnet activation status@@ -39315,7 +39413,7 @@ This reads the `txv1` feature account and the current confirmed slot through thecurl 'https://three.ws/api/solana/atomic?signature=SOLANA_SIGNATURE'```-The RPC request always passes `maxSupportedTransactionVersion: 1`. Confirmed results are cached because their wire bytes and metadata are immutable.+The RPC request always passes `maxSupportedTransactionVersion: 1`. Confirmed results are cached because their wire bytes and metadata are immutable. The response also carries `events` (every decoded pump.fun event in the transaction, see Replay above) and, for a create transaction, `replay`. `before` and `tradeLimit` query params page a create transaction's `replay.trades` deeper; a response that passed `before` is never cached.### Raw transaction@@ -39328,6 +39426,37 @@ Content-Type: application/jsonThe raw path is not cached and does not send the transaction to Solana.+### Size and budget plan++```http+POST /api/solana/atomic-plan+Content-Type: application/json++{+ "feePayer": "BASE58_ADDRESS",+ "version": 1,+ "budgetConfig": { "computeUnitLimit": 200000, "loadedAccountsDataSizeLimit": 4096, "priorityFeeMicroLamportsPerCu": 10 },+ "instructions": [+ { "programId": "11111111111111111111111111111111", "keys": [{ "pubkey": "BASE58_ADDRESS", "isSigner": true, "isWritable": true }], "data": "BASE64_DATA" }+ ]+}+```++`version` is `"legacy"`, `0`, or `1`. `budgetConfig` and each of its fields are optional. Every reported number comes from compiling and encoding this exact instruction set with `@solana/kit`; nothing is estimated, signed, simulated, or broadcast. The handler is rate-limited the same way as `/api/solana/atomic` and caps the request body at 64 KiB and 64 instructions.++### Legacy vs V0 vs V1 diff++Same endpoint, with `"diff": true` in place of `version`:++```http+POST /api/solana/atomic-plan+Content-Type: application/json++{ "feePayer": "BASE58_ADDRESS", "diff": true, "budgetConfig": {}, "instructions": [ ... ] }+```++The response is `{ "diff": { "legacy", "v0", "v1", "bytesSavedVsLegacy", "bytesSavedVsV0" } }`, one plan object per version plus the byte deltas between them.+## Platform compatibilityEvery three.ws Solana transaction read now opts into version 1. The web app and API dependency floor is `@solana/kit` 8.3 and `@solana/web3.js` 1.99, so direct readers can decode V1 rather than rejecting it as an unsupported transaction version.@@ -56776,6 +56905,36 @@ The same dispatcher handles the full lifecycle beyond launch: `buy-prep` /(`strategy-backtest`, `strategy-validate`, `strategy-close-all`) that back the[sniper](#sec-141).+## Launch receipt++`/launches/<mint>` composes five of the facts above (mint and freeze+authority, supply, top-10 holder share, fee routing, the creation+transaction, and the Trade Safety Firewall's verdict) into one plain-English+receipt, so a trader can read or share one object instead of piecing five+panels together.++```+GET /api/pump/launch-receipt?mint=<mint>&network=<mainnet|devnet>+```++Public, CORS-open, cached `public, max-age=60, s-maxage=300`+(`api/pump/launch-receipt.js` `buildReceipt`). Each section fails+independently: a source that cannot be read marks only its own section+`{ "available": false, "reason": "…" }` rather than failing the whole+response, and a mint that never launched through pump.fun gets+`fee_routing: { "applicable": false }` instead of an error. The response+carries a `content_hash`, a SHA-256 of its own canonical JSON, so a+downloaded or shared copy can be checked against a fresh read.++```bash+curl -s 'https://three.ws/api/pump/launch-receipt?mint=FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump'+```++The coin detail page renders this as a "Launch receipt" panel with a copy-as-text+button and a JSON download, both reusing `content_hash` from the same+response. `?variant=receipt` on `api/pump/launch-og.js` renders the same facts+as a shareable 1200×630 social card.+## $THREE onlyThe launcher is **coin-agnostic plumbing**: it accepts an arbitrary,@@ -64348,7 +64507,25 @@ GitHub token for that account (`GITHUB_TOKEN`, or the PAT on the `origin` remoteA token for a different account authenticates fine and is then rejected for thatnamespace.-**3. Standalone GitHub mirrors** - about 80 directories in this monorepo also+**3. Catching a published package that lagged its source** (`scripts/lib/stale-packages.mjs`,+run from either publish script):++```bash+npm run publish:stale # or: node scripts/publish-mcp-servers.mjs --stale+```++A publish only happens when someone runs the commands above. If source keeps moving+after that run and nobody runs it again, npm quietly serves a stale tarball forever;+nothing else notices. `--stale` checks every publishable directory (library packages+and MCP servers alike): for each one it reads `npm view <name> time --json`, and if+the local `version` is already on npm, counts commits to that directory after the+publish timestamp that touch something other than `README.md`, `CHANGELOG.md`, or a+test file. A package with such commits is stale; the report prints the exact bump and+publish command for each one and the command exits `1` if anything is stale. A local+version npm has never seen is reported separately as "never published" rather than as+an error. It never calls `npm publish` itself.++**4. Standalone GitHub mirrors** - about 80 directories in this monorepo alsolive in their own public repo at `github.com/<owner>/<name>` (a read-onlymirror; the monorepo stays canonical). [`data/standalone-mirrors.json`](../data/standalone-mirrors.json)is the single source of truth for "which directory is which public repo, in@@ -131157,30 +131334,94 @@ Written down so the next person does not re-derive it:A live feed of **first-time pump.fun creator fee claims**, delivered to aTelegram channel (`@pumpfunclaims`), one message per claim.-A claim is a real on-chain withdrawal. For GitHub social fees, it proves payment-to a GitHub fee account, not automatically that the GitHub user created, owns, or-endorses a particular coin. Token metadata can name lookalike accounts, and one-fee account can pool rewards from several coins.--Trader-facing cards use five evidence labels: **Verified GitHub Fee Claim**,-**Creator-Wallet GitHub Fee Claim**, **Identity Mismatch**, **Unverified**, and-**Unresolved Pooled**. A pooled event selects no primary CA or per-coin amount.-“First-ever” refers to the shared fee account, and trade links appear only for-verified relationships. The feed is a research lead, not an endorsement.+Two kinds of claim feed this channel: an ordinary wallet withdrawing its own+coin's creator fees (the original feature), and a GitHub identity withdrawing+fees a coin delegated to it through pump.fun's fee-sharing program (the+`claim_social_fee_pda` instruction). A GitHub withdrawal is a real on-chain+payment to that GitHub identity's fee account, but it does not by itself prove+which coin paid for it, or that the GitHub user created, owns, or endorses that+coin: one fee account (a "social fee PDA") can be a shareholder on more than one+coin's `SharingConfig`, and a scammer can paste someone else's PDA, or their own+freshly-registered one, into a copycat coin's metadata. Attribution below+answers "which coin, if any, paid this" from on-chain evidence, never from the+highest-market-cap guess.++## GitHub fee-claim attribution++`api/_lib/pump-claims-attribution.js` classifies every GitHub+`claim_social_fee_pda` withdrawal into exactly one of seven labels, using two+evidence rules in order of strength, then two identity checks when neither rule+finds evidence:++1. **Transaction-attributed.** The claim transaction itself also carries a+ `DistributeCreatorFeesEvent` that pays the exact PDA being claimed. Payout+ and attribution are in the same atomic transaction, so this is the strongest+ evidence a withdrawal can have.+2. **Fee-history-attributed.** No distribution rode along with the claim, so the+ scanner walks the PDA's own transaction history backward from the claim (up+ to 40 transactions or 7 days, whichever comes first, stopping early at the+ PDA's previous claim) looking for distributions in the claim's own quote+ currency. If those distributions cover at least 90% of the amount withdrawn,+ and one coin accounts for at least 90% of what was observed, the withdrawal+ is attributed to that coin. Short of either threshold, nothing is attributed+ from history.+3. **Verified repository.** Neither rule found a paying coin, but the claiming+ GitHub login matches the repository owner linked in the coin's metadata+ (description, website, X/Telegram links, or metadata URI).+4. **Identity mismatch.** A repository link exists in the coin's metadata, but+ its owner is a different GitHub account than the one that claimed. This is+ the strongest public signal of a lookalike coin.+5. **Creator-wallet verified.** No repository link exists at all, but the claim+ recipient wallet matches the coin's on-chain creator wallet.+6. **Unresolved pooled.** No evidence rule found a payer, and the PDA has been a+ shareholder in more than one coin recently. The withdrawal is real but cannot+ be assigned to a single CA or amount.+7. **Unverified.** A real withdrawal occurred, and none of the above resolved+ it. The claim is reported; no coin is credited.++**The impersonation hold** (`assessImpersonation`) is a separate, additive gate+applied after classification. Even an attributed claim is held for review, not+posted with its celebratory framing, when the claiming GitHub account is less+than 30 days old AND either: a same-name coin on pump.fun is at least 1.5x+larger by market cap than the one the claim is about, or the metadata repository+was created less than 7 days before the claim. A new account alone is not+suspicious, and neither is a same-name coin; the combination is the pattern a+scam follows (register a lookalike account, push a repo, put it in a copycat+coin's metadata, delegate fees to it, claim them), so both conditions must hold+before a claim is held. A held claim's Telegram message and feed card+(`buildClaimCard` in `src/pump/first-claims.js`) state plainly that a withdrawal+happened and why it is held, instead of naming a coin or identity the evidence+does not support yet.## How it works```pump.fun program activity│- ▼-scanFirstClaims() api/_lib/pump-claims.js- ├── PUMPFUN_BOT_URL indexer (preferred)- └── direct Solana RPC scan (fallback, see "Known limits")+ ├── creator fee claims (Pump program)+ │ │+ │ ▼+ │ scanFirstClaims() api/_lib/pump-claims.js+ │ ├── PUMPFUN_BOT_URL indexer (preferred)+ │ └── direct Solana RPC scan (fallback, see "Known limits")+ │+ └── GitHub fee-PDA claims (PumpFees program, claim_social_fee_pda)+ │+ ├── services/pump-claims (real-time listener, see below)+ │ └── writes pump_fee_claims+ │+ ▼+ _fetchGithubClaimsFromRpc() api/_lib/pump-claims.js+ ├── pump_fee_claims table (preferred; populated by the listener)+ └── direct Solana RPC scan (fallback, when the table has nothing+ for the requested window; same evidence rules either way)+ ├── same-tx / fee-history evidence pump-claims-attribution.js+ └── GitHub user + coin metadata lookups pump-claims-github.js│▼pushTelegramLane() api/_lib/pump-claims-push.js├── diff against app_settings['pump_claims_push_telegram']+ ├── wallet claims deduped by signature, GitHub claims by user id + mint├── oldest-first, 10 per tick, 3.5s apart└── Telegram sendMessage → TELEGRAM_PUMP_CLAIMS_CHAT_ID│@@ -131191,13 +131432,32 @@ GET /api/cron/pump-claims-push every 5 minutes (Cloud Scheduler)The same scanner also backs `GET /api/pump/first-claims` and the`pumpfun_first_claims` MCP tool, so the channel and the API never disagree.+## The real-time listener: `services/pump-claims`++GitHub fee-PDA claims no longer depend on an RPC scan at read time, or on+`PUMPFUN_BOT_URL`, which only ever covered ordinary wallet claims. A standalone+long-lived process, [services/pump-claims](../services/pump-claims), holds a+Solana log subscription on the PumpFees program, decodes and attributes each+`claim_social_fee_pda` as it lands, and writes it into `pump_fee_claims`+(migration+[20261015080000_pump_fee_claims.sql](../api/_lib/migrations/20261015080000_pump_fee_claims.sql)).++`scanFirstClaims`'s GitHub path now reads that table first and only falls back+to the direct RPC scan described below when the table has nothing for the+requested window (a fresh deployment before the listener's backfill has run,+or the listener being down). Both paths run the exact same attribution rules,+so which one answered is invisible to a caller except for a `source` field+logged server-side. See the service's own+[README](../services/pump-claims/README.md) for how it runs, reconnects, and+backfills.+## Configuration| Variable | Required | Purpose ||---|---|---|| `TELEGRAM_BOT_TOKEN` | yes | Bot that posts. Create via [@BotFather](https://t.me/BotFather). || `TELEGRAM_PUMP_CLAIMS_CHAT_ID` | yes | `@pumpfunclaims`, or the `-100…` numeric id. |-| `PUMPFUN_BOT_URL` | yes in practice | pump.fun claims indexer. Without it the scan returns nothing (see below). |+| `PUMPFUN_BOT_URL` | optional | pump.fun claims indexer for **ordinary wallet claims** only. Without it, wallet claims return nothing (see below); GitHub fee-PDA claims are unaffected, served by `services/pump-claims` and its RPC fallback regardless. || `PUMPFUN_BOT_TOKEN` | optional | Bearer token for the indexer, when it requires one. |The bot **must be an administrator of the channel** with permission to post.@@ -131221,7 +131481,10 @@ gcloud run services update three-ws-api \## Verifying it```bash-# 1. Is the scan returning claims at all?+# 1. Is the scan returning claims at all? GitHub claims carry githubUserId and+# attribution; wallet claims do not. An empty items array with HTTP 200 is a+# correct result when no first-time claim of either kind happened in the+# window, not a failure (GitHub fee-PDA claims are rare on mainnet).curl -s 'https://three.ws/api/pump/first-claims?sinceMinutes=60&limit=5'# 2. Does the bot have channel access? (replace $TOKEN)@@ -131242,16 +131505,23 @@ call reports exactly what happened: `{ posted, scanned, backlog }`, orState lives in `app_settings` under `pump_claims_push_telegram`:```json-{ "lastTs": 1723661000, "seen": ["<tx signature>", "..."] }+{ "lastTs": 1723661000, "seen": ["<tx signature>", "..."], "githubSeen": ["<githubUserId>:<mint>", "..."] }```- **First run seeds without posting.** Enabling the lane records what is alreadyon-chain and starts posting from the next tick, so switching it on never dumpsa backlog into the channel.-- **Dedupe is by transaction signature**, not by timestamp. Two claims landing in- the same second are common; a timestamp-only cursor would silently drop the- second one. `seen` is a bounded ring of 400 signatures; `lastTs` bounds the- scan window so the ring never has to answer for anything older.+- **Wallet claims dedupe by transaction signature**, not by timestamp. Two+ claims landing in the same second are common; a timestamp-only cursor would+ silently drop the second one. `seen` is a bounded ring of 400 signatures;+ `lastTs` bounds the scan window so the ring never has to answer for anything+ older.+- **GitHub claims dedupe by GitHub user id plus mint**, in a second bounded ring,+ `githubSeen`. The same GitHub identity can submit more than one+ `claim_social_fee_pda` transaction against the same coin (a sweep followed by+ a claim, or claiming again later), each with its own signature; the channel+ announces that pairing once, the same way it announces a wallet's first claim+ once.- **A three-hour cutoff** bounds any catch-up. A lane that has been down for aday drains recent claims and drops stale ones rather than replaying history.- **State is written per message, not per run.** A tick killed mid-batch (the@@ -131266,11 +131536,16 @@ State lives in `app_settings` under `pump_claims_push_telegram`:data; unescaped text could otherwise smuggle a clickable link posted under theplatform bot's identity.-## Known limits: the RPC fallback cannot serve this feed+## Known limits: the RPC fallback cannot serve the wallet-claim feed++This limit is specific to **ordinary wallet claims**. The GitHub fee-claim path+(`_fetchGithubClaimsFromRpc`) always runs a direct RPC scan, independent of+`PUMPFUN_BOT_URL`; see "Verifying it" below for a live check of that path.-`scanFirstClaims` prefers the `PUMPFUN_BOT_URL` indexer and falls back to a-direct RPC scan of the pump program's recent signatures. **That fallback cannot-produce a useful result, and the channel will stay silent without the indexer.**+`scanFirstClaims` prefers the `PUMPFUN_BOT_URL` indexer for wallet claims and+falls back to a direct RPC scan of the pump program's recent signatures. **That+fallback cannot produce a useful result, and the channel will stay silent for+wallet claims without the indexer.**Measured against mainnet on 2026-08-14:@@ -131306,9 +131581,13 @@ built yet.## Related-- [api/_lib/pump-claims.js](../api/_lib/pump-claims.js) - the shared scanner+- [api/_lib/pump-claims.js](../api/_lib/pump-claims.js) - the shared scanner (wallet claims and GitHub fee-PDA claims)+- [api/_lib/pump-events.js](../api/_lib/pump-events.js) - typed Pump/PumpFees event decoder (wraps `@nirholas/pump-sdk`)+- [api/_lib/pump-claims-attribution.js](../api/_lib/pump-claims-attribution.js) - the evidence rules, the seven labels, and the impersonation hold+- [api/_lib/pump-claims-github.js](../api/_lib/pump-claims-github.js) - GitHub identity and coin-metadata lookups used by attribution- [api/_lib/pump-claims-push.js](../api/_lib/pump-claims-push.js) - the delivery lane- [api/cron/pump-claims-push.js](../api/cron/pump-claims-push.js) - the cron entry point+- [src/pump/first-claims.js](../src/pump/first-claims.js) - `buildClaimCard`, the shared held/attributed/claimed view model- [api/_lib/commit-feed-push.js](../api/_lib/commit-feed-push.js) - the sibling commit feed this lane mirrors---diff --git a/docs/api-reference.md b/docs/api-reference.mdindex 0e6acba52..0c5e4266d 100644--- a/docs/api-reference.md+++ b/docs/api-reference.md@@ -9404,6 +9404,35 @@ No auth. `GET` returns `{ network, win, leaders[], starter_caps, eligibility_bar| `invalid_config` | 400 | a `starter: true` subscription past a starter cap (the reason is in `error_description`) || `rate_limited` | 429 | over the IP limit |+### Launch receipt++```+GET /api/pump/launch-receipt?mint=<mint>&network=<mainnet|devnet>+```++No auth, CORS-open, IP rate-limited, cached `public, max-age=60, s-maxage=300`.+Composes authorities, supply, top-10 holder share, fee routing, the creation+transaction's version and byte size, and the Trade Safety Firewall's verdict+into one plain-English object for a pump.fun launch, each with a `sentence`+field in addition to its raw value. Every section fails independently: a+source that can't be read answers `{ available: false, reason }` for that+section alone, and a mint that never launched through pump.fun gets+`fee_routing: { available: true, applicable: false }` rather than an error.+`content_hash` is a SHA-256 of the response's own canonical JSON, so a saved+or shared copy can be checked against a fresh read. Rendered on+`/launches/<mint>` as the "Launch receipt" panel, and as a shareable card via+`GET /api/pump/launch-og?mint=<mint>&variant=receipt`. Guide:+[coin-launches.md](coin-launches.md#launch-receipt).++```bash+curl -s 'https://three.ws/api/pump/launch-receipt?mint=FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump'+```++| Error | Status | Meaning |+| --- | --- | --- |+| `invalid_mint` | 400 | `mint` is not a base58 address |+| `rate_limited` | 429 | over the IP limit |+## Home APIRead and act on a Home Assistant house the account has connected. Session-authenticated from adiff --git a/docs/coin-launches.md b/docs/coin-launches.mdindex d2e32dd3c..49dbb2774 100644--- a/docs/coin-launches.md+++ b/docs/coin-launches.md@@ -67,6 +67,36 @@ The same dispatcher handles the full lifecycle beyond launch: `buy-prep` /(`strategy-backtest`, `strategy-validate`, `strategy-close-all`) that back the[sniper](autonomous-x402.md).+## Launch receipt++`/launches/<mint>` composes five of the facts above (mint and freeze+authority, supply, top-10 holder share, fee routing, the creation+transaction, and the Trade Safety Firewall's verdict) into one plain-English+receipt, so a trader can read or share one object instead of piecing five+panels together.++```+GET /api/pump/launch-receipt?mint=<mint>&network=<mainnet|devnet>+```++Public, CORS-open, cached `public, max-age=60, s-maxage=300`+(`api/pump/launch-receipt.js` `buildReceipt`). Each section fails+independently: a source that cannot be read marks only its own section+`{ "available": false, "reason": "…" }` rather than failing the whole+response, and a mint that never launched through pump.fun gets+`fee_routing: { "applicable": false }` instead of an error. The response+carries a `content_hash`, a SHA-256 of its own canonical JSON, so a+downloaded or shared copy can be checked against a fresh read.++```bash+curl -s 'https://three.ws/api/pump/launch-receipt?mint=FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump'+```++The coin detail page renders this as a "Launch receipt" panel with a copy-as-text+button and a JSON download, both reusing `content_hash` from the same+response. `?variant=receipt` on `api/pump/launch-og.js` renders the same facts+as a shareable 1200×630 social card.+## $THREE onlyThe launcher is **coin-agnostic plumbing**: it accepts an arbitrary,diff --git a/pages/launch-detail.html b/pages/launch-detail.htmlindex a87918751..009f71c14 100644--- a/pages/launch-detail.html+++ b/pages/launch-detail.html@@ -65,6 +65,7 @@<section id="ld-chart" class="ld-section" aria-label="Price history"></section><section id="ld-distribution" class="ld-section" aria-label="Holder distribution"></section><section id="ld-economics" class="ld-section" aria-label="Buyback & burn economics"></section>+ <section id="ld-receipt" class="ld-section" aria-label="Launch receipt"></section><section id="ld-copilot" class="ld-section" aria-label="Launch Copilot — autonomous market-maker"></section></div><aside class="ld-side">diff --git a/public/changelog-recent.json b/public/changelog-recent.jsonindex 549d9f984..8acd11b21 100644--- a/public/changelog-recent.json+++ b/public/changelog-recent.json@@ -1,11 +1,11 @@{- "generated_at": "2026-10-14T17:22:11.561Z",+ "generated_at": "2026-10-14T18:13:33.933Z","generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json","site": {"name": "three.ws","url": "https://three.ws"},- "total": 4087,+ "total": 4088,"complete": false,"full_feed": "/changelog.json","entries": [@@ -51,6 +51,16 @@"sdk"]},+ {+ "date": "2026-10-14",+ "type": "update",+ "title": "Every pump.fun launch now carries a plain-English receipt",+ "summary": "/launches/<mint> gained a Launch receipt panel composing five on-chain facts into one readable object: whether the mint or freeze authority can still act (with a plain sentence for each, not just enabled/disabled), supply and decimals, the top-10 holder share, where trading fees route (a creator wallet, a fee-sharing config, cashback, or holder rewards), the creation transaction's version and byte size, and the Trade Safety Firewall's verdict. A coin that never launched through pump.fun gets an honest 'not a pump.fun launch' instead of an error, and a source that fails marks only its own section unavailable, never an invented number. Copy the receipt as text or download it as JSON; both carry a SHA-256 content hash of the response so a saved copy can be checked against a fresh read. A shareable 1200x630 card is available via GET /api/pump/launch-og?mint=<mint>&variant=receipt, and the composition itself is a new public endpoint, GET /api/pump/launch-receipt?mint=<mint>.",+ "link": "/launches",+ "tags": [+ "feature"+ ]+ },{"date": "2026-10-14","type": "update",@@ -1547,16 +1557,6 @@"feature","security"]- },- {- "date": "2026-10-10",- "type": "update",- "title": "Approve your agents' payments from a notification",- "summary": "Set any agent spend rule to Ask me and the agent now waits for your yes instead of failing. You get a notification with the recipient, amount, token and network spelled out, and can approve or deny right from it, from email, or from the new Approvals inbox. Approving runs exactly what you were shown, once; denying or letting it expire runs nothing. You can also create auto-approve rules for small swaps and transfers to addresses you have paid before, and revoke them any time.",- "link": "/approvals",- "tags": [- "feature"- ]}]}diff --git a/public/changelog.json b/public/changelog.jsonindex 728cfa8fa..43bcc043f 100644--- a/public/changelog.json+++ b/public/changelog.json@@ -1,5 +1,5 @@{- "generated_at": "2026-10-14T17:22:11.540Z",+ "generated_at": "2026-10-14T18:13:33.913Z","generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json","site": {"name": "three.ws",@@ -48,6 +48,16 @@"sdk"]},+ {+ "date": "2026-10-14",+ "type": "update",+ "title": "Every pump.fun launch now carries a plain-English receipt",+ "summary": "/launches/<mint> gained a Launch receipt panel composing five on-chain facts into one readable object: whether the mint or freeze authority can still act (with a plain sentence for each, not just enabled/disabled), supply and decimals, the top-10 holder share, where trading fees route (a creator wallet, a fee-sharing config, cashback, or holder rewards), the creation transaction's version and byte size, and the Trade Safety Firewall's verdict. A coin that never launched through pump.fun gets an honest 'not a pump.fun launch' instead of an error, and a source that fails marks only its own section unavailable, never an invented number. Copy the receipt as text or download it as JSON; both carry a SHA-256 content hash of the response so a saved copy can be checked against a fresh read. A shareable 1200x630 card is available via GET /api/pump/launch-og?mint=<mint>&variant=receipt, and the composition itself is a new public endpoint, GET /api/pump/launch-receipt?mint=<mint>.",+ "link": "/launches",+ "tags": [+ "feature"+ ]+ },{"date": "2026-10-14","type": "update",diff --git a/public/changelog.xml b/public/changelog.xmlindex 1ccbe5d04..e603d4ed1 100644--- a/public/changelog.xml+++ b/public/changelog.xml@@ -38,6 +38,14 @@<category>fix</category><description>@three-ws/walk's ?walk=play&avatar=<id> deep link and the drop-in resume path read the saved avatar preference straight out of storage and never looked at the query string, so sharing a link to a specific avatar silently loaded the stored (or default) one instead. A new deepLinkAvatarId resolver gives the query param precedence and persists it, the same way picking an avatar in the UI does.</description></item>+ <item>+ <title>Every pump.fun launch now carries a plain-English receipt</title>+ <link>https://three.ws/launches</link>+ <guid isPermaLink="false">2026-10-14:Every pump.fun launch now carries a plain-English receipt</guid>+ <pubDate>Wed, 14 Oct 2026 12:00:00 GMT</pubDate>+ <category>feature</category>+ <description>/launches/<mint> gained a Launch receipt panel composing five on-chain facts into one readable object: whether the mint or freeze authority can still act (with a plain sentence for each, not just enabled/disabled), supply and decimals, the top-10 holder share, where trading fees route (a creator wallet, a fee-sharing config, cashback, or holder rewards), the creation transaction's version and byte size, and the Trade Safety Firewall's verdict. A coin that never launched through pump.fun gets an honest 'not a pump.fun launch' instead of an error, and a source that fails marks only its own section unavailable, never an invented number. Copy the receipt as text or download it as JSON; both carry a SHA-256 content hash of the response so a saved copy can be checked against a fresh read. A shareable 1200x630 card is available via GET /api/pump/launch-og?mint=<mint>&variant=receipt, and the composition itself is a new public endpoint, GET /api/pump/launch-receipt?mint=<mint>.</description>+ </item><item><title>GitHub fee-claim channel now attributes withdrawals to a coin, or says plainly it cannot</title><link>https://three.ws/changelog</link>diff --git a/public/features.json b/public/features.jsonindex 24d8fdd44..b5dedb993 100644--- a/public/features.json+++ b/public/features.json@@ -1,5 +1,5 @@{- "generated_at": "2026-10-14T17:22:11.527Z",+ "generated_at": "2026-10-14T18:13:33.899Z","generated_by": "scripts/build-page-index.mjs from data/pages.json","site": {"name": "three.ws",diff --git a/src/launch-detail.css b/src/launch-detail.cssindex d9667a3b0..c492eade0 100644--- a/src/launch-detail.css+++ b/src/launch-detail.css@@ -492,6 +492,42 @@ body {.ld-burn-row:hover { color: var(--ink-bright); }.ld-burn-amt { font-family: var(--font-mono); color: var(--ink); }.ld-burn-time { margin-left: auto; }++/* ── Launch receipt ───────────────────────────────────────────────────────── */++.ld-receipt { display: flex; flex-direction: column; gap: var(--space-md); }+.ld-receipt-rows { display: flex; flex-direction: column; gap: var(--space-sm); }+.ld-receipt-row {+ display: grid; grid-template-columns: 148px 1fr auto; align-items: start; gap: var(--space-sm);+ padding-bottom: var(--space-sm); border-bottom: 1px solid var(--surface-3);+}+.ld-receipt-row:last-child { border-bottom: none; padding-bottom: 0; }+.ld-receipt-k { font-size: var(--text-2xs); text-transform: uppercase; letter-spacing: 0.08em; color: var(--ink-dim); padding-top: 2px; }+.ld-receipt-v { font-size: var(--text-sm); color: var(--ink-bright); line-height: 1.5; }+.ld-receipt-row-unavailable .ld-receipt-v { color: var(--ink-faint); }+.ld-receipt-na { font-style: italic; }+.ld-receipt-addr {+ font-family: var(--font-mono); font-size: var(--text-xs); color: var(--ink-dim);+ text-decoration: none; white-space: nowrap; transition: color var(--duration-fast);+}+.ld-receipt-addr:hover { color: var(--ink-bright); }+.ld-receipt-addr:focus-visible { outline: var(--focus-ring-width, 2px) solid var(--focus-ring-color); outline-offset: 2px; border-radius: 3px; }+@media (max-width: 640px) {+ .ld-receipt-row { grid-template-columns: 1fr; gap: var(--space-2xs); }+ .ld-receipt-k { padding-top: 0; }+}+.ld-receipt-foot {+ display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: var(--space-sm);+ padding-top: var(--space-sm); border-top: 1px solid var(--stroke);+}+.ld-receipt-hash { display: flex; align-items: baseline; gap: var(--space-xs); min-width: 0; }+.ld-receipt-hash-k { font-size: var(--text-2xs); text-transform: uppercase; letter-spacing: 0.08em; color: var(--ink-dim); white-space: nowrap; }+.ld-receipt-hash-v {+ font-family: var(--font-mono); font-size: var(--text-2xs); color: var(--ink-dim);+ overflow: hidden; text-overflow: ellipsis; max-width: 220px;+}+.ld-receipt-time { font-size: var(--text-2xs); color: var(--ink-faint); }+.ld-receipt-actions { display: flex; gap: var(--space-sm); }.ld-burn-link { color: var(--ink-faint); }/* ── Agent ────────────────────────────────────────────────────────────────── */diff --git a/src/launch-detail.js b/src/launch-detail.jsindex 2d74f5a1d..d1fc2f9f5 100644--- a/src/launch-detail.js+++ b/src/launch-detail.js@@ -66,6 +66,7 @@ const state = {priceTimer: 0,statsPromise: null, // shared /api/pump/token-stats read (stats + holders panels)statsWindow: '1h', // selected timeframe tab in the stats panel+ receiptPromise: null, // shared /api/pump/launch-receipt read};// The chart-source choice is a viewing preference, not coin-specific: persist it@@ -1310,6 +1311,171 @@ function creatorFeesNote(fees) {]);}+// ════════════════════════════════════════════════════════════════════════════+// LAUNCH RECEIPT: one plain-English object pulled from five on-chain facts+// ════════════════════════════════════════════════════════════════════════════+//+// Everything here already exists elsewhere on the page (authorities in Token+// stats, holders in the Holders panel, fee routing nowhere visible until now,+// the creation transaction never shown at all). The receipt's job is to let a+// trader copy or download one object instead of piecing five panels together,+// with a content hash so a saved copy can be checked against a fresh read.++function loadReceipt() {+ if (!state.receiptPromise) {+ state.receiptPromise = fetchJson(`/api/pump/launch-receipt?mint=${encodeURIComponent(state.mint)}&network=${state.network}`, { timeout: 20000 });+ state.receiptPromise.catch(() => { state.receiptPromise = null; });+ }+ return state.receiptPromise;+}++function receiptToText(r) {+ const lines = [`Launch receipt for ${r.mint} (${r.network})`, `Generated ${new Date(r.generated_at).toLocaleString()}`, ''];+ lines.push(r.authorities.available ? r.authorities.mint_authority.sentence : `Mint authority: unavailable (${r.authorities.reason})`);+ lines.push(r.authorities.available ? r.authorities.freeze_authority.sentence : `Freeze authority: unavailable (${r.authorities.reason})`);+ lines.push(r.supply.available ? `Supply: ${compact(r.supply.formatted)} (${r.supply.decimals} decimals)` : `Supply: unavailable (${r.supply.reason})`);+ lines.push(r.holders.available ? r.holders.sentence : `Holders: unavailable (${r.holders.reason})`);+ lines.push(r.fee_routing.available ? r.fee_routing.sentence : `Fee routing: unavailable (${r.fee_routing.reason})`);+ lines.push(+ r.creation.available+ ? `Creation transaction: ${r.creation.signature} (${r.creation.version_label}, ${r.creation.bytes} bytes)`+ : `Creation transaction: unavailable (${r.creation.reason})`,+ );+ lines.push(r.risk.available ? `Risk flags: ${r.risk.verdict} (score ${r.risk.score})` : `Risk flags: unavailable (${r.risk.reason})`);+ lines.push('', `Content hash (SHA-256): ${r.content_hash}`, 'Verify at https://three.ws/launches/' + r.mint);+ return lines.join('\n');+}++function actionButton(label, onclick, cls = '') {+ const btn = el('button', { class: `ld-btn ld-btn-ghost ${cls}`, type: 'button', text: label, onclick });+ return btn;+}++function copyTextButton(getText, label) {+ return actionButton(label, async (e) => {+ const btn = e.currentTarget;+ const old = btn.textContent;+ try {+ await navigator.clipboard.writeText(getText());+ btn.textContent = 'Copied';+ btn.classList.add('ld-copied');+ } catch {+ btn.textContent = 'Copy failed';+ }+ setTimeout(() => {+ btn.textContent = old;+ btn.classList.remove('ld-copied');+ }, 1600);+ });+}++function downloadJsonButton(getValue, filename, label) {+ return actionButton(label, () => {+ const blob = new Blob([JSON.stringify(getValue(), null, 2)], { type: 'application/json' });+ const url = URL.createObjectURL(blob);+ const a = el('a', { href: url, download: filename });+ document.body.appendChild(a);+ a.click();+ a.remove();+ URL.revokeObjectURL(url);+ });+}++function receiptRow(label, sentence, extra = null) {+ return el('div', { class: 'ld-receipt-row' }, [+ el('span', { class: 'ld-receipt-k', text: label }),+ el('span', { class: 'ld-receipt-v', text: sentence }),+ extra,+ ]);+}++function receiptUnavailable(label, reason) {+ return el('div', { class: 'ld-receipt-row ld-receipt-row-unavailable' }, [+ el('span', { class: 'ld-receipt-k', text: label }),+ el('span', { class: 'ld-receipt-v ld-receipt-na', text: `Unavailable: ${reason}` }),+ ]);+}++function renderReceiptBody(r) {+ const rows = [];++ rows.push(+ r.authorities.available+ ? receiptRow('Mint authority', r.authorities.mint_authority.sentence, r.authorities.mint_authority.address ? el('a', { class: 'ld-receipt-addr', href: `https://solscan.io/account/${r.authorities.mint_authority.address}`, target: '_blank', rel: 'noopener noreferrer', text: shortAddr(r.authorities.mint_authority.address, 4, 4) }) : null)+ : receiptUnavailable('Mint authority', r.authorities.reason),+ );+ rows.push(+ r.authorities.available+ ? receiptRow('Freeze authority', r.authorities.freeze_authority.sentence, r.authorities.freeze_authority.address ? el('a', { class: 'ld-receipt-addr', href: `https://solscan.io/account/${r.authorities.freeze_authority.address}`, target: '_blank', rel: 'noopener noreferrer', text: shortAddr(r.authorities.freeze_authority.address, 4, 4) }) : null)+ : receiptUnavailable('Freeze authority', r.authorities.reason),+ );+ rows.push(+ r.supply.available+ ? receiptRow('Supply', `${compact(r.supply.formatted)} tokens, ${r.supply.decimals} decimals.`)+ : receiptUnavailable('Supply', r.supply.reason),+ );+ rows.push(r.holders.available ? receiptRow('Holders', r.holders.sentence) : receiptUnavailable('Holders', r.holders.reason));+ rows.push(r.fee_routing.available ? receiptRow('Fee routing', r.fee_routing.sentence) : receiptUnavailable('Fee routing', r.fee_routing.reason));+ rows.push(+ r.creation.available+ ? receiptRow(+ 'Creation transaction',+ `${r.creation.version_label}, ${compact(r.creation.bytes)} bytes (${r.creation.utilization_pct != null ? fmtPct(r.creation.utilization_pct, { dp: 0 }) : '-'} of the size limit).`,+ el('a', { class: 'ld-receipt-addr', href: `https://solscan.io/tx/${r.creation.signature}`, target: '_blank', rel: 'noopener noreferrer', text: shortAddr(r.creation.signature, 4, 4) }),+ )+ : receiptUnavailable('Creation transaction', r.creation.reason),+ );+ rows.push(+ r.risk.available+ ? receiptRow('Risk flags', `Trade Safety Firewall verdict: ${r.risk.verdict} (score ${r.risk.score}).`)+ : receiptUnavailable('Risk flags', r.risk.reason),+ );++ return el('div', { class: 'ld-receipt' }, [+ el('div', { class: 'ld-receipt-rows' }, rows),+ el('div', { class: 'ld-receipt-foot' }, [+ el('div', { class: 'ld-receipt-hash', title: 'SHA-256 of this receipt’s canonical JSON' }, [+ el('span', { class: 'ld-receipt-hash-k', text: 'Content hash' }),+ el('code', { class: 'ld-receipt-hash-v', text: r.content_hash }),+ ]),+ el('span', { class: 'ld-receipt-time', text: `Generated ${relTime(r.generated_at)}` }),+ el('div', { class: 'ld-receipt-actions' }, [+ copyTextButton(() => receiptToText(r), 'Copy as text'),+ downloadJsonButton(() => r, `three-ws-launch-receipt-${r.mint}.json`, 'Download JSON'),+ ]),+ ]),+ ]);+}++async function renderReceipt() {+ const target = $('ld-receipt');+ if (!target) return;+ if (state.network !== 'mainnet') {+ target.hidden = true;+ return;+ }+ target.replaceChildren(el('div', { class: 'ld-skel', style: 'height:220px' }));++ let r = null;+ try {+ r = await loadReceipt();+ } catch {+ /* rendered as the error state below */+ }+ if (!r) {+ section(+ target,+ 'Launch receipt',+ el('div', { class: 'ld-empty ld-empty-sm' }, [+ el('p', { text: 'The launch receipt is unavailable right now.' }),+ el('button', { class: 'ld-btn ld-btn-ghost', type: 'button', text: 'Retry', onclick: () => renderReceipt() }),+ ]),+ );+ return;+ }+ section(target, 'Launch receipt', renderReceiptBody(r), { tag: 'live · composed' });+}+// ════════════════════════════════════════════════════════════════════════════// AGENT BEHIND THE COIN// ════════════════════════════════════════════════════════════════════════════@@ -2070,6 +2236,7 @@ async function boot() {renderChart();renderDistribution();renderEconomics();+ renderReceipt();renderAgent();renderTape();renderCommunity();diff --git a/tests/api/pump-launch-receipt.test.js b/tests/api/pump-launch-receipt.test.jsnew file mode 100644index 000000000..363e67c38--- /dev/null+++ b/tests/api/pump-launch-receipt.test.js@@ -0,0 +1,243 @@+// Tests for GET /api/pump/launch-receipt (api/pump/launch-receipt.js).+//+// The receipt composes four independent sources (token-stats, fee-info,+// the trade safety firewall, and a creation-transaction RPC walk). Each+// section is isolated: a source that throws must mark only its own section+// `{ available: false, reason }`, never invent a figure, and never take the+// rest of the receipt down with it. These tests pin that contract plus the+// full-success shape and the content_hash's stability.++import { describe, it, expect, vi, beforeEach } from 'vitest';++const state = {+ stats: null,+ statsErr: null,+ feeInfo: null,+ feeErr: null,+ assessment: null,+ assessErr: null,+ sigPages: [],+ txResult: null,+};++vi.mock('../../api/pump/token-stats.js', () => ({+ buildStats: vi.fn(async () => {+ if (state.statsErr) throw state.statsErr;+ return state.stats;+ }),+}));++vi.mock('../../api/pump/[action].js', () => ({+ computeFeeInfo: vi.fn(async () => {+ if (state.feeErr) throw state.feeErr;+ return state.feeInfo;+ }),+}));++vi.mock('../../api/_lib/trade-firewall.js', () => ({+ assessTradeSafety: vi.fn(async () => {+ if (state.assessErr) throw state.assessErr;+ return state.assessment;+ }),+}));++vi.mock('../../api/_lib/pump.js', () => ({+ getConnection: vi.fn(() => ({+ _rpcRequest: vi.fn(async (method) => {+ if (method === 'getSignaturesForAddress') {+ const page = state.sigPages.shift() ?? [];+ return { result: page };+ }+ if (method === 'getTransaction') {+ if (state.txResult === 'error') return { error: { message: 'tatum gateway rejected the request' } };+ return { result: state.txResult };+ }+ throw new Error(`unexpected rpc method ${method}`);+ }),+ })),+}));++const { buildReceipt } = await import('../../api/pump/launch-receipt.js');++const MINT = 'FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump';++const FULL_STATS = {+ authorities: {+ mint_authority: null,+ freeze_authority: null,+ decimals: 6,+ supply: '1000000000000000',+ },+ holders: {+ count: 15,+ top10_pct: 0.25,+ },+};++const FULL_FEE_INFO = {+ fee_destination: 'CreatorVault111',+ creator: 'Creator111',+ is_graduated: true,+ claimable_sol: 1.23,+ sharing_config: null,+ is_cashback_coin: false,+ is_holder_reward: false,+ has_sharing_config: false,+};++const FULL_ASSESSMENT = {+ verdict: 'ok',+ score: 92,+ reasons: [],+ checks: [{ name: 'authority', status: 'pass' }],+};++// A real base64-encoded legacy wire transaction: 1 byte version marker-free+// (legacy format has no version prefix), signature, message header, two+// account keys, a blockhash, zero instructions. Built once rather than+// pulled off-chain so the test stays offline.+function buildLegacyTxBase64() {+ const sig = Buffer.alloc(64, 1);+ const header = Buffer.from([1, 1, 0]); // numRequiredSignatures, numReadonlySigned, numReadonlyUnsigned+ const keys = Buffer.concat([Buffer.from([2]), Buffer.alloc(32, 2), Buffer.alloc(32, 3)]);+ const blockhash = Buffer.alloc(32, 4);+ const instructions = Buffer.from([0]);+ const message = Buffer.concat([header, keys, blockhash, instructions]);+ const tx = Buffer.concat([Buffer.from([1]), sig, message]);+ return tx.toString('base64');+}++const LEGACY_TX_B64 = buildLegacyTxBase64();++function resetState() {+ state.stats = FULL_STATS;+ state.statsErr = null;+ state.feeInfo = FULL_FEE_INFO;+ state.feeErr = null;+ state.assessment = FULL_ASSESSMENT;+ state.assessErr = null;+ state.sigPages = [[{ signature: 'CREATE_SIG' }]];+ state.txResult = {+ slot: 100,+ blockTime: 1_700_000_000,+ transaction: [LEGACY_TX_B64],+ };+}++beforeEach(() => {+ resetState();+});++describe('buildReceipt: full success', () => {+ it('composes every section from its real source with no invented data', async () => {+ const r = await buildReceipt(MINT, 'mainnet');++ expect(r.mint).toBe(MINT);+ expect(r.network).toBe('mainnet');++ expect(r.authorities.mint_authority.enabled).toBe(false);+ expect(r.authorities.mint_authority.sentence).toMatch(/fixed/);+ expect(r.authorities.freeze_authority.enabled).toBe(false);++ expect(r.supply).toMatchObject({ available: true, raw: '1000000000000000', decimals: 6 });+ expect(r.supply.formatted).toBeCloseTo(1_000_000_000);++ expect(r.holders).toMatchObject({ available: true, top10_pct: 0.25, holder_count: 15 });+ expect(r.holders.sentence).toMatch(/25\.00%/);++ expect(r.fee_routing).toMatchObject({ available: true, applicable: true, destination: 'CreatorVault111' });+ expect(r.fee_routing.sentence).toMatch(/creator wallet/);++ expect(r.creation).toMatchObject({ available: true, signature: 'CREATE_SIG', slot: 100 });+ expect(r.creation.version_label).toBeTruthy();++ expect(r.risk).toMatchObject({ available: true, verdict: 'ok', score: 92 });++ expect(typeof r.generated_at).toBe('string');+ expect(r.content_hash).toMatch(/^[0-9a-f]{64}$/);+ });++ it('produces a stable content_hash for identical inputs, holding generated_at fixed', async () => {+ vi.useFakeTimers();+ vi.setSystemTime(new Date('2026-10-14T00:00:00Z'));+ const a = await buildReceipt(MINT, 'mainnet');+ state.sigPages = [[{ signature: 'CREATE_SIG' }]];+ const b = await buildReceipt(MINT, 'mainnet');+ vi.useRealTimers();+ expect(a.content_hash).toBe(b.content_hash);+ });+});++describe('buildReceipt: per-section degradation', () => {+ it('marks only authorities/supply/holders unavailable when token-stats throws', async () => {+ state.statsErr = new Error('postgres pool exhausted');+ const r = await buildReceipt(MINT, 'mainnet');++ expect(r.authorities).toEqual({ available: false, reason: 'could not read the mint account from chain' });+ expect(r.supply).toEqual({ available: false, reason: 'could not read supply and decimals from the mint account' });+ expect(r.holders.available).toBe(false);++ // Unrelated sections still carry real data, not a fabricated stand-in.+ expect(r.fee_routing.available).toBe(true);+ expect(r.risk.available).toBe(true);+ expect(r.creation.available).toBe(true);+ });++ it('marks fee_routing unavailable (not a fake destination) when fee-info throws', async () => {+ state.feeErr = new Error('pump sdk rpc timeout');+ const r = await buildReceipt(MINT, 'mainnet');++ expect(r.fee_routing).toEqual({ available: false, reason: 'pump sdk rpc timeout' });+ expect(r.authorities.available).toBe(true);+ expect(r.risk.available).toBe(true);+ });++ it('reports fee_routing as not applicable (not unavailable) for a non-pump.fun mint', async () => {+ state.feeInfo = null;+ const r = await buildReceipt(MINT, 'mainnet');++ expect(r.fee_routing).toMatchObject({ available: true, applicable: false });+ expect(r.fee_routing.sentence).toMatch(/did not launch through pump\.fun/);+ });++ it('marks risk unavailable when the trade safety firewall throws', async () => {+ state.assessErr = new Error('firewall simulation RPC failed');+ const r = await buildReceipt(MINT, 'mainnet');++ expect(r.risk).toEqual({ available: false, reason: 'firewall simulation RPC failed' });+ expect(r.authorities.available).toBe(true);+ expect(r.fee_routing.available).toBe(true);+ });++ it('marks creation unavailable without a signature when the mint has no history', async () => {+ state.sigPages = [[]];+ const r = await buildReceipt(MINT, 'mainnet');++ expect(r.creation).toEqual({ available: false, reason: 'this mint has no transaction history on this RPC' });+ });++ it('marks creation unavailable when the RPC rejects getTransaction, surfacing the real reason', async () => {+ state.txResult = 'error';+ const r = await buildReceipt(MINT, 'mainnet');++ expect(r.creation.available).toBe(false);+ expect(r.creation.reason).toMatch(/tatum gateway rejected/);+ });++ it('never throws even when every source fails at once', async () => {+ state.statsErr = new Error('db down');+ state.feeErr = new Error('rpc down');+ state.assessErr = new Error('firewall down');+ state.sigPages = [[]];++ const r = await buildReceipt(MINT, 'mainnet');++ expect(r.authorities.available).toBe(false);+ expect(r.supply.available).toBe(false);+ expect(r.holders.available).toBe(false);+ expect(r.fee_routing.available).toBe(false);+ expect(r.risk.available).toBe(false);+ expect(r.creation.available).toBe(false);+ expect(r.content_hash).toMatch(/^[0-9a-f]{64}$/);+ });+});diff --git a/vercel.json b/vercel.jsonindex d860a0ee8..91a91f55d 100644--- a/vercel.json+++ b/vercel.json@@ -4051,6 +4051,10 @@"src": "/api/pump/token-stats","dest": "/api/pump/token-stats.js"},+ {+ "src": "/api/pump/launch-receipt",+ "dest": "/api/pump/launch-receipt.js"+ },{"src": "/api/pump/check-three-balance","dest": "/api/pump/check-three-balance.js"