@pickhooks/sdk 0.2.0 → 0.5.0

package/dist/v2.js

@@ -0,0 +1,61 @@
+import { encodeFunctionData, parseAbi } from "viem";
+import { deadlineIn } from "./tx.js";
+/**
+ * PancakeSwap V2: every sticky coin (and every rules coin since 03.10.) has a V2 pair next to its V3 pool, at the same
+ * start price. A dark launch puts the whole round's BNB into that pair, so right after the birth the pair is the venue
+ * with the BNB and the V3 curve holds only coins above the price: a sell into V3 would get almost nothing ("SPL").
+ * Terminals route to the better pool by themselves; the SDK quotes both and picks the better one (sticky.quote).
+ */
+export const v2RouterAbi = parseAbi([
+    "function getAmountsOut(uint256 amountIn, address[] path) view returns (uint256[] amounts)",
+    "function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline) payable",
+    "function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)",
+]);
+/** What a trade gets in the V2 pair, from the router (reverts when the coin has no pair or the pair is empty). */
+export async function v2Quote(ctx, q) {
+    const path = q.side === "buy" ? [ctx.a.wbnb, q.token] : [q.token, ctx.a.wbnb];
+    const amounts = (await ctx.pub.readContract({ address: ctx.a.v2Router, abi: v2RouterAbi, functionName: "getAmountsOut", args: [q.amount, path] }));
+    return amounts[amounts.length - 1];
+}
+/** A buy through the V2 router, BNB in. */
+export function buildV2Buy(a, b) {
+    return {
+        to: a.v2Router,
+        value: b.bnbIn,
+        data: encodeFunctionData({ abi: v2RouterAbi, functionName: "swapExactETHForTokensSupportingFeeOnTransferTokens", args: [b.minOut, [a.wbnb, b.token], b.recipient, b.deadline ?? deadlineIn()] }),
+        gasPct: b.gasPct,
+        label: "The buy",
+    };
+}
+/** A sell through the V2 router for native BNB. Needs the coin approved to the V2 router. */
+export function buildV2Sell(a, s) {
+    return {
+        to: a.v2Router,
+        value: 0n,
+        data: encodeFunctionData({ abi: v2RouterAbi, functionName: "swapExactTokensForETHSupportingFeeOnTransferTokens", args: [s.amount, s.minOut, [s.token, a.wbnb], s.recipient, s.deadline ?? deadlineIn()] }),
+        gasPct: s.gasPct,
+        label: "The sell",
+    };
+}
+/**
+ * The better of the two venues for this trade: the V3 pool (quoter) and the V2 pair (router). A venue that cannot
+ * quote (no pair, no BNB below the price, a refusing rule) counts as nothing; `errors` keeps what each one said.
+ */
+export async function bestVenue(ctx, quotes) {
+    const errors = {};
+    const [v3, v2] = await Promise.all([
+        quotes.v3().catch((e) => {
+            errors.v3 = e;
+            return null;
+        }),
+        quotes.v2().catch((e) => {
+            errors.v2 = e;
+            return null;
+        }),
+    ]);
+    void ctx;
+    if (v3 === null && v2 === null)
+        return { venue: "v3", amountOut: 0n, v3, v2, errors };
+    const venue = (v2 ?? 0n) > (v3 ?? 0n) ? "v2" : "v3";
+    return { venue, amountOut: venue === "v2" ? v2 : v3, v3, v2, errors };
+}

package/dist/wallet.d.ts

