@pickhooks/sdk 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pickhooks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,4 +1,310 @@
-# Temporary Holding Version
+# @pickhooks/sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
-If no other versions are published within 30 days, this package and version will be deleted.
+Read, quote, trade and launch on [pickhooks](https://pickhooks.com) from a bot, a launchpad or a trading terminal. BNB Chain, TypeScript, built on [viem](https://viem.sh).
+
+Every pickhooks product, one client:
+
+* **hook any coin** (`ph.any`): a PancakeSwap Infinity pool next to any coin that already trades. After every swap the pool's hook closes the gap to the coin's PancakeSwap V2 pair in the same transaction (**arb recapture**) and books a quarter of that profit to the trader. Fees and recapture profits are split between the pool's opener, a **partner** that brought the pool, a **router** that sent the trade, and pickhooks. A second line takes flap tax coins, their tax included.
+* **sticky rules** (`ph.sticky`): coins whose rules stick to the coins, not to the wallet. Launch one from templates, read its table, and ask the coin which rule would stop a trade before anyone signs.
+* **coins with rules** (`ph.coins`): the v1 and v2 coins, with their rules in the coin (also find the dev and CZ mode coins). Rules as sentences, the rule that would refuse a trade, launches.
+* **pools** (`ph.pools`) and **curve calls** (`ph.calls`): coins with their rules in the pool's hook; renting a step of a coin's curve.
+* **Lever** (`ph.lever`, the first lever: `ph.leverV1`): longs and shorts on a coin's own liquidity.
+* **dip bids** (`ph.dips`): floors at a strike, bought from a maker's bid.
+
+For a terminal the point is the same everywhere: before a trade is signed, the SDK asks the coin, and a refusal comes back as the rule's sentence ("Refused by the rule "Max per buy". No buy over 0.5% of supply.") instead of "honeypot".
+
+```bash
+npm install @pickhooks/sdk viem
+```
+
+```ts
+import { createPickhooks } from "@pickhooks/sdk";
+import { createWalletClient, http, parseEther } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { bsc } from "viem/chains";
+
+const walletClient = createWalletClient({ account: privateKeyToAccount(KEY), chain: bsc, transport: http() });
+const ph = createPickhooks({ walletClient });
+
+const [pool] = await ph.any.pools({ limit: 1 });
+const r = await ph.any.buy({ pool, bnbIn: parseEther("0.05") });
+console.log(r.amountOut, r.recapture); // coins bought; the recapture of this transaction and your share of it
+await ph.any.claim(); // your recapture shares (and, as an opener or partner, those shares)
+```
+
+Without a `walletClient` everything that only reads works. Every write also exists as a builder (`ph.any.build.*`, `ph.sticky.build.*`) that returns plain `{ to, data, value, extraGas }` for wallets, multicalls and your own router contracts.
+
+## Who earns what (hook any coin)
+
+| who | what | how it is paid |
+|---|---|---|
+| the trader | 25 % of every recapture its swap made possible | `claim()` |
+| the opener | 35 % of the pool's BNB fees and of what is left of each recapture after the trader's share (part of it can feed a jackpot) | `claim()` |
+| a partner | its listed share (up to 50 %) of the pickhooks part of every fee and recapture in pools opened with it | `claim()` |
+| a router | its listed share (up to 50 %) of the pickhooks part of the fee of every buy it sends, and of the recapture profit its trades create | `claimRouter()` from the payout wallet |
+
+The trader share applies to pools opened from now on (factory `traderBps`, each pool keeps its own). Partners and routers are listed by pickhooks (`partnerBps(partner)`, `router(contract)`): ask to be listed.
+
+**A router is the contract that calls the pool manager.** Trades through PancakeSwap's UniversalRouter come from the UniversalRouter; a terminal with its own router contract is listed by that contract's address and gets paid to a wallet it names. Buy fees are credited at the swap and funded when the pool's fees are collected (`collect`: anyone can call it, and pickhooks' keeper runs it); recapture shares are funded at once. `earnings(payout).routerClaimable` is what `claimRouter()` pays now.
+
+## Gas: the recapture room
+
+The hook recaptures inside the trader's transaction, after the swap, with its own gas budget (600k plus a 250k reserve). A wallet's plain estimate leaves that out, so the swap goes through without a recapture. Trades built by the SDK carry `extraGas: 900_000n`; `sendTx` uses estimate x 1.3 + extraGas. Only the gas used is paid (a recapture uses about 400k). Pass `recapture: false` to trade without the room. A terminal that routes through its own contract leaves at least 850k gas for the hook's `afterSwap`.
+
+## hook any coin: `ph.any`
+
+Reading
+
+```ts
+await ph.any.terms();                 // { owner, platformWallet, openerBps, traderBps, hook }
+await ph.any.pools({ limit, offset }); // newest first: id, key, token, symbol, config, counters, positions, price
+await ph.any.pool(id);                // one pool, or null
+await ph.any.poolsOf(token);          // every pool of a coin (one per slot)
+await ph.any.check(token);            // can this coin get a pool? price, price source, depth, free slot, pair
+await ph.any.earnings(wallet);        // { owed, routerCredit, routerClaimable, partnerBps }
+await ph.any.router(contract);        // { payout, bps }
+await ph.any.partnerBps(partner);
+await ph.any.bonusOf(pool, wallet);   // lock to earn
+await ph.any.pendingFees(pool);       // what a collect would book now
+```
+
+Trading (BNB in for buys, BNB out for sells; `pool` is an id, a key or a pool from `pools()`)
+
+```ts
+const q = await ph.any.quote({ pool, side: "buy", amount: parseEther("0.1"), from: me }); // quote = fill
+const b = await ph.any.buy({ pool, bnbIn: parseEther("0.1"), slippageBps: 100 });
+const s = await ph.any.sell({ pool, amount: b.amountOut / 2n });  // approves Permit2 once, then the router for 30 days
+// b.amountOut, b.recapture { profit, toTrader, soldHere }, b.routerCredit, b.hash, b.receipt
+```
+
+Building instead of sending
+
+```ts
+const key = await ph.any.key(poolId);
+const tx = ph.any.build.buy({ key, bnbIn, minOut });  // { to: UniversalRouter, data, value, extraGas }
+const approvals = await ph.any.sellApprovals(owner, key.currency1, amount); // TxRequest[]
+ph.any.readTrade(receipt);                              // the trade, the recapture and the router credit of a receipt
+```
+
+Opening a pool (as a launchpad or bot, with yourself as the partner)
+
+```ts
+const c = await ph.any.check(coin);                   // c.ok, c.text, c.depth (BNB in the coin's main pool)
+const need = ph.any.depthNeeds(c, "ladder10", c.freeSlot!); // coins a pool needs to be as deep (the factory refuses a shallower one)
+const { id } = await ph.any.open({ token: coin, tokenAmount: need.coins, partner: MY_PARTNER_WALLET });
+ph.any.partnerLink(MY_PARTNER_WALLET);                // the site's open form with you named as partner
+```
+
+Options and their defaults (the site's): `range` `"ladder10"` (coins only, up to 10x; `"ladder"` no top; `"around"` with BNB), `feeBps` 30, `holderFeeBps` 5 for wallets with `holderMin` 10,000 $hooks, `chestBps` 200 (the fire), `bonus` 5 % locked 7 days for buys from 0.05 BNB (`false` for none), `jackpot` off, `recapture` true, `maxMoveBps` 100. Each position stays in the pool 30 days.
+
+Payouts and pool tools: `claim()`, `claimRouter()`, `collect(pool)`, `settleJackpot(pool)`, `fundPot(pool, wei)`, `feedChest(token, amount)`, `fundBonus(pool, amount)`, `lockBonus(pool, amount)`, `unlockBonus(pool)`, `addLiquidity(pool, range, coins, bnb)`, `removeLiquidity(pool, index)`, each also under `build`.
+
+### The tax line (flap tax coins)
+
+Flap tax coins keep their tax in a pickhooks pool: buyers and sellers pay it like on the coin's main pool, and the tax goes where the coin sends it. They open on a second factory with its own hook (`addresses.anyTaxFactory`; `ph.any.taxLineOn` says whether it is set). The SDK routes for you: `check(token)` names the line (`line: "main" | "tax"`, with the coin's live tax in `tax`), and `pools()`, `pool()`, `quote()`, `buy()` and `sell()` work on both.
+
+```ts
+const c = await ph.any.check(taxCoin);           // c.line === "tax", c.tax { buyBps, sellBps, ... }
+const t = await ph.any.taxOf(taxCoin);           // the tax as it runs now
+const fit = fitLadder(c, coins, c.freeSlot!, t.sellBps); // the range a ladder of `coins` needs to be as deep as the main pool
+const q = await ph.any.quote({ pool, side: "buy", amount }); // { amountOut (after tax), gross, taxBps }
+await ph.any.sell({ pool, amount });             // while the anti-farmer tax runs: pays the coins in first, then swaps
+await ph.any.claim({ line: "tax" });             // the opener's side of the tax line's fees
+```
+
+While a coin's anti-farmer tax runs, a sell in its pickhooks pool must pay its coins in first; a plain router sell is refused with `PayFirst`. The SDK's `sell()` does it right; terminals that route themselves sell such coins in their main pool.
+
+## sticky rules: `ph.sticky`
+
+```ts
+import { TEMPLATES } from "@pickhooks/sdk";  // hold, sniper, devlock, drip, maxbuy, maxwallet, window, hours, burn, dipdrop, lucky, wakeup
+
+const picks = [
+  { id: "sniper", params: { b: 20, h: 24 } },  // buys in the first 20 blocks are marked; marked coins cannot sell for 24 h, in any wallet
+  { id: "devlock", params: { d: 7 } },         // the creator's first buy cannot sell for 7 days
+  { id: "lucky", params: { pot: 2, n: 25, share: 100 } },
+];
+const table = ph.sticky.compile(picks);       // { rows, release, problems }
+await ph.sticky.validate(table.rows, table.release); // null, or the validator's reason as a sentence
+const { token } = await ph.sticky.launch({ name, symbol, metadata: "https://…/meta.json", picks, devBuy: parseEther("0.05") });
+```
+
+A launch costs the factory's seed (0.01 BNB, into the coin's V2 pair) plus the creator's first buy; the creator gets half of the fees the coin's pool earns (`keepBps` of it, the rest buys back and burns $hooks). `metadata` is a link to the coin's JSON (name, symbol, description, image, website, twitter, telegram): host your own, or let pickhooks.com host it: `prepareMetadata({ name, symbol, description, website, twitter, telegram, image })` returns `{ metadata, image }`.
+
+```ts
+await ph.sticky.coins({ limit });            // newest first: rows as sentences, scanner color, holders, pot, price
+await ph.sticky.coin(token);
+await ph.sticky.wallet(token, who);          // balance, sellable now, lots (amount, locked, since, marks)
+const v = await ph.sticky.check({ token, side: "sell", wallet, amount });
+// { ok: true } or { ok: false, row: 1, text: "Refused by rule 2: Sniper jail. A sell is refused when …" }
+await ph.sticky.buy({ token, bnbIn });       // quote, check, then the buy through PancakeSwap V3
+await ph.sticky.sell({ token, amount });     // check first: a refusing rule stops it before anything is signed
+await ph.sticky.lift(token, row);            // the creator lifts a row for good
+```
+
+**Hook script: your own rows.** With the factory's custom switch on (`terms().custom`, on since 08.10.2026), a coin can carry the creator's own rows after the templates, written like the site's editor:
+
+```ts
+import { ACT, ON, OP, VAR, VARS } from "@pickhooks/sdk";   // VARS: every variable with its unit (minutes, % of supply, x, ...)
+
+const noBigSells = { on: ON.SELL, act: ACT.DENY, arg: 0, conds: [{ v: VAR.AMOUNT, op: OP.GE, x: 1 }] }; // no sell of 1 % of supply or more
+await ph.sticky.launch({ name, symbol, metadata, picks: [{ id: "devlock", params: { d: 7 } }], script: [noBigSells], devBuy });
+```
+
+The editor's checks run first (a row the site would refuse stops before anything is signed, in words), then the validator on chain. Rows that lock shares take `scriptHours` (10 minutes to 30 days).
+
+Sticky coins trade in a PancakeSwap V3 pool of 1 % and a V2 pair, so any router can trade them. For a terminal the point is `check()`: instead of "honeypot", show the row that stops the trade, in words.
+
+**A quote that a rule refuses.** PancakeSwap's QuoterV2 runs the swap, so a buy a rule refuses fails in the quoter, and the quoter does not pass the coin's reason on (it says "Unexpected error"). `quote()` of sticky coins and of coins with rules then checks the buy again with `estimateBuy(token, bnbIn)` (the pool's liquidity at its price) and throws the rule's sentence (`code: "Blocked"`). Pass `wallet` to check for that wallet. The estimate names rules; never use it as a minimum.
+
+## Coins with rules: `ph.coins`
+
+The v1 and v2 coins (`pickhooks.com/launch`): up to eight rules live in the coin itself and apply to every transfer with its PancakeSwap V3 pool.
+
+```ts
+import { RULES } from "@pickhooks/sdk";             // the catalog: id, kind, name, fields (also @pickhooks/sdk/coin-rules)
+
+await ph.coins.coins({ version: 2, limit: 20 });     // newest first: rules as sentences, holders, price
+const c = await ph.coins.coin(token);                // c.version, c.rules [{ name, text, ended }], c.extras
+const v = await ph.coins.check({ token, side: "buy", wallet, amount: await ph.coins.estimateBuy(token, bnbIn) });
+// { ok: true } or { ok: false, kind: 2, name: "Max per buy", text: "Refused by the rule "Max per buy". No buy over 0.5% of supply." }
+await ph.coins.buy({ token, bnbIn });                // quote, check, buy; a refusing rule stops it before anything is signed
+await ph.coins.sell({ token, amount });
+```
+
+`check()` runs the coin's own transfer in an `eth_call` (a buy: the coins leaving the pool to the wallet), so the answer is the coin's, not a copy of its logic.
+
+Launching (v2):
+
+```ts
+const rules = [
+  { id: "max_wallet", values: { cap: 1 } },              // % of supply
+  { id: "max_tx", values: { cap: 0.5 } },
+  { id: "buyout", values: { rules: "2", price: 0.1 } },  // anyone can buy rule 2 off for 0.1 BNB
+];
+const L = await ph.coins.launch({ name, symbol, metadata, rules, devBuy: parseEther("0.02") });
+// L.token, L.burned: rules that need $hooks burn it in the launch, bought with BNB (payBurnIn: "hooks" uses yours)
+```
+
+`burnFor(mask)` says what a set of rules burns and the BNB it costs. After launch: `wallet(token, who)`, `pendingFees(token)`, `collect(token)` (anyone; the creator gets its side), `claim(token)`, `buyout(token, kind)`, `fundPot(token, "jackpot" | "rewards", wei)`, `settleJackpot`, `withdrawRewards`, `poke`, `alive`, `release`, and under `build` the vote, duel, floor and payroll steps.
+
+## Pools and curve calls: `ph.pools`, `ph.calls`
+
+Pool coins carry their rules in a PancakeSwap Infinity pool's hook instead of the coin; they trade through the UniversalRouter (Permit2 for sells).
+
+```ts
+await ph.pools.knownKinds();                          // the rules a pool can carry (Max wallet needs the coin, so no)
+const P = await ph.pools.launch({ name, symbol, metadata, rules: [{ id: "max_tx", values: { cap: 0.5 } }], devBuy });
+await ph.pools.check({ token, side: "buy", wallet, amount }); // the quoter runs the hook as the buyer and names the rule
+await ph.pools.buy({ token, bnbIn }); await ph.pools.sell({ token, amount });
+await ph.pools.owed(creator); await ph.pools.claim();  // the creator's share, booked on every swap
+```
+
+`ph.calls` is the same for curve calls coins, plus the desk:
+
+```ts
+const steps = await ph.calls.steps(token);            // the steps above the price that are open (none in a coin's first 10 minutes)
+const q = await ph.calls.quoteCall(token, step, coins, seconds); // { premium, liquidity }
+const { id } = await ph.calls.openCall({ token, step, coins, seconds });
+await ph.calls.payout(id, me);                        // what closing pays now
+await ph.calls.closeCall(id);                         // the payout and the bond come back
+await ph.calls.withdraw();                            // anything the desk holds for you (ph.calls.pending(me))
+```
+
+## Lever: `ph.lever` and `ph.leverV1`
+
+```ts
+const m = await ph.lever.coin(token);                 // the Lens: price, room for longs and shorts, open longs and shorts
+const o = await ph.lever.quoteOpen(token, "long", gross, 2); // o.reason 0 = it opens; otherwise o.text says why
+const { id } = await ph.lever.open({ token, side: "short", gross, leverage: 2 });
+await ph.lever.positions(token);                      // { longs, shorts }: owner, margin, trigger, closeNet (what closing pays now)
+await ph.lever.close({ token, side: "short", id });
+await ph.lever.sell({ token, amount });               // sellPlan() splits a sale around open shorts when it must
+await ph.lever.claim(token, "creator");               // "creator" | "refund" | "platform"
+```
+
+`grossForMargin(margin, leverage)` is the BNB to send for a margin. `ph.leverV1` is the first lever (engine curve, longs only): `quoteBuy`, `quoteSell`, `quoteOpen`, `buy`, `sell`, `openLong`, `closeLong`, `closeExpired`, `claimRefund`, `claimCreator`, `launch`.
+
+## Dip bids: `ph.dips`
+
+A maker posts a bid: BNB that buys coins at a strike, in floors that holders buy for a premium. A holder with a floor can sell up to its cover at the strike while it runs, even after a dip.
+
+```ts
+const { id } = await ph.dips.post({ token, price: 0.000000003, duration: 86_400, premiumBps: 500, until, minCover, deposit });
+await ph.dips.bids(token);                            // the coin's bids
+const q = await ph.dips.quote(id, coins);             // { cover, premium, fee, payout }
+const f = await ph.dips.buyFloor(id, coins);          // f.id: the floor
+await ph.dips.exercise({ floorId: f.id, coins, token }); // approval, a dry run, then the coins go to the maker for BNB
+await ph.dips.close(id);                              // the maker takes the free BNB back
+```
+
+`strikeFromPrice(bnbPerCoin)`, `coverOf(strike, coins)` and `coinsFor(strike, cover)` convert; the strike is BNB wei per whole coin.
+
+## HOOKS infra: `ph.infra`
+
+Off until its contracts are on mainnet (`addresses.hooksExecutor`, `addresses.hooksFloorFactory`; `ph.infra.on` says which part is live).
+
+* **Floors:** a BNB reserve under a coin (one per coin, anyone can open and feed it). A holder hands coins in for reserve / circulating, less 2 % (1 % stays and lifts the floor, 1 % to the protocol); the coins go to 0xdead. No owner, no withdraw: the floor only rises.
+* **Protected buy:** one transaction buys through PancakeSwap's own routers and a dip floor for what arrived. pickhooks.com picks the route and the bid; `protect()` sends what the site built, after checking it goes to the executor.
+
+```ts
+const f = await ph.infra.floorOf(token);          // { floor, reserve, circulating, perCoin, totalFed, totalPaid, totalRedeemed }
+await ph.infra.quoteRedeem(token, coins);         // { payout, kept, protocolFee }
+await ph.infra.redeem({ token, coins });          // approval, then the hand in (quote less 0.5 % as the minimum)
+await ph.infra.feed(token, parseEther("1"));      // more BNB under the coin
+await ph.infra.open({ token, seed });             // the coin's first floor
+const o = await ph.infra.offer({ token, bnbIn }); // the route, the bids that can cover it, the transaction
+await ph.infra.protect({ token, bnbIn });         // { coins, floorId, premium }
+```
+
+## Building blocks: `ph.blocks`
+
+The vocabulary of every rule, as plain data and offline: sticky rules' 12 ready blocks (numbers with their ranges, the sentence, the rows they make, what scanners show), the hook script grammar (triggers, actions, marks, variables with their units, operators, the checks a table must pass) and the rule book of coins with rules (each rule with its fields).
+
+```ts
+const c = ph.blocks.catalog();          // { version, sticky: { blocks, script, promises, limits }, coinRules: { groups, rules } }
+ph.blocks.block("sniper");              // { name, line, example, params, rows, scanner, sticky }
+await ph.api.blocks();                  // the same object from pickhooks.com/api/blocks, once the site serves it
+```
+
+It is built from the same files as the site's launchers (a checked copy), so a terminal, a bot or an agent can explain a coin's rules or compose a table without guessing.
+
+## pickhooks.com's API: `ph.api`
+
+`launches({ since, before, limit })`, `launch(address)`, `coins()`, `activity()`, `official()`, `burners()`, or `get(path, query)`. No key; a limit per address per minute.
+
+## Errors
+
+Every failure is a `PickhooksError` with `code` (the contract's error name, or `wallet`, `funds`, `pancake`, `reverted`, `input`) and a sentence as `message`. `explain(err)` turns any error (also from your own viem calls) into `{ code, text }`, including hook errors that PancakeSwap wraps.
+
+## Addresses (BNB Chain)
+
+| | |
+|---|---|
+| hook any coin v3 factory | `0x1662668Ab8FaA612A7F615F1AccB90ceC20be117` |
+| hook any coin v3 hook | `0x49892253A5E71f5DF0Fbc118bd7c15acAF55F767` |
+| sticky factory | `0x385C273bDaBC5a0788dfBb648F05bE0C5EE018fd` |
+| sticky validator | `0x057007a21330EA770f2Fcb61c8925C28c270480f` |
+| coins with rules v1 factory | `0xecED45Ae3e85D947038009710594a50d422A54D8` |
+| coins with rules v2 factory | `0x23cC366e1DDBc41CFD70011C4AaC14B79998B24F` |
+| pools factory | `0x3F97831C8296D934d84357B619CfC44D32d0241B` |
+| curve calls factory | `0x98D49C17458def2e5fdF00F20479658693498301` |
+| Lever factory | `0x03EbF1558E2f9337E4d2FfCAcE3A5114aC32A87A` |
+| Lever Lens | `0x3f1a660FC365Af192acE4E761657cE61A6ED0F13` |
+| lever (v1) factory | `0xeaB93e923170bd5331Db4300aF6F2555eBBF9615` |
+| dip bids desk | `0xc73bcB859C3fD5Bd38A10B0aD9A862EAAf6765bf` |
+| $hooks | `0x07bcB8E8226f671300e135b4A61Dc157359b7777` |
+
+All verified on BscScan. `BSC_MAINNET` holds these and PancakeSwap's; `createPickhooks({ addresses })` points the SDK elsewhere (a fork). The tax line's factory is not set yet (`anyTaxFactory` is zero until it is on mainnet). ABIs: `@pickhooks/sdk/abis`; the sticky encoder alone: `@pickhooks/sdk/rules`; the rule catalog of coins with rules: `@pickhooks/sdk/coin-rules`.
+
+## Examples
+
+* `examples/terminal.mjs`: pools, routing a buy, sticky rows and coins with rules with the rule that refuses a trade, a wallet's earnings (read only)
+* `examples/bot.mjs`: quote, buy with the recapture room, sell, claim
+* `examples/launchpad.mjs`: a sticky launch from templates, a pool with you as the partner, the partner's claim
+
+They send nothing without `--send`.
+
+## Tests
+
+`npm test` (offline: pool ids, ranges, building, errors, the rule compiler). On a local BSC fork (`scripts/fork.sh`, anvil) against the live contracts: `npm run fork-proof` (hook any coin and sticky rules) and `npm run fork-proof-2` (coins with rules, pools, dip bids, Lever, lever v1, curve calls, and the tax line, which it deploys on the fork from a throwaway key). `npm run fork-proof-infra` runs floors and the protected buy on the infra rehearsal fork (`script/infra/rehearsal-fork.sh`, contracts deployed there by a throwaway key) against a dev server of the site. `npm run check` confirms the rule catalogs and the building blocks catalog are the site's.