clockwork-press 0.0.1 → 0.2.1

package/dist/press.js

@@ -0,0 +1,744 @@
+// The Press. Every tick: sweep and claim what the launch owes, split what the
+// wallet holds, burn, stash, and move ops only at fair value.
+// Whatever the number is — large or embarrassing — the press posts.
+import { formatUnits, parseUnits } from 'viem';
+import { cfg, launched, napping } from './env.js';
+import { pub, wallet, account } from './chain.js';
+import { erc20Abi, curveAbi } from './abis.js';
+import { CLOCKWORK_ADDRESS } from './config.js';
+import { quoteBuy } from './quote.js';
+import { quoteGmeToToken, swapGmeToToken } from './v4.js';
+import { checkPeg } from './peg.js';
+import { readMarket } from './market.js';
+import { readHolders } from './holders.js';
+import { gmeRank } from './gmerank.js';
+import { readLaunch, unswept, trySweep, owed, claimPair, vestStatus, releaseVest, claimVestTokens, poolIdFor, reason } from './pons.js';
+import { appendPress, readLedger, writeLedger, writeStats, burnGmeTotal, statsPath, countKind, hasTx, dailyRollup, totals } from './ledger.js';
+import { parseAbiItem } from 'viem';
+import { readFileSync } from 'node:fs';
+import { post, postCard, ART } from './telegram.js';
+// two assets, two decimal counts: the pairing asset is whatever the launch is priced in, the launch token is 18.
+const fmtPair = (v, dp = 2) => Number(formatUnits(v, cfg.pairDecimals)).toFixed(dp);
+const fmtTok = (v, dp = 0) => Number(formatUnits(v, 18)).toFixed(dp);
+const pairNum = (v) => Number(formatUnits(v, cfg.pairDecimals));
+const TOTAL_SUPPLY = BigInt(cfg.totalSupply) * 10n ** 18n; // whole tokens at mint, from clockwork.json
+const ZERO = '0x0000000000000000000000000000000000000000';
+// a native pair: the machine pays gas in the same asset it presses, so a little stays behind.
+const GAS_RESERVE = parseUnits('0.005', 18);
+const W = cfg.words;
+const same = (a, b) => a.toLowerCase() === b.toLowerCase();
+async function waitTx(hash) {
+    const rcpt = await pub.waitForTransactionReceipt({ hash });
+    if (rcpt.status !== 'success')
+        throw new Error(`tx reverted: ${hash}`);
+    return hash;
+}
+function prevStats() {
+    try {
+        return JSON.parse(readFileSync(statsPath(), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function staleStats() {
+    const at = prevStats().checkedAt;
+    return !at || Date.now() - new Date(at).getTime() > cfg.refreshMin * 60_000;
+}
+// the pairing asset's balance: the chain's own coin when the launch is native, an erc20 otherwise.
+const pairBal = (holder) => cfg.pairNative ? pub.getBalance({ address: holder }) : pub.readContract({ address: cfg.gme, abi: erc20Abi, functionName: 'balanceOf', args: [holder] });
+const tokBal = (holder, asset) => pub.readContract({ address: asset, abi: erc20Abi, functionName: 'balanceOf', args: [holder] });
+// one transfer of the pairing asset, whichever kind it is.
+async function sendPair(to, amount) {
+    const w = wallet();
+    if (cfg.pairNative)
+        return waitTx(await w.sendTransaction({ to, value: amount }));
+    return waitTx(await w.writeContract({ address: cfg.gme, abi: erc20Abi, functionName: 'transfer', args: [to, amount] }));
+}
+// The numbers the site reads every run: supply burned, the treasury, the sunk total.
+async function siteNumbers(token, stash) {
+    const [supply, stashBal] = await Promise.all([
+        pub.readContract({ address: token, abi: erc20Abi, functionName: 'totalSupply' }),
+        cfg.stash ? pairBal(stash) : Promise.resolve(0n),
+    ]);
+    const burnedPct = (Number(TOTAL_SUPPLY - supply) / Number(TOTAL_SUPPLY)) * 100;
+    const stashGme = pairNum(stashBal);
+    return { burnedPct, stashGme, gmeSunk: stashGme + burnGmeTotal() + Number(cfg.gradSeedGme) };
+}
+// The stash scanner: every transfer of the pairing asset into the stash is a press (a claim landing),
+// found by reading the chain, never by a human pasting a hash. Returns how many were new.
+async function scanStash(fairUsd) {
+    if (!cfg.stash || cfg.pairNative)
+        return 0; // a native pair leaves no Transfer logs to scan
+    const ledger = readLedger();
+    const latest = await pub.getBlockNumber();
+    const from = ledger.stashScanBlock ? BigInt(ledger.stashScanBlock) + 1n : latest - 200000n; // first run: ~5.5 hours back
+    if (from > latest)
+        return 0;
+    const logs = await pub.getLogs({
+        address: cfg.gme,
+        event: parseAbiItem('event Transfer(address indexed from, address indexed to, uint256 value)'),
+        args: { to: cfg.stash }, fromBlock: from, toBlock: latest,
+    });
+    // the pairing asset that landed in the burn wallet from the same sender in the same window is part of the press too
+    // (the 45% for snacks, and whatever else the founder fed the machine); the row says how much, not why.
+    const fed = cfg.pressWallet ? await pub.getLogs({
+        address: cfg.gme, event: parseAbiItem('event Transfer(address indexed from, address indexed to, uint256 value)'),
+        args: { to: cfg.pressWallet }, fromBlock: from, toBlock: latest,
+    }) : [];
+    let added = 0;
+    for (const log of logs) {
+        const tx = log.transactionHash;
+        const amt = log.args.value;
+        if (amt === 0n || hasTx(tx))
+            continue;
+        // the machine's own treasury leg is a slice, never a claim, whether or not its row got written
+        if (cfg.pressWallet && same(log.args.from, cfg.pressWallet))
+            continue;
+        const gme = pairNum(amt);
+        const sender = log.args.from.toLowerCase();
+        const toBurn = fed.filter((f) => f.args.from.toLowerCase() === sender).reduce((t, f) => t + pairNum(f.args.value), 0);
+        const fedNote = toBurn > 0 ? ` ${toBurn.toFixed(2)} ${cfg.pairSymbol} went to the machine wallet in the same ${W.claim}, for ${W.slice}s.` : '';
+        const entry = appendPress({
+            kind: 'press',
+            note: `${W.claim}: ${gme.toFixed(2)} ${cfg.pairSymbol} claimed from fees, into the ${W.treasury}. never sold, never distributed.${fedNote}`,
+            burnedGmerald: '0', burnGmeSpent: '0', stashedGme: gme.toFixed(4), opsMovedGme: '0',
+            pegStatus: 'n/a', stashTx: tx, gmeUsd: fairUsd && fairUsd > 0 ? fairUsd : undefined,
+        });
+        await postCard(ART.press, [`${cfg.emoji} ${W.claim} #${entry.k}`, `${W.treasury}: +${gme.toFixed(2)} ${cfg.pairSymbol}. never sold, never distributed.`, fedNote ? fedNote.trim() : null, `the ${W.treasury}: ${Math.round(totals().stashedGme).toLocaleString('en-US')} ${cfg.pairSymbol}`]);
+        added++;
+    }
+    const l2 = readLedger();
+    l2.stashScanBlock = latest.toString();
+    writeLedger(l2);
+    return added;
+}
+// The minimum interval. The primary clock fires at :00/:15/:30/:45 and the backup github cron three
+// minutes later, often late. A tick is refused only when a run already worked in the same slot (the
+// backup leaves when the primary ran; a delayed backup at :12 still belongs to the :00 slot) or within
+// half a cadence, five minutes at most (a primary that fired a second early and the backup three minutes
+// after it are one tick, not two). The last run is the newest of stats.lastRunAt and the last ledger row,
+// so a slice that wrote its row counts even when the stats write was lost. A timestamp in the future is
+// a bad clock, not a recent run.
+function tooSoon() {
+    const stamps = [prevStats().lastRunAt, readLedger().presses.at(-1)?.ts].filter(Boolean).map((t) => new Date(t).getTime()).filter((t) => !Number.isNaN(t));
+    if (!stamps.length)
+        return null;
+    const at = Math.max(...stamps), now = Date.now();
+    const min = (now - at) / 60_000;
+    if (min < 0)
+        return null;
+    const slot = (t) => Math.floor(t / (cfg.cadenceMin * 60_000));
+    return slot(now) === slot(at) || min < Math.min(5, cfg.cadenceMin / 2) ? Math.round(min) : null;
+}
+// lastRunAt is written the moment a run commits to doing work (the first signed transaction), on top of
+// whatever stats are there. a napping tick never writes it, so the stats file does not change every tick.
+function markRun(at) {
+    const prev = prevStats();
+    writeStats({ presses: 0, burnedPct: '0.00', stashGme: '0', gmeSunk: '0', status: 'running', updatedAt: null, ...prev, lastRunAt: at });
+}
+// the legs of the slice in flight. saved after every transaction lands, cleared when the row is written,
+// so a run that dies between two legs leaves its hashes for the next run to record.
+function saveLegs(legs) {
+    if (cfg.dry)
+        return;
+    const l = readLedger();
+    l.meta = { ...(l.meta ?? {}) };
+    if (legs)
+        l.meta.pendingLegs = legs;
+    else
+        delete l.meta.pendingLegs;
+    writeLedger(l);
+}
+function recoverLegs() {
+    const legs = readLedger().meta?.pendingLegs;
+    if (!legs)
+        return;
+    const sent = [legs.burnTx, legs.stashTx, legs.serviceTx, legs.opsTx].filter(Boolean).length;
+    if (sent) {
+        // whatever the interrupted run bought and did not burn still sits in the wallet; this run burns it below
+        const entry = appendPress({
+            kind: 'snack', note: `${legs.note ?? 'pressed'} · the run stopped after ${sent} of its legs at ${legs.startedAt.slice(0, 16).replace('T', ' ')} utc; recorded on the next tick`,
+            burnedGmerald: legs.burnedGmerald ?? '0', burnGmeSpent: legs.burnGmeSpent ?? '0', stashedGme: legs.stashedGme ?? '0', opsMovedGme: legs.opsMovedGme ?? '0',
+            pegStatus: legs.pegStatus ?? 'n/a', burnTx: legs.burnTx, stashTx: legs.stashTx, opsTx: legs.opsTx, serviceTx: legs.serviceTx, serviceGme: legs.serviceGme ?? '0', gmeUsd: legs.gmeUsd,
+        });
+        console.log(`[press] recovered ${W.slice} #${entry.k} from a run that stopped mid-way (${sent} legs landed)`);
+    }
+    saveLegs(undefined);
+}
+// a read the run can live without: log the reason, hand back the fallback, carry on to the burn.
+async function tryRead(what, fn, fallback) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        console.log(`[pons] ${what} read failed: ${reason(e)}`);
+        return fallback;
+    }
+}
+async function watchRecipient(s, me) {
+    const now = new Date().toISOString();
+    if (cfg.claimMode !== 'auto')
+        return { elsewhere: false, feeRecipient: { address: s.recipient, ok: true }, pendingRecipient: null };
+    const prev = prevStats().feeRecipient;
+    const ledger = readLedger();
+    const meta = ledger.meta ?? {};
+    let dirty = false;
+    const ok = same(s.recipient, me);
+    let feeRecipient;
+    if (ok) {
+        feeRecipient = { address: s.recipient, ok: true };
+        if (meta.alertedRecipient) {
+            if (cfg.dry)
+                console.log('[press] dry: would post "fees point at the machine again"');
+            else {
+                await post(`${cfg.emoji} fees point at the machine again.`);
+                delete meta.alertedRecipient;
+                dirty = true;
+            }
+        }
+    }
+    else {
+        // keep the earliest since across runs, so the row says how long it has been
+        const since = prev && !prev.ok && same(prev.address, s.recipient) && prev.since ? prev.since : now;
+        feeRecipient = { address: s.recipient, ok: false, since };
+        console.log(`[press] fees point elsewhere: ${s.recipient} since ${since}; the machine burns what it holds and claims nothing new`);
+        if (!meta.alertedRecipient || !same(meta.alertedRecipient, s.recipient)) {
+            const lines = ['fees no longer point at the machine', `since ${since.slice(0, 16).replace('T', ' ')} utc creator fees go to ${s.recipient}`, 'the machine burns what it holds and claims nothing new.', 'if this was you, nothing to do. if not, open pons.'];
+            if (cfg.dry)
+                console.log(`[press] dry: would post the alert:\n${lines.join('\n')}`);
+            else {
+                await postCard('', lines);
+                meta.alertedRecipient = s.recipient;
+                dirty = true;
+            }
+        }
+    }
+    let pendingRecipient = null;
+    if (s.pending) {
+        pendingRecipient = { to: s.pending.to, effectiveAt: s.pending.effectiveAt };
+        const when = new Date(s.pending.effectiveAt * 1000).toISOString().slice(0, 16).replace('T', ' ');
+        console.log(`[press] a fee-recipient change is pending: ${s.pending.to} from ${when} utc`);
+        if (!meta.alertedPending || !same(meta.alertedPending, s.pending.to)) {
+            const lines = ['a fee-recipient change is pending', `from ${when} utc creator fees would go to ${s.pending.to}`, 'nothing has moved yet; this is the advance notice.', 'if this was you, nothing to do. if not, open pons.'];
+            if (cfg.dry)
+                console.log(`[press] dry: would post the alert:\n${lines.join('\n')}`);
+            else {
+                await postCard('', lines);
+                meta.alertedPending = s.pending.to;
+                dirty = true;
+            }
+        }
+    }
+    else if (meta.alertedPending) {
+        delete meta.alertedPending;
+        dirty = true;
+    }
+    if (dirty && !cfg.dry) {
+        ledger.meta = meta;
+        writeLedger(ledger);
+    }
+    return { elsewhere: !ok, feeRecipient, pendingRecipient };
+}
+// a run that dies after it committed to work leaves lastRunAt and a status behind, so the interval guard
+// and the site both see it; the workflow commits data/ even when the step failed.
+export async function runPress() {
+    const runAt = new Date().toISOString();
+    let committed = false;
+    // called before the first signed transaction, once. a napping or dry tick never gets here.
+    const commit = () => { if (committed || cfg.dry)
+        return; committed = true; markRun(runAt); };
+    try {
+        await pressOnce(runAt, commit);
+    }
+    catch (e) {
+        const why = reason(e);
+        if (!cfg.dry) {
+            const prev = prevStats();
+            writeStats({ presses: 0, burnedPct: '0.00', stashGme: '0', gmeSunk: '0', updatedAt: null, ...prev, status: `failed: ${why}`.slice(0, 160), checkedAt: new Date().toISOString(), ...(committed ? { lastRunAt: runAt } : {}) });
+        }
+        console.log(`[press] the run failed: ${why}`);
+        throw e;
+    }
+}
+async function pressOnce(runAt, commit) {
+    const soon = cfg.dry ? null : tooSoon();
+    if (soon !== null) {
+        console.log(`[press] ran ${soon} min ago, the next tick is not due; leaving`);
+        return;
+    }
+    // The peg reading is free (feed + dexscreener) and worth publishing before
+    // launch: the site shows the machine's sensor is real while the machine naps.
+    const peg = await checkPeg();
+    console.log(`[press] peg: ${peg.status} — ${peg.note}`);
+    const pegOut = { status: peg.status, premiumBps: peg.premiumBps, tokenUsd: peg.tokenUsd, fairUsd: peg.fairUsd, note: peg.note };
+    const holders = await readHolders();
+    if (holders)
+        console.log(`[holders] ${holders}`);
+    try {
+        await gmeRank();
+    }
+    catch (e) {
+        console.log(`[gme-rank] skipped: ${e.shortMessage || e.message}`);
+    }
+    if (!launched()) {
+        if (!cfg.dry) {
+            writeStats({ presses: 0, burnedPct: '0.00', stashGme: '0', gmeSunk: '0', status: 'napping til launch', updatedAt: null, checkedAt: new Date().toISOString(), peg: pegOut });
+        }
+        console.log('[press] not launched yet — wrote the peg check only. exiting cleanly.');
+        return;
+    }
+    const token = cfg.token;
+    const stash = (cfg.stash || ZERO);
+    // 0. Where is the launch — curve or pool — and where do its fees point?
+    const s = await readLaunch();
+    console.log(`[press] launch: ${s.phaseWord}${s.graduationPct != null ? `, ${s.graduationPct.toFixed(1)}% to graduation` : ''}; fees go to ${s.recipient}`);
+    // a slice that stopped between legs last time is recorded first, before the stash scan can mistake it for a claim
+    if (!cfg.dry)
+        recoverLegs();
+    const newPresses = cfg.dry ? 0 : await scanStash(peg.fairUsd);
+    if (newPresses)
+        console.log(`[press] stash scan: ${newPresses} new press(es) logged from the chain`);
+    const mustWrite = () => newPresses > 0 || staleStats();
+    // what every stats write carries this run; the recipient watch and unswept are filled in once known.
+    // the recipient row is red whenever an auto-mode machine is not where the fees point, key or no key.
+    // lastRunAt is whatever the file holds: markRun sets it when a run commits to work, never a napping tick.
+    const common = () => ({
+        presses: countKind('press'), snacks: countKind('snack'), checkedAt: new Date().toISOString(), peg: pegOut,
+        cadenceMin: cfg.cadenceMin, days: dailyRollup(), holders, lastRunAt: prevStats().lastRunAt,
+        phase: s.phaseWord, graduationPct: s.graduationPct,
+        feeRecipient: { address: s.recipient, ok: cfg.claimMode !== 'auto' || same(s.recipient, cfg.pressWallet) }, pendingRecipient: null,
+    });
+    const lastTs = () => readLedger().presses.at(-1)?.ts ?? null;
+    if (!cfg.key) {
+        // Launched, but the bot has no key yet: the founder presses by hand. Refresh
+        // what the site reads (supply, stash, peg) and leave without signing anything.
+        const [n, u] = await Promise.all([siteNumbers(token, stash), unswept(s)]);
+        if (u.total > 0n)
+            console.log(`[press] ${fmtPair(u.total, 4)} ${cfg.pairSymbol} of fees wait on the ${s.phaseWord}, unswept`);
+        if (!cfg.dry && mustWrite()) {
+            writeStats({
+                ...common(), burnedPct: n.burnedPct.toFixed(2), stashGme: n.stashGme.toFixed(2), gmeSunk: n.gmeSunk.toFixed(2),
+                unswept: fmtPair(u.total, 4), status: 'pressing by hand until the bot wakes', updatedAt: lastTs(),
+            });
+        }
+        console.log(`[press] no MACHINE_WALLET_KEY — refreshed the numbers (stash ${n.stashGme.toFixed(2)} ${cfg.pairSymbol}) and left. the founder presses by hand.`);
+        return;
+    }
+    const me = account().address;
+    const w = wallet();
+    // 0b. The recipient watch, then the claim block.
+    const watch = await watchRecipient(s, me);
+    const mine = same(s.recipient, me);
+    const minPress = parseUnits(cfg.minPressGme, cfg.pairDecimals);
+    let unsweptOut = '0';
+    let escrowOut = '0';
+    // 1. Fees reach the escrow only after a sweep: on the curve they accrue as balances on the curve, in
+    //    the pool as pendings on the hook. The numbers are read in every mode; only auto mode sweeps,
+    //    claims and releases (manual: the founder claims by hand and the machine presses what it is sent).
+    //    None of these reads may end the run: the wallet can still burn what it holds without them.
+    const auto = cfg.claimMode === 'auto';
+    const u = await unswept(s);
+    if (u.total > 0n) {
+        unsweptOut = fmtPair(u.total, 4);
+        if (!mine)
+            console.log(`[press] ${unsweptOut} ${cfg.pairSymbol} of fees unswept, and they are not ours to sweep`);
+        else if (!auto)
+            console.log(`[press] ${unsweptOut} ${cfg.pairSymbol} of fees wait on the ${s.phaseWord}, unswept (claim mode manual: the founder sweeps and claims)`);
+        else {
+            const r = await trySweep(s, { onSend: commit });
+            if (r.swept) {
+                console.log(`[press] swept ${unsweptOut} ${cfg.pairSymbol} of fees into the escrow${r.tx ? `: ${cfg.explorer}/tx/${r.tx}` : ''}`);
+                unsweptOut = '0';
+            }
+            else
+                console.log(`[press] ${unsweptOut} ${cfg.pairSymbol} of fees still waiting on the ${s.phaseWord}: ${r.reason ?? 'sweep held'}`);
+        }
+    }
+    if (u.tokenSide > 0n)
+        console.log(`[press] ${fmtTok(u.tokenSide)} ${cfg.tokenSymbol} of fees wait on the hook too; only the pons operator converts those`);
+    const o = await tryRead('escrow', () => owed(me), { pair: 0n, token: 0n });
+    // a claim costs gas and posts a card, so the machine waits for the claim floor, and claims whatever waits
+    // at least once every `atLeastEveryHours` so small fees never sit forever
+    const claimFloor = parseUnits(String(cfg.claimFloor), cfg.pairDecimals);
+    const lastClaimTs = readLedger().presses.filter((p) => (p.kind ?? 'press') === 'press').at(-1)?.ts;
+    const hoursSinceClaim = lastClaimTs ? (Date.now() - new Date(lastClaimTs).getTime()) / 3_600_000 : Infinity;
+    const claimDue = o.pair >= minPress && (o.pair >= claimFloor || hoursSinceClaim >= cfg.claimEveryHours);
+    escrowOut = fmtPair(o.pair, 4);
+    if (o.pair >= minPress && !auto)
+        console.log(`[press] the escrow holds ${fmtPair(o.pair, 4)} ${cfg.pairSymbol} for the machine (claim mode manual: not claimed by the machine)`);
+    else if (o.pair >= minPress && !claimDue)
+        console.log(`[press] the escrow holds ${fmtPair(o.pair, 4)} ${cfg.pairSymbol} for the machine; claims at ${cfg.claimFloor} ${cfg.pairSymbol} or after ${cfg.claimEveryHours}h (last claim ${hoursSinceClaim === Infinity ? 'never' : hoursSinceClaim.toFixed(1) + 'h ago'})`);
+    else if (claimDue) {
+        const got = pairNum(o.pair);
+        commit();
+        const tx = await claimPair();
+        if (!tx)
+            console.log(`[press] dry: would claim ${got.toFixed(4)} ${cfg.pairSymbol} from the fee escrow`);
+        else {
+            const entry = appendPress({ kind: 'press', note: `${W.claim}: ${got.toFixed(2)} ${cfg.pairSymbol} claimed from the fee escrow.`, burnedGmerald: '0', burnGmeSpent: '0', stashedGme: '0', opsMovedGme: '0', pegStatus: 'n/a', stashTx: tx, gmeUsd: peg.fairUsd && peg.fairUsd > 0 ? peg.fairUsd : undefined, claimedGme: got.toFixed(4) });
+            if (cfg.cards.claim)
+                await postCard(ART.press, [`${cfg.emoji} ${W.claim} #${entry.k}`, `${got.toFixed(2)} ${cfg.pairSymbol} claimed from the fee escrow.`, `${Number(cfg.burnBps) / 100}% ${W.slice}s · ${Number(cfg.stashBps) / 100}% ${W.treasury} · ${Number(cfg.opsBps) / 100}% ops.`]);
+            console.log(`[press] claimed ${got.toFixed(4)} ${cfg.pairSymbol} from the escrow`);
+        }
+    }
+    else if (o.pair > 0n)
+        console.log(`[press] the escrow holds ${fmtPair(o.pair, 4)} ${cfg.pairSymbol} for the machine, under the ${fmtPair(minPress)} floor`);
+    // 1b. The buyback vest as a burn feed: a released vest credits the escrow under the launch token;
+    //     claimed into the wallet, it goes into the burn below with everything else. The vault pays only
+    //     its beneficiaries, and the recipient is the beneficiary: when fees point elsewhere the vest is
+    //     not ours to release, and a refusal from the vault or the escrow is a log line, not a dead tick.
+    let vested = 0n;
+    if (cfg.vestMode === 'burn' && s.buybackEnabled && auto && mine) {
+        const v = await tryRead('vault', () => vestStatus(s), { releasable: 0n, escrowToken: o.token });
+        let credited = o.token; // what the escrow holds for the machine under the launch token, after any release
+        if (v.releasable > 0n) {
+            commit();
+            try {
+                const tx = await releaseVest();
+                if (tx) {
+                    // the vault splits a release between the creator and the protocol; the escrow says what our share is
+                    credited = (await tryRead('escrow', () => owed(me), { pair: 0n, token: credited })).token;
+                    console.log(`[press] released the buyback vest (${fmtTok(v.releasable)} ${cfg.tokenSymbol} vault-wide); ${fmtTok(credited)} ${cfg.tokenSymbol} now credited to the machine`);
+                }
+                else
+                    console.log(`[press] dry: would release the buyback vest, up to ${fmtTok(v.releasable)} ${cfg.tokenSymbol} vault-wide, the machine's share of it credited to the escrow`);
+            }
+            catch (e) {
+                console.log(`[press] the vest was not released: ${reason(e)}`);
+            }
+        }
+        if (credited > 0n) {
+            try {
+                const tx = await claimVestTokens();
+                if (tx) {
+                    vested = credited;
+                    console.log(`[press] claimed ${fmtTok(vested)} ${cfg.tokenSymbol} of vested buybacks; they burn with this ${W.slice}`);
+                }
+                else {
+                    vested = credited;
+                    console.log(`[press] dry: would claim ${fmtTok(vested)} ${cfg.tokenSymbol} of vested buybacks and burn them`);
+                }
+            }
+            catch (e) {
+                console.log(`[press] the vested tokens were not claimed: ${reason(e)}`);
+            }
+        }
+    }
+    const watched = () => ({ ...common(), feeRecipient: watch.feeRecipient, pendingRecipient: watch.pendingRecipient, unswept: unsweptOut, escrowOwed: escrowOut, claimFloor: cfg.claimFloor });
+    // 2. The float. Everything the wallet holds is pressed; held-back ops
+    //    slices from earlier presses roll in naturally. A native pair keeps its gas money.
+    let floatBal = await pairBal(me);
+    if (cfg.pairNative)
+        floatBal = floatBal > GAS_RESERVE ? floatBal - GAS_RESERVE : 0n;
+    const nap = napping();
+    if (nap.yes) {
+        // Napping: no slice, no post. Presses are still logged above; the numbers refresh hourly.
+        if (!cfg.dry && mustWrite()) {
+            const n = await siteNumbers(token, stash);
+            writeStats({
+                ...watched(), queuedGme: formatUnits(floatBal, cfg.pairDecimals), sliceGme: '0', slicesLeft: 0,
+                burnedPct: n.burnedPct.toFixed(2), stashGme: n.stashGme.toFixed(2), gmeSunk: n.gmeSunk.toFixed(2),
+                status: watch.elsewhere ? 'paused: fees point elsewhere' : `napping until ${nap.until.slice(11, 16)} utc`, updatedAt: lastTs(),
+            });
+        }
+        console.log(`[press] napping until ${nap.until} — ${fmtPair(floatBal, 2)} ${cfg.pairSymbol} waits in the machine wallet.`);
+        return;
+    }
+    // The TWAP: each press works a fixed fraction of the float (default 1/6), so a
+    // weekly top-up drips into the pool over days instead of landing in one fill.
+    // Slice mode (the 15-minute TWAP): a fixed amount per run, and the tail is
+    // folded into the last slice rather than left as dust.
+    // Dip mode: read the market once (independent of our RPC) and scale the slice.
+    const market = await readMarket(poolIdFor(token));
+    const m = cfg.dipMultiplier;
+    let dip = '', why = '';
+    if (cfg.dipMode && market) {
+        // vsHighBps is 0 at a fresh high and negative below it. A dip: 10%+ under the recent
+        // high → the multiplier (2x by default). Hot: a fresh high with the last hour up 10%+ → divided by it.
+        const h1 = market.h1;
+        if (market.vsHighBps <= -cfg.dipBandBps) {
+            dip = 'more';
+            why = `${m === 2n ? 'double' : `${m}x`}: price ${(-market.vsHighBps / 100).toFixed(1)}% under its recent high`;
+        }
+        else if (market.vsHighBps === 0 && h1 >= cfg.dipBandBps / 100) {
+            dip = 'less';
+            why = `${m === 2n ? 'half' : `1/${m}`}: a fresh high, up ${h1.toFixed(1)}% in the hour`;
+        }
+    }
+    if (market)
+        console.log(`[press] market: ${market.priceGme.toExponential(3)} ${cfg.pairSymbol} per token, ${(market.vsHighBps / 100).toFixed(1)}% vs its recent high${why ? ` → ${why}` : ''}`);
+    let base = parseUnits(cfg.pressSliceGme, cfg.pairDecimals);
+    if (cfg.pressSliceUsd > 0 && peg.tokenUsd && peg.tokenUsd > 0) {
+        const floor = parseUnits((cfg.pressSliceUsd / peg.tokenUsd).toFixed(6), cfg.pairDecimals);
+        if (floor > base) {
+            base = floor;
+            console.log(`[press] slice floor: $${cfg.pressSliceUsd} = ${fmtPair(floor, 2)} ${cfg.pairSymbol} at $${peg.tokenUsd.toFixed(2)}`);
+        }
+    }
+    let slice = base;
+    if (cfg.pressSpreadHours > 0 && floatBal > 0n) {
+        // Batch = everything since the last press. Ticks in the window minus snacks already done.
+        const all = readLedger().presses;
+        const lastPressIdx = all.map((p) => p.kind ?? 'press').lastIndexOf('press');
+        const lastPress = lastPressIdx >= 0 ? all[lastPressIdx] : undefined;
+        const done = lastPress ? all.slice(lastPressIdx + 1).filter((p) => p.kind === 'snack').length : 0;
+        const total = Math.max(1, Math.round((cfg.pressSpreadHours * 60) / cfg.cadenceMin));
+        // A batch that already used its window (or a press the scanner has not seen yet) is treated
+        // as a fresh batch, never as "one tick left".
+        const left = done >= total ? total : total - done;
+        slice = floatBal / BigInt(left);
+        console.log(`[press] spread: ${cfg.pressSpreadHours}h = ${total} ticks, ${done} snacks done since the last press, ${left} left → ${fmtPair(slice, 2)} ${cfg.pairSymbol} each`);
+    }
+    // the dip scales whatever rule produced the slice, the spread included, and never more than the float
+    if (dip === 'more')
+        slice = slice * m;
+    else if (dip === 'less')
+        slice = slice / m;
+    let gmeBal = slice > 0n ? (floatBal < slice ? floatBal : slice) : (floatBal * cfg.pressFractionBps) / cfg.BPS;
+    if (slice > 0n && floatBal > gmeBal && floatBal - gmeBal < slice / 2n)
+        gmeBal = floatBal;
+    console.log(`[press] float: ${fmtPair(floatBal, 4)} ${cfg.pairSymbol}, pressing ${fmtPair(gmeBal, 4)} (${s.phaseWord}, dry=${cfg.dry})`);
+    // Rule: nothing of the launch token ever sits in this wallet. Whatever is here gets burned
+    // on this run, whether or not there is anything to press (a slice burns its own buy
+    // plus anything left over, vested buybacks included; a sweep burns leftovers alone).
+    // Between the curve and the pool (swept) or after a rescue there is no venue to buy in, so the
+    // whole slice waits rather than splitting the treasury and service legs off a burn that cannot happen.
+    const heldTok = await tokBal(me, token);
+    const noVenue = s.phase === 1 || s.phase === 3;
+    const sweepOnly = (gmeBal < minPress || noVenue) && heldTok > 0n;
+    if (noVenue && !sweepOnly) {
+        const where = s.phase === 3 ? 'the launch was rescued; there is no pool to burn in' : 'the curve is swept and the pool is not open yet';
+        if (!cfg.dry && mustWrite()) {
+            const n = await siteNumbers(token, stash);
+            writeStats({
+                ...watched(), queuedGme: formatUnits(floatBal, cfg.pairDecimals), sliceGme: '0', slicesLeft: 0,
+                burnedPct: n.burnedPct.toFixed(2), stashGme: n.stashGme.toFixed(2), gmeSunk: n.gmeSunk.toFixed(2),
+                status: `holding: ${where}`, updatedAt: lastTs(),
+            });
+        }
+        console.log(`[press] holding the whole slice: ${where}. ${fmtPair(floatBal, 2)} ${cfg.pairSymbol} waits in the machine wallet.`);
+        return;
+    }
+    if (gmeBal < minPress && !sweepOnly) {
+        // Nothing to press: no ledger row, no post. Between claims the machine naps quietly,
+        // and the site's numbers get a refresh about once an hour.
+        if (!cfg.dry && mustWrite()) {
+            const n = await siteNumbers(token, stash);
+            writeStats({
+                ...watched(), queuedGme: '0',
+                burnedPct: n.burnedPct.toFixed(2), stashGme: n.stashGme.toFixed(2), gmeSunk: n.gmeSunk.toFixed(2),
+                status: watch.elsewhere ? 'paused: fees point elsewhere' : 'napping between claims', updatedAt: lastTs(),
+            });
+        }
+        console.log('[press] nothing to press — the machine napped (no row, no post).');
+        return;
+    }
+    let note = why ? `pressed · ${why}` : 'pressed';
+    let burnedGmerald = '0';
+    let burnGmeSpent = '0';
+    let stashedGme = '0';
+    let opsMovedGme = '0';
+    let burnTx;
+    let stashTx;
+    let opsTx;
+    let serviceTx;
+    let serviceGme = '0';
+    const pegStatus = `${peg.status}${peg.premiumBps != null ? ` (${peg.premiumBps >= 0 ? '+' : ''}${(peg.premiumBps / 100).toFixed(2)}%)` : ''}`;
+    const gmeUsd = peg.fairUsd && peg.fairUsd > 0 ? peg.fairUsd : undefined;
+    // after each leg lands its hash is on disk, so a run that dies before the row is written is not lost
+    const legs = () => saveLegs({ startedAt: runAt, note, burnedGmerald, burnGmeSpent, stashedGme, opsMovedGme, pegStatus, burnTx, stashTx, opsTx, serviceTx, serviceGme, gmeUsd });
+    if (sweepOnly) {
+        note = 'burned what was waiting in the burn wallet';
+    }
+    else {
+        const burnAmt = (gmeBal * cfg.burnBps) / cfg.BPS;
+        const stashAmt = (gmeBal * cfg.stashBps) / cfg.BPS;
+        const serviceAmt = (gmeBal * cfg.serviceBps) / cfg.BPS;
+        // no ops share: the rounding dust stays in the float instead of going anywhere
+        const opsAmt = cfg.opsBps === 0n || !cfg.ops ? 0n : gmeBal - burnAmt - stashAmt - serviceAmt;
+        // 3. Burn leg: the pairing asset -> the launch token in our own venue, then burn. On the curve
+        //    this is a direct buy; in the pool it is the v4 route. A native pair has no burn leg yet.
+        if (cfg.pairNative) {
+            console.log('[press] native-pair launches: the burn leg is next; claims and the treasury share still run');
+            note = 'pressed — burn leg held (native pair: the burn leg is next)';
+        }
+        else if (s.phase === 0) {
+            const q = await quoteBuy(s.curve, burnAmt, me);
+            const minOut = (q.tokensOut * (cfg.BPS - cfg.slippageBps)) / cfg.BPS;
+            if (cfg.dry) {
+                console.log(`[press] dry: would buy ~${fmtTok(q.tokensOut)} tokens with ${fmtPair(q.spent, 4)} ${cfg.pairSymbol} and burn it`);
+            }
+            else {
+                commit();
+                await waitTx(await w.writeContract({
+                    address: cfg.gme, abi: erc20Abi, functionName: 'approve', args: [s.curve, burnAmt],
+                }));
+                burnTx = await waitTx(await w.writeContract({
+                    address: s.curve, abi: curveAbi, functionName: 'buy', args: [burnAmt, minOut, me],
+                }));
+                burnGmeSpent = formatUnits(burnAmt, cfg.pairDecimals);
+                legs();
+            }
+        }
+        else if (s.phase === 2 && cfg.v4SwapEnabled) {
+            const quoted = await quoteGmeToToken(token, burnAmt);
+            const minOut = (quoted * (cfg.BPS - cfg.slippageBps)) / cfg.BPS;
+            // Sanity: the quote comes from our RPC; the market read comes from dexscreener. If they
+            // disagree by more than QUOTE_SANITY_BPS, something is lying and the slice is held.
+            if (market && market.priceGme > 0) {
+                const expected = pairNum(burnAmt) / market.priceGme;
+                const gapBps = Math.round((Number(formatUnits(quoted, 18)) / expected - 1) * 10000);
+                if (Math.abs(gapBps) > cfg.quoteSanityBps)
+                    throw new Error(`quote ${fmtTok(quoted)} vs market ${expected.toFixed(0)} tokens (${gapBps} bps apart); holding this slice`);
+            }
+            if (cfg.dry) {
+                console.log(`[press] dry: would swap ${fmtPair(burnAmt, 4)} ${cfg.pairSymbol} -> ~${fmtTok(quoted)} tokens on the v4 pool and burn it`);
+            }
+            else {
+                commit();
+                const swapTx = await swapGmeToToken(token, burnAmt, minOut);
+                console.log(`[press] swapped: ${cfg.explorer}/tx/${swapTx}`);
+                burnGmeSpent = formatUnits(burnAmt, cfg.pairDecimals);
+                legs();
+            }
+        }
+        else {
+            // phase 2 with the v4 swap off (phases 1 and 3 held the whole slice above)
+            note = 'pressed — burn leg held (pool phase, V4_SWAP_ENABLED=0: swap+burn manually)';
+        }
+        // 4. Stash leg: already the pairing asset. One transfer, nothing to convert.
+        if (stashAmt === 0n) {
+            // burn-only wallet: nothing to stash here
+        }
+        else if (cfg.dry) {
+            console.log(`[press] dry: would stash ${fmtPair(stashAmt, 4)} ${cfg.pairSymbol}`);
+        }
+        else {
+            commit();
+            stashTx = await sendPair(stash, stashAmt);
+            stashedGme = formatUnits(stashAmt, cfg.pairDecimals);
+            legs();
+        }
+        // 4b. Service leg: the clockwork share. One transfer, on-chain, every slice.
+        if (serviceAmt > 0n) {
+            // belt and braces: validate() already refuses a share with no wallet to send it to
+            if (same(CLOCKWORK_ADDRESS, ZERO))
+                throw new Error('the service wallet is not pinned in this build of clockwork-press; update the package');
+            if (cfg.dry)
+                console.log(`[press] dry: would send ${fmtPair(serviceAmt, 4)} ${cfg.pairSymbol} to clockwork`);
+            else {
+                commit();
+                serviceTx = await sendPair(CLOCKWORK_ADDRESS, serviceAmt);
+                serviceGme = formatUnits(serviceAmt, cfg.pairDecimals);
+                legs();
+            }
+        }
+        // 5. Ops leg: moves only at or above fair value. Unchecked = held.
+        const opsOk = peg.status === 'at-or-above' || cfg.opsForce;
+        if (opsOk && opsAmt > 0n) {
+            if (cfg.dry) {
+                console.log(`[press] dry: would move ${fmtPair(opsAmt, 4)} ${cfg.pairSymbol} to ops`);
+            }
+            else {
+                commit();
+                opsTx = await sendPair(cfg.ops, opsAmt);
+                opsMovedGme = formatUnits(opsAmt, cfg.pairDecimals);
+                legs();
+            }
+        }
+        else if (opsAmt > 0n) {
+            console.log(`[press] ops slice held (${fmtPair(opsAmt, 4)} ${cfg.pairSymbol}): peg ${peg.status}`);
+        }
+    }
+    // 3b. The burn itself: whatever the wallet holds now — this run's buy, vested buybacks, anything
+    //     that was already waiting — goes in one burn tx, so nothing of the token ever sits here.
+    if (cfg.dry) {
+        if (heldTok > 0n)
+            console.log(`[press] dry: would burn ${fmtTok(heldTok)} ${cfg.tokenSymbol} already held${vested > 0n ? ` (of which ${fmtTok(vested)} vested buybacks)` : ''}`);
+        console.log('[press] dry run complete — no ledger, no stats, no post.');
+        return;
+    }
+    const toBurn = await tokBal(me, token);
+    if (toBurn > 0n) {
+        commit();
+        const tx = await waitTx(await w.writeContract({ address: token, abi: erc20Abi, functionName: 'burn', args: [toBurn] }));
+        burnTx ??= tx;
+        burnedGmerald = fmtTok(toBurn);
+        // Tokens that were already waiting in the wallet (vested buybacks, a manual buy, a top-up) go into the
+        // same burn; say so, so the row does not read like a miracle fill.
+        if (!sweepOnly && heldTok > 0n)
+            note = `${note} · plus ${fmtTok(heldTok)} that was already waiting in the burn wallet${vested > 0n ? ` (${fmtTok(vested)} of it vested buybacks)` : ''}`;
+        legs();
+    }
+    // 6. Write the record the site reads.
+    let remaining = await pairBal(me);
+    if (cfg.pairNative)
+        remaining = remaining > GAS_RESERVE ? remaining - GAS_RESERVE : 0n;
+    // Slices left: on the spread, the ticks left in the window; otherwise remaining / slice.
+    let slicesLeft = slice > 0n ? Number((remaining + slice - 1n) / slice) : 0;
+    let nextSlice = slice;
+    if (cfg.pressSpreadHours > 0) {
+        const all = readLedger().presses;
+        const idx = all.map((p) => p.kind ?? 'press').lastIndexOf('press');
+        const done = idx >= 0 ? all.slice(idx + 1).filter((p) => p.kind === 'snack').length : 0;
+        const total = Math.max(1, Math.round((cfg.pressSpreadHours * 60) / cfg.cadenceMin));
+        slicesLeft = remaining >= minPress ? Math.max(1, total - done) : 0;
+        nextSlice = slicesLeft > 0 ? remaining / BigInt(slicesLeft) : 0n;
+    }
+    const entry = appendPress({
+        kind: 'snack',
+        note,
+        burnedGmerald,
+        burnGmeSpent: Number(burnGmeSpent).toFixed(4),
+        stashedGme: Number(stashedGme).toFixed(4),
+        opsMovedGme: Number(opsMovedGme).toFixed(4),
+        pegStatus,
+        burnTx,
+        stashTx,
+        opsTx,
+        serviceTx,
+        serviceGme: Number(serviceGme).toFixed(4),
+        gmeUsd,
+    });
+    saveLegs(undefined); // the row is written; nothing is in flight
+    const n = await siteNumbers(token, stash);
+    const burnedPct = n.burnedPct;
+    let curveOut;
+    if (s.phase === 0) {
+        const [raised, threshold] = await Promise.all([
+            pub.readContract({ address: s.curve, abi: curveAbi, functionName: 'realQuoteReserve' }),
+            pub.readContract({ address: s.curve, abi: curveAbi, functionName: 'graduationThreshold' }),
+        ]);
+        curveOut = { raisedGme: fmtPair(raised, 2), thresholdGme: fmtPair(threshold, 0), pct: threshold > 0n ? Math.min(100, Number((raised * 10000n) / threshold) / 100) : 0 };
+    }
+    // the burn counter before this snack, so a whole percent crossing gets its own post
+    const prevPct = Number(prevStats().burnedPct) || 0;
+    writeStats({
+        ...watched(), queuedGme: formatUnits(remaining, cfg.pairDecimals), sliceGme: fmtPair(nextSlice, 2), slicesLeft,
+        burnedPct: burnedPct.toFixed(2),
+        stashGme: n.stashGme.toFixed(2),
+        gmeSunk: n.gmeSunk.toFixed(2),
+        status: watch.elsewhere ? 'paused: fees point elsewhere' : remaining >= minPress ? `snacking. ${slicesLeft} slice${slicesLeft === 1 ? '' : 's'} of ~${fmtPair(nextSlice, 0)} ${cfg.pairSymbol} to go` : 'napping between claims',
+        updatedAt: entry.ts,
+        checkedAt: entry.ts,
+        curve: curveOut,
+    });
+    // 7. Say it happened. Both hashes or it didn't.
+    const gone = Number(String(burnedGmerald).replace(/,/g, ''));
+    if (cfg.cards.slice)
+        await postCard(ART.snack, [
+            `${cfg.emoji} ${W.slice} #${entry.k}`,
+            burnTx ? `burned ${gone.toLocaleString('en-US')} ${cfg.tokenSymbol}${Number(burnGmeSpent) > 0 ? ` with ${Number(burnGmeSpent).toFixed(2)} ${cfg.pairSymbol}` : ''}` : null,
+            stashTx ? `${W.treasury}: +${entry.stashedGme} ${cfg.pairSymbol}` : null,
+            serviceTx ? `clockwork: ${Number(serviceGme).toFixed(2)} ${cfg.pairSymbol}` : null,
+            opsTx ? `ops: ${entry.opsMovedGme} ${cfg.pairSymbol}` : null,
+            note !== 'pressed' ? note.replace('pressed · ', '') : null,
+            `this ${W.slice}: ${(gone / (cfg.totalSupply / 100)).toFixed(3)}% of supply`,
+            `burned so far: ${burnedPct.toFixed(2)}% of supply, forever`,
+            remaining >= minPress ? `${slicesLeft} more to go, one every ${cfg.cadenceMin} min` : 'that was the last one until the next claim',
+        ]);
+    if (cfg.cards.percent && Math.floor(burnedPct) > Math.floor(prevPct) && prevPct > 0)
+        await postCard(ART.burn, [`\u{1F525} ${Math.floor(burnedPct)}% of ${cfg.tokenSymbol} supply is gone.`, `${burnedPct.toFixed(2)}% exactly, bought with fees and burned.${cfg.siteUrl ? ` ${cfg.siteUrl}` : ''}`]);
+    console.log(`[press] snack #${entry.k} complete.`);
+}