@pickhooks/sdk 0.2.0 → 0.5.0

package/dist/text-launch.d.ts

@@ -0,0 +1,52 @@
+import type { ModeName } from "./addresses.js";
+import { MODES, type ModeSettings } from "./modes-catalog.js";
+import { type TemplateId } from "./sticky-rules.js";
+/**
+ * launch from a sentence: "CAT, combo, dev lock 7 days, sniper jail 24h, dev buy 0.05" becomes a sticky 3 launch
+ * (name, ticker, mode with its settings, rule templates, first buy). The fixed parser reads the usual phrasings (English,
+ * and the German units the pad's users write: Tage, Std, Minuten) with no model and no key. For anything else pass your
+ * own reader (a model with your key): it gets the sentence and the catalog and must answer with the same draft. Neither
+ * can produce anything but templates and a listed mode; the validator and the mode check it on chain before a launch.
+ */
+export type TextPick = {
+    id: TemplateId;
+    params: Record<string, number>;
+};
+export type TextDraft = {
+    name: string;
+    symbol: string;
+    mode: ModeName | null;
+    modeSettings?: ModeSettings;
+    picks: TextPick[];
+    devBuyBnb: number;
+};
+export type TextRead = {
+    /** null when the sentence names no ticker */
+    draft: TextDraft | null;
+    /** clauses the parser did not understand (a reader of your own can take them) */
+    unknown: string[];
+    /** what sticky coins can never do, with the closest rule that can */
+    refusals: string[];
+    notes: string[];
+};
+/** What sticky coins can never do, and the closest rule that can. */
+export declare const NOT_POSSIBLE: {
+    test: RegExp;
+    reply: string;
+}[];
+/**
+ * Reads a sentence. The ticker comes first ("$CAT" or "CAT"), then the name ("CAT Cat Coin, combo, ..."), then
+ * clauses split by commas, semicolons, "and" / "und". ok is up to the caller: a draft with unknown clauses is a
+ * question, not a launch.
+ */
+export declare function readLaunch(text: string): TextRead;
+/**
+ * Reads a sentence with the fixed parser, and hands what it did not understand to `reader` (your model, your key) with
+ * the catalog of modes and templates. The reader answers with a full draft or null.
+ */
+export declare function understandLaunch(text: string, reader?: (text: string, catalog: {
+    modes: typeof MODES;
+    templates: string[];
+}) => Promise<TextDraft | null>): Promise<TextRead & {
+    by: "parser" | "reader" | null;
+}>;

package/dist/text-launch.js

