clockwork-press 0.0.1 → 0.2.1

package/dist/ledger.js

@@ -0,0 +1,97 @@
+// The site's live data: press-ledger.json (every press, forever) and
+// press-stats.json (the status-bar numbers). The workflow commits both after
+// a press, Vercel redeploys, and the terminal reads them — nothing is
+// reported, it is read.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { cfg } from './env.js';
+import { boardSeats } from './holders.js';
+import { readRank } from './gmerank.js';
+export function costBasis() {
+    let sc = 0, sg = 0, fc = 0, tg = 0;
+    for (const p of readArchive()) {
+        const st = Number(p.stashedGme || 0), fed = Number(p.burnGmeSpent || 0), px = Number(p.gmeUsd || 0);
+        tg += st;
+        if (px > 0) {
+            sc += st * px;
+            sg += st;
+            fc += fed * px;
+        }
+    }
+    const r = (x) => Math.round(x * 100) / 100;
+    return { stashCostUsd: r(sc), stashAvgUsd: sg > 0 ? r(sc / sg) : 0, fedCostUsd: r(fc), pricedGme: r(sg), totalGme: r(tg) };
+}
+const ledgerPath = () => join(cfg.siteDir, 'press-ledger.json');
+export const statsPath = () => join(cfg.siteDir, "press-stats.json");
+const archivePath = () => join(cfg.siteDir, 'press-ledger-all.json');
+function readArchive() {
+    try {
+        return JSON.parse(readFileSync(archivePath(), 'utf8')).presses;
+    }
+    catch {
+        return readLedger().presses;
+    }
+}
+function sumTotals(all) {
+    const t = { press: 0, snack: 0, burnGme: 0, stashedGme: 0, burnedGmerald: 0 };
+    for (const p of all) {
+        t[(p.kind ?? 'press')]++;
+        t.burnGme += Number(p.burnGmeSpent || 0);
+        t.stashedGme += Number(p.stashedGme || 0);
+        t.burnedGmerald += Number(p.burnedGmerald || 0);
+    }
+    return t;
+}
+export const totals = () => readLedger().totals ?? sumTotals(readArchive());
+// Per-day rollup of snacks (utc days), last 7 days, for the site's today/yesterday lines.
+export function dailyRollup() {
+    const out = {};
+    for (const p of readArchive()) {
+        if (p.kind !== 'snack')
+            continue;
+        const d = p.ts.slice(0, 10);
+        out[d] ??= { snacks: 0, gme: 0, burned: 0 };
+        out[d].snacks++;
+        out[d].gme += Number(p.burnGmeSpent || 0);
+        out[d].burned += Number(p.burnedGmerald || 0);
+    }
+    return Object.fromEntries(Object.entries(out).sort().slice(-7));
+}
+const RECENT_SNACKS = 48, RECENT_PRESSES = 12;
+export function readLedger() {
+    try {
+        return JSON.parse(readFileSync(ledgerPath(), 'utf8'));
+    }
+    catch {
+        return { presses: [] };
+    }
+}
+export function writeLedger(ledger) { writeFileSync(ledgerPath(), JSON.stringify(ledger, null, 1)); }
+export const countKind = (kind) => totals()[kind];
+export const hasTx = (tx) => readArchive().some((p) => p.stashTx === tx || p.burnTx === tx);
+export function appendPress(entry) {
+    const all = readArchive();
+    const kind = entry.kind ?? 'press';
+    const full = {
+        n: all.length + 1,
+        ts: new Date().toISOString(),
+        explorer: cfg.explorer,
+        ...entry,
+        kind,
+        k: all.filter((p) => (p.kind ?? 'press') === kind).length + 1,
+    };
+    all.push(full);
+    writeFileSync(archivePath(), JSON.stringify({ presses: all }, null, 1));
+    const ledger = readLedger();
+    const presses = all.filter((p) => (p.kind ?? 'press') === 'press').slice(-RECENT_PRESSES);
+    const snacks = all.filter((p) => p.kind === 'snack').slice(-RECENT_SNACKS);
+    ledger.presses = [...presses, ...snacks].sort((a, b) => a.n - b.n);
+    ledger.totals = sumTotals(all);
+    writeFileSync(ledgerPath(), JSON.stringify(ledger, null, 1));
+    return full;
+}
+export function writeStats(stats) {
+    writeFileSync(statsPath(), JSON.stringify({ ...stats, seats: boardSeats(), gmeRank: readRank(), basis: costBasis() }, null, 1));
+}
+// Cumulative GME the burns pushed into the curve/pool — part of "GME sunk".
+export function burnGmeTotal() { return totals().burnGme; }

