@pickhooks/sdk 0.0.0-stage → 0.4.0

package/dist/sticky.js

@@ -0,0 +1,420 @@
+import { encodeFunctionData, parseEventLogs } from "viem";
+import { stickyFactoryAbi, stickyTokenAbi, stickyValidatorAbi } from "./abis/sticky.js";
+import { sticky2FactoryAbi, sticky2TokenAbi, sticky2ValidatorAbi } from "./abis/sticky2.js";
+import { v3PoolAbi } from "./abis/common.js";
+import { v2LockerAbi } from "./abis/v2.js";
+import { ZERO_ADDRESS } from "./addresses.js";
+import { PickhooksError, errorText, explain, toPickhooksError } from "./errors.js";
+import { ACT, LOCKED, NONE, ON, compile, decodeRow, defaults, editToRow, rowProblems, rowText, scannerOf, TEMPLATE_BY_ID, templateOf } from "./sticky-rules.js";
+import { simulate } from "./sticky-sim.js";
+import { chainDeadline, minusBps, sendTx, senderAddress, signer } from "./tx.js";
+import { bestVenue, buildV2Buy, buildV2Sell, v2Quote } from "./v2.js";
+import { approvalFor, buildV3Buy, buildV3Sell, receivedOf, v3EstimateBuy, v3PriceBnb, v3Quote } from "./v3.js";
+const randomSalt = () => {
+    const b = new Uint8Array(32);
+    globalThis.crypto.getRandomValues(b);
+    return `0x${Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("")}`;
+};
+const toBase64 = (bytes) => {
+    const B = globalThis.Buffer;
+    if (B)
+        return B.from(bytes).toString("base64");
+    let s = "";
+    for (const x of bytes)
+        s += String.fromCharCode(x);
+    return btoa(s);
+};
+/** The rows of a coin as sentences, with the template each belongs to. */
+export function describeRows(raw, release, off) {
+    return raw.map((x, i) => {
+        const r = decodeRow(x);
+        const id = templateOf(r);
+        const t = id ? TEMPLATE_BY_ID.get(id) : null;
+        const name = r.act === ACT.POT ? "Pot" : (t?.name ?? "Custom row");
+        return { i, name, text: rowText(r, release), template: id, sticky: t?.sticky ?? false, lock: r.act === ACT.LOCK, drop: r.act === ACT.DROP, lifted: (off & (1 << i)) !== 0, raw: x };
+    });
+}
+/**
+ * The table a launch would send: the templates' rows, then the hook script rows (the site's order), one release time per
+ * coin (the longer one wins); or rows + release as given. Offline; throws the problems as sentences.
+ */
+export function stickyTable(l) {
+    if (!l.picks && !l.script?.length)
+        return { rows: l.rows ?? [], release: l.release ?? 0 };
+    // a template's numbers left out take its defaults
+    const picks = (l.picks ?? []).map((p) => {
+        const t = TEMPLATE_BY_ID.get(p.id);
+        if (!t)
+            throw new PickhooksError(`There is no template "${p.id}". Templates: ${[...TEMPLATE_BY_ID.keys()].join(", ")}.`, { code: "input" });
+        return { id: p.id, params: { ...defaults(t), ...p.params } };
+    });
+    const own = (l.script ?? []).map(editToRow);
+    const c = compile(picks, own);
+    const problems = [...c.problems, ...own.flatMap(rowProblems)];
+    const hours = l.scriptHours ?? 0;
+    const locks = own.some((r) => r.act === ACT.LOCK);
+    if (locks && !(hours * 3600 >= 600 && hours <= 720))
+        problems.push("Locked shares: unlock over 10 minutes to 30 days.");
+    if (problems.length)
+        throw new PickhooksError(problems.join(" "), { code: "input" });
+    return { rows: c.rows, release: locks ? Math.max(c.release, Math.round(hours * 3600)) : c.release };
+}
+const dur = (s) => s < 90 ? `${Math.round(s)} s` : s < 5400 ? `${Math.round(s / 60)} min` : s < 2 * 86_400 ? `${+(s / 3600).toFixed(1)} h` : `${+(s / 86_400).toFixed(1)} days`;
+/** A test run as sentences: the launcher's card line by line. `names` are the rows' names (rule i + 1). */
+export function testRunText(r, names) {
+    const rule = (row) => (row === LOCKED ? "still locked" : `rule ${row + 1}, ${names[row] ?? ""}`);
+    const pct = (x) => +x.toFixed(2);
+    const out = [
+        `Trades: ${r.buys.ok + r.buys.refused} buys, ${r.sells.ok + r.sells.refused} sells, ${r.sends.ok + r.sends.refused} sends in ${+r.hours.toFixed(1)} hours.`,
+        `Refused: ${r.refusals.length ? r.refusals.map((x) => `${rule(x.row)} ${x.count}x`).join(", ") : "nothing"}.`,
+        `Longest wait to sell: ${r.longestWait ? `${dur(r.longestWait)}${r.stillWaiting ? `, ${r.stillWaiting} wallets still waiting at the end` : ""}` : "nobody had to wait"}.`,
+        `Snipers: ${r.snipers.firstSellAfter !== null ? `first sold ${dur(r.snipers.firstSellAfter)} after launch` : "could not sell during the run"}.`,
+        `Split bags: ${r.splits.count ? `${r.splits.count} sent to fresh wallets, refused there again ${r.splits.refusedAfter} times` : "none"}.`,
+        `Everyone free: ${r.allFreeAfter === 0 ? "every wallet can sell everything right after the run" : r.allFreeAfter !== null ? `every wallet can sell everything ${dur(r.allFreeAfter)} after the run` : "at the latest when every lot is 30 days old"}.`,
+    ];
+    if (r.burnedPct > 0)
+        out.push(`Burned: ${pct(r.burnedPct)} % of the supply.`);
+    if (r.pot.inPct > 0)
+        out.push(`Pot: ${pct(r.pot.inPct)} % of the supply in, ${r.pot.drops} drops paid ${pct(r.pot.paidPct)} %, ${pct(r.pot.leftPct)} % left.`);
+    out.push(`A scanner's test: ${r.scanner.buy !== null
+        ? `its test buy is refused by ${rule(r.scanner.buy)}`
+        : r.scanner.sell !== null
+            ? `its sell right after the buy is refused by ${rule(r.scanner.sell)}: it can show a honeypot`
+            : "a small buy and an instant sell pass"}.`);
+    return out;
+}
+/**
+ * The launcher's test run, offline: the table on a fresh coin with random trades (the creator's first buy, three snipers
+ * in the first blocks, wallets that buy, hold and sell, bags split to fresh wallets). It runs the coin's own rule engine,
+ * checked against the contract trade by trade. The same seed gives the same run; the chain stays the truth.
+ */
+export function stickyTestRun(l) {
+    const { rows, release } = stickyTable(l);
+    const report = simulate(rows, release, { seed: l.seed ?? 7, trades: l.trades ?? 200, devBuyBnb: l.devBuyBnb ?? 0, start: l.start });
+    const names = describeRows(rows, release, 0).map((x) => x.name);
+    return { rows, release, report, text: testRunText(report, names) };
+}
+/**
+ * The sticky module. `v2` points it at the sticky 2 factory (same coins, same rules, same calls; its coins also count
+ * the creator's sold coins and can carry switch rows, see ph.sticky2).
+ */
+export function stickyModule(ctx, v2 = false) {
+    const { pub, a } = ctx;
+    const F = v2 ? a.sticky2Factory : a.stickyFactory;
+    const FA = (v2 ? sticky2FactoryAbi : stickyFactoryAbi);
+    const TA = (v2 ? sticky2TokenAbi : stickyTokenAbi);
+    const call = (address, abi, functionName, args = []) => pub.readContract({ address, abi, functionName, args });
+    /** The factory's terms now: the seed every launch pays into the V2 pair, the creator side, whether own rows are open. */
+    async function terms() {
+        const fns = ["seedBnb", "creatorBps", "custom", "validator", "startFdv", "platformWallet", "locker"];
+        const r = await pub.multicall({ contracts: fns.map((functionName) => ({ address: F, abi: FA, functionName })), allowFailure: false });
+        return { seed: r[0], creatorBps: Number(r[1]), custom: r[2], validator: r[3], startFdv: r[4], platformWallet: r[5], locker: r[6] };
+    }
+    /** Asks the validator on chain whether a table can launch: null when it can, else the reason. */
+    async function validate(rows, release, custom) {
+        const t = custom === undefined ? await terms() : null;
+        try {
+            await call(t?.validator ?? a.stickyValidator, stickyValidatorAbi, "validate", [rows, release, custom ?? t.custom]);
+            return null;
+        }
+        catch (e) {
+            return explain(e, "The validator refused this table.").text;
+        }
+    }
+    const maskOf = (rowsOn) => (rowsOn ?? []).reduce((m, i) => m | (1 << i), 0);
+    /** sticky 2: asks the validator whether these rows can switch (drop rows only, 2 to 4): null when they can, else why not */
+    async function validateSwitch(rows, mask, validator) {
+        if (!v2)
+            return "Switch rows are a sticky 2 feature.";
+        try {
+            await call(validator ?? (await terms()).validator, sticky2ValidatorAbi, "switchRows", [rows, mask]);
+            return null;
+        }
+        catch (e) {
+            return explain(e, "The validator refused these switch rows.").text;
+        }
+    }
+    /**
+     * Stores the image and metadata on pickhooks.com and returns the metadata link (the site's /api/sticky/prepare, rate
+     * limited, only while sticky rules are live on the site). A launchpad can host its own JSON and pass that link instead.
+     */
+    async function prepareMetadata(m) {
+        const res = await fetch(`${ctx.site}/api/sticky/prepare`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ ...m, image: { mime: m.image.mime, base64: toBase64(m.image.bytes) } }),
+        });
+        const j = (await res.json().catch(() => ({})));
+        if (!res.ok || !j.metadata)
+            throw new PickhooksError(j.error ?? `The site answered ${res.status}.`, { code: "site" });
+        return { metadata: j.metadata, image: j.image ?? "" };
+    }
+    /** The launch call. value = the factory's seed + the creator's first buy. */
+    function buildLaunch(l, value) {
+        const args = { name: l.name, symbol: l.symbol, metadata: l.metadata, rows: l.rows, release: l.release, salt: l.salt ?? randomSalt(), keepBps: l.keepBps ?? 10_000, minCreatorBps: l.minCreatorBps };
+        if (!v2 && l.switchMask)
+            throw new PickhooksError("Switch rows are a sticky 2 feature.", { code: "input" });
+        // sticky 2 takes a switcher and its switch rows too: none from a plain launch
+        const full = v2 ? { ...args, switcher: l.switchMask ? (l.switcher ?? a.ruleAuction) : ZERO_ADDRESS, switchMask: l.switchMask ?? 0 } : args;
+        return { to: F, value, data: encodeFunctionData({ abi: FA, functionName: "launch", args: [full] }), label: "The launch" };
+    }
+    /** Builds the table from templates and hook script rows (or takes rows), checks it locally and on chain, launches, returns the coin. */
+    async function launch(l, s = {}) {
+        const t = await terms();
+        if (l.script?.length && !t.custom)
+            throw new PickhooksError("The hook script is off on the factory: templates only for now.", { code: "input" });
+        const { rows, release } = stickyTable(l);
+        const refused = await validate(rows, release, t.custom);
+        if (refused)
+            throw new PickhooksError(refused, { code: "Bad" });
+        const switchMask = maskOf(l.switchRows);
+        if (switchMask) {
+            const no = await validateSwitch(rows, switchMask, t.validator);
+            if (no)
+                throw new PickhooksError(no, { code: "Bad" });
+        }
+        const tx = buildLaunch({ name: l.name, symbol: l.symbol, metadata: l.metadata, rows, release, salt: l.salt, keepBps: l.keepBps, minCreatorBps: t.creatorBps, switcher: l.switcher, switchMask }, t.seed + (l.devBuy ?? 0n));
+        const sent = await sendTx(ctx, tx, s);
+        // both factories emit the same Launched event
+        const ev = parseEventLogs({ abi: stickyFactoryAbi, logs: sent.receipt.logs.filter((x) => x.address.toLowerCase() === F.toLowerCase()), eventName: "Launched" })[0];
+        if (!ev)
+            throw new PickhooksError("Launched, but the coin was not found in the receipt.", { code: "receipt", hash: sent.hash });
+        return { ...sent, token: ev.args.token, pool: ev.args.pool, pair: ev.args.pair, rows, release };
+    }
+    const FIELDS = ["name", "symbol", "metadata", "creator", "pool", "pool2", "start", "stats", "script", "pot", "totalSupply"];
+    async function summaries(tokens) {
+        if (!tokens.length)
+            return [];
+        const per = FIELDS.length;
+        const res = await pub.multicall({ contracts: tokens.flatMap((t) => FIELDS.map((functionName) => ({ address: t, abi: TA, functionName }))), allowFailure: true });
+        const pools = tokens.map((_, i) => res[i * per + 4].result);
+        const slots = await pub.multicall({
+            contracts: pools.map((p) => ({ address: (p ?? a.wbnb), abi: v3PoolAbi, functionName: "slot0" })),
+            allowFailure: true,
+        });
+        const out = [];
+        tokens.forEach((token, i) => {
+            const g = (k) => res[i * per + k];
+            if (g(0).status !== "success" || !pools[i] || g(8).status !== "success")
+                return;
+            const stats = g(7).result;
+            const [raw, release, off] = g(8).result;
+            const supply = g(10).result ?? 10n ** 27n;
+            const sl = slots[i];
+            const priceBnb = sl.status === "success" ? v3PriceBnb(sl.result[0], token, a.wbnb) : 0;
+            out.push({
+                token,
+                name: String(g(0).result ?? ""),
+                symbol: String(g(1).result ?? ""),
+                metadata: String(g(2).result ?? ""),
+                creator: g(3).result,
+                pool: pools[i],
+                pair: g(5).result ?? ZERO_ADDRESS,
+                start: Number(g(6).result ?? 0),
+                release: Number(release),
+                rows: describeRows(raw, Number(release), Number(off)),
+                scanner: scannerOf(raw.map(decodeRow)),
+                holders: Number(stats[0]),
+                buys: Number(stats[1]),
+                sells: Number(stats[2]),
+                lastBuy: Number(stats[4]),
+                volume: stats[5],
+                pot: g(9).result ?? 0n,
+                totalSupply: supply,
+                priceBnb,
+                mcapBnb: priceBnb * (Number(supply) / 1e18),
+            });
+        });
+        return out;
+    }
+    /** How many coins the factory launched. */
+    const count = async () => Number(await call(F, FA, "coinCount"));
+    /** Coins newest first: `limit` of them, skipping the newest `offset`. */
+    async function coins(o = {}) {
+        const n = await count();
+        const end = Math.max(0, n - (o.offset ?? 0));
+        const from = Math.max(0, end - (o.limit ?? 50));
+        if (end <= from)
+            return [];
+        const idx = Array.from({ length: end - from }, (_, i) => BigInt(end - 1 - i));
+        const tokens = (await pub.multicall({
+            contracts: idx.map((i) => ({ address: F, abi: FA, functionName: "coins", args: [i] })),
+            allowFailure: false,
+        }));
+        return summaries(tokens);
+    }
+    const isCoin = async (token) => (await call(F, FA, "isCoin", [token]).catch(() => false)) === true;
+    /** One sticky coin, or null when the address is not one of the factory's coins. */
+    async function coin(token) {
+        if (!(await isCoin(token)))
+            return null;
+        return (await summaries([token]))[0] ?? null;
+    }
+    /** A wallet's lots (amount, locked part, since, marks), its balance and what it can sell now. */
+    async function wallet(token, who) {
+        const r = await pub.multicall({
+            contracts: [
+                { address: token, abi: TA, functionName: "balanceOf", args: [who] },
+                { address: token, abi: TA, functionName: "sellable", args: [who] },
+                { address: token, abi: TA, functionName: "lotsOf", args: [who] },
+            ],
+            allowFailure: false,
+        });
+        const [amount, locked, since, flags, open] = r[2];
+        return {
+            balance: r[0],
+            sellable: r[1],
+            lots: amount.map((x, i) => ({ amount: x, locked: locked[i], since: Number(since[i]), flags: Number(flags[i]), open: open[i] })),
+        };
+    }
+    /**
+     * Would this trade go through: the coin's own check(), the same code a transfer runs. For a buy pass the coins it would
+     * get (a quote is fine: the size rows look at a share of the supply). A send is checked from `wallet` to `to`.
+     */
+    async function check(c) {
+        const args = c.side === "buy" ? [ON.BUY, ZERO_ADDRESS, c.wallet, c.amount] : c.side === "sell" ? [ON.SELL, c.wallet, ZERO_ADDRESS, c.amount] : [ON.SEND, c.wallet, c.to ?? ZERO_ADDRESS, c.amount];
+        const [r, script] = await Promise.all([call(c.token, TA, "check", args), call(c.token, TA, "script")]);
+        const answer = Number(r);
+        if (answer === NONE)
+            return { ok: true };
+        if (answer === LOCKED) {
+            // the coin answers "locked" too when the wallet simply holds fewer coins than the trade
+            const held = c.side === "buy" ? null : await call(c.token, TA, "balanceOf", [c.wallet]).catch(() => null);
+            const text = held !== null && held < c.amount ? "This wallet holds fewer of these coins than that." : errorText("Blocked", [LOCKED]);
+            return { ok: false, row: "locked", text, rule: null };
+        }
+        const rows = describeRows(script[0], Number(script[1]), Number(script[2]));
+        const rule = rows[answer] ?? null;
+        return { ok: false, row: answer, text: `Refused by rule ${answer + 1}${rule ? `: ${rule.name}. ${rule.text}` : "."}`, rule };
+    }
+    /** Coins a buy of `bnbIn` would get, estimated from the pool's liquidity at its price (see v3EstimateBuy); not a minOut. */
+    async function estimateBuy(token, bnbIn) {
+        return v3EstimateBuy(ctx, await call(token, TA, "pool"), token, bnbIn);
+    }
+    /**
+     * What a trade gets in the V3 pool, from PancakeSwap's QuoterV2. It runs the swap, so a refusing rule fails it, and it
+     * does not pass the reason on: a refused buy is checked again with an estimate of its coins and the refusal names the
+     * rule (for `wallet`, by default the quoter the quote ran as).
+     */
+    /**
+     * The better of the coin's two venues: its V3 pool and its V2 pair (every sticky coin has both at the same start price;
+     * after a dark launch the round's BNB sits in the pair, and a sell into the one sided V3 curve would get almost nothing).
+     * Terminals pick the pool by themselves; the SDK does the same here. The venue field says which one buy/sell will use.
+     */
+    async function quote(q) {
+        const best = await bestVenue(ctx, { v3: () => v3Quote(ctx, q), v2: () => v2Quote(ctx, q) });
+        if (best.v3 !== null || best.v2 !== null)
+            return { amountOut: best.amountOut, venue: best.venue, v3: best.v3, v2: best.v2 };
+        const e = best.errors.v3 ?? best.errors.v2;
+        {
+            if (q.side === "buy") {
+                const est = await estimateBuy(q.token, q.amount).catch(() => 0n);
+                const c = est > 0n ? await check({ token: q.token, side: "buy", wallet: q.wallet ?? a.v3Quoter, amount: est }).catch(() => null) : null;
+                if (c && !c.ok)
+                    throw new PickhooksError(c.text, { code: "Blocked", args: [c.row === "locked" ? LOCKED : c.row], cause: e });
+            }
+            throw toPickhooksError(e, "The quoter refused this trade.");
+        }
+    }
+    /** A buy through PancakeSwap's V3 SwapRouter, BNB in (wrapped by the router). */
+    const buildBuy = (b) => buildV3Buy(a, b);
+    /** A sell through the V3 SwapRouter for native BNB: swap to the router, unwrap to the seller. Needs approval to the router. */
+    const buildSell = (x) => buildV3Sell(a, x);
+    /** The approval a sell needs (the coin to the V3 router), or null. */
+    const sellApproval = (owner, token, amount) => approvalFor(ctx, owner, token, amount, a.v3Router, "Allowing PancakeSwap");
+    const refuse = (c) => {
+        if (!c.ok)
+            throw new PickhooksError(c.text, { code: "Blocked", args: [c.row === "locked" ? LOCKED : c.row] });
+    };
+    /** Quotes, checks the coin's rules for this wallet, and buys. A refusing rule stops it before anything is signed. */
+    async function buy(b, s = {}) {
+        const { address } = await signer(ctx, s.wallet);
+        const q = await quote({ token: b.token, side: "buy", amount: b.bnbIn, wallet: address });
+        const venue = b.venue ?? q.venue;
+        const quoted = (venue === "v2" ? q.v2 : q.v3) ?? q.amountOut;
+        refuse(await check({ token: b.token, side: "buy", wallet: address, amount: quoted }));
+        const minOut = b.minOut ?? minusBps(quoted, b.slippageBps ?? 100);
+        const deadline = b.deadline ?? (await chainDeadline(ctx));
+        const tx = venue === "v2" ? buildV2Buy(a, { token: b.token, bnbIn: b.bnbIn, minOut, recipient: address, deadline }) : buildBuy({ token: b.token, bnbIn: b.bnbIn, minOut, recipient: address, deadline });
+        const sent = await sendTx(ctx, tx, s);
+        return { ...sent, quoted, minOut, amountOut: receivedOf(sent.receipt, b.token, address), venue };
+    }
+    /** Checks the rules, approves the router if needed, quotes and sells for BNB. */
+    async function sell(x, s = {}) {
+        const { address } = await signer(ctx, s.wallet);
+        refuse(await check({ token: x.token, side: "sell", wallet: address, amount: x.amount }));
+        const q = await quote({ token: x.token, side: "sell", amount: x.amount });
+        const venue = x.venue ?? q.venue;
+        const quoted = (venue === "v2" ? q.v2 : q.v3) ?? q.amountOut;
+        const ap = await approvalFor(ctx, address, x.token, x.amount, venue === "v2" ? a.v2Router : a.v3Router, "Allowing PancakeSwap");
+        if (ap)
+            await sendTx(ctx, ap, s);
+        const minOut = x.minOut ?? minusBps(quoted, x.slippageBps ?? 100);
+        const deadline = x.deadline ?? (await chainDeadline(ctx));
+        const tx = venue === "v2" ? buildV2Sell(a, { token: x.token, amount: x.amount, minOut, recipient: address, deadline }) : buildSell({ token: x.token, amount: x.amount, minOut, recipient: address, deadline });
+        const sent = await sendTx(ctx, tx, s);
+        return { ...sent, quoted, minOut, venue };
+    }
+    /** The creator lifts a row for good (a drop row cannot be lifted). */
+    const buildLift = (token, row) => ({ to: token, value: 0n, data: encodeFunctionData({ abi: TA, functionName: "lift", args: [row] }), label: `Lifting rule ${row + 1}` });
+    const lockerOf = (token) => call(token, TA, "locker");
+    /** Anyone: collects the coin's trading fees from its locked position; the locker pays the creator's side to the creator. */
+    const buildCollect = async (token) => ({
+        to: await lockerOf(token),
+        value: 0n,
+        data: encodeFunctionData({ abi: v2LockerAbi, functionName: "collect", args: [token] }),
+        label: "The collect",
+    });
+    /**
+     * What collect() would book now (simulated): the BNB fees of the coin's position and the coins it burns, what of it goes
+     * to the creator (creatorBps of the fees is the creator side, keepBps of that the creator keeps, the rest buys back and
+     * burns $hooks), and BNB the locker holds for the creator because a payout bounced (withdrawPending() takes it).
+     */
+    async function fees(token) {
+        const locker = await lockerOf(token);
+        const pos = await call(locker, v2LockerAbi, "positions", [token]);
+        const [sim, pending] = await Promise.all([
+            pub.simulateContract({ address: locker, abi: v2LockerAbi, functionName: "collect", args: [token] }).then((r) => r.result),
+            call(locker, v2LockerAbi, "pending", [pos[2]]),
+        ]);
+        // the locker's own split
+        const side = (sim[0] * BigInt(pos[3])) / 10000n;
+        const toCreator = ((side - (side * BigInt(pos[4])) / 10000n) * BigInt(pos[5])) / 10000n;
+        return { bnb: sim[0], burned: sim[1], toCreator, creator: pos[2], creatorBps: Number(pos[3]), keepBps: Number(pos[5]), pending };
+    }
+    /** Collects the coin's fees; returns what the locker booked (its Collected event). */
+    async function collect(token, s = {}) {
+        const sent = await sendTx(ctx, await buildCollect(token), s);
+        const ev = parseEventLogs({ abi: v2LockerAbi, logs: sent.receipt.logs, eventName: "Collected" })[0];
+        return { ...sent, bnb: ev?.args.bnb ?? 0n, toCreator: ev?.args.toCreator ?? 0n, burned: ev?.args.burned ?? 0n };
+    }
+    return {
+        factory: F,
+        terms,
+        validate,
+        validateSwitch,
+        compile,
+        table: stickyTable,
+        testRun: stickyTestRun,
+        describeRows,
+        prepareMetadata,
+        count,
+        coins,
+        coin,
+        isCoin,
+        wallet,
+        check,
+        quote,
+        estimateBuy,
+        sellApproval,
+        build: { launch: buildLaunch, buy: buildBuy, sell: buildSell, lift: buildLift, collect: buildCollect },
+        launch,
+        buy,
+        sell,
+        lift: (token, row, s = {}) => sendTx(ctx, buildLift(token, row), s),
+        fees,
+        collect,
+        /** the sender's address, for callers that check before they sign */
+        from: (s = {}) => senderAddress(ctx, s.wallet),
+    };
+}

