@pickhooks/sdk 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,58 @@
+import { anyModule } from "./any.js";
+import { apiModule } from "./api.js";
+import { blocksCatalog } from "./blocks.js";
+import { coinsModule } from "./coins.js";
+import { dipsModule } from "./dips.js";
+import { infraModule } from "./infra.js";
+import { lever2Module, leverModule } from "./lever.js";
+import { callsModule, poolsModule } from "./pools.js";
+import { stickyModule } from "./sticky.js";
+import { makeCtx, sendAll, sendTx } from "./tx.js";
+/**
+ * The pickhooks SDK. One client, a part per product:
+ *   any      hook any coin: quotes, trades with the recapture room, opening a pool with a partner, the payouts
+ *   sticky   sticky rules: launching from templates, checking a trade against the coin's table, trading, lifting
+ *   coins    coins with rules in the coin (v1, v2): rules as sentences, the rule that would refuse a trade, launches
+ *   pools    rules in the pool; calls: curve calls; lever: Lever longs and shorts (leverV1 the first lever); dips: dip bids
+ *   api      pickhooks.com's public JSON API (launch feed, board, activity)
+ *
+ *   const ph = createPickhooks({ walletClient });
+ *   const [pool] = await ph.any.pools({ limit: 1 });
+ *   const r = await ph.any.buy({ pool, bnbIn: parseEther("0.05") });
+ */
+export function createPickhooks(options = {}) {
+    const ctx = makeCtx(options);
+    return {
+        addresses: ctx.a,
+        publicClient: ctx.pub,
+        any: anyModule(ctx),
+        sticky: stickyModule(ctx),
+        coins: coinsModule(ctx),
+        pools: poolsModule(ctx),
+        calls: callsModule(ctx),
+        lever: lever2Module(ctx),
+        leverV1: leverModule(ctx),
+        dips: dipsModule(ctx),
+        infra: infraModule(ctx),
+        blocks: { catalog: blocksCatalog, block: (id) => blocksCatalog().sticky.blocks.find((b) => b.id === id) ?? null },
+        api: apiModule(ctx),
+        send: (tx, o) => sendTx(ctx, tx, o),
+        sendAll: (txs, o) => sendAll(ctx, txs, o),
+    };
+}
+export { BSC_MAINNET, LIMITS, NATIVE, ZERO_ADDRESS } from "./addresses.js";
+export { CHECK_TEXT, PickhooksError, decodeRevert, errorText, explain, findRevertData } from "./errors.js";
+export { DEFAULT_RPC, deadlineIn, minusBps } from "./tx.js";
+export { blockedKind, buildInfiSwap, infiPriceBnb, infiQuote, infiSwapInput, permit2Approvals, poolIdOf, toKey } from "./infinity.js";
+export { approvalFor, buildV3Buy, buildV3Sell, receivedOf, v3PriceBnb, v3Quote } from "./v3.js";
+export { MAX_TICK, MIN_TICK, TAX_QUOTE_MARK, afterTax, depthNeeds, fitLadder, partnerLink, rangeFor, tickOf, } from "./any.js";
+export { describeRows, } from "./sticky.js";
+export { ruleText } from "./coins.js";
+export {} from "./pools.js";
+export { LEVER2_REASON, } from "./lever.js";
+export { coinsFor, coverOf, strikeFromPrice } from "./dips.js";
+export {} from "./api.js";
+export {} from "./infra.js";
+export { BLOCKS_VERSION, BLOCK_ACTIONS, BLOCK_CHECKS, BLOCK_MARKS, BLOCK_OPERATORS, BLOCK_TRIGGERS, blockLineVars, blocksCatalog, } from "./blocks.js";
+export { ACT, FLAG, LOCKED, NONE, ON, OP, STICKY_LIMITS, TEMPLATES, TEMPLATE_BY_ID, VAR, VARS, VAR_BY_ID, compile, decodeRow, defaults, editToRow, emptyEditRow, encodeRow, paramProblems, rowProblems, rowText, scannerOf, tableProblems, templateOf, } from "./sticky-rules.js";
+export { GROUPS, RULES, RULE_BY_ID, RULE_BY_KIND, buildRules, emptyExtras, emptyRules, fieldProblem, kindsOf, refusal, selectionProblem, v2Costs, worstScanner, defaults as ruleDefaults, } from "./coin-rules.js";