@@ -0,0 +1,80 @@
+import { type Address } from "viem";
+import type { AgentLock, AgentsModule } from "./agents.js";
+import type { AnyModule, Earnings } from "./any.js";
+import type { CoinsModule } from "./coins.js";
+import type { DipFloor, DipsModule } from "./dips.js";
+import type { Lever2Module } from "./lever.js";
+import type { CallsModule, PoolsModule } from "./pools.js";
+import type { StickyModule } from "./sticky.js";
+import type { Ctx } from "./tx.js";
+import type { WatchMode } from "./watch.js";
+/**
+ * One address in: everything it holds on pickhooks, what it can sell right now, and what it can claim.
+ *
+ *   const w = await ph.wallet(address);
+ *   w.coins            // every pickhooks coin it holds, with mode, price, value and what is sellable now
+ *   w.claims           // BNB owed by the hooks (hook any coin, pools, curve calls, agents)
+ *   w.locks            // coins locked at the agents desk (vetoes, firing)
+ *   w.floors           // dip bid floors it holds
+ */
+export type WalletCoin = {
+    token: Address;
+    mode: WatchMode;
+    name: string;
+    symbol: string;
+    balance: bigint;
+    /** what a sell of the whole balance would be allowed right now: the balance, less (sticky: unlocked lots), or 0 with the reason */
+    sellable: bigint;
+    /** why not everything is sellable (a rule's sentence), or null */
+    refused: string | null;
+    priceBnb: number;
+    /** balance x price, in BNB */
+    valueBnb: number;
+    page: string;
+};
+export type WalletView = {
+    address: Address;
+    bnb: bigint;
+    coins: WalletCoin[];
+    /** the coins' value together, BNB */
+    valueBnb: number;
+    claims: {
+        /** hook any coin: recapture shares, opener and partner shares, router credits */
+        any: Earnings | null;
+        /** pools and curve calls: jackpot wins, rewards, a creator's share */
+        pools: bigint;
+        calls: bigint;
+        /** agents: jackpot wins, rewards, a creator's share */
+        agents: bigint;
+        /** all of the above in BNB (router credits counted as claimable) */
+        totalBnb: bigint;
+    };
+    /** coins locked at the agents desk, per agent coin */
+    locks: ({
+        token: Address;
+        symbol: string;
+    } & AgentLock)[];
+    floors: DipFloor[];
+    /** factories the scan covered and how many coins each has (the newest `limit` per factory are scanned) */
+    scanned: {
+        mode: WatchMode;
+        count: number;
+        scanned: number;
+    }[];
+};
+type Mods = {
+    sticky: StickyModule;
+    sticky2: StickyModule;
+    coins: CoinsModule;
+    pools: PoolsModule;
+    calls: CallsModule;
+    lever: Lever2Module;
+    agents: AgentsModule;
+    any: AnyModule;
+    dips: DipsModule;
+};
+export declare function walletModule(ctx: Ctx, mods: Mods): (who: Address, o?: {
+    limit?: number;
+}) => Promise<WalletView>;
+export type WalletModule = ReturnType<typeof walletModule>;
+export {};

package/dist/wallet.js