package/dist/tlock.d.ts

@@ -0,0 +1,67 @@
+import type { Hex } from "viem";
+export type Net = {
+    chainHash: string;
+    publicKey: string;
+    genesis: number;
+    period: number;
+    dst: string;
+    urls: string[];
+};
+export type Sealed = {
+    u: Hex;
+    v: Hex;
+    w: Hex;
+    round: number;
+    sigma: Hex;
+};
+export declare const QUICKNET: Net;
+declare const G2: import("@noble/curves/abstract/weierstrass").ProjConstructor<import("@noble/curves/abstract/tower").Fp2>;
+type G2P = InstanceType<typeof G2>;
+/** r = (keccak(TAG3 || 0x01 || sigma || M) * 2^256 + keccak(TAG3 || 0x02 || sigma || M)) mod q, never 0. */
+export declare function h3(sigma: Uint8Array, m: Uint8Array): bigint;
+/** keccak(TAG4 || sigma). */
+export declare function h4(sigma: Uint8Array): Uint8Array;
+/** First second at which drand publishes the round. */
+export declare function roundTime(round: number | bigint, net?: Net): number;
+/** First round published at or after `unixSeconds`. */
+export declare function roundAt(unixSeconds: number, net?: Net): number;
+/** The round's identity point: hash_to_G1(sha256(round as 8 bytes big endian)), as drand quicknet signs it. */
+export declare function roundPoint(round: number | bigint, net?: Net): import("@noble/curves/abstract/weierstrass").ProjPointType<bigint>;
+/** True when `sigHex` is drand's signature on `round` under the network's key. */
+export declare function verifyRoundSig(round: number | bigint, sigHex: string, net?: Net): boolean;
+/** G2 point to the 256 byte EIP-2537 encoding: x.c0, x.c1, y.c0, y.c1, each 64 bytes (16 zero bytes + 48). */
+export declare function g2ToEip(point: G2P): Hex;
+export declare function g2FromEip(h: string): G2P;
+/** The 32 byte message of a dark launch bid: the bidder (20 bytes), the step (1 byte), 11 zero bytes. */
+export declare function darkMessage(bidder: string, step: number): Hex;
+export declare function parseDarkMessage(m: string): {
+    bidder: Hex;
+    step: number;
+    clean: boolean;
+};
+/**
+ * Encrypts 32 bytes to a drand round. Returns hex ready for the contracts: u (256 bytes), v and w (32 each).
+ * `opts.sigma` and `opts.publicKey` exist for tests only.
+ */
+export declare function encrypt(round: number | bigint, message: string | Uint8Array, opts?: {
+    net?: Net;
+    sigma?: string | Uint8Array;
+    publicKey?: string;
+}): Sealed;
+/** Opens a ciphertext with drand's signature on its round: { sigma, message }, or null when it does not open. */
+export declare function decrypt(c: {
+    u: string;
+    v: string;
+    w: string;
+}, sigHex: string): {
+    sigma: Hex;
+    message: Hex;
+} | null;
+/** The contract's own check, in JS: U == H3(sigma, M) * G2 and W == M xor H4(sigma). */
+export declare function opens(c: {
+    u: string;
+    w: string;
+}, sigma: string | Uint8Array, message: string | Uint8Array): boolean;
+/** drand's signature on `round` (hex, 48 bytes), checked against the network's key. Null while the round is not out. */
+export declare function fetchRoundSig(round: number | bigint, net?: Net, fetcher?: typeof fetch): Promise<string | null>;
+export {};