package/dist/infinity.d.ts

@@ -0,0 +1,63 @@
+import { type Address, type Hex } from "viem";
+import { type Addresses } from "./addresses.js";
+import { type Ctx, type TxRequest } from "./tx.js";
+/**
+ * PancakeSwap Infinity, shared by every pickhooks product whose coin trades in an Infinity CL pool (hook any coin, pools,
+ * Lever, curve calls): pool keys and ids, the UniversalRouter's swap encoding, the quoter, Permit2 approvals for sells,
+ * and the rule a hook names when it refuses a swap.
+ */
+/** An Infinity CL pool key. currency0 is always BNB (the zero address), currency1 the coin. */
+export type PoolKey = {
+    currency0: Address;
+    currency1: Address;
+    hooks: Address;
+    poolManager: Address;
+    fee: number;
+    parameters: Hex;
+};
+/** The pool id of a key: keccak256 of the encoded key, as Infinity's PoolIdLibrary computes it. */
+export declare function poolIdOf(key: PoolKey): Hex;
+/** a key as a contract returns it (fee as a number) */
+export declare const toKey: (raw: PoolKey) => PoolKey;
+/**
+ * The UniversalRouter's INFI_SWAP input: every leg an exact-in swap on the same pool (CL_SWAP_EXACT_IN_SINGLE), then the
+ * whole input settled once (SETTLE_ALL) and the whole output taken once (TAKE_ALL, at least minOut). A single leg also
+ * carries minOut as its own limit; with more legs only the total is bounded.
+ */
+export declare function infiSwapInput(key: PoolKey, buy: boolean, legs: readonly bigint[], minOut: bigint, hookData?: Hex): Hex;
+/** A swap through the UniversalRouter. A buy sends its BNB along; a sell needs the Permit2 approvals first. */
+export declare function buildInfiSwap(a: Addresses, s: {
+    key: PoolKey;
+    buy: boolean;
+    legs: readonly bigint[];
+    minOut: bigint;
+    deadline?: bigint;
+    extraGas?: bigint;
+    gasPct?: number;
+    hookData?: Hex;
+    label?: string;
+}): TxRequest;
+/**
+ * What a swap gets, from PancakeSwap's CL quoter running the real swap in an eth_call (the hook's fee, rules and
+ * liquidations are in it). `from` is the trader: hooks read tx.origin. A refusal throws the raw error; blockedKind() and
+ * explain() read it.
+ */
+export declare function infiQuote(ctx: Ctx, q: {
+    key: PoolKey;
+    buy: boolean;
+    amount: bigint;
+    from?: Address;
+    hookData?: Hex;
+}): Promise<{
+    amountOut: bigint;
+    gasEstimate: bigint;
+}>;
+/** The approvals a sell of `amount` through the UniversalRouter needs first: the coin to Permit2 (once), Permit2 to the router (30 days). */
+export declare function permit2Approvals(ctx: Ctx, owner: Address, token: Address, amount: bigint): Promise<TxRequest[]>;
+/**
+ * The rule a hook names in Blocked(uint8) (pools, curve calls): PancakeSwap wraps the hook's error (and the quoter once
+ * more), so the selector is searched anywhere in the revert data and the next word is the rule kind.
+ */
+export declare function blockedKind(err: unknown): number | null;
+/** BNB per coin at an Infinity pool's sqrt price (the price is coins per BNB). */
+export declare const infiPriceBnb: (sqrtPriceX96: bigint, decimals?: number) => number;

package/dist/infinity.js

