@pickhooks/sdk 0.0.0-stage → 0.2.0

package/dist/v3.d.ts

@@ -0,0 +1,42 @@
+import { type Address, type TransactionReceipt } from "viem";
+import { type Addresses } from "./addresses.js";
+import { type Ctx, type TxRequest } from "./tx.js";
+/** A buy through the V3 SwapRouter, BNB in (the router wraps it). */
+export declare function buildV3Buy(a: Addresses, b: {
+    token: Address;
+    bnbIn: bigint;
+    minOut: bigint;
+    recipient: Address;
+    deadline?: bigint;
+    fee?: number;
+    gasPct?: number;
+}): TxRequest;
+/** A sell through the V3 SwapRouter for native BNB: swap to the router, unwrap to the seller. Needs the coin approved to the router. */
+export declare function buildV3Sell(a: Addresses, s: {
+    token: Address;
+    amount: bigint;
+    minOut: bigint;
+    recipient: Address;
+    deadline?: bigint;
+    fee?: number;
+    gasPct?: number;
+}): TxRequest;
+/** What a trade gets in the V3 pool, from the QuoterV2 (it runs the swap, so a coin's refusing rule fails it: raw error). */
+export declare function v3Quote(ctx: Ctx, q: {
+    token: Address;
+    side: "buy" | "sell";
+    amount: bigint;
+    fee?: number;
+}): Promise<bigint>;
+/** The approval of `spender` (default the V3 router) a sell needs, or null when it is in place. */
+export declare function approvalFor(ctx: Ctx, owner: Address, token: Address, amount: bigint, spender?: Address, label?: string): Promise<TxRequest | null>;
+/** Coins of `token` that reached `to` in a receipt (its Transfer events). */
+export declare function receivedOf(receipt: TransactionReceipt, token: Address, to: Address): bigint;
+/**
+ * Coins a buy of `bnbIn` would get from a V3 pool, estimated as a constant product on the pool's active liquidity at its
+ * current price, the fee taken off the input. PancakeSwap's QuoterV2 cannot run a buy a coin's rule refuses, and it does
+ * not pass the coin's error on ("Unexpected error"), so this estimate is what names the rule then. Never use it as a minOut.
+ */
+export declare function v3EstimateBuy(ctx: Ctx, pool: Address, token: Address, bnbIn: bigint, fee?: number): Promise<bigint>;
+/** BNB per coin at a V3 pool's sqrt price (V3 prices token1 per token0). */
+export declare function v3PriceBnb(sqrtPriceX96: bigint, token: Address, wbnb: Address): number;

package/dist/v3.js

@@ -0,0 +1,98 @@
+import { encodeFunctionData, isAddressEqual, maxUint256, parseAbi, parseEventLogs } from "viem";
+import { erc20Abi, v3QuoterAbi, v3RouterAbi } from "./abis/common.js";
+import { LIMITS } from "./addresses.js";
+import { deadlineIn } from "./tx.js";
+/**
+ * PancakeSwap V3, shared by the products whose coins trade in a V3 pool of 1 % (coins with rules in the coin, v1 and v2,
+ * and sticky coins): the SwapRouter's buy and sell, the QuoterV2, the sell approval, and what a receipt delivered.
+ */
+const transferAbi = [
+    {
+        type: "event",
+        name: "Transfer",
+        inputs: [
+            { name: "from", type: "address", indexed: true },
+            { name: "to", type: "address", indexed: true },
+            { name: "value", type: "uint256", indexed: false },
+        ],
+        anonymous: false,
+    },
+];
+/** A buy through the V3 SwapRouter, BNB in (the router wraps it). */
+export function buildV3Buy(a, b) {
+    return {
+        to: a.v3Router,
+        value: b.bnbIn,
+        data: encodeFunctionData({
+            abi: v3RouterAbi,
+            functionName: "exactInputSingle",
+            args: [{ tokenIn: a.wbnb, tokenOut: b.token, fee: b.fee ?? LIMITS.stickyPoolFee, recipient: b.recipient, deadline: b.deadline ?? deadlineIn(), amountIn: b.bnbIn, amountOutMinimum: b.minOut, sqrtPriceLimitX96: 0n }],
+        }),
+        gasPct: b.gasPct,
+        label: "The buy",
+    };
+}
+/** A sell through the V3 SwapRouter for native BNB: swap to the router, unwrap to the seller. Needs the coin approved to the router. */
+export function buildV3Sell(a, s) {
+    const swap = encodeFunctionData({
+        abi: v3RouterAbi,
+        functionName: "exactInputSingle",
+        args: [{ tokenIn: s.token, tokenOut: a.wbnb, fee: s.fee ?? LIMITS.stickyPoolFee, recipient: a.v3Router, deadline: s.deadline ?? deadlineIn(), amountIn: s.amount, amountOutMinimum: s.minOut, sqrtPriceLimitX96: 0n }],
+    });
+    const unwrap = encodeFunctionData({ abi: v3RouterAbi, functionName: "unwrapWETH9", args: [s.minOut, s.recipient] });
+    return { to: a.v3Router, value: 0n, data: encodeFunctionData({ abi: v3RouterAbi, functionName: "multicall", args: [[swap, unwrap]] }), gasPct: s.gasPct, label: "The sell" };
+}
+/** What a trade gets in the V3 pool, from the QuoterV2 (it runs the swap, so a coin's refusing rule fails it: raw error). */
+export async function v3Quote(ctx, q) {
+    const buy = q.side === "buy";
+    const r = await ctx.pub.simulateContract({
+        address: ctx.a.v3Quoter,
+        abi: v3QuoterAbi,
+        functionName: "quoteExactInputSingle",
+        args: [{ tokenIn: buy ? ctx.a.wbnb : q.token, tokenOut: buy ? q.token : ctx.a.wbnb, amountIn: q.amount, fee: q.fee ?? LIMITS.stickyPoolFee, sqrtPriceLimitX96: 0n }],
+    });
+    return r.result[0];
+}
+/** The approval of `spender` (default the V3 router) a sell needs, or null when it is in place. */
+export async function approvalFor(ctx, owner, token, amount, spender = ctx.a.v3Router, label = "The approval") {
+    const have = await ctx.pub.readContract({ address: token, abi: erc20Abi, functionName: "allowance", args: [owner, spender] });
+    if (have >= amount)
+        return null;
+    return { to: token, value: 0n, data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [spender, maxUint256] }), label };
+}
+/** Coins of `token` that reached `to` in a receipt (its Transfer events). */
+export function receivedOf(receipt, token, to) {
+    const logs = parseEventLogs({ abi: transferAbi, logs: receipt.logs.filter((l) => isAddressEqual(l.address, token)), eventName: "Transfer" });
+    return logs.filter((l) => isAddressEqual(l.args.to, to)).reduce((x, l) => x + l.args.value, 0n);
+}
+const poolStateAbi = parseAbi([
+    "function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16, uint16, uint16, uint32, bool)",
+    "function liquidity() view returns (uint128)",
+]);
+/**
+ * Coins a buy of `bnbIn` would get from a V3 pool, estimated as a constant product on the pool's active liquidity at its
+ * current price, the fee taken off the input. PancakeSwap's QuoterV2 cannot run a buy a coin's rule refuses, and it does
+ * not pass the coin's error on ("Unexpected error"), so this estimate is what names the rule then. Never use it as a minOut.
+ */
+export async function v3EstimateBuy(ctx, pool, token, bnbIn, fee = LIMITS.stickyPoolFee) {
+    const [slot0, liquidity] = await Promise.all([
+        ctx.pub.readContract({ address: pool, abi: poolStateAbi, functionName: "slot0" }),
+        ctx.pub.readContract({ address: pool, abi: poolStateAbi, functionName: "liquidity" }),
+    ]);
+    const sqrtP = slot0[0];
+    if (sqrtP === 0n || liquidity === 0n)
+        return 0n;
+    const Q96 = 1n << 96n;
+    const r0 = (liquidity * Q96) / sqrtP;
+    const r1 = (liquidity * sqrtP) / Q96;
+    const [coins, bnb] = token.toLowerCase() < ctx.a.wbnb.toLowerCase() ? [r0, r1] : [r1, r0];
+    const dIn = (bnbIn * BigInt(1_000_000 - fee)) / 1000000n;
+    return (coins * dIn) / (bnb + dIn);
+}
+/** BNB per coin at a V3 pool's sqrt price (V3 prices token1 per token0). */
+export function v3PriceBnb(sqrtPriceX96, token, wbnb) {
+    const p = (Number(sqrtPriceX96) / 2 ** 96) ** 2;
+    if (p === 0)
+        return 0;
+    return token.toLowerCase() < wbnb.toLowerCase() ? p : 1 / p;
+}

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@pickhooks/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.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",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./abis": {
+      "types": "./dist/abis/index.d.ts",
+      "import": "./dist/abis/index.js"
+    },
+    "./rules": {
+      "types": "./dist/sticky-rules.d.ts",
+      "import": "./dist/sticky-rules.js"
+    },
+    "./coin-rules": {
+      "types": "./dist/coin-rules.d.ts",
+      "import": "./dist/coin-rules.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "abis": "node scripts/gen-abis.mjs",
+    "build": "node scripts/gen-abis.mjs && tsc -p tsconfig.json",
+    "check": "node scripts/check-rules-copy.mjs",
+    "test": "node --test test/unit.test.mjs",
+    "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"
+  },
+  "peerDependencies": {
+    "viem": "^2.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "viem": "^2.57.2"
+  },
+  "keywords": [
+    "pickhooks",
+    "bnb-chain",
+    "pancakeswap",
+    "infinity",
+    "hooks",
+    "viem"
+  ],
+  "engines": {
+    "node": ">=20"
+  }
+}