@pickhooks/sdk 0.0.0-stage → 0.4.0

package/dist/lever.js

@@ -0,0 +1,419 @@
+import { encodeFunctionData, isAddressEqual, parseEventLogs } from "viem";
+import { plainTokenAbi } from "./abis/pools.js";
+import { leverEngineAbi, leverFactoryAbi, leverHookAbi, leverRouterAbi } from "./abis/lever.js";
+import { lever2EngineAbi, lever2FactoryAbi, lever2HookAbi, lever2LensAbi } from "./abis/lever2.js";
+import { PickhooksError, toPickhooksError } from "./errors.js";
+import { buildInfiSwap, infiQuote, permit2Approvals, poolIdOf, toKey } from "./infinity.js";
+import { deadlineIn, minusBps, sendAll, sendTx, signer } from "./tx.js";
+import { approvalFor } from "./v3.js";
+/**
+ * Lever: coins whose curve lends BNB to leveraged positions, liquidated inside the trade that reaches them.
+ *  - lever (v1, factory 0xeaB9…9615): the curve lives in the lever engine behind an Infinity hook; spot trades and longs
+ *    go through the lever router and hook.
+ *  - Lever (v2, factory 0x03Eb…A87A): the curve is real liquidity in the coin's Infinity pool (LP fee 0, hook fee 1 %),
+ *    so terminals see its price; longs borrow BNB from the curve, shorts borrow coins, 2x to 5x, priced by the Lens.
+ * Both: up to 3x in a coin's first 10 minutes, then up to 5x; at least 0.01 BNB margin; a position is closed after 24
+ * hours at the latest.
+ */
+const TEN_K = 10000n;
+/** room on a Lens or engine quote for a position's bound (minTokens, maxCoins, minBnb), basis points */
+const QUOTE_ROOM = 100n;
+const down = (x, bps = QUOTE_ROOM) => (x * (TEN_K - bps)) / TEN_K;
+const up = (x, bps = QUOTE_ROOM) => (x * (TEN_K + bps) + TEN_K - 1n) / TEN_K;
+/** lever v1 */
+export function leverModule(ctx) {
+    const { pub, a } = ctx;
+    const F = leverFactoryAbi;
+    const H = leverHookAbi;
+    const E = leverEngineAbi;
+    const RT = leverRouterAbi;
+    let parts = null;
+    const call = (address, abi, functionName, args = []) => pub.readContract({ address, abi, functionName, args });
+    /** The hook, router and engine of the lever factory. */
+    function contracts() {
+        parts ??= (async () => {
+            const [hook, router] = await Promise.all([call(a.leverFactory, F, "hook"), call(a.leverFactory, F, "router")]);
+            return { hook, router, engine: await call(hook, H, "engine") };
+        })();
+        return parts;
+    }
+    const count = async () => Number(await call(a.leverFactory, F, "coinCount"));
+    const isCoin = async (token) => (await call(a.leverFactory, F, "isCoin", [token]).catch(() => false)) === true;
+    async function summaries(tokens) {
+        if (!tokens.length)
+            return [];
+        const { engine } = await contracts();
+        const res = await pub.multicall({
+            contracts: tokens.flatMap((t) => [
+                { address: t, abi: plainTokenAbi, functionName: "name" },
+                { address: t, abi: plainTokenAbi, functionName: "symbol" },
+                { address: t, abi: plainTokenAbi, functionName: "metadata" },
+                { address: engine, abi: E, functionName: "marketOf", args: [t] },
+                { address: engine, abi: E, functionName: "activePositions", args: [t] },
+            ]),
+            allowFailure: true,
+        });
+        const out = [];
+        tokens.forEach((token, i) => {
+            const g = (k) => res[i * 5 + k];
+            if (g(3).status !== "success")
+                return;
+            const m = g(3).result;
+            const priceBnb = m.q > 0n ? Number(m.r) / Number(m.q) : 0;
+            out.push({
+                token,
+                name: String(g(0).result ?? ""),
+                symbol: String(g(1).result ?? ""),
+                metadata: String(g(2).result ?? ""),
+                market: { ...m, start: Number(m.start), creatorBps: Number(m.creatorBps) },
+                priceBnb,
+                mcapBnb: priceBnb * (Number(m.supply) / 1e18),
+                positions: (g(4).result ?? []).length,
+            });
+        });
+        return out;
+    }
+    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: a.leverFactory, abi: F, functionName: "coins", args: [BigInt(end - 1 - i)] })),
+            allowFailure: false,
+        }));
+        return summaries(tokens);
+    }
+    /** Every open long of a coin, with its liquidation trigger and what closing it pays now. */
+    async function positions(token) {
+        const { engine } = await contracts();
+        const [ids, ps, triggers] = await call(engine, E, "positionsOf", [token]);
+        const quotes = ids.length ? await pub.multicall({ contracts: ids.map((id) => ({ address: engine, abi: E, functionName: "quoteClose", args: [token, id] })), allowFailure: true }) : [];
+        return ids.map((id, i) => ({
+            id,
+            owner: ps[i].owner,
+            tokens: ps[i].tokens,
+            debt: ps[i].debt,
+            margin: ps[i].margin,
+            opened: Number(ps[i].opened),
+            trigger: triggers[i],
+            closeQuote: quotes[i]?.status === "success" ? quotes[i].result : null,
+        }));
+    }
+    const engineRead = async (fn, args) => {
+        try {
+            return await call((await contracts()).engine, E, fn, args);
+        }
+        catch (e) {
+            throw toPickhooksError(e, "The lever engine refused this.");
+        }
+    };
+    /** Coins a buy gets, BNB a sell gets (and how many longs it liquidates), a long's coins, debt, fee and trigger. */
+    const quoteBuy = (token, bnbIn) => engineRead("quoteBuy", [token, bnbIn]);
+    const quoteSell = async (token, amount) => {
+        const [out, liquidations] = await engineRead("quoteSell", [token, amount]);
+        return { out, liquidations: Number(liquidations) };
+    };
+    const quoteOpen = async (token, gross, leverage) => {
+        const [tokens, debt, fee, trigger] = await engineRead("quoteOpen", [token, gross, leverage]);
+        return { tokens, debt, fee, trigger };
+    };
+    const tx = async (to, abi, fn, args, value = 0n, label) => ({
+        to: (await contracts())[to],
+        value,
+        data: encodeFunctionData({ abi, functionName: fn, args }),
+        gasPct: 150,
+        label,
+    });
+    const build = {
+        buy: (token, bnbIn, minOut) => tx("router", RT, "buy", [token, minOut, deadlineIn()], bnbIn, "The buy"),
+        /** needs the coin approved to the lever router */
+        sell: (token, amount, minOut) => tx("router", RT, "sell", [token, amount, minOut, deadlineIn()], 0n, "The sell"),
+        openLong: (token, gross, leverage, minTokens) => tx("hook", H, "openLong", [token, leverage, minTokens, deadlineIn()], gross, "Opening the long"),
+        closeLong: (token, id, minBnb) => tx("hook", H, "closeLong", [token, id, minBnb, deadlineIn()], 0n, "Closing the long"),
+        /** anyone, after 24 hours: the payout waits for the owner as a refund */
+        closeExpired: (token, id) => tx("hook", H, "closeExpired", [token, id], 0n, "Closing an expired long"),
+        claimRefund: (token) => tx("hook", H, "claimRefund", [token], 0n, "The refund"),
+        claimCreator: (token) => tx("hook", H, "claimCreator", [token], 0n, "The creator claim"),
+    };
+    return {
+        factory: a.leverFactory,
+        contracts,
+        count,
+        coins,
+        coin: async (token) => ((await isCoin(token)) ? ((await summaries([token]))[0] ?? null) : null),
+        isCoin,
+        positions,
+        quoteBuy,
+        quoteSell,
+        quoteOpen,
+        refundOwed: async (token, who) => engineRead("refundOwed", [token, who]),
+        poolKey: async (token) => toKey(await call(a.leverFactory, F, "poolKeyOf", [token])),
+        build,
+        buy: async (b, s = {}) => {
+            const out = await quoteBuy(b.token, b.bnbIn);
+            return { ...(await sendTx(ctx, await build.buy(b.token, b.bnbIn, minusBps(out, b.slippageBps ?? 100)), s)), quoted: out };
+        },
+        sell: async (x, s = {}) => {
+            const { address } = await signer(ctx, s.wallet);
+            const ap = await approvalFor(ctx, address, x.token, x.amount, (await contracts()).router, "Allowing the lever router");
+            if (ap)
+                await sendTx(ctx, ap, s);
+            const q = await quoteSell(x.token, x.amount);
+            return { ...(await sendTx(ctx, await build.sell(x.token, x.amount, minusBps(q.out, x.slippageBps ?? 100)), s)), quoted: q.out, liquidations: q.liquidations };
+        },
+        /** gross = margin plus the open fee; the long gets at least the quote less roomBps (default 100) coins */
+        openLong: async (o, s = {}) => {
+            const q = await quoteOpen(o.token, o.gross, o.leverage);
+            const sent = await sendTx(ctx, await build.openLong(o.token, o.gross, o.leverage, down(q.tokens, BigInt(o.roomBps ?? 100))), s);
+            const ev = parseEventLogs({ abi: E, logs: sent.receipt.logs }).find((e) => e.eventName === "LongOpened");
+            return { ...sent, id: ev?.args.id ?? 0n, tokens: ev?.args.tokens ?? q.tokens };
+        },
+        closeLong: async (o, s = {}) => {
+            const net = await engineRead("quoteClose", [o.token, o.id]);
+            return { ...(await sendTx(ctx, await build.closeLong(o.token, o.id, down(net, BigInt(o.roomBps ?? 100))), s)), quoted: net };
+        },
+        closeExpired: async (token, id, s = {}) => sendTx(ctx, await build.closeExpired(token, id), s),
+        claimRefund: async (token, s = {}) => sendTx(ctx, await build.claimRefund(token), s),
+        claimCreator: async (token, s = {}) => sendTx(ctx, await build.claimCreator(token), s),
+        /** one transaction: the coin and the creator's first buy; returns the coin */
+        launch: async (l, s = {}) => {
+            const t = {
+                to: a.leverFactory,
+                value: l.firstBuy ?? 0n,
+                data: encodeFunctionData({ abi: F, functionName: "launch", args: [l.name, l.symbol, l.metadata, l.minSeedTokens ?? 0n] }),
+                gasPct: 125,
+                label: "The launch",
+            };
+            const sent = await sendTx(ctx, t, s);
+            const ev = parseEventLogs({ abi: F, logs: sent.receipt.logs.filter((x) => isAddressEqual(x.address, a.leverFactory)) }).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 };
+        },
+    };
+}
+/** Lens reasons as sentences */
+export const LEVER2_REASON = {
+    0: "OK",
+    1: "Up to 3x in a coin's first 10 minutes, then up to 5x.",
+    2: "The smallest position is 0.01 BNB of margin plus the open fee.",
+    3: "All 8 slots of this side are taken; a bigger margin takes the smallest one's slot.",
+    4: "This side is full for now: each side may borrow at most a quarter of the real BNB in the curve. Try a smaller position or wait for more buys.",
+    5: "This position would sit at its liquidation point. Try a smaller margin or a lower leverage.",
+    6: "This trade would leave another position at its liquidation point. Try a smaller margin or a lower leverage.",
+    7: "This is not a lever coin.",
+    8: "The price was pushed in this second. Try again in a moment.",
+};
+const KIND = { creator: 3, refund: 4, platform: 5 };
+export function lever2Module(ctx) {
+    const { pub, a } = ctx;
+    const F = lever2FactoryAbi;
+    const H = lever2HookAbi;
+    const E = lever2EngineAbi;
+    const L = lever2LensAbi;
+    let parts = null;
+    const keys = new Map();
+    const call = (address, abi, functionName, args = []) => pub.readContract({ address, abi, functionName, args });
+    function contracts() {
+        parts ??= (async () => {
+            const hook = await call(a.lever2Factory, F, "hook");
+            return { hook, engine: await call(hook, H, "engine"), lens: a.lever2Lens };
+        })();
+        return parts;
+    }
+    const count = async () => Number(await call(a.lever2Factory, F, "coinCount"));
+    const isCoin = async (token) => (await call(a.lever2Factory, F, "isCoin", [token]).catch(() => false)) === true;
+    async function poolKey(token) {
+        const hit = keys.get(token.toLowerCase());
+        if (hit)
+            return hit;
+        const k = toKey(await call(a.lever2Factory, F, "poolKeyOf", [token]));
+        keys.set(token.toLowerCase(), k);
+        return k;
+    }
+    /** The curve now (Lens stateOf), the market (engine), and the coin. */
+    async function coin(token) {
+        if (!(await isCoin(token)))
+            return null;
+        const { engine, lens } = await contracts();
+        const r = await pub.multicall({
+            contracts: [
+                { address: token, abi: plainTokenAbi, functionName: "name" },
+                { address: token, abi: plainTokenAbi, functionName: "symbol" },
+                { address: token, abi: plainTokenAbi, functionName: "metadata" },
+                { address: token, abi: plainTokenAbi, functionName: "totalSupply" },
+                { address: lens, abi: L, functionName: "stateOf", args: [token] },
+                { address: engine, abi: E, functionName: "marketOf", args: [token] },
+            ],
+            allowFailure: false,
+        });
+        const state = r[4];
+        const market = r[5];
+        const priceBnb = Number(state.price) / 1e18;
+        return {
+            token,
+            name: String(r[0]),
+            symbol: String(r[1]),
+            metadata: String(r[2]),
+            supply: r[3],
+            state: { ...state, tS: Number(state.tS), tB: Number(state.tB) },
+            market: { ...market, start: Number(market.start), creatorBps: Number(market.creatorBps) },
+            key: await poolKey(token),
+            id: poolIdOf(await poolKey(token)),
+            priceBnb,
+            mcapBnb: priceBnb * (Number(r[3]) / 1e18),
+        };
+    }
+    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: a.lever2Factory, abi: F, functionName: "coins", args: [BigInt(end - 1 - i)] })),
+            allowFailure: false,
+        }));
+        return (await Promise.all(tokens.map((t) => coin(t)))).filter((c) => c !== null);
+    }
+    /** Open longs and shorts with their trigger price and what closing pays now (Lens rows). */
+    async function positions(token) {
+        const { lens } = await contracts();
+        const [longs, shorts] = await Promise.all([call(lens, L, "longsOf", [token]), call(lens, L, "shortsOf", [token])]);
+        const fix = (x) => ({ ...x, opened: Number(x.opened) });
+        return { longs: longs.map(fix), shorts: shorts.map(fix) };
+    }
+    /** The Lens quote of a position: margin, borrowed, fee, coins, trigger, and reason (0 = it would open). */
+    async function quoteOpen(token, side, gross, leverage) {
+        const q = await call((await contracts()).lens, L, side === "long" ? "quoteOpenLong" : "quoteOpenShort", [token, gross, leverage]);
+        return { ...q, reason: Number(q.reason), text: LEVER2_REASON[Number(q.reason)] ?? "The Lens refused this position." };
+    }
+    const quoteClose = async (token, side, id) => call((await contracts()).lens, L, side === "long" ? "quoteCloseLong" : "quoteCloseShort", [token, id]);
+    /** Spot: what a trade gets in the coin's pool (the hook's fee and every liquidation it reaches are in it). */
+    async function quote(q) {
+        try {
+            return { amountOut: (await infiQuote(ctx, { key: await poolKey(q.token), buy: q.side === "buy", amount: q.amount, from: q.from })).amountOut };
+        }
+        catch (e) {
+            throw toPickhooksError(e, "The pool refused this trade.");
+        }
+    }
+    /**
+     * How a sale of `amount` goes through the pool. While shorts are open, a sale bigger than the curve's room (Lens
+     * sellRoom) goes in two legs of one transaction: the room first (it liquidates every long on its way and ends at the
+     * start), then the rest, which closes shorts at the start (most coins first) until it fits. fits false: even closing
+     * every short leaves no room; nothing would be sold.
+     */
+    async function sellPlan(token, amount) {
+        const { lens, engine } = await contracts();
+        const s = await call(lens, L, "stateOf", [token]);
+        if (s.lent === 0n || amount <= s.sellRoom || s.sellRoom === 0n)
+            return { legs: [amount], closes: 0, fits: true, sellRoom: s.sellRoom };
+        const shorts = await call(engine, E, "shortsOf", [token]);
+        const rest = amount - s.sellRoom;
+        const sizes = shorts[1].map((x) => x.coins).sort((x, y) => (x > y ? -1 : x < y ? 1 : 0));
+        let bought = 0n;
+        let closes = 0;
+        for (const c of sizes) {
+            if (rest <= bought)
+                break;
+            bought += c;
+            closes++;
+        }
+        return { legs: [s.sellRoom, rest], closes, fits: rest < bought + 1000000000n, sellRoom: s.sellRoom };
+    }
+    const hookTx = async (fn, args, value = 0n, label) => ({
+        to: (await contracts()).hook,
+        value,
+        data: encodeFunctionData({ abi: H, functionName: fn, args }),
+        gasPct: 150,
+        label,
+    });
+    const build = {
+        buy: (key, bnbIn, minOut) => buildInfiSwap(a, { key, buy: true, legs: [bnbIn], minOut, gasPct: 150 }),
+        /** legs from sellPlan(); the router pulls the coins with Permit2 */
+        sell: (key, legs, minOut) => buildInfiSwap(a, { key, buy: false, legs, minOut, gasPct: 150 }),
+        openLong: (token, gross, leverage, minTokens) => hookTx("openLong", [token, leverage, minTokens, deadlineIn()], gross, "Opening the long"),
+        openShort: (token, gross, leverage, maxCoins) => hookTx("openShort", [token, leverage, maxCoins, deadlineIn()], gross, "Opening the short"),
+        close: (token, side, id, minBnb) => hookTx(side === "long" ? "closeLong" : "closeShort", [token, id, minBnb, deadlineIn()], 0n, `Closing the ${side}`),
+        /** the pad's keeper after 24 hours, anyone 24 hours later; the payout waits for the owner as a refund */
+        closeExpired: (token, side, id, minBnb) => hookTx("closeExpired", [token, id, side === "short", minBnb], 0n, `Closing an expired ${side}`),
+        /** refund: the caller's refunds; creator: the creator's fees; platform: the pad's share (anyone may send it) */
+        claim: (token, kind) => hookTx("claim", [token, KIND[kind]], 0n, `The ${kind} claim`),
+    };
+    return {
+        factory: a.lever2Factory,
+        contracts,
+        count,
+        coins,
+        coin,
+        isCoin,
+        poolKey,
+        positions,
+        quoteOpen,
+        quoteClose,
+        quote,
+        sellPlan,
+        refundOwed: async (token, who) => call((await contracts()).engine, E, "refundOwed", [token, who]),
+        /** the gross (margin plus the open fee) for at least `margin` at `leverage`, rounded up to a millionth of a BNB */
+        grossForMargin: (margin, leverage) => {
+            const bps = TEN_K + BigInt(leverage * 30);
+            const g = (margin * bps + TEN_K - 1n) / TEN_K;
+            const step = 10n ** 12n;
+            return ((g + step - 1n) / step) * step;
+        },
+        build,
+        buy: async (b, s = {}) => {
+            const { address } = await signer(ctx, s.wallet);
+            const q = await quote({ token: b.token, side: "buy", amount: b.bnbIn, from: address });
+            return { ...(await sendTx(ctx, build.buy(await poolKey(b.token), b.bnbIn, minusBps(q.amountOut, b.slippageBps ?? 100)), s)), quoted: q.amountOut };
+        },
+        /** sells in one or two legs (sellPlan); the minimum is the pool's quote of the first leg plus the rest, less slippage */
+        sell: async (x, s = {}) => {
+            const { address } = await signer(ctx, s.wallet);
+            const plan = await sellPlan(x.token, x.amount);
+            if (!plan.fits)
+                throw new PickhooksError("This sale is bigger than what closing every short frees before the curve's start. Sell less.", { code: "input" });
+            await sendAll(ctx, await permit2Approvals(ctx, address, x.token, x.amount), s);
+            const q = plan.legs.length === 1 ? await quote({ token: x.token, side: "sell", amount: x.amount, from: address }) : await quote({ token: x.token, side: "sell", amount: plan.legs[0], from: address });
+            const minOut = x.minOut ?? minusBps(q.amountOut, x.slippageBps ?? 100);
+            return { ...(await sendTx(ctx, build.sell(await poolKey(x.token), plan.legs, minOut), s)), quoted: q.amountOut, plan };
+        },
+        /** opens a long or short at the Lens quote with roomBps (default 100) on its bound; a refusing reason throws its sentence */
+        open: async (o, s = {}) => {
+            const q = await quoteOpen(o.token, o.side, o.gross, o.leverage);
+            if (q.reason !== 0 && q.reason !== 3)
+                throw new PickhooksError(q.text, { code: "lens", args: [q.reason] });
+            const room = BigInt(o.roomBps ?? 100);
+            const t = o.side === "long" ? await build.openLong(o.token, o.gross, o.leverage, down(q.amount, room)) : await build.openShort(o.token, o.gross, o.leverage, up(q.amount, room));
+            const sent = await sendTx(ctx, t, s);
+            const ev = parseEventLogs({ abi: E, logs: sent.receipt.logs }).find((e) => e.eventName === (o.side === "long" ? "LongOpened" : "ShortOpened"));
+            return { ...sent, id: ev?.args.id ?? 0n, quote: q };
+        },
+        close: async (o, s = {}) => {
+            const q = await quoteClose(o.token, o.side, o.id);
+            if (q.pushed)
+                throw new PickhooksError(LEVER2_REASON[8], { code: "lens", args: [8] });
+            return { ...(await sendTx(ctx, await build.close(o.token, o.side, o.id, down(q.net, BigInt(o.roomBps ?? 100))), s)), quoted: q.net };
+        },
+        claim: async (token, kind, s = {}) => sendTx(ctx, await build.claim(token, kind), s),
+        /** one transaction: the hook's launch dust plus the creator's first buy; returns the coin */
+        launch: async (l, s = {}) => {
+            const dust = await call((await contracts()).hook, H, "LAUNCH_DUST");
+            const t = {
+                to: a.lever2Factory,
+                value: dust + (l.firstBuy ?? 0n),
+                data: encodeFunctionData({ abi: F, functionName: "launch", args: [l.name, l.symbol, l.metadata, l.minSeedTokens ?? 0n] }),
+                gasPct: 125,
+                label: "The launch",
+            };
+            const sent = await sendTx(ctx, t, s);
+            const ev = parseEventLogs({ abi: F, logs: sent.receipt.logs.filter((x) => isAddressEqual(x.address, a.lever2Factory)) }).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 };
+        },
+    };
+}