@@ -0,0 +1,96 @@
+import { concatHex, encodeAbiParameters, encodeFunctionData, keccak256, maxUint256, toFunctionSelector } from "viem";
+import { POOL_KEY, SWAP_EXACT_IN_SINGLE, clQuoterAbi, erc20Abi, permit2Abi, universalRouterAbi } from "./abis/common.js";
+import { NATIVE } from "./addresses.js";
+import { findRevertData } from "./errors.js";
+import { deadlineIn } from "./tx.js";
+/** The pool id of a key: keccak256 of the encoded key, as Infinity's PoolIdLibrary computes it. */
+export function poolIdOf(key) {
+    return keccak256(encodeAbiParameters([POOL_KEY], [key]));
+}
+/** a key as a contract returns it (fee as a number) */
+export const toKey = (raw) => ({ ...raw, fee: Number(raw.fee) });
+/**
+ * The UniversalRouter's INFI_SWAP input: every leg an exact-in swap on the same pool (CL_SWAP_EXACT_IN_SINGLE), then the
+ * whole input settled once (SETTLE_ALL) and the whole output taken once (TAKE_ALL, at least minOut). A single leg also
+ * carries minOut as its own limit; with more legs only the total is bounded.
+ */
+export function infiSwapInput(key, buy, legs, minOut, hookData = "0x") {
+    const coin = key.currency1;
+    const total = legs.reduce((x, y) => x + y, 0n);
+    const actions = concatHex([...legs.map(() => "0x06"), "0x0c", "0x0f"]);
+    const params = [
+        ...legs.map((amountIn) => encodeAbiParameters(SWAP_EXACT_IN_SINGLE, [{ poolKey: key, zeroForOne: buy, amountIn, amountOutMinimum: legs.length === 1 ? minOut : 0n, hookData }])),
+        encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [buy ? NATIVE : coin, total]),
+        encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [buy ? coin : NATIVE, minOut]),
+    ];
+    return encodeAbiParameters([{ type: "bytes" }, { type: "bytes[]" }], [actions, params]);
+}
+/** A swap through the UniversalRouter. A buy sends its BNB along; a sell needs the Permit2 approvals first. */
+export function buildInfiSwap(a, s) {
+    const total = s.legs.reduce((x, y) => x + y, 0n);
+    return {
+        to: a.universalRouter,
+        value: s.buy ? total : 0n,
+        data: encodeFunctionData({ abi: universalRouterAbi, functionName: "execute", args: ["0x10", [infiSwapInput(s.key, s.buy, s.legs, s.minOut, s.hookData)], s.deadline ?? deadlineIn()] }),
+        extraGas: s.extraGas,
+        gasPct: s.gasPct,
+        label: s.label ?? (s.buy ? "The buy" : "The sell"),
+    };
+}
+/**
+ * What a swap gets, from PancakeSwap's CL quoter running the real swap in an eth_call (the hook's fee, rules and
+ * liquidations are in it). `from` is the trader: hooks read tx.origin. A refusal throws the raw error; blockedKind() and
+ * explain() read it.
+ */
+export async function infiQuote(ctx, q) {
+    const r = await ctx.pub.simulateContract({
+        address: ctx.a.clQuoter,
+        abi: clQuoterAbi,
+        functionName: "quoteExactInputSingle",
+        args: [{ poolKey: q.key, zeroForOne: q.buy, exactAmount: q.amount, hookData: q.hookData ?? "0x" }],
+        account: q.from,
+    });
+    return { amountOut: r.result[0], gasEstimate: r.result[1] };
+}
+/** The approvals a sell of `amount` through the UniversalRouter needs first: the coin to Permit2 (once), Permit2 to the router (30 days). */
+export async function permit2Approvals(ctx, owner, token, amount) {
+    const { pub, a } = ctx;
+    const out = [];
+    const [toPermit2, p2] = await Promise.all([
+        pub.readContract({ address: token, abi: erc20Abi, functionName: "allowance", args: [owner, a.permit2] }),
+        pub.readContract({ address: a.permit2, abi: permit2Abi, functionName: "allowance", args: [owner, token, a.universalRouter] }),
+    ]);
+    if (toPermit2 < amount) {
+        out.push({ to: token, value: 0n, data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [a.permit2, maxUint256] }), label: "Allowing Permit2" });
+    }
+    const now = Math.floor(Date.now() / 1000);
+    if (p2[0] < amount || Number(p2[1]) < now + 60) {
+        out.push({
+            to: a.permit2,
+            value: 0n,
+            data: encodeFunctionData({ abi: permit2Abi, functionName: "approve", args: [token, a.universalRouter, (1n << 160n) - 1n, now + 30 * 86_400] }),
+            label: "Allowing the router through Permit2",
+        });
+    }
+    return out;
+}
+const BLOCKED = toFunctionSelector("Blocked(uint8)").slice(2).toLowerCase();
+/**
+ * The rule a hook names in Blocked(uint8) (pools, curve calls): PancakeSwap wraps the hook's error (and the quoter once
+ * more), so the selector is searched anywhere in the revert data and the next word is the rule kind.
+ */
+export function blockedKind(err) {
+    const data = findRevertData(err)?.toLowerCase();
+    if (!data)
+        return null;
+    const i = data.indexOf(BLOCKED);
+    if (i < 0)
+        return null;
+    const word = data.slice(i + BLOCKED.length, i + BLOCKED.length + 64);
+    return word.length === 64 ? Number.parseInt(word, 16) : null;
+}
+/** BNB per coin at an Infinity pool's sqrt price (the price is coins per BNB). */
+export const infiPriceBnb = (sqrtPriceX96, decimals = 18) => {
+    const p = (Number(sqrtPriceX96) / 2 ** 96) ** 2 * 10 ** (18 - decimals);
+    return p > 0 ? 1 / p : 0;
+};