package/dist/market.js

@@ -0,0 +1,19 @@
+export async function readMarket(poolId) {
+    try {
+        const res = await fetch(`https://api.dexscreener.com/latest/dex/pairs/robinhood/${poolId}`);
+        if (!res.ok)
+            return null;
+        const j = (await res.json());
+        const p = (j.pairs ?? [j.pair])[0];
+        if (!p?.priceNative)
+            return null;
+        const now = Number(p.priceNative);
+        const ch = p.priceChange ?? {};
+        const at = (k) => (ch[k] == null ? now : now / (1 + Number(ch[k]) / 100));
+        const high = Math.max(now, at('h1'), at('h6'), at('h24'));
+        return { priceGme: now, recentHighGme: high, vsHighBps: Math.round((now / high - 1) * 10000), h1: Number(ch.h1 ?? 0) };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/peg.js

@@ -0,0 +1,56 @@
+// The ops-leg gate: "never a forced seller." Fair value comes from the
+// Chainlink tokenized-equity feed; the on-chain token price comes from
+// dexscreener (keyless). When either half is unavailable the answer is
+// 'unchecked' and the caller HOLDS the ops slice — the conservative default.
+import { cfg } from './env.js';
+import { pub } from './chain.js';
+import { feedAbi } from './abis.js';
+// the pools that can set the token price: the stock token as base, a dollar as quote, real depth
+const USD = new Set(['USDG', 'USDC', 'USDT', 'USD1', 'DAI']);
+export async function checkPeg() {
+    if (!cfg.pegFeed)
+        return { status: 'unchecked', note: 'PEG_FEED_ADDRESS not set' };
+    try {
+        const [round, dec] = await Promise.all([
+            pub.readContract({ address: cfg.pegFeed, abi: feedAbi, functionName: 'latestRoundData' }),
+            pub.readContract({ address: cfg.pegFeed, abi: feedAbi, functionName: 'decimals' }),
+        ]);
+        const fairUsd = Number(round[1]) / 10 ** Number(dec);
+        const feedAt = Number(round[3]);
+        if (!(fairUsd > 0))
+            return { status: 'unchecked', note: 'feed returned no price' };
+        const res = await fetch(`https://api.dexscreener.com/latest/dex/tokens/${cfg.gme}`);
+        if (!res.ok)
+            return { status: 'unchecked', note: `dexscreener ${res.status}`, fairUsd };
+        const data = (await res.json());
+        const pairs = (data.pairs ?? []).filter((p) => p.priceUsd && p.baseToken?.address?.toLowerCase() === cfg.gme.toLowerCase()
+            && USD.has((p.quoteToken?.symbol ?? '').toUpperCase()) && (p.liquidity?.usd ?? 0) >= 20000);
+        if (!pairs.length)
+            return { status: 'unchecked', note: 'no usd pools for the stock token', fairUsd, feedAt };
+        // weighted by the hour's volume, so a pool nobody traded in cannot set the price; the deepest pool if nothing traded
+        let num = 0, den = 0, n = 0;
+        for (const p of pairs) {
+            const w = p.volume?.h1 ?? 0;
+            if (w > 0) {
+                num += Number(p.priceUsd) * w;
+                den += w;
+                n++;
+            }
+        }
+        pairs.sort((a, b) => (b.liquidity?.usd ?? 0) - (a.liquidity?.usd ?? 0));
+        const tokenUsd = den > 0 ? num / den : Number(pairs[0].priceUsd);
+        const source = den > 0 ? `${n} pool${n === 1 ? '' : 's'}, weighted by the hour's volume` : 'deepest pool, no trades this hour';
+        const premiumBps = Math.round((tokenUsd / fairUsd - 1) * 10000);
+        const status = premiumBps >= -cfg.pegToleranceBps ? 'at-or-above' : 'below';
+        return {
+            status,
+            fairUsd,
+            tokenUsd,
+            premiumBps, feedAt, source,
+            note: `token $${tokenUsd.toFixed(2)} (${source}) vs fair $${fairUsd.toFixed(2)} (chainlink ${new Date(feedAt * 1000).toISOString().slice(11, 16)} utc): ${premiumBps >= 0 ? '+' : ''}${(premiumBps / 100).toFixed(2)}%`,
+        };
+    }
+    catch (e) {
+        return { status: 'unchecked', note: `peg check failed: ${e.message}` };
+    }
+}

package/dist/pons.js

@@ -0,0 +1,203 @@
+// pons v2, read and written from one place: where the launch is, who the fees point at, what is unswept
+// on the curve or the hook, what the escrow has credited, the buyback vest, and the handback.
+// money in and out is raw units of the asset (bigint); callers format with cfg.pairDecimals.
+// nothing here signs without a key: every writer checks cfg.key and cfg.dry before touching wallet().
+import { keccak256, encodeAbiParameters, BaseError, ContractFunctionRevertedError } from 'viem';
+import { cfg } from './env.js';
+import { pub, wallet } from './chain.js';
+import { factoryAbi, curveAbi, hookAbi, escrowAbi, vaultAbi } from './abis.js';
+import { poolKey } from './v4.js';
+// the hook and the vault come from env.ts (clockwork.json's launch.hook / launch.vault, or the shared pons v2
+// addresses on robinhood chain when the file does not name them), the same place the factory and escrow live.
+const ZERO = '0x0000000000000000000000000000000000000000';
+const token = () => cfg.token;
+const escrow = () => cfg.escrow;
+// a launch quoted in native eth has the zero address as its pair; the escrow keeps a separate ledger for it.
+const pairNative = () => cfg.pairNative;
+const PHASE = ['curve', 'swept', 'pool', 'rescued'];
+// the standard uniswap v4 pool id: keccak of the abi-encoded PoolKey. the key is the one v4.ts swaps
+// through (currencies sorted, fee 0, the record's tick spacing, the pons hook), so the id the hook
+// reports pendings under is the id the press trades on.
+export function poolIdFor(t) {
+    const k = poolKey(t);
+    return keccak256(encodeAbiParameters([{ type: 'address' }, { type: 'address' }, { type: 'uint24' }, { type: 'int24' }, { type: 'address' }], [k.currency0, k.currency1, k.fee, k.tickSpacing, k.hooks]));
+}
+// a revert, in words a founder can act on. viem decodes the custom error when the abi names it and
+// otherwise hands back the bare selector.
+export function reason(e) {
+    let name = '', sig = '';
+    if (e instanceof BaseError) {
+        const r = e.walk((x) => x instanceof ContractFunctionRevertedError);
+        name = r?.data?.errorName ?? '';
+        sig = r?.signature ?? '';
+    }
+    if (name === 'InternalSwapRequiresOperator')
+        return 'waiting on pons: the sweep needs the operator';
+    if (name === 'NotCreatorFeeRecipient')
+        return 'the machine wallet is not the fee recipient';
+    if (name === 'NotVestBeneficiary')
+        return 'the machine wallet is not the vest beneficiary';
+    if (name)
+        return `reverted: ${name}`;
+    if (sig)
+        return `reverted with ${sig} (the contract refused; the caller is likely not the creator or the operator)`;
+    const m = e?.shortMessage || e?.message || String(e);
+    return String(m).split('\n')[0];
+}
+export async function readLaunch() {
+    const [lt, pend] = await Promise.all([
+        pub.readContract({ address: cfg.factory, abi: factoryAbi, functionName: 'getLaunchedToken', args: [token()] }),
+        pub.readContract({ address: cfg.factory, abi: factoryAbi, functionName: 'pendingCreatorFeeRecipient', args: [token()] }),
+    ]);
+    const phase = (lt.phase <= 3 ? lt.phase : 3);
+    let graduationPct = null;
+    if (lt.exists && phase === 0) {
+        // progress along the curve: what has really been paid in against the threshold, capped at 100
+        const raised = await pub.readContract({ address: lt.curve, abi: curveAbi, functionName: 'realQuoteReserve' });
+        graduationPct = lt.graduationThreshold > 0n ? Math.min(100, Number((raised * 10000n) / lt.graduationThreshold) / 100) : 0;
+    }
+    const [to, effectiveAt, expiresAt] = pend;
+    return {
+        exists: lt.exists, phase, phaseWord: PHASE[phase], graduationPct,
+        curve: lt.curve, recipient: lt.creatorFeeRecipient,
+        pending: to.toLowerCase() === ZERO && effectiveAt === 0n ? null : { to, effectiveAt: Number(effectiveAt), expiresAt: Number(expiresAt) },
+        buybackEnabled: lt.buybackEnabled, pairToken: lt.pairToken,
+    };
+}
+// what has been earned but not yet swept into the escrow, in the pair currency. quote is the pool or curve
+// fee before pons splits it (protocol / buyback / creator), tax is the creator tax, all of which is the
+// creator's. tokenSide is fees denominated in the launch token: only the operator can convert those.
+export async function unswept(s) {
+    const zero = { quote: 0n, tax: 0n, total: 0n, tokenSide: 0n };
+    try {
+        if (!s.exists)
+            return zero;
+        if (s.phase === 0) {
+            const [quote, tax] = await Promise.all([
+                pub.readContract({ address: s.curve, abi: curveAbi, functionName: 'quoteFeeBalance' }),
+                pub.readContract({ address: s.curve, abi: curveAbi, functionName: 'creatorTaxBalance' }),
+            ]);
+            return { quote, tax, total: quote + tax, tokenSide: 0n };
+        }
+        if (s.phase === 2) {
+            const id = poolIdFor(token());
+            const read = (fn, cur) => pub.readContract({ address: cfg.hook, abi: hookAbi, functionName: fn, args: [id, cur] });
+            const [quote, tax, tf, tt] = await Promise.all([read('pendingFees', cfg.gme), read('pendingCreatorTax', cfg.gme), read('pendingFees', token()), read('pendingCreatorTax', token())]);
+            return { quote, tax, total: quote + tax, tokenSide: tf + tt };
+        }
+        return zero;
+    }
+    catch (e) {
+        console.log(`[pons] unswept read failed: ${reason(e)}`);
+        return zero;
+    }
+}
+async function waitTx(hash) {
+    const rcpt = await pub.waitForTransactionReceipt({ hash });
+    if (rcpt.status !== 'success')
+        throw new Error(`tx reverted: ${hash}`);
+    return hash;
+}
+// can this run sign? dry runs and keyless runs read and simulate only.
+const canWrite = () => !!cfg.key && !cfg.dry;
+// the sweep the creator may do itself: sweepFees(0) on the curve, sweepPoolFees(poolId, 0, 0) on the hook.
+// simulated first from the machine wallet; pons refuses with InternalSwapRequiresOperator when a buyback
+// or a launch-token conversion is involved, and that is not a failure, it is a wait.
+// send: false is the diagnostic path (claimcheck): it says whether the sweep would pass and never signs.
+// onSend runs once the simulation passed and a transaction is about to go out (the press stamps lastRunAt there).
+export async function trySweep(s, opts = {}) {
+    if (!s.exists)
+        return { swept: false, reason: 'no launch record' };
+    const call = s.phase === 0
+        ? { address: s.curve, abi: curveAbi, functionName: 'sweepFees', args: [0n] }
+        : s.phase === 2
+            ? { address: cfg.hook, abi: hookAbi, functionName: 'sweepPoolFees', args: [poolIdFor(token()), 0n, 0n] }
+            : null;
+    if (!call)
+        return { swept: false, reason: `nothing to sweep in phase ${s.phaseWord}` };
+    try {
+        await pub.simulateContract({ ...call, account: cfg.pressWallet });
+    }
+    catch (e) {
+        return { swept: false, reason: reason(e) };
+    }
+    if (opts.send === false)
+        return { swept: false, reason: 'the sweep would pass; this job only reads, so it is not sent' };
+    if (!canWrite())
+        return { swept: false, reason: cfg.dry ? 'dry: the sweep would pass, not sent' : 'no key: the sweep would pass, not sent' };
+    try {
+        opts.onSend?.();
+        const tx = await waitTx(await wallet().writeContract({ ...call }));
+        return { swept: true, tx };
+    }
+    catch (e) {
+        return { swept: false, reason: reason(e) };
+    }
+}
+// what the escrow has credited to a recipient: the pair ledger (native or per-token) and the launch-token
+// ledger, where released vests land.
+export async function owed(recipient) {
+    if (!cfg.escrow)
+        return { pair: 0n, token: 0n };
+    const [pair, tok] = await Promise.all([
+        pairNative()
+            ? pub.readContract({ address: escrow(), abi: escrowAbi, functionName: 'balanceOf', args: [recipient] })
+            : pub.readContract({ address: escrow(), abi: escrowAbi, functionName: 'balanceOfToken', args: [recipient, cfg.gme] }),
+        pub.readContract({ address: escrow(), abi: escrowAbi, functionName: 'balanceOfToken', args: [recipient, token()] }),
+    ]);
+    return { pair, token: tok };
+}
+const claimCall = () => pairNative()
+    ? { address: escrow(), abi: escrowAbi, functionName: 'claim' }
+    : { address: escrow(), abi: escrowAbi, functionName: 'claimToken', args: [cfg.gme] };
+const claimTokenCall = () => ({ address: escrow(), abi: escrowAbi, functionName: 'claimToken', args: [token()] });
+// a write, or in dry mode the simulation of it. null when nothing was sent. the simulation runs first in
+// every mode, so a call the contract would refuse (NotVestBeneficiary, NotCreatorFeeRecipient) throws a
+// decoded reason before anything is signed; callers on the press path catch it and carry on.
+async function write(call, what) {
+    await pub.simulateContract({ ...call, account: cfg.pressWallet });
+    if (!canWrite()) {
+        console.log(`[pons] ${cfg.dry ? 'dry' : 'no key'}: would ${what}`);
+        return null;
+    }
+    return waitTx(await wallet().writeContract({ ...call }));
+}
+export async function claimPair() {
+    if (!cfg.escrow)
+        return null;
+    return write(claimCall(), `claim the ${cfg.pairSymbol} the escrow holds for the machine wallet`);
+}
+// the buyback vest: zeros when the launch has buybacks off, else what the vault can release now and what
+// an earlier release already credited in the escrow under the launch token.
+export async function vestStatus(s) {
+    const st = s ?? await readLaunch();
+    if (!st.exists || !st.buybackEnabled)
+        return { releasable: 0n, escrowToken: 0n };
+    const [releasable, o] = await Promise.all([
+        pub.readContract({ address: cfg.vault, abi: vaultAbi, functionName: 'releasable', args: [token()] }),
+        owed(cfg.pressWallet),
+    ]);
+    return { releasable, escrowToken: o.token };
+}
+export async function releaseVest() {
+    return write({ address: cfg.vault, abi: vaultAbi, functionName: 'release', args: [token()] }, 'release the buyback vest');
+}
+export async function claimVestTokens() {
+    if (!cfg.escrow)
+        return null;
+    return write(claimTokenCall(), `claim the ${cfg.tokenSymbol} the escrow holds from released vests`);
+}
+// hand the fees back: claim what is already credited (a transfer does not move it), then move the
+// recipient. only the current recipient may call; the machine must be it.
+export async function handback(to) {
+    const o = cfg.escrow ? await owed(cfg.pressWallet) : { pair: 0n, token: 0n };
+    let claimed = null;
+    if (o.pair > 0n)
+        claimed = await claimPair();
+    if (o.token > 0n) {
+        const t = await claimVestTokens();
+        claimed = claimed ?? t;
+    }
+    const moved = await write({ address: cfg.factory, abi: factoryAbi, functionName: 'transferCreatorFeeRecipient', args: [token(), to] }, `move the fee recipient from ${cfg.pressWallet} to ${to}`);
+    return { claimed, moved };
+}