clockwork-press 0.0.1 → 0.2.0

package/dist/jobs/buys.js

@@ -0,0 +1,121 @@
+// The buy bot. Scans the pool's Swap events since the last run and posts each buy above the floor
+// to the burrow: size in gme and dollars, new holder or not, market cap at that moment, the buyer,
+// the hash. Runs at the end of every press run (the reliable clock); state is the last scanned
+// block in site/buys-state.json, committed with the terminal's numbers.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { encodeAbiParameters, formatUnits, keccak256, parseAbiItem } from 'viem';
+import { cfg } from '../env.js';
+import { pub } from '../chain.js';
+import { postMedia, ART } from '../telegram.js';
+import { checkPeg } from '../peg.js';
+import { V4, poolKey } from '../v4.js';
+const statePath = () => join(cfg.siteDir, 'buys-state.json');
+const short = (a) => a.slice(0, 6) + '…' + a.slice(-4);
+const TRANSFER = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
+const SEAT = 250_000;
+// tokens that land here are in transit, not bought: the pool, the routers, permit2, the hook
+const NOT_BUYERS = new Set(['0x8366a39cc670b4001a1121b8f6a443a643e40951', '0x8876789976decbfcbbbe364623c63652db8c0904', '0x000000000022d473030f116ddee9f6b43ac78ba3', '0xe5e702641ea86f4ae6cc3cdaed2b886f976be044', '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f', '0x39b38686a19836ac10162c490e4558e120cbbe5f', '0x8f10b468b06c6fd214b65f87778827f7d113f996']);
+const erc20 = [parseAbiItem('function balanceOf(address) view returns (uint256)'), parseAbiItem('function totalSupply() view returns (uint256)')];
+const money = (n) => n >= 1e6 ? `$${(n / 1e6).toFixed(2)}m` : n >= 1e3 ? `$${(n / 1e3).toFixed(0)}k` : `$${n.toFixed(0)}`;
+// the wallet the bought tokens ended up in: the biggest token transfer in the tx that is not to infra
+async function buyerOf(hash, token, fallback) {
+    try {
+        const rc = await pub.getTransactionReceipt({ hash });
+        let best = 0n, who = '';
+        for (const l of rc.logs) {
+            if (l.address.toLowerCase() !== token.toLowerCase() || l.topics[0] !== TRANSFER || l.topics.length < 3)
+                continue;
+            const to = '0x' + l.topics[2].slice(26);
+            const v = BigInt(l.data);
+            if (!NOT_BUYERS.has(to.toLowerCase()) && v > best) {
+                best = v;
+                who = to;
+            }
+        }
+        return who || fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function runBuys() {
+    if (!cfg.token) {
+        console.log('[buys] TOKEN_ADDRESS not set');
+        return;
+    }
+    // telegram.cards.buys is the switch for this job; off means nothing scanned, nothing posted
+    if (!cfg.cards.buys) {
+        console.log('[buys] buy cards are off in clockwork.json (telegram.cards.buys); nothing posted');
+        return;
+    }
+    const token = cfg.token;
+    const k = poolKey(token);
+    const poolId = keccak256(encodeAbiParameters([{ type: 'address' }, { type: 'address' }, { type: 'uint24' }, { type: 'int24' }, { type: 'address' }], [k.currency0, k.currency1, k.fee, k.tickSpacing, k.hooks]));
+    const latest = await pub.getBlockNumber();
+    let from;
+    try {
+        from = BigInt(JSON.parse(readFileSync(statePath(), 'utf8')).lastBlock) + 1n;
+    }
+    catch {
+        from = latest - 200n;
+    }
+    if (from > latest) {
+        console.log('[buys] nothing new');
+        return;
+    }
+    // blocks are ~0.1s apart. if the state is stale (first run, or the clock slept), only look back ~15 minutes:
+    // nobody wants an hour of buys dumped into the chat at once.
+    const MAX_BACK = 10000n;
+    if (latest - from > MAX_BACK) {
+        console.log(`[buys] state is ${latest - from} blocks behind; skipping ahead to the last ${MAX_BACK}`);
+        from = latest - MAX_BACK;
+    }
+    const logs = await pub.getLogs({
+        address: V4.poolManager,
+        event: parseAbiItem('event Swap(bytes32 indexed id, address indexed sender, int128 amount0, int128 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint24 fee)'),
+        args: { id: poolId }, fromBlock: from, toBlock: latest,
+    });
+    const peg = await checkPeg();
+    const gmeUsd = peg.tokenUsd ?? 0;
+    const supply = Number(formatUnits(await pub.readContract({ address: token, abi: erc20, functionName: 'totalSupply' }), 18));
+    const gmeIs0 = k.zeroForOne; // GME is currency0 when GME sorts first
+    let posted = 0;
+    for (const log of logs) {
+        const a0 = log.args.amount0, a1 = log.args.amount1;
+        const gmeDelta = gmeIs0 ? a0 : a1, tokDelta = gmeIs0 ? a1 : a0;
+        // from the swapper's view: negative = paid in, positive = received. a buy pays gme and receives $gmerald.
+        if (!(gmeDelta < 0n && tokDelta > 0n))
+            continue;
+        const gme = Number(formatUnits(-gmeDelta, 18)), got = Number(formatUnits(tokDelta, 18));
+        const usd = gme * gmeUsd;
+        if (usd < Number(cfg.minBuyUsd))
+            continue;
+        const tx = await pub.getTransaction({ hash: log.transactionHash });
+        const buyer = await buyerOf(log.transactionHash, token, tx.from);
+        if (buyer.toLowerCase() === String(cfg.pressWallet).toLowerCase())
+            continue; // the machine's own snacks are posted as snacks
+        let before = 0;
+        try {
+            before = Number(formatUnits(await pub.readContract({ address: token, abi: erc20, functionName: 'balanceOf', args: [buyer], blockNumber: (log.blockNumber ?? latest) - 1n }), 18));
+        }
+        catch { }
+        const after = before + got, fresh = before < 1;
+        const mcap = got > 0 && usd > 0 ? (usd / got) * supply : 0;
+        const hamsters = '\u{1F439}'.repeat(Math.max(1, Math.min(40, Math.floor(usd / Number(cfg.buyStepUsd)))));
+        const who = fresh ? 'new holder · welcome to the burrow' : `holder since before · now ${after.toLocaleString('en-US', { maximumFractionDigits: 0 })} $gmerald`;
+        const seat = after >= SEAT ? (fresh || before < SEAT ? ' · takes a seat on the board' : ' · a seat on the board') : '';
+        const text = [
+            hamsters,
+            `buy: ${gme.toFixed(3)} gme${gmeUsd ? ` ($${usd.toFixed(0)})` : ''} → ${got.toLocaleString('en-US', { maximumFractionDigits: 0 })} $gmerald`,
+            who + seat,
+            mcap > 0 ? `market cap at the time: ${money(mcap)}` : null,
+            `buyer ${short(buyer)} · ${cfg.explorer}/tx/${log.transactionHash}`,
+            `chart: https://dexscreener.com/robinhood/${poolId}`,
+        ].filter(Boolean).join('\n');
+        await postMedia(fresh ? ART.newHolder : ART.buy, text);
+        posted++;
+    }
+    writeFileSync(statePath(), JSON.stringify({ lastBlock: latest.toString(), scannedAt: new Date().toISOString() }));
+    console.log(`[buys] ${logs.length} swaps scanned, ${posted} buys posted, up to block ${latest}`);
+}

package/dist/jobs/claimcheck.js

@@ -0,0 +1,53 @@
+// clockwork claimcheck: where the launch is, who the fees point at, and what is owed, credited, unswept
+// and releasable right now, without claiming any of it.
+import { formatUnits } from 'viem';
+import { cfg } from '../env.js';
+import { readLaunch, unswept, owed, vestStatus, trySweep } from '../pons.js';
+const fmt = (v, dp = 4) => Number(formatUnits(v, cfg.pairDecimals)).toFixed(dp);
+const short = (a) => `${a.slice(0, 6)}…${a.slice(-4)}`;
+const when = (t) => new Date(t * 1000).toISOString().slice(0, 16).replace('T', ' ') + ' utc';
+const say = (l) => console.log(`[claimcheck] ${l}`);
+export async function runClaimCheck() {
+    if (!cfg.escrow) {
+        say('no fee escrow in clockwork.json (launch.kind is not pons-v2)');
+        return;
+    }
+    const s = await readLaunch();
+    if (!s.exists) {
+        say(`the pons factory has no record of ${cfg.token}; nothing to check`);
+        return;
+    }
+    const where = s.phase === 0 ? `on the curve, ${s.graduationPct?.toFixed(1) ?? '?'}% to graduation`
+        : s.phase === 2 ? 'graduated, trading in the pool' : s.phase === 1 ? 'swept, waiting for its pool' : 'rescued';
+    say(`${cfg.brandName}: ${where} (phase ${s.phase}, ${s.phaseWord})`);
+    const machine = cfg.pressWallet;
+    const isMachine = s.recipient.toLowerCase() === machine.toLowerCase();
+    say(`fee recipient: ${s.recipient}${isMachine ? ' — the machine wallet' : ` — not the machine wallet (${short(machine)}); fees credit the recipient, the machine only presses what it is sent`}`);
+    if (s.pending)
+        say(`pending takeover: fees move to ${s.pending.to} at ${when(s.pending.effectiveAt)} (offer expires ${when(s.pending.expiresAt)})`);
+    else
+        say('pending takeover: none');
+    const [mine, theirs, un, vest, sweep] = await Promise.all([
+        // send: false — this job reads and simulates; it never signs, whatever key or claim mode is set
+        owed(machine), isMachine ? null : owed(s.recipient), unswept(s), vestStatus(s), trySweep(s, { send: false }),
+    ]);
+    say(`escrow credited to the machine wallet: ${fmt(mine.pair)} ${cfg.pairSymbol}${mine.token > 0n ? ` + ${Number(formatUnits(mine.token, 18)).toFixed(0)} ${cfg.tokenSymbol} from released vests` : ''}`);
+    if (theirs)
+        say(`escrow credited to the recipient: ${fmt(theirs.pair)} ${cfg.pairSymbol}`);
+    const venue = s.phase === 0 ? 'the curve' : 'the hook';
+    if (s.phase === 0 || s.phase === 2) {
+        say(`unswept on ${venue}: ${fmt(un.total)} ${cfg.pairSymbol} (fee ${fmt(un.quote)} + creator tax ${fmt(un.tax)}); the creator's cut lands in the escrow at the next sweep`);
+        if (un.tokenSide > 0n)
+            say(`plus ${Number(formatUnits(un.tokenSide, 18)).toLocaleString('en-US', { maximumFractionDigits: 0 })} ${cfg.tokenSymbol} in launch-token fees that only the pons operator can convert`);
+        say(`self-sweep from the machine wallet: ${sweep.reason}`);
+    }
+    else
+        say(`unswept: nothing accrues in phase ${s.phaseWord}`);
+    if (s.buybackEnabled)
+        say(`buyback vest: ${Number(formatUnits(vest.releasable, 18)).toFixed(0)} ${cfg.tokenSymbol} releasable now, ${Number(formatUnits(vest.escrowToken, 18)).toFixed(0)} already in the escrow`);
+    else
+        say('buyback vest: buybacks are off for this launch');
+    const now = mine.pair;
+    const later = isMachine ? un.total : 0n;
+    say(`the machine could collect now: ${fmt(now)} ${cfg.pairSymbol} (claim mode: ${cfg.claimMode})${later > 0n ? `; up to ${fmt(later)} ${cfg.pairSymbol} more after a sweep` : ''}`);
+}

package/dist/jobs/doctor.js

@@ -0,0 +1,74 @@
+// Preflight that works BEFORE the token exists: connectivity, identity,
+// config completeness, integrations. Run it after every secret change.
+import { formatUnits } from 'viem';
+import { cfg, launched } from '../env.js';
+import { pub, account } from '../chain.js';
+import { erc20Abi, factoryAbi } from '../abis.js';
+import { checkPeg } from '../peg.js';
+import { readLaunch, unswept } from '../pons.js';
+const ok = (label, detail = '') => console.log(`  ✓ ${label}${detail ? ` — ${detail}` : ''}`);
+const warn = (label, detail = '') => console.log(`  ⚠ ${label}${detail ? ` — ${detail}` : ''}`);
+export async function runDoctor() {
+    console.log('press doctor\n');
+    const chainId = await pub.getChainId();
+    chainId === 4663 ? ok('rpc', `robinhood chain (${chainId})`) : warn('rpc', `unexpected chain id ${chainId}`);
+    const [sym, approved] = await Promise.all([
+        pub.readContract({ address: cfg.gme, abi: erc20Abi, functionName: 'symbol' }),
+        pub.readContract({ address: cfg.factory, abi: factoryAbi, functionName: 'approvedPairTokens', args: [cfg.gme] }),
+    ]);
+    sym === 'GME' ? ok('gme stock token', cfg.gme) : warn('gme token symbol', `read "${sym}" — verify the address`);
+    approved ? ok('gme approved as pons pair') : warn('gme NOT approved as pons pair anymore — re-plan before launch');
+    if (cfg.key) {
+        const me = account().address;
+        const [eth, gme] = await Promise.all([
+            pub.getBalance({ address: me }),
+            pub.readContract({ address: cfg.gme, abi: erc20Abi, functionName: 'balanceOf', args: [me] }),
+        ]);
+        ok('press wallet', me);
+        Number(formatUnits(eth, 18)) > 0.002
+            ? ok('gas', `${Number(formatUnits(eth, 18)).toFixed(4)} ETH`)
+            : warn('gas low', `${formatUnits(eth, 18)} ETH — top up for ~6 tx/press`);
+        ok('float', `${Number(formatUnits(gme, 18)).toFixed(4)} GME`);
+    }
+    else
+        warn('MACHINE_WALLET_KEY unset', 'reads only; press will fail');
+    launched()
+        ? ok('launch config', `token ${cfg.token}, stash ${cfg.stash}`)
+        : warn('not launched', 'TOKEN_ADDRESS / STASH_ADDRESS unset — press exits cleanly');
+    cfg.escrow ? ok('escrow', cfg.escrow) : warn('ESCROW_ADDRESS unset', 'claim step skipped');
+    cfg.ops ? ok('ops wallet', cfg.ops) : warn('no ops wallet in clockwork.json', 'ops slice held');
+    // pons: where the launch is, who the fees point at, and what is sitting unswept on the curve or the hook.
+    if (cfg.escrow) {
+        try {
+            const s = await readLaunch();
+            if (!s.exists)
+                warn('pons launch', `the factory has no record of ${cfg.token}`);
+            else {
+                ok('phase', s.phase === 0 ? `on the curve, ${s.graduationPct?.toFixed(1)}% to graduation` : `${s.phaseWord} (${s.phase})`);
+                s.recipient.toLowerCase() === String(cfg.pressWallet).toLowerCase()
+                    ? ok('fee recipient', 'the machine wallet')
+                    : warn('fee recipient is not the machine', `${s.recipient} — fees credit that address; the machine only presses what it is sent`);
+                if (s.pending)
+                    warn('pending takeover', `fees move to ${s.pending.to} at ${new Date(s.pending.effectiveAt * 1000).toISOString()}`);
+                const un = await unswept(s);
+                const total = Number(formatUnits(un.total, cfg.pairDecimals));
+                (s.phase === 0 || s.phase === 2) && total > 0
+                    ? warn('unswept', `${total.toFixed(4)} ${cfg.pairSymbol} on the ${s.phase === 0 ? 'curve' : 'hook'} waits for a sweep${un.tokenSide > 0n ? `, plus ${Number(formatUnits(un.tokenSide, 18)).toFixed(0)} ${cfg.tokenSymbol} the operator must convert` : ''}`)
+                    : ok('unswept', 'nothing waiting for a sweep');
+            }
+        }
+        catch (e) {
+            warn('pons reads failed', e.shortMessage || e.message);
+        }
+    }
+    const peg = await checkPeg();
+    peg.status === 'unchecked' ? warn('peg check', peg.note) : ok('peg check', peg.note);
+    if (cfg.tgToken) {
+        const res = await fetch(`https://api.telegram.org/bot${cfg.tgToken}/getMe`);
+        res.ok ? ok('telegram bot') : warn('telegram', `getMe ${res.status}`);
+        cfg.tgChat ? ok('telegram chat', cfg.tgChat) : warn('TELEGRAM_CHAT_ID unset');
+    }
+    else
+        warn('telegram unset', 'presses will only log to console');
+    console.log('\ndone.');
+}

package/dist/jobs/handback.js

@@ -0,0 +1,50 @@
+// clockwork handback <newRecipient>: give the fees back. claims what the escrow has already credited to
+// the machine wallet (a transfer does not move it), then points the creator fee recipient at the new
+// address. in dry mode, or without a key, it simulates both and says what it would do.
+import { formatUnits } from 'viem';
+import { cfg } from '../env.js';
+import { readLaunch, owed, handback, reason } from '../pons.js';
+const say = (l) => console.log(`[handback] ${l}`);
+export async function runHandback() {
+    const to = process.argv[3] ?? '';
+    if (!/^0x[0-9a-fA-F]{40}$/.test(to))
+        throw new Error('usage: clockwork handback <new recipient address>');
+    if (/^0x0{40}$/.test(to))
+        throw new Error('refusing to hand the fees to the zero address');
+    if (!cfg.escrow) {
+        say('no fee escrow in clockwork.json (launch.kind is not pons-v2); nothing to hand back');
+        return;
+    }
+    const s = await readLaunch();
+    if (!s.exists)
+        throw new Error(`the pons factory has no record of ${cfg.token}`);
+    const machine = cfg.pressWallet;
+    if (s.recipient.toLowerCase() !== machine.toLowerCase()) {
+        say(`the fee recipient is ${s.recipient}, not the machine wallet ${machine}; only the current recipient can move it. nothing to do.`);
+        return;
+    }
+    if (s.recipient.toLowerCase() === to.toLowerCase()) {
+        say(`${to} is already the recipient; nothing to do.`);
+        return;
+    }
+    const o = await owed(machine);
+    const fmt = (v) => Number(formatUnits(v, cfg.pairDecimals)).toFixed(4);
+    say(`credited to the machine wallet: ${fmt(o.pair)} ${cfg.pairSymbol}${o.token > 0n ? ` and ${Number(formatUnits(o.token, 18)).toFixed(0)} ${cfg.tokenSymbol}` : ''}; ${o.pair > 0n || o.token > 0n ? 'claiming first' : 'nothing to claim first'}`);
+    const mode = cfg.dry ? 'dry run' : cfg.key ? 'live' : 'no key';
+    say(`${mode}: ${cfg.dry || !cfg.key ? 'simulating' : 'sending'} the recipient move ${machine} -> ${to}`);
+    let r;
+    try {
+        r = await handback(to);
+    }
+    catch (e) {
+        throw new Error(`handback stopped: ${reason(e)}`);
+    }
+    if (r.claimed)
+        say(`claimed: ${cfg.explorer}/tx/${r.claimed}`);
+    if (r.moved)
+        say(`recipient moved: ${cfg.explorer}/tx/${r.moved}`);
+    if (!r.claimed && !r.moved)
+        say(`simulation passed; nothing was sent (${mode}). run without CLOCKWORK_DRY_RUN and with MACHINE_WALLET_KEY to do it.`);
+    else
+        say(`done: ${to} receives the fees from here; balances claimed before the move stay in the machine wallet.`);
+}

package/dist/jobs/init.js

@@ -0,0 +1,71 @@
+// clockwork init <token> [--out clockwork.json] [--ops <address>]: reads the launch from the pons factory and
+// writes a config with the chain facts filled in and the client's addresses left to fill. Does not touch env.ts,
+// because the config file does not exist yet.
+import { writeFileSync, existsSync } from 'node:fs';
+import { createPublicClient, http, parseAbi } from 'viem';
+import { CLOCKWORK_ADDRESS, ZERO as ZERO_ADDRESS, isHouse } from '../config.js';
+const FACTORY = '0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e', ESCROW = '0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e', HOOK = '0xE5e702641Ea86F4ae6cC3cDaeD2B886f976Be044', LOCKER = '0x267444D099b10fB5Ed7c3Cc7B7c767AdcA574952', VAULT = '0x42df2a798f82289E177311362e8f5ccC45c1219c';
+const ZERO = '0x0000000000000000000000000000000000000000';
+const FEEDS = { '0x1b0e319c6a659f002271b69db8a7df2f911c153e': '0x27C71df6A64fB476468EdF256CF72c038baB5B67' }; // pairing asset -> chainlink usd feed, when one exists
+const PHASES = ['on the curve', 'swept, pool pending', 'trading in the pool', 'rescued'];
+const factoryAbi = parseAbi([
+    'struct LaunchedToken { address token; address curve; address deployer; address creatorFeeRecipient; address pairToken; uint256 graduationThreshold; uint24 poolFee; int24 tickSpacing; uint16 creatorTaxBps; bool buybackEnabled; uint8 phase; uint256 sweptQuote; uint256 sweptTokens; uint256 sweptAt; bool exists; }',
+    'function getLaunchedToken(address token) view returns (LaunchedToken)',
+    // the factory records decimals per quote asset; a six-decimal stable is not an eighteen-decimal stock
+    'function pairTokenEconomics(address pairToken) view returns (uint256 phantomQuote, uint256 graduationThreshold, uint8 decimals)',
+]);
+const erc20 = parseAbi(['function symbol() view returns (string)', 'function name() view returns (string)', 'function decimals() view returns (uint8)']);
+const isAddr = (a) => /^0x[0-9a-fA-F]{40}$/.test(String(a ?? ''));
+const flag = (name) => { const i = process.argv.indexOf(name); return i > -1 ? process.argv[i + 1] : undefined; };
+export async function runInit() {
+    const token = process.argv[3];
+    if (!isAddr(token))
+        throw new Error('usage: clockwork init <token address> [--out clockwork.json] [--ops <address>]');
+    const out = flag('--out') || 'clockwork.json';
+    if (existsSync(out))
+        throw new Error(`${out} already exists; move it first`);
+    const ops = flag('--ops');
+    if (ops !== undefined && !isAddr(ops))
+        throw new Error('--ops needs an address');
+    const pub = createPublicClient({ transport: http(process.env.RPC_URL || 'https://rpc.mainnet.chain.robinhood.com', { retryCount: 4, retryDelay: 1000 }) });
+    let lt = null;
+    try {
+        lt = await pub.readContract({ address: FACTORY, abi: factoryAbi, functionName: 'getLaunchedToken', args: [token] });
+    }
+    catch { }
+    if (!lt?.exists)
+        throw new Error('this token was not launched by the pons v2 factory; pass --pair <address> support is next');
+    // a zero pairToken is a native launch: quoted in eth, no erc20 to ask, no usd feed to pin
+    const native = /^0x0{40}$/i.test(String(lt.pairToken));
+    const [tSym, tName] = await Promise.all([pub.readContract({ address: token, abi: erc20, functionName: 'symbol' }), pub.readContract({ address: token, abi: erc20, functionName: 'name' })]);
+    let pair = { address: ZERO, symbol: 'ETH', decimals: 18, native: true };
+    if (!native) {
+        const p = lt.pairToken;
+        const [pSym, econ] = await Promise.all([pub.readContract({ address: p, abi: erc20, functionName: 'symbol' }), pub.readContract({ address: FACTORY, abi: factoryAbi, functionName: 'pairTokenEconomics', args: [p] })]);
+        pair = { address: p, symbol: pSym, decimals: Number(econ[2]), ...(FEEDS[p.toLowerCase()] ? { usdFeed: FEEDS[p.toLowerCase()] } : {}) };
+    }
+    // the house does not pay itself; everyone else pays the service share, which needs the service wallet pinned in this build
+    const house = isHouse(token);
+    const unpinned = !house && CLOCKWORK_ADDRESS === ZERO_ADDRESS;
+    const cfg = {
+        version: 1, chain: { id: 4663 },
+        token: { address: token, symbol: tSym, name: tName, supply: 1000000000 },
+        pair,
+        launch: { kind: 'pons-v2', factory: FACTORY, feeEscrow: ESCROW, hook: HOOK, locker: LOCKER, vault: VAULT, launchBlock: 0 },
+        wallets: { machine: '0x_FILL_ME_the_fresh_machine_wallet', treasury: '0x_FILL_ME_your_treasury', ...(ops ? { ops } : {}) },
+        split: house ? { burnBps: 5000, treasuryBps: 5000, opsBps: 0, serviceBps: 0 } : { burnBps: 4500, treasuryBps: 4500, opsBps: 0, serviceBps: 1000 },
+        schedule: { cadenceMin: 15, weekends: true, napUntil: null },
+        slices: { rule: { kind: 'pace', pace: 'steady' }, dip: { on: false, bandBps: 1000, multiplier: 2 }, quoteSanityBps: 1500, maxSlippageBps: 300 },
+        burn: { method: 'burn' }, buyback: { vest: 'burn' }, claim: { mode: 'auto' },
+        telegram: { mode: 'shared', cards: { claim: true, slice: true, percent: true, buys: false }, buyFloorUsd: 50 },
+        site: { enabled: true, modules: ['treasury', 'burns', 'holders', 'seats', 'wallet', 'rank', 'ledger'], seatThreshold: 250000 },
+        brand: { name: tName, treasuryWord: 'treasury', burnWord: 'burn', accent: '#3DFF8E' },
+    };
+    writeFileSync(out, JSON.stringify(cfg, null, 1) + '\n');
+    console.log(`wrote ${out}: ${tName} (${tSym}) paired with ${pair.symbol}${native ? ' (native)' : ` at ${pair.address}`}, ${PHASES[Number(lt.phase)] ?? `phase ${lt.phase}`}, buybacks ${lt.buybackEnabled ? 'on' : 'off'}.`);
+    // where fees go today. the machine claims only once the founder points this at the machine wallet (claim the old balance first).
+    console.log(`creator fees go to ${lt.creatorFeeRecipient} right now${String(lt.creatorFeeRecipient).toLowerCase() === String(lt.deployer).toLowerCase() ? ' (the deployer)' : ''}.`);
+    console.log(`fill in the machine and treasury wallets${ops ? '' : ' (add wallets.ops if you want an ops share)'}, then run: clockwork dry`);
+    if (unpinned)
+        console.log('note: this build of clockwork-press has no service wallet pinned, so a file with a service share will not load until the package is updated. the house token runs with serviceBps 0.');
+}

package/dist/jobs/launchcheck.js

@@ -0,0 +1,82 @@
+// Launch morning, one command: every pre-launch read from GO.md phase 3, plus
+// the exact launchAndBuy parameters printed ready to sign. This job only
+// reads the chain and prints; the founder's wallet does the signing.
+import { formatUnits, toHex } from 'viem';
+import { parseAbi } from 'viem';
+import { cfg } from '../env.js';
+import { pub } from '../chain.js';
+import { readLaunch } from '../pons.js';
+const launchAbi = parseAbi([
+    'struct LaunchConfig { uint256 supply; uint256 curveFeeBps; uint256 phantomQuote; uint256 graduationThreshold; uint24 poolFee; int24 tickSpacing; bool enabled; }',
+    'function canLaunch(address) view returns (bool)',
+    'function launchFee() view returns (uint256)',
+    'function maxCreatorTaxBps() view returns (uint16)',
+    'function launchConfigCount() view returns (uint256)',
+    'function getLaunchConfig(uint256 id) view returns (LaunchConfig)',
+    'function approvedPairTokens(address) view returns (bool)',
+    'function pairTokenEconomics(address) view returns (uint256 phantomQuote, uint256 graduationThreshold, uint8 decimals)',
+    'function previewLaunchEconomics(uint256 launchConfigId, address pairToken) view returns (bytes32)',
+]);
+const ok = (l, d = '') => console.log(`  ✓ ${l}${d ? ` — ${d}` : ''}`);
+const bad = (l, d = '') => console.log(`  ✗ ${l}${d ? ` — ${d}` : ''}`);
+export async function runLaunchCheck() {
+    const founder = (process.env.FOUNDER_ADDRESS ?? '');
+    const read = (functionName, args = []) => pub.readContract({ address: cfg.factory, abi: launchAbi, functionName, args });
+    console.log('launch check — gmerald, paired with gme, config 0\n');
+    let go = true;
+    // already launched? the factory record says so; the rest of this check is for the morning before.
+    const live = await readLaunch();
+    if (live.exists)
+        ok('already launched', `phase ${live.phase} (${live.phaseWord})${live.graduationPct != null ? `, ${live.graduationPct.toFixed(1)}% to graduation` : ''}, fees to ${live.recipient}`);
+    if (founder) {
+        const can = await read('canLaunch', [founder]);
+        can ? ok('canLaunch(founder)') : ((go = false), bad('canLaunch(founder)', 'gate closed for this address'));
+    }
+    else {
+        const can = await read('canLaunch', ['0x000000000000000000000000000000000000dEaD']);
+        can
+            ? ok('public launch gate open', 'set FOUNDER_ADDRESS to check your wallet specifically')
+            : ((go = false), bad('public gate closed', 'whitelist only right now — set FOUNDER_ADDRESS and re-run'));
+    }
+    const config = await read('getLaunchConfig', [0n]);
+    config.enabled ? ok('config 0 enabled', `curve fee ${config.curveFeeBps} bps`) : ((go = false), bad('config 0 DISABLED'));
+    const approved = await read('approvedPairTokens', [cfg.gme]);
+    approved ? ok('gme approved as pair') : ((go = false), bad('gme pair approval REVOKED'));
+    const econ = await read('pairTokenEconomics', [cfg.gme]);
+    econ[1] > 0n
+        ? ok('gme pair economics', `phantom ${formatUnits(econ[0], 18)} gme, graduation ${formatUnits(econ[1], 18)} gme`)
+        : ((go = false), bad('gme pair economics empty'));
+    const maxTax = await read('maxCreatorTaxBps');
+    Number(maxTax) >= 200 ? ok('2% creator tax under cap', `cap ${maxTax} bps`) : ((go = false), bad('cap below 200 bps'));
+    const [fee, pin] = await Promise.all([
+        read('launchFee'),
+        read('previewLaunchEconomics', [0n, cfg.gme]),
+    ]);
+    ok('launch fee', `${formatUnits(fee, 18)} ETH (sent as value)`);
+    ok('economics pin (read NOW, use NOW)', pin);
+    const salt = toHex(crypto.getRandomValues(new Uint8Array(32)));
+    console.log(`\n${go ? 'ALL CLEAR.' : 'BLOCKED — fix the ✗ lines first.'} launchAndBuy args, ready to sign:\n`);
+    console.log(JSON.stringify({
+        params: {
+            name: 'Gmerald',
+            symbol: 'GMERALD',
+            logo: 'ipfs://<pin the head mark first>',
+            description: 'He buys GameStop and burns himself. Every 4 hours. Forever.',
+            socials: { twitter: 'https://x.com/gmeraldexe', telegram: 'https://t.me/GMERALDportal', discord: '', website: 'https://gmerald.xyz', farcaster: '' },
+            creatorFeeRecipient: founder || '<FOUNDER WALLET — never the press wallet>',
+            creatorTaxBps: 200,
+            buybackEnabled: false,
+            expectedEconomics: pin,
+            salt,
+        },
+        launchConfigId: 0,
+        pairToken: cfg.gme,
+        quoteIn: '<opening buy, in gme wei — the pre-announced size>',
+        minTokensOut: '<from the quoted rate, slippage-adjusted>',
+        recipient: founder || '<FOUNDER WALLET>',
+        snipeTaxExemptions: [],
+    }, null, 2));
+    console.log('\nremember: ERC-20 pair, so approve the launchAndBuy router for quoteIn first,');
+    console.log('and send ONLY the launch fee as value. the pin above goes stale if pons edits');
+    console.log('the config — re-run this check immediately before signing.');
+}

package/dist/jobs/log.js

@@ -0,0 +1,50 @@
+// Record a MANUAL press so the site's ledger and status bar reflect it.
+// Usage (from press/):
+//   npx tsx src/index.ts log --burned 1234567 --stashed 12.5 --burn-tx 0x.. --stash-tx 0x.. [--gme-spent 12.5] [--ops 2.7] [--note "pressed by hand"]
+// Then commit and push site/press-ledger.json + site/press-stats.json.
+import { formatUnits } from 'viem';
+import { cfg } from '../env.js';
+import { pub } from '../chain.js';
+import { erc20Abi } from '../abis.js';
+import { appendPress, writeStats, burnGmeTotal, totals } from '../ledger.js';
+import { checkPeg } from '../peg.js';
+const arg = (k, d = '') => { const i = process.argv.indexOf(`--${k}`); return i > -1 ? (process.argv[i + 1] ?? d) : d; };
+export async function runLog() {
+    const burned = arg('burned', '0'), stashed = arg('stashed', '0'), spent = arg('gme-spent', stashed), ops = arg('ops', '0');
+    const peg = await checkPeg();
+    const entry = appendPress({
+        kind: arg('kind', 'press'),
+        note: arg('note', 'pressed by hand'),
+        burnedGmerald: Number(burned).toFixed(0),
+        burnGmeSpent: Number(spent).toFixed(4),
+        stashedGme: Number(stashed).toFixed(4),
+        opsMovedGme: Number(ops).toFixed(4),
+        pegStatus: peg.status,
+        burnTx: arg('burn-tx') || undefined,
+        stashTx: arg('stash-tx') || undefined,
+        gmeUsd: peg.fairUsd && peg.fairUsd > 0 ? peg.fairUsd : undefined,
+    });
+    let burnedPct = '0.00', stashGme = 0;
+    if (cfg.token) {
+        const supply = await pub.readContract({ address: cfg.token, abi: erc20Abi, functionName: 'totalSupply' });
+        burnedPct = ((Number(10n ** 27n - supply) / 1e27) * 100).toFixed(2);
+    }
+    if (cfg.stash) {
+        const bal = await pub.readContract({ address: cfg.gme, abi: erc20Abi, functionName: 'balanceOf', args: [cfg.stash] });
+        stashGme = Number(formatUnits(bal, 18));
+    }
+    else {
+        stashGme = totals().stashedGme;
+    }
+    const queued = await pub.readContract({ address: cfg.gme, abi: erc20Abi, functionName: 'balanceOf', args: [cfg.pressWallet] });
+    const slice = Number(cfg.pressSliceGme) || 20, slicesLeft = Math.ceil(Number(formatUnits(queued, 18)) / slice);
+    const status = Number(formatUnits(queued, 18)) >= Number(cfg.minPressGme) ? `snacking. ${slicesLeft} slice${slicesLeft === 1 ? '' : 's'} of ${slice} gme to go` : 'napping between claims';
+    writeStats({
+        presses: totals().press, snacks: totals().snack, burnedPct, stashGme: stashGme.toFixed(2),
+        gmeSunk: (stashGme + burnGmeTotal() + Number(cfg.gradSeedGme)).toFixed(2),
+        status, queuedGme: formatUnits(queued, 18), updatedAt: entry.ts, checkedAt: entry.ts,
+        cadenceMin: cfg.cadenceMin,
+        peg: { status: peg.status, premiumBps: peg.premiumBps, tokenUsd: peg.tokenUsd, fairUsd: peg.fairUsd, note: peg.note },
+    });
+    console.log(`[log] press #${entry.n} recorded. commit site/press-ledger.json + site/press-stats.json and push.`);
+}

package/dist/jobs/quotecheck.js

@@ -0,0 +1,45 @@
+// Launch-day confidence: find a recent live pons launch and run our quote
+// arithmetic against its real curve. If this prints a sane quote, the burn
+// leg's math matches the chain.
+import { parseAbiItem, formatUnits } from 'viem';
+import { cfg } from '../env.js';
+import { pub } from '../chain.js';
+import { factoryAbi, curveAbi } from '../abis.js';
+import { quoteBuy } from '../quote.js';
+export async function runQuoteCheck() {
+    const latest = await pub.getBlockNumber();
+    const span = 200000n;
+    console.log(`scanning TokenLaunched over the last ${span} blocks...`);
+    const logs = await pub.getLogs({
+        address: cfg.factory,
+        event: parseAbiItem('event TokenLaunched(address indexed token, address indexed curve, address indexed deployer, address pairToken, uint256 launchConfigId, uint256 graduationThreshold)'),
+        fromBlock: latest > span ? latest - span : 0n,
+        toBlock: latest,
+    });
+    console.log(`found ${logs.length} launches`);
+    for (const log of logs.reverse()) {
+        const token = log.args.token;
+        const rec = await pub.readContract({
+            address: cfg.factory, abi: factoryAbi, functionName: 'getLaunchedToken', args: [token],
+        });
+        if (rec.phase !== 0)
+            continue;
+        const ready = await pub.readContract({
+            address: rec.curve, abi: curveAbi, functionName: 'readyToGraduate',
+        });
+        if (ready)
+            continue;
+        const oneUnit = 10n ** 18n;
+        const q = await quoteBuy(rec.curve, oneUnit, '0x000000000000000000000000000000000000dEaD');
+        console.log(`\nlive curve: ${rec.curve} (token ${token}, pair ${rec.pairToken})`);
+        console.log(`  quote for 1.0 pair-unit in:`);
+        console.log(`  tokens out : ${formatUnits(q.tokensOut, 18)}`);
+        console.log(`  spent      : ${formatUnits(q.spent, 18)} (refund ${formatUnits(q.refund, 18)})`);
+        console.log(`  snipe bps  : ${q.snipeBps}`);
+        if (q.tokensOut <= 0n)
+            throw new Error('quote produced zero out — investigate before launch');
+        console.log('\nquote math verified against a live curve.');
+        return;
+    }
+    console.log('no phase-0 curve found in range — widen the span or check factory activity.');
+}

package/dist/jobs/tgcheck.js

@@ -0,0 +1,32 @@
+// Prints what the telegram bot can see: itself, and every chat it has been added to.
+// Run it once after `gh secret set TELEGRAM_BOT_TOKEN` to learn the burrow's chat id
+// without adding any third-party "get id" bot to the group.
+import { cfg } from '../env.js';
+export async function runTgCheck() {
+    if (!cfg.tgToken) {
+        console.log('[tgcheck] TELEGRAM_BOT_TOKEN not set');
+        return;
+    }
+    const api = (m) => fetch(`https://api.telegram.org/bot${cfg.tgToken}/${m}`).then(r => r.json());
+    const me = await api('getMe');
+    if (!me.ok) {
+        console.log(`[tgcheck] token rejected: ${JSON.stringify(me)}`);
+        return;
+    }
+    console.log(`[tgcheck] bot: @${me.result.username} (${me.result.first_name})`);
+    const upd = await api('getUpdates?limit=100&allowed_updates=["message","my_chat_member","channel_post"]');
+    const chats = new Map();
+    for (const u of upd.result ?? []) {
+        const c = u.message?.chat ?? u.my_chat_member?.chat ?? u.channel_post?.chat;
+        if (c)
+            chats.set(String(c.id), `${c.type} · ${c.title ?? c.username ?? ''}`);
+    }
+    if (chats.size === 0)
+        console.log('[tgcheck] no chats seen yet. add the bot to the group as an admin, post one message there, run again.');
+    for (const [id, d] of chats)
+        console.log(`[tgcheck] chat ${id}  ${d}`);
+    if (cfg.tgChat) {
+        const r = await api(`getChat?chat_id=${cfg.tgChat}`);
+        console.log(`[tgcheck] TELEGRAM_CHAT_ID=${cfg.tgChat}: ${r.ok ? `${r.result.type} · ${r.result.title} (ok)` : JSON.stringify(r)}`);
+    }
+}