@@ -0,0 +1,178 @@
+import { MODES } from "./modes-catalog.js";
+import { TEMPLATE_BY_ID } from "./sticky-rules.js";
+/** What sticky coins can never do, and the closest rule that can. */
+export const NOT_POSSIBLE = [
+    {
+        test: /\b(sell|selling|paper ?hands?|exit)\b[^,;\n]{0,24}\b(tax|fee|fees|pay|pays|penalty)\b|\b(tax|taxes|steuer)\b/i,
+        reply: "Sell fees are not possible on sticky coins: a sell or a send is never taxed. Closest: a hold time (sells wait a while) or drip (big buys unlock over hours).",
+    },
+    { test: /\b(blacklist|blocklist|ban|freeze|pause)\b/i, reply: "Nobody can freeze or ban a wallet on sticky coins. Closest: sniper jail (early buys wait before they can sell)." },
+    { test: /\b(mint|minting|more supply|inflation)\b/i, reply: "The supply is fixed at 1 billion, nobody can mint. Closest: auto burn (a share of every buy burns)." },
+];
+/** the words that name each mode */
+const MODE_WORDS = [
+    ["forward", /\bpay\s*it\s*forward\b|\bforward\s*mode\b/i],
+    ["combo", /\bcombo\b/i],
+];
+const num = (s) => Number(s.replace(",", "."));
+const UNIT = "(m|mins?|minutes?|minuten|h|hrs?|hours?|std|stunden?|d|days?|tage?n?)";
+const minutes = (n, unit) => {
+    const u = unit.toLowerCase();
+    const x = num(n);
+    if (u.startsWith("d") || u.startsWith("t"))
+        return x * 1440;
+    if (u.startsWith("h") || u.startsWith("s"))
+        return x * 60;
+    return x;
+};
+const pick = (d, id, params) => {
+    const t = TEMPLATE_BY_ID.get(id);
+    if (!t)
+        return;
+    const defaults = Object.fromEntries(t.params.map((p) => [p.key, p.def]));
+    const had = d.picks.find((p) => p.id === id);
+    if (had)
+        Object.assign(had.params, params);
+    else
+        d.picks.push({ id, params: { ...defaults, ...params } });
+};
+const READERS = [
+    // a mode, with its share: "combo", "combo 3%", "pay it forward 3 %"
+    (c, d) => {
+        const hit = MODE_WORDS.find(([, re]) => re.test(c));
+        if (!hit)
+            return false;
+        d.mode = hit[0];
+        const m = c.match(/(\d+(?:[.,]\d+)?)\s*%/);
+        const info = MODES[hit[0]];
+        if (m && info.settings.includes("bps"))
+            d.modeSettings = { ...d.modeSettings, bps: Math.round(num(m[1]) * 100) };
+        return true;
+    },
+    // hold 1h / hold time 30 min / sells wait 2h
+    (c, d) => {
+        const m = c.match(new RegExp(`\\b(?:hold(?:\\s*time)?|sells?\\s+wait|hold\\s+for|haltezeit)\\s*(\\d+(?:[.,]\\d+)?)\\s*${UNIT}\\b`, "i"));
+        if (!m)
+            return false;
+        pick(d, "hold", { m: minutes(m[1], m[2]) });
+        return true;
+    },
+    // sniper jail / anti bundle / snipers wait 12 hours
+    (c, d) => {
+        if (!/\bsnipers?\b|\bbundl/i.test(c))
+            return false;
+        const m = c.match(new RegExp(`(\\d+(?:[.,]\\d+)?)\\s*${UNIT}`, "i"));
+        const b = c.match(/first\s+(\d+)\s+blocks?/i);
+        pick(d, "sniper", { ...(m && { h: minutes(m[1], m[2]) / 60 }), ...(b && { b: num(b[1]) }) });
+        return true;
+    },
+    // dev lock 7 days / dev lock 7 Tage
+    (c, d) => {
+        if (!/\bdev\s*(?:lock|locked|can'?t\s+sell|sperre)/i.test(c))
+            return false;
+        const m = c.match(new RegExp(`(\\d+(?:[.,]\\d+)?)\\s*${UNIT}`, "i"));
+        pick(d, "devlock", m ? { d: minutes(m[1], m[2]) / 1440 } : {});
+        return true;
+    },
+    // drip / drip over 6h / big buys drip
+    (c, d) => {
+        if (!/\bdrip/i.test(c))
+            return false;
+        const m = c.match(new RegExp(`(\\d+(?:[.,]\\d+)?)\\s*${UNIT}`, "i"));
+        const big = c.match(/(?:from|over|above)\s*(\d+(?:[.,]\d+)?)\s*%/i);
+        pick(d, "drip", { ...(m && { h: minutes(m[1], m[2]) / 60 }), ...(big && { big: num(big[1]) }), ...(/\b(every|all)\s+buys?\b/i.test(c) && { big: 0 }) });
+        return true;
+    },
+    // max buy 1%
+    (c, d) => {
+        const m = c.match(/\bmax(?:imum)?\s*(?:per\s*)?buy\s*(?:of\s*)?(\d+(?:[.,]\d+)?)\s*%/i);
+        if (!m)
+            return false;
+        pick(d, "maxbuy", { pct: num(m[1]) });
+        return true;
+    },
+    // max wallet 2%
+    (c, d) => {
+        const m = c.match(/\bmax(?:imum)?\s*wallet\s*(?:of\s*)?(\d+(?:[.,]\d+)?)\s*%/i);
+        if (!m)
+            return false;
+        pick(d, "maxwallet", { pct: num(m[1]) });
+        return true;
+    },
+    // burn 1% / auto burn 2%
+    (c, d) => {
+        const m = c.match(/\b(?:auto\s*)?burns?\s*(\d+(?:[.,]\d+)?)\s*%/i) ?? c.match(/(\d+(?:[.,]\d+)?)\s*%\s*(?:of\s+(?:every|each)\s+buy\s+)?(?:is\s+)?burn(?:s|ed)?\b/i);
+        if (!m)
+            return false;
+        pick(d, "burn", { pct: num(m[1]) });
+        return true;
+    },
+    // market hours 6-22 (UTC)
+    (c, d) => {
+        const m = c.match(/\bmarket\s*hours?\s*(\d{1,2})\s*(?:-|to|until|bis)\s*(\d{1,2})/i);
+        if (!m)
+            return false;
+        pick(d, "hours", { open: num(m[1]), close: num(m[2]) });
+        return true;
+    },
+    // dev buy 0.02 (bnb)
+    (c, d) => {
+        const m = c.match(/\b(?:dev\s*buy|first\s*buy|buy\s*first|erster\s*kauf)\s*(\d+(?:[.,]\d+)?)\s*(?:bnb)?\b/i);
+        if (!m)
+            return false;
+        d.devBuyBnb = num(m[1]);
+        return true;
+    },
+];
+/**
+ * Reads a sentence. The ticker comes first ("$CAT" or "CAT"), then the name ("CAT Cat Coin, combo, ..."), then
+ * clauses split by commas, semicolons, "and" / "und". ok is up to the caller: a draft with unknown clauses is a
+ * question, not a launch.
+ */
+export function readLaunch(text) {
+    const refusals = NOT_POSSIBLE.filter((n) => n.test.test(text)).map((n) => n.reply);
+    const body = text.replace(/@\w+/g, " ").replace(/^\s*\/?launch\b/i, " ").trim();
+    const parts = body.split(/[,;\n]|\band\b|\bund\b/i).map((x) => x.trim()).filter(Boolean);
+    const notes = [];
+    if (!parts.length)
+        return { draft: null, unknown: [], refusals, notes: ["Nothing to read: start with the ticker, like CAT or $CAT."] };
+    const head = parts[0].match(/^\$?([A-Za-z0-9]{1,10})\b\s*[-:]?\s*(.*)$/);
+    if (!head)
+        return { draft: null, unknown: [], refusals, notes: ["No ticker: start with it, like CAT or $CAT."] };
+    const symbol = head[1].toUpperCase();
+    const name = head[2].trim() || symbol;
+    const d = { name: name.slice(0, 32), symbol, mode: null, picks: [], devBuyBnb: 0 };
+    const unknown = [];
+    for (const c of parts.slice(1)) {
+        if (NOT_POSSIBLE.some((n) => n.test.test(c)))
+            continue;
+        if (!READERS.some((r) => r(c, d)))
+            unknown.push(c);
+    }
+    if (name === symbol)
+        notes.push(`No name after the ticker: the coin is called ${symbol}.`);
+    if (!d.mode)
+        notes.push("No mode named: the coin launches with rules only (like sticky 2).");
+    return { draft: d, unknown, refusals, notes };
+}
+/**
+ * Reads a sentence with the fixed parser, and hands what it did not understand to `reader` (your model, your key) with
+ * the catalog of modes and templates. The reader answers with a full draft or null.
+ */
+export async function understandLaunch(text, reader) {
+    const r = readLaunch(text);
+    if (r.draft && !r.unknown.length)
+        return { ...r, by: "parser" };
+    if (!reader)
+        return { ...r, by: null };
+    const d = await reader(text, { modes: MODES, templates: [...TEMPLATE_BY_ID.keys()] });
+    if (!d)
+        return { ...r, by: null };
+    // a reader can only pick what exists
+    if (d.mode && !(d.mode in MODES))
+        return { ...r, notes: [...r.notes, `The reader named a mode that does not exist: ${d.mode}.`], by: null };
+    const bad = d.picks.filter((p) => !TEMPLATE_BY_ID.has(p.id));
+    if (bad.length)
+        return { ...r, notes: [...r.notes, `The reader named templates that do not exist: ${bad.map((p) => p.id).join(", ")}.`], by: null };
+    return { draft: d, unknown: [], refusals: r.refusals, notes: r.notes, by: "reader" };
+}

package/dist/tlock.d.ts

@@ -0,0 +1,77 @@
+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>;
+/** A G1 point (drand's compressed signature, 48 bytes hex) in the 128 byte EIP-2537 encoding the DrandBeacon checks. */
+export declare function g1ToEip(sigHex: string): Hex;
+/**
+ * drand's signature on `round` ready for DrandBeacon.submit (128 bytes, checked against quicknet's key), and the
+ * randomness the beacon will keep: keccak256 of those bytes. Null while the round is not out.
+ */
+export declare function beaconSig(round: number | bigint, net?: Net, fetcher?: typeof fetch): Promise<{
+    sig: Hex;
+    randomness: Hex;
+} | null>;
+export {};

package/dist/tlock.js

@@ -0,0 +1,201 @@
+// 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;
+}
+/** A G1 point (drand's compressed signature, 48 bytes hex) in the 128 byte EIP-2537 encoding the DrandBeacon checks. */
+export function g1ToEip(sigHex) {
+    const { x, y } = G1.fromHex(sigHex.startsWith("0x") ? sigHex.slice(2) : sigHex).toAffine();
+    return `0x${[x, y].map((v) => v.toString(16).padStart(128, "0")).join("")}`;
+}
+/**
+ * drand's signature on `round` ready for DrandBeacon.submit (128 bytes, checked against quicknet's key), and the
+ * randomness the beacon will keep: keccak256 of those bytes. Null while the round is not out.
+ */
+export async function beaconSig(round, net = QUICKNET, fetcher = fetch) {
+    const s = await fetchRoundSig(round, net, fetcher);
+    if (!s)
+        return null;
+    const sig = g1ToEip(s);
+    return { sig, randomness: `0x${hex(keccak_256(unhex(sig)))}` };
+}

package/dist/tx.d.ts

@@ -66,5 +66,7 @@ export declare function sendTx(ctx: Ctx, tx: TxRequest, o?: SendOptions): Promis
 export declare function sendAll(ctx: Ctx, txs: TxRequest[], o?: SendOptions): Promise<Sent[]>;
 /** A deadline 10 minutes from now (seconds), for router calls. */
 export declare const deadlineIn: (seconds?: number) => bigint;
+/** A deadline from the later of this machine's clock and the chain's (a skewed clock or a fork ahead of real time). */
+export declare function chainDeadline(ctx: Ctx, seconds?: number): Promise<bigint>;
 /** amount less a slippage in basis points */
 export declare const minusBps: (amount: bigint, bps: number) => bigint;

package/dist/tx.js

@@ -65,5 +65,14 @@ export async function sendAll(ctx, txs, o = {}) {
 }
 /** A deadline 10 minutes from now (seconds), for router calls. */
 export const deadlineIn = (seconds = 600) => BigInt(Math.floor(Date.now() / 1000) + seconds);
+/** A deadline from the later of this machine's clock and the chain's (a skewed clock or a fork ahead of real time). */
+export async function chainDeadline(ctx, seconds = 600) {
+    const local = Math.floor(Date.now() / 1000);
+    const chain = await ctx.pub
+        .getBlock()
+        .then((b) => Number(b.timestamp))
+        .catch(() => local);
+    return BigInt(Math.max(local, chain) + seconds);
+}
 /** amount less a slippage in basis points */
 export const minusBps = (amount, bps) => (amount * BigInt(10_000 - Math.max(0, Math.min(10_000, Math.round(bps))))) / 10000n;

package/dist/v2.d.ts

@@ -0,0 +1,106 @@
+import { type Address } from "viem";
+import type { Addresses } from "./addresses.js";
+import { type Ctx, type TxRequest } from "./tx.js";
+/**
+ * PancakeSwap V2: every sticky coin (and every rules coin since 03.10.) has a V2 pair next to its V3 pool, at the same
+ * start price. A dark launch puts the whole round's BNB into that pair, so right after the birth the pair is the venue
+ * with the BNB and the V3 curve holds only coins above the price: a sell into V3 would get almost nothing ("SPL").
+ * Terminals route to the better pool by themselves; the SDK quotes both and picks the better one (sticky.quote).
+ */
+export declare const v2RouterAbi: readonly [{
+    readonly name: "getAmountsOut";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amountIn";
+    }, {
+        readonly type: "address[]";
+        readonly name: "path";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256[]";
+        readonly name: "amounts";
+    }];
+}, {
+    readonly name: "swapExactETHForTokensSupportingFeeOnTransferTokens";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amountOutMin";
+    }, {
+        readonly type: "address[]";
+        readonly name: "path";
+    }, {
+        readonly type: "address";
+        readonly name: "to";
+    }, {
+        readonly type: "uint256";
+        readonly name: "deadline";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "swapExactTokensForETHSupportingFeeOnTransferTokens";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amountIn";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amountOutMin";
+    }, {
+        readonly type: "address[]";
+        readonly name: "path";
+    }, {
+        readonly type: "address";
+        readonly name: "to";
+    }, {
+        readonly type: "uint256";
+        readonly name: "deadline";
+    }];
+    readonly outputs: readonly [];
+}];
+export type Venue = "v3" | "v2";
+/** What a trade gets in the V2 pair, from the router (reverts when the coin has no pair or the pair is empty). */
+export declare function v2Quote(ctx: Ctx, q: {
+    token: Address;
+    side: "buy" | "sell";
+    amount: bigint;
+}): Promise<bigint>;
+/** A buy through the V2 router, BNB in. */
+export declare function buildV2Buy(a: Addresses, b: {
+    token: Address;
+    bnbIn: bigint;
+    minOut: bigint;
+    recipient: Address;
+    deadline?: bigint;
+    gasPct?: number;
+}): TxRequest;
+/** A sell through the V2 router for native BNB. Needs the coin approved to the V2 router. */
+export declare function buildV2Sell(a: Addresses, s: {
+    token: Address;
+    amount: bigint;
+    minOut: bigint;
+    recipient: Address;
+    deadline?: bigint;
+    gasPct?: number;
+}): TxRequest;
+/**
+ * The better of the two venues for this trade: the V3 pool (quoter) and the V2 pair (router). A venue that cannot
+ * quote (no pair, no BNB below the price, a refusing rule) counts as nothing; `errors` keeps what each one said.
+ */
+export declare function bestVenue(ctx: Ctx, quotes: {
+    v3: () => Promise<bigint>;
+    v2: () => Promise<bigint>;
+}): Promise<{
+    venue: Venue;
+    amountOut: bigint;
+    v3: bigint | null;
+    v2: bigint | null;
+    errors: {
+        v3?: unknown;
+        v2?: unknown;
+    };
+}>;