@pickhooks/sdk 0.4.0 → 0.5.0

package/dist/sticky.js

@@ -1,6 +1,9 @@
 import { encodeFunctionData, parseEventLogs } from "viem";
 import { stickyFactoryAbi, stickyTokenAbi, stickyValidatorAbi } from "./abis/sticky.js";
 import { sticky2FactoryAbi, sticky2TokenAbi, sticky2ValidatorAbi } from "./abis/sticky2.js";
+import { sticky3FactoryAbi, sticky3LensAbi, sticky3TokenAbi, sticky3ValidatorAbi } from "./abis/sticky3.js";
+import { MODE_NAMES } from "./addresses.js";
+import { encodeModeData } from "./modes-catalog.js";
 import { v3PoolAbi } from "./abis/common.js";
 import { v2LockerAbi } from "./abis/v2.js";
 import { ZERO_ADDRESS } from "./addresses.js";
@@ -10,6 +13,18 @@ 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 sticky3ModeQuoteAbi = [
+    {
+        type: "function",
+        name: "quote",
+        stateMutability: "view",
+        inputs: [
+            { name: "creator", type: "address" },
+            { name: "data", type: "bytes" },
+        ],
+        outputs: [{ name: "gameBps", type: "uint16" }],
+    },
+];
 const randomSalt = () => {
     const b = new Uint8Array(32);
     globalThis.crypto.getRandomValues(b);
@@ -96,13 +111,18 @@ export function stickyTestRun(l) {
 }
 /**
  * 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).
+ * the creator's sold coins and can carry switch rows, see ph.sticky2). `3` points it at sticky 3: the same again, plus a
+ * mode per coin (launch with `mode` and `modeSettings`; the game itself is ph.modes); a sticky 3 coin leaves its lot
+ * views to the lens.
  */
-export function stickyModule(ctx, v2 = false) {
+export function stickyModule(ctx, version = false) {
     const { pub, a } = ctx;
-    const F = v2 ? a.sticky2Factory : a.stickyFactory;
-    const FA = (v2 ? sticky2FactoryAbi : stickyFactoryAbi);
-    const TA = (v2 ? sticky2TokenAbi : stickyTokenAbi);
+    const v3 = version === 3;
+    const v2 = version === true || v3; // sticky 3 has everything sticky 2 has
+    const F = v3 ? a.sticky3Factory : v2 ? a.sticky2Factory : a.stickyFactory;
+    const FA = (v3 ? sticky3FactoryAbi : v2 ? sticky2FactoryAbi : stickyFactoryAbi);
+    const TA = (v3 ? sticky3TokenAbi : v2 ? sticky2TokenAbi : stickyTokenAbi);
+    const modeName = (m) => m.toLowerCase() === ZERO_ADDRESS ? null : (MODE_NAMES.find((n) => a.modes[n].toLowerCase() === m.toLowerCase()) ?? "other");
     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() {
@@ -127,7 +147,7 @@ export function stickyModule(ctx, v2 = false) {
         if (!v2)
             return "Switch rows are a sticky 2 feature.";
         try {
-            await call(validator ?? (await terms()).validator, sticky2ValidatorAbi, "switchRows", [rows, mask]);
+            await call(validator ?? (await terms()).validator, (v3 ? sticky3ValidatorAbi : sticky2ValidatorAbi), "switchRows", [rows, mask]);
             return null;
         }
         catch (e) {
@@ -155,9 +175,38 @@ export function stickyModule(ctx, v2 = false) {
         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;
+        const full2 = v2 ? { ...args, switcher: l.switchMask ? (l.switcher ?? a.ruleAuction) : ZERO_ADDRESS, switchMask: l.switchMask ?? 0 } : args;
+        if (!v3 && l.mode)
+            throw new PickhooksError("Modes are a sticky 3 feature.", { code: "input" });
+        const modeAddr = l.mode ? a.modes[l.mode] : ZERO_ADDRESS;
+        if (l.mode && modeAddr.toLowerCase() === ZERO_ADDRESS)
+            throw new PickhooksError(`The mode ${l.mode} is not deployed yet.`, { code: "input" });
+        const full = v3 ? { ...full2, mode: modeAddr, modeData: l.mode ? encodeModeData(l.mode, l.modeSettings) : "0x" } : full2;
         return { to: F, value, data: encodeFunctionData({ abi: FA, functionName: "launch", args: [full] }), label: "The launch" };
     }
+    /**
+     * sticky 3: asks the mode for its share of buys with these settings (it refuses settings out of bounds) and the validator
+     * whether that share fits next to the rows' burns and pots (10 % of a buy at most). null when the launch can go.
+     */
+    async function validateMode(mode, settings, rows, validator, creator) {
+        if (!v3)
+            return "Modes are a sticky 3 feature.";
+        const m = a.modes[mode];
+        if (m.toLowerCase() === ZERO_ADDRESS)
+            return `The mode ${mode} is not deployed yet.`;
+        try {
+            const listed = await call(F, FA, "modes", [m]);
+            if (!listed)
+                return `The mode ${mode} is not open for launches yet.`;
+            const from = creator ?? (await senderAddress(ctx)) ?? ZERO_ADDRESS;
+            const bps = await call(m, sticky3ModeQuoteAbi, "quote", [from, encodeModeData(mode, settings)]);
+            await call(validator ?? (await terms()).validator, sticky3ValidatorAbi, "game", [rows, bps]);
+            return null;
+        }
+        catch (e) {
+            return explain(e, "The mode refused these settings.").text;
+        }
+    }
     /** 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();
@@ -173,7 +222,12 @@ export function stickyModule(ctx, v2 = false) {
             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));
+        if (l.mode) {
+            const no = await validateMode(l.mode, l.modeSettings, rows, 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, mode: l.mode, modeSettings: l.modeSettings }, 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];
@@ -192,6 +246,16 @@ export function stickyModule(ctx, v2 = false) {
             contracts: pools.map((p) => ({ address: (p ?? a.wbnb), abi: v3PoolAbi, functionName: "slot0" })),
             allowFailure: true,
         });
+        const modeRes = v3
+            ? await pub.multicall({
+                contracts: tokens.flatMap((t) => [
+                    { address: t, abi: TA, functionName: "mode" },
+                    { address: t, abi: TA, functionName: "gameBps" },
+                    { address: t, abi: TA, functionName: "gamePot" },
+                ]),
+                allowFailure: true,
+            })
+            : [];
         const out = [];
         tokens.forEach((token, i) => {
             const g = (k) => res[i * per + k];
@@ -223,6 +287,16 @@ export function stickyModule(ctx, v2 = false) {
                 totalSupply: supply,
                 priceBnb,
                 mcapBnb: priceBnb * (Number(supply) / 1e18),
+                ...(v3 && modeRes[i * 3]?.status === "success"
+                    ? {
+                        mode: {
+                            name: modeName(modeRes[i * 3].result),
+                            address: modeRes[i * 3].result,
+                            gameBps: Number(modeRes[i * 3 + 1].result ?? 0),
+                            gamePot: modeRes[i * 3 + 2].result ?? 0n,
+                        },
+                    }
+                    : {}),
             });
         });
         return out;
@@ -252,6 +326,20 @@ export function stickyModule(ctx, v2 = false) {
     }
     /** A wallet's lots (amount, locked part, since, marks), its balance and what it can sell now. */
     async function wallet(token, who) {
+        if (v3) {
+            const [bal, sellable, lots, held] = await Promise.all([
+                call(token, TA, "balanceOf", [who]),
+                call(a.sticky3Lens, sticky3LensAbi, "sellable", [token, who]),
+                call(a.sticky3Lens, sticky3LensAbi, "lotsOf", [token, who]),
+                call(token, TA, "heldOf", [who]),
+            ]);
+            return {
+                balance: bal,
+                sellable,
+                lots: lots.amount.map((x, i) => ({ amount: x, locked: lots.locked[i], since: Number(lots.since[i]), flags: Number(lots.flags[i]), open: lots.open[i] })),
+                held: held[0],
+            };
+        }
         const r = await pub.multicall({
             contracts: [
                 { address: token, abi: TA, functionName: "balanceOf", args: [who] },
@@ -326,6 +414,25 @@ export function stickyModule(ctx, v2 = false) {
         if (!c.ok)
             throw new PickhooksError(c.text, { code: "Blocked", args: [c.row === "locked" ? LOCKED : c.row] });
     };
+    /**
+     * The share of a buy the coin keeps, basis points: its burn and pot rows on buys that are not lifted, and a sticky 3
+     * coin's game share (at most 10 %). The V2 router measures what arrives in the wallet, after the coin took its share,
+     * so a V2 buy's minimum leaves it out; the V3 router measures what the pool sends, before it.
+     */
+    async function buyTakeBps(token) {
+        const [raw, , off] = await call(token, TA, "script");
+        let take = 0;
+        raw.forEach((x, i) => {
+            if ((Number(off) >> i) & 1)
+                return;
+            const r = decodeRow(x);
+            if (r.on & ON.BUY && (r.act === ACT.BURN || r.act === ACT.POT))
+                take += r.arg;
+        });
+        if (v3)
+            take += Number(await call(token, TA, "gameBps").catch(() => 0));
+        return Math.min(take, 1000);
+    }
     /** 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);
@@ -333,7 +440,8 @@ export function stickyModule(ctx, v2 = false) {
         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 arrives = venue === "v2" ? minusBps(quoted, await buyTakeBps(b.token)) : quoted;
+        const minOut = b.minOut ?? minusBps(arrives, 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);
@@ -393,6 +501,7 @@ export function stickyModule(ctx, v2 = false) {
         terms,
         validate,
         validateSwitch,
+        validateMode,
         compile,
         table: stickyTable,
         testRun: stickyTestRun,
@@ -406,6 +515,7 @@ export function stickyModule(ctx, v2 = false) {
         check,
         quote,
         estimateBuy,
+        buyTakeBps,
         sellApproval,
         build: { launch: buildLaunch, buy: buildBuy, sell: buildSell, lift: buildLift, collect: buildCollect },
         launch,

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

@@ -64,4 +64,14 @@ export declare function opens(c: {
 }, 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

@@ -183,3 +183,19 @@ export async function fetchRoundSig(round, net = QUICKNET, fetcher = fetch) {
     }
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pickhooks/sdk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Read, quote, trade and launch on pickhooks (BNB Chain) from a bot, a launchpad or a trading terminal. Built on viem.",
   "license": "MIT",
   "type": "module",
@@ -42,7 +42,8 @@
     "fork-proof-2": "node test/fork-proof-2.mjs",
     "fork-proof-infra": "node test/fork-proof-infra.mjs",
     "mainnet-read-agents": "node test/mainnet-read-agents.mjs",
-    "release": "node scripts/publish.mjs"
+    "release": "node scripts/publish.mjs",
+    "fork-proof-sticky3": "node test/fork-proof-sticky3.mjs"
   },
   "dependencies": {
     "@noble/curves": "^1.9.1",