@pickhooks/sdk 0.0.0-stage → 0.2.0

package/dist/lever.d.ts

@@ -0,0 +1,391 @@
+import { type Address } from "viem";
+import { type PoolKey } from "./infinity.js";
+import { type Ctx, type SendOptions, type Sent, type TxRequest } from "./tx.js";
+export type LeverMarket = {
+    /** free coins and the curve's BNB with its virtual part */
+    q: bigint;
+    r: bigint;
+    v: bigint;
+    /** BNB the open longs borrowed */
+    debt: bigint;
+    locked: bigint;
+    supply: bigint;
+    creatorOwed: bigint;
+    platformOwed: bigint;
+    refunds: bigint;
+    start: number;
+    creator: Address;
+    creatorBps: number;
+};
+export type LeverCoin = {
+    token: Address;
+    name: string;
+    symbol: string;
+    metadata: string;
+    market: LeverMarket;
+    priceBnb: number;
+    mcapBnb: number;
+    positions: number;
+};
+export type LeverPosition = {
+    id: bigint;
+    owner: Address;
+    tokens: bigint;
+    debt: bigint;
+    margin: bigint;
+    opened: number;
+    trigger: bigint;
+    closeQuote: bigint | null;
+};
+/** lever v1 */
+export declare function leverModule(ctx: Ctx): {
+    factory: `0x${string}`;
+    contracts: () => Promise<{
+        hook: Address;
+        router: Address;
+        engine: Address;
+    }>;
+    count: () => Promise<number>;
+    coins: (o?: {
+        limit?: number;
+        offset?: number;
+    }) => Promise<LeverCoin[]>;
+    coin: (token: Address) => Promise<LeverCoin | null>;
+    isCoin: (token: Address) => Promise<boolean>;
+    positions: (token: Address) => Promise<LeverPosition[]>;
+    quoteBuy: (token: Address, bnbIn: bigint) => Promise<bigint>;
+    quoteSell: (token: Address, amount: bigint) => Promise<{
+        out: bigint;
+        liquidations: number;
+    }>;
+    quoteOpen: (token: Address, gross: bigint, leverage: number) => Promise<{
+        tokens: bigint;
+        debt: bigint;
+        fee: bigint;
+        trigger: bigint;
+    }>;
+    refundOwed: (token: Address, who: Address) => Promise<bigint>;
+    poolKey: (token: Address) => Promise<PoolKey>;
+    build: {
+        buy: (token: Address, bnbIn: bigint, minOut: bigint) => Promise<TxRequest>;
+        /** needs the coin approved to the lever router */
+        sell: (token: Address, amount: bigint, minOut: bigint) => Promise<TxRequest>;
+        openLong: (token: Address, gross: bigint, leverage: number, minTokens: bigint) => Promise<TxRequest>;
+        closeLong: (token: Address, id: bigint, minBnb: bigint) => Promise<TxRequest>;
+        /** anyone, after 24 hours: the payout waits for the owner as a refund */
+        closeExpired: (token: Address, id: bigint) => Promise<TxRequest>;
+        claimRefund: (token: Address) => Promise<TxRequest>;
+        claimCreator: (token: Address) => Promise<TxRequest>;
+    };
+    buy: (b: {
+        token: Address;
+        bnbIn: bigint;
+        slippageBps?: number;
+    }, s?: SendOptions) => Promise<{
+        quoted: bigint;
+        hash: import("viem").Hex;
+        receipt: import("viem").TransactionReceipt;
+    }>;
+    sell: (x: {
+        token: Address;
+        amount: bigint;
+        slippageBps?: number;
+    }, s?: SendOptions) => Promise<{
+        quoted: bigint;
+        liquidations: number;
+        hash: import("viem").Hex;
+        receipt: import("viem").TransactionReceipt;
+    }>;
+    /** gross = margin plus the open fee; the long gets at least the quote less roomBps (default 100) coins */
+    openLong: (o: {
+        token: Address;
+        gross: bigint;
+        leverage: number;
+        roomBps?: number;
+    }, s?: SendOptions) => Promise<Sent & {
+        id: bigint;
+        tokens: bigint;
+    }>;
+    closeLong: (o: {
+        token: Address;
+        id: bigint;
+        roomBps?: number;
+    }, s?: SendOptions) => Promise<{
+        quoted: bigint;
+        hash: import("viem").Hex;
+        receipt: import("viem").TransactionReceipt;
+    }>;
+    closeExpired: (token: Address, id: bigint, s?: SendOptions) => Promise<Sent>;
+    claimRefund: (token: Address, s?: SendOptions) => Promise<Sent>;
+    claimCreator: (token: Address, s?: SendOptions) => Promise<Sent>;
+    /** one transaction: the coin and the creator's first buy; returns the coin */
+    launch: (l: {
+        name: string;
+        symbol: string;
+        metadata: string;
+        firstBuy?: bigint;
+        minSeedTokens?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        token: Address;
+    }>;
+};
+export type Lever2State = {
+    q: bigint;
+    r: bigint;
+    /** BNB per coin times 1e18 */
+    price: bigint;
+    curveBnb: bigint;
+    longRoom: bigint;
+    shortRoom: bigint;
+    debt: bigint;
+    locked: bigint;
+    lent: bigint;
+    notional: bigint;
+    longs: bigint;
+    shorts: bigint;
+    tS: number;
+    tB: number;
+    /** coins a sale may take before the curve's start (the longs' coins already off) */
+    sellRoom: bigint;
+};
+export type Lever2Row = {
+    id: bigint;
+    owner: Address;
+    opened: number;
+    margin: bigint;
+    borrowed: bigint;
+    amount: bigint;
+    trigger: bigint;
+    triggerPrice: bigint;
+    closeNet: bigint;
+    expired: boolean;
+};
+/** Lens OpenQuote; reason 0 ok, 1 leverage, 2 margin, 3 no slot, 4 side full, 5 unsafe self, 6 unsafe other, 7 unknown, 8 pushed */
+export type Lever2OpenQuote = {
+    reason: number;
+    margin: bigint;
+    /** long: BNB debt; short: notional (what its coins sell for) */
+    borrowed: bigint;
+    fee: bigint;
+    /** long: coins bought; short: coins borrowed and sold */
+    amount: bigint;
+    trigger: bigint;
+    triggerPrice: bigint;
+    entryPrice: bigint;
+    curveBnb: bigint;
+    room: bigint;
+    liquidations: bigint;
+    /** a full side: the position of this side the open closes first to take its slot (0: none) */
+    bump: bigint;
+    /** reason 3: the margin from which a new position takes the smallest one's slot */
+    bumpFrom: bigint;
+};
+export type Lever2CloseQuote = {
+    net: bigint;
+    gross: bigint;
+    fundingFee: bigint;
+    closeFee: bigint;
+    liquidations: bigint;
+    pushed: boolean;
+};
+/** Lens reasons as sentences */
+export declare const LEVER2_REASON: Record<number, string>;
+declare const KIND: {
+    readonly creator: 3;
+    readonly refund: 4;
+    readonly platform: 5;
+};
+export declare function lever2Module(ctx: Ctx): {
+    factory: `0x${string}`;
+    contracts: () => Promise<{
+        hook: Address;
+        engine: Address;
+        lens: Address;
+    }>;
+    count: () => Promise<number>;
+    coins: (o?: {
+        limit?: number;
+        offset?: number;
+    }) => Promise<{
+        token: `0x${string}`;
+        name: string;
+        symbol: string;
+        metadata: string;
+        supply: bigint;
+        state: {
+            tS: number;
+            tB: number;
+            q: bigint;
+            r: bigint;
+            /** BNB per coin times 1e18 */
+            price: bigint;
+            curveBnb: bigint;
+            longRoom: bigint;
+            shortRoom: bigint;
+            debt: bigint;
+            locked: bigint;
+            lent: bigint;
+            notional: bigint;
+            longs: bigint;
+            shorts: bigint;
+            /** coins a sale may take before the curve's start (the longs' coins already off) */
+            sellRoom: bigint;
+        };
+        market: {
+            start: number;
+            creatorBps: number;
+            creator: Address;
+            liquidity: bigint;
+            v: bigint;
+            debt: bigint;
+            creatorOwed: bigint;
+            platformOwed: bigint;
+            refunds: bigint;
+        };
+        key: PoolKey;
+        id: `0x${string}`;
+        priceBnb: number;
+        mcapBnb: number;
+    }[]>;
+    coin: (token: Address) => Promise<{
+        token: `0x${string}`;
+        name: string;
+        symbol: string;
+        metadata: string;
+        supply: bigint;
+        state: {
+            tS: number;
+            tB: number;
+            q: bigint;
+            r: bigint;
+            /** BNB per coin times 1e18 */
+            price: bigint;
+            curveBnb: bigint;
+            longRoom: bigint;
+            shortRoom: bigint;
+            debt: bigint;
+            locked: bigint;
+            lent: bigint;
+            notional: bigint;
+            longs: bigint;
+            shorts: bigint;
+            /** coins a sale may take before the curve's start (the longs' coins already off) */
+            sellRoom: bigint;
+        };
+        market: {
+            start: number;
+            creatorBps: number;
+            creator: Address;
+            liquidity: bigint;
+            v: bigint;
+            debt: bigint;
+            creatorOwed: bigint;
+            platformOwed: bigint;
+            refunds: bigint;
+        };
+        key: PoolKey;
+        id: `0x${string}`;
+        priceBnb: number;
+        mcapBnb: number;
+    } | null>;
+    isCoin: (token: Address) => Promise<boolean>;
+    poolKey: (token: Address) => Promise<PoolKey>;
+    positions: (token: Address) => Promise<{
+        longs: Lever2Row[];
+        shorts: Lever2Row[];
+    }>;
+    quoteOpen: (token: Address, side: "long" | "short", gross: bigint, leverage: number) => Promise<Lever2OpenQuote & {
+        text: string;
+    }>;
+    quoteClose: (token: Address, side: "long" | "short", id: bigint) => Promise<Lever2CloseQuote>;
+    quote: (q: {
+        token: Address;
+        side: "buy" | "sell";
+        amount: bigint;
+        from?: Address;
+    }) => Promise<{
+        amountOut: bigint;
+    }>;
+    sellPlan: (token: Address, amount: bigint) => Promise<{
+        legs: bigint[];
+        closes: number;
+        fits: boolean;
+        sellRoom: bigint;
+    }>;
+    refundOwed: (token: Address, who: Address) => Promise<bigint>;
+    /** the gross (margin plus the open fee) for at least `margin` at `leverage`, rounded up to a millionth of a BNB */
+    grossForMargin: (margin: bigint, leverage: number) => bigint;
+    build: {
+        buy: (key: PoolKey, bnbIn: bigint, minOut: bigint) => TxRequest;
+        /** legs from sellPlan(); the router pulls the coins with Permit2 */
+        sell: (key: PoolKey, legs: readonly bigint[], minOut: bigint) => TxRequest;
+        openLong: (token: Address, gross: bigint, leverage: number, minTokens: bigint) => Promise<TxRequest>;
+        openShort: (token: Address, gross: bigint, leverage: number, maxCoins: bigint) => Promise<TxRequest>;
+        close: (token: Address, side: "long" | "short", id: bigint, minBnb: bigint) => Promise<TxRequest>;
+        /** the pad's keeper after 24 hours, anyone 24 hours later; the payout waits for the owner as a refund */
+        closeExpired: (token: Address, side: "long" | "short", id: bigint, minBnb: bigint) => Promise<TxRequest>;
+        /** refund: the caller's refunds; creator: the creator's fees; platform: the pad's share (anyone may send it) */
+        claim: (token: Address, kind: keyof typeof KIND) => Promise<TxRequest>;
+    };
+    buy: (b: {
+        token: Address;
+        bnbIn: bigint;
+        slippageBps?: number;
+    }, s?: SendOptions) => Promise<{
+        quoted: bigint;
+        hash: import("viem").Hex;
+        receipt: import("viem").TransactionReceipt;
+    }>;
+    /** sells in one or two legs (sellPlan); the minimum is the pool's quote of the first leg plus the rest, less slippage */
+    sell: (x: {
+        token: Address;
+        amount: bigint;
+        slippageBps?: number;
+        minOut?: bigint;
+    }, s?: SendOptions) => Promise<{
+        quoted: bigint;
+        plan: {
+            legs: bigint[];
+            closes: number;
+            fits: boolean;
+            sellRoom: bigint;
+        };
+        hash: import("viem").Hex;
+        receipt: import("viem").TransactionReceipt;
+    }>;
+    /** opens a long or short at the Lens quote with roomBps (default 100) on its bound; a refusing reason throws its sentence */
+    open: (o: {
+        token: Address;
+        side: "long" | "short";
+        gross: bigint;
+        leverage: number;
+        roomBps?: number;
+    }, s?: SendOptions) => Promise<Sent & {
+        id: bigint;
+        quote: Lever2OpenQuote;
+    }>;
+    close: (o: {
+        token: Address;
+        side: "long" | "short";
+        id: bigint;
+        roomBps?: number;
+    }, s?: SendOptions) => Promise<{
+        quoted: bigint;
+        hash: import("viem").Hex;
+        receipt: import("viem").TransactionReceipt;
+    }>;
+    claim: (token: Address, kind: keyof typeof KIND, s?: SendOptions) => Promise<Sent>;
+    /** one transaction: the hook's launch dust plus the creator's first buy; returns the coin */
+    launch: (l: {
+        name: string;
+        symbol: string;
+        metadata: string;
+        firstBuy?: bigint;
+        minSeedTokens?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        token: Address;
+    }>;
+};
+export type LeverModule = ReturnType<typeof leverModule>;
+export type Lever2Module = ReturnType<typeof lever2Module>;
+export {};