@pickhooks/sdk 0.0.0-stage → 0.2.0

package/dist/sticky-rules.js

@@ -0,0 +1,580 @@
+// Copied from web/src/lib/sticky-rules.ts (the site's encoder, templates and checks; same encoding as src/sticky/StickyRules.sol).
+// Keep the two in step: node scripts/check-rules-copy.mjs compares them.
+/**
+ * sticky rules: the rule table of a sticky coin, the same encoding as src/sticky/StickyRules.sol.
+ * A row is one uint256: on (bits 0..7), act (8..15), arg (16..31), then four conditions of 56 bits (var, op, value).
+ * The launcher offers templates; each template is one or two rows. The chain is the truth: the validator checks every
+ * table at launch and the coin checks every transfer. POT rows fill the coin's pot from buys, DROP rows pay it out to
+ * buyers (at most the coins of the buy, never to the creator).
+ */
+export const ON = { BUY: 1, SELL: 2, SEND: 4 };
+export const ACT = { DENY: 1, FLAG: 2, LOCK: 3, BURN: 4, POT: 5, DROP: 6 };
+export const VAR = { AGE: 1, LAUNCH: 2, BLOCKS: 3, AMOUNT: 4, BALANCE: 5, PRICE: 6, DIP: 7, SOLD: 8, HOUR: 9, WEEKDAY: 10, FLAGS: 11, BUYS: 12, HOLDERS: 13, IDLE: 14, POTSIZE: 15 };
+export const OP = { LT: 1, GE: 2, HAS: 3, NOT: 4, MODLT: 5, MODGE: 6 };
+export const FLAG = { SNIPER: 1, MARK: 2, DEV: 4 };
+/** answers of token.check(): allowed, and "no row stops it but the coins are still locked" */
+export const NONE = 255;
+export const LOCKED = 254;
+export const STICKY_LIMITS = {
+    maxRows: 8,
+    maxLots: 8,
+    exitDays: 30,
+    maxBurnPct: 10,
+    /** burn and pot together, per buy */
+    maxTakePct: 10,
+    maxHoldDays: 7,
+    minReleaseMinutes: 10,
+    maxReleaseDays: 30,
+};
+export function encodeRow(r) {
+    let x = BigInt(r.on) | (BigInt(r.act) << BigInt(8)) | (BigInt(r.arg) << BigInt(16));
+    r.conds.slice(0, 4).forEach((c, i) => {
+        const packed = BigInt(c.v) | (BigInt(c.op) << BigInt(8)) | (c.val << BigInt(16));
+        x |= packed << BigInt(32 + 56 * i);
+    });
+    return x;
+}
+export function decodeRow(x) {
+    const b = (v, n) => Number(v & ((BigInt(1) << BigInt(n)) - BigInt(1)));
+    const conds = [];
+    for (let i = 0; i < 4; i++) {
+        const c = x >> BigInt(32 + 56 * i);
+        const v = b(c, 8);
+        if (v === 0)
+            break;
+        conds.push({ v, op: b(c >> BigInt(8), 8), val: (c >> BigInt(16)) & ((BigInt(1) << BigInt(40)) - BigInt(1)) });
+    }
+    return { on: b(x, 8), act: b(x >> BigInt(8), 8), arg: b(x >> BigInt(16), 16), conds };
+}
+const c = (v, op, val) => ({ v, op, val: BigInt(val) });
+const MIN = 60;
+const HOUR = 3600;
+const DAY = 86_400;
+const ppm = (pct) => Math.round(pct * 10_000);
+const potRow = (pct) => ({ on: ON.BUY, act: ACT.POT, arg: Math.round(pct * 100), conds: [] });
+/** every n-th buy: the buys before it are n-1, 2n-1, ... (buys % n >= n - 1) */
+export const every = (n) => (BigInt(Math.round(n)) << BigInt(20)) | BigInt(Math.max(0, Math.round(n) - 1));
+export const TEMPLATES = [
+    {
+        id: "hold",
+        name: "Hold time",
+        line: "Coins must be {m} minutes old before they can be sold, in any wallet they move to.",
+        sticky: true,
+        scanner: "red",
+        scannerNote: "A scanner's test sell right after its test buy fails and can show a honeypot.",
+        params: [{ key: "m", label: "Hold time", unit: "minutes", min: 1, max: 7 * 24 * 60, step: 1, def: 30, hint: "1 minute to 7 days" }],
+        rows: (p) => [{ on: ON.SELL, act: ACT.DENY, arg: 0, conds: [c(VAR.AGE, OP.LT, Math.round(p.m * MIN))] }],
+    },
+    {
+        id: "sniper",
+        name: "Sniper jail",
+        line: "Buys in the first {b} blocks are marked. Marked coins cannot be sold for {h} hours, in any wallet.",
+        sticky: true,
+        scanner: "green",
+        scannerNote: "Only coins bought in the first blocks. A scanner that tests later sees nothing.",
+        params: [
+            { key: "b", label: "First blocks", unit: "blocks", min: 1, max: 400, step: 1, def: 20, hint: "about 0.45 seconds each" },
+            { key: "h", label: "Jail time", unit: "hours", min: 1, max: 168, step: 1, def: 24, hint: "1 hour to 7 days" },
+        ],
+        rows: (p) => [
+            { on: ON.BUY, act: ACT.FLAG, arg: FLAG.SNIPER, conds: [c(VAR.BLOCKS, OP.LT, p.b), c(VAR.FLAGS, OP.NOT, FLAG.DEV)] },
+            { on: ON.SELL, act: ACT.DENY, arg: 0, conds: [c(VAR.FLAGS, OP.HAS, FLAG.SNIPER), c(VAR.AGE, OP.LT, Math.round(p.h * HOUR))] },
+        ],
+    },
+    {
+        id: "devlock",
+        name: "Dev lock",
+        line: "Your own first buy cannot be sold for {d} days after launch, wherever you send it.",
+        sticky: true,
+        scanner: "green",
+        scannerNote: "Only the creator's coins. Scanners see nothing.",
+        params: [{ key: "d", label: "Locked for", unit: "days", min: 1, max: 30, step: 1, def: 7, hint: "1 to 30 days, needs a first buy" }],
+        rows: (p) => [{ on: ON.SELL, act: ACT.DENY, arg: 0, conds: [c(VAR.FLAGS, OP.HAS, FLAG.DEV), c(VAR.LAUNCH, OP.LT, Math.round(p.d * DAY))] }],
+    },
+    {
+        id: "drip",
+        name: "Drip",
+        line: "{pct} % of every buy{big} unlocks over {h} hours. Ten wallets sell no faster than one.",
+        sticky: true,
+        scanner: "yellow",
+        scannerNote: "Only buys from the set size lock, so a scanner's small test buy and sell pass. With 0 every buy locks and a scanner's test sell fails.",
+        params: [
+            { key: "pct", label: "Share locked", unit: "%", min: 1, max: 100, step: 1, def: 100, hint: "of each buy" },
+            { key: "h", label: "Unlocks over", unit: "hours", min: 1, max: 720, step: 1, def: 6, hint: "1 hour to 30 days, on a straight line" },
+            { key: "big", label: "Only buys from", unit: "%", min: 0, max: 5, step: 0.01, def: 0.5, hint: "of the supply, 0 for every buy" },
+        ],
+        rows: (p) => [
+            p.big > 0
+                ? { on: ON.BUY, act: ACT.LOCK, arg: Math.round(p.pct * 100), conds: [c(VAR.AMOUNT, OP.GE, ppm(p.big))] }
+                : { on: ON.BUY, act: ACT.LOCK, arg: Math.round(p.pct * 100), conds: [] },
+        ],
+        release: (p) => Math.round(p.h * HOUR),
+    },
+    {
+        id: "maxbuy",
+        name: "Max per buy",
+        line: "No buy above {pct} % of the supply. Your own first buy is free of it.",
+        sticky: false,
+        scanner: "yellow",
+        scannerNote: 'Scanners show "anti whale".',
+        params: [{ key: "pct", label: "Biggest buy", unit: "%", min: 0.05, max: 10, step: 0.05, def: 1, hint: "of the supply" }],
+        rows: (p) => [{ on: ON.BUY, act: ACT.DENY, arg: 0, conds: [c(VAR.AMOUNT, OP.GE, ppm(p.pct) + 1), c(VAR.FLAGS, OP.NOT, FLAG.DEV)] }],
+    },
+    {
+        id: "maxwallet",
+        name: "Max wallet",
+        line: "No buy that takes a wallet above {pct} % of the supply. Your own first buy is free of it.",
+        sticky: false,
+        scanner: "yellow",
+        scannerNote: 'Scanners show "anti whale". Sends to other wallets are not capped.',
+        params: [{ key: "pct", label: "Biggest wallet", unit: "%", min: 0.1, max: 20, step: 0.1, def: 2, hint: "of the supply" }],
+        rows: (p) => [{ on: ON.BUY, act: ACT.DENY, arg: 0, conds: [c(VAR.BALANCE, OP.GE, ppm(p.pct) + 1), c(VAR.FLAGS, OP.NOT, FLAG.DEV)] }],
+    },
+    {
+        id: "window",
+        name: "Sell window",
+        line: "Sells open for {m} minutes every {h} hours, counted from the launch.",
+        sticky: false,
+        scanner: "red",
+        scannerNote: "Outside the window a scanner's test sell fails and can show a honeypot.",
+        params: [
+            { key: "h", label: "Every", unit: "hours", min: 0.5, max: 24, step: 0.5, def: 2, hint: "half an hour to a day" },
+            { key: "m", label: "Open for", unit: "minutes", min: 1, max: 1439, step: 1, def: 15, hint: "shorter than the period" },
+        ],
+        rows: (p) => {
+            const period = Math.round(p.h * HOUR);
+            const open = Math.round(p.m * MIN);
+            return [{ on: ON.SELL, act: ACT.DENY, arg: 0, conds: [c(VAR.LAUNCH, OP.MODGE, (BigInt(period) << BigInt(20)) | BigInt(open))] }];
+        },
+    },
+    {
+        id: "hours",
+        name: "Market hours",
+        line: "Buys and sells only from {open}:00 to {close}:00 UTC.",
+        sticky: false,
+        scanner: "red",
+        scannerNote: "Outside the hours a scanner's test trade fails.",
+        params: [
+            { key: "open", label: "Opens", unit: "UTC", min: 1, max: 22, step: 1, def: 6, hint: "hour of the day" },
+            { key: "close", label: "Closes", unit: "UTC", min: 2, max: 23, step: 1, def: 22, hint: "after the opening hour" },
+        ],
+        rows: (p) => [
+            { on: ON.BUY | ON.SELL, act: ACT.DENY, arg: 0, conds: [c(VAR.HOUR, OP.LT, p.open)] },
+            { on: ON.BUY | ON.SELL, act: ACT.DENY, arg: 0, conds: [c(VAR.HOUR, OP.GE, p.close)] },
+        ],
+    },
+    {
+        id: "burn",
+        name: "Auto burn",
+        line: "{pct} % of every buy is burned. Sells are never taxed.",
+        sticky: false,
+        scanner: "yellow",
+        scannerNote: "Scanners show it as a buy tax.",
+        params: [{ key: "pct", label: "Burned per buy", unit: "%", min: 0.1, max: 10, step: 0.1, def: 1, hint: "0.1 to 10 %" }],
+        rows: (p) => [{ on: ON.BUY, act: ACT.BURN, arg: Math.round(p.pct * 100), conds: [] }],
+    },
+    {
+        id: "dipdrop",
+        name: "Dip drop",
+        line: "{pot} % of every buy fills the pot. A buy while the price is more than {dip} % under the hour's high gets {share} % of the pot, up to as many coins as it buys.",
+        sticky: false,
+        gives: true,
+        scanner: "yellow",
+        scannerNote: "Scanners show the pot share as a buy tax. A drop is extra coins for the buyer, never for you.",
+        params: [
+            { key: "pot", label: "Into the pot", unit: "%", min: 0.1, max: 10, step: 0.1, def: 2, hint: "of every buy" },
+            { key: "dip", label: "Dip", unit: "%", min: 1, max: 90, step: 1, def: 20, hint: "under the high of the last hour" },
+            { key: "share", label: "Drop", unit: "%", min: 1, max: 100, step: 1, def: 50, hint: "of the pot, up to the buy" },
+        ],
+        rows: (p) => [potRow(p.pot), { on: ON.BUY, act: ACT.DROP, arg: Math.round(p.share * 100), conds: [c(VAR.DIP, OP.LT, Math.round((100 - p.dip) * 100))] }],
+    },
+    {
+        id: "lucky",
+        name: "Lucky buy",
+        line: "{pot} % of every buy fills the pot. Every {n}th buy gets {share} % of the pot, up to as many coins as it buys.",
+        sticky: false,
+        gives: true,
+        scanner: "yellow",
+        scannerNote: "Scanners show the pot share as a buy tax. A drop is extra coins for the buyer, never for you.",
+        params: [
+            { key: "pot", label: "Into the pot", unit: "%", min: 0.1, max: 10, step: 0.1, def: 2, hint: "of every buy" },
+            { key: "n", label: "Every", unit: "th buy", min: 2, max: 10_000, step: 1, def: 25, hint: "2 to 10,000" },
+            { key: "share", label: "Drop", unit: "%", min: 1, max: 100, step: 1, def: 100, hint: "of the pot, up to the buy" },
+        ],
+        rows: (p) => [potRow(p.pot), { on: ON.BUY, act: ACT.DROP, arg: Math.round(p.share * 100), conds: [c(VAR.BUYS, OP.MODGE, every(p.n))] }],
+    },
+    {
+        id: "wakeup",
+        name: "Wake up",
+        line: "{pot} % of every buy fills the pot. The first buy after {m} minutes without a buy gets {share} % of the pot, up to as many coins as it buys.",
+        sticky: false,
+        gives: true,
+        scanner: "yellow",
+        scannerNote: "Scanners show the pot share as a buy tax. A drop is extra coins for the buyer, never for you.",
+        params: [
+            { key: "pot", label: "Into the pot", unit: "%", min: 0.1, max: 10, step: 0.1, def: 2, hint: "of every buy" },
+            { key: "m", label: "Quiet for", unit: "minutes", min: 1, max: 1440, step: 1, def: 30, hint: "1 minute to a day" },
+            { key: "share", label: "Drop", unit: "%", min: 1, max: 100, step: 1, def: 100, hint: "of the pot, up to the buy" },
+        ],
+        rows: (p) => [potRow(p.pot), { on: ON.BUY, act: ACT.DROP, arg: Math.round(p.share * 100), conds: [c(VAR.IDLE, OP.GE, Math.round(p.m * MIN))] }],
+    },
+];
+export const TEMPLATE_BY_ID = new Map(TEMPLATES.map((t) => [t.id, t]));
+export function defaults(t) {
+    return Object.fromEntries(t.params.map((p) => [p.key, p.def]));
+}
+/** Problems of a template's numbers, as sentences (the validator has the same bounds). */
+export function paramProblems(t, p) {
+    const out = [];
+    for (const q of t.params) {
+        const v = p[q.key];
+        if (!(Number.isFinite(v) && v >= q.min && v <= q.max))
+            out.push(`${q.label}: ${q.min} to ${q.max} ${q.unit}.`);
+    }
+    if (t.id === "hours" && !(p.open < p.close))
+        out.push("Market hours: close after the opening hour.");
+    if (t.id === "window" && !(p.m * MIN < p.h * HOUR - 59))
+        out.push("Sell window: open for less than the period.");
+    if (t.id === "lucky" && !Number.isInteger(p.n))
+        out.push("Every: a whole number of buys.");
+    return out;
+}
+/** The rows and release time of the picked templates (and the creator's own rows after them), and the problems that
+ *  keep the table from launching. The own rows' single checks are rowProblems; the table checks run over everything. */
+export function compile(picks, own = []) {
+    const rows = [];
+    const problems = [];
+    let release = 0;
+    for (const pk of picks) {
+        const t = TEMPLATE_BY_ID.get(pk.id);
+        if (!t)
+            continue;
+        problems.push(...paramProblems(t, pk.params));
+        rows.push(...t.rows(pk.params));
+        if (t.release)
+            release = Math.max(release, t.release(pk.params));
+    }
+    rows.push(...own);
+    if (rows.length > STICKY_LIMITS.maxRows)
+        problems.push(`At most ${STICKY_LIMITS.maxRows} rows: these rules make ${rows.length}.`);
+    problems.push(...tableProblems(rows));
+    return { rows: rows.map(encodeRow), release, problems };
+}
+export const VARS = [
+    { v: VAR.AGE, label: "age of the coins", unit: "minutes", toChain: (x) => Math.round(x * MIN), fromChain: (x) => x / MIN, lotOnly: true },
+    { v: VAR.LAUNCH, label: "time since launch", unit: "minutes", toChain: (x) => Math.round(x * MIN), fromChain: (x) => x / MIN },
+    { v: VAR.BLOCKS, label: "blocks since launch", unit: "blocks", toChain: (x) => Math.round(x), fromChain: (x) => x },
+    { v: VAR.AMOUNT, label: "size of the trade", unit: "% of supply", toChain: (x) => ppm(x), fromChain: (x) => x / 10_000 },
+    { v: VAR.BALANCE, label: "wallet balance", unit: "% of supply", toChain: (x) => ppm(x), fromChain: (x) => x / 10_000 },
+    { v: VAR.PRICE, label: "price against the start", unit: "x", toChain: (x) => Math.round(x * 10_000), fromChain: (x) => x / 10_000 },
+    { v: VAR.DIP, label: "price against the hour's high", unit: "%", toChain: (x) => Math.round(x * 100), fromChain: (x) => x / 100 },
+    { v: VAR.SOLD, label: "curve sold", unit: "%", toChain: (x) => Math.round(x * 100), fromChain: (x) => x / 100 },
+    { v: VAR.HOUR, label: "hour of the day", unit: "UTC", toChain: (x) => Math.round(x), fromChain: (x) => x },
+    { v: VAR.WEEKDAY, label: "weekday", unit: "0 = Sunday", toChain: (x) => Math.round(x), fromChain: (x) => x },
+    { v: VAR.BUYS, label: "buys since launch", unit: "buys", toChain: (x) => Math.round(x), fromChain: (x) => x },
+    { v: VAR.HOLDERS, label: "holders", unit: "wallets", toChain: (x) => Math.round(x), fromChain: (x) => x },
+    { v: VAR.IDLE, label: "time since the last buy", unit: "minutes", toChain: (x) => Math.round(x * MIN), fromChain: (x) => x / MIN },
+    { v: VAR.POTSIZE, label: "the pot", unit: "% of supply", toChain: (x) => ppm(x), fromChain: (x) => x / 10_000 },
+    { v: VAR.FLAGS, label: "marks of the coins", unit: "", toChain: (x) => x, fromChain: (x) => x, lotOnly: true },
+];
+export const VAR_BY_ID = new Map(VARS.map((d) => [d.v, d]));
+export function emptyEditRow() {
+    return { on: ON.SELL, act: ACT.DENY, arg: 0, conds: [{ v: VAR.AGE, op: OP.LT, x: 30 }] };
+}
+/** The editor's row as an on chain row. A window (MODLT / MODGE on the launch time) packs period << 20 | minutes. */
+export function editToRow(e) {
+    return {
+        on: e.on,
+        act: e.act,
+        arg: e.act === ACT.LOCK || e.act === ACT.BURN || e.act === ACT.POT || e.act === ACT.DROP ? Math.round(e.arg * 100) : e.act === ACT.FLAG ? e.arg : 0,
+        conds: e.conds.slice(0, 4).map((k) => {
+            // every n-th buy
+            if (k.v === VAR.BUYS && k.op === OP.MODGE)
+                return { v: VAR.BUYS, op: OP.MODGE, val: every(k.x) };
+            if (k.op === OP.MODLT || k.op === OP.MODGE) {
+                const period = Math.round((k.period ?? 60) * MIN);
+                return { v: VAR.LAUNCH, op: k.op, val: (BigInt(period) << BigInt(20)) | BigInt(Math.round(k.x * MIN)) };
+            }
+            const d = VAR_BY_ID.get(k.v);
+            return { v: k.v, op: k.op, val: BigInt(Math.max(0, d ? d.toChain(k.x) : Math.round(k.x))) };
+        }),
+    };
+}
+const ALL_HOURS = (1 << 24) - 1;
+const ALL_DAYS = (1 << 7) - 1;
+export const HOLD_LIMITS = { maxAgeDays: 7, maxHoldBlocks: 1_000_000, minSellCapPpm: 500 };
+/**
+ * A drop row that pays on every buy: no condition, or only ones every buy meets (the coins of a buy are 0 seconds old,
+ * a stranger's coins are not the creator's). Bots then buy small again and again and empty the pot.
+ */
+export function dropOnEveryBuy(r) {
+    return r.act === ACT.DROP && r.conds.every((k) => (k.v === VAR.AGE && k.op === OP.LT) || (k.v === VAR.FLAGS && k.op === OP.NOT));
+}
+export function holdOf(r) {
+    const h = { ends: false, window: false, hasHour: false, hours: ALL_HOURS, hasDay: false, days: ALL_DAYS };
+    for (const k of r.conds) {
+        const n = Number(k.val);
+        if (k.v === VAR.FLAGS) {
+            if (k.op === OP.HAS && n === FLAG.DEV)
+                h.ends = true; // the creator's coins only
+        }
+        else if (k.op === OP.MODLT || k.op === OP.MODGE) {
+            if (k.v === VAR.LAUNCH)
+                h.window = true;
+        }
+        else if (k.v === VAR.AGE) {
+            if (k.op === OP.LT)
+                h.ends = true;
+        }
+        else if (k.v === VAR.LAUNCH) {
+            if (k.op === OP.LT && n <= HOLD_LIMITS.maxAgeDays * DAY)
+                h.ends = true;
+        }
+        else if (k.v === VAR.BLOCKS) {
+            if (k.op === OP.LT && n <= HOLD_LIMITS.maxHoldBlocks)
+                h.ends = true;
+        }
+        else if (k.v === VAR.AMOUNT) {
+            if (k.op === OP.GE && n >= HOLD_LIMITS.minSellCapPpm)
+                h.ends = true;
+        }
+        else if (k.v === VAR.HOUR && n >= 1 && n <= 23) {
+            const below = (1 << n) - 1;
+            h.hours &= k.op === OP.LT ? below : ALL_HOURS & ~below;
+            h.hasHour = true;
+        }
+        else if (k.v === VAR.WEEKDAY && n >= 1 && n <= 6) {
+            const below = (1 << n) - 1;
+            h.days &= k.op === OP.LT ? below : ALL_DAYS & ~below;
+            h.hasDay = true;
+        }
+    }
+    return h;
+}
+const stopsSells = (r) => r.act === ACT.DENY && (r.on & (ON.SELL | ON.SEND)) !== 0;
+/** The validator's checks for one row, as sentences (the chain checks again at launch). */
+export function rowProblems(r) {
+    const out = [];
+    if (r.on === 0 || r.on > 7)
+        out.push("Pick buy, sell or send.");
+    if (r.act !== ACT.DENY && r.on !== ON.BUY)
+        out.push("Mark, lock, burn, pot and drop work on buys only.");
+    if (r.act === ACT.FLAG && !(r.arg >= 1 && r.arg <= 3))
+        out.push("Pick a mark.");
+    if (r.act === ACT.LOCK && !(r.arg >= 1 && r.arg <= 10_000))
+        out.push("Lock: 0.01 to 100 % of the buy.");
+    if (r.act === ACT.BURN && !(r.arg >= 1 && r.arg <= 1000))
+        out.push("Burn: 0.01 to 10 % of the buy.");
+    if (r.act === ACT.POT && !(r.arg >= 1 && r.arg <= 1000))
+        out.push("Pot: 0.01 to 10 % of the buy.");
+    if (r.act === ACT.DROP && !(r.arg >= 1 && r.arg <= 10_000))
+        out.push("Drop: 0.01 to 100 % of the pot.");
+    for (const k of r.conds) {
+        const n = Number(k.val);
+        if (k.v === VAR.FLAGS) {
+            if (k.op === OP.NOT && n !== FLAG.DEV)
+                out.push('"Not marked" only works with the creator\'s coins.');
+            continue;
+        }
+        if (k.v === VAR.BUYS && (k.op === OP.MODLT || k.op === OP.MODGE)) {
+            const n = Number(k.val >> BigInt(20));
+            const at = Number(k.val & BigInt(0xfffff));
+            if (!(n >= 2 && n <= 1_000_000 && at > 0 && at < n))
+                out.push("Every n-th buy: n from 2 to 1,000,000.");
+            continue;
+        }
+        if (k.op === OP.MODLT || k.op === OP.MODGE) {
+            const period = Number(k.val >> BigInt(20));
+            const th = Number(k.val & BigInt(0xfffff));
+            const open = k.op === OP.MODLT ? period - th : th;
+            if (!(period > 0 && period <= DAY && th > 0 && th < period && open >= 60))
+                out.push("Window: a period of at most a day, open at least a minute.");
+            continue;
+        }
+        if (k.v === VAR.AGE) {
+            if (n > 30 * DAY)
+                out.push("Age: at most 30 days.");
+            else if (k.op === OP.LT && n > 7 * DAY)
+                out.push("Age: at most 7 days.");
+        }
+        else if (k.v === VAR.PRICE) {
+            if (n > 1e9)
+                out.push("Price: at most 100,000x the start.");
+        }
+        else if (k.v === VAR.BUYS || k.v === VAR.HOLDERS) {
+            if (n > 1e9)
+                out.push("Count: at most 1,000,000,000.");
+        }
+        else if (k.v === VAR.LAUNCH) {
+            if (n > 30 * DAY)
+                out.push("Time since launch: at most 30 days.");
+        }
+        else if (k.v === VAR.BLOCKS) {
+            if (n > 6_000_000)
+                out.push("Blocks: at most 6,000,000.");
+        }
+        else if (k.v === VAR.AMOUNT || k.v === VAR.BALANCE) {
+            if (!(n >= 1 && n <= 1e6))
+                out.push("Size: more than 0 and at most 100 %.");
+        }
+        else if (k.v === VAR.HOUR) {
+            if (!(n >= 1 && n <= 23))
+                out.push("Hour: 1 to 23.");
+        }
+        else if (k.v === VAR.WEEKDAY) {
+            if (!(n >= 1 && n <= 6))
+                out.push("Weekday: 1 to 6.");
+        }
+        else if ((k.v === VAR.DIP || k.v === VAR.SOLD) && n > 10_000) {
+            out.push("Share: at most 100 %.");
+        }
+        else if (k.v === VAR.IDLE && n > 30 * DAY) {
+            out.push("Time since the last buy: at most 30 days.");
+        }
+        else if (k.v === VAR.POTSIZE && n > 1e6) {
+            out.push("The pot: at most 100 % of the supply.");
+        }
+    }
+    const h = holdOf(r);
+    if (stopsSells(r) && !h.ends && !h.window && !h.hasHour && !h.hasDay) {
+        out.push("A row that stops sells or sends must let go by itself: the coins' age or the time since launch up to 7 days, blocks since launch up to 1,000,000, a size from 0.05 % of the supply on, the creator's coins only, or a clock (one window, hours, weekdays).");
+    }
+    return out;
+}
+/** Checks of the whole table that no single row shows: burn and pot together, a pot without a drop. */
+export function tableProblems(rows) {
+    const out = [];
+    const sum = (a) => rows.filter((r) => r.act === a).reduce((x, r) => x + r.arg, 0);
+    const burn = sum(ACT.BURN);
+    const pot = sum(ACT.POT);
+    if (burn + pot > STICKY_LIMITS.maxTakePct * 100)
+        out.push(pot ? `Burn and pot: at most ${STICKY_LIMITS.maxTakePct} % of a buy together.` : `Auto burn: at most ${STICKY_LIMITS.maxBurnPct} % in total.`);
+    if (pot && !rows.some((r) => r.act === ACT.DROP))
+        out.push("A pot needs a drop row that pays it out.");
+    // the rows that close sells or sends only by the clock must leave a way out every week
+    let windows = 0;
+    let hours = 0;
+    let days = 0;
+    for (const r of rows) {
+        if (!stopsSells(r))
+            continue;
+        const h = holdOf(r);
+        if (h.ends)
+            continue;
+        if (h.window)
+            windows++;
+        else if (h.hasHour)
+            hours |= h.hours;
+        else if (h.hasDay)
+            days |= h.days;
+    }
+    if (windows > 1 || (windows === 1 && (hours || days)))
+        out.push("One sell window at most, and not next to rows on hours or weekdays.");
+    if (hours === ALL_HOURS)
+        out.push("The rows on hours close every hour of the day: leave one open.");
+    if (days === ALL_DAYS)
+        out.push("The rows on weekdays close every day: leave one open.");
+    return out;
+}
+// ---------------------------------------------------------------- reading a coin's table back
+const dur = (s) => s % DAY === 0 ? `${s / DAY} ${s === DAY ? "day" : "days"}` : s % HOUR === 0 ? `${s / HOUR} ${s === HOUR ? "hour" : "hours"}` : s % MIN === 0 ? `${s / MIN} min` : `${s} s`;
+const pctOf = (ppmVal) => `${+(ppmVal / 10_000).toFixed(3)} %`;
+const flagName = (f) => [f & FLAG.SNIPER ? "marked as sniper" : "", f & FLAG.MARK ? "marked" : "", f & FLAG.DEV ? "the creator's" : ""].filter(Boolean).join(" or ");
+const ordinal = (n) => `${n}${n % 100 >= 11 && n % 100 <= 13 ? "th" : (["th", "st", "nd", "rd"][n % 10] ?? "th")}`;
+const markAs = (f) => [f & FLAG.SNIPER ? "sniper coins" : "", f & FLAG.MARK ? "marked coins" : ""].filter(Boolean).join(" and ");
+function condText(k) {
+    const n = Number(k.val);
+    switch (k.v) {
+        case VAR.AGE:
+            return k.op === OP.LT ? `the coins are younger than ${dur(n)}` : `the coins are at least ${dur(n)} old`;
+        case VAR.LAUNCH:
+            if (k.op === OP.MODLT || k.op === OP.MODGE) {
+                const period = Number(k.val >> BigInt(20));
+                const th = Number(k.val & BigInt(0xfffff));
+                return k.op === OP.MODGE ? `outside the first ${dur(th)} of every ${dur(period)}` : `inside the first ${dur(th)} of every ${dur(period)}`;
+            }
+            return k.op === OP.LT ? `the coin is younger than ${dur(n)}` : `the coin is at least ${dur(n)} old`;
+        case VAR.BLOCKS:
+            return k.op === OP.LT ? `in the first ${n} blocks` : `after the first ${n} blocks`;
+        case VAR.AMOUNT:
+            return k.op === OP.GE ? `the trade is ${pctOf(n)} of the supply or more` : `the trade is under ${pctOf(n)} of the supply`;
+        case VAR.BALANCE:
+            return k.op === OP.GE ? `the wallet holds ${pctOf(n)} of the supply or more` : `the wallet holds under ${pctOf(n)} of the supply`;
+        case VAR.PRICE:
+            return k.op === OP.LT ? `the price is under ${(n / 10_000).toFixed(2)}x the start` : `the price is at least ${(n / 10_000).toFixed(2)}x the start`;
+        case VAR.DIP:
+            return k.op === OP.LT ? `the price is more than ${100 - n / 100} % under the high of the hour` : `the price is within ${100 - n / 100} % of the high of the hour`;
+        case VAR.SOLD:
+            return k.op === OP.LT ? `under ${n / 100} % of the curve is sold` : `${n / 100} % of the curve or more is sold`;
+        case VAR.HOUR:
+            return k.op === OP.LT ? `before ${n}:00 UTC` : `from ${n}:00 UTC`;
+        case VAR.WEEKDAY:
+            return k.op === OP.LT ? `before ${["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][n]}` : `from ${["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][n]} on`;
+        case VAR.FLAGS:
+            return k.op === OP.HAS ? `the coins are ${flagName(n)}` : `the coins are not ${flagName(n)}`;
+        case VAR.BUYS: {
+            if (k.op === OP.MODGE || k.op === OP.MODLT) {
+                const m = Number(k.val >> BigInt(20));
+                const at = Number(k.val & BigInt(0xfffff));
+                return k.op === OP.MODGE && at === m - 1 ? `it is the ${ordinal(m)} buy, the ${ordinal(2 * m)}, and so on` : `the count of buys modulo ${m} is ${k.op === OP.MODGE ? "at least" : "under"} ${at}`;
+            }
+            return k.op === OP.LT ? `the coin has had fewer than ${n} buys` : `the coin has had ${n} buys or more`;
+        }
+        case VAR.HOLDERS:
+            return k.op === OP.LT ? `fewer than ${n} wallets hold the coin` : `${n} wallets or more hold the coin`;
+        case VAR.IDLE:
+            return k.op === OP.LT ? `the last buy was less than ${dur(n)} ago` : `nobody bought for ${dur(n)}`;
+        case VAR.POTSIZE:
+            return k.op === OP.LT ? `the pot holds under ${pctOf(n)} of the supply` : `the pot holds ${pctOf(n)} of the supply or more`;
+    }
+    return "a condition the site does not know";
+}
+function onText(on) {
+    const parts = [on & ON.BUY ? "buy" : "", on & ON.SELL ? "sell" : "", on & ON.SEND ? "send" : ""].filter(Boolean);
+    return parts.length > 1 ? `${parts.slice(0, -1).join(", ")} or ${parts[parts.length - 1]}` : parts[0] ?? "trade";
+}
+/** One row as a sentence, for the coin page and the API. */
+export function rowText(r, release) {
+    const when = r.conds.length ? ` when ${r.conds.map(condText).join(" and ")}` : "";
+    switch (r.act) {
+        case ACT.DENY:
+            return `A ${onText(r.on)} is refused${when}.`;
+        case ACT.FLAG:
+            return `A buy marks the new coins as ${markAs(r.arg)}${when}.`;
+        case ACT.LOCK:
+            return `${r.arg / 100} % of a buy unlocks over ${dur(release)}${when}.`;
+        case ACT.BURN:
+            return `${r.arg / 100} % of a buy is burned${when}.`;
+        case ACT.POT:
+            return `${r.arg / 100} % of a buy goes into the pot${when}.`;
+        case ACT.DROP:
+            return `A buy also gets ${r.arg / 100} % of the pot, up to as many coins as it buys${when}. Never the creator's buys.`;
+    }
+    return "A row the site does not know.";
+}
+/** Which template a row belongs to, by its shape (null for a custom row). */
+export function templateOf(r) {
+    const shape = (x) => `${x.on}:${x.act}:${x.conds.map((k) => `${k.v}.${k.op}`).join(",")}`;
+    const s = shape(r);
+    for (const t of TEMPLATES) {
+        // defaults and every number at its maximum: covers the branches of a template (drip for every buy or big ones)
+        const variants = [defaults(t), Object.fromEntries(t.params.map((q) => [q.key, q.max]))];
+        if (variants.some((p) => t.rows(p).some((x) => shape(x) === s)))
+            return t.id;
+    }
+    return null;
+}
+/** Scanner color of a whole table: the worst of its templates. */
+export function scannerOf(rows) {
+    let worst = "green";
+    for (const r of rows) {
+        const id = templateOf(r);
+        // drip on every buy: a scanner's test sell fails; drip on big buys only: its small test passes
+        const s = id === "drip" && r.conds.length === 0 ? "red" : id ? TEMPLATE_BY_ID.get(id).scanner : "yellow";
+        if (s === "red")
+            return "red";
+        if (s === "yellow")
+            worst = "yellow";
+    }
+    return worst;
+}