@pickhooks/sdk 0.0.0-stage → 0.4.0

package/dist/sticky-sim.js

@@ -0,0 +1,637 @@
+// Copied from web/src/lib/sticky-sim.ts (the coin's rule engine on bigints and the launcher's test run), with its import pointed
+// at the SDK's copy of the encoder. Keep the two in step: node scripts/check-rules-copy.mjs compares them.
+/**
+ * sticky rules in the browser: the coin's rule engine (src/sticky/StickyToken.sol) line for line, on bigints, and a test
+ * run of random trades on top. The engine is checked against the contract trade by trade (test/sticky/StickyTrace.t.sol
+ * writes a run, scripts/dev/sticky-sim-diff.mjs replays it here), so what the launcher shows is what the coin would do.
+ * The chain stays the truth: this only shows a creator what a table does before the launch.
+ */
+import { ACT, FLAG, ON, OP, VAR, decodeRow } from "./sticky-rules.js";
+export const SUPPLY = BigInt("1000000000000000000000000000"); // 1e9 coins of 18 decimals
+const E6 = BigInt(1_000_000);
+const BPS = BigInt(10_000);
+const NONE = 255;
+const LOCKED = 254;
+const EXIT = 30 * 86_400;
+const MAX_LOTS = 8;
+const MAX_TAKE = BigInt(1000);
+const USER_FLAGS = FLAG.SNIPER | FLAG.MARK;
+const U40 = (BigInt(1) << BigInt(40)) - BigInt(1);
+const Z = BigInt(0);
+const ONE = BigInt(1);
+/** The addresses the coin does not keep lots for. */
+export const POOL = "pool";
+export const POT = "pot";
+export const DEAD = "dead";
+const tracked = (a) => a !== POOL && a !== POT && a !== DEAD;
+const min = (a, b) => (a < b ? a : b);
+const bal = (s, a) => s.bal.get(a) ?? Z;
+const lotsOf = (s, a) => s.lots.get(a) ?? [];
+export function newCoin(rows, release, creator, curveSupply, start = 0, startBlock = 0) {
+    return {
+        rows: rows.map((r) => (typeof r === "bigint" ? decodeRow(r) : r)),
+        release,
+        off: 0,
+        creator: creator.toLowerCase(),
+        start,
+        startBlock,
+        curveSupply,
+        stats: { holders: 0, buys: 0, sells: 0, highAt: start, lastBuy: start, volume: Z, net: Z, peak: Z, high: Z },
+        bal: new Map(),
+        lots: new Map(),
+    };
+}
+// ---------------------------------------------------------------- rows
+function ctx(s, kind, amount, balance, now) {
+    const c = { kind, amount: Z, balance: Z, price: Z, dip: Z, sold: Z, sinceLaunch: Z, blocks: Z, buys: Z, holders: Z, idle: Z, pot: Z };
+    if (s.rows.length === 0)
+        return c;
+    c.amount = (amount * E6) / SUPPLY;
+    c.balance = (balance * E6) / SUPPLY;
+    const sup = s.curveSupply;
+    const net = s.stats.net;
+    if (sup !== Z) {
+        if (net >= sup) {
+            c.price = U40;
+            c.dip = BPS;
+            c.sold = BPS;
+        }
+        else {
+            const left = sup - net;
+            c.price = min((sup * sup * BPS) / (left * left), U40);
+            const high = now.t >= s.stats.highAt + 3600 ? net : s.stats.high > net ? s.stats.high : net;
+            c.dip = ((sup - high) * (sup - high) * BPS) / (left * left);
+            c.sold = (net * BPS) / sup;
+        }
+    }
+    c.sinceLaunch = BigInt(now.t - s.start);
+    c.blocks = BigInt(now.b - s.startBlock);
+    c.buys = BigInt(s.stats.buys);
+    c.holders = BigInt(s.stats.holders);
+    c.idle = BigInt(now.t - s.stats.lastBuy);
+    c.pot = (bal(s, POT) * E6) / SUPPLY;
+    return c;
+}
+function value(v, c, age, flags, now) {
+    switch (v) {
+        case VAR.AGE:
+            return age;
+        case VAR.LAUNCH:
+            return c.sinceLaunch;
+        case VAR.BLOCKS:
+            return c.blocks;
+        case VAR.AMOUNT:
+            return c.amount;
+        case VAR.BALANCE:
+            return c.balance;
+        case VAR.PRICE:
+            return c.price;
+        case VAR.DIP:
+            return c.dip;
+        case VAR.SOLD:
+            return c.sold;
+        case VAR.HOUR:
+            return BigInt(Math.floor(now.t / 3600) % 24);
+        case VAR.WEEKDAY:
+            return BigInt((Math.floor(now.t / 86_400) + 4) % 7);
+        case VAR.FLAGS:
+            return BigInt(flags);
+        case VAR.BUYS:
+            return c.buys;
+        case VAR.HOLDERS:
+            return c.holders;
+        case VAR.IDLE:
+            return c.idle;
+        case VAR.POTSIZE:
+            return c.pot;
+    }
+    return Z;
+}
+function test(op, x, val) {
+    if (op === OP.LT)
+        return x < val;
+    if (op === OP.GE)
+        return x >= val;
+    if (op === OP.HAS)
+        return (x & val) !== Z;
+    if (op === OP.NOT)
+        return (x & val) === Z;
+    const period = val >> BigInt(20);
+    if (period === Z)
+        return false;
+    const phase = x % period;
+    const th = val & BigInt(0xfffff);
+    if (op === OP.MODLT)
+        return phase < th;
+    if (op === OP.MODGE)
+        return phase >= th;
+    return false;
+}
+function matches(r, c, age, flags, now) {
+    for (const k of r.conds)
+        if (!test(k.op, value(k.v, c, age, flags, now), k.val))
+            return false;
+    return true;
+}
+function buyRows(s, to, amount, now) {
+    const b = { why: NONE, flags: to === s.creator ? FLAG.DEV : 0, lockBps: Z, burn: Z, toPot: Z, drop: Z };
+    if (s.rows.length === 0)
+        return b;
+    const c = ctx(s, ON.BUY, amount, bal(s, to) + amount, now);
+    let burnBps = Z;
+    let potBps = Z;
+    let dropBps = Z;
+    for (let i = 0; i < s.rows.length; i++) {
+        if (s.off & (1 << i))
+            continue;
+        const r = s.rows[i];
+        if (!(r.on & ON.BUY) || !matches(r, c, Z, b.flags, now))
+            continue;
+        const x = BigInt(r.arg);
+        if (r.act === ACT.DENY) {
+            b.why = i;
+            return b;
+        }
+        if (r.act === ACT.FLAG)
+            b.flags |= r.arg & USER_FLAGS;
+        else if (r.act === ACT.LOCK)
+            b.lockBps = x > b.lockBps ? x : b.lockBps;
+        else if (r.act === ACT.BURN)
+            burnBps += x;
+        else if (r.act === ACT.POT)
+            potBps += x;
+        else if (r.act === ACT.DROP)
+            dropBps = x > dropBps ? x : dropBps;
+    }
+    if (burnBps > MAX_TAKE)
+        burnBps = MAX_TAKE;
+    if (burnBps + potBps > MAX_TAKE)
+        potBps = MAX_TAKE - burnBps;
+    if (b.lockBps > BPS)
+        b.lockBps = BPS;
+    if (dropBps > BPS)
+        dropBps = BPS;
+    b.burn = (amount * burnBps) / BPS;
+    b.toPot = (amount * potBps) / BPS;
+    if (dropBps !== Z && to !== s.creator && tracked(to)) {
+        const got = amount - b.burn - b.toPot;
+        b.drop = min((bal(s, POT) * dropBps) / BPS, got);
+    }
+    return b;
+}
+function denied(s, c, age, flags, now) {
+    for (let i = 0; i < s.rows.length; i++) {
+        if (s.off & (1 << i))
+            continue;
+        const r = s.rows[i];
+        if (r.act !== ACT.DENY || (r.on & c.kind) === 0)
+            continue;
+        if (matches(r, c, BigInt(age), flags, now))
+            return i;
+    }
+    return NONE;
+}
+// ---------------------------------------------------------------- lots
+function lockedNow(s, l, t) {
+    const d = s.release;
+    if (d === 0 || l.lk === Z)
+        return Z;
+    const end = l.since + d;
+    if (t >= end)
+        return Z;
+    return (l.lk * BigInt(end - t) + BigInt(d) - ONE) / BigInt(d);
+}
+function free(s, l, c, now) {
+    const age = now.t - l.since;
+    if (age >= EXIT)
+        return l.amount;
+    if (denied(s, c, age, l.flags, now) !== NONE)
+        return Z;
+    const lk = lockedNow(s, l, now.t);
+    return lk >= l.amount ? Z : l.amount - lk;
+}
+function planSell(s, a, amount, c, now) {
+    const ls = lotsOf(s, a).map((l) => ({ ...l }));
+    let left = amount;
+    let why = NONE;
+    for (let i = 0; i < ls.length && left !== Z; i++) {
+        const l = ls[i];
+        const age = now.t - l.since;
+        let fr;
+        if (age >= EXIT) {
+            fr = l.amount;
+        }
+        else {
+            const r = denied(s, c, age, l.flags, now);
+            if (r !== NONE) {
+                if (why === NONE)
+                    why = r;
+                continue;
+            }
+            const lk = lockedNow(s, l, now.t);
+            fr = lk >= l.amount ? Z : l.amount - lk;
+        }
+        const take = min(fr, left);
+        if (take === Z)
+            continue;
+        l.amount -= take; // the lock at purchase stays: the time decides what is still locked
+        left -= take;
+    }
+    if (left !== Z)
+        return { why: why === NONE ? LOCKED : why, ls };
+    return { why: NONE, ls };
+}
+function planSend(s, a, amount, c, now) {
+    const ls = lotsOf(s, a).map((l) => ({ ...l }));
+    const pieces = [];
+    let left = amount;
+    let why = NONE;
+    for (let i = ls.length - 1; i >= 0 && left !== Z; i--) {
+        const l = ls[i];
+        const age = now.t - l.since;
+        if (age < EXIT) {
+            const r = denied(s, c, age, l.flags, now);
+            if (r !== NONE) {
+                if (why === NONE)
+                    why = r;
+                continue;
+            }
+        }
+        const am = l.amount;
+        const lk = l.lk;
+        const take = min(am, left);
+        const moved = take === am ? lk : min(lk, (lk * take + am - ONE) / am);
+        pieces.push({ amount: take, lk: moved, since: l.since, flags: l.flags });
+        ls[i] = { amount: am - take, lk: lk - moved, since: l.since, flags: l.flags };
+        left -= take;
+    }
+    if (left !== Z)
+        return { why: why === NONE ? LOCKED : why, ls, pieces: [] };
+    return { why: NONE, ls, pieces };
+}
+function insert(ls, p) {
+    let at = ls.length;
+    for (let i = 0; i < ls.length; i++) {
+        const l = ls[i];
+        if (l.since === p.since && l.flags === p.flags) {
+            ls[i] = { amount: l.amount + p.amount, lk: l.lk + p.lk, since: l.since, flags: l.flags };
+            return;
+        }
+        if (l.since > p.since && at === ls.length)
+            at = i;
+    }
+    ls.splice(at, 0, p);
+}
+/** Joins the cheapest pair of lots with the same flags: the younger time, both locks. */
+function join(ls) {
+    let best = null;
+    let bi = 0;
+    let bj = 0;
+    for (let i = 0; i < ls.length; i++) {
+        for (let j = i + 1; j < ls.length; j++) {
+            if (ls[j].flags !== ls[i].flags)
+                continue;
+            const cost = ls[i].amount * BigInt(ls[j].since - ls[i].since);
+            if (best === null || cost < best)
+                [best, bi, bj] = [cost, i, j];
+            break;
+        }
+    }
+    const x = ls[bi];
+    const y = ls[bj];
+    ls[bj] = { amount: x.amount + y.amount, lk: x.lk + y.lk, since: y.since, flags: y.flags };
+    ls.splice(bi, 1);
+}
+function receive(s, a, pieces) {
+    const ls = lotsOf(s, a).map((l) => ({ ...l }));
+    for (const p of pieces) {
+        if (p.amount === Z)
+            continue;
+        insert(ls, p);
+        if (ls.length > MAX_LOTS)
+            join(ls);
+    }
+    store(s, a, ls);
+}
+function store(s, a, ls) {
+    const kept = ls.filter((l) => l.amount !== Z);
+    if (kept.length)
+        s.lots.set(a, kept);
+    else
+        s.lots.delete(a);
+}
+function high(st, net, t) {
+    if (net > st.high || t >= st.highAt + 3600) {
+        st.high = net;
+        st.highAt = t;
+    }
+}
+// ---------------------------------------------------------------- transfers
+/** A transfer as the coin runs it: out of POOL is a buy, into POOL a sell, anything else a send. */
+export function transfer(s, from, to, amount, now) {
+    from = from.toLowerCase();
+    to = to.toLowerCase();
+    const fromBal = bal(s, from);
+    if (fromBal < amount)
+        return { ok: false, why: "nope" };
+    let b = { why: NONE, flags: 0, lockBps: Z, burn: Z, toPot: Z, drop: Z };
+    if (amount !== Z) {
+        const isBuy = from === POOL;
+        const isSell = to === POOL;
+        if (isBuy && isSell)
+            return { ok: false, why: "nope" };
+        if (isBuy) {
+            b = buyRows(s, to, amount, now);
+            if (b.why !== NONE)
+                return { ok: false, why: b.why };
+            const got = amount - b.burn - b.toPot + b.drop;
+            if (got !== Z && tracked(to))
+                receive(s, to, [{ amount: got, lk: (got * b.lockBps) / BPS, since: now.t, flags: b.flags }]);
+            const st = s.stats;
+            st.buys++;
+            st.lastBuy = now.t;
+            st.volume += amount;
+            st.net += amount;
+            if (st.net > st.peak)
+                st.peak = st.net;
+            high(st, st.net, now.t);
+        }
+        else if (isSell) {
+            if (tracked(from)) {
+                const p = planSell(s, from, amount, ctx(s, ON.SELL, amount, fromBal, now), now);
+                if (p.why !== NONE)
+                    return { ok: false, why: p.why };
+                store(s, from, p.ls);
+            }
+            const st = s.stats;
+            st.sells++;
+            st.volume += amount;
+            st.net = amount > st.net ? Z : st.net - amount;
+            high(st, st.net, now.t);
+        }
+        else {
+            let pieces;
+            if (tracked(from)) {
+                const p = planSend(s, from, amount, ctx(s, ON.SEND, amount, bal(s, to) + amount, now), now);
+                if (p.why !== NONE)
+                    return { ok: false, why: p.why };
+                store(s, from, p.ls);
+                pieces = p.pieces;
+            }
+            else {
+                pieces = [{ amount, lk: Z, since: now.t, flags: 0 }];
+            }
+            if (tracked(to))
+                receive(s, to, pieces);
+        }
+    }
+    s.bal.set(from, fromBal - amount);
+    const got = amount - b.burn - b.toPot;
+    const toBefore = bal(s, to);
+    s.bal.set(to, toBefore + got);
+    if (b.burn !== Z)
+        s.bal.set(DEAD, bal(s, DEAD) + b.burn);
+    if (b.toPot !== Z)
+        s.bal.set(POT, bal(s, POT) + b.toPot);
+    if (b.drop !== Z) {
+        s.bal.set(POT, bal(s, POT) - b.drop);
+        s.bal.set(to, bal(s, to) + b.drop);
+    }
+    if (tracked(from) && fromBal !== Z && fromBal === amount && s.stats.holders > 0)
+        s.stats.holders--;
+    if (tracked(to) && toBefore === Z && got + b.drop !== Z)
+        s.stats.holders++;
+    return { ok: true, burn: b.burn, toPot: b.toPot, drop: b.drop };
+}
+/** What `a` could sell right now (size rows left out, like the coin's view). */
+export function sellable(s, a, now) {
+    a = a.toLowerCase();
+    const c = ctx(s, ON.SELL, Z, bal(s, a), now);
+    return lotsOf(s, a).reduce((x, l) => x + free(s, l, c, now), Z);
+}
+export function balanceOf(s, a) {
+    return bal(s, a.toLowerCase());
+}
+export function lots(s, a) {
+    return lotsOf(s, a.toLowerCase());
+}
+// ---------------------------------------------------------------- a test run of random trades
+/** The curve as the coin prices it: x * y = k from the start price, so price / start = (supply / coins left)². */
+export const CURVE = {
+    supply: BigInt("998319327731092436974789916"), // 1e9 coins minus the seed coins of the V2 pair (0.01 BNB at 5.95 BNB)
+    startFdvBnb: 5.95,
+};
+function coinsFor(net, bnb) {
+    const sup = Number(CURVE.supply) / 1e18;
+    const left = sup - Number(net) / 1e18;
+    const k = (CURVE.startFdvBnb / 1e9) * sup * sup; // BNB * coins
+    const y = k / left;
+    const out = left - k / (y + bnb * 0.99);
+    return BigInt(Math.floor(Math.max(0, out))) * BigInt(1e18);
+}
+function rng(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/**
+ * Random trades on a fresh coin with this table: the creator's first buy, three snipers in the first blocks, wallets
+ * that come, buy, hold for a while and sell (and try again when refused), some bags split to fresh wallets that then
+ * try to sell. The same seed gives the same run.
+ */
+export function simulate(rows, release, opts = {}) {
+    const R = rng(opts.seed ?? 7);
+    const N = opts.trades ?? 200;
+    // launch at the top of the current hour: rows on the hour and the weekday see a real clock
+    const T0 = opts.start ?? Math.floor(Date.now() / 3_600_000) * 3600;
+    const s = newCoin(rows, release, "creator", CURVE.supply, T0, 0);
+    // times below are seconds after the launch; blocks of 0.45 s
+    const now = (t) => ({ t: T0 + Math.floor(t), b: Math.floor(t / 0.45) });
+    // the pool holds everything the curve has, so every buy can be served
+    s.bal.set(POOL, SUPPLY);
+    const rep = {
+        trades: 0,
+        hours: 0,
+        buys: { ok: 0, refused: 0 },
+        sells: { ok: 0, refused: 0 },
+        sends: { ok: 0, refused: 0 },
+        refusals: [],
+        longestWait: 0,
+        stillWaiting: 0,
+        allFreeAfter: 0,
+        burnedPct: 0,
+        pot: { inPct: 0, drops: 0, paidPct: 0, biggestX: 0, leftPct: 0 },
+        snipers: { count: 3, firstSellAfter: null },
+        splits: { count: 0, refusedAfter: 0 },
+        scanner: { buy: null, sell: null },
+    };
+    const refused = new Map();
+    const firstRefusal = new Map();
+    const splitWallets = new Set();
+    let potIn = Z;
+    let potOut = Z;
+    const q = [];
+    const push = (e) => {
+        let i = q.length;
+        while (i > 0 && q[i - 1].t > e.t)
+            i--;
+        q.splice(i, 0, e);
+    };
+    const logUniform = (lo, hi) => Math.exp(Math.log(lo) + R() * (Math.log(hi) - Math.log(lo)));
+    // the launch: the creator's first buy
+    if ((opts.devBuyBnb ?? 0) > 0) {
+        const amt = coinsFor(s.stats.net, opts.devBuyBnb);
+        if (amt > Z)
+            transfer(s, POOL, "creator", amt, now(0));
+    }
+    // snipers in the first blocks, out as soon as they can
+    for (let k = 0; k < 3; k++) {
+        push({ t: 1 + k * 2, kind: "buy", w: `sniper${k}`, bnb: 0.1 + R() * 0.3 });
+        push({ t: 60 + R() * 300, kind: "sell", w: `sniper${k}`, part: 1 });
+    }
+    // wallets coming in, faster at first
+    let t = 30;
+    for (let k = 0; k < 120; k++) {
+        t += -Math.log(1 - R()) * (k < 30 ? 120 : 900);
+        const w = `w${k}`;
+        // at the start 0.1 BNB buys about 1.6 % of the supply
+        push({ t, kind: "buy", w, bnb: logUniform(0.005, 0.3) });
+        if (R() < 0.3)
+            push({ t: t + logUniform(120, 6 * 3600), kind: "buy", w, bnb: logUniform(0.005, 0.15) });
+        if (R() < 0.15)
+            push({ t: t + logUniform(60, 3600), kind: "split", w });
+        push({ t: t + logUniform(60, 2 * 86_400), kind: "sell", w, part: R() < 0.5 ? 1 : 0.3 + R() * 0.6 });
+    }
+    const note = (why) => refused.set(why, (refused.get(why) ?? 0) + 1);
+    let last = 0;
+    while (q.length && rep.trades < N) {
+        const e = q.shift();
+        last = e.t;
+        const n = now(e.t);
+        if (e.kind === "buy") {
+            rep.trades++;
+            const amt = coinsFor(s.stats.net, e.bnb);
+            if (amt === Z)
+                continue;
+            const r = transfer(s, POOL, e.w, amt, n);
+            if (r.ok) {
+                rep.buys.ok++;
+                potIn += r.toPot;
+                if (r.drop > Z) {
+                    potOut += r.drop;
+                    rep.pot.drops++;
+                    const paid = amt - r.burn - r.toPot;
+                    rep.pot.biggestX = Math.max(rep.pot.biggestX, Number(r.drop) / Number(paid));
+                }
+            }
+            else {
+                rep.buys.refused++;
+                if (typeof r.why === "number")
+                    note(r.why);
+            }
+        }
+        else if (e.kind === "split") {
+            const b = balanceOf(s, e.w);
+            if (b === Z)
+                continue;
+            rep.trades++;
+            const fresh = `${e.w}-split`;
+            const r = transfer(s, e.w, fresh, b / BigInt(2), n);
+            if (r.ok) {
+                rep.sends.ok++;
+                rep.splits.count++;
+                splitWallets.add(fresh);
+                push({ t: e.t + 5 + R() * 60, kind: "sell", w: fresh, part: 1 });
+            }
+            else {
+                rep.sends.refused++;
+                if (typeof r.why === "number")
+                    note(r.why);
+            }
+        }
+        else {
+            const b = balanceOf(s, e.w);
+            if (b === Z)
+                continue;
+            rep.trades++;
+            const amt = e.part === 1 ? b : BigInt(Math.floor(Number(b / BigInt(1e12)) * e.part)) * BigInt(1e12);
+            if (amt === Z)
+                continue;
+            const r = transfer(s, e.w, POOL, amt, n);
+            if (r.ok) {
+                rep.sells.ok++;
+                const since = firstRefusal.get(e.w);
+                if (since !== undefined) {
+                    rep.longestWait = Math.max(rep.longestWait, e.t - since);
+                    firstRefusal.delete(e.w);
+                }
+                if (e.w.startsWith("sniper") && rep.snipers.firstSellAfter === null)
+                    rep.snipers.firstSellAfter = e.t;
+            }
+            else {
+                rep.sells.refused++;
+                if (typeof r.why === "number")
+                    note(r.why);
+                if (!firstRefusal.has(e.w))
+                    firstRefusal.set(e.w, e.t);
+                if (splitWallets.has(e.w))
+                    rep.splits.refusedAfter++;
+                // try again later, the whole bag or what can go now
+                const retry = (e.retry ?? 0) + 1;
+                if (retry <= 6)
+                    push({ t: e.t + logUniform(900, 6 * 3600), kind: "sell", w: e.w, part: e.part, retry });
+            }
+        }
+    }
+    rep.hours = last / 3600;
+    for (const [, since] of firstRefusal)
+        rep.longestWait = Math.max(rep.longestWait, last - since);
+    rep.stillWaiting = firstRefusal.size;
+    // after the run: when can every wallet sell everything?
+    const holders = [...s.bal.entries()].filter(([a, v]) => tracked(a) && v > Z).map(([a]) => a);
+    const steps = [...Array.from({ length: 180 }, (_, i) => i * 60), ...Array.from({ length: 564 }, (_, i) => 3 * 3600 + i * 300), ...Array.from({ length: 700 }, (_, i) => 2 * 86_400 + i * 3600)];
+    rep.allFreeAfter = null;
+    const pending = new Set(holders);
+    let worst = 0;
+    for (const dt of steps) {
+        const n = now(last + dt);
+        for (const a of [...pending]) {
+            if (sellable(s, a, n) < balanceOf(s, a))
+                continue;
+            pending.delete(a);
+            worst = dt;
+        }
+        if (!pending.size) {
+            rep.allFreeAfter = worst;
+            break;
+        }
+    }
+    // a scanner an hour after launch: a tiny test buy, then sell at once
+    const probe = newCoinCopy(s);
+    const tp = now(3600);
+    const small = coinsFor(Z, 0.001);
+    const rb = transfer(probe, POOL, "scanner", small, tp);
+    rep.scanner.buy = rb.ok ? null : typeof rb.why === "number" ? rb.why : null;
+    if (rb.ok) {
+        const rs = transfer(probe, "scanner", POOL, balanceOf(probe, "scanner"), { t: tp.t + 3, b: tp.b + 7 });
+        rep.scanner.sell = rs.ok ? null : typeof rs.why === "number" ? rs.why : null;
+    }
+    const pct = (x) => Number((x * BigInt(1_000_000)) / SUPPLY) / 10_000;
+    rep.burnedPct = pct(balanceOf(s, DEAD));
+    rep.pot.inPct = pct(potIn);
+    rep.pot.paidPct = pct(potOut);
+    rep.pot.leftPct = pct(balanceOf(s, POT));
+    rep.refusals = [...refused.entries()].map(([row, count]) => ({ row, count })).sort((a, b) => b.count - a.count);
+    return rep;
+}
+/** A coin with the same table, fresh from launch: the scanner probe must not see the run's history. */
+function newCoinCopy(s) {
+    const c = newCoin(s.rows, s.release, s.creator, s.curveSupply, s.start, s.startBlock);
+    c.bal.set(POOL, SUPPLY);
+    return c;
+}