How Solary works, in code

73/** The launch as one or two unsigned transactions. Exported shape for tests and the devnet/mainnet dry run. */74async build(input: SolanaLaunchInput, deployer: PublicKey): Promise<{ txs: VersionedTransaction[]; oneTransaction: boolean; blockhash: string; lastValidBlockHeight: number }> {75  if (!SOLARY_VAULT_OK) throw new SolanaLaunchError('config', 'the Solary vault address is not set on this site yet');76  const mint = new PublicKey(input.mint);77  const cfg = pumpPda.sharingConfig(mint);78  const price = ComputeBudgetProgram.setComputeUnitPrice({ microLamports: SOL_PRIORITY_MICRO_LAMPORTS });79  const create = createV2Ix({ mint, user: deployer, creator: deployer, name: input.name, symbol: input.symbol, uri: input.metadataUri });80  const config = createFeeSharingConfigIx({ mint, creator: deployer });81  const shares = updateFeeSharesIx({ mint, authority: deployer, currentShareholders: [deployer], shareholders: launchShareholders(input.holdersBps, deployer) });82  const buy = input.initialBuyLamports > 0n ? buyExactSolInIxs({ mint, user: deployer, creator: cfg, lamports: input.initialBuyLamports }) : [];83  const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash('confirmed');84  const compile = (ixs: TransactionInstruction[], alts: AddressLookupTableAccount[] = []) =>85    new VersionedTransaction(new TransactionMessage({ payerKey: deployer, recentBlockhash: blockhash, instructions: ixs }).compileToV0Message(alts));86 87  const lut = await this.lookupTable();88  if (lut) {89    const one = compile([ComputeBudgetProgram.setComputeUnitLimit({ units: buy.length ? 640_000 : 480_000 }), price, create, config, shares, ...buy], [lut]);90    if (sizeOf(one) <= MAX_TX_BYTES) return { txs: [one], oneTransaction: true, blockhash, lastValidBlockHeight };91  }92  // create + config measured at 180–220k CU on mainnet (varies with PDA bumps): keep a wide margin93  const first = compile([ComputeBudgetProgram.setComputeUnitLimit({ units: 320_000 }), price, create, config]);94  const second = compile([ComputeBudgetProgram.setComputeUnitLimit({ units: buy.length ? 320_000 : 160_000 }), price, shares, ...buy]);95  if (sizeOf(first) > MAX_TX_BYTES || sizeOf(second) > MAX_TX_BYTES) {96    throw new SolanaLaunchError('too-large', 'the launch transaction is too large: shorten the name or the ticker');97  }98  return { txs: [first, second], oneTransaction: false, blockhash, lastValidBlockHeight };99}

42/** The locked split's shareholders for this deployer, as web3.js keys. */43export function launchShareholders(holdersBps: number, deployer: PublicKey): Array<{ address: PublicKey; bps: number }> {44  return sharingShareholders(feeSplit(holdersBps), SOLARY_VAULT, deployer.toBase58()).map((s) => ({ address: new PublicKey(s.address), bps: s.bps }));45}

270/** update_fee_shares(shareholders: Vec<{address, share_bps u16}>). */271export function updateFeeSharesData(shareholders: ReadonlyArray<{ address: string; bps: number }>): Uint8Array {272  const len = new Uint8Array(4);273  new DataView(len.buffer).setUint32(0, shareholders.length, true);274  const items = shareholders.map((s) => {275    const b = new Uint8Array(34);276    b.set(base58Decode(s.address), 0);277    new DataView(b.buffer).setUint16(32, s.bps, true);278    return b;279  });280  return concat([PUMP_IX.updateFeeShares, len, ...items]);281}

197/** The reward split can no longer change (pump's one-time policy: every v1 config, or v2 with the admin revoked). */198export function sharingConfigLocked(c: PumpSharingConfig): boolean {199  return c.version === 1 || c.adminRevoked;200}

74/** The exact text the wallet signs (UTF-8). `collectionName` is display only and not part of the JSON. */75export function launchRecordText(r: LaunchRecord, collectionName?: string): string {76  const s = feeSplit(r.holdersBps);77  const parts = [`${bpsToPct(s.holdersBps)} to NFT holders by rarity`];78  if (s.creatorBps > 0) parts.push(`${bpsToPct(s.creatorBps)} to the creator`);79  parts.push(`${bpsToPct(s.buybackBps)} buys and burns $SOLARY`, `${bpsToPct(s.platformBps)} to Solary`);80  return [81    'Solary launch record (pump.fun)',82    `Coin: ${r.name} ($${r.symbol})`,83    `Mint: ${r.mint}`,84    `Collection: ${collectionName ? `${collectionName} ` : ''}${r.collection}`,85    `Creator fees: ${parts.join(', ')}`,86    `Deployer: ${r.deployer}`,87    '',88    launchRecordJson(r),89  ].join('\n');90}

43/** The chain agrees with the record: see the file comment. `409` means "not visible yet, retry". */44export async function checkSolanaLaunch(a: {45  mint: string;46  tx: string;47  deployer: string;48  vault: string;49  holdersBps: number;50  name: string;51  symbol: string;52  metadataUri?: string;53}): Promise<LaunchCheck> {54  type TxRes = { meta: { err: unknown } | null; transaction: { message: { accountKeys: string[] } } } | null;55  const t = await rpc<TxRes>('getTransaction', [a.tx, { encoding: 'json', commitment: 'confirmed', maxSupportedTransactionVersion: 0 }]);56  if (!t) return { ok: false, status: 409, error: 'launch transaction not found yet; retry in a few seconds' };57  if (!t.meta || t.meta.err) return { ok: false, status: 400, error: 'launch transaction failed on-chain' };58  const keys = t.transaction.message.accountKeys;59  if (keys[0] !== a.deployer) return { ok: false, status: 400, error: 'launch transaction was paid by a different wallet' };60  if (!keys.includes(a.mint)) return { ok: false, status: 400, error: 'launch transaction does not touch this mint' };61 62  const mint = new PublicKey(a.mint);63  const cfg = pumpPda.sharingConfig(mint);64  const res = await rpc<{ value: Array<{ data: [string, string] } | null> }>('getMultipleAccounts', [65    [pumpPda.bondingCurve(mint).toBase58(), cfg.toBase58(), a.mint],66    { encoding: 'base64', commitment: 'confirmed' },67  ]);68  const [bcA, cfgA, mintA] = res.value;69  if (!bcA || !mintA) return { ok: false, status: 409, error: 'coin not visible yet; retry in a few seconds' };70  const bytes = (x: { data: [string, string] }) => new Uint8Array(Buffer.from(x.data[0], 'base64'));71  const bc = decodeBondingCurve(bytes(bcA));72  // a two-transaction launch sets the split in its second transaction73  if (!cfgA || bc.creator !== cfg.toBase58()) return { ok: false, status: 409, error: "the coin's fee split is not set yet; finish the launch" };74  const sc = decodeSharingConfig(bytes(cfgA));75  const expected = sharingShareholders(feeSplit(a.holdersBps), a.vault, a.deployer);76  if (!sameShareholders(sc.shareholders, expected)) {77    // editable and still pointing at the deployer: the split transaction has not landed yet78    if (!sharingConfigLocked(sc)) return { ok: false, status: 409, error: "the coin's fee split is not set yet; finish the launch" };79    return { ok: false, status: 400, error: "the coin's fee split does not match the signed record" };80  }81  if (!sharingConfigLocked(sc)) return { ok: false, status: 400, error: "the coin's fee split is not locked" };82  const md = decodeToken2022Metadata(bytes(mintA));83  if (md) {84    if (md.name.trim() !== a.name || md.symbol.trim().toUpperCase() !== a.symbol) return { ok: false, status: 400, error: 'name or ticker differ from the coin on-chain' };85    if (a.metadataUri && md.uri.trim() !== a.metadataUri) return { ok: false, status: 400, error: 'metadata address differs from the coin on-chain' };86  }87  return { ok: true };88}

12export const FEE_RULES = {13  /** fixed: the platform's cut of every coin's creator fees */14  platformBps: 1_000,15  /** fixed: buys $SOLARY on the market and burns it */16  buybackBps: 1_000,17  /** the creator picks the NFT holders' share between these (inclusive), in steps */18  holdersMinBps: 5_000,19  holdersMaxBps: 8_000,20  holdersStepBps: 500,21  holdersDefaultBps: 7_000,22} as const;

31/** The whole split for a chosen holders' share. The creator keeps whatever the holders and fixed cuts leave. */32export function feeSplit(holdersBps: number = FEE_RULES.holdersDefaultBps): FeeSplit {33  const creatorBps = BPS - holdersBps - FEE_RULES.buybackBps - FEE_RULES.platformBps;34  return { holdersBps, creatorBps, buybackBps: FEE_RULES.buybackBps, platformBps: FEE_RULES.platformBps };35}

53/** The pump.fun fee-sharing shareholders for a split: the vault first (the keeper's scan matches on it), then the creator. */54export function sharingShareholders(split: FeeSplit, vault: string, creator: string): Array<{ address: string; bps: number }> {55  const vaultBps = BPS - split.creatorBps;56  const out = [{ address: vault, bps: vaultBps }];57  if (split.creatorBps > 0) out.push({ address: creator, bps: split.creatorBps });58  return out;59}

70/**71 * Split lamports that reached the Solary vault for one coin. Integer math, rounded down per bucket; the rounding72 * remainder goes to the holders so nothing is lost.73 */74export function splitVaultAmount(lamports: bigint, split: FeeSplit): VaultSplit {75  const vb = BigInt(vaultBps(split));76  if (vb === 0n || lamports <= 0n) return { holders: 0n, buyback: 0n, platform: 0n };77  const buyback = (lamports * BigInt(split.buybackBps)) / vb;78  const platform = (lamports * BigInt(split.platformBps)) / vb;79  return { holders: lamports - buyback - platform, buyback, platform };80}

17/** Best first. The last tier holds everything the others don't. */18export const TIERS: readonly TierInfo[] = [19  { tier: 'flare', label: 'Flare', topPct: 0.01, multiplier: 5 },20  { tier: 'blaze', label: 'Blaze', topPct: 0.05, multiplier: 3 },21  { tier: 'glow', label: 'Glow', topPct: 0.2, multiplier: 2 },22  { tier: 'ray', label: 'Ray', topPct: 1, multiplier: 1 },23] as const;

65export function rankRarity(nfts: readonly NftForRarity[]): RarityResult {66  const n = nfts.length;67  if (n === 0) return { items: [], flat: true, traitTypes: [], totalWeight: 0 };68 69  const withTraits = nfts.filter((x) => x.attributes.some((a) => a.value !== null && String(a.value).trim() !== '')).length;70  const flat = withTraits * 2 < n;71 72  // value per (item, trait type); a missing trait counts as its own value ("None")73  const types = new Map<string, string>(); // normalized → first display name74  const values: Array<Map<string, string>> = nfts.map((x) => {75    const m = new Map<string, string>();76    for (const a of x.attributes) {77      if (!a.trait_type || a.value === null || String(a.value).trim() === '') continue;78      const t = norm(a.trait_type);79      if (!types.has(t)) types.set(t, a.trait_type.trim());80      m.set(t, norm(String(a.value)));81    }82    return m;83  });84 85  const counted: string[] = [];86  const freq = new Map<string, Map<string, number>>();87  for (const t of [...types.keys()].sort()) {88    const f = new Map<string, number>();89    for (const m of values) {90      const v = m.get(t) ?? NONE;91      f.set(v, (f.get(v) ?? 0) + 1);92    }93    if (f.size <= 1) continue; // every NFT has the same value: says nothing about rarity94    if (f.size >= n * UNIQUE_SKIP_RATIO && n >= 20) continue; // a serial number, not a trait95    freq.set(t, f);96    counted.push(types.get(t)!);97  }98  // trait count is a trait too99  const countFreq = new Map<number, number>();100  for (const m of values) countFreq.set(m.size, (countFreq.get(m.size) ?? 0) + 1);101 102  const scored = nfts.map((x, i) => {103    if (flat) return { id: x.id, score: 0 };104    const m = values[i]!;105    let score = 0;106    for (const [t, f] of freq) score += n / f.get(m.get(t) ?? NONE)!;107    if (countFreq.size > 1) score += n / countFreq.get(m.size)!;108    return { id: x.id, score };109  });110  // rarest first; ties broken by address so the order is total and reproducible111  scored.sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));112 113  const cut = (pct: number) => Math.floor(n * pct);114  const flareCut = Math.max(1, cut(TIERS[0]!.topPct));115  const blazeCut = Math.max(flareCut, cut(TIERS[1]!.topPct));116  const glowCut = Math.max(blazeCut, cut(TIERS[2]!.topPct));117 118  let totalWeight = 0;119  const items: RankedNft[] = scored.map((s, i) => {120    const rank = i + 1;121    const tier: Tier = flat ? 'ray' : rank <= flareCut ? 'flare' : rank <= blazeCut ? 'blaze' : rank <= glowCut ? 'glow' : 'ray';122    const multiplier = tierMultiplier(tier);123    totalWeight += multiplier;124    return { id: s.id, score: Math.round(s.score * 1000) / 1000, rank, tier, multiplier };125  });126  return { items, flat, traitTypes: counted, totalWeight };127}

148// rarity over every NFT HowRare knows149const ranked = rankRarity(hr.items.map((i) => ({ id: i.mint, attributes: i.attributes })));150const byId = new Map(ranked.items.map((r) => [r.id, r]));151const rarityHash = createHash('sha256')152  .update(ranked.items.map((r) => `${r.id}:${r.rank}:${r.tier}`).join('\n'))153  .digest('hex');

40async function refreshTotals(ctx: Pick<JobCtx, 'db'>, collection: string): Promise<void> {41  await ctx.db.execute(sql`42    UPDATE collections SET43      total_shares = COALESCE((SELECT SUM(multiplier) FROM nfts WHERE collection = ${collection} AND NOT burnt), 0),44      owners = GREATEST((SELECT COUNT(DISTINCT owner) FROM nfts WHERE collection = ${collection} AND owner IS NOT NULL AND NOT burnt), owners),45      owners_at = now()46    WHERE address = ${collection}`);47}

1// Holder rewards: how a coin's holder share becomes lamports owed to each NFT, and when a payout goes out.2//3// Rewards follow the NFT, not the wallet. Each coin keeps one running index: lamports per reward share, scaled by4// ACC_SCALE. A fee claim of P lamports for holders raises the index by P / (Σ shares of live NFTs). An NFT is owed5//   shares × (index − index at its last payout)6// and whoever owns the NFT when a payout runs receives it. O(1) per claim, exact to the lamport: the rounding dust of7// each claim is carried into the next one, never lost.8 9export const ACC_SCALE = 10n ** 18n;

11/** Raise a coin's index by `lamports` spread over `totalShares`. `dust` stays with the coin for the next claim. */12export function accrue(lamports: bigint, totalShares: bigint): { delta: bigint; distributed: bigint; dust: bigint } {13  if (lamports <= 0n || totalShares <= 0n) return { delta: 0n, distributed: 0n, dust: lamports > 0n ? lamports : 0n };14  const delta = (lamports * ACC_SCALE) / totalShares;15  const distributed = (delta * totalShares) / ACC_SCALE;16  return { delta, distributed, dust: lamports - distributed };17}

19/** Lamports an NFT is owed for one coin. */20export function owed(shares: number | bigint, index: bigint, settled: bigint): bigint {21  const d = index - settled;22  return d > 0n ? (BigInt(shares) * d) / ACC_SCALE : 0n;23}

30/** Pure: how one claim moves a coin's ledger. */31export function planFeeClaim(i: { lamports: bigint; creatorLamports?: bigint; split: FeeSplit; dust: bigint; totalShares: number }): FeeClaimPlan {32  const s = splitVaultAmount(i.lamports, i.split);33  const shares = Math.max(0, Math.floor(i.totalShares));34  const a = accrue(s.holders + i.dust, BigInt(shares));35  return {36    lamports: i.lamports,37    creatorLamports: i.creatorLamports ?? 0n,38    holders: s.holders,39    buyback: s.buyback,40    platform: s.platform,41    shares,42    delta: a.delta,43    distributed: a.distributed,44    dust: a.dust,45  };46}

69/** Record one claim exactly once. Returns null when (tx, coin) was already recorded or the coin is unknown. */70export async function recordFeeClaim(db: Db, c: RecordFeeClaimInput): Promise<RecordedFeeClaim | null> {71  return db.transaction(async (t) => {72    const [coin] = await t73      .select({74        symbol: coins.symbol,75        collection: coins.collection,76        holdersBps: coins.holdersBps,77        creatorBps: coins.creatorBps,78        buybackBps: coins.buybackBps,79        platformBps: coins.platformBps,80        accIndex: coins.accIndex,81        dust: coins.dustLamports,82      })83      .from(coins)84      .where(eq(coins.mint, c.coin))85      .for('update');86    if (!coin) return null;87    let totalShares = 0;88    if (coin.collection) {89      const [col] = await t.select({ s: collections.totalShares }).from(collections).where(eq(collections.address, coin.collection));90      totalShares = col?.s ?? 0;91    }92    const plan = planFeeClaim({93      lamports: c.lamports,94      creatorLamports: c.creatorLamports,95      split: { holdersBps: coin.holdersBps, creatorBps: coin.creatorBps, buybackBps: coin.buybackBps, platformBps: coin.platformBps },96      dust: coin.dust,97      totalShares,98    });99    const usdCents = c.solUsd ? lamportsToCents(c.lamports + c.creatorLamports, c.solUsd) : 0;100    const holdersUsdCents = c.solUsd ? lamportsToCents(plan.holders, c.solUsd) : 0;101    const [row] = await t102      .insert(feeClaims)103      .values({104        coin: c.coin,105        tx: c.tx,106        lamports: c.lamports,107        creatorLamports: c.creatorLamports,108        holdersLamports: plan.holders,109        buybackLamports: plan.buyback,110        platformLamports: plan.platform,111        shares: plan.shares,112        indexDelta: plan.delta.toString(),113        solUsd: c.solUsd,114        usdCents,115        createdAt: c.at,116      })117      .onConflictDoNothing({ target: [feeClaims.tx, feeClaims.coin] })118      .returning({ id: feeClaims.id });119    if (c.intentId) await t.update(intents).set({ status: 'confirmed', updatedAt: new Date() }).where(eq(intents.id, c.intentId));120    if (!row) return null;121    await t122      .update(coins)123      .set({124        accIndex: (BigInt(coin.accIndex) + plan.delta).toString(),125        dustLamports: plan.dust,126        feesLamports: sql`${coins.feesLamports} + ${(c.lamports + c.creatorLamports).toString()}::bigint`,127        holdersLamports: sql`${coins.holdersLamports} + ${plan.holders.toString()}::bigint`,128        creatorLamports: sql`${coins.creatorLamports} + ${c.creatorLamports.toString()}::bigint`,129        buybackLamports: sql`${coins.buybackLamports} + ${plan.buyback.toString()}::bigint`,130        platformLamports: sql`${coins.platformLamports} + ${plan.platform.toString()}::bigint`,131        feesUsdCents: sql`${coins.feesUsdCents} + ${usdCents}`,132        holdersUsdCents: sql`${coins.holdersUsdCents} + ${holdersUsdCents}`,133        lastClaimAt: sql`GREATEST(${coins.lastClaimAt}, ${c.at.toISOString()}::timestamptz)`,134      })135      .where(eq(coins.mint, c.coin));136    return { ...plan, id: row.id, coin: c.coin, symbol: coin.symbol, collection: coin.collection, usdCents, holdersUsdCents };137  });138}

31/** Pure: what each wallet is owed for one coin at `index`. Burnt, ownerless, program-owned and excluded NFTs wait. */32export function owedLines(rows: readonly NftOwedRow[], index: bigint, exclude: ReadonlySet<string> = new Set()): OwedLine[] {33  const by = new Map<string, OwedLine>();34  for (const r of rows) {35    if (r.burnt || !r.owner || !r.ownerIsWallet || exclude.has(r.id)) continue;36    const o = owed(r.multiplier, index, r.settledIndex);37    if (o <= 0n) continue;38    const line = by.get(r.owner) ?? { owner: r.owner, gross: 0n, items: [] };39    line.gross += o;40    line.items.push([r.id, o]);41    by.set(r.owner, line);42  }43  return [...by.values()];44}

251/** A wallet (on the ed25519 curve) rather than a program address (escrow, pool, PDA). */252export function isWalletAddress(address: string): boolean {253  try {254    return isOnCurve(pk(address));255  } catch {256    return false;257  }258}

27/** SOL transfers per payout transaction (legacy message, ~50 bytes per recipient, well under 1232 bytes). */28export const TRANSFERS_PER_TX = 18;29/** Base fee per signature. */30export const BASE_FEE_LAMPORTS = 5_000;31/** Compute units a payout transaction asks for: 18 transfers at ~150 CU each plus the compute-budget instructions. */32export const PAYOUT_TX_CU = 5_000;33/** Rent-exempt minimum of an empty wallet: a transfer that would leave a new wallet below it fails. */34export const RENT_EXEMPT_WALLET = 890_880;35/** Holders keep at least this share of an automatic payout after gas (the rest pays the transactions). */36export const AUTO_PAYOUT_KEEP_BPS = 9_000;

87/**88 * Turn owed lines into transfers. Gas is shared equally by the paid wallets (rounded up so the vault never runs89 * short). A line is skipped (it stays owed on the NFTs) when its net would be under `minNet`, or when the wallet90 * doesn't exist yet and the transfer can't make it rent-exempt.91 */92export function planTransfers(93  lines: readonly PayoutLine[],94  opts: { priorityMicroLamports?: number; minNetLamports?: bigint; walletExists?: (owner: string) => boolean } = {},95): { transfers: PlannedTransfer[]; skipped: PayoutLine[]; gas: bigint } {96  let paid = [...lines].filter((l) => l.gross > 0n).sort((a, b) => (a.gross > b.gross ? -1 : a.gross < b.gross ? 1 : a.owner < b.owner ? -1 : 1));97  const skipped: PayoutLine[] = [];98  // shrink until stable: dropping a line lowers the transaction count, which can only lower everyone's gas share99  for (;;) {100    const gas = payoutGasLamports(paid.length, opts.priorityMicroLamports);101    const each = paid.length ? (gas + BigInt(paid.length) - 1n) / BigInt(paid.length) : 0n;102    const keep: PayoutLine[] = [];103    let dropped = false;104    for (const l of paid) {105      const net = l.gross - each;106      const tooSmall = net < (opts.minNetLamports ?? 1n);107      const cantOpen = opts.walletExists && !opts.walletExists(l.owner) && net < BigInt(RENT_EXEMPT_WALLET);108      if (tooSmall || cantOpen) {109        skipped.push(l);110        dropped = true;111      } else keep.push(l);112    }113    paid = keep;114    if (!dropped) {115      return { transfers: paid.map((l) => ({ owner: l.owner, gross: l.gross, gas: each, net: l.gross - each })), skipped, gas: each * BigInt(paid.length) };116    }117  }118}

61/**62 * Should a coin's automatic payout go out? Holders must keep at least 90% after gas, and the batch must reach63 * `minLamports` (so wallets aren't sprayed with dust every few minutes).64 */65export function autoPayoutState(pending: bigint, recipients: number, opts: { priorityMicroLamports?: number; minLamports?: bigint } = {}): AutoPayoutState {66  const gas = payoutGasLamports(recipients, opts.priorityMicroLamports);67  const keepFloor = (gas * 10_000n) / BigInt(10_000 - AUTO_PAYOUT_KEEP_BPS);68  const threshold = keepFloor > (opts.minLamports ?? 0n) ? keepFloor : (opts.minLamports ?? 0n);69  const progress = threshold > 0n ? Math.min(1, Number((pending * 10_000n) / threshold) / 10_000) : pending > 0n ? 1 : 0;70  return { pending, recipients, gas, threshold, progress, ready: recipients > 0 && pending >= threshold && pending > gas };71}

95/** Pure: should a coin's automatic run go out now? (holders keep ≥ 90% after gas, the floor, the interval) */96export function autoDecision(plan: RunPlan, o: AutoOpts): { ready: boolean; reason: string; state: AutoPayoutState } {97  const state = autoPayoutState(plan.gross, plan.transfers.length, { priorityMicroLamports: o.priorityMicroLamports, minLamports: o.minLamports });98  const since = o.lastPayoutAt ? (o.now - o.lastPayoutAt.getTime()) / 1000 : Infinity;99  if (plan.transfers.length === 0) return { ready: false, reason: 'no wallet is owed enough yet', state };100  if (since < o.minIntervalS) return { ready: false, reason: `last payout ${Math.round(since)}s ago (minimum ${o.minIntervalS}s)`, state };101  if (!state.ready) return { ready: false, reason: `pending ${plan.gross} of ${state.threshold} lamports`, state };102  // planTransfers already shares gas; this is the SPEC's 90%-after-gas rule stated once more for the record103  if (plan.net * 10_000n < plan.gross * BigInt(AUTO_PAYOUT_KEEP_BPS)) return { ready: false, reason: 'gas would take more than 10%', state };104  return { ready: true, reason: 'ready', state };105}

238const minLamports = await settingBig(ctx, 'payout.min_lamports', 10_000_000n);239const minIntervalS = await settingNum(ctx, 'payout.min_interval_s', ctx.env.fast ? 60 : 3600);240const autoMinNet = await settingBig(ctx, 'payout.auto_min_net_lamports', 1_000_000n);241let runs = 0;242let would = 0;243let notReady = 0;244let refused = 0;245// alert coins (fees stopped reaching the vault) still pay out what their holders already earned; paused ones wait246const list = [...p.coins.values()].filter((c) => c.status !== 'paused' && c.collection && c.collectionStatus === 'listed' && c.holdersBps > 0);247// longest-waiting first248list.sort((a, b) => (a.lastPayoutAt?.getTime() ?? 0) - (b.lastPayoutAt?.getTime() ?? 0));

227const [open] = rowsOf<{ g: string | null }>(228  await t.execute(sql`SELECT SUM(gross_lamports)::text AS g FROM payout_transfers WHERE coin = ${r.coin} AND status IN ('built', 'sent')`),229);230const inflight = BigInt(open?.g ?? '0');231if (c.paid + inflight + gross > c.holders) {232  throw new ConservationError(`run for ${r.coin} would pay ${c.paid + inflight + gross} of ${c.holders} lamports ever received for holders`);233}

372// settlements, aggregated per (coin, nft)373const settle = new Map<string, { coin: string; nft: string; index: bigint; lamports: bigint }>();374for (const r of rows) {375  const index = BigInt(runIndex.get(r.run)!);376  for (const [nft, l] of r.items) {377    const k = `${r.coin}:${nft}`;378    const s = settle.get(k) ?? { coin: r.coin, nft, index: 0n, lamports: 0n };379    s.index = index > s.index ? index : s.index;380    s.lamports += BigInt(l);381    settle.set(k, s);382  }383}384const list = [...settle.values()];385for (let i = 0; i < list.length; i += 5000) {386  // one JSON parameter instead of five per row: a wallet with hundreds of NFTs settles them all at once387  const rows = JSON.stringify(list.slice(i, i + 5000).map((s) => ({ c: s.coin, n: s.nft, i: s.index.toString(), l: s.lamports.toString() })));388  await t.execute(sql`389    INSERT INTO nft_settlements (coin, nft, settled_index, paid_lamports, updated_at)390    SELECT x.c, x.n, x.i::numeric, x.l::bigint, ${at.toISOString()}::timestamptz FROM jsonb_to_recordset(${rows}::jsonb) AS x(c text, n text, i text, l text)391    ON CONFLICT (coin, nft) DO UPDATE SET392      settled_index = GREATEST(nft_settlements.settled_index, excluded.settled_index),393      paid_lamports = nft_settlements.paid_lamports + excluded.paid_lamports,394      updated_at = excluded.updated_at`);395}

1// The exact text a holder signs to ask for an immediate payout (SPEC §3). Shared by the page and /api/claims.2export const claimMessage = (wallet: string, nonce: string): string => `Solary claim\nWallet: ${wallet}\nNonce: ${nonce}`;

25/**26 * Ask for an immediate payout. Body: { wallet, nonce, signature } where signature is the base58 ed25519 signature27 * of `Solary claim\nWallet: <wallet>\nNonce: <nonce>` by the wallet itself. The keeper pays everything the wallet's28 * NFTs are owed, across coins, on its next pass. One queued request per wallet.29 */30export async function POST(req: Request) {31  if (!rateLimit(`claims:${clientIp(req)}`, 10, 60_000)) return error(429, 'slow down');32  const body = (await req.json().catch(() => null)) as { wallet?: unknown; nonce?: unknown; signature?: unknown } | null;33  if (!body || typeof body !== 'object') return error(400, 'bad json');34  const wallet = typeof body.wallet === 'string' ? body.wallet.trim() : '';35  const nonce = typeof body.nonce === 'string' ? body.nonce.trim() : '';36  const signature = typeof body.signature === 'string' ? body.signature.trim() : '';37  if (!isSolAddress(wallet)) return error(400, 'wallet: not a Solana address');38  const bad = nonceError(nonce);39  if (bad) return error(400, bad.replace('start the launch again', 'sign again'));40  if (!SOL_SIGNATURE_RE.test(signature)) return error(400, 'signature: expected base58');41  if (!verifyEd25519(new TextEncoder().encode(claimMessage(wallet, nonce)), signature, wallet)) {42    return error(401, 'signature does not match this wallet');43  }44 45  try {46    // what a claim could pay now (re-uses the Magic Eden lookup the page just made, no new request)47    const rewards = await walletRewards(wallet, { live: false });48    if (rewards.totals.claimableLamports < MIN_CLAIM_LAMPORTS) {49      return error(400, 'nothing to claim yet: the minimum is 0.0001 SOL');50    }51    const result = await db().transaction(async (tx) => {52      await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${`solary-claim:${wallet}`}))`);53      const open = (await tx.execute(sql`SELECT id FROM claim_requests WHERE owner = ${wallet} AND status = 'queued' LIMIT 1`)) as unknown as Array<{ id: string }>;54      if (open.length) return 'queued' as const;55      const ins = (await tx.execute(sql`56        INSERT INTO claim_requests (owner, signature, nonce) VALUES (${wallet}, ${signature}, ${nonce})57        ON CONFLICT (nonce) DO NOTHING RETURNING id`)) as unknown as Array<{ id: string }>;58      return ins.length ? ('ok' as const) : ('reused' as const);59    });60    if (result === 'reused') return error(409, 'this signature was already used; sign again');61    const claim = await latestClaim(wallet);62    return json({ claim, alreadyQueued: result === 'queued' }, 0, { status: result === 'ok' ? 201 : 200 });63  } catch {64    return error(503, 'claims are unavailable right now');65  }66}

179const minNet = await settingBig(ctx, 'payout.min_net_lamports', 100_000n);180const queued = await ctx.db.select().from(claimRequests).where(eq(claimRequests.status, 'queued')).orderBy(asc(claimRequests.createdAt)).limit(20);181let paid = 0;182let nothing = 0;183let waiting = 0;184for (const q of queued) {185  if (p.txBudget <= 0) break;186  const [inflight] = await ctx.db187    .select({ id: payoutTransfers.id })188    .from(payoutTransfers)189    .where(and(eq(payoutTransfers.owner, q.owner), inArray(payoutTransfers.status, ['built', 'sent'])))190    .limit(1);191  if (inflight) {192    waiting++;193    continue;194  }195  const owed = (await loadWalletOwed(ctx.db, q.owner)).filter((o) => handles(ctx, o.coin));196  const exists = (await ctx.sol.walletsExist([q.owner])).has(q.owner);197  const plan = planWalletClaim(owed, { priorityMicroLamports: p.priority, minNetLamports: minNet, walletExists: exists });