@pickhooks/sdk 0.0.0-stage → 0.2.0

package/dist/any.js

@@ -0,0 +1,729 @@
+import { concatHex, encodeAbiParameters, encodeFunctionData, isAddressEqual, maxUint256, parseAbi, parseEventLogs, } from "viem";
+import { any3FactoryAbi, any3HookAbi } from "./abis/any3.js";
+import { anyTaxFactoryAbi, anyTaxHookAbi } from "./abis/anytax.js";
+import { SWAP_EXACT_IN_SINGLE, clPoolManagerAbi, erc20Abi, pancakeV2FactoryAbi, universalRouterAbi } from "./abis/common.js";
+import { LIMITS, NATIVE, ZERO_ADDRESS } from "./addresses.js";
+import { CHECK_TEXT, PickhooksError, toPickhooksError } from "./errors.js";
+import { buildInfiSwap, infiQuote, permit2Approvals, poolIdOf, toKey } from "./infinity.js";
+import { deadlineIn, minusBps, sendAll, sendTx, senderAddress, signer } from "./tx.js";
+export { poolIdOf } from "./infinity.js";
+// ---------------------------------------------------------------- pure helpers
+const Q96 = 2 ** 96;
+const LOG_BASE = Math.log(1.0001);
+export const MIN_TICK = -887272;
+export const MAX_TICK = 887272;
+/** flap's anti-farmer state: every pool transfer is taxed, the Infinity vault's too */
+const ANTI_FARMER = 2;
+/** AnyTaxHook.QUOTE = keccak256("pickhooks.any.tax.quote"): a sell quote carries it to look past the pay-first guard */
+export const TAX_QUOTE_MARK = "0xef4a4762058b7d8f677fa48345d3b8a6bfcfe2e6867a31c94f0749a6b8079c54";
+/** The tick of a sqrt price (Q64.96), rounded down. */
+export function tickOf(sqrtPrice) {
+    const p = (Number(sqrtPrice) / Q96) ** 2;
+    return Math.floor(Math.log(p) / LOG_BASE);
+}
+const sqrtAt = (tick) => Math.sqrt(1.0001 ** tick);
+const floorTo = (t, s) => Math.floor(t / s) * s;
+const ceilTo = (t, s) => Math.ceil(t / s) * s;
+/**
+ * The ticks of a range for a slot. The pool's price is coin per BNB, so the coin gets dearer as the tick falls.
+ * ladder: coins only, from the price up with no top; ladder10: coins only, up to 10x; around: half to twice the price.
+ */
+export function rangeFor(kind, sqrtPrice, slot) {
+    const s = LIMITS.tickBase + slot;
+    const t = tickOf(sqrtPrice);
+    const minUsable = ceilTo(MIN_TICK, s);
+    const maxUsable = floorTo(MAX_TICK, s);
+    if (kind === "around") {
+        const w = Math.round(Math.log(2) / LOG_BASE);
+        return { lower: Math.max(minUsable, floorTo(t - w, s)), upper: Math.min(maxUsable, ceilTo(t + w, s)) };
+    }
+    // one spacing of margin below the price, so a small move before the open never needs BNB
+    const upper = floorTo(t, s) - s;
+    if (kind === "ladder10")
+        return { lower: Math.max(minUsable, floorTo(upper - Math.round(Math.log(10) / LOG_BASE), s)), upper };
+    return { lower: minUsable, upper };
+}
+/**
+ * About how many coins (raw) and how much BNB a range needs so the new pool is as deep for buys as the coin's main pool
+ * (the factory refuses a shallower one with TooShallow), with a 3 % margin. Depth is liquidity / sqrt price, the number a
+ * V2 pool's BNB reserve means. A tax-line coin arrives less its sell tax: pass `sellTaxBps` (CoinCheck.tax.poolSellBps).
+ */
+export function depthNeeds(check, range, slot, sellTaxBps = 0) {
+    const { lower, upper } = rangeFor(range, check.sqrtPrice, slot);
+    const sp = Number(check.sqrtPrice) / Q96;
+    const sl = sqrtAt(lower);
+    const su = sqrtAt(upper);
+    const d = Number(check.depth) * 1.03;
+    const gross = (c) => (sellTaxBps > 0 ? (c * 10_000) / (10_000 - sellTaxBps) : c);
+    if (range === "around") {
+        const l = d * sp;
+        return { coins: BigInt(Math.ceil(gross(l * (sp - sl)))), bnb: BigInt(Math.ceil((l * (su - sp)) / (sp * su))) };
+    }
+    // coins only, the price above the range: the depth counts at the range's top
+    return { coins: BigInt(Math.ceil(gross(d * su * (su - sl)))), bnb: 0n };
+}
+/**
+ * The widest coins-only ladder right above the price that `coins` can make at least as deep as the coin's main pool
+ * (plus marginBps, default 500): the way to open with few coins (depth sits at the price, the ladder ends sooner).
+ * A tax-line coin arrives less its sell tax. Null when the coins cannot fill even one tick spacing.
+ */
+export function fitLadder(check, coins, slot, sellTaxBps = 0, marginBps = 500) {
+    const s = LIMITS.tickBase + slot;
+    const upper = floorTo(tickOf(check.sqrtPrice), s) - s;
+    const arrive = (Number(coins) * (10_000 - sellTaxBps)) / 10_000;
+    const need = (Number(check.depth) * (10_000 + marginBps)) / 10_000;
+    const su = sqrtAt(upper);
+    let width = 0;
+    for (let w = s; w <= 2000 * s && upper - w >= ceilTo(MIN_TICK, s); w += s) {
+        // liquidity of the coins over [upper - w, upper], and its depth at the top (the price sits just above the range)
+        const l = arrive / (su - sqrtAt(upper - w));
+        if (l / su < need)
+            break;
+        width = w;
+    }
+    return width ? { tickLower: upper - width, tickUpper: upper } : null;
+}
+/** The site's link that opens a pool with this partner named (the open form reads ?partner=). */
+export function partnerLink(partner, site = "https://pickhooks.com") {
+    return `${site.replace(/\/$/, "")}/any?partner=${partner}`;
+}
+/** what arrives of `amount` after a tax of `bps` (flap floors the tax) */
+export const afterTax = (amount, bps) => amount - (amount * BigInt(bps)) / 10000n;
+const flapAbi = parseAbi([
+    "function getPoolStateData() view returns (uint8 state, uint16 buyTax, uint16 sellTax, uint256 threshold, uint256 taxExpiry, uint256 antiFarmerExpiry)",
+    "function pools(address) view returns (bool)",
+    "function quoteToken() view returns (address)",
+]);
+export function anyModule(ctx) {
+    const { pub, a } = ctx;
+    const TAX_ON = !/^0x0{40}$/i.test(a.anyTaxFactory);
+    const LINES = {
+        main: { name: "main", on: true, factory: a.anyFactory, fAbi: any3FactoryAbi, hAbi: any3HookAbi },
+        tax: { name: "tax", on: TAX_ON, factory: a.anyTaxFactory, fAbi: anyTaxFactoryAbi, hAbi: anyTaxHookAbi },
+    };
+    const hooks = new Map([["main", a.anyHook]]);
+    /** where each pool id lives, learned from reads */
+    const where = new Map();
+    const call = (address, abi, functionName, args = []) => pub.readContract({ address, abi, functionName, args });
+    async function hookOf(line) {
+        const known = hooks.get(line);
+        if (known)
+            return known;
+        const h = await call(LINES[line].factory, LINES[line].fAbi, "hook");
+        hooks.set(line, h);
+        return h;
+    }
+    const lineOfFactory = (f) => (TAX_ON && isAddressEqual(f, a.anyTaxFactory) ? "tax" : "main");
+    /** a pool's line and key: from the ref, a read before, or the factories (main first) */
+    async function locate(ref) {
+        if (typeof ref !== "string" && "id" in ref)
+            return { id: ref.id, line: ref.line ?? "main", key: ref.key };
+        if (typeof ref !== "string") {
+            const id = poolIdOf(ref);
+            return { id, line: isAddressEqual(ref.hooks, a.anyHook) ? "main" : TAX_ON && isAddressEqual(ref.hooks, await hookOf("tax")) ? "tax" : "main", key: ref };
+        }
+        const hit = where.get(ref.toLowerCase());
+        if (hit)
+            return { id: ref, ...hit };
+        for (const line of ["main", "tax"]) {
+            if (!LINES[line].on)
+                continue;
+            const raw = await call(LINES[line].factory, LINES[line].fAbi, "keyOf", [ref]);
+            if (/^0x0{40}$/i.test(raw.hooks))
+                continue;
+            const key = toKey(raw);
+            where.set(ref.toLowerCase(), { line, key });
+            return { id: ref, line, key };
+        }
+        throw new PickhooksError("There is no pickhooks pool with this id.", { code: "UnknownPool" });
+    }
+    const key = async (ref) => (await locate(ref)).key;
+    // ------------------------------------------------ reads
+    /** The main factory's terms for pools opened now. */
+    async function terms() {
+        const fns = ["owner", "platformWallet", "openerBps", "traderBps", "hook"];
+        const r = await pub.multicall({ contracts: fns.map((functionName) => ({ address: a.anyFactory, abi: LINES.main.fAbi, functionName })), allowFailure: false });
+        return { owner: r[0], platformWallet: r[1], openerBps: Number(r[2]), traderBps: Number(r[3]), hook: r[4] };
+    }
+    /** A flap tax coin's tax now, and what of it applies in a tax-line pool. */
+    async function taxOf(token) {
+        const r = await pub.multicall({
+            contracts: [
+                { address: token, abi: flapAbi, functionName: "getPoolStateData" },
+                { address: token, abi: flapAbi, functionName: "pools", args: [a.vault] },
+                { address: token, abi: flapAbi, functionName: "quoteToken" },
+            ],
+            allowFailure: true,
+        });
+        const st = r[0].status === "success" ? r[0].result : null;
+        // a coin that does not answer counts as taxed, like the hook does
+        const state = st ? Number(st[0]) : ANTI_FARMER;
+        const buyBps = st ? Number(st[1]) : 0;
+        const sellBps = st ? Number(st[2]) : 0;
+        const vaultTaxed = r[1].status === "success" ? Boolean(r[1].result) : true;
+        const live = vaultTaxed && state === ANTI_FARMER;
+        return {
+            state,
+            buyBps,
+            sellBps,
+            antiFarmerEnd: st ? Number(st[5]) : 0,
+            vaultTaxed,
+            poolBuyBps: live ? buyBps : 0,
+            poolSellBps: live ? sellBps : 0,
+            payFirst: live && sellBps > 0,
+            quote: r[2].status === "success" ? r[2].result : ZERO_ADDRESS,
+        };
+    }
+    /**
+     * Whether a coin can get a pool, at what price, how deep it must be, and its first free slot. The main factory decides
+     * first; a coin it refuses as taxed (4) or for its dividends (5) goes to the tax line when that is on.
+     */
+    async function check(token) {
+        let line = "main";
+        let code = Number(await call(a.anyFactory, LINES.main.fAbi, "check", [token]));
+        if (TAX_ON && (code === 4 || code === 5)) {
+            const taxCode = Number(await call(a.anyTaxFactory, LINES.tax.fAbi, "check", [token]));
+            // 7: not a flap tax coin, the main factory's reason stands
+            if (taxCode !== 7) {
+                line = "tax";
+                code = taxCode;
+            }
+        }
+        const L = LINES[line];
+        const [meta, ref, slots, pair, tax] = await Promise.all([
+            pub.multicall({
+                contracts: ["name", "symbol", "decimals", "owner"].map((functionName) => ({ address: token, abi: erc20Abi, functionName })),
+                allowFailure: true,
+            }),
+            call(L.factory, L.fAbi, "referencePrice", [token]).catch(() => [0n, ZERO_ADDRESS, 0n]),
+            call(L.factory, L.fAbi, "slots", [token]).catch(() => []),
+            call(a.v2Factory, pancakeV2FactoryAbi, "getPair", [token, a.wbnb]).catch(() => ZERO_ADDRESS),
+            line === "tax" ? taxOf(token).catch(() => null) : Promise.resolve(null),
+        ]);
+        const [sqrtPrice, priceSource, depth] = ref;
+        const decimals = meta[2].status === "success" ? Number(meta[2].result) : 18;
+        const owner = meta[3].status === "success" ? meta[3].result : null;
+        const used = slots.map(Number);
+        const free = Array.from({ length: LIMITS.maxSlots }, (_, i) => i).find((i) => !used.includes(i));
+        let text = CHECK_TEXT[code] ?? "This coin cannot get a pool.";
+        if (line === "tax" && code === 0)
+            text = "This flap tax coin can get a pickhooks pool. Its tax stays: buyers and sellers here pay it like on its main pool.";
+        if (line === "tax" && code === 6)
+            text = "No PancakeSwap pool of this coin holds at least 3 BNB of value, against BNB or against its quote token, so there is no fair price to open at.";
+        return {
+            token,
+            line,
+            factory: L.factory,
+            code,
+            ok: code === 0,
+            text,
+            name: meta[0].status === "success" ? String(meta[0].result) : "?",
+            symbol: meta[1].status === "success" ? String(meta[1].result) : "?",
+            decimals,
+            sqrtPrice,
+            priceSource,
+            depth,
+            price: sqrtPrice > 0n ? (Number(sqrtPrice) / Q96) ** 2 * 10 ** (18 - decimals) : 0,
+            // a flap tax coin's owner (flap's portal, or nobody) can only run its migration, it cannot pause or blacklist
+            owner: owner && !/^0x0{40}$/i.test(owner) && line === "main" ? owner : null,
+            slotsUsed: used,
+            freeSlot: free ?? null,
+            pair,
+            tax,
+        };
+    }
+    /** How many pools a line's factory has opened (main by default). */
+    const count = async (line = "main") => (LINES[line].on ? Number(await call(LINES[line].factory, LINES[line].fAbi, "poolCount")) : 0);
+    async function idsOf(line, limit, offset) {
+        const L = LINES[line];
+        const n = await count(line);
+        const end = Math.max(0, n - offset);
+        const from = Math.max(0, end - limit);
+        if (end <= from)
+            return [];
+        return (await pub.multicall({
+            contracts: Array.from({ length: end - from }, (_, i) => ({ address: L.factory, abi: L.fAbi, functionName: "allPools", args: [BigInt(from + i)] })),
+            allowFailure: false,
+        }));
+    }
+    /** Pools newest first: `limit` of each line, skipping the newest `offset` (both lines merged by opening time). */
+    async function pools(o = {}) {
+        const lines = (o.line ? [o.line] : ["main", "tax"]).filter((l) => LINES[l].on);
+        const lists = await Promise.all(lines.map(async (l) => read(l, await idsOf(l, o.limit ?? 50, o.offset ?? 0))));
+        return lists.flat().sort((x, y) => y.start - x.start || (x.line === y.line ? 0 : x.line === "main" ? -1 : 1));
+    }
+    /** One pool of either line, or null. */
+    async function pool(ref) {
+        try {
+            const p = await locate(ref);
+            return (await read(p.line, [p.id]))[0] ?? null;
+        }
+        catch (e) {
+            if (e instanceof PickhooksError && e.code === "UnknownPool")
+                return null;
+            throw e;
+        }
+    }
+    /** Every pool of a coin on both lines (one per used slot). */
+    async function poolsOf(token) {
+        const out = [];
+        for (const line of ["main", "tax"]) {
+            const L = LINES[line];
+            if (!L.on)
+                continue;
+            const slots = (await call(L.factory, L.fAbi, "slots", [token])).map(Number);
+            if (!slots.length)
+                continue;
+            const ks = (await pub.multicall({
+                contracts: slots.map((s) => ({ address: L.factory, abi: L.fAbi, functionName: "poolKey", args: [token, s] })),
+                allowFailure: false,
+            }));
+            out.push(...(await read(line, ks.map((k) => poolIdOf(toKey(k))))));
+        }
+        return out;
+    }
+    async function read(line, ids) {
+        if (!ids.length)
+            return [];
+        const L = LINES[line];
+        const hook = await hookOf(line);
+        const many = (address, abi, functionName) => pub.multicall({ contracts: ids.map((id) => ({ address, abi, functionName, args: [id] })), allowFailure: true });
+        const [raws, rawKeys, slot0s, positions, head] = await Promise.all([
+            many(hook, L.hAbi, "poolOf"),
+            many(L.factory, L.fAbi, "keyOf"),
+            many(a.clPoolManager, clPoolManagerAbi, "getSlot0"),
+            many(L.factory, L.fAbi, "positions"),
+            pub.getBlock({ blockTag: "latest" }),
+        ]);
+        const tokens = [...new Set(raws.filter((r) => r.status === "success" && r.result && !/^0x0{40}$/i.test(r.result.token)).map((r) => r.result.token.toLowerCase()))];
+        const meta = await pub.multicall({
+            contracts: tokens.flatMap((t) => [
+                { address: t, abi: erc20Abi, functionName: "name" },
+                { address: t, abi: erc20Abi, functionName: "symbol" },
+                { address: t, abi: erc20Abi, functionName: "decimals" },
+                { address: hook, abi: L.hAbi, functionName: "chest", args: [t] },
+            ]),
+            allowFailure: true,
+        });
+        const info = new Map();
+        const taxes = line === "tax" ? await Promise.all(tokens.map((t) => taxOf(t).catch(() => null))) : [];
+        tokens.forEach((t, i) => {
+            const r = (k) => meta[i * 4 + k];
+            info.set(t, {
+                name: r(0).status === "success" ? String(r(0).result) : "?",
+                symbol: r(1).status === "success" ? String(r(1).result) : "?",
+                decimals: r(2).status === "success" ? Number(r(2).result) : 18,
+                chest: r(3).status === "success" ? r(3).result : 0n,
+                tax: taxes[i] ?? null,
+            });
+        });
+        const out = [];
+        ids.forEach((id, i) => {
+            const p = raws[i].status === "success" ? raws[i].result : undefined;
+            const k = rawKeys[i].status === "success" ? rawKeys[i].result : undefined;
+            if (!p || !k || /^0x0{40}$/i.test(p.token) || /^0x0{40}$/i.test(k.hooks))
+                return;
+            const keyN = toKey(k);
+            where.set(id.toLowerCase(), { line, key: keyN });
+            const m = info.get(p.token.toLowerCase());
+            const s0 = slot0s[i].status === "success" ? slot0s[i].result : undefined;
+            const sp = s0 ? s0[0] : 0n;
+            const spacing = Number((BigInt(k.parameters) >> 16n) & 0xffffffn);
+            const c = p.cfg;
+            let tax = m.tax;
+            // the pool's own tax listing is fixed at opening: the vault was on the coin's list then, or not
+            if (tax && !c.vaultTaxed)
+                tax = { ...tax, poolBuyBps: 0, poolSellBps: 0, payFirst: false };
+            out.push({
+                id,
+                line,
+                factory: L.factory,
+                hook,
+                key: keyN,
+                token: p.token,
+                name: m.name,
+                symbol: m.symbol,
+                decimals: m.decimals,
+                slot: spacing - LIMITS.tickBase,
+                opener: p.opener,
+                start: Number(p.start),
+                config: {
+                    feeBps: Number(c.feeBps),
+                    holderFeeBps: Number(c.holderFeeBps),
+                    holderMin: c.holderMin,
+                    openerBps: Number(c.openerBps),
+                    potBps: Number(c.potBps),
+                    chestBps: Number(c.chestBps),
+                    jackpotShareBps: Number(c.jackpotShareBps),
+                    jackpotSilence: Number(c.jackpotSilence),
+                    jackpotMinBuy: c.jackpotMinBuy,
+                    bonusBps: Number(c.bonusBps),
+                    bonusLock: Number(c.bonusLock),
+                    bonusMinBuy: c.bonusMinBuy,
+                    bonusCap: c.bonusCap,
+                    pair: c.pair ?? ZERO_ADDRESS,
+                    traderBps: Number(c.traderBps ?? 0),
+                    partner: c.partner ?? ZERO_ADDRESS,
+                    partnerBps: Number(c.partnerBps ?? 0),
+                    vaultTaxed: Boolean(c.vaultTaxed),
+                },
+                buys: Number(p.buys),
+                sells: Number(p.sells),
+                volumeBnb: p.volumeBnb,
+                feesBnb: p.feesBnb,
+                burned: p.burned,
+                burnedFromChest: p.burnedFromChest,
+                pot: p.pot,
+                lastBuyer: p.lastBuyer,
+                lastBuyTime: Number(p.lastBuyTime),
+                bonusPot: p.bonusPot,
+                bonusGiven: p.bonusGiven,
+                recaptured: p.recaptured ?? 0n,
+                recaptures: Number(p.recaptures ?? 0),
+                routerDue: p.routerDue ?? 0n,
+                chest: m.chest,
+                tax,
+                positions: (positions[i].status === "success" ? positions[i].result : []).map((x, index) => ({
+                    index,
+                    tickLower: Number(x.tickLower),
+                    tickUpper: Number(x.tickUpper),
+                    liquidity: x.liquidity,
+                    unlockAt: Number(x.unlockAt),
+                })),
+                sqrtPriceX96: sp,
+                tick: s0 ? Number(s0[1]) : 0,
+                lpFee: s0 ? Number(s0[3]) : 0,
+                price: sp > 0n ? (Number(sp) / Q96) ** 2 * 10 ** (18 - m.decimals) : 0,
+                chainNow: Number(head.timestamp),
+            });
+        });
+        return out;
+    }
+    /** What a wallet can claim and has been credited, in BNB. */
+    async function earnings(who) {
+        const r = await pub.multicall({
+            contracts: [
+                { address: a.anyHook, abi: LINES.main.hAbi, functionName: "owed", args: [who] },
+                { address: a.anyHook, abi: LINES.main.hAbi, functionName: "routerCredit", args: [who] },
+                { address: a.anyHook, abi: LINES.main.hAbi, functionName: "routerFunded" },
+                { address: a.anyFactory, abi: LINES.main.fAbi, functionName: "partnerBps", args: [who] },
+            ],
+            allowFailure: false,
+        });
+        const taxOwed = TAX_ON ? await call(await hookOf("tax"), LINES.tax.hAbi, "owed", [who]) : 0n;
+        const credit = r[1];
+        const funded = r[2];
+        return { owed: r[0], routerCredit: credit, routerClaimable: credit < funded ? credit : funded, partnerBps: Number(r[3]), taxOwed };
+    }
+    /** A router contract's listing: the wallet its share goes to, and the share (0: not listed). */
+    async function router(routerContract) {
+        const r = await call(a.anyHook, LINES.main.hAbi, "routerOf", [routerContract]);
+        return { payout: r.payout, bps: Number(r.bps) };
+    }
+    /** A partner's share of the platform's part in main-line pools opened with it (0: not listed). */
+    const partnerBps = async (partner) => Number(await call(a.anyFactory, LINES.main.fAbi, "partnerBps", [partner]));
+    /** A wallet's lock-to-earn state in a pool. */
+    async function bonusOf(ref, who) {
+        const p = await locate(ref);
+        const b = await call(await hookOf(p.line), LINES[p.line].hAbi, "bonusOf", [p.id, who]);
+        return { bought: b.bought, locked: b.locked, owed: b.owed, total: b.total, unlockAt: Number(b.unlockAt) };
+    }
+    /** What collect() would book now (BNB fees, coins burned), without sending. */
+    async function pendingFees(ref) {
+        const p = await locate(ref);
+        const r = await pub.simulateContract({ address: LINES[p.line].factory, abi: LINES[p.line].fAbi, functionName: "collect", args: [p.id] });
+        const [bnb, coins] = r.result;
+        return { bnb, coins };
+    }
+    // ------------------------------------------------ quotes and trades
+    /**
+     * What a trade gets, from PancakeSwap's quoter running the real swap (quote = fill). Pass `from` (the trader) when it
+     * holds $hooks: the holder fee depends on tx.origin. Tax line: a buy gets the pool's coins less the buy tax that applies
+     * now (gross is the pool's amount); a sell is quoted on what arrives after the sell tax.
+     */
+    async function quote(q) {
+        const p = await locate(q.pool);
+        const tax = p.line === "tax" ? await taxOf(p.key.currency1) : null;
+        const buyBps = tax?.poolBuyBps ?? 0;
+        const sellBps = tax?.poolSellBps ?? 0;
+        try {
+            if (q.side === "buy") {
+                const r = await infiQuote(ctx, { key: p.key, buy: true, amount: q.amount, from: q.from });
+                return { amountOut: afterTax(r.amountOut, buyBps), gross: r.amountOut, taxBps: buyBps, gasEstimate: r.gasEstimate };
+            }
+            const r = await infiQuote(ctx, { key: p.key, buy: false, amount: afterTax(q.amount, sellBps), from: q.from, hookData: p.line === "tax" ? TAX_QUOTE_MARK : "0x" });
+            return { amountOut: r.amountOut, gross: r.amountOut, taxBps: sellBps, gasEstimate: r.gasEstimate };
+        }
+        catch (e) {
+            throw toPickhooksError(e, "The quoter refused this trade.");
+        }
+    }
+    /** A buy through PancakeSwap's UniversalRouter, BNB in. Main line: extraGas carries the recapture room. */
+    function buildBuy(b) {
+        const main = isAddressEqual(b.key.hooks, a.anyHook);
+        return buildInfiSwap(a, { key: b.key, buy: true, legs: [b.bnbIn], minOut: b.minOut, deadline: b.deadline, extraGas: main && b.recapture !== false ? LIMITS.recaptureExtraGas : 0n });
+    }
+    /** A sell through the UniversalRouter, BNB out; the router pulls the coins with Permit2 (see sellApprovals()). */
+    function buildSell(s) {
+        const main = isAddressEqual(s.key.hooks, a.anyHook);
+        return buildInfiSwap(a, { key: s.key, buy: false, legs: [s.amount], minOut: s.minOut, deadline: s.deadline, extraGas: main && s.recapture !== false ? LIMITS.recaptureExtraGas : 0n });
+    }
+    /**
+     * Tax line, while sells pay first: SETTLE(coin, amount, from the seller via Permit2), CL_SWAP_EXACT_IN_SINGLE with
+     * amount 0 (the router swaps the whole credit, whatever arrived after the tax), TAKE_ALL(BNB, minOut).
+     */
+    function buildSellPayFirst(s) {
+        const coin = s.key.currency1;
+        const actions = concatHex(["0x0b", "0x06", "0x0f"]);
+        const params = [
+            encodeAbiParameters([{ type: "address" }, { type: "uint256" }, { type: "bool" }], [coin, s.amount, true]),
+            encodeAbiParameters(SWAP_EXACT_IN_SINGLE, [{ poolKey: s.key, zeroForOne: false, amountIn: 0n, amountOutMinimum: s.minOut, hookData: "0x" }]),
+            encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [NATIVE, s.minOut]),
+        ];
+        const input = encodeAbiParameters([{ type: "bytes" }, { type: "bytes[]" }], [actions, params]);
+        return { to: a.universalRouter, value: 0n, data: encodeFunctionData({ abi: universalRouterAbi, functionName: "execute", args: ["0x10", [input], s.deadline ?? deadlineIn()] }), label: "The sell" };
+    }
+    /** The approvals a sell of `amount` needs first: the coin to Permit2 (once), Permit2 to the router (30 days). */
+    const sellApprovals = (owner, token, amount) => permit2Approvals(ctx, owner, token, amount);
+    /** The trade, the recapture and a router credit of one transaction, from its receipt (either line). */
+    function readTrade(receipt) {
+        let side = null;
+        let tokens = 0n;
+        let bnb = 0n;
+        let recapture = null;
+        let routerCredit = 0n;
+        for (const line of ["main", "tax"]) {
+            const h = hooks.get(line);
+            if (!h)
+                continue;
+            const logs = parseEventLogs({ abi: any3HookAbi, logs: receipt.logs.filter((l) => isAddressEqual(l.address, h)) });
+            for (const l of logs) {
+                if (l.eventName === "Traded" && side === null) {
+                    side = l.args.buy ? "buy" : "sell";
+                    tokens = l.args.tokens;
+                    bnb = l.args.bnb;
+                }
+                else if (l.eventName === "Recaptured") {
+                    recapture = { profit: l.args.profit, toTrader: l.args.toTrader, soldHere: l.args.soldHere };
+                }
+                else if (l.eventName === "RouterCredited") {
+                    routerCredit += l.args.amount;
+                }
+            }
+        }
+        return { side, tokens, bnb, recapture, routerCredit };
+    }
+    /** Quotes, takes slippage off (on the pool's own amount), sends the buy, and reads what happened. */
+    async function buy(b, o = {}) {
+        const p = await locate(b.pool);
+        if (p.line === "tax")
+            await hookOf("tax");
+        const from = await senderAddress(ctx, o.wallet);
+        const q = await quote({ pool: p, side: "buy", amount: b.bnbIn, from });
+        const minOut = b.minOut ?? minusBps(q.gross, b.slippageBps ?? 100);
+        const sent = await sendTx(ctx, buildBuy({ key: p.key, bnbIn: b.bnbIn, minOut, recapture: b.recapture, deadline: b.deadline }), o);
+        const t = readTrade(sent.receipt);
+        return { ...sent, side: "buy", quoted: q.amountOut, minOut, amountIn: b.bnbIn, amountOut: t.tokens, recapture: t.recapture, routerCredit: t.routerCredit };
+    }
+    /** Approves what is missing, quotes, sends the sell (paying first on a taxed tax-line pool), and reads what happened. */
+    async function sell(s, o = {}) {
+        const p = await locate(s.pool);
+        if (p.line === "tax")
+            await hookOf("tax");
+        const { address } = await signer(ctx, o.wallet);
+        await sendAll(ctx, await sellApprovals(address, p.key.currency1, s.amount), o);
+        const q = await quote({ pool: p, side: "sell", amount: s.amount, from: address });
+        const minOut = s.minOut ?? minusBps(q.amountOut, s.slippageBps ?? 100);
+        const payFirst = p.line === "tax" && (await taxOf(p.key.currency1)).payFirst;
+        const tx = payFirst ? buildSellPayFirst({ key: p.key, amount: s.amount, minOut, deadline: s.deadline }) : buildSell({ key: p.key, amount: s.amount, minOut, recapture: s.recapture, deadline: s.deadline });
+        const sent = await sendTx(ctx, tx, o);
+        const t = readTrade(sent.receipt);
+        return { ...sent, side: "sell", quoted: q.amountOut, minOut, amountIn: s.amount, amountOut: t.bnb, recapture: t.recapture, routerCredit: t.routerCredit };
+    }
+    // ------------------------------------------------ opening a pool
+    /** An approval of `spender` for `amount` of `token`, or null when it is already in place. */
+    async function approvalFor(owner, token, spender, amount) {
+        const have = await call(token, erc20Abi, "allowance", [owner, spender]);
+        if (have >= amount)
+            return null;
+        return { to: token, value: 0n, data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [spender, maxUint256] }), label: "The approval" };
+    }
+    /** The factory's open() parameters for these options, with the site's defaults, at the coin's price now. */
+    async function openParams(o, checked) {
+        const c = checked ?? (await check(o.token));
+        if (!c.ok)
+            throw new PickhooksError(c.text, { code: "Refused", args: [c.code] });
+        if (c.line === "tax" && o.partner)
+            throw new PickhooksError("The tax line has no partners: pools of flap tax coins open without one.", { code: "input" });
+        const slot = o.slot ?? c.freeSlot;
+        if (slot === null || slot === undefined)
+            throw new PickhooksError("All 50 slots of this coin are taken.", { code: "input" });
+        if (c.slotsUsed.includes(slot))
+            throw new PickhooksError(`Slot ${slot} of this coin is taken; the first free one is ${c.freeSlot}.`, { code: "input" });
+        const range = o.range ?? "ladder10";
+        const { lower, upper } = typeof range === "object" ? { lower: range.tickLower, upper: range.tickUpper } : rangeFor(range, c.sqrtPrice, slot);
+        const holderMin = o.holderMin ?? 10000n * 10n ** 18n;
+        const bonus = o.bonus === false ? null : { bps: 500, lockSeconds: 7 * 86_400, minBuy: 5n * 10n ** 16n, cap: 0n, ...(o.bonus ?? {}) };
+        const jackpot = o.jackpot ? { potShareBps: 10_000, shareBps: 5000, silenceSeconds: 600, minBuy: 2n * 10n ** 16n, ...o.jackpot } : null;
+        const params = {
+            token: o.token,
+            slot,
+            feeBps: o.feeBps ?? 30,
+            holderFeeBps: holderMin > 0n ? (o.holderFeeBps ?? 5) : 0,
+            holderMin,
+            chestBps: o.chestBps ?? 200,
+            potShareBps: jackpot ? jackpot.potShareBps : 0,
+            jackpotShareBps: jackpot ? jackpot.shareBps : 0,
+            jackpotSilence: jackpot ? jackpot.silenceSeconds : 0,
+            jackpotMinBuy: jackpot ? jackpot.minBuy : 0n,
+            bonusBps: bonus ? bonus.bps : 0,
+            bonusLock: bonus ? bonus.lockSeconds : 0,
+            bonusMinBuy: bonus ? bonus.minBuy : 0n,
+            bonusCap: bonus ? bonus.cap : 0n,
+            expectedSqrtPrice: c.sqrtPrice,
+            maxMoveBps: o.maxMoveBps ?? 100,
+            tickLower: lower,
+            tickUpper: upper,
+            tokenAmount: o.tokenAmount,
+            partner: o.partner ?? ZERO_ADDRESS,
+            noRecapture: o.recapture === false,
+        };
+        return { params, value: range === "around" || typeof range === "object" ? (o.bnb ?? 0n) : 0n, check: c };
+    }
+    /**
+     * The open() call of a line's factory (main by default; the tax line takes the struct without partner and
+     * noRecapture). The opener must have approved tokenAmount + 1 to that factory (one unit proves the burns work).
+     */
+    function buildOpen(params, value = 0n, line = "main") {
+        if (line === "tax") {
+            const { partner: _p, noRecapture: _n, ...v2 } = params;
+            return { to: a.anyTaxFactory, value, data: encodeFunctionData({ abi: anyTaxFactoryAbi, functionName: "open", args: [v2] }), label: "Opening the pool" };
+        }
+        return { to: a.anyFactory, value, data: encodeFunctionData({ abi: any3FactoryAbi, functionName: "open", args: [params] }), label: "Opening the pool" };
+    }
+    /** Checks the coin (and which line takes it), approves, opens the pool and returns its id. */
+    async function open(o, s = {}) {
+        const { address } = await signer(ctx, s.wallet);
+        const { params, value, check: c } = await openParams(o);
+        const approval = await approvalFor(address, o.token, c.factory, params.tokenAmount + 1n);
+        if (approval)
+            await sendTx(ctx, approval, s);
+        const sent = await sendTx(ctx, buildOpen(params, value, c.line), s);
+        const ev = parseEventLogs({ abi: any3FactoryAbi, logs: sent.receipt.logs.filter((l) => isAddressEqual(l.address, c.factory)), eventName: "Opened" })[0];
+        if (!ev)
+            throw new PickhooksError("Opened, but the pool was not found in the receipt.", { code: "receipt", hash: sent.hash });
+        if (c.line === "tax")
+            await hookOf("tax");
+        return { ...sent, id: ev.args.id, params, line: c.line };
+    }
+    // ------------------------------------------------ payouts and pool tools
+    const tx = (to, abi, functionName, args = [], value = 0n, label) => ({
+        to,
+        value,
+        data: encodeFunctionData({ abi, functionName, args }),
+        label,
+    });
+    /** a call to the hook (or factory) of the line a pool belongs to */
+    const atHook = async (ref, fn, args, value = 0n, label) => {
+        const p = await locate(ref);
+        return tx(await hookOf(p.line), LINES[p.line].hAbi, fn, args(p.id), value, label);
+    };
+    const atFactory = async (ref, fn, args, label) => {
+        const p = await locate(ref);
+        return tx(LINES[p.line].factory, LINES[p.line].fAbi, fn, args(p.id), 0n, label);
+    };
+    const build = {
+        buy: buildBuy,
+        sell: buildSell,
+        sellPayFirst: buildSellPayFirst,
+        open: buildOpen,
+        /** main line: opener side, jackpot wins, recapture shares, a partner's share; { line: "tax" } for the tax line's hook */
+        claim: (o = {}) => tx(o.line === "tax" ? (hooks.get("tax") ?? ZERO_ADDRESS) : a.anyHook, any3HookAbi, "claim", [], 0n, "The claim"),
+        /** a router's payout wallet takes what collects have funded of its credit */
+        claimRouter: () => tx(a.anyHook, any3HookAbi, "claimRouter", [], 0n, "The router claim"),
+        /** anyone: collects the pool's fees and books them (funds router credits) */
+        collect: (ref) => atFactory(ref, "collect", (id) => [id], "The collect"),
+        settleJackpot: (ref) => atHook(ref, "settleJackpot", (id) => [id], 0n, "Settling the jackpot"),
+        fundPot: (ref, wei) => atHook(ref, "fundPot", (id) => [id], wei, "Funding the jackpot"),
+        /** these move coins into the hook: approve the coin to the hook first (approvalFor) */
+        feedChest: async (token, amount, line = "main") => tx(await hookOf(line), LINES[line].hAbi, "feedChest", [token, amount], 0n, "Feeding the fire"),
+        fundBonus: (ref, amount) => atHook(ref, "fundBonus", (id) => [id, amount], 0n, "Funding the bonus"),
+        lockBonus: (ref, amount) => atHook(ref, "lockBonus", (id) => [id, amount], 0n, "Locking for the bonus"),
+        unlockBonus: (ref) => atHook(ref, "unlockBonus", (id) => [id], 0n, "Unlocking the bonus"),
+        /** the opener: more liquidity (approve the coin to the factory first), or a position out after its 30 days */
+        addLiquidity: (token, slot, tickLower, tickUpper, tokenAmount, bnb = 0n, line = "main") => tx(LINES[line].factory, LINES[line].fAbi, "addLiquidity", [token, slot, tickLower, tickUpper, tokenAmount], bnb, "Adding liquidity"),
+        removeLiquidity: (ref, index) => atFactory(ref, "removeLiquidity", (id) => [id, BigInt(index)], "Taking a position out"),
+    };
+    /** Approves `spender` first when a call moves coins into it. */
+    async function withApproval(t, token, amount, s, spender) {
+        const { address } = await signer(ctx, s.wallet);
+        const ap = await approvalFor(address, token, spender, amount);
+        if (ap)
+            await sendTx(ctx, ap, s);
+        return sendTx(ctx, t, s);
+    }
+    return {
+        /** the main factory and hook, and whether the tax line is on */
+        factory: a.anyFactory,
+        hook: a.anyHook,
+        taxLineOn: TAX_ON,
+        terms,
+        check,
+        taxOf,
+        depthNeeds,
+        fitLadder,
+        rangeFor,
+        count,
+        pools,
+        pool,
+        poolsOf,
+        key,
+        poolId: poolIdOf,
+        earnings,
+        router,
+        partnerBps,
+        partnerLink: (partner) => partnerLink(partner, ctx.site),
+        bonusOf,
+        pendingFees,
+        quote,
+        sellApprovals,
+        approvalFor,
+        openParams,
+        readTrade,
+        build,
+        buy,
+        sell,
+        open,
+        claim: async (s = {}) => {
+            if (s.line === "tax")
+                await hookOf("tax");
+            return sendTx(ctx, build.claim({ line: s.line }), s);
+        },
+        claimRouter: (s = {}) => sendTx(ctx, build.claimRouter(), s),
+        collect: async (ref, s = {}) => sendTx(ctx, await build.collect(ref), s),
+        settleJackpot: async (ref, s = {}) => sendTx(ctx, await build.settleJackpot(ref), s),
+        fundPot: async (ref, wei, s = {}) => sendTx(ctx, await build.fundPot(ref, wei), s),
+        feedChest: async (token, amount, s = {}) => withApproval(await build.feedChest(token, amount, s.line), token, amount, s, await hookOf(s.line ?? "main")),
+        fundBonus: async (ref, amount, s = {}) => {
+            const p = await locate(ref);
+            return withApproval(await build.fundBonus(p, amount), p.key.currency1, amount, s, await hookOf(p.line));
+        },
+        lockBonus: async (ref, amount, s = {}) => {
+            const p = await locate(ref);
+            return withApproval(await build.lockBonus(p, amount), p.key.currency1, amount, s, await hookOf(p.line));
+        },
+        unlockBonus: async (ref, s = {}) => sendTx(ctx, await build.unlockBonus(ref), s),
+        addLiquidity: async (ref, range, tokenAmount, bnb = 0n, s = {}) => {
+            const p = await pool(ref);
+            if (!p)
+                throw new PickhooksError("There is no pickhooks pool with this id.", { code: "UnknownPool" });
+            const t = build.addLiquidity(p.token, p.slot, range.tickLower, range.tickUpper, tokenAmount, bnb, p.line);
+            return tokenAmount > 0n ? withApproval(t, p.token, tokenAmount, s, p.factory) : sendTx(ctx, t, s);
+        },
+        removeLiquidity: async (ref, index, s = {}) => sendTx(ctx, await build.removeLiquidity(ref, index), s),
+        /** the tax line's hook: anyone sends a surplus to its place (the coin's own into the fire, other tokens to the platform) */
+        sweep: async (token, s = {}) => sendTx(ctx, tx(await hookOf("tax"), LINES.tax.hAbi, "sweep", [token], 0n, "The sweep"), s),
+        lineOf: async (ref) => (await locate(ref)).line,
+        lineOfFactory,
+    };
+}