@@ -0,0 +1,115 @@
+import { formatEther, isAddressEqual } from "viem";
+import { agentsFactoryAbi } from "./abis/agents.js";
+import { callsFactoryAbi } from "./abis/calls.js";
+import { erc20Abi } from "./abis/common.js";
+import { lever2FactoryAbi } from "./abis/lever2.js";
+import { poolsFactoryAbi } from "./abis/pools.js";
+import { stickyFactoryAbi } from "./abis/sticky.js";
+import { sticky2FactoryAbi } from "./abis/sticky2.js";
+import { v1FactoryAbi } from "./abis/v1.js";
+import { v2FactoryAbi } from "./abis/v2.js";
+import { ZERO_ADDRESS } from "./addresses.js";
+export function walletModule(ctx, mods) {
+    const { pub, a } = ctx;
+    const page = (mode, token) => {
+        const path = { sticky: "s", sticky2: "s", rules: "c", "rules-v1": "c", pools: "h", calls: "z", lever: "l", agents: "a", any: "any" }[mode];
+        return `${ctx.site}/${path}/${token}`;
+    };
+    const factories = [
+        { mode: "sticky", address: a.stickyFactory, abi: stickyFactoryAbi },
+        { mode: "sticky2", address: a.sticky2Factory, abi: sticky2FactoryAbi },
+        { mode: "rules", address: a.coinsV2Factory, abi: v2FactoryAbi },
+        { mode: "rules-v1", address: a.coinsV1Factory, abi: v1FactoryAbi },
+        { mode: "pools", address: a.poolsFactory, abi: poolsFactoryAbi },
+        { mode: "calls", address: a.callsFactory, abi: callsFactoryAbi },
+        { mode: "lever", address: a.lever2Factory, abi: lever2FactoryAbi },
+        { mode: "agents", address: a.agentsFactory, abi: agentsFactoryAbi },
+    ];
+    /** The newest `limit` coins of every factory. */
+    async function tokens(limit) {
+        const live = factories.filter((f) => !isAddressEqual(f.address, ZERO_ADDRESS));
+        const counts = await pub.multicall({ contracts: live.map((f) => ({ address: f.address, abi: f.abi, functionName: "coinCount" })), allowFailure: true });
+        const calls = [];
+        const owners = [];
+        const scanned = [];
+        live.forEach((f, i) => {
+            const n = counts[i].status === "success" ? Number(counts[i].result) : 0;
+            const from = Math.max(0, n - limit);
+            scanned.push({ mode: f.mode, count: n, scanned: n - from });
+            for (let j = n - 1; j >= from; j--) {
+                calls.push({ address: f.address, abi: f.abi, functionName: "coins", args: [BigInt(j)] });
+                owners.push(f.mode);
+            }
+        });
+        if (!calls.length)
+            return { list: [], scanned };
+        const res = await pub.multicall({ contracts: calls, allowFailure: true });
+        const list = [];
+        res.forEach((r, i) => {
+            if (r.status === "success")
+                list.push({ mode: owners[i], token: r.result });
+        });
+        return { list, scanned };
+    }
+    /** A held coin's name, symbol, price and what is sellable now, by mode. */
+    async function detail(mode, token, who, balance) {
+        const refusedOf = (r) => (r.ok ? null : (r.text ?? "The coin refused a sell right now."));
+        if (mode === "sticky" || mode === "sticky2") {
+            const m = mode === "sticky" ? mods.sticky : mods.sticky2;
+            const [c, w] = await Promise.all([m.coin(token), m.wallet(token, who)]);
+            return { name: c?.name ?? "", symbol: c?.symbol ?? "", sellable: w.sellable, refused: w.sellable < balance ? "Part of these coins is still locked by a rule; it unlocks over time." : null, priceBnb: c?.priceBnb ?? 0, valueBnb: (c?.priceBnb ?? 0) * Number(formatEther(balance)) };
+        }
+        if (mode === "rules" || mode === "rules-v1") {
+            const [c, r] = await Promise.all([mods.coins.coin(token), mods.coins.check({ token, side: "sell", wallet: who, amount: balance }).catch(() => ({ ok: false, kind: 0, name: "", text: "The coin could not be asked." }))]);
+            return { name: c?.name ?? "", symbol: c?.symbol ?? "", sellable: r.ok ? balance : 0n, refused: refusedOf(r), priceBnb: c?.priceBnb ?? 0, valueBnb: (c?.priceBnb ?? 0) * Number(formatEther(balance)) };
+        }
+        if (mode === "pools" || mode === "calls" || mode === "agents") {
+            const m = mode === "pools" ? mods.pools : mode === "calls" ? mods.calls : mods.agents;
+            const [c, r] = await Promise.all([m.coin(token), m.check({ token, side: "sell", wallet: who, amount: balance }).catch(() => ({ ok: false, kind: 0, name: "", text: "The pool could not be asked." }))]);
+            return { name: c?.name ?? "", symbol: c?.symbol ?? "", sellable: r.ok ? balance : 0n, refused: refusedOf(r), priceBnb: c?.priceBnb ?? 0, valueBnb: (c?.priceBnb ?? 0) * Number(formatEther(balance)) };
+        }
+        if (mode === "lever") {
+            const c = await mods.lever.coin(token);
+            return { name: c?.name ?? "", symbol: c?.symbol ?? "", sellable: balance, refused: null, priceBnb: c?.priceBnb ?? 0, valueBnb: (c?.priceBnb ?? 0) * Number(formatEther(balance)) };
+        }
+        const r = await pub.multicall({ contracts: [{ address: token, abi: erc20Abi, functionName: "name" }, { address: token, abi: erc20Abi, functionName: "symbol" }], allowFailure: true });
+        return { name: r[0].status === "success" ? String(r[0].result) : "", symbol: r[1].status === "success" ? String(r[1].result) : "", sellable: balance, refused: null, priceBnb: 0, valueBnb: 0 };
+    }
+    /**
+     * Everything a wallet holds on pickhooks: the newest `limit` coins of every factory (default 300) are checked for a
+     * balance, the held ones read in full. Claims and locks come from the hooks and the agents desk, floors from dip bids.
+     */
+    async function wallet(who, o = {}) {
+        const { list, scanned } = await tokens(o.limit ?? 300);
+        const [bnb, balances] = await Promise.all([
+            pub.getBalance({ address: who }),
+            list.length ? pub.multicall({ contracts: list.map((t) => ({ address: t.token, abi: erc20Abi, functionName: "balanceOf", args: [who] })), allowFailure: true }) : [],
+        ]);
+        const held = list.filter((_, i) => balances[i]?.status === "success" && balances[i].result > 0n).map((t, j) => ({ ...t, balance: balances[list.indexOf(t)].result, j }));
+        const coins = await Promise.all(held.map(async (h) => ({ token: h.token, mode: h.mode, balance: h.balance, page: page(h.mode, h.token), ...(await detail(h.mode, h.token, who, h.balance)) })));
+        coins.sort((x, y) => y.valueBnb - x.valueBnb);
+        const agentTokens = list.filter((t) => t.mode === "agents").map((t) => t.token);
+        const [any, pools, calls, agents, lockRows, floors] = await Promise.all([
+            mods.any.earnings(who).catch(() => null),
+            mods.pools.owed(who).catch(() => 0n),
+            mods.calls.owed(who).catch(() => 0n),
+            mods.agents.on ? mods.agents.owed(who).catch(() => 0n) : Promise.resolve(0n),
+            Promise.all(agentTokens.map((t) => mods.agents.locks(t, who).then((l) => ({ token: t, ...l })).catch(() => null))),
+            mods.dips.floorsOf(who).catch(() => []),
+        ]);
+        const locks = lockRows.filter((l) => l !== null && l.amount > 0n);
+        const lockSymbols = locks.length ? await pub.multicall({ contracts: locks.map((l) => ({ address: l.token, abi: erc20Abi, functionName: "symbol" })), allowFailure: true }) : [];
+        const anyBnb = any ? any.owed + any.routerClaimable + any.taxOwed : 0n;
+        return {
+            address: who,
+            bnb,
+            coins,
+            valueBnb: coins.reduce((s, c) => s + c.valueBnb, 0),
+            claims: { any, pools, calls, agents, totalBnb: anyBnb + pools + calls + agents },
+            locks: locks.map((l, i) => ({ ...l, symbol: lockSymbols[i]?.status === "success" ? String(lockSymbols[i].result) : "" })),
+            floors,
+            scanned,
+        };
+    }
+    return wallet;
+}