package/dist/infra.d.ts

@@ -0,0 +1,112 @@
+import { type Address, type Hex } from "viem";
+import { type Ctx, type SendOptions, type Sent, type TxRequest } from "./tx.js";
+/**
+ * HOOKS infra.
+ *  - Floors: a BNB reserve under a coin (HooksFloor, one per coin from HooksFloorFactory). Anyone feeds it; a holder hands
+ *    coins in for reserve / circulating, less 2 % (1 % stays and lifts the floor, 1 % to the protocol). The coins go to
+ *    0xdead. No owner, no withdraw: the floor only rises.
+ *  - Protected buy: HooksExecutor buys through PancakeSwap's own routers and a floor for what arrived from a live dip bid,
+ *    in one transaction. pickhooks.com picks the route and the bid (/api/infra/protect); protect() sends what it built.
+ * Off while addresses.hooksFloorFactory / hooksExecutor are zero (until they are on mainnet).
+ */
+export type FloorState = {
+    token: Address;
+    /** the coin's floor, or null while nobody opened it */
+    floor: Address | null;
+    /** where the floor is (or will be once opened) */
+    predicted: Address;
+    reserve: bigint;
+    /** coins that could be handed in: supply minus 0xdead */
+    circulating: bigint;
+    /** BNB wei per whole coin a hand in is worth before the 2 % */
+    perCoin: bigint;
+    totalFed: bigint;
+    totalPaid: bigint;
+    totalRedeemed: bigint;
+};
+/** pickhooks.com's answer for a protected buy (loosely typed: the site may add fields) */
+export type ProtectOffer = {
+    token: Address;
+    route: string | null;
+    /** why there is no protected buy, when there is none */
+    reason: string | null;
+    bnbIn: string;
+    coinsOut: string;
+    options: unknown[];
+    best: {
+        bidId?: string | number;
+        floorPct?: number;
+        premium?: string;
+        [k: string]: unknown;
+    } | null;
+    executor: Address | null;
+    tx: {
+        to: Address;
+        data: Hex;
+        value: string;
+    } | null;
+    simulated: {
+        coins: string;
+        floorId: string;
+        premium: string;
+    } | {
+        error: string;
+    } | null;
+    [k: string]: unknown;
+};
+export declare function infraModule(ctx: Ctx): {
+    on: {
+        floors: boolean;
+        executor: boolean;
+    };
+    floorAddress: (token: Address) => Promise<Address | null>;
+    floorOf: (token: Address) => Promise<FloorState>;
+    quoteRedeem: (token: Address, coins: bigint) => Promise<{
+        payout: bigint;
+        kept: bigint;
+        protocolFee: bigint;
+    }>;
+    build: {
+        /** opens a coin's floor (anyone can) and feeds it `seed` */
+        open: (token: Address, seed?: bigint) => TxRequest;
+        /** adds BNB to a floor's reserve (plain BNB to the floor does the same) */
+        feed: (floor: Address, wei: bigint) => TxRequest;
+        /** hands coins in (the floor needs the approval first) */
+        redeem: (floor: Address, coins: bigint, minBnb: bigint, to: Address) => TxRequest;
+    };
+    open: (o: {
+        token: Address;
+        seed?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        floor: Address;
+    }>;
+    feed: (token: Address, wei: bigint, s?: SendOptions) => Promise<Sent>;
+    redeem: (o: {
+        token: Address;
+        coins: bigint;
+        slippageBps?: number;
+        minBnb?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        quoted: bigint;
+    }>;
+    offer: (q: {
+        token: Address;
+        bnbIn: bigint;
+        wallet?: Address;
+        minFloorPct?: number;
+        bid?: number;
+        slippagePct?: number;
+    }) => Promise<ProtectOffer>;
+    protect: (q: {
+        token: Address;
+        bnbIn: bigint;
+        minFloorPct?: number;
+        bid?: number;
+        slippagePct?: number;
+    }, s?: SendOptions) => Promise<Sent & {
+        coins: bigint;
+        floorId: bigint;
+        premium: bigint;
+    }>;
+};
+export type InfraModule = ReturnType<typeof infraModule>;

package/dist/infra.js

@@ -0,0 +1,114 @@
+import { encodeFunctionData, formatEther, parseEventLogs } from "viem";
+import { hooksExecutorAbi, hooksFloorAbi, hooksFloorFactoryAbi } from "./abis/infra.js";
+import { ZERO_ADDRESS } from "./addresses.js";
+import { PickhooksError, toPickhooksError } from "./errors.js";
+import { minusBps, sendTx, signer } from "./tx.js";
+import { approvalFor } from "./v3.js";
+export function infraModule(ctx) {
+    const { a, pub } = ctx;
+    const on = { floors: a.hooksFloorFactory !== ZERO_ADDRESS, executor: a.hooksExecutor !== ZERO_ADDRESS };
+    const need = (part) => {
+        if (!on[part])
+            throw new PickhooksError(part === "floors" ? "HOOKS floors are not live yet." : "The protected buy is not live yet.", { code: "input" });
+    };
+    const tx = (to, abi, functionName, args, value = 0n, label) => ({
+        to,
+        value,
+        data: encodeFunctionData({ abi, functionName, args }),
+        label,
+    });
+    async function floorAddress(token) {
+        need("floors");
+        const f = (await pub.readContract({ address: a.hooksFloorFactory, abi: hooksFloorFactoryAbi, functionName: "floorOf", args: [token] }));
+        return f === ZERO_ADDRESS ? null : f;
+    }
+    /** A coin's floor: reserve, circulating, BNB per whole coin, and what it paid so far (zeros while it is not open). */
+    async function floorOf(token) {
+        const [floor, predicted] = await Promise.all([
+            floorAddress(token),
+            pub.readContract({ address: a.hooksFloorFactory, abi: hooksFloorFactoryAbi, functionName: "predict", args: [token] }),
+        ]);
+        if (!floor)
+            return { token, floor: null, predicted, reserve: 0n, circulating: 0n, perCoin: 0n, totalFed: 0n, totalPaid: 0n, totalRedeemed: 0n };
+        const fns = ["reserve", "circulating", "floor", "totalFed", "totalPaid", "totalRedeemed"];
+        const r = (await pub.multicall({ contracts: fns.map((functionName) => ({ address: floor, abi: hooksFloorAbi, functionName })), allowFailure: false }));
+        return { token, floor, predicted, reserve: r[0], circulating: r[1], perCoin: r[2], totalFed: r[3], totalPaid: r[4], totalRedeemed: r[5] };
+    }
+    async function mustFloor(token) {
+        const f = await floorAddress(token);
+        if (!f)
+            throw new PickhooksError("This coin has no floor yet. Anyone can open it with open().", { code: "input" });
+        return f;
+    }
+    /** What handing in `coins` pays now: the payout, what stays in the reserve, the protocol's part. */
+    async function quoteRedeem(token, coins) {
+        const [payout, kept, protocolFee] = (await pub.readContract({ address: await mustFloor(token), abi: hooksFloorAbi, functionName: "quote", args: [coins] }));
+        return { payout, kept, protocolFee };
+    }
+    const build = {
+        /** opens a coin's floor (anyone can) and feeds it `seed` */
+        open: (token, seed = 0n) => tx(a.hooksFloorFactory, hooksFloorFactoryAbi, "open", [token], seed, "Opening the floor"),
+        /** adds BNB to a floor's reserve (plain BNB to the floor does the same) */
+        feed: (floor, wei) => tx(floor, hooksFloorAbi, "feed", [], wei, "Feeding the floor"),
+        /** hands coins in (the floor needs the approval first) */
+        redeem: (floor, coins, minBnb, to) => tx(floor, hooksFloorAbi, "redeem", [coins, minBnb, to], 0n, "Handing in"),
+    };
+    /** Opens the coin's floor, fed with `seed` BNB. */
+    async function open(o, s = {}) {
+        need("floors");
+        const sent = await sendTx(ctx, build.open(o.token, o.seed ?? 0n), s);
+        const ev = parseEventLogs({ abi: hooksFloorFactoryAbi, logs: sent.receipt.logs, eventName: "FloorOpened" })[0];
+        return { ...sent, floor: ev?.args.floor ?? (await mustFloor(o.token)) };
+    }
+    /** Feeds the coin's floor with `wei` BNB. */
+    async function feed(token, wei, s = {}) {
+        return sendTx(ctx, build.feed(await mustFloor(token), wei), s);
+    }
+    /** Hands `coins` in for BNB: approval to the floor if needed, then the hand in with the quote less `slippageBps` (default 50) as the minimum. */
+    async function redeem(o, s = {}) {
+        const floor = await mustFloor(o.token);
+        const { address } = await signer(ctx, s.wallet);
+        const q = await quoteRedeem(o.token, o.coins);
+        if (q.payout === 0n)
+            throw new PickhooksError("The floor pays nothing for these coins yet.", { code: "input" });
+        const ap = await approvalFor(ctx, address, o.token, o.coins, floor, "Allowing the floor");
+        if (ap)
+            await sendTx(ctx, ap, s);
+        const sent = await sendTx(ctx, build.redeem(floor, o.coins, o.minBnb ?? minusBps(q.payout, o.slippageBps ?? 50), address), s);
+        return { ...sent, quoted: q.payout };
+    }
+    /** pickhooks.com's protected buy for `bnbIn`: the route, the coins, the dip bids that can cover them, and with `wallet` the transaction. */
+    async function offer(q) {
+        const query = { token: q.token, bnb: formatEther(q.bnbIn), wallet: q.wallet, minFloor: q.minFloorPct, bid: q.bid, slippage: q.slippagePct };
+        const qs = Object.entries(query)
+            .filter(([, v]) => v !== undefined)
+            .map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`)
+            .join("&");
+        const res = await fetch(`${ctx.site}/api/infra/protect?${qs}`, { headers: { accept: "application/json" } });
+        const j = (await res.json().catch(() => null));
+        if (!res.ok || !j)
+            throw new PickhooksError(j?.error ?? `The protected buy answered ${res.status}.`, { code: res.status === 429 ? "rate" : "site" });
+        return j;
+    }
+    /** Buys `bnbIn` of the coin with a floor in one transaction, as pickhooks.com builds it; refuses when the site found no cover. */
+    async function protect(q, s = {}) {
+        need("executor");
+        const { address } = await signer(ctx, s.wallet);
+        const o = await offer({ ...q, wallet: address });
+        if (!o.tx)
+            throw new PickhooksError(o.reason ?? "No dip bid can cover this buy right now.", { code: "input" });
+        if (o.simulated && "error" in o.simulated)
+            throw new PickhooksError(o.simulated.error, { code: "reverted" });
+        if (o.tx.to.toLowerCase() !== a.hooksExecutor.toLowerCase())
+            throw new PickhooksError("The site built a transaction to another contract than the executor.", { code: "input" });
+        try {
+            const sent = await sendTx(ctx, { to: o.tx.to, data: o.tx.data, value: BigInt(o.tx.value), label: "The protected buy" }, s);
+            const ev = parseEventLogs({ abi: hooksExecutorAbi, logs: sent.receipt.logs, eventName: "ProtectedBuy" })[0];
+            return { ...sent, coins: ev?.args.coins ?? 0n, floorId: ev?.args.floorId ?? 0n, premium: ev?.args.premium ?? 0n };
+        }
+        catch (e) {
+            throw toPickhooksError(e, "The protected buy would fail.");
+        }
+    }
+    return { on, floorAddress, floorOf, quoteRedeem, build, open, feed, redeem, offer, protect };
+}