package/dist/tlock.js

@@ -0,0 +1,185 @@
+// Time-lock encryption to a drand quicknet round, the same as the site's web/src/lib/hide-tlock.mjs (find the dev) and
+// what the dark launch's sealed bids use. Its own entry (@pickhooks/sdk/tlock), so the main SDK does not load BLS12-381.
+//
+// Ciphertext (U, V, W) for a 32 byte message M and the round's identity Q = hashToG1(sha256(round)):
+//   sigma random 32 bytes, r = H3(sigma, M) mod q
+//   U = r * G2                      (G2 point, 256 bytes in EIP-2537 encoding on chain)
+//   V = sigma xor H2(e(Q, pk)^r)
+//   W = M xor H4(sigma)
+// Opening needs drand's signature on the round (sig = s * Q): sigma = V xor H2(e(sig, U)), M = W xor H4(sigma).
+// The contracts check U == H3(sigma, M) * G2 and W == M xor H4(sigma) with the BLS12-381 precompile (HideMath.sol).
+import { bls12_381 as bls } from "@noble/curves/bls12-381";
+import { sha256 } from "@noble/hashes/sha2";
+import { keccak_256 } from "@noble/hashes/sha3";
+export const QUICKNET = {
+    chainHash: "52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971",
+    publicKey: "83cf0f2896adee7eb8b5f01fcad3912212c437e0073e911fb90022d3e760183c8c4b450b6a0a6c3ac6a5776a2d1064510d1fec758c921cc22b0e17e63aaf4bcb5ed66304de9cf809bd274ca73bab4af5a6e9c76a4bc09e76eae8991ef5ece45a",
+    genesis: 1692803367,
+    period: 3,
+    dst: "BLS_SIG_BLS12381G1_XMD:SHA-256_SSWU_RO_NUL_",
+    urls: ["https://api.drand.sh", "https://api2.drand.sh", "https://api3.drand.sh", "https://drand.cloudflare.com"],
+};
+const Q = bls.params.r;
+const TWO256 = 1n << 256n;
+const TAG3 = new TextEncoder().encode("pickhooks.hide.H3");
+const TAG4 = new TextEncoder().encode("pickhooks.hide.H4");
+const TAG2 = new TextEncoder().encode("pickhooks.hide.H2");
+const G2 = bls.G2.ProjectivePoint;
+const G1 = bls.G1.ProjectivePoint;
+const hex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+const unhex = (h) => {
+    const s = h.startsWith("0x") ? h.slice(2) : h;
+    if (s.length % 2)
+        throw new Error("odd hex");
+    const out = new Uint8Array(s.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16);
+    return out;
+};
+const concat = (...parts) => {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let o = 0;
+    for (const p of parts) {
+        out.set(p, o);
+        o += p.length;
+    }
+    return out;
+};
+const xor32 = (a, b) => {
+    const out = new Uint8Array(32);
+    for (let i = 0; i < 32; i++)
+        out[i] = a[i] ^ b[i];
+    return out;
+};
+const toBig = (b) => BigInt("0x" + (hex(b) || "0"));
+const be = (n, len) => unhex(n.toString(16).padStart(len * 2, "0"));
+const bytes32 = (x) => {
+    const b = typeof x === "string" ? unhex(x) : x;
+    if (b.length !== 32)
+        throw new Error("need 32 bytes");
+    return b;
+};
+/** r = (keccak(TAG3 || 0x01 || sigma || M) * 2^256 + keccak(TAG3 || 0x02 || sigma || M)) mod q, never 0. */
+export function h3(sigma, m) {
+    const a = toBig(keccak_256(concat(TAG3, Uint8Array.of(1), sigma, m)));
+    const b = toBig(keccak_256(concat(TAG3, Uint8Array.of(2), sigma, m)));
+    const r = (a * TWO256 + b) % Q;
+    return r === 0n ? 1n : r;
+}
+/** keccak(TAG4 || sigma). */
+export function h4(sigma) {
+    return keccak_256(concat(TAG4, sigma));
+}
+function h2(gt) {
+    return keccak_256(concat(TAG2, bls.fields.Fp12.toBytes(gt)));
+}
+/** First second at which drand publishes the round. */
+export function roundTime(round, net = QUICKNET) {
+    return net.genesis + (Number(round) - 1) * net.period;
+}
+/** First round published at or after `unixSeconds`. */
+export function roundAt(unixSeconds, net = QUICKNET) {
+    const t = Math.max(0, Math.ceil(unixSeconds) - net.genesis);
+    return Math.ceil(t / net.period) + 1;
+}
+/** The round's identity point: hash_to_G1(sha256(round as 8 bytes big endian)), as drand quicknet signs it. */
+export function roundPoint(round, net = QUICKNET) {
+    return G1.fromAffine(bls.G1.hashToCurve(sha256(be(BigInt(round), 8)), { DST: net.dst }).toAffine());
+}
+/** True when `sigHex` is drand's signature on `round` under the network's key. */
+export function verifyRoundSig(round, sigHex, net = QUICKNET) {
+    const sig = G1.fromHex(sigHex.startsWith("0x") ? sigHex.slice(2) : sigHex);
+    const pk = G2.fromHex(net.publicKey);
+    const lhs = bls.pairing(sig, G2.BASE);
+    const rhs = bls.pairing(roundPoint(round, net), pk);
+    return bls.fields.Fp12.eql(lhs, rhs);
+}
+/** G2 point to the 256 byte EIP-2537 encoding: x.c0, x.c1, y.c0, y.c1, each 64 bytes (16 zero bytes + 48). */
+export function g2ToEip(point) {
+    const { x, y } = point.toAffine();
+    return `0x${[x.c0, x.c1, y.c0, y.c1].map((v) => v.toString(16).padStart(128, "0")).join("")}`;
+}
+export function g2FromEip(h) {
+    const b = unhex(h);
+    if (b.length !== 256)
+        throw new Error("U must be 256 bytes");
+    const f = (i) => toBig(b.slice(i * 64, i * 64 + 64));
+    const Fp2 = bls.fields.Fp2;
+    const p = G2.fromAffine({ x: Fp2.create({ c0: f(0), c1: f(1) }), y: Fp2.create({ c0: f(2), c1: f(3) }) });
+    p.assertValidity();
+    return p;
+}
+/** The 32 byte message of a dark launch bid: the bidder (20 bytes), the step (1 byte), 11 zero bytes. */
+export function darkMessage(bidder, step) {
+    const a = unhex(bidder);
+    if (a.length !== 20)
+        throw new Error("bidder must be 20 bytes");
+    if (!(Number.isInteger(step) && step >= 0 && step < 24))
+        throw new Error("step must be 0 to 23");
+    return `0x${hex(concat(a, Uint8Array.of(step), new Uint8Array(11)))}`;
+}
+export function parseDarkMessage(m) {
+    const b = bytes32(m);
+    return { bidder: `0x${hex(b.slice(0, 20))}`, step: b[20], clean: b.slice(21).every((x) => x === 0) };
+}
+/**
+ * Encrypts 32 bytes to a drand round. Returns hex ready for the contracts: u (256 bytes), v and w (32 each).
+ * `opts.sigma` and `opts.publicKey` exist for tests only.
+ */
+export function encrypt(round, message, opts = {}) {
+    const net = opts.net ?? QUICKNET;
+    const m = bytes32(message);
+    const sigma = opts.sigma ? bytes32(opts.sigma) : crypto.getRandomValues(new Uint8Array(32));
+    const r = h3(sigma, m);
+    const pk = G2.fromHex(opts.publicKey ?? net.publicKey);
+    const U = G2.BASE.multiply(r);
+    const gid = bls.pairing(roundPoint(round, net), pk.multiply(r));
+    const V = xor32(sigma, h2(gid));
+    const W = xor32(m, h4(sigma));
+    return { u: g2ToEip(U), v: `0x${hex(V)}`, w: `0x${hex(W)}`, round: Number(round), sigma: `0x${hex(sigma)}` };
+}
+/** Opens a ciphertext with drand's signature on its round: { sigma, message }, or null when it does not open. */
+export function decrypt(c, sigHex) {
+    let U;
+    try {
+        U = g2FromEip(c.u);
+    }
+    catch {
+        return null;
+    }
+    const sig = G1.fromHex(sigHex.startsWith("0x") ? sigHex.slice(2) : sigHex);
+    const gid = bls.pairing(sig, U);
+    const sigma = xor32(bytes32(c.v), h2(gid));
+    const m = xor32(bytes32(c.w), h4(sigma));
+    if (!opens(c, sigma, m))
+        return null;
+    return { sigma: `0x${hex(sigma)}`, message: `0x${hex(m)}` };
+}
+/** The contract's own check, in JS: U == H3(sigma, M) * G2 and W == M xor H4(sigma). */
+export function opens(c, sigma, message) {
+    const s = bytes32(sigma);
+    const m = bytes32(message);
+    if (hex(xor32(m, h4(s))) !== hex(bytes32(c.w)))
+        return false;
+    return g2ToEip(G2.BASE.multiply(h3(s, m))).toLowerCase() === c.u.toLowerCase();
+}
+/** drand's signature on `round` (hex, 48 bytes), checked against the network's key. Null while the round is not out. */
+export async function fetchRoundSig(round, net = QUICKNET, fetcher = fetch) {
+    for (const base of net.urls) {
+        try {
+            const res = await fetcher(`${base}/${net.chainHash}/public/${round}`, { cache: "no-store" });
+            if (!res.ok)
+                continue;
+            const j = (await res.json());
+            if (Number(j.round) !== Number(round) || typeof j.signature !== "string")
+                continue;
+            if (!verifyRoundSig(round, j.signature, net))
+                continue;
+            return j.signature;
+        }
+        catch {
+            // next relay
+        }
+    }
+    return null;
+}