package/dist/watch.d.ts

@@ -0,0 +1,82 @@
+import { type Address, type Hex } from "viem";
+import type { AgentsModule } from "./agents.js";
+import type { AnyModule } from "./any.js";
+import type { CoinsModule } from "./coins.js";
+import type { CallsModule, PoolsModule } from "./pools.js";
+import type { StickyModule } from "./sticky.js";
+import type { Ctx } from "./tx.js";
+/**
+ * Live events, for terminals and bots: every launch on the pad, every trade of a coin, everything that happens to an
+ * agent coin. Each watcher polls the RPC (HTTP is enough) and returns a function that stops it.
+ *
+ *   const stop = ph.watch.launches((l) => console.log(l.mode, l.symbol, l.token));
+ *   const stop2 = await ph.watch.trades(token, (t) => console.log(t.buy ? "buy" : "sell", t.bnb, t.coins));
+ *   const stop3 = await ph.watch.agent(token, (e) => console.log(e.event, e.args));
+ */
+export type WatchMode = "sticky" | "sticky2" | "rules" | "rules-v1" | "pools" | "calls" | "lever" | "agents" | "any";
+export type WatchedLaunch = {
+    mode: WatchMode;
+    token: Address;
+    creator: Address;
+    /** read from the token when `details` is on (default) */
+    name: string;
+    symbol: string;
+    /** the V3 pool and V2 pair (sticky, rules), the Infinity pool id (pools, calls, lever, agents, any) */
+    pool?: Address;
+    pair?: Address;
+    poolId?: Hex;
+    factory: Address;
+    block: bigint;
+    tx: Hex;
+    /** the raw event as viem decoded it */
+    args: Record<string, unknown>;
+};
+export type WatchedTrade = {
+    token: Address;
+    buy: boolean;
+    /** the trader where the event names one (the hooks do; V3 and V2 name the router's sender and the recipient) */
+    trader: Address | null;
+    /** coins moved (18 decimals), BNB moved (wei); the hooks' events carry the fee or the BNB, the pools' Swap both sides */
+    coins: bigint;
+    bnb: bigint | null;
+    /** the hook's fee in BNB (pools, calls, agents) */
+    fee: bigint | null;
+    /** v3, v2 (PancakeSwap pools of sticky and rules coins), or the hook's event (pools, calls, agents, any) */
+    source: "v3" | "v2" | "hook";
+    block: bigint;
+    tx: Hex;
+};
+export type AgentEvent = {
+    token: Address;
+    /** Proposed, Cancelled, Activated, Vetoed, VetoBacked, FireBacked, PilotFired, PilotHandedOver, Locked, Withdrawn, TreasuryMoved (desk); Burned, LiquidityAdded, FloorFed, Moved, Given, ProgramSet, JackpotWon, RewardEarned, Traded (hook) */
+    event: string;
+    args: Record<string, unknown>;
+    block: bigint;
+    tx: Hex;
+};
+export type WatchOptions = {
+    /** ms between polls (default 3000, about one BNB Chain block) */
+    pollingInterval?: number;
+    /** errors of the poll (an RPC hiccup); default: ignored, the next poll tries again */
+    onError?: (e: Error) => void;
+};
+type Mods = {
+    sticky: StickyModule;
+    sticky2: StickyModule;
+    coins: CoinsModule;
+    pools: PoolsModule;
+    calls: CallsModule;
+    agents: AgentsModule;
+    any: AnyModule;
+};
+export declare function watchModule(ctx: Ctx, mods: Mods): {
+    launches: (cb: (l: WatchedLaunch) => void, o?: WatchOptions & {
+        modes?: WatchMode[];
+        details?: boolean;
+    }) => () => void;
+    trades: (token: Address, cb: (t: WatchedTrade) => void, o?: WatchOptions) => Promise<() => void>;
+    agent: (token: Address, cb: (e: AgentEvent) => void, o?: WatchOptions) => Promise<() => void>;
+    modes: WatchMode[];
+};
+export type WatchModule = ReturnType<typeof watchModule>;
+export {};

