@pickhooks/sdk 0.0.0-stage → 0.2.0

package/dist/pools.d.ts

@@ -0,0 +1,274 @@
+import { type Address, type Hex } from "viem";
+import { type Picked, type R } from "./coin-rules.js";
+import type { CoinRule } from "./coins.js";
+import { type PoolKey } from "./infinity.js";
+import { type Ctx, type SendOptions, type Sent, type TxRequest } from "./tx.js";
+/**
+ * Coins with their rules in a PancakeSwap Infinity pool hook: the coin is a plain ERC20, the hook checks the rules on every
+ * swap of its pool and takes the fee from the BNB side. Two products share this shape:
+ *  - pools (factory 0x3F97…241B): rules in the pool
+ *  - curve calls (factory 0x98D4…8301): the curve is held by the calls desk as 24 steps above the price that anyone can
+ *    rent for 10 minutes to 24 hours (a call), keeping every BNB above the step when it closes
+ * Trades go through PancakeSwap's UniversalRouter like any Infinity pool; the quoter runs the hook, so a refusing rule
+ * comes back named before anyone signs.
+ */
+export type HookCoin = {
+    token: Address;
+    name: string;
+    symbol: string;
+    metadata: string;
+    creator: Address;
+    start: number;
+    /** the Infinity pool id and key */
+    id: Hex;
+    key: PoolKey;
+    rules: CoinRule[];
+    raw: R;
+    scanner: "green" | "yellow" | "red";
+    /** the creator's share of the hook's fee, and the part of it that feeds the jackpot */
+    creatorBps: number;
+    potBps: number;
+    jackpotPot: bigint;
+    jackpotLast: Address;
+    jackpotTime: number;
+    rewardsPot: bigint;
+    buyers: number;
+    buys: number;
+    sells: number;
+    /** share of the curve sold, basis points */
+    soldBps: number;
+    priceBnb: number;
+    mcapBnb: number;
+    chainNow: number;
+};
+export type HookLaunch = {
+    name: string;
+    symbol: string;
+    metadata: string;
+    /** rules of the catalog that work in a pool (the factory's KNOWN mask); none for a plain calls coin */
+    rules?: Picked[];
+    /** the creator's first buy, BNB wei */
+    devBuy?: bigint;
+    salt?: Hex;
+};
+/** pools: rules in a PancakeSwap Infinity pool hook. */
+export declare function poolsModule(ctx: Ctx): {
+    factory: `0x${string}`;
+    hook: () => Promise<Address>;
+    key: (token: Address) => Promise<PoolKey>;
+    count: () => Promise<number>;
+    coins: (o?: {
+        limit?: number;
+        offset?: number;
+    }) => Promise<HookCoin[]>;
+    coin: (token: Address) => Promise<HookCoin | null>;
+    isCoin: (token: Address) => Promise<boolean>;
+    knownKinds: () => Promise<number[]>;
+    quote: (q: {
+        token: Address;
+        side: "buy" | "sell";
+        amount: bigint;
+        from?: Address;
+    }) => Promise<{
+        amountOut: bigint;
+    }>;
+    check: (c: {
+        token: Address;
+        side: "buy" | "sell";
+        wallet: Address;
+        amount: bigint;
+    }) => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        kind: number;
+        name: string;
+        text: string;
+    }>;
+    sellApprovals: (owner: Address, token: Address, amount: bigint) => Promise<TxRequest[]>;
+    build: {
+        buy: (k: PoolKey, bnbIn: bigint, minOut: bigint, deadline?: bigint) => TxRequest;
+        sell: (k: PoolKey, amount: bigint, minOut: bigint, deadline?: bigint) => TxRequest;
+        /** jackpot wins, rewards and the creator's share, for every coin of the hook */
+        claim: () => Promise<TxRequest>;
+        settleJackpot: (token: Address) => Promise<TxRequest>;
+        fundPot: (token: Address, pot: "jackpot" | "rewards", wei: bigint) => Promise<TxRequest>;
+        withdrawRewards: (token: Address, wei: bigint) => Promise<TxRequest>;
+    };
+    buy: (b: {
+        token: Address;
+        bnbIn: bigint;
+        slippageBps?: number;
+        minOut?: bigint;
+        deadline?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        quoted: bigint;
+        minOut: bigint;
+    }>;
+    sell: (x: {
+        token: Address;
+        amount: bigint;
+        slippageBps?: number;
+        minOut?: bigint;
+        deadline?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        quoted: bigint;
+        minOut: bigint;
+    }>;
+    launch: (l: HookLaunch, s?: SendOptions) => Promise<Sent & {
+        token: Address;
+        id: Hex;
+    }>;
+    /** BNB the hook owes a wallet (jackpot wins, rewards, a creator's share) */
+    owed: (who: Address) => Promise<bigint>;
+    claim: (s?: SendOptions) => Promise<Sent>;
+    settleJackpot: (token: Address, s?: SendOptions) => Promise<Sent>;
+    fundPot: (token: Address, pot: "jackpot" | "rewards", wei: bigint, s?: SendOptions) => Promise<Sent>;
+    withdrawRewards: (token: Address, wei: bigint, s?: SendOptions) => Promise<Sent>;
+};
+export type CallStep = {
+    step: number;
+    /** the step's ticks (the pool's price is coins per BNB: the coin is dearer at lower ticks) */
+    lo: number;
+    hi: number;
+    /** how far the coin's BNB price must rise to reach the step and to cross it, from the price the desk uses now (percent) */
+    fromPct: number;
+    toPct: number;
+    lentCoins: bigint;
+    capCoins: bigint;
+    /** a call can be rented on it right now */
+    open: boolean;
+};
+export type CallRow = {
+    id: bigint;
+    owner: Address;
+    token: Address;
+    step: number;
+    coins: bigint;
+    premium: bigint;
+    opened: number;
+    expiry: number;
+    liquidity: bigint;
+};
+/** curve calls: the pools-shaped coin plus the desk that rents out its curve. */
+export declare function callsModule(ctx: Ctx): {
+    desk: () => Promise<`0x${string}`>;
+    deskTerms: () => Promise<{
+        bond: bigint;
+        minDuration: number;
+        maxDuration: number;
+        steps: number;
+        maxAhead: number;
+        openAfter: number;
+        stepCapBps: number;
+    }>;
+    steps: (token: Address) => Promise<CallStep[]>;
+    quoteCall: (token: Address, step: number, coins: bigint, seconds: number) => Promise<{
+        premium: bigint;
+        liquidity: bigint;
+    }>;
+    calls: (token: Address, o?: {
+        scan?: number;
+    }) => Promise<CallRow[]>;
+    payout: (id: bigint, as: Address) => Promise<bigint>;
+    pending: (who: Address) => Promise<bigint>;
+    build: {
+        /** value = the premium (at most maxPremium) plus the desk's bond, which comes back with the close */
+        openCall: (token: Address, step: number, coins: bigint, seconds: number, maxPremium: bigint) => Promise<TxRequest>;
+        closeCall: (id: bigint, minPayout: bigint) => Promise<TxRequest>;
+        /** BNB the desk could not send (a wallet that refused it) */
+        withdraw: () => Promise<TxRequest>;
+        buy: (k: PoolKey, bnbIn: bigint, minOut: bigint, deadline?: bigint) => TxRequest;
+        sell: (k: PoolKey, amount: bigint, minOut: bigint, deadline?: bigint) => TxRequest;
+        /** jackpot wins, rewards and the creator's share, for every coin of the hook */
+        claim: () => Promise<TxRequest>;
+        settleJackpot: (token: Address) => Promise<TxRequest>;
+        fundPot: (token: Address, pot: "jackpot" | "rewards", wei: bigint) => Promise<TxRequest>;
+        withdrawRewards: (token: Address, wei: bigint) => Promise<TxRequest>;
+    };
+    /** rents `coins` of a step for `seconds`; the premium is capped at the quote plus slippageBps (default 100) */
+    openCall: (c: {
+        token: Address;
+        step: number;
+        coins: bigint;
+        seconds: number;
+        maxPremium?: bigint;
+        slippageBps?: number;
+    }, s?: SendOptions) => Promise<Sent & {
+        id: bigint;
+        premium: bigint;
+    }>;
+    /** closes a call for at least the payout of a fresh simulation less slippageBps (default 100) */
+    closeCall: (id: bigint, o?: {
+        minPayout?: bigint;
+        slippageBps?: number;
+    }, s?: SendOptions) => Promise<Sent & {
+        payout: bigint;
+    }>;
+    withdraw: (s?: SendOptions) => Promise<Sent>;
+    factory: `0x${string}`;
+    hook: () => Promise<Address>;
+    key: (token: Address) => Promise<PoolKey>;
+    count: () => Promise<number>;
+    coins: (o?: {
+        limit?: number;
+        offset?: number;
+    }) => Promise<HookCoin[]>;
+    coin: (token: Address) => Promise<HookCoin | null>;
+    isCoin: (token: Address) => Promise<boolean>;
+    knownKinds: () => Promise<number[]>;
+    quote: (q: {
+        token: Address;
+        side: "buy" | "sell";
+        amount: bigint;
+        from?: Address;
+    }) => Promise<{
+        amountOut: bigint;
+    }>;
+    check: (c: {
+        token: Address;
+        side: "buy" | "sell";
+        wallet: Address;
+        amount: bigint;
+    }) => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        kind: number;
+        name: string;
+        text: string;
+    }>;
+    sellApprovals: (owner: Address, token: Address, amount: bigint) => Promise<TxRequest[]>;
+    buy: (b: {
+        token: Address;
+        bnbIn: bigint;
+        slippageBps?: number;
+        minOut?: bigint;
+        deadline?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        quoted: bigint;
+        minOut: bigint;
+    }>;
+    sell: (x: {
+        token: Address;
+        amount: bigint;
+        slippageBps?: number;
+        minOut?: bigint;
+        deadline?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        quoted: bigint;
+        minOut: bigint;
+    }>;
+    launch: (l: HookLaunch, s?: SendOptions) => Promise<Sent & {
+        token: Address;
+        id: Hex;
+    }>;
+    /** BNB the hook owes a wallet (jackpot wins, rewards, a creator's share) */
+    owed: (who: Address) => Promise<bigint>;
+    claim: (s?: SendOptions) => Promise<Sent>;
+    settleJackpot: (token: Address, s?: SendOptions) => Promise<Sent>;
+    fundPot: (token: Address, pot: "jackpot" | "rewards", wei: bigint, s?: SendOptions) => Promise<Sent>;
+    withdrawRewards: (token: Address, wei: bigint, s?: SendOptions) => Promise<Sent>;
+};
+export type PoolsModule = ReturnType<typeof poolsModule>;
+export type CallsModule = ReturnType<typeof callsModule>;

package/dist/pools.js

@@ -0,0 +1,405 @@
+import { encodeFunctionData, isAddressEqual, parseEventLogs } from "viem";
+import { callsDeskAbi, callsFactoryAbi, callsHookAbi } from "./abis/calls.js";
+import { clPoolManagerAbi } from "./abis/common.js";
+import { poolsFactoryAbi, poolsHookAbi } from "./abis/pools.js";
+import { RULE_BY_ID, RULE_BY_KIND, buildRules, kindsOf, selectionProblem, worstScanner } from "./coin-rules.js";
+import { ruleText } from "./coins.js";
+import { PickhooksError, explain, toPickhooksError } from "./errors.js";
+import { blockedKind, buildInfiSwap, infiPriceBnb, infiQuote, permit2Approvals, toKey } from "./infinity.js";
+import { minusBps, sendAll, sendTx, signer } from "./tx.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("")}`;
+};
+function hookCoinModule(ctx, factory, fAbi, hAbi, product) {
+    const { pub, a } = ctx;
+    let hookAddr = null;
+    const keys = new Map();
+    const call = (address, abi, functionName, args = []) => pub.readContract({ address, abi, functionName, args });
+    async function hook() {
+        hookAddr ??= await call(factory, fAbi, "hook");
+        return hookAddr;
+    }
+    async function key(token) {
+        const hit = keys.get(token.toLowerCase());
+        if (hit)
+            return hit;
+        const k = toKey(await call(factory, fAbi, "poolKeyOf", [token]));
+        if (/^0x0{40}$/i.test(k.hooks))
+            throw new PickhooksError(`This is not a ${product} coin.`, { code: "input" });
+        keys.set(token.toLowerCase(), k);
+        return k;
+    }
+    const count = async () => Number(await call(factory, fAbi, "coinCount"));
+    const isCoin = async (token) => (await call(factory, fAbi, "isCoin", [token]).catch(() => false)) === true;
+    /** Coins newest first. */
+    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 tokens = (await pub.multicall({
+            contracts: Array.from({ length: end - from }, (_, i) => ({ address: factory, abi: fAbi, functionName: "coins", args: [BigInt(end - 1 - i)] })),
+            allowFailure: false,
+        }));
+        return summaries(tokens);
+    }
+    /** One coin, or null. */
+    async function coin(token) {
+        if (!(await isCoin(token)))
+            return null;
+        return (await summaries([token]))[0] ?? null;
+    }
+    async function summaries(tokens) {
+        if (!tokens.length)
+            return [];
+        const h = await hook();
+        const per = 5;
+        const [res, head] = await Promise.all([
+            pub.multicall({
+                contracts: tokens.flatMap((t) => [
+                    { address: h, abi: hAbi, functionName: "coinOf", args: [t] },
+                    { address: h, abi: hAbi, functionName: "rulesOf", args: [t] },
+                    { address: h, abi: hAbi, functionName: "statsOf", args: [t] },
+                    { address: h, abi: hAbi, functionName: "poolOf", args: [t] },
+                    { address: factory, abi: fAbi, functionName: "poolKeyOf", args: [t] },
+                ]),
+                allowFailure: true,
+            }),
+            pub.getBlock({ blockTag: "latest" }),
+        ]);
+        // name, symbol and metadata are the token's own (the hook ABIs do not carry them): read them as an ERC20
+        const tokenMeta = await pub.multicall({
+            contracts: tokens.flatMap((t) => ["name", "symbol", "metadata"].map((functionName) => ({ address: t, abi: PLAIN, functionName }))),
+            allowFailure: true,
+        });
+        const ids = tokens.map((_, i) => res[i * per + 3].result);
+        const slots = await pub.multicall({
+            contracts: ids.map((id) => ({ address: a.clPoolManager, abi: clPoolManagerAbi, functionName: "getSlot0", args: [id ?? `0x${"0".repeat(64)}`] })),
+            allowFailure: true,
+        });
+        const now = Number(head.timestamp);
+        const untilRes = await pub.multicall({
+            contracts: tokens.flatMap((_, i) => {
+                const r = res[i * per + 1].result;
+                return r && ids[i] ? kindsOf(r.mask).map((k) => ({ address: h, abi: hAbi, functionName: "until", args: [ids[i], k] })) : [];
+            }),
+            allowFailure: true,
+        });
+        let u = 0;
+        const out = [];
+        tokens.forEach((token, i) => {
+            const g = (k) => res[i * per + k];
+            const rules = g(1).result;
+            const kinds = rules && ids[i] ? kindsOf(rules.mask) : [];
+            const untils = kinds.map(() => untilRes[u++]);
+            if (g(0).status !== "success" || !rules || !ids[i] || g(4).status !== "success")
+                return;
+            const c = g(0).result;
+            const st = g(2).result;
+            const k = toKey(g(4).result);
+            keys.set(token.toLowerCase(), k);
+            const sl = slots[i];
+            const priceBnb = sl.status === "success" ? infiPriceBnb(sl.result[0]) : 0;
+            const m = (j) => tokenMeta[i * 3 + j];
+            out.push({
+                token,
+                name: m(0).status === "success" ? String(m(0).result) : "",
+                symbol: m(1).status === "success" ? String(m(1).result) : "",
+                metadata: m(2).status === "success" ? String(m(2).result) : "",
+                creator: c[0],
+                start: Number(c[1]),
+                id: ids[i],
+                key: k,
+                rules: kinds.map((kind, j) => {
+                    const def = RULE_BY_KIND.get(kind);
+                    const until = untils[j]?.status === "success" ? Number(untils[j].result) : 0;
+                    let text = def?.line ?? "";
+                    try {
+                        if (def)
+                            text = def.describe(rules);
+                    }
+                    catch {
+                        /* keep the line */
+                    }
+                    return { kind, name: def?.name ?? `Rule ${kind}`, text, scanner: def?.scanner.level ?? "green", until, ended: until !== 0 && now >= until };
+                }),
+                raw: rules,
+                scanner: worstScanner(kinds),
+                creatorBps: Number(c[3]),
+                potBps: Number(c[4]),
+                jackpotPot: c[5],
+                jackpotLast: c[6],
+                jackpotTime: Number(c[7]),
+                rewardsPot: c[8],
+                buyers: Number(st.buyers),
+                buys: Number(st.buys),
+                sells: Number(st.sells),
+                soldBps: c[2] ? Number((st.net * 10000n) / c[2]) : 0,
+                priceBnb,
+                mcapBnb: priceBnb * 1e9,
+                chainNow: now,
+            });
+        });
+        return out;
+    }
+    /** a refusal of the hook as a sentence that names the rule */
+    async function refusalOf(token, e, fallback) {
+        const kind = blockedKind(e);
+        if (kind === null)
+            return toPickhooksError(e, fallback);
+        const rules = await call(await hook(), hAbi, "rulesOf", [token]).catch(() => null);
+        return new PickhooksError(ruleText(kind, rules).text, { code: "Blocked", args: [kind], cause: e });
+    }
+    /** What a trade gets, from PancakeSwap's quoter running the swap with the hook; a refusing rule is named. `from` is the trader. */
+    async function quote(q) {
+        try {
+            const r = await infiQuote(ctx, { key: await key(q.token), buy: q.side === "buy", amount: q.amount, from: q.from });
+            return { amountOut: r.amountOut };
+        }
+        catch (e) {
+            throw await refusalOf(q.token, e, "The quoter refused this trade.");
+        }
+    }
+    /** Would this trade go through for this wallet: the quote runs the hook's rules as the trader. */
+    async function check(c) {
+        try {
+            await infiQuote(ctx, { key: await key(c.token), buy: c.side === "buy", amount: c.amount, from: c.wallet });
+            return { ok: true };
+        }
+        catch (e) {
+            const kind = blockedKind(e);
+            if (kind === null)
+                return { ok: false, kind: 0, name: "", text: explain(e, "The pool refused this trade.").text };
+            const rules = await call(await hook(), hAbi, "rulesOf", [c.token]).catch(() => null);
+            return { ok: false, kind, ...ruleText(kind, rules) };
+        }
+    }
+    const buildBuy = (k, bnbIn, minOut, deadline) => buildInfiSwap(a, { key: k, buy: true, legs: [bnbIn], minOut, deadline, gasPct: 150 });
+    const buildSell = (k, amount, minOut, deadline) => buildInfiSwap(a, { key: k, buy: false, legs: [amount], minOut, deadline, gasPct: 150 });
+    /** Quotes as the trader (a refusing rule stops it before anything is signed), then buys through the UniversalRouter. */
+    async function buy(b, s = {}) {
+        const { address } = await signer(ctx, s.wallet);
+        const q = await quote({ token: b.token, side: "buy", amount: b.bnbIn, from: address });
+        const minOut = b.minOut ?? minusBps(q.amountOut, b.slippageBps ?? 100);
+        try {
+            return { ...(await sendTx(ctx, buildBuy(await key(b.token), b.bnbIn, minOut, b.deadline), s)), quoted: q.amountOut, minOut };
+        }
+        catch (e) {
+            throw await refusalOf(b.token, e, "The buy would fail.");
+        }
+    }
+    /** Approves Permit2 if needed, quotes as the trader, sells through the UniversalRouter. */
+    async function sell(x, s = {}) {
+        const { address } = await signer(ctx, s.wallet);
+        const q = await quote({ token: x.token, side: "sell", amount: x.amount, from: address });
+        await sendAll(ctx, await permit2Approvals(ctx, address, x.token, x.amount), s);
+        const minOut = x.minOut ?? minusBps(q.amountOut, x.slippageBps ?? 100);
+        try {
+            return { ...(await sendTx(ctx, buildSell(await key(x.token), x.amount, minOut, x.deadline), s)), quoted: q.amountOut, minOut };
+        }
+        catch (e) {
+            throw await refusalOf(x.token, e, "The sell would fail.");
+        }
+    }
+    /** The factory's rule kinds that work in a pool (its KNOWN mask). */
+    const knownKinds = async () => kindsOf(await call(factory, fAbi, "KNOWN"));
+    /** Checks the rules (catalog, the factory's known kinds, the factory's own validate), launches, returns the coin. */
+    async function launch(l, s = {}) {
+        const picked = l.rules ?? [];
+        const problem = selectionProblem(picked);
+        if (problem)
+            throw new PickhooksError(problem, { code: "input" });
+        const known = await knownKinds();
+        for (const p of picked) {
+            const def = RULE_BY_ID.get(p.id);
+            if (def && !known.includes(def.kind))
+                throw new PickhooksError(`${def.name} does not work in a pool: it needs the coin itself.`, { code: "input" });
+        }
+        const now = Number((await pub.getBlock({ blockTag: "latest" })).timestamp);
+        const built = buildRules(picked, now);
+        try {
+            await call(factory, fAbi, "validate", [built.rules, built.untilIds, built.untilTimes]);
+        }
+        catch (e) {
+            throw toPickhooksError(e, "The factory refused these rules.");
+        }
+        const tx = {
+            to: factory,
+            value: l.devBuy ?? 0n,
+            data: encodeFunctionData({ abi: fAbi, functionName: "launch", args: [l.name, l.symbol, l.metadata, built.rules, built.untilIds, built.untilTimes, l.salt ?? randomSalt()] }),
+            gasPct: 125,
+            label: "The launch",
+        };
+        const sent = await sendTx(ctx, tx, s);
+        const ev = parseEventLogs({ abi: fAbi, logs: sent.receipt.logs.filter((x) => isAddressEqual(x.address, factory)) }).find((e) => e.eventName === "Launched");
+        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, id: ev.args.poolId };
+    }
+    const hookTx = async (fn, args = [], value = 0n, label) => ({
+        to: await hook(),
+        value,
+        data: encodeFunctionData({ abi: hAbi, functionName: fn, args }),
+        label,
+    });
+    const build = {
+        buy: (k, bnbIn, minOut, deadline) => buildBuy(k, bnbIn, minOut, deadline),
+        sell: (k, amount, minOut, deadline) => buildSell(k, amount, minOut, deadline),
+        /** jackpot wins, rewards and the creator's share, for every coin of the hook */
+        claim: () => hookTx("claim", [], 0n, "The claim"),
+        settleJackpot: (token) => hookTx("settleJackpot", [token], 0n, "Settling the jackpot"),
+        fundPot: (token, pot, wei) => hookTx(pot === "rewards" ? "fundRewards" : "fundJackpot", [token], wei, `Funding the ${pot}`),
+        withdrawRewards: (token, wei) => hookTx("withdrawRewards", [token, wei], 0n, "Taking rewards back"),
+    };
+    return {
+        factory,
+        hook,
+        key,
+        count,
+        coins,
+        coin,
+        isCoin,
+        knownKinds,
+        quote,
+        check,
+        sellApprovals: (owner, token, amount) => permit2Approvals(ctx, owner, token, amount),
+        build,
+        buy,
+        sell,
+        launch,
+        /** BNB the hook owes a wallet (jackpot wins, rewards, a creator's share) */
+        owed: async (who) => call(await hook(), hAbi, "owed", [who]),
+        claim: async (s = {}) => sendTx(ctx, await build.claim(), s),
+        settleJackpot: async (token, s = {}) => sendTx(ctx, await build.settleJackpot(token), s),
+        fundPot: async (token, pot, wei, s = {}) => sendTx(ctx, await build.fundPot(token, pot, wei), s),
+        withdrawRewards: async (token, wei, s = {}) => sendTx(ctx, await build.withdrawRewards(token, wei), s),
+    };
+}
+const PLAIN = [
+    { type: "function", name: "name", inputs: [], outputs: [{ name: "", type: "string" }], stateMutability: "view" },
+    { type: "function", name: "symbol", inputs: [], outputs: [{ name: "", type: "string" }], stateMutability: "view" },
+    { type: "function", name: "metadata", inputs: [], outputs: [{ name: "", type: "string" }], stateMutability: "view" },
+];
+/** pools: rules in a PancakeSwap Infinity pool hook. */
+export function poolsModule(ctx) {
+    return hookCoinModule(ctx, ctx.a.poolsFactory, poolsFactoryAbi, poolsHookAbi, "pools");
+}
+const LN_TICK = Math.log(1.0001);
+const priceAt = (tick) => Math.exp(-tick * LN_TICK);
+/** curve calls: the pools-shaped coin plus the desk that rents out its curve. */
+export function callsModule(ctx) {
+    const base = hookCoinModule(ctx, ctx.a.callsFactory, callsFactoryAbi, callsHookAbi, "curve calls");
+    const { pub } = ctx;
+    let deskAddr = null;
+    const desk = async () => (deskAddr ??= (await pub.readContract({ address: ctx.a.callsFactory, abi: callsFactoryAbi, functionName: "desk" })));
+    const D = callsDeskAbi;
+    const call = (address, abi, functionName, args = []) => pub.readContract({ address, abi, functionName, args });
+    /** The desk's rules: bond, durations, steps, how far ahead, when calls open after a launch. */
+    async function deskTerms() {
+        const d = await desk();
+        const fns = ["BOND", "MIN_DURATION", "MAX_DURATION", "STEPS", "MAX_AHEAD", "OPEN_AFTER", "STEP_CAP_BPS"];
+        const r = await pub.multicall({ contracts: fns.map((functionName) => ({ address: d, abi: D, functionName })), allowFailure: false });
+        return { bond: r[0], minDuration: Number(r[1]), maxDuration: Number(r[2]), steps: Number(r[3]), maxAhead: Number(r[4]), openAfter: Number(r[5]), stepCapBps: Number(r[6]) };
+    }
+    /** The steps of a coin's curve a call can rent, with how far the price must rise to reach each one. */
+    async function steps(token) {
+        const [d, t, h] = await Promise.all([desk(), deskTerms(), base.hook()]);
+        const [coin, oracle, block] = await Promise.all([
+            call(h, callsHookAbi, "coinOf", [token]),
+            call(h, callsHookAbi, "oracleOf", [token]),
+            pub.getBlock({ blockTag: "latest" }),
+        ]);
+        const now = Number(block.timestamp);
+        const at = Math.min(Number(oracle[0]), Number(oracle[1]));
+        const r = await pub.multicall({ contracts: Array.from({ length: t.steps }, (_, k) => ({ address: d, abi: D, functionName: "stepOf", args: [token, k] })), allowFailure: false });
+        return r.map((x, k) => {
+            const [lo, hi, , , lentCoins, capCoins] = x;
+            const open = Number(hi) <= at && at - Number(hi) <= t.maxAhead * (Number(hi) - Number(lo)) && now >= Number(coin[1]) + t.openAfter;
+            return { step: k, lo: Number(lo), hi: Number(hi), fromPct: (priceAt(Number(hi)) / priceAt(at) - 1) * 100, toPct: (priceAt(Number(lo)) / priceAt(at) - 1) * 100, lentCoins, capCoins, open };
+        });
+    }
+    /** The premium for renting `coins` of a step for `seconds`, priced by the desk. */
+    async function quoteCall(token, step, coins, seconds) {
+        try {
+            const [premium, liquidity] = await call(await desk(), D, "quote", [token, step, coins, seconds]);
+            return { premium, liquidity };
+        }
+        catch (e) {
+            throw toPickhooksError(e, "The desk refused this call.");
+        }
+    }
+    /** Open calls of a coin (the newest `scan` calls of the desk are read, default 400). */
+    async function calls(token, o = {}) {
+        const d = await desk();
+        const n = Number(await call(d, D, "callCount"));
+        if (!n)
+            return [];
+        const from = Math.max(1, n - (o.scan ?? 400) + 1);
+        const res = await pub.multicall({ contracts: Array.from({ length: n - from + 1 }, (_, i) => ({ address: d, abi: D, functionName: "callOf", args: [BigInt(from + i)] })), allowFailure: true });
+        const out = [];
+        res.forEach((r, i) => {
+            if (r.status !== "success")
+                return;
+            const c = r.result;
+            if (/^0x0{40}$/i.test(c.owner) || !isAddressEqual(c.token, token))
+                return;
+            out.push({ id: BigInt(from + i), owner: c.owner, token: c.token, step: Number(c.step), coins: c.coins, premium: c.premium, opened: Number(c.opened), expiry: Number(c.expiry), liquidity: c.liquidity });
+        });
+        return out;
+    }
+    /** What closing a call pays now, simulated as `as` (its owner before the end, anyone after). */
+    async function payout(id, as) {
+        try {
+            const r = await pub.simulateContract({ address: await desk(), abi: D, functionName: "close", args: [id, 0n], account: as });
+            return r.result;
+        }
+        catch (e) {
+            throw toPickhooksError(e, "This call cannot be closed now.");
+        }
+    }
+    const deskTx = async (fn, args = [], value = 0n, label) => ({
+        to: await desk(),
+        value,
+        data: encodeFunctionData({ abi: D, functionName: fn, args }),
+        label,
+    });
+    const callBuild = {
+        ...base.build,
+        /** value = the premium (at most maxPremium) plus the desk's bond, which comes back with the close */
+        openCall: async (token, step, coins, seconds, maxPremium) => deskTx("open", [token, step, coins, seconds, maxPremium], maxPremium + (await deskTerms()).bond, "Opening the call"),
+        closeCall: (id, minPayout) => deskTx("close", [id, minPayout], 0n, "Closing the call"),
+        /** BNB the desk could not send (a wallet that refused it) */
+        withdraw: () => deskTx("withdraw", [], 0n, "The withdrawal"),
+    };
+    return {
+        ...base,
+        desk,
+        deskTerms,
+        steps,
+        quoteCall,
+        calls,
+        payout,
+        pending: async (who) => call(await desk(), D, "pending", [who]),
+        build: callBuild,
+        /** rents `coins` of a step for `seconds`; the premium is capped at the quote plus slippageBps (default 100) */
+        openCall: async (c, s = {}) => {
+            const q = await quoteCall(c.token, c.step, c.coins, c.seconds);
+            const max = c.maxPremium ?? (q.premium * BigInt(10_000 + (c.slippageBps ?? 100))) / 10000n;
+            const sent = await sendTx(ctx, await callBuild.openCall(c.token, c.step, c.coins, c.seconds, max), s);
+            const ev = parseEventLogs({ abi: D, logs: sent.receipt.logs }).find((e) => e.eventName === "CallOpened");
+            return { ...sent, id: ev?.args.id ?? 0n, premium: ev?.args.premium ?? q.premium };
+        },
+        /** closes a call for at least the payout of a fresh simulation less slippageBps (default 100) */
+        closeCall: async (id, o = {}, s = {}) => {
+            const { address } = await signer(ctx, s.wallet);
+            const now = await payout(id, address);
+            const sent = await sendTx(ctx, await callBuild.closeCall(id, o.minPayout ?? minusBps(now, o.slippageBps ?? 100)), s);
+            const ev = parseEventLogs({ abi: D, logs: sent.receipt.logs }).find((e) => e.eventName === "CallClosed");
+            return { ...sent, payout: ev?.args.payout ?? now };
+        },
+        withdraw: async (s = {}) => sendTx(ctx, await callBuild.withdraw(), s),
+    };
+}