@pickhooks/sdk 0.0.0-stage → 0.4.0

package/dist/coin-rules.js

@@ -0,0 +1,878 @@
+// Copied from web/src/lib/rules.ts (the site's rule catalog for coins with rules in the coin and in the pool), with one line changed:
+// the import of the site's config. Keep the two in step: node scripts/check-rules-copy.mjs compares them.
+/**
+ * The rule catalog for hooks on BNB: one entry per rule of HooksToken (src/HooksToken.sol).
+ * The launcher builds its form from `fields` and turns the values into the token's `Rules` struct
+ * with `apply`; the coin page explains a live rule with `describe` and `live`.
+ * Every rule says what a scanner (GoPlus, honeypot.is) will make of it: `scanner`.
+ * Shared by client and server.
+ */
+import { V2 } from "./coin-rules-config.js";
+export const SUPPLY = 1_000_000_000;
+export const MAX_RULES = 8;
+export const DAY = 86_400;
+const E18 = BigInt(10) ** BigInt(18);
+/** Binance Account Bound Token: the soulbound token of identity-verified Binance users, one per account, balanceOf is 0 or 1. */
+export const BABT = "0x2B09d47D550061f995A3b5C6F0Fd58005215D7c8";
+/** The pickhooks token on BNB Chain (flap, migrated to PancakeSwap). Gate for the set "$hooks holders only". */
+export const HOOKS_TOKEN = "0x07bcB8E8226f671300e135b4A61Dc157359b7777";
+export const GROUPS = [
+    { id: "hold", title: "Who can hold", blurb: "Caps, clubs and gates." },
+    { id: "buy", title: "How you buy", blurb: "Size, pace and order of buys." },
+    { id: "sell", title: "How you sell", blurb: "Sell caps, holds and locks." },
+    { id: "time", title: "When it trades", blurb: "Clocks, turns and windows." },
+    { id: "games", title: "Games", blurb: "Rules that turn trading into play." },
+    { id: "pay", title: "Who gets paid", blurb: "BNB that moves with buys." },
+    { id: "linked", title: "Linked coins", blurb: "One coin reacts to another." },
+    { id: "move", title: "Where it moves", blurb: "Pool only or wallet to wallet." },
+    { id: "hooks", title: "Hooks rules", blurb: "Shows that cost $hooks." },
+    { id: "trust", title: "Trust", blurb: "The dev earns it, the coin defends itself." },
+];
+const G = (note = "Scanners see nothing special.") => ({ level: "green", note });
+const Y = (note) => ({ level: "yellow", note });
+const RED = (note) => ({ level: "red", note });
+const WHALE = Y('Scanners show "anti whale". A hint, not a red flag.');
+const SELLCAP = RED('A sell cap per trade: scanners show "cannot sell all" and many buyers read that as a red flag.');
+const HONEYPOT = RED("A fresh wallet cannot sell right after buying. Scanners test exactly that and will mark the coin as a honeypot.");
+const ZERO = "0x0000000000000000000000000000000000000000";
+export function emptyRules() {
+    return {
+        mask: BigInt(0),
+        maxWalletBps: 0, riseStartBps: 0, riseStepBps: 0, riseSeconds: 0,
+        chapterStartBps: 0, chapterVolume: BigInt(0), clubMax: 0, gateToken: ZERO, gateMin: BigInt(0),
+        maxTradeBps: 0, buysPerBlock: 0, maxGasPrice: BigInt(0), raiseBps: 0, raiseReset: 0,
+        minBuy: BigInt(0), slowSeconds: 0, buyLimit: 0,
+        dumpBuyBps: 0, dumpSellBps: 0, curveSmallBps: 0, curveFloorBps: 0, curveBigBagBps: 0,
+        taperStartBps: 0, taperEndBps: 0, taperSoldBps: 0, unlockBuys: 0,
+        devLockSeconds: 0, devCapBps: 0, devGapSeconds: 0, diamondSeconds: 0, cooldownSeconds: 0,
+        jailWindow: 0, jailSeconds: 0,
+        openHour: 0, closeHour: 0, weekdays: 0, sellsOpen: false,
+        sellWindow: 0, sellPeriod: 0, tickSeconds: 0, bellSeconds: 0, bellSoldBps: 0,
+        rewardPerBuy: BigInt(0), rewardMinBuy: BigInt(0), rewardEveryN: 0,
+        jackpotSilence: 0, jackpotShareBps: 0, jackpotMinBuy: BigInt(0), jackpotFeeBps: 0,
+        dipBps: 0, beacon: ZERO, beaconTargetBps: 0, partner: ZERO, reactBaseBps: 0, reactSensitivity: 0,
+    };
+}
+export function emptyExtras() {
+    return {
+        buyoutMask: BigInt(0),
+        buyoutPrice: [BigInt(0), BigInt(0), BigInt(0), BigInt(0), BigInt(0), BigInt(0), BigInt(0), BigInt(0)],
+        votable: BigInt(0), quorumBps: 0, voteSeconds: 0,
+        duelOpponent: ZERO, duelStake: BigInt(0),
+        feed: ZERO, target: BigInt(0), sellsAtSeconds: 0,
+        deadManSeconds: 0,
+        floorDeposit: BigInt(0), floorBps: 0,
+        shiftSeconds: 0, payrollMin: BigInt(0), payrollDeposit: BigInt(0),
+        creatorKeepBps: 10_000,
+    };
+}
+// ---------------------------------------------------------------- formatting
+export function pct(bps) {
+    const v = bps / 100;
+    return `${v >= 10 ? Math.round(v * 10) / 10 : Number(v.toPrecision(3))}%`;
+}
+export function dur(s) {
+    if (s < 90)
+        return `${Math.round(s)}s`;
+    if (s < 5400)
+        return `${Math.round(s / 60)} min`;
+    if (s < 2 * DAY)
+        return `${Math.round((s / 3600) * 10) / 10} h`;
+    return `${Math.round((s / DAY) * 10) / 10} days`;
+}
+export const bnb = (v) => `${Number(v.toPrecision(4))} BNB`;
+export const short = (a) => (a && a !== ZERO ? `${a.slice(0, 6)}..${a.slice(-4)}` : "none");
+const DAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+export const tokens = (t) => `${t.toLocaleString("en-US", { maximumFractionDigits: 0 })} tokens`;
+const bps = (p) => Math.round(Number(p) * 100);
+const n = (v) => Math.round(Number(v));
+/** share of supply in % -> raw token units */
+const supplyShare = (p) => (BigInt(Math.round(Number(p) * 1e6)) * BigInt(SUPPLY) * E18) / BigInt(1e8);
+const wei = (b) => BigInt(Math.round(Number(b) * 1e9)) * BigInt(1e9);
+export const fromRaw = (x) => Number(x / BigInt(1e12)) / 1e6;
+const shareOf = (raw) => Math.round((fromRaw(raw) / SUPPLY) * 10_000);
+const age = (s, now) => Math.max(0, now - s.start);
+const bit = (id) => BigInt(1) << BigInt(id);
+/** UI days: bit 0 = Monday. Token: bit 0 = Sunday. */
+const toChainDays = (mask) => DAYS.reduce((m, _, i) => ((mask >> i) & 1 ? m | (1 << ((i + 1) % 7)) : m), 0);
+const fromChainDays = (mask) => DAYS.reduce((m, _, i) => ((mask >> ((i + 1) % 7)) & 1 ? m | (1 << i) : m), 0);
+const hh = (h) => `${String(h).padStart(2, "0")}:00`;
+/** rule kinds of the v1 catalog (the v2 factory takes them all as well) */
+export const V1_KINDS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 28, 31, 34, 35, 36, 37, 38];
+/** rules that only restrict trading: the only ones a buyout or a vote can lift (never trust rules, games, pots or linked coins) */
+export const LIFTABLE = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 28, 38, 42];
+/** rules that cannot have an end time on the v2 factory: trust rules, pots, games and the v2 machinery */
+export const NO_UNTIL = [21, 31, 36, 39, 40, 41, 42, 43, 44, 45, 46];
+export const FEED_NAMES = ["BNB", "BTC", "ETH", "DOGE"];
+const feedAddress = (i) => V2.feeds[FEED_NAMES[Number(i)] ?? "BNB"];
+const feedName = (addr) => FEED_NAMES.find((k) => V2.feeds[k].toLowerCase() === addr.toLowerCase()) ?? "the feed";
+const usd = (v) => `${v.toLocaleString("en-US", { maximumFractionDigits: v < 10 ? 4 : 0 })} USD`;
+/** the kinds a comma list names, kept to the rules that are picked and can be lifted */
+const listedKinds = (v, picked) => {
+    const chosen = String(v ?? "").split(",").map((s) => Number(s.trim())).filter((k) => Number.isInteger(k) && k > 0);
+    const present = new Set(picked.map((p) => RULE_BY_ID.get(p.id)?.kind ?? 0));
+    return chosen.filter((k) => LIFTABLE.includes(k) && present.has(k)).sort((a, b) => a - b);
+};
+const maskOf = (kinds) => kinds.reduce((m, k) => m | bit(k), BigInt(0));
+const namesOf = (mask) => kindsOf(mask).map((k) => RULE_BY_KIND.get(k)?.name ?? `rule ${k}`).join(", ");
+const SHIFT_LABEL = { 14_400: "4 hour", 28_800: "8 hour", 86_400: "24 hour" };
+// ---------------------------------------------------------------- the rules
+export const RULES = [
+    // who can hold
+    {
+        kind: 1, id: "max_wallet", name: "Max wallet", group: "hold", scanner: WHALE,
+        line: "No wallet holds more than a share of supply.",
+        fields: [{ id: "cap", label: "Max per wallet", kind: "pct", def: 1, min: 0.1, max: 100 }],
+        apply: (v) => ({ maxWalletBps: bps(v.cap) }),
+        describe: (r) => `No wallet holds more than ${pct(r.maxWalletBps)} of supply.`,
+    },
+    {
+        kind: 10, id: "rising_wallet", name: "Rising max wallet", group: "hold", scanner: WHALE,
+        line: "The cap starts tiny and rises on a timer, by a step or doubling.",
+        fields: [
+            { id: "start", label: "Cap at launch", kind: "pct", def: 0.2, min: 0.1, max: 100 },
+            { id: "double", label: "Double every step instead of adding", kind: "bool", def: false },
+            { id: "step", label: "Added every step", kind: "pct", def: 0.2, min: 0.01, max: 100, hint: "ignored when doubling" },
+            { id: "every", label: "Step every", kind: "dur", def: 600, min: 60, max: 7 * DAY },
+        ],
+        apply: (v) => ({ riseStartBps: bps(v.start), riseStepBps: v.double ? 0 : bps(v.step), riseSeconds: n(v.every) }),
+        describe: (r) => `Max wallet starts at ${pct(r.riseStartBps)} and ${r.riseStepBps === 0 ? "doubles" : `rises by ${pct(r.riseStepBps)}`} every ${dur(r.riseSeconds)}.`,
+        live: (r, s, now) => {
+            const steps = Math.floor(age(s, now) / r.riseSeconds);
+            const cap = Math.min(10_000, r.riseStepBps === 0 ? r.riseStartBps * 2 ** Math.min(steps, 14) : r.riseStartBps + r.riseStepBps * steps);
+            return cap >= 10_000 ? "No cap anymore." : `Cap now ${pct(cap)}, next step in ${dur(r.riseSeconds - (age(s, now) % r.riseSeconds))}.`;
+        },
+    },
+    {
+        kind: 6, id: "chapters", name: "Chapters", group: "hold", scanner: WHALE,
+        line: "The wallet cap doubles every time a set volume has traded.",
+        fields: [
+            { id: "start", label: "Cap in chapter 1", kind: "pct", def: 0.5, min: 0.1, max: 100 },
+            { id: "volume", label: "Volume per chapter (share of supply traded)", kind: "pct", def: 10, min: 0.1, max: 1000 },
+        ],
+        apply: (v) => ({ chapterStartBps: bps(v.start), chapterVolume: supplyShare(v.volume) }),
+        describe: (r) => `Max wallet ${pct(r.chapterStartBps)}, doubling every time ${pct(shareOf(r.chapterVolume))} of supply has traded.`,
+        live: (r, s) => {
+            const ch = Math.min(14, Math.floor(s.volumeTokens / fromRaw(r.chapterVolume)));
+            return `Chapter ${ch + 1}: cap ${pct(Math.min(10_000, r.chapterStartBps * 2 ** ch))}.`;
+        },
+    },
+    {
+        kind: 17, id: "holder_cap", name: "The club", group: "hold", scanner: Y("While the club is full, a scanner's test buy fails and can show \"cannot buy\"."),
+        line: "Only so many holders at a time. A seat opens when someone sells out.",
+        fields: [{ id: "max", label: "Seats", kind: "int", def: 100, min: 10, max: 1_000_000 }],
+        apply: (v) => ({ clubMax: n(v.max) }),
+        describe: (r) => `At most ${r.clubMax} holders at a time.`,
+        live: (r, s) => (s.holders >= r.clubMax ? `Full: ${s.holders} of ${r.clubMax} seats.` : `${r.clubMax - s.holders} of ${r.clubMax} seats free.`),
+    },
+    {
+        kind: 8, id: "gated", name: "Holder gated", group: "hold",
+        scanner: RED("A scanner's test wallet holds no gate token, so its buy fails: likely shown as \"cannot buy\", plus \"external call\"."),
+        line: "Only wallets that hold another token can buy or receive. Works with NFTs and soulbound tokens too, for example the Binance Account Bound Token.",
+        fields: [
+            { id: "gate", label: "Gate token (BNB Chain address)", kind: "address" },
+            { id: "min", label: "Smallest amount to hold", kind: "int", def: 1, min: 1, max: 1_000_000_000_000, hint: "whole tokens, or pieces for an NFT or soulbound token" },
+            { id: "nft", label: "Gate token counts pieces (NFT or soulbound token, no decimals)", kind: "bool", def: false, hint: "tick this for BABT and other NFTs" },
+        ],
+        apply: (v) => ({ gateToken: String(v.gate).trim(), gateMin: v.nft ? BigInt(n(v.min)) : BigInt(n(v.min)) * E18 }),
+        describe: (r) => r.gateToken.toLowerCase() === BABT.toLowerCase()
+            ? "Only verified Binance users can buy or receive: wallets with a Binance Account Bound Token."
+            : r.gateToken.toLowerCase() === HOOKS_TOKEN.toLowerCase()
+                ? `Only wallets with at least ${Number(r.gateMin / E18).toLocaleString("en-US")} $hooks can buy or receive.`
+                : `Only holders of ${short(r.gateToken)} can receive.`,
+    },
+    // how you buy
+    {
+        kind: 2, id: "max_tx", name: "Max per buy", alias: "Trade guard", group: "buy", scanner: WHALE,
+        line: "No single buy over a share of supply.",
+        fields: [{ id: "cap", label: "Max per buy", kind: "pct", def: 0.5, min: 0.1, max: 100 }],
+        apply: (v) => ({ maxTradeBps: bps(v.cap) }),
+        describe: (r) => `No buy over ${pct(r.maxTradeBps)} of supply.`,
+    },
+    {
+        kind: 5, id: "anti_bundle", name: "Anti bundle", group: "buy", scanner: G(),
+        line: "A limit on buys per block, so nobody packs the first block.",
+        fields: [{ id: "max", label: "Buys per block", kind: "int", def: 2, min: 1, max: 64 }],
+        apply: (v) => ({ buysPerBlock: n(v.max) }),
+        describe: (r) => `At most ${r.buysPerBlock} ${r.buysPerBlock === 1 ? "buy" : "buys"} per block.`,
+    },
+    {
+        kind: 28, id: "gas_cap", name: "Gas cap", alias: "Sniper-fee cap", group: "buy", scanner: G(),
+        line: "A buy that outbids everyone with a high gas price is refused.",
+        fields: [{ id: "gwei", label: "Max gas price", kind: "gwei", def: 1, max: 1000, hint: "BNB Chain runs at about 0.05 gwei" }],
+        apply: (v) => ({ maxGasPrice: BigInt(Math.round(Number(v.gwei) * 1e9)) }),
+        describe: (r) => `Buys pay at most ${Number(r.maxGasPrice) / 1e9} gwei gas.`,
+    },
+    {
+        kind: 12, id: "raise", name: "Raise", group: "buy", scanner: Y("A small test buy right after a big buy fails."),
+        line: "Every buy must beat the last one, until nobody buys for a while.",
+        fields: [
+            { id: "by", label: "Beat the last buy by", kind: "pct", def: 1, min: 0.01, max: 100 },
+            { id: "reset", label: "Resets after a quiet", kind: "dur", def: 120, min: 10, max: DAY },
+        ],
+        apply: (v) => ({ raiseBps: bps(v.by), raiseReset: n(v.reset) }),
+        describe: (r) => `Each buy must beat the last by ${pct(r.raiseBps)}. Resets after ${dur(r.raiseReset)} without a buy.`,
+        live: (r, s, now) => {
+            if (!s.lastBuyTime || now - s.lastBuyTime >= r.raiseReset)
+                return "Open: any size goes.";
+            return `Beat ${tokens(s.lastBuyTokens * (1 + r.raiseBps / 10_000))}, or wait ${dur(r.raiseReset - (now - s.lastBuyTime))}.`;
+        },
+    },
+    {
+        kind: 13, id: "no_repeat", name: "No repeat", group: "buy", scanner: G(),
+        line: "The same wallet cannot buy twice in a row.",
+        fields: [],
+        apply: () => ({}),
+        describe: () => "No wallet buys twice in a row.",
+        live: (_r, s) => (s.lastBuyer ? `Last buyer ${short(s.lastBuyer)} waits for someone else.` : null),
+    },
+    {
+        kind: 18, id: "min_buy", name: "Min buy", group: "buy", scanner: Y("A scanner that tests with a tiny buy sees it fail."),
+        line: "No dust: every buy has a smallest size.",
+        fields: [{ id: "min", label: "Smallest buy (share of supply)", kind: "pct", def: 0.01, min: 0.0001, max: 1 }],
+        apply: (v) => ({ minBuy: supplyShare(v.min) }),
+        describe: (r) => `Every buy is at least ${tokens(fromRaw(r.minBuy))}.`,
+    },
+    {
+        kind: 19, id: "slow_mode", name: "Slow mode", group: "buy", scanner: Y("A test buy right after another buy fails."),
+        line: "One buy every so often, for everyone.",
+        fields: [{ id: "gap", label: "Time between buys", kind: "dur", def: 10, min: 1, max: 3600 }],
+        apply: (v) => ({ slowSeconds: n(v.gap) }),
+        describe: (r) => `One buy every ${dur(r.slowSeconds)}.`,
+        live: (r, s, now) => (s.lastBuyTime && now - s.lastBuyTime < r.slowSeconds ? `Next buy opens in ${dur(r.slowSeconds - (now - s.lastBuyTime))}.` : "Open now."),
+    },
+    {
+        kind: 23, id: "buy_limit", name: "Buy limit", group: "buy", scanner: G(),
+        line: "Each wallet buys a set number of times. Counted on the wallet that signs.",
+        fields: [{ id: "max", label: "Buys per wallet", kind: "int", def: 1, min: 1, max: 100 }],
+        apply: (v) => ({ buyLimit: n(v.max) }),
+        describe: (r) => `Each wallet buys ${r.buyLimit === 1 ? "once" : `${r.buyLimit} times`}.`,
+    },
+    // how you sell
+    {
+        kind: 3, id: "anti_dump", name: "Anti dump", group: "sell", scanner: SELLCAP,
+        line: "Separate caps for a buy and for a sell.",
+        fields: [
+            { id: "buy", label: "Max buy", kind: "pct", def: 1, min: 0.1, max: 100 },
+            { id: "sell", label: "Max sell", kind: "pct", def: 0.25, min: 0.1, max: 100 },
+        ],
+        apply: (v) => ({ dumpBuyBps: bps(v.buy), dumpSellBps: bps(v.sell) }),
+        describe: (r) => `Max buy ${pct(r.dumpBuyBps)}, max sell ${pct(r.dumpSellBps)} of supply at once.`,
+    },
+    {
+        kind: 4, id: "sell_curve", name: "Sell curve", alias: "Graduated sell caps", group: "sell", scanner: SELLCAP,
+        line: "The bigger the bag, the smaller the share of supply it can sell at once.",
+        fields: [
+            { id: "small", label: "Sell cap for a small bag", kind: "pct", def: 1, min: 0.05, max: 100 },
+            { id: "floor", label: "Sell cap for a big bag", kind: "pct", def: 0.1, min: 0.05, max: 100 },
+            { id: "big", label: "A big bag is", kind: "pct", def: 3, min: 0.01, max: 100, hint: "share of supply" },
+        ],
+        apply: (v) => ({ curveSmallBps: bps(v.small), curveFloorBps: bps(v.floor), curveBigBagBps: bps(v.big) }),
+        describe: (r) => `Small bags sell up to ${pct(r.curveSmallBps)} at once, bags of ${pct(r.curveBigBagBps)} or more only ${pct(r.curveFloorBps)}.`,
+    },
+    {
+        kind: 11, id: "taper", name: "Taper", alias: "Sliding caps", group: "sell", scanner: SELLCAP,
+        line: "The sell cap shrinks as the curve sells out.",
+        fields: [
+            { id: "start", label: "Sell cap at launch", kind: "pct", def: 1, min: 0.05, max: 100 },
+            { id: "end", label: "Sell cap at the end", kind: "pct", def: 0.2, min: 0.05, max: 100 },
+            { id: "at", label: "End reached when the curve has sold", kind: "pct", def: 80, min: 1, max: 100 },
+        ],
+        apply: (v) => ({ taperStartBps: bps(v.start), taperEndBps: bps(v.end), taperSoldBps: bps(v.at) }),
+        describe: (r) => `Sell cap goes from ${pct(r.taperStartBps)} down to ${pct(r.taperEndBps)} as the curve sells ${pct(r.taperSoldBps)}.`,
+        live: (r, s) => `Sell cap now ${pct(r.taperStartBps - Math.floor(((r.taperStartBps - r.taperEndBps) * Math.min(s.soldBps, r.taperSoldBps)) / r.taperSoldBps))}.`,
+    },
+    {
+        kind: 14, id: "buys_unlock", name: "Buys unlock sells", group: "sell", scanner: HONEYPOT,
+        line: "A number of buys has to happen before the next sell.",
+        fields: [{ id: "buys", label: "Buys per sell", kind: "int", def: 3, min: 1, max: 20 }],
+        apply: (v) => ({ unlockBuys: n(v.buys) }),
+        describe: (r) => `${r.unlockBuys} ${r.unlockBuys === 1 ? "buy unlocks" : "buys unlock"} the next sell.`,
+        live: (r, s) => (s.buysSinceSell >= r.unlockBuys ? "A sell is unlocked." : `${r.unlockBuys - s.buysSinceSell} more ${r.unlockBuys - s.buysSinceSell === 1 ? "buy" : "buys"} until the next sell.`),
+    },
+    {
+        kind: 21, id: "dev_lock", name: "Dev lock", group: "sell", scanner: G("Only the creator is locked. Scanners see nothing."),
+        line: "The dev cannot sell or send for a while, then only in small pieces.",
+        fields: [
+            { id: "lock", label: "Locked for", kind: "dur", def: DAY, max: 30 * DAY, zeroOk: true },
+            { id: "cap", label: "Then max per sell", kind: "pct", def: 0.5, min: 0.01, max: 100 },
+            { id: "gap", label: "Time between dev sells", kind: "dur", def: 3600, max: DAY, zeroOk: true },
+        ],
+        apply: (v) => ({ devLockSeconds: n(v.lock), devCapBps: bps(v.cap), devGapSeconds: n(v.gap) }),
+        describe: (r) => `The dev is locked for ${dur(r.devLockSeconds)}, then sells at most ${pct(r.devCapBps)} at once${r.devGapSeconds ? `, ${dur(r.devGapSeconds)} apart` : ""}.`,
+        live: (r, s, now) => (age(s, now) < r.devLockSeconds ? `Dev unlocks in ${dur(r.devLockSeconds - age(s, now))}.` : "Dev lock is over."),
+    },
+    {
+        kind: 24, id: "diamond", name: "Diamond hands", group: "sell", scanner: HONEYPOT,
+        line: "A wallet holds for a while after its last buy before it can sell.",
+        fields: [{ id: "hold", label: "Hold after each buy", kind: "dur", def: 600, min: 1, max: DAY }],
+        apply: (v) => ({ diamondSeconds: n(v.hold) }),
+        describe: (r) => `A wallet holds ${dur(r.diamondSeconds)} after its last buy before it sells.`,
+    },
+    {
+        kind: 22, id: "cooldown", name: "Cooldown", group: "sell", scanner: RED('A fresh wallet cannot sell right after buying: scanners show "trading cooldown" and may mark it as a honeypot.'),
+        line: "A wallet trades once every so often.",
+        fields: [{ id: "gap", label: "Time between trades of one wallet", kind: "dur", def: 60, min: 1, max: DAY }],
+        apply: (v) => ({ cooldownSeconds: n(v.gap) }),
+        describe: (r) => `A wallet trades once every ${dur(r.cooldownSeconds)}.`,
+    },
+    {
+        kind: 25, id: "sniper_jail", name: "Sniper jail", group: "sell", scanner: Y("Only wallets from the first seconds. A scanner that checks in that window sees a honeypot."),
+        line: "Wallets that get the coin in the first seconds sell later than everyone else.",
+        fields: [
+            { id: "window", label: "Snipers are wallets that buy in the first", kind: "dur", def: 30, min: 1, max: 3600 },
+            { id: "jail", label: "They wait after their buy", kind: "dur", def: 3600, min: 1, max: DAY },
+        ],
+        apply: (v) => ({ jailWindow: n(v.window), jailSeconds: n(v.jail) }),
+        describe: (r) => `Wallets that bought in the first ${dur(r.jailWindow)} wait ${dur(r.jailSeconds)} before they sell or send.`,
+        live: (r, s, now) => (age(s, now) < r.jailWindow ? `Sniper window open for ${dur(r.jailWindow - age(s, now))}.` : "Sniper window closed."),
+    },
+    // when it trades
+    {
+        kind: 15, id: "hours", name: "Market hours", group: "time", scanner: Y("Outside hours a test buy fails. Red when sells close too."),
+        line: "Trades only in set hours and weekdays, in UTC. Sells can stay open.",
+        fields: [
+            { id: "open", label: "Opens (UTC hour)", kind: "hour", def: 13 },
+            { id: "close", label: "Closes (UTC hour)", kind: "hour", def: 20 },
+            { id: "days", label: "Days", kind: "days", def: 0b0011111 },
+            { id: "sells", label: "Sells always open", kind: "bool", def: true },
+        ],
+        apply: (v) => ({ openHour: n(v.open), closeHour: n(v.close), weekdays: toChainDays(n(v.days)), sellsOpen: Boolean(v.sells) }),
+        describe: (r) => {
+            const days = fromChainDays(r.weekdays);
+            return `Open ${hh(r.openHour)} to ${hh(r.closeHour)} UTC${days === 127 ? ", every day" : `, ${DAYS.filter((_, i) => (days >> i) & 1).join(" ")}`}${r.sellsOpen ? ". Sells always open" : ""}.`;
+        },
+        live: (r, _s, now) => {
+            const h = Math.floor(now / 3600) % 24;
+            const day = (Math.floor(now / DAY) + 4) % 7;
+            const inHours = r.openHour < r.closeHour ? h >= r.openHour && h < r.closeHour : h >= r.openHour || h < r.closeHour;
+            return inHours && (r.weekdays >> day) & 1 ? "Open now." : "Closed now.";
+        },
+    },
+    {
+        kind: 16, id: "sell_window", name: "Sell window", group: "time", scanner: HONEYPOT,
+        line: "Sells only in the first part of every period.",
+        fields: [
+            { id: "window", label: "Sells open for", kind: "dur", def: 300, min: 60, max: DAY },
+            { id: "period", label: "Every", kind: "dur", def: 3600, min: 60, max: DAY },
+        ],
+        apply: (v) => ({ sellWindow: n(v.window), sellPeriod: n(v.period) }),
+        describe: (r) => `Sells open for ${dur(r.sellWindow)} every ${dur(r.sellPeriod)}.`,
+        live: (r, s, now) => {
+            const t = age(s, now) % r.sellPeriod;
+            return t < r.sellWindow ? `Sells open, closing in ${dur(r.sellWindow - t)}.` : `Sells closed, open again in ${dur(r.sellPeriod - t)}.`;
+        },
+    },
+    {
+        kind: 20, id: "tick_tock", name: "Tick tock", group: "time", scanner: HONEYPOT,
+        line: "Buys only, then sells only, in turns.",
+        fields: [{ id: "turn", label: "Each turn lasts", kind: "dur", def: 300, min: 60, max: DAY }],
+        apply: (v) => ({ tickSeconds: n(v.turn) }),
+        describe: (r) => `Buy turn and sell turn swap every ${dur(r.tickSeconds)}.`,
+        live: (r, s, now) => {
+            const a = age(s, now);
+            return `${Math.floor(a / r.tickSeconds) % 2 === 0 ? "Buy" : "Sell"} turn, ${dur(r.tickSeconds - (a % r.tickSeconds))} left.`;
+        },
+    },
+    {
+        kind: 38, id: "opening", name: "Opening bell", group: "time", scanner: RED("While the bell has not rung, nobody can sell: scanners checking then see a honeypot."),
+        line: "No sells for the first while, earlier once enough of the curve is sold.",
+        fields: [
+            { id: "secs", label: "No sells for", kind: "dur", def: 600, min: 1, max: DAY },
+            { id: "sold", label: "Earlier once the curve sold (0 = never)", kind: "pct", def: 0, min: 0, max: 100, zeroOk: true },
+        ],
+        apply: (v) => ({ bellSeconds: n(v.secs), bellSoldBps: Number(v.sold) > 0 ? bps(v.sold) : 10_000 }),
+        describe: (r) => `No sells for ${dur(r.bellSeconds)}${r.bellSoldBps < 10_000 ? `, or until the curve has sold ${pct(r.bellSoldBps)}` : ""}.`,
+        live: (r, s, now) => (age(s, now) >= r.bellSeconds || s.soldBps >= r.bellSoldBps ? "Sells are open." : `Bell rings in ${dur(r.bellSeconds - age(s, now))}.`),
+    },
+    // where it moves
+    {
+        kind: 7, id: "pool_only", name: "Pool only", alias: "Venue-locked", group: "move",
+        scanner: RED("Wallet to wallet is blocked. Aggregators that route through their own contract fail, and scanners may show transfers as blocked."),
+        line: "No wallet to wallet. The coin only moves through its pool.",
+        fields: [],
+        apply: () => ({}),
+        describe: () => "No wallet to wallet sends. Trade on PancakeSwap directly.",
+    },
+    {
+        kind: 9, id: "p2p_only", name: "P2P only", group: "move", scanner: RED('Nobody but the creator can buy from the pool: scanners show "cannot buy".'),
+        line: "Only the creator buys from the pool. Everyone else gets it hand to hand.",
+        fields: [],
+        apply: () => ({}),
+        describe: () => "Only the creator buys from the pool, everyone else gets it wallet to wallet. Selling back is open.",
+    },
+    // who gets paid
+    {
+        kind: 31, id: "rewards", name: "Buyer rewards", group: "pay", scanner: G(),
+        line: "Qualifying buys earn BNB from a pot you fill, or only every Nth buy.",
+        fields: [
+            { id: "amount", label: "BNB per reward", kind: "bnb", def: 0.005, max: 10 },
+            { id: "min", label: "Smallest qualifying buy (share of supply)", kind: "pct", def: 0.1, min: 0, max: 1, zeroOk: true },
+            { id: "every", label: "Every Nth buy (1 = every buy)", kind: "int", def: 10, min: 1, max: 1000 },
+            { id: "pot", label: "Fill the pot with", kind: "bnb", def: 0.05, max: 100, zeroOk: true, hint: "sent right after the launch" },
+        ],
+        apply: (v) => ({ rewardPerBuy: wei(v.amount), rewardMinBuy: supplyShare(v.min), rewardEveryN: n(v.every) }),
+        describe: (r) => `${r.rewardEveryN > 1 ? `Every ${r.rewardEveryN}th buy` : "Every buy"} of ${tokens(fromRaw(r.rewardMinBuy))} or more earns ${bnb(Number(r.rewardPerBuy) / 1e18)}.`,
+        live: (r, s) => {
+            const left = r.rewardEveryN > 1 ? r.rewardEveryN - (s.qualifyingBuys % r.rewardEveryN) : 1;
+            return `Pot ${bnb(s.rewardsPot)}${r.rewardEveryN > 1 ? `, ${left === 1 ? "the next buy wins" : `${left} buys to the next reward`}` : ""}.`;
+        },
+    },
+    // games
+    {
+        kind: 36, id: "jackpot", name: "Jackpot", group: "games", scanner: G(),
+        line: "When nobody buys for a while, the last buyer takes the pot. You seed it, you can feed it a share of your creator fee, and anyone can top it up.",
+        fields: [
+            { id: "quiet", label: "Pot pays after a quiet", kind: "dur", def: 300, min: 30, max: DAY },
+            { id: "share", label: "Share of the pot paid out", kind: "pct", def: 80, min: 0.01, max: 100 },
+            { id: "min", label: "Smallest buy that takes the lead (share of supply)", kind: "pct", def: 0.05, min: 0, max: 1, zeroOk: true },
+            { id: "seed", label: "Seed the pot with", kind: "bnb", def: 0, max: 100, zeroOk: true, hint: "sent right after the launch" },
+        ],
+        apply: (v) => ({ jackpotSilence: n(v.quiet), jackpotShareBps: bps(v.share), jackpotMinBuy: supplyShare(v.min), jackpotFeeBps: 0 }),
+        describe: (r) => `${dur(r.jackpotSilence)} without a buy and the last buyer takes ${pct(r.jackpotShareBps)} of the pot.`,
+        live: (r, s, now) => {
+            if (!s.jackpotLast)
+                return `Pot ${bnb(s.jackpotPot)}, waiting for the first buyer.`;
+            const quiet = now - s.jackpotTime;
+            return quiet >= r.jackpotSilence
+                ? `Pot ${bnb(s.jackpotPot)}: ${short(s.jackpotLast)} won ${pct(r.jackpotShareBps)} of it.`
+                : `Pot ${bnb(s.jackpotPot)}, ${short(s.jackpotLast)} wins in ${dur(r.jackpotSilence - quiet)} unless someone buys.`;
+        },
+    },
+    {
+        kind: 37, id: "dip_only", name: "Dip only", group: "games", scanner: RED('Most of the time a buy fails: scanners show "cannot buy".'),
+        line: "Buys only while the price is a set share under its peak. The dev is the market maker.",
+        fields: [{ id: "dip", label: "Price under the peak by", kind: "pct", def: 20, min: 1, max: 99 }],
+        apply: (v) => ({ dipBps: bps(v.dip) }),
+        describe: (r) => `Buys only while the price is ${pct(r.dipBps)} or more under its peak. The dev can always buy.`,
+        live: (r, s) => {
+            const ratio = ((10_000 - s.peakBps) / Math.max(1, 10_000 - s.soldBps)) ** 2;
+            return ratio <= 1 - r.dipBps / 10_000 ? "In the dip: buys open." : `Price at ${Math.round(ratio * 100)}% of the peak: buys closed.`;
+        },
+    },
+    // linked coins
+    {
+        kind: 34, id: "entangled", name: "Entangled", alias: "Beacon", group: "linked",
+        scanner: RED('Buys fail until the beacon is reached: scanners show "cannot buy" until then, plus "external call".'),
+        line: "Locked until another coin of the pad has sold a set share of its supply.",
+        fields: [
+            { id: "beacon", label: "Beacon coin (address of a coin on this pad)", kind: "address" },
+            { id: "target", label: "Opens when the beacon has sold", kind: "pct", def: 20, min: 0.01, max: 100 },
+        ],
+        apply: (v) => ({ beacon: String(v.beacon).trim(), beaconTargetBps: bps(v.target) }),
+        describe: (r) => `Buys locked until ${short(r.beacon)} has sold ${pct(r.beaconTargetBps)} of its supply.`,
+        live: (_r, s) => (s.entangledOpen ? "Unlocked for good." : "Locked, watching the beacon."),
+    },
+    {
+        kind: 35, id: "reactive", name: "Reactive", group: "linked", scanner: Y('Scanners show "anti whale" and "external call".'),
+        line: "The buy cap grows while a partner coin is bought and shrinks when it is sold.",
+        fields: [
+            { id: "partner", label: "Partner coin (address of a coin on this pad)", kind: "address" },
+            { id: "base", label: "Base buy cap", kind: "pct", def: 0.5, min: 0.01, max: 100 },
+            { id: "gain", label: "Cap points per point the partner sold (%)", kind: "int", def: 10, min: 1, max: 1000 },
+        ],
+        apply: (v) => ({ partner: String(v.partner).trim(), reactBaseBps: bps(v.base), reactSensitivity: n(v.gain) }),
+        describe: (r) => `Buy cap ${pct(r.reactBaseBps)}, moving ${r.reactSensitivity}% of every point ${short(r.partner)} sells or buys back.`,
+    },
+    // v2: hooks rules (each burns $hooks at launch)
+    {
+        kind: 39, id: "buyout", name: "Buyout", group: "hooks", burns: true,
+        scanner: G("Scanners see the rules that can be bought off. Once bought, their warning goes away."),
+        line: "Listed rules can be bought off for BNB. Half goes to you, half burns $hooks.",
+        fields: [
+            { id: "rules", label: "Rules that can be bought off", kind: "rules", hint: "only rules that restrict trading" },
+            { id: "price", label: "Price per rule", kind: "bnb", def: 1, min: 0.1, max: 100 },
+        ],
+        apply: () => ({}),
+        extras: (v, picked) => {
+            const kinds = listedKinds(v.rules, picked);
+            const price = wei(v.price);
+            const prices = [0, 1, 2, 3, 4, 5, 6, 7].map((i) => (i < kinds.length ? price : BigInt(0)));
+            return { buyoutMask: maskOf(kinds), buyoutPrice: prices };
+        },
+        describe: (_r, x) => (x && x.buyoutMask ? `${namesOf(x.buyoutMask)} can be bought off for ${bnb(Number(x.buyoutPrice[0]) / 1e18)} each. Half of the price goes to the creator, half buys $hooks back and burns it. A bought rule never comes back.` : "Listed rules can be bought off for BNB. Half goes to the creator, half burns $hooks."),
+        live: (_r, s, _now, x) => {
+            if (!x || !s.v2)
+                return null;
+            const gone = kindsOf(x.buyoutMask).filter((k) => s.v2.off.includes(k));
+            return gone.length ? `Bought off so far: ${gone.map((k) => RULE_BY_KIND.get(k)?.name ?? k).join(", ")}.` : "Nothing bought off yet.";
+        },
+    },
+    {
+        kind: 40, id: "vote", name: "Vote", group: "hooks", burns: true,
+        scanner: G("Scanners see the rules that can be voted off, until they are."),
+        line: "Holders can vote listed rules off. Nobody changes the rules, except everyone together.",
+        fields: [
+            { id: "rules", label: "Rules that can be voted off", kind: "rules", hint: "only rules that restrict trading" },
+            { id: "quorum", label: "Quorum (share of the circulating supply on the yes side)", kind: "pct", def: 20, min: 5, max: 50 },
+            { id: "time", label: "A vote runs for", kind: "dur", def: DAY, min: 3600, max: 7 * DAY },
+        ],
+        apply: () => ({}),
+        extras: (v, picked) => ({ votable: maskOf(listedKinds(v.rules, picked)), quorumBps: bps(v.quorum), voteSeconds: n(v.time) }),
+        describe: (_r, x) => (x && x.votable ? `Holders can vote ${namesOf(x.votable)} off: coins go into the vote box for ${dur(x.voteSeconds)}, it passes with ${pct(x.quorumBps)} of the circulating supply on the yes side, a majority and at least 20 wallets. The creator's coins do not count. A lifted rule never comes back.` : "Holders can vote listed rules off."),
+        live: (_r, s, now, x) => {
+            if (!x || !s.v2)
+                return null;
+            const open = s.v2.votes.filter((v) => v.round > 0 && !v.done && now < v.end);
+            if (open.length)
+                return `Vote open on ${open.map((v) => RULE_BY_KIND.get(v.kind)?.name ?? v.kind).join(", ")}: ends in ${dur(Math.max(0, open[0].end - now))}.`;
+            const gone = kindsOf(x.votable).filter((k) => s.v2.off.includes(k));
+            return gone.length ? `Voted off so far: ${gone.map((k) => RULE_BY_KIND.get(k)?.name ?? k).join(", ")}.` : "No vote open right now.";
+        },
+    },
+    {
+        kind: 41, id: "duel", name: "Duel", group: "hooks", burns: true, scanner: G(),
+        line: "Two coins, one pot, 24 hours. The coin with more net buys wins both stakes.",
+        fields: [
+            { id: "stake", label: "Stake", kind: "bnb", def: 0.1, min: 0.01, max: 10, hint: "the other coin stakes the same" },
+            { id: "opponent", label: "Accept the open duel of (coin address)", kind: "address", optional: true, hint: "empty opens a new duel" },
+        ],
+        apply: () => ({}),
+        extras: (v) => ({ duelStake: wei(v.stake), duelOpponent: (ADDRESS.test(String(v.opponent ?? "").trim()) ? String(v.opponent).trim() : ZERO) }),
+        describe: (_r, x) => {
+            if (!x)
+                return "Two coins, one pot, 24 hours.";
+            const base = `${bnb(Number(x.duelStake) / 1e18)} staked against another coin for 24 hours. The coin with more net buys through its pools wins both stakes: 95% buys the winner and burns it, 5% feeds the pickhooks token.`;
+            return x.duelOpponent !== ZERO ? `${base} This coin accepted the duel of ${short(x.duelOpponent)}.` : `${base} A duel nobody accepts within an hour pays the stake back.`;
+        },
+        live: (_r, s, now) => {
+            const d = s.v2?.duel;
+            if (!d)
+                return null;
+            if (d.settled)
+                return d.winner ? `Settled: ${short(d.winner)} won ${bnb(d.stake * 2 * 0.95)} of buys.` : "Settled with a tie or a refund.";
+            if (!d.opponent)
+                return now < d.openedAt + 3600 ? `Open for ${dur(d.openedAt + 3600 - now)}: another coin can accept.` : "Nobody accepted: the stake can be refunded.";
+            const end = d.startedAt + 86_400;
+            const lead = d.flowA === d.flowB ? "tied" : `${d.flowA > d.flowB ? "this coin" : short(d.opponent)} leads`;
+            return now < end ? `Against ${short(d.opponent)}, ${lead}, ${dur(end - now)} to go.` : d.closed ? `Over: ${d.winner ? `${short(d.winner)} won` : "a tie"}, waiting for the settle.` : "The 24 hours are over: anyone can close it.";
+        },
+    },
+    {
+        kind: 42, id: "sells_at", name: "Sells at", group: "hooks", burns: true,
+        scanner: RED("Until the target or the deadline nobody can sell. Scanners mark that as a honeypot."),
+        line: "Sells open when a price feed reaches a target, or at a deadline. Diamond hands, enforced by the market.",
+        fields: [
+            { id: "feed", label: "Price feed (Chainlink)", kind: "choice", def: 0, options: [{ value: 0, label: "BNB" }, { value: 1, label: "BTC" }, { value: 2, label: "ETH" }, { value: 3, label: "DOGE" }] },
+            { id: "target", label: "Target price", kind: "usd", def: 1000, min: 0.0001, max: 100_000_000, hint: "must be above the price at launch" },
+            { id: "deadline", label: "Sells open at the latest after", kind: "dur", def: 7 * DAY, min: 3600, max: 7 * DAY },
+        ],
+        apply: () => ({}),
+        extras: (v) => ({ feed: feedAddress(v.feed), target: BigInt(Math.round(Number(v.target) * 1e8)), sellsAtSeconds: n(v.deadline) }),
+        describe: (_r, x) => (x && x.feed !== ZERO ? `Nobody can sell until ${feedName(x.feed)} reaches ${usd(Number(x.target) / 1e8)}, or ${dur(x.sellsAtSeconds)} after launch at the latest. Once open, it stays open. A feed that stops updating opens sells too.` : "Sells open when a price feed reaches a target, or at a deadline."),
+        live: (_r, s, now, x) => {
+            if (!x || !s.v2)
+                return null;
+            if (s.v2.off.includes(42))
+                return "Open: the target was reached.";
+            if (now >= s.start + x.sellsAtSeconds)
+                return "Open: the deadline passed.";
+            return `${feedName(x.feed)} at ${s.v2.feedPrice === null ? "?" : usd(s.v2.feedPrice)} now, target ${usd(Number(x.target) / 1e8)}, deadline in ${dur(s.start + x.sellsAtSeconds - now)}.`;
+        },
+    },
+    // v2: trust rules (free)
+    {
+        kind: 43, id: "dead_man", name: "Dead man", group: "trust", scanner: G("Only the creator's bag can be burned. Scanners see nothing."),
+        line: "If the dev vanishes, the dev's bag burns.",
+        fields: [{ id: "time", label: "Burnable after this long without a sign of life", kind: "dur", def: 7 * DAY, min: 3 * DAY, max: 30 * DAY }],
+        apply: () => ({}),
+        extras: (v) => ({ deadManSeconds: n(v.time) }),
+        describe: (_r, x) => `If the creator shows no sign of life for ${x ? dur(x.deadManSeconds) : "a while"} (a trade, a send or a tap on "still here"), anyone can burn the creator's whole bag. The creator cannot park it elsewhere: sends count against the same lock as sells.`,
+        live: (_r, s, now, x) => {
+            if (!x || !s.v2)
+                return null;
+            const left = s.v2.devAlive + x.deadManSeconds - now;
+            return left > 0 ? `Creator last seen ${dur(Math.max(0, now - s.v2.devAlive))} ago. The bag can be burned in ${dur(left)}.` : "The creator went quiet: the bag can be burned now.";
+        },
+    },
+    {
+        kind: 44, id: "milestone", name: "Milestone unlock", group: "trust", scanner: G("Only the creator is locked. Scanners see nothing."),
+        line: "The dev gets paid when you do: the dev's bag unlocks with the BNB in the pool.",
+        fields: [],
+        apply: () => ({}),
+        extras: () => ({}),
+        describe: () => "The creator's bag unlocks with the BNB in the pool: a quarter at 2 BNB, half at 5, three quarters at 10, all of it at 20, and everything after 30 days. A level counts after it held for 10 minutes, and if the pool drains, the lock closes again.",
+        live: (_r, s) => (s.v2 ? `${s.v2.milestonePct}% of the creator's peak bag may leave, ${tokens(s.v2.devOutTokens)} left so far.` : null),
+    },
+    {
+        kind: 45, id: "floor_fund", name: "Floor fund", group: "trust", scanner: G(),
+        line: "The coin defends its own floor. Anyone can pull the trigger.",
+        fields: [
+            { id: "deposit", label: "Deposit at launch", kind: "bnb", def: 0.5, min: 0.1, max: 10 },
+            { id: "floor", label: "Floor, as a share of the peak price", kind: "choice", def: 5000, options: [{ value: 2500, label: "25%" }, { value: 5000, label: "50%" }, { value: 7500, label: "75%" }] },
+        ],
+        apply: () => ({}),
+        extras: (v) => ({ floorDeposit: wei(v.deposit), floorBps: n(v.floor) }),
+        describe: (_r, x) => (x && x.floorBps ? `${bnb(Number(x.floorDeposit) / 1e18)} sit in a vault. When the half-hour average price falls under ${pct(x.floorBps)} of the peak hourly average, anyone can make the vault buy a tenth of its deposit and burn the coins, once an hour. The caller gets 0.5% of the buy.` : "The coin defends its own floor from a vault filled at launch."),
+        live: (_r, s, now) => {
+            const f = s.v2?.floor;
+            if (!f)
+                return null;
+            const rest = f.lastDefend + 3600 - now;
+            return `${bnb(f.left)} left of ${bnb(f.deposit)}.${f.peakPct === null ? " Waiting for the first hour of price history." : f.belowFloor ? (rest > 0 ? ` Under the floor, next defence in ${dur(rest)}.` : " Under the floor: the vault can buy now.") : " Above the floor."}`;
+        },
+    },
+    {
+        kind: 46, id: "payroll", name: "Payroll", group: "trust", scanner: G(),
+        line: "Hold your shift, get paid. Sell and you lose what is unpaid.",
+        fields: [
+            { id: "shift", label: "Shift length", kind: "choice", def: 28_800, options: [{ value: 14_400, label: "4 hours" }, { value: 28_800, label: "8 hours" }, { value: 86_400, label: "24 hours" }] },
+            { id: "min", label: "Smallest bag on the payroll (share of supply)", kind: "pct", def: 0.001, min: 0.0001, max: 1, hint: "0.0001% is 1,000 coins" },
+            { id: "deposit", label: "Pot at launch", kind: "bnb", def: 0.1, max: 100, zeroOk: true, hint: "95% of your creator fee feeds it from then on" },
+        ],
+        apply: () => ({}),
+        extras: (v) => ({ shiftSeconds: n(v.shift), payrollMin: supplyShare(v.min), payrollDeposit: wei(v.deposit) }),
+        describe: (_r, x) => (x && x.shiftSeconds ? `Hold at least ${pct(shareOf(x.payrollMin))} of supply through a whole ${SHIFT_LABEL[x.shiftSeconds] ?? dur(x.shiftSeconds)} shift and get paid in BNB: every shift pays a tenth of the pot over all coins on the payroll. Coins that join earn from the next shift. Sell or send, and the unpaid wages go back to the pot. 95% of the creator's fee feeds the pot.` : "Hold your shift, get paid in BNB."),
+        live: (_r, s, now) => {
+            const p = s.v2?.payroll;
+            if (!p)
+                return null;
+            const next = p.lastShift + p.shiftSeconds - now;
+            return `Pot ${bnb(p.pot)}, ${tokens(p.total)} on the payroll, shift ${p.shiftNo + 1} ${next > 0 ? `pays in ${dur(next)}` : "can be paid now"}.`;
+        },
+    },
+];
+/** the catalog the site shows: the eight v2 rules only once the v2 factory is set */
+export const RULES_SHOWN = V2.factory ? RULES : RULES.filter((r) => r.kind < 39);
+export const GROUPS_SHOWN = GROUPS.filter((g) => RULES_SHOWN.some((r) => r.group === g.id));
+export const RULE_BY_KIND = new Map(RULES.map((r) => [r.kind, r]));
+export const RULE_BY_ID = new Map(RULES.map((r) => [r.id, r]));
+export function defaults(def) {
+    const v = {};
+    for (const f of def.fields)
+        v[f.id] = f.kind === "address" || f.kind === "rules" ? "" : f.def;
+    return v;
+}
+const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+/** Checks the values against the same limits the factory enforces. Returns a sentence or null. */
+export function fieldProblem(def, v) {
+    for (const f of def.fields) {
+        const raw = v[f.id];
+        const val = Number(raw);
+        switch (f.kind) {
+            case "pct": {
+                const min = f.zeroOk ? 0 : (f.min ?? 0.01);
+                if (!Number.isFinite(val) || val < min || val > (f.max ?? 100) || (val === 0 && !f.zeroOk))
+                    return `${f.label}: ${min} to ${f.max ?? 100}%.`;
+                break;
+            }
+            case "dur":
+                if (!Number.isFinite(val) || val < (f.min ?? 0) || (val === 0 && !f.zeroOk) || val > f.max)
+                    return `${f.label}: ${dur(f.min ?? 1)} to ${dur(f.max)}.`;
+                break;
+            case "int":
+                if (!Number.isInteger(val) || val < f.min || val > f.max)
+                    return `${f.label}: ${f.min} to ${f.max}.`;
+                break;
+            case "bnb":
+                if (!Number.isFinite(val) || val < (f.min ?? 0) || (val === 0 && !f.zeroOk) || val > f.max)
+                    return f.min ? `${f.label}: ${f.min} to ${f.max} BNB.` : `${f.label}: up to ${f.max} BNB.`;
+                break;
+            case "usd":
+                if (!Number.isFinite(val) || val < f.min || val > f.max)
+                    return `${f.label}: ${f.min} to ${f.max.toLocaleString("en-US")} USD.`;
+                break;
+            case "choice":
+                if (!f.options.some((o) => o.value === val))
+                    return `${f.label}: pick one.`;
+                break;
+            case "rules":
+                if (!String(raw ?? "").split(",").some((s) => Number(s.trim()) > 0))
+                    return `${f.label}: pick at least one.`;
+                break;
+            case "gwei":
+                if (!Number.isFinite(val) || val < 0.05 || val > f.max)
+                    return `${f.label}: 0.05 to ${f.max} gwei.`;
+                break;
+            case "address":
+                if (f.optional && String(raw ?? "").trim() === "")
+                    break;
+                if (typeof raw !== "string" || !ADDRESS.test(raw.trim()))
+                    return `${f.label}: paste a 0x address.`;
+                break;
+            case "hour":
+                if (!Number.isInteger(val) || val < 0 || val > 23)
+                    return `${f.label}: an hour from 0 to 23.`;
+                break;
+            case "days":
+                if (!Number.isInteger(val) || val <= 0 || val > 127)
+                    return "Pick at least one day.";
+                break;
+        }
+    }
+    const e = { ...emptyRules(), ...def.apply(v) };
+    if (def.id === "sell_curve" && e.curveFloorBps > e.curveSmallBps)
+        return "The big bag cap cannot be bigger than the small bag cap.";
+    if (def.id === "taper" && e.taperEndBps > e.taperStartBps)
+        return "The end cap cannot be bigger than the start cap.";
+    if (def.id === "sell_window" && e.sellWindow >= e.sellPeriod)
+        return "The window must be shorter than the period.";
+    if (def.id === "hours" && e.openHour === e.closeHour)
+        return "Opening and closing hour must differ.";
+    return null;
+}
+/** Checks a whole selection the way the factory does. */
+export function selectionProblem(picked) {
+    if (!picked.length)
+        return null;
+    const kinds = picked.map((p) => RULE_BY_ID.get(p.id)?.kind ?? 0);
+    if (kinds.includes(0))
+        return "Unknown rule.";
+    if (picked.length > MAX_RULES)
+        return `Up to ${MAX_RULES} rules per coin.`;
+    if (new Set(kinds).size !== kinds.length)
+        return "Each rule once.";
+    if (kinds.includes(7) && kinds.includes(9))
+        return "Pool only and P2P only cannot be combined.";
+    if (kinds.includes(34) && kinds.includes(35))
+        return "One linked rule per coin.";
+    // time gates that together can shut sells for good: the live token factory accepts them, so the launcher refuses them
+    // (the pool factory refuses them on chain as well)
+    const sellsAlwaysOpen = picked.some((p) => p.id === "hours" && Boolean(p.values.sells));
+    if (kinds.includes(20) && kinds.includes(16))
+        return "Tick tock and Sell window cannot be combined: sells could stay shut for good.";
+    if (kinds.includes(15) && !sellsAlwaysOpen && kinds.includes(20))
+        return "Tick tock and Market hours only work together when sells stay open.";
+    if (kinds.includes(15) && !sellsAlwaysOpen && kinds.includes(16))
+        return "Sell window and Market hours only work together when sells stay open.";
+    // with P2P only nobody but the creator buys from the pools, so only the creator could ever unlock sells
+    if (kinds.includes(9) && kinds.includes(14))
+        return "P2P only and Buys unlock sells cannot be combined: only the creator could ever unlock sells.";
+    // a jackpot that ends keeps its pot, and the creator fee share keeps feeding it, with nobody left to win it
+    if (picked.some((p) => p.id === "jackpot" && p.endsAfter))
+        return "Jackpot cannot have an end time: its pot would keep filling with nobody left to win it.";
+    if (picked.some((p) => p.id === "rewards" && p.endsAfter))
+        return "Buyer rewards cannot have an end time: nobody could earn its pot after that.";
+    // the v2 factory's validator: traps that could stop every buy or sell for good, and what belongs together
+    const has = (k) => kinds.includes(k);
+    if (has(9) && has(14))
+        return "P2P only and Buys unlock sells cannot be combined: only the creator could ever unlock sells.";
+    if (has(14) && (has(34) || has(8)))
+        return "Buys unlock sells needs open buying: not with Entangled or Holder gated.";
+    if (has(14) && has(17) && has(23))
+        return "The club, Buy limit and Buys unlock sells together could lock sells for good.";
+    if (has(18)) {
+        const r = picked.reduce((acc, p) => Object.assign(acc, RULE_BY_ID.get(p.id).apply(p.values)), emptyRules());
+        let cap = 10_000;
+        if (has(1) && r.maxWalletBps < cap)
+            cap = r.maxWalletBps;
+        if (has(2) && r.maxTradeBps < cap)
+            cap = r.maxTradeBps;
+        if (has(3) && r.dumpBuyBps < cap)
+            cap = r.dumpBuyBps;
+        if (r.minBuy > (BigInt(SUPPLY) * E18 * BigInt(cap)) / BigInt(10_000))
+            return "Min buy is above the buy caps: nobody but the creator could ever buy.";
+    }
+    if (has(9) && has(43))
+        return "P2P only and Dead man cannot be combined: nobody but the creator could ever hold.";
+    if (has(44) && has(21))
+        return "Milestone unlock replaces Dev lock: pick one of them.";
+    if (has(46) && has(36))
+        return "Payroll and Jackpot cannot be combined: a coin has one pot.";
+    for (const p of picked) {
+        const def = RULE_BY_ID.get(p.id);
+        if (p.endsAfter && NO_UNTIL.includes(def.kind) && (def.kind >= 39 || V2.factory))
+            return `${def.name} cannot have an end time.`;
+        if ((p.id === "buyout" || p.id === "vote") && listedKinds(p.values.rules, picked).length === 0) {
+            return `${def.name}: pick at least one rule of this coin that restricts trading (not a trust rule, game, pot or linked coin).`;
+        }
+    }
+    for (const p of picked) {
+        const def = RULE_BY_ID.get(p.id);
+        const problem = fieldProblem(def, p.values);
+        if (problem)
+            return `${def.name}: ${problem}`;
+        if (p.endsAfter !== undefined && p.endsAfter !== 0 && (!(p.endsAfter > 0) || p.endsAfter > 365 * DAY))
+            return `${def.name}: end time up to a year.`;
+    }
+    return null;
+}
+/** The launch arguments for the factory: the Rules struct, the end times, and for the v2 factory the Extras. */
+export function buildRules(picked, nowSec, creatorKeepBps = 10_000) {
+    const rules = emptyRules();
+    const extras = { ...emptyExtras(), creatorKeepBps };
+    const untilIds = [];
+    const untilTimes = [];
+    for (const p of picked) {
+        const def = RULE_BY_ID.get(p.id);
+        Object.assign(rules, def.apply(p.values));
+        if (def.extras)
+            Object.assign(extras, def.extras(p.values, picked));
+        rules.mask |= bit(def.kind);
+        if (p.endsAfter) {
+            untilIds.push(def.kind);
+            untilTimes.push(nowSec + Math.round(p.endsAfter) + 120); // the launch lands a little later
+        }
+    }
+    return { rules, untilIds, untilTimes, extras };
+}
+/** v2: how many hooks rules a selection carries (each burns $hooks at launch), and the BNB the launch deposits besides the seed. */
+export function v2Costs(picked) {
+    let hooksRules = 0;
+    let stakeBnb = 0;
+    let floorBnb = 0;
+    let payrollBnb = 0;
+    let v2 = false;
+    for (const p of picked) {
+        const def = RULE_BY_ID.get(p.id);
+        if (!def)
+            continue;
+        if (def.kind >= 39)
+            v2 = true;
+        if (def.burns)
+            hooksRules++;
+        if (p.id === "duel")
+            stakeBnb += Number(p.values.stake || 0);
+        if (p.id === "floor_fund")
+            floorBnb += Number(p.values.deposit || 0);
+        if (p.id === "payroll")
+            payrollBnb += Number(p.values.deposit || 0);
+    }
+    return { hooksRules, stakeBnb, floorBnb, payrollBnb, v2 };
+}
+/** BNB the launcher sends into pots right after the launch. */
+export function launchPots(picked) {
+    let jackpot = 0;
+    let rewards = 0;
+    for (const p of picked) {
+        if (p.id === "jackpot")
+            jackpot += Number(p.values.seed || 0);
+        if (p.id === "rewards")
+            rewards += Number(p.values.pot || 0);
+    }
+    return { jackpot, rewards };
+}
+/** The worst scanner level in a selection. */
+export function worstScanner(kinds) {
+    const levels = kinds.map((k) => RULE_BY_KIND.get(k)?.scanner.level ?? "green");
+    return levels.includes("red") ? "red" : levels.includes("yellow") ? "yellow" : "green";
+}
+/** Rule kinds that are on in a mask. */
+export const kindsOf = (mask) => RULES.filter((r) => (mask & bit(r.kind)) !== BigInt(0)).map((r) => r.kind);
+/** The rule's current sentence, or that it ended. */
+export function ruleNow(kind, r, s, until, now, x) {
+    const def = RULE_BY_KIND.get(kind);
+    if (!def)
+        return { name: `Rule ${kind}`, text: "Unknown rule.", live: null, ended: false, lifted: false, scanner: G() };
+    // v2: a rule that was bought off, voted off or (sells at) reached its target is over for good
+    const lifted = Boolean(s.v2?.off.includes(kind));
+    const ended = (until !== 0 && now >= until) || lifted;
+    let live = null;
+    if (!ended && def.live) {
+        try {
+            live = def.live(r, s, now, x);
+        }
+        catch {
+            live = null;
+        }
+    }
+    const ends = until && !ended ? ` Ends in ${dur(until - now)}.` : "";
+    return { name: def.name, text: def.describe(r, x) + ends, live, ended, lifted, scanner: def.scanner };
+}
+/** Names of the rules a token error refers to, for "rule: max wallet" messages. */
+export function refusal(kind, r) {
+    const def = RULE_BY_KIND.get(kind);
+    if (!def)
+        return `Refused by rule ${kind}.`;
+    return `Refused by the rule "${def.name}". ${r ? def.describe(r) : def.line}`;
+}