package/dist/watch.js

@@ -0,0 +1,194 @@
+import { isAddressEqual, parseAbi } from "viem";
+import { agentsDeskAbi, agentsFactoryAbi, agentsHookAbi } from "./abis/agents.js";
+import { any3FactoryAbi, any3HookAbi } from "./abis/any3.js";
+import { callsFactoryAbi, callsHookAbi } from "./abis/calls.js";
+import { lever2FactoryAbi } from "./abis/lever2.js";
+import { poolsFactoryAbi, poolsHookAbi } from "./abis/pools.js";
+import { stickyFactoryAbi } from "./abis/sticky.js";
+import { sticky2FactoryAbi } from "./abis/sticky2.js";
+import { v1FactoryAbi } from "./abis/v1.js";
+import { v2FactoryAbi } from "./abis/v2.js";
+import { ZERO_ADDRESS } from "./addresses.js";
+import { PickhooksError } from "./errors.js";
+const v3SwapAbi = parseAbi([
+    "event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint128 protocolFeesToken0, uint128 protocolFeesToken1)",
+]);
+const v2SwapAbi = parseAbi(["event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to)"]);
+const PLAIN = parseAbi(["function name() view returns (string)", "function symbol() view returns (string)"]);
+export function watchModule(ctx, mods) {
+    const { pub, a } = ctx;
+    const abs = (v) => (v < 0n ? -v : v);
+    const factories = [
+        { mode: "sticky", address: a.stickyFactory, abi: stickyFactoryAbi, event: "Launched" },
+        { mode: "sticky2", address: a.sticky2Factory, abi: sticky2FactoryAbi, event: "Launched" },
+        { mode: "rules", address: a.coinsV2Factory, abi: v2FactoryAbi, event: "Launched" },
+        { mode: "rules-v1", address: a.coinsV1Factory, abi: v1FactoryAbi, event: "Launched" },
+        { mode: "pools", address: a.poolsFactory, abi: poolsFactoryAbi, event: "Launched" },
+        { mode: "calls", address: a.callsFactory, abi: callsFactoryAbi, event: "Launched" },
+        { mode: "lever", address: a.lever2Factory, abi: lever2FactoryAbi, event: "Launched" },
+        { mode: "agents", address: a.agentsFactory, abi: agentsFactoryAbi, event: "Launched" },
+        { mode: "any", address: a.anyFactory, abi: any3FactoryAbi, event: "Opened" },
+    ];
+    const watch = (p, o) => pub.watchContractEvent({
+        address: p.address,
+        abi: p.abi,
+        eventName: p.eventName,
+        args: p.args,
+        onLogs: p.onLogs,
+        onError: o.onError ?? (() => undefined),
+        poll: true,
+        pollingInterval: o.pollingInterval ?? 3000,
+        strict: false,
+    });
+    /**
+     * Every new coin on the pad (and every new hook any coin pool), as it is mined. `modes` narrows it; `details` reads
+     * name and symbol from the token (one multicall per batch).
+     */
+    function launches(cb, o = {}) {
+        const wanted = factories.filter((f) => !isAddressEqual(f.address, ZERO_ADDRESS) && (!o.modes || o.modes.includes(f.mode)));
+        const stops = wanted.map((f) => watch({
+            address: f.address,
+            abi: f.abi,
+            eventName: f.event,
+            onLogs: async (logs) => {
+                const rows = logs.map((log) => {
+                    const args = (log.args ?? {});
+                    return {
+                        mode: f.mode,
+                        token: args.token,
+                        creator: (args.creator ?? args.opener),
+                        name: "",
+                        symbol: "",
+                        pool: args.pool,
+                        pair: args.pair,
+                        poolId: (args.poolId ?? args.id),
+                        factory: f.address,
+                        block: log.blockNumber ?? 0n,
+                        tx: log.transactionHash ?? "0x",
+                        args,
+                    };
+                });
+                if (o.details !== false && rows.length) {
+                    const meta = await pub
+                        .multicall({ contracts: rows.flatMap((r) => [{ address: r.token, abi: PLAIN, functionName: "name" }, { address: r.token, abi: PLAIN, functionName: "symbol" }]), allowFailure: true })
+                        .catch(() => null);
+                    if (meta)
+                        rows.forEach((r, i) => Object.assign(r, { name: meta[i * 2].status === "success" ? String(meta[i * 2].result) : "", symbol: meta[i * 2 + 1].status === "success" ? String(meta[i * 2 + 1].result) : "" }));
+                }
+                for (const r of rows)
+                    cb(r);
+            },
+        }, o));
+        return () => stops.forEach((s) => s());
+    }
+    /** The hooks' Traded(id, trader, buy, tokens, fee|bnb) for a set of pool ids on one hook. */
+    const hookTrades = (token, hook, abi, ids, bnbField, cb, o) => watch({
+        address: hook,
+        abi,
+        eventName: "Traded",
+        args: { id: ids },
+        onLogs: (logs) => {
+            for (const log of logs) {
+                const g = (log.args ?? {});
+                cb({
+                    token,
+                    buy: Boolean(g.buy),
+                    trader: g.trader ?? null,
+                    coins: g.tokens,
+                    bnb: bnbField === "bnb" ? g.bnb : null,
+                    fee: bnbField === "fee" ? g.fee : null,
+                    source: "hook",
+                    block: log.blockNumber ?? 0n,
+                    tx: log.transactionHash ?? "0x",
+                });
+            }
+        },
+    }, o);
+    /** A PancakeSwap V3 pool's and V2 pair's Swap events of a coin (sticky and rules coins trade there). */
+    const pancakeTrades = (token, pool, pair, cb, o) => {
+        // the coin is token0 when its address sorts under WBNB's
+        const coinIs0 = token.toLowerCase() < a.wbnb.toLowerCase();
+        const stops = [
+            watch({
+                address: pool,
+                abi: v3SwapAbi,
+                eventName: "Swap",
+                onLogs: (logs) => {
+                    for (const log of logs) {
+                        const g = (log.args ?? {});
+                        const coin = (coinIs0 ? g.amount0 : g.amount1);
+                        const bnb = (coinIs0 ? g.amount1 : g.amount0);
+                        // the pool's view: a negative coin amount left the pool, so someone bought
+                        cb({ token, buy: coin < 0n, trader: g.recipient ?? null, coins: abs(coin), bnb: abs(bnb), fee: null, source: "v3", block: log.blockNumber ?? 0n, tx: log.transactionHash ?? "0x" });
+                    }
+                },
+            }, o),
+        ];
+        if (!isAddressEqual(pair, ZERO_ADDRESS)) {
+            stops.push(watch({
+                address: pair,
+                abi: v2SwapAbi,
+                eventName: "Swap",
+                onLogs: (logs) => {
+                    for (const log of logs) {
+                        const g = (log.args ?? {});
+                        const coinOut = (coinIs0 ? g.amount0Out : g.amount1Out);
+                        const coinIn = (coinIs0 ? g.amount0In : g.amount1In);
+                        const bnbOut = (coinIs0 ? g.amount1Out : g.amount0Out);
+                        const bnbIn = (coinIs0 ? g.amount1In : g.amount0In);
+                        const buy = coinOut > 0n;
+                        cb({ token, buy, trader: g.to ?? null, coins: buy ? coinOut : coinIn, bnb: buy ? bnbIn : bnbOut, fee: null, source: "v2", block: log.blockNumber ?? 0n, tx: log.transactionHash ?? "0x" });
+                    }
+                },
+            }, o));
+        }
+        return () => stops.forEach((s) => s());
+    };
+    /**
+     * Every trade of a pickhooks coin, whatever its mode: the hook's Traded events (pools, calls, agents, hook any coin
+     * pools next to the coin) or the Swap events of its PancakeSwap V3 pool and V2 pair (sticky, rules).
+     */
+    async function trades(token, cb, o = {}) {
+        if (await mods.agents.isCoin(token))
+            return hookTrades(token, await mods.agents.hook(), agentsHookAbi, [(await mods.agents.coin(token)).id], "fee", cb, o);
+        if (await mods.pools.isCoin(token))
+            return hookTrades(token, await mods.pools.hook(), poolsHookAbi, [(await mods.pools.coin(token)).id], "fee", cb, o);
+        if (await mods.calls.isCoin(token))
+            return hookTrades(token, await mods.calls.hook(), callsHookAbi, [(await mods.calls.coin(token)).id], "fee", cb, o);
+        for (const s of [mods.sticky, mods.sticky2]) {
+            if (await s.isCoin(token).catch(() => false)) {
+                const c = (await s.coin(token));
+                return pancakeTrades(token, c.pool, c.pair, cb, o);
+            }
+        }
+        if (await mods.coins.versionOf(token).catch(() => null)) {
+            const c = (await mods.coins.coin(token));
+            return pancakeTrades(token, c.pool, c.pair, cb, o);
+        }
+        const pools = await mods.any.poolsOf(token).catch(() => []);
+        if (pools.length) {
+            const stops = [...new Set(pools.map((p) => p.hook.toLowerCase()))].map((h) => hookTrades(token, h, any3HookAbi, pools.filter((p) => p.hook.toLowerCase() === h).map((p) => p.id), "bnb", cb, o));
+            return () => stops.forEach((s) => s());
+        }
+        throw new PickhooksError("This is not a coin pickhooks knows.", { code: "input" });
+    }
+    /** Everything that happens to an agent coin: the desk's events (changes, vetoes, firing, treasury moves) and the hook's runs. */
+    async function agent(token, cb, o = {}) {
+        if (!(await mods.agents.isCoin(token)))
+            throw new PickhooksError("This is not an agent coin.", { code: "input" });
+        const [hook, desk, c] = await Promise.all([mods.agents.hook(), mods.agents.desk(), mods.agents.coin(token)]);
+        const emit = (logs) => {
+            for (const log of logs) {
+                const l = log;
+                cb({ token, event: l.eventName ?? "", args: l.args ?? {}, block: log.blockNumber ?? 0n, tx: log.transactionHash ?? "0x" });
+            }
+        };
+        const stops = [
+            watch({ address: desk, abi: agentsDeskAbi, args: { token }, onLogs: emit }, o),
+            watch({ address: hook, abi: agentsHookAbi, args: { token }, onLogs: emit }, o),
+            watch({ address: hook, abi: agentsHookAbi, eventName: "Traded", args: { id: c.id }, onLogs: emit }, o),
+        ];
+        return () => stops.forEach((s) => s());
+    }
+    return { launches, trades, agent, modes: factories.filter((f) => !isAddressEqual(f.address, ZERO_ADDRESS)).map((f) => f.mode) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pickhooks/sdk",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "description": "Read, quote, trade and launch on pickhooks (BNB Chain) from a bot, a launchpad or a trading terminal. Built on viem.",
   "license": "MIT",
   "type": "module",
@@ -22,6 +22,10 @@
     "./coin-rules": {
       "types": "./dist/coin-rules.d.ts",
       "import": "./dist/coin-rules.js"
+    },
+    "./tlock": {
+      "types": "./dist/tlock.d.ts",
+      "import": "./dist/tlock.js"
     }
   },
   "files": [
@@ -37,7 +41,13 @@
     "fork-proof": "node test/fork-proof.mjs",
     "fork-proof-2": "node test/fork-proof-2.mjs",
     "fork-proof-infra": "node test/fork-proof-infra.mjs",
-    "release": "node scripts/publish.mjs"
+    "mainnet-read-agents": "node test/mainnet-read-agents.mjs",
+    "release": "node scripts/publish.mjs",
+    "fork-proof-sticky3": "node test/fork-proof-sticky3.mjs"
+  },
+  "dependencies": {
+    "@noble/curves": "^1.9.1",
+    "@noble/hashes": "^1.8.0"
   },
   "peerDependencies": {
     "viem": "^2.0.0"