hookr-sdk 0.1.0 → 0.2.1

package/README.md

@@ -1,8 +1,17 @@
 # hookr-sdk
 
-Build a market on Hookr's live root hook with a custom rule configuration, quote and swap
-through Hookr's router, read markets, and claim payouts. There is exactly one root today:
-`HookrModularHookV6` on Robinhood Chain (id 4663), `ADDRESSES.root`.
+Build a market on Hookr's live root hooks with a custom rule configuration, quote and swap
+through Hookr's router, read markets, and claim payouts, on Robinhood Chain (id 4663).
+
+Two roots are live. A pool names exactly one of them in `PoolKey.hooks`:
+
+| Root | Export | What it runs |
+| --- | --- | --- |
+| `HookrModularHookV6` | `ADDRESSES.root`, `ROOTS.default` | the five native rules |
+| `HookrModularHookV6WthV5` | `ADDRESSES.recaptureRoot`, `ROOTS.recapture` | the same five rules plus the arbitrage-recapture lane |
+
+Earlier recapture roots still hold trading pools. Their pools read back like any other, so resolve
+a root from the pool's own `PoolKey.hooks` or from the registry rather than from a list.
 
 ## Install
 
@@ -10,6 +19,21 @@ through Hookr's router, read markets, and claim payouts. There is exactly one ro
 npm install hookr-sdk viem
 ```
 
+## RPC
+
+`RPC_URL` is the chain's public, keyless endpoint. It is fine for a few reads. Under load it rate
+limits, and a wide `eth_getLogs` can come back as an empty array instead of an error. `listMarkets`
+scans in windows of `MARKET_SCAN_CHUNK_BLOCKS` (3,000,000 blocks, the width the app's own scanners
+use; pass `chunkBlocks` to lower it) so no single answer is wide, but anything that must not miss
+data should still run on a provider endpoint you own:
+
+```ts
+import { http } from "viem";
+import { RPC_URL } from "hookr-sdk";
+
+const transport = http(process.env.HOOKR_RPC_URL ?? RPC_URL);
+```
+
 ## List and validate rules
 
 ```ts
@@ -23,9 +47,15 @@ const { ok, errors } = validateStack(stack);
 
 ## Build and send a create-market call
 
+A market opens on the default root unless `root: ROOTS.recapture` is passed. On the recapture
+root the builder also freezes the five correction fields of the stack (`RECAPTURE_CORRECTION`
+plus the creator), without which the pool would carry that root's name and never correct. The
+registry admits that lane on native-ETH-quoted pools only, so the builder throws on any other
+quote, and it needs `creator` (the launching wallet) to freeze as the correction creator.
+
 ```ts
 import { createWalletClient, http } from "viem";
-import { CHAIN_ID, RPC_URL, buildExistingTokenMarketCall } from "hookr-sdk";
+import { CHAIN_ID, NATIVE_ADDRESS, ROOTS, buildExistingTokenMarketCall } from "hookr-sdk";
 
 const call = buildExistingTokenMarketCall({
   subject: token, quote: usdcAddress, tickSpacing: 60, sqrtPriceX96,
@@ -33,6 +63,14 @@ const call = buildExistingTokenMarketCall({
   protocolRecipient, protocolShareBps, caps, // read from the coordinator and native block first
 });
 const hash = await walletClient.writeContract(call);
+
+// The same market on the recapture root: native ETH quote, and the creator wallet.
+const recaptureCall = buildExistingTokenMarketCall({
+  subject: token, quote: NATIVE_ADDRESS, tickSpacing: 60, sqrtPriceX96,
+  rules: { baseFeePips: 3_000, blocks: stack },
+  protocolRecipient, protocolShareBps, caps,
+  root: ROOTS.recapture, creator: account.address,
+});
 ```
 
 `caps` comes from `nativeMechanicsBlock.validateStack(...)`; `protocolShareBps` from
@@ -41,17 +79,49 @@ package computes and what it takes as an already-resolved input.
 
 ## Read a market, quote, and swap
 
+`poolKeyFor` defaults `hooks` to the default root. Pass `hooks: ADDRESSES.recaptureRoot` for a
+pool on the recapture root, or use the `kernel` a `readMarket` row carries.
+
 ```ts
 import { createPublicClient, http } from "viem";
-import { readMarket, poolKeyFor, quoteExactInput, buildExactInputSwapCall } from "hookr-sdk";
+import { ADDRESSES, readMarket, poolKeyFor, quoteExactInput, buildExactInputSwapCall } from "hookr-sdk";
 
-const client = createPublicClient({ transport: http(RPC_URL) });
+const client = createPublicClient({ transport });
 const market = await readMarket(client, poolId);
-const key = poolKeyFor({ subject: market.subject, quote: market.quote, tickSpacing: market.tickSpacing });
+const key = poolKeyFor({
+  subject: market.subject, quote: market.quote, tickSpacing: market.tickSpacing,
+  hooks: market.kernel, // ADDRESSES.root or ADDRESSES.recaptureRoot
+});
 const { amountOut } = await quoteExactInput(client, { key, user, currencyIn: market.quote, amountIn });
 const swapCall = buildExactInputSwapCall({ key, currencyIn: market.quote, amountIn, amountOutMinimum, recipient: user, deadline });
 ```
 
