@pickhooks/sdk 0.0.0-stage → 0.2.0

package/dist/coins.d.ts

@@ -0,0 +1,217 @@
+import { type Address, type Hex } from "viem";
+import { type Picked, type R, type X } from "./coin-rules.js";
+import { type Ctx, type SendOptions, type Sent, type TxRequest } from "./tx.js";
+/**
+ * Coins with their rules in the coin (pickhooks' main launches): v1 (32 rules, factory 0xecED…54D8) and v2 (40 rules,
+ * factory 0x23cC…B24F, every launch since 04.10.2026, also find the dev and CZ mode coins). The coin checks its rules
+ * on every transfer; it trades in a PancakeSwap V3 pool of 1 % plus a V2 pair, so any router can trade it. check() runs
+ * the transfer of a trade in an eth_call and names the rule that would refuse it, before anyone signs.
+ */
+export type RuleCoinVersion = 1 | 2;
+export type CoinRule = {
+    kind: number;
+    name: string;
+    /** the rule with this coin's numbers, as a sentence */
+    text: string;
+    scanner: "green" | "yellow" | "red";
+    /** unix time the rule ends (0: never) */
+    until: number;
+    /** v2: bought off, voted off, or (sells at) reached its target, or past its end time */
+    ended: boolean;
+};
+export type RuleCoin = {
+    token: Address;
+    version: RuleCoinVersion;
+    name: string;
+    symbol: string;
+    metadata: string;
+    creator: Address;
+    /** the PancakeSwap V3 pool (1 %) and the V2 pair */
+    pool: Address;
+    pair: Address;
+    start: number;
+    rules: CoinRule[];
+    scanner: "green" | "yellow" | "red";
+    /** the token's Rules struct (and for v2 its Extras), for coin-rules' helpers */
+    raw: R;
+    extras: X | null;
+    holders: number;
+    buys: number;
+    sells: number;
+    /** share of the curve sold, basis points */
+    soldBps: number;
+    jackpotPot: bigint;
+    jackpotLast: Address;
+    jackpotTime: number;
+    rewardsPot: bigint;
+    /** BNB per coin at the V3 pool's price, and the market cap in BNB */
+    priceBnb: number;
+    mcapBnb: number;
+    chainNow: number;
+};
+export type RuleCheck = {
+    ok: true;
+} | {
+    ok: false;
+    kind: number;
+    name: string;
+    text: string;
+};
+export type RuleLaunch = {
+    name: string;
+    symbol: string;
+    /** a link to the coin's metadata JSON (name, symbol, description, image, website, twitter, telegram) */
+    metadata: string;
+    /** up to eight rules of the catalog (coin-rules RULES): { id, values, endsAfter? } */
+    rules: Picked[];
+    /** the creator's first buy, BNB wei */
+    devBuy?: bigint;
+    /** share of the creator side the creator keeps (default 10000); the rest buys back and burns $hooks */
+    keepBps?: number;
+    /** hooks rules burn $hooks at launch: bought with BNB inside the launch (default), or the creator's own $hooks */
+    payBurnIn?: "bnb" | "hooks";
+    salt?: Hex;
+};
+/** A rule's sentence for a refusal: its name and the rule with the coin's numbers. */
+export declare function ruleText(kind: number, rules?: R | null, extras?: X | null): {
+    name: string;
+    text: string;
+};
+export declare function coinsModule(ctx: Ctx): {
+    v1Factory: `0x${string}`;
+    v2Factory: `0x${string}`;
+    versionOf: (token: Address) => Promise<RuleCoinVersion | null>;
+    count: (version?: RuleCoinVersion) => Promise<number>;
+    coins: (o?: {
+        version?: RuleCoinVersion;
+        limit?: number;
+        offset?: number;
+    }) => Promise<RuleCoin[]>;
+    coin: (token: Address) => Promise<RuleCoin | null>;
+    terms: () => Promise<{
+        hooksBurn: bigint;
+        creatorBps: number;
+        seedBnb: bigint;
+        hooks: Address;
+        voteBox: Address;
+        arena: Address;
+        floorVault: Address;
+        payrollBox: Address;
+        locker: Address;
+    }>;
+    extrasOf: (token: Address, mask: bigint) => Promise<X>;
+    check: (c: {
+        token: Address;
+        side: "buy" | "sell" | "send";
+        wallet: Address;
+        amount: bigint;
+        to?: Address;
+    }) => Promise<RuleCheck>;
+    quote: (q: {
+        token: Address;
+        side: "buy" | "sell";
+        amount: bigint;
+        wallet?: Address;
+    }) => Promise<{
+        amountOut: bigint;
+    }>;
+    estimateBuy: (token: Address, bnbIn: bigint) => Promise<bigint>;
+    burnFor: (mask: bigint) => Promise<{
+        hooks: bigint;
+        bnb: bigint;
+    }>;
+    build: {
+        buy: (b: {
+            token: Address;
+            bnbIn: bigint;
+            minOut: bigint;
+            recipient: Address;
+            deadline?: bigint;
+        }) => TxRequest;
+        sell: (x: {
+            token: Address;
+            amount: bigint;
+            minOut: bigint;
+            recipient: Address;
+            deadline?: bigint;
+        }) => TxRequest;
+        /** jackpot wins and buyer rewards the coin owes the caller */
+        claim: (token: Address) => Promise<TxRequest>;
+        settleJackpot: (token: Address) => Promise<TxRequest>;
+        /** the creator takes back rewards it paid in and nobody earned */
+        withdrawRewards: (token: Address, wei: bigint) => Promise<TxRequest>;
+        /** anyone: collects the coin's trading fees from its locked position (creator, pot, platform; coins burned or into the pair) */
+        collect: (token: Address) => Promise<TxRequest>;
+        /** v2: buys a listed rule off (half to the creator, half burns $hooks); the price is the coin's buyoutPrice(kind) */
+        buyout: (token: Address, kind: number) => Promise<TxRequest>;
+        /** v2: moves the milestone level and sells at along without a trade (anyone) */
+        poke: (token: Address) => Promise<TxRequest>;
+        /** v2 dead man: the creator says it is still here; release: anyone burns the bag of a quiet creator */
+        alive: (token: Address) => Promise<TxRequest>;
+        release: (token: Address) => Promise<TxRequest>;
+        fundPayroll: (token: Address, wei: bigint) => Promise<TxRequest>;
+        payrollClaim: (token: Address) => Promise<TxRequest>;
+        payShift: (token: Address) => Promise<TxRequest>;
+        floorDefend: (token: Address) => Promise<TxRequest>;
+        duelClose: (id: bigint) => Promise<TxRequest>;
+        duelSettle: (id: bigint) => Promise<TxRequest>;
+        duelRefund: (id: bigint) => Promise<TxRequest>;
+        /** votes move coins into the vote box: approve the coin to the box first (terms().voteBox) */
+        voteStart: (token: Address, kind: number, amount: bigint) => Promise<TxRequest>;
+        voteCast: (token: Address, kind: number, amount: bigint, yes: boolean) => Promise<TxRequest>;
+        voteFinish: (token: Address, kind: number) => Promise<TxRequest>;
+        voteWithdraw: (token: Address, kind: number, round: bigint) => Promise<TxRequest>;
+    };
+    buy: (b: {
+        token: Address;
+        bnbIn: bigint;
+        slippageBps?: number;
+        minOut?: bigint;
+        deadline?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        quoted: bigint;
+        minOut: bigint;
+        amountOut: bigint;
+    }>;
+    sell: (x: {
+        token: Address;
+        amount: bigint;
+        slippageBps?: number;
+        minOut?: bigint;
+        deadline?: bigint;
+    }, s?: SendOptions) => Promise<Sent & {
+        quoted: bigint;
+        minOut: bigint;
+    }>;
+    launch: (l: RuleLaunch, s?: SendOptions) => Promise<Sent & {
+        token: Address;
+        burned: bigint;
+        pots: Sent[];
+    }>;
+    fundPot: (token: Address, pot: "jackpot" | "rewards", wei: bigint, s?: SendOptions) => Promise<Sent>;
+    /** a wallet's jackpot wins and buyer rewards in a coin, and its counters there */
+    wallet: (token: Address, who: Address) => Promise<{
+        balance: bigint;
+        owed: bigint;
+        buys: number;
+        lastBuy: number;
+        lastTrade: number;
+        jailUntil: number;
+    }>;
+    /** what collect() would book now: BNB fees and coins burned (simulated) */
+    pendingFees: (token: Address) => Promise<{
+        bnb: bigint;
+        burned: bigint;
+    }>;
+    claim: (token: Address, s?: SendOptions) => Promise<Sent>;
+    settleJackpot: (token: Address, s?: SendOptions) => Promise<Sent>;
+    withdrawRewards: (token: Address, wei: bigint, s?: SendOptions) => Promise<Sent>;
+    collect: (token: Address, s?: SendOptions) => Promise<Sent>;
+    buyout: (token: Address, kind: number, s?: SendOptions) => Promise<Sent>;
+    poke: (token: Address, s?: SendOptions) => Promise<Sent>;
+    alive: (token: Address, s?: SendOptions) => Promise<Sent>;
+    release: (token: Address, s?: SendOptions) => Promise<Sent>;
+    /** the coin's PancakeSwap V2 pair against WBNB */
+    pairOf: (token: Address) => Promise<`0x${string}`>;
+};
+export type CoinsModule = ReturnType<typeof coinsModule>;