+A swap on a recapture pool needs more gas than an estimate reports, because the correction is
+fail-open: an estimate converges on the cheapest swap that succeeds, which is the one that skipped
+the correction. The swap builders put `gas: CORRECTION_SWAP_GAS_FLOOR` (1,100,000, the app's
+floor) on the call whenever the pool's root is the current recapture root, so pass the call to
+`writeContract` as it is; on the default root the call carries no `gas` and the wallet estimates
+as usual. A pool opened on a superseded recapture root keeps its executor and keeps correcting;
+read `poolCorrects(await readPoolRules(client, poolId))` and pass it as `correcting` to the swap
+builders to put the same floor on that call (since 0.2.1).
+
+## Roots
+
+`ROOTS` names the two roots Hookr opens markets on today. The registry itself never retires a
+root, so `listRoots` shows every kernel it has registered, current or not, with its status and
+whether its profile is sealed (the coordinator opens markets on sealed profiles only):
+
+```ts
+import { listRoots } from "hookr-sdk";
+
+for (const root of await listRoots(client)) {
+  console.log(root.hook, root.status, root.sealed ? "sealed" : "unsealed");
+}
+```
+
+Pools on any of those roots read, quote and swap through this package when their root's address is
+passed as `hooks`; only market creation is limited to `ROOTS`.
+
 ## Claim
 
 ```ts
@@ -65,6 +135,19 @@ if (owed > 0n) await walletClient.writeContract(claimCall(quoteAddress));
 
 `RULES` and `PARAMS` are this package's own machine-readable list of the five public rules and
 their bounds, and the same list is served live at https://hookr.fun/api/hooks/catalog together
-with the root and contract addresses, the fee model, the composition limits and prefilled
+with the roots and contract addresses, the fee model, the composition limits and prefilled
 builder links for example configurations. Both come from the same source in the Hookr app, and a
 parity test in that repository keeps the package and the app in step.
+
+## Changes
+
+- 0.2.1: the swap builders take `correcting` (default `isCorrectingRoot(key.hooks)`, the current
+  recapture root), and `poolCorrects(rules)` reads from a pool's frozen rules whether it names a
+  correction executor, so a pool on a superseded recapture root can carry the gas floor too.
+- 0.2.0: names both live roots (`ADDRESSES.recaptureRoot`, `RECAPTURE_KERNEL_ID`, `ROOTS`); the
+  market builders take `root` and freeze the recapture correction fields (`RECAPTURE_CORRECTION`);
+  swap calls carry `gas: CORRECTION_SWAP_GAS_FLOOR` on a correcting root; `listMarkets` scans in
+  windows (`MARKET_SCAN_CHUNK_BLOCKS`, `chunkBlocks`); `listRoots` reads every registered root
+  from the registry; documents the public RPC's limits. The README on npm for 0.1.0 had drifted
+  from the repository.
+- 0.1.0: first release, default root only.

package/dist/chain.d.ts

@@ -1,25 +1,36 @@
 import type { Address, Hex } from "viem";
 /**
- * Robinhood Chain, and Hookr's one live root hook on it.
+ * Robinhood Chain, and Hookr's two live root hooks on it.
  *
  * Every value here is a literal copy of `src/lib/v2-deployments.ts` (the addresses, read from
  * the app's own deployment evidence) and `src/lib/chain.ts` (the RPC and explorer origin) in the
  * Hookr app. `src/test/hookr-sdk-parity.test.ts` in that app asserts this file agrees with both,
  * so a redeploy or an RPC change that is not mirrored here fails that suite.
  *
- * There is exactly one root today: `HookrModularHookV6`, deployed as `ADDRESSES.root`. Every V2
- * pool's `PoolKey.hooks` is that address.
+ * Two roots take new markets today, and a pool names exactly one of them in `PoolKey.hooks`:
+ * `HookrModularHookV6` (`ADDRESSES.root`, the default root: the five native rules) and
+ * `HookrModularHookV6WthV5` (`ADDRESSES.recaptureRoot`: the same five rules plus the arbitrage
+ * recapture lane, whose correction executor is run by WTH). `ROOTS` pairs each with the kernel
+ * id the coordinator opens it under. Earlier recapture roots still hold trading pools; resolve
+ * any other root from the registry rather than from a list.
  */
 /** Robinhood Chain's id. */
 export declare const CHAIN_ID = 4663;
-/** The chain's public, keyless RPC endpoint. */
+/**
+ * The chain's public, keyless RPC endpoint. Use it for light reads only: under load it rate
+ * limits, and an over-wide `eth_getLogs` can come back as an empty array instead of an error.
+ * Anything that scans logs or must not miss data should run on a provider endpoint you own and
+ * check for failed ranges; see the README.
+ */
 export declare const RPC_URL = "https://rpc.mainnet.chain.robinhood.com";
 /** Origin of the chain's block explorer (Blockscout). No trailing slash. */
 export declare const EXPLORER_URL = "https://robinhoodchain.blockscout.com";
 /** The V2 contracts and ids a third-party integration calls or reads. */
 export declare const ADDRESSES: Readonly<{
-    /** `HookrModularHookV6` — `hooks` in every V2 `PoolKey`. The one live root. */
+    /** `HookrModularHookV6` — the default root, `hooks` in every pool opened on it. */
     root: Address;
+    /** `HookrModularHookV6WthV5` — the arbitrage-recapture root, `hooks` in every pool opened on it. */
+    recaptureRoot: Address;
     /** `HookrMarketCoordinatorV5` — opens markets, collects founding fees, resolves the share tier. */
     coordinator: Address;
     /** `HookrKernelRouterV3` — the swap router that pays into and out of the pot. */
@@ -37,8 +48,39 @@ export declare const ADDRESSES: Readonly<{
 }>;
 /** The native-mechanics module id every V2 pool's one module is keyed by in the registry. */
 export declare const MODULE_ID: Hex;
-/** The coordinator's kernel id for the root hook, carried in `MarketParams.kernelId`. */
+/** The coordinator's kernel id for the default root, carried in `MarketParams.kernelId`. */
 export declare const KERNEL_ID: Hex;
+/** The coordinator's kernel id for the recapture root. */
+export declare const RECAPTURE_KERNEL_ID: Hex;
+/** The two live roots, each with the kernel id a market opens under on it. */
+export declare const ROOTS: Readonly<{
+    default: Readonly<{
+        hook: `0x${string}`;
+        kernelId: `0x${string}`;
+    }>;
+    recapture: Readonly<{
+        hook: `0x${string}`;
+        kernelId: `0x${string}`;
+    }>;
+}>;
+/**
+ * The frozen `StackLimits` correction fields a market on the recapture root must carry for its
+ * correction lane to exist at all (the app's `V2_RECAPTURE_CORRECTION`). The kernel returns before
+ * correcting when a pool's frozen `correctionExecutor` is zero, and the fields are part of the stack
+ * hash, so they are set at creation or never. `executor` is the adapter the current recapture root's
+ * profile admits, bound immutably to WTH's executor; `feePolicyId` is the id that adapter answers
+ * with; `maxVolumeBps` and `minProfitQuote` are the registry's permissive ceiling and its smallest
+ * legal floor, frozen but not enforced (WTH sizes its own corrections). The registry admits a
+ * correction executor only on a native-ETH-quoted pool, and the pool's creator is frozen beside them.
+ */
+export declare const RECAPTURE_CORRECTION: Readonly<{
+    executor: Address;
+    feePolicyId: Hex;
+    maxVolumeBps: 5000;
+    minProfitQuote: 1n;
+}>;
+/** True when `hooks` is the recapture root, the one root whose pools carry a correction lane. */
+export declare function isRecaptureRoot(hooks: Address): boolean;
 /** Native ETH as a v4 currency: the zero address. Always `currency0` when it is one side of a pool. */
 export declare const NATIVE_ADDRESS: Address;
 export declare function explorerAddressUrl(address: Address): string;

package/dist/chain.js

@@ -1,24 +1,35 @@
 /**
- * Robinhood Chain, and Hookr's one live root hook on it.
+ * Robinhood Chain, and Hookr's two live root hooks on it.
  *
  * Every value here is a literal copy of `src/lib/v2-deployments.ts` (the addresses, read from
  * the app's own deployment evidence) and `src/lib/chain.ts` (the RPC and explorer origin) in the
  * Hookr app. `src/test/hookr-sdk-parity.test.ts` in that app asserts this file agrees with both,
  * so a redeploy or an RPC change that is not mirrored here fails that suite.
  *
- * There is exactly one root today: `HookrModularHookV6`, deployed as `ADDRESSES.root`. Every V2
- * pool's `PoolKey.hooks` is that address.
+ * Two roots take new markets today, and a pool names exactly one of them in `PoolKey.hooks`:
+ * `HookrModularHookV6` (`ADDRESSES.root`, the default root: the five native rules) and
+ * `HookrModularHookV6WthV5` (`ADDRESSES.recaptureRoot`: the same five rules plus the arbitrage
+ * recapture lane, whose correction executor is run by WTH). `ROOTS` pairs each with the kernel
+ * id the coordinator opens it under. Earlier recapture roots still hold trading pools; resolve
+ * any other root from the registry rather than from a list.
  */
 /** Robinhood Chain's id. */
 export const CHAIN_ID = 4663;
-/** The chain's public, keyless RPC endpoint. */
+/**
+ * The chain's public, keyless RPC endpoint. Use it for light reads only: under load it rate
+ * limits, and an over-wide `eth_getLogs` can come back as an empty array instead of an error.
+ * Anything that scans logs or must not miss data should run on a provider endpoint you own and
+ * check for failed ranges; see the README.
+ */
 export const RPC_URL = "https://rpc.mainnet.chain.robinhood.com";
 /** Origin of the chain's block explorer (Blockscout). No trailing slash. */
 export const EXPLORER_URL = "https://robinhoodchain.blockscout.com";
 /** The V2 contracts and ids a third-party integration calls or reads. */
 export const ADDRESSES = Object.freeze({
-    /** `HookrModularHookV6` — `hooks` in every V2 `PoolKey`. The one live root. */
+    /** `HookrModularHookV6` — the default root, `hooks` in every pool opened on it. */
     root: "0xb3cA29cF721380CEe8b8e4755F3865Ebc68Fe8cC",
+    /** `HookrModularHookV6WthV5` — the arbitrage-recapture root, `hooks` in every pool opened on it. */
+    recaptureRoot: "0xb914f955294799de4b891bd2EA8AF628Fa1c68CC",
     /** `HookrMarketCoordinatorV5` — opens markets, collects founding fees, resolves the share tier. */
     coordinator: "0x53A192A3fCeE94Da77916B461E0cCa2Dd6402442",
     /** `HookrKernelRouterV3` — the swap router that pays into and out of the pot. */
@@ -36,8 +47,35 @@ export const ADDRESSES = Object.freeze({
 });
 /** The native-mechanics module id every V2 pool's one module is keyed by in the registry. */
 export const MODULE_ID = "0x961091565aaf4eaa4996296fda9772957e61d18d90b965111a59ded2bbb5e774";
-/** The coordinator's kernel id for the root hook, carried in `MarketParams.kernelId`. */
+/** The coordinator's kernel id for the default root, carried in `MarketParams.kernelId`. */
 export const KERNEL_ID = "0x1be0c118b1c6520d97de31ee9f0c33069f0e715ffcdcb16c87a343752bb5be14";
+/** The coordinator's kernel id for the recapture root. */
+export const RECAPTURE_KERNEL_ID = "0xd8b6c165b82efc3b7498081f071ea4f2476e2fb9c61b2e614aba2a016f94555a";
+/** The two live roots, each with the kernel id a market opens under on it. */
+export const ROOTS = Object.freeze({
+    default: Object.freeze({ hook: ADDRESSES.root, kernelId: KERNEL_ID }),
+    recapture: Object.freeze({ hook: ADDRESSES.recaptureRoot, kernelId: RECAPTURE_KERNEL_ID }),
+});
+/**
+ * The frozen `StackLimits` correction fields a market on the recapture root must carry for its
+ * correction lane to exist at all (the app's `V2_RECAPTURE_CORRECTION`). The kernel returns before
+ * correcting when a pool's frozen `correctionExecutor` is zero, and the fields are part of the stack
+ * hash, so they are set at creation or never. `executor` is the adapter the current recapture root's
+ * profile admits, bound immutably to WTH's executor; `feePolicyId` is the id that adapter answers
+ * with; `maxVolumeBps` and `minProfitQuote` are the registry's permissive ceiling and its smallest
+ * legal floor, frozen but not enforced (WTH sizes its own corrections). The registry admits a
+ * correction executor only on a native-ETH-quoted pool, and the pool's creator is frozen beside them.
+ */
+export const RECAPTURE_CORRECTION = Object.freeze({
+    executor: "0x28AF7A3645080e926a3101461e0Ec0594D42D806",
+    feePolicyId: "0xd2653e091cb7002585fd8b1192b58f11b9c951061dc797123e37d5e2ccb45cef",
+    maxVolumeBps: 5_000,
+    minProfitQuote: 1n,
+});
+/** True when `hooks` is the recapture root, the one root whose pools carry a correction lane. */
+export function isRecaptureRoot(hooks) {
+    return hooks.toLowerCase() === ADDRESSES.recaptureRoot.toLowerCase();
+}
 /** Native ETH as a v4 currency: the zero address. Always `currency0` when it is one side of a pool. */
 export const NATIVE_ADDRESS = "0x0000000000000000000000000000000000000000";
 export function explorerAddressUrl(address) {

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 /**
- * `@hookr/sdk` — build a market on Hookr's one live root hook with a custom rule configuration,
+ * `hookr-sdk` — build a market on Hookr's live root hooks with a custom rule configuration,
  * quote and swap through Hookr's router, read markets, and claim payouts.
  *
- * There is exactly one root today: `HookrModularHookV6` on Robinhood Chain (id 4663),
- * `ADDRESSES.root` in `chain.ts`. See the README for a quickstart.
+ * Two roots are live on Robinhood Chain (id 4663): the default root `HookrModularHookV6`
+ * (`ADDRESSES.root`) and the arbitrage-recapture root `HookrModularHookV6WthV5`
+ * (`ADDRESSES.recaptureRoot`); `ROOTS` in `chain.ts` pairs each with its kernel id. See the
+ * README for a quickstart.
  */
 export * from "./chain.js";
 export * from "./abi.js";

package/dist/index.js

@@ -1,9 +1,11 @@
 /**
- * `@hookr/sdk` — build a market on Hookr's one live root hook with a custom rule configuration,
+ * `hookr-sdk` — build a market on Hookr's live root hooks with a custom rule configuration,
  * quote and swap through Hookr's router, read markets, and claim payouts.
  *
- * There is exactly one root today: `HookrModularHookV6` on Robinhood Chain (id 4663),
- * `ADDRESSES.root` in `chain.ts`. See the README for a quickstart.
+ * Two roots are live on Robinhood Chain (id 4663): the default root `HookrModularHookV6`
+ * (`ADDRESSES.root`) and the arbitrage-recapture root `HookrModularHookV6WthV5`
+ * (`ADDRESSES.recaptureRoot`); `ROOTS` in `chain.ts` pairs each with its kernel id. See the
+ * README for a quickstart.
  */
 export * from "./chain.js";
 export * from "./abi.js";

package/dist/market.d.ts

@@ -50,7 +50,8 @@ export type PoolKey = Readonly<{
 export declare function subjectIsCurrency0(subject: Address, quote: Address): boolean;
 /**
  * `HookrMarketCoordinatorV5._poolKey`: currencies sorted numerically, `fee = DYNAMIC_FEE`,
- * `hooks` the root hook (defaults to `ADDRESSES.root`, the one live root).
+ * `hooks` the root hook: `ADDRESSES.root` (the default root) unless a pool on another root is
+ * being addressed, in which case pass that root's address (a market row's `kernel`).
  */
 export declare function poolKeyFor(input: {
     subject: Address;
@@ -93,6 +94,15 @@ export declare const MODULE_GAS = 2000000;
 export declare const ZERO_BYTES32: Hex;
 /** What `HookrNativeMechanicsBlockV2.validateStack` returns for a config: the surcharge and
  *  take-bps ceilings this creator's stack is admitted at. A live chain read; see the module doc. */
+/**
+ * The root a market opens on: its hook address (`PoolKey.hooks`) and the kernel id the coordinator
+ * opens it under. `ROOTS.default` and `ROOTS.recapture` are the two current roots; the registry
+ * accepts any active kernel, so this is a product choice, not a chain constraint.
+ */
+export type RootChoice = Readonly<{
+    hook: Address;
+    kernelId: Hex;
+}>;
 export type StackCaps = Readonly<{
     configHash: Hex;
     maxLpFeeSurchargePips: number;
@@ -115,13 +125,27 @@ export type StackLimits = Readonly<{
     correctionMinProfitQuote: bigint;
     correctionFeePolicyId: Hex;
 }>;
+/** The correction lane frozen into a recapture-root pool's limits: `RECAPTURE_CORRECTION` plus the creator. */
+export type CorrectionWiring = Readonly<{
+    executor: Address;
+    creator: Address;
+    maxVolumeBps: number;
+    minProfitQuote: bigint;
+    feePolicyId: Hex;
+}>;
+/**
+ * The correction wiring a market on `root` must freeze, or null on a root that does not correct.
+ * The registry admits a correction executor only on a native-ETH-quoted pool and requires a
+ * non-zero creator, so both are checked here rather than failing on chain.
+ */
+export declare function correctionFor(root: RootChoice, quote: Address, creator: Address | undefined): CorrectionWiring | null;
 /**
  * The tightest `StackLimits` the registry admits: equal to the block's own caps, exactly as the
- * app's `v2StackLimits` sets them. `trustedRouter`/`trustedQuoter` are always `ADDRESSES.router`
+ * app's `v2StackLimits` sets them, with the correction lane frozen in when `correction` is given. `trustedRouter`/`trustedQuoter` are always `ADDRESSES.router`
  * / `ADDRESSES.quoter` today — the app's own equivalent takes them as a parameter only so its
  * tests can fake them; a real launch always wires the same two addresses this package does.
  */
-export declare function stackLimitsFor(config: NativeConfig, caps: StackCaps): StackLimits;
+export declare function stackLimitsFor(config: NativeConfig, caps: StackCaps, correction?: CorrectionWiring | null): StackLimits;
 export type ModuleSelection = Readonly<{
     moduleId: Hex;
     config: Hex;
@@ -213,6 +237,8 @@ export declare function buildNewTokenMarketCall(input: {
         deadline: bigint;
         moduleData?: Hex;
     }>;
+    /** The root to open the market on: `ROOTS.default` when omitted, or `ROOTS.recapture`. */
+    root?: RootChoice;
 }): CoordinatorCall<readonly [NewTokenArgs, Hex, Address]>;
 /**
  * Build the exact `openExistingTokenMarket` call. The existing-asset lane carries no guard, no
@@ -229,6 +255,10 @@ export declare function buildExistingTokenMarketCall(input: {
     protocolRecipient: Address;
     protocolShareBps: number;
     caps: StackCaps;
+    /** The root to open the market on: `ROOTS.default` when omitted, or `ROOTS.recapture`. */
+    root?: RootChoice;
+    /** The launching wallet; required on the recapture root, where it is frozen as the correction creator. */
+    creator?: Address;
 }): CoordinatorCall<readonly [ExistingTokenArgs]>;
 /** The calldata `encodeFunctionData` would produce for a built call, for sending with viem directly. */
 export declare function encodeMarketCall(call: CoordinatorCall<readonly unknown[]>): Hex;

package/dist/market.js

@@ -36,7 +36,7 @@
  */
 import { encodeAbiParameters, encodeFunctionData, keccak256 } from "viem";
 import { hookrMarketCoordinatorV5Abi } from "./abi.js";
-import { ADDRESSES, KERNEL_ID, MODULE_ID, NATIVE_ADDRESS } from "./chain.js";
+import { ADDRESSES, MODULE_ID, NATIVE_ADDRESS, RECAPTURE_CORRECTION, ROOTS, isRecaptureRoot } from "./chain.js";
 import { compileRuleBlocks } from "./rules.js";
 // -----------------------------------------------------------------------------------------------
 // Pool key and pool id
@@ -61,7 +61,8 @@ export function subjectIsCurrency0(subject, quote) {
 }
 /**
  * `HookrMarketCoordinatorV5._poolKey`: currencies sorted numerically, `fee = DYNAMIC_FEE`,
- * `hooks` the root hook (defaults to `ADDRESSES.root`, the one live root).
+ * `hooks` the root hook: `ADDRESSES.root` (the default root) unless a pool on another root is
+ * being addressed, in which case pass that root's address (a market row's `kernel`).
  */
 export function poolKeyFor(input) {
     const subjectFirst = subjectIsCurrency0(input.subject, input.quote);
@@ -122,13 +123,29 @@ export function guardEndBlockFor(contractBlock, guardBlocks) {
 /** The native block's registered callback gas; `limits.maxTotalModuleGas` in every fixture. */
 export const MODULE_GAS = 2_000_000;
 export const ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+/**
+ * The correction wiring a market on `root` must freeze, or null on a root that does not correct.
+ * The registry admits a correction executor only on a native-ETH-quoted pool and requires a
+ * non-zero creator, so both are checked here rather than failing on chain.
+ */
+export function correctionFor(root, quote, creator) {
+    if (!isRecaptureRoot(root.hook))
+        return null;
+    if (quote.toLowerCase() !== NATIVE_ADDRESS.toLowerCase()) {
+        throw new Error("The recapture root corrects native-ETH-quoted pools only; the registry rejects any other quote.");
+    }
+    if (!creator || creator.toLowerCase() === NATIVE_ADDRESS.toLowerCase()) {
+        throw new Error("Opening a market on the recapture root needs the creator wallet; it is frozen as the correction creator.");
+    }
+    return Object.freeze({ ...RECAPTURE_CORRECTION, creator });
+}
 /**
  * The tightest `StackLimits` the registry admits: equal to the block's own caps, exactly as the
- * app's `v2StackLimits` sets them. `trustedRouter`/`trustedQuoter` are always `ADDRESSES.router`
+ * app's `v2StackLimits` sets them, with the correction lane frozen in when `correction` is given. `trustedRouter`/`trustedQuoter` are always `ADDRESSES.router`
  * / `ADDRESSES.quoter` today — the app's own equivalent takes them as a parameter only so its
  * tests can fake them; a real launch always wires the same two addresses this package does.
  */
-export function stackLimitsFor(config, caps) {
+export function stackLimitsFor(config, caps, correction = null) {
     return Object.freeze({
         baseLpFeePips: config.baseFeePips,
         maxLpFeePips: config.baseFeePips + caps.maxLpFeeSurchargePips,
@@ -138,11 +155,11 @@ export function stackLimitsFor(config, caps) {
         maxTotalModuleGas: MODULE_GAS,
         trustedRouter: ADDRESSES.router,
         trustedQuoter: ADDRESSES.quoter,
-        correctionExecutor: NATIVE_ADDRESS,
-        correctionCreator: NATIVE_ADDRESS,
-        correctionMaxVolumeBps: 0,
-        correctionMinProfitQuote: 0n,
-        correctionFeePolicyId: ZERO_BYTES32,
+        correctionExecutor: correction?.executor ?? NATIVE_ADDRESS,
+        correctionCreator: correction?.creator ?? NATIVE_ADDRESS,
+        correctionMaxVolumeBps: correction?.maxVolumeBps ?? 0,
+        correctionMinProfitQuote: correction?.minProfitQuote ?? 0n,
+        correctionFeePolicyId: correction?.feePolicyId ?? ZERO_BYTES32,
     });
 }
 const NO_INITIAL_BUY = Object.freeze({
@@ -157,7 +174,7 @@ function buildNativeConfig(input) {
     const guardOn = lane === "new" && (rules.guardBlocks ?? 0) > 0;
     return Object.freeze({
         poolId: input.poolId,
-        kernel: ADDRESSES.root,
+        kernel: input.kernel ?? ADDRESSES.root,
         subject: input.subject,
         quote: input.quote,
         lockedLiquidityProvider: guardOn ? ADDRESSES.coordinator : NATIVE_ADDRESS,
@@ -186,10 +203,12 @@ function buildNativeConfig(input) {
  * an allowance, exactly like the app).
  */
 export function buildNewTokenMarketCall(input) {
+    const root = input.root ?? ROOTS.default;
     const subject = input.expectedToken;
-    const poolId = poolIdFor(poolKeyFor({ subject, quote: input.quote, tickSpacing: input.tickSpacing }));
+    const poolId = poolIdFor(poolKeyFor({ subject, quote: input.quote, tickSpacing: input.tickSpacing, hooks: root.hook }));
     const config = buildNativeConfig({
         lane: "new",
+        kernel: root.hook,
         rules: input.rules,
         poolId,
         subject,
@@ -199,7 +218,7 @@ export function buildNewTokenMarketCall(input) {
         protocolShareBps: input.protocolShareBps,
     });
     const encodedConfig = encodeNativeBlockConfig(config);
-    const limits = stackLimitsFor(config, input.caps);
+    const limits = stackLimitsFor(config, input.caps, correctionFor(root, input.quote, input.creator));
     const market = {
         quote: input.quote,
         subjectAmount: input.totalSupply,
@@ -207,7 +226,7 @@ export function buildNewTokenMarketCall(input) {
         lpFeeRecipient: input.lpFeeRecipient ?? input.creator,
         tickSpacing: input.tickSpacing,
         sqrtPriceX96: input.sqrtPriceX96,
-        kernelId: KERNEL_ID,
+        kernelId: root.kernelId,
         modules: [{ moduleId: MODULE_ID, config: encodedConfig }],
         limits,
     };
@@ -246,9 +265,11 @@ export function buildNewTokenMarketCall(input) {
  * refuses a guard on this lane rather than silently applying it.
  */
 export function buildExistingTokenMarketCall(input) {
-    const poolId = poolIdFor(poolKeyFor({ subject: input.subject, quote: input.quote, tickSpacing: input.tickSpacing }));
+    const root = input.root ?? ROOTS.default;
+    const poolId = poolIdFor(poolKeyFor({ subject: input.subject, quote: input.quote, tickSpacing: input.tickSpacing, hooks: root.hook }));
     const config = buildNativeConfig({
         lane: "existing",
+        kernel: root.hook,
         rules: input.rules,
         poolId,
         subject: input.subject,
@@ -258,7 +279,7 @@ export function buildExistingTokenMarketCall(input) {
         protocolShareBps: input.protocolShareBps,
     });
     const encodedConfig = encodeNativeBlockConfig(config);
-    const limits = stackLimitsFor(config, input.caps);
+    const limits = stackLimitsFor(config, input.caps, correctionFor(root, input.quote, input.creator));
     const market = {
         quote: input.quote,
         subjectAmount: 0n,
@@ -266,7 +287,7 @@ export function buildExistingTokenMarketCall(input) {
         lpFeeRecipient: NATIVE_ADDRESS,
         tickSpacing: input.tickSpacing,
         sqrtPriceX96: input.sqrtPriceX96,
-        kernelId: KERNEL_ID,
+        kernelId: root.kernelId,
         modules: [{ moduleId: MODULE_ID, config: encodedConfig }],
         limits,
     };

package/dist/reads.d.ts

@@ -45,6 +45,13 @@ export type Market = Readonly<{
 export declare function readMarket(client: PublicClient, poolId: Hex): Promise<Market>;
 /** The coordinator's deploy block on chain 4663: no `MarketCreated` log can sit before it. */
 export declare const MARKET_SCAN_FROM_BLOCK = 57229676n;
+/**
+ * Blocks per `eth_getLogs` window in `listMarkets`, the same width the app's own scanners use.
+ * The chain's public node answers an over-wide window with an empty array rather than an error,
+ * so one request over the whole history is a silent miss waiting to happen; a bounded window
+ * keeps each answer small. Lower it further on a provider with a tighter range limit.
+ */
+export declare const MARKET_SCAN_CHUNK_BLOCKS = 3000000n;
 export declare const MARKET_CREATED_TOPIC: Hex;
 /** One decoded `MarketCreated` log: every field the coordinator emitted, nothing derived. */
 export type MarketRow = Readonly<{
@@ -61,17 +68,19 @@ export type MarketRow = Readonly<{
     logIndex: number;
 }>;
 /**
- * Every `MarketCreated` log the coordinator emitted in `[fromBlock, toBlock]`, oldest first.
+ * Every `MarketCreated` log the coordinator emitted in `[fromBlock, toBlock]`, oldest first,
+ * fetched in windows of `chunkBlocks` (`MARKET_SCAN_CHUNK_BLOCKS` by default).
  *
  * `root`, when given, is checked against every row's `kernel` rather than passed to the log
- * filter: `kernel` is not an indexed topic, and there is exactly one live root today
- * (`ADDRESSES.root`), so every row already carries it. A future second root would need a
- * client-side filter here, which is exactly what this parameter is for.
+ * filter, because `kernel` is not an indexed topic. Pass `ADDRESSES.root` for markets on the
+ * default root, `ADDRESSES.recaptureRoot` for markets on the recapture root, or nothing for
+ * every market the coordinator opened, on any root.
  */
 export declare function listMarkets(client: PublicClient, options?: Readonly<{
     root?: Address;
     fromBlock?: bigint;
     toBlock?: bigint;
+    chunkBlocks?: bigint;
 }>): Promise<readonly MarketRow[]>;
 /** The inverse of `market.ts`'s `encodeNativeBlockConfig`. */
 export declare function decodeNativeBlockConfig(data: Hex): NativeConfig;
@@ -89,3 +98,39 @@ export type PoolRules = Readonly<{
  * by this package.
  */
 export declare function readPoolRules(client: PublicClient, poolId: Hex): Promise<PoolRules>;
+/**
+ * True when the pool's frozen rules name a correction executor, so the root's kernel dispatches a
+ * correction around every swap and the swap needs `CORRECTION_SWAP_GAS_FLOOR`. This is the pool's
+ * own record rather than the root's identity: a pool on a superseded recapture root keeps its
+ * executor and keeps correcting, which `isCorrectingRoot` (current root only) does not see. Pass
+ * the result as `correcting` to the swap builders. It is also true for a pool whose lane cannot
+ * run on ordinary gas (the first recapture root); the floor is then unused headroom, not a loss.
+ */
+export declare function poolCorrects(rules: PoolRules): boolean;
+/** `HookrStackRegistryV1.KernelStatus`. */
+export type RootStatus = "unset" | "active" | "retired";
+/** One registered root (kernel) as the stack registry records it. */
+export type RootRow = Readonly<{
+    kernelId: Hex;
+    /** The root hook: `PoolKey.hooks` for every pool opened on it. */
+    hook: Address;
+    version: number;
+    codeHash: Hex;
+    hookFlags: bigint;
+    status: RootStatus;
+    /** True when the registry holds a sealed root profile for this kernel; the coordinator only
+     *  opens markets on a sealed profile. */
+    sealed: boolean;
+    profileId: Hex | null;
+    moduleCount: number | null;
+}>;
+/**
+ * Every kernel the stack registry has registered, in registration order: `kernelCount`, then
+ * `kernelIdAt`, `kernel`, `kernelStatus` and `rootProfile` for each. Nothing here comes from a
+ * list in this package, so a root this package has never heard of still appears. `rootProfile`
+ * reverts for a kernel whose profile was never sealed; that reads as `sealed: false`.
+ *
+ * The registry never retires a root on its own, so an active, sealed root is not the same thing
+ * as a current one: `ROOTS` names the two roots Hookr opens markets on today.
+ */
+export declare function listRoots(client: PublicClient): Promise<readonly RootRow[]>;

package/dist/reads.js

@@ -11,7 +11,7 @@
  */
 import { decodeAbiParameters, getAbiItem, toEventSelector } from "viem";
 import { hookrMarketCoordinatorV5Abi, hookrStackRegistryV2Abi } from "./abi.js";
-import { ADDRESSES, MODULE_ID } from "./chain.js";
+import { ADDRESSES, MODULE_ID, NATIVE_ADDRESS } from "./chain.js";
 function marketOrigin(value) {
     if (value === 1)
         return "new-token";
@@ -34,26 +34,41 @@ export async function readMarket(client, poolId) {
 // -----------------------------------------------------------------------------------------------
 /** The coordinator's deploy block on chain 4663: no `MarketCreated` log can sit before it. */
 export const MARKET_SCAN_FROM_BLOCK = 57229676n;
+/**
+ * Blocks per `eth_getLogs` window in `listMarkets`, the same width the app's own scanners use.
+ * The chain's public node answers an over-wide window with an empty array rather than an error,
+ * so one request over the whole history is a silent miss waiting to happen; a bounded window
+ * keeps each answer small. Lower it further on a provider with a tighter range limit.
+ */
+export const MARKET_SCAN_CHUNK_BLOCKS = 3000000n;
 const MARKET_CREATED_EVENT = getAbiItem({ abi: hookrMarketCoordinatorV5Abi, name: "MarketCreated" });
 export const MARKET_CREATED_TOPIC = toEventSelector(MARKET_CREATED_EVENT);
 /**
- * Every `MarketCreated` log the coordinator emitted in `[fromBlock, toBlock]`, oldest first.
+ * Every `MarketCreated` log the coordinator emitted in `[fromBlock, toBlock]`, oldest first,
+ * fetched in windows of `chunkBlocks` (`MARKET_SCAN_CHUNK_BLOCKS` by default).
  *
  * `root`, when given, is checked against every row's `kernel` rather than passed to the log
- * filter: `kernel` is not an indexed topic, and there is exactly one live root today
- * (`ADDRESSES.root`), so every row already carries it. A future second root would need a
- * client-side filter here, which is exactly what this parameter is for.
+ * filter, because `kernel` is not an indexed topic. Pass `ADDRESSES.root` for markets on the
+ * default root, `ADDRESSES.recaptureRoot` for markets on the recapture root, or nothing for
+ * every market the coordinator opened, on any root.
  */
 export async function listMarkets(client, options = {}) {
     const fromBlock = options.fromBlock ?? MARKET_SCAN_FROM_BLOCK;
     const toBlock = options.toBlock ?? (await client.getBlockNumber());
-    const logs = await client.getLogs({
-        address: ADDRESSES.coordinator,
-        event: MARKET_CREATED_EVENT,
-        fromBlock,
-        toBlock,
-        strict: true,
-    });
+    const chunk = options.chunkBlocks ?? MARKET_SCAN_CHUNK_BLOCKS;
+    if (chunk <= 0n)
+        throw new Error("chunkBlocks must be positive.");
+    const logs = [];
+    for (let from = fromBlock; from <= toBlock; from += chunk) {
+        const to = from + chunk - 1n < toBlock ? from + chunk - 1n : toBlock;
+        logs.push(...(await client.getLogs({
+            address: ADDRESSES.coordinator,
+            event: MARKET_CREATED_EVENT,
+            fromBlock: from,
+            toBlock: to,
+            strict: true,
+        })));
+    }
     const rows = [];
     for (const log of logs) {
         const args = log.args;
@@ -138,3 +153,67 @@ export async function readPoolRules(client, poolId) {
     }
     return Object.freeze({ configured: true, limits: core.limits, nativeConfig });
 }
+/**
+ * True when the pool's frozen rules name a correction executor, so the root's kernel dispatches a
+ * correction around every swap and the swap needs `CORRECTION_SWAP_GAS_FLOOR`. This is the pool's
+ * own record rather than the root's identity: a pool on a superseded recapture root keeps its
+ * executor and keeps correcting, which `isCorrectingRoot` (current root only) does not see. Pass
+ * the result as `correcting` to the swap builders. It is also true for a pool whose lane cannot
+ * run on ordinary gas (the first recapture root); the floor is then unused headroom, not a loss.
+ */
+export function poolCorrects(rules) {
+    const executor = rules.limits?.correctionExecutor;
+    return executor !== undefined && executor.toLowerCase() !== NATIVE_ADDRESS.toLowerCase();
+}
+function rootStatus(value) {
+    if (value === 0)
+        return "unset";
+    if (value === 1)
+        return "active";
+    if (value === 2)
+        return "retired";
+    throw new Error(`Unknown KernelStatus ${value}.`);
+}
+/**
+ * Every kernel the stack registry has registered, in registration order: `kernelCount`, then
+ * `kernelIdAt`, `kernel`, `kernelStatus` and `rootProfile` for each. Nothing here comes from a
+ * list in this package, so a root this package has never heard of still appears. `rootProfile`
+ * reverts for a kernel whose profile was never sealed; that reads as `sealed: false`.
+ *
+ * The registry never retires a root on its own, so an active, sealed root is not the same thing
+ * as a current one: `ROOTS` names the two roots Hookr opens markets on today.
+ */
+export async function listRoots(client) {
+    const registry = { address: ADDRESSES.registry, abi: hookrStackRegistryV2Abi };
+    const count = (await client.readContract({ ...registry, functionName: "kernelCount" }));
+    const rows = [];
+    for (let i = 0n; i < count; i++) {
+        const kernelId = (await client.readContract({ ...registry, functionName: "kernelIdAt", args: [i] }));
+        const record = (await client.readContract({ ...registry, functionName: "kernel", args: [kernelId] }));
+        const status = (await client.readContract({ ...registry, functionName: "kernelStatus", args: [kernelId] }));
+        let sealed = false;
+        let profileId = null;
+        let moduleCount = null;
+        try {
+            const profile = (await client.readContract({ ...registry, functionName: "rootProfile", args: [kernelId] }));
+            sealed = profile.isSealed;
+            profileId = profile.profileId;
+            moduleCount = profile.moduleCount;
+        }
+        catch {
+            // Unsealed: the registry reverts rather than returning an empty profile.
+        }
+        rows.push(Object.freeze({
+            kernelId,
+            hook: record.implementation,
+            version: record.version,
+            codeHash: record.implementationCodeHash,
+            hookFlags: record.hookFlags,
+            status: rootStatus(status),
+            sealed,
+            profileId,
+            moduleCount,
+        }));
+    }
+    return rows;
+}

package/dist/swap.d.ts

@@ -10,6 +10,28 @@
 import type { Address, ContractFunctionArgs, Hex, PublicClient } from "viem";
 import { hookrKernelRouterV3Abi } from "./abi.js";
 import type { PoolKey } from "./market.js";
+/**
+ * The gas limit a swap on a correcting root must carry (the app's `CORRECTION_SWAP_GAS_FLOOR` in
+ * `src/lib/gas-headroom.ts`). The recapture root runs its correction in both swap phases, once in
+ * `beforeSwap` and again in `afterSwap` (`HookrSwapKernelV5Wth.sol`, `_tryCorrection` at lines 214
+ * and 250), each inside a bounded call that fails open: a wallet's gas estimate covers the swap
+ * alone, so an estimated transaction succeeds with the correction skipped and nothing recaptured.
+ * The swap builders below put this floor on the call whenever `key.hooks` is the current recapture
+ * root, or whenever the caller passes `correcting: true`; pass it through to `writeContract` (viem
+ * sends `gas` as the limit) instead of estimating.
+ */
+export declare const CORRECTION_SWAP_GAS_FLOOR = 1100000n;
+/**
+ * True when `hooks` is the current recapture root, which corrects in both swap phases. This is the
+ * root's identity, not the pool's: a pool opened on a superseded recapture root keeps the executor
+ * frozen into its rules and keeps correcting, and this returns false for it. Read that from the
+ * pool itself with `poolCorrects(await readPoolRules(client, poolId))` and pass the answer as
+ * `correcting` to the swap builders.
+ */
+export declare function isCorrectingRoot(hooks: Address): boolean;
+/** The gas limit to send with a swap on `key`: the floor when the pool corrects (`correcting`,
+ *  defaulting to `isCorrectingRoot(key.hooks)`), else `undefined` (let the wallet estimate). */
+export declare function swapGasLimit(key: PoolKey, correcting?: boolean): bigint | undefined;
 /** Router / block `MIN_SQRT_PRICE_LIMIT`: the full-fill limit for a `zeroForOne` swap. */
 export declare const MIN_SQRT_PRICE_LIMIT = 4295128740n;
 /** Router / block `MAX_SQRT_PRICE_LIMIT`: the full-fill limit for a `oneForZero` swap. */
@@ -31,10 +53,14 @@ export type RouterCall<F extends "exactInput" | "exactOutput"> = Readonly<{
     functionName: F;
     args: ContractFunctionArgs<typeof hookrKernelRouterV3Abi, "payable", F>;
     value: bigint;
+    /** Set to `CORRECTION_SWAP_GAS_FLOOR` when the pool corrects; absent otherwise. */
+    gas?: bigint;
 }>;
 /**
  * `exactInput` through the Hookr router. `value` is `amountIn` when `currencyIn` is native ETH,
- * else 0 (the router pulls the ERC-20 by `transferFrom`; approve it first).
+ * else 0 (the router pulls the ERC-20 by `transferFrom`; approve it first). `gas` carries the
+ * correction floor when the pool corrects; send it as the gas limit. `correcting` defaults to
+ * `isCorrectingRoot(key.hooks)`; pass `poolCorrects(rules)` for a pool on a superseded root.
  */
 export declare function buildExactInputSwapCall(input: {
     key: PoolKey;
@@ -43,10 +69,12 @@ export declare function buildExactInputSwapCall(input: {
     amountOutMinimum: bigint;
     recipient: Address;
     deadline: bigint;
+    correcting?: boolean;
 }): RouterCall<"exactInput">;
 /**
  * `exactOutput` through the Hookr router. `value` is `amountInMaximum` when `currencyIn` is
- * native ETH — the router refunds what the swap does not use.
+ * native ETH — the router refunds what the swap does not use. `correcting` works as on
+ * `buildExactInputSwapCall`.
  */
 export declare function buildExactOutputSwapCall(input: {
     key: PoolKey;
@@ -55,6 +83,7 @@ export declare function buildExactOutputSwapCall(input: {
     amountInMaximum: bigint;
     recipient: Address;
     deadline: bigint;
+    correcting?: boolean;
 }): RouterCall<"exactOutput">;
 export type Quote = Readonly<{
     amountIn: bigint;

package/dist/swap.js

@@ -1,5 +1,31 @@
 import { hookrKernelQuoterV1Abi, hookrKernelRouterV3Abi } from "./abi.js";
 import { ADDRESSES, NATIVE_ADDRESS } from "./chain.js";
+/**
+ * The gas limit a swap on a correcting root must carry (the app's `CORRECTION_SWAP_GAS_FLOOR` in
+ * `src/lib/gas-headroom.ts`). The recapture root runs its correction in both swap phases, once in
+ * `beforeSwap` and again in `afterSwap` (`HookrSwapKernelV5Wth.sol`, `_tryCorrection` at lines 214
+ * and 250), each inside a bounded call that fails open: a wallet's gas estimate covers the swap
+ * alone, so an estimated transaction succeeds with the correction skipped and nothing recaptured.
+ * The swap builders below put this floor on the call whenever `key.hooks` is the current recapture
+ * root, or whenever the caller passes `correcting: true`; pass it through to `writeContract` (viem
+ * sends `gas` as the limit) instead of estimating.
+ */
+export const CORRECTION_SWAP_GAS_FLOOR = 1100000n;
+/**
+ * True when `hooks` is the current recapture root, which corrects in both swap phases. This is the
+ * root's identity, not the pool's: a pool opened on a superseded recapture root keeps the executor
+ * frozen into its rules and keeps correcting, and this returns false for it. Read that from the
+ * pool itself with `poolCorrects(await readPoolRules(client, poolId))` and pass the answer as
+ * `correcting` to the swap builders.
+ */
+export function isCorrectingRoot(hooks) {
+    return hooks.toLowerCase() === ADDRESSES.recaptureRoot.toLowerCase();
+}
+/** The gas limit to send with a swap on `key`: the floor when the pool corrects (`correcting`,
+ *  defaulting to `isCorrectingRoot(key.hooks)`), else `undefined` (let the wallet estimate). */
+export function swapGasLimit(key, correcting) {
+    return (correcting ?? isCorrectingRoot(key.hooks)) ? CORRECTION_SWAP_GAS_FLOOR : undefined;
+}
 /** Router / block `MIN_SQRT_PRICE_LIMIT`: the full-fill limit for a `zeroForOne` swap. */
 export const MIN_SQRT_PRICE_LIMIT = 4295128740n;
 /** Router / block `MAX_SQRT_PRICE_LIMIT`: the full-fill limit for a `oneForZero` swap. */
@@ -26,11 +52,14 @@ export function swapDirection(key, currencyIn) {
 }
 /**
  * `exactInput` through the Hookr router. `value` is `amountIn` when `currencyIn` is native ETH,
- * else 0 (the router pulls the ERC-20 by `transferFrom`; approve it first).
+ * else 0 (the router pulls the ERC-20 by `transferFrom`; approve it first). `gas` carries the
+ * correction floor when the pool corrects; send it as the gas limit. `correcting` defaults to
+ * `isCorrectingRoot(key.hooks)`; pass `poolCorrects(rules)` for a pool on a superseded root.
  */
 export function buildExactInputSwapCall(input) {
     const zeroForOne = swapDirection(input.key, input.currencyIn);
     const native = input.currencyIn.toLowerCase() === NATIVE_ADDRESS.toLowerCase();
+    const gas = swapGasLimit(input.key, input.correcting);
     return Object.freeze({
         address: ADDRESSES.router,
         abi: hookrKernelRouterV3Abi,
@@ -48,15 +77,18 @@ export function buildExactInputSwapCall(input) {
             EMPTY_MODULE_DATA,
         ],
         value: native ? input.amountIn : 0n,
+        ...(gas === undefined ? {} : { gas }),
     });
 }
 /**
  * `exactOutput` through the Hookr router. `value` is `amountInMaximum` when `currencyIn` is
- * native ETH — the router refunds what the swap does not use.
+ * native ETH — the router refunds what the swap does not use. `correcting` works as on
+ * `buildExactInputSwapCall`.
  */
 export function buildExactOutputSwapCall(input) {
     const zeroForOne = swapDirection(input.key, input.currencyIn);
     const native = input.currencyIn.toLowerCase() === NATIVE_ADDRESS.toLowerCase();
+    const gas = swapGasLimit(input.key, input.correcting);
     return Object.freeze({
         address: ADDRESSES.router,
         abi: hookrKernelRouterV3Abi,
@@ -74,6 +106,7 @@ export function buildExactOutputSwapCall(input) {
             EMPTY_MODULE_DATA,
         ],
         value: native ? input.amountInMaximum : 0n,
+        ...(gas === undefined ? {} : { gas }),
     });
 }
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hookr-sdk",
-  "version": "0.1.0",
-  "description": "Build a market on Hookr's live root hook, quote and swap through its router, read markets, and claim payouts.",
+  "version": "0.2.1",
+  "description": "Build a market on Hookr's live root hooks, quote and swap through its router, read markets, and claim payouts.",
   "type": "module",
   "license": "MIT",
   "repository": {