@logswap/sdk 0.5.65 → 0.5.67

package/src/client.ts

@@ -165,7 +165,19 @@ export const EXPECTED_VERSION = 5n;
 // is the policy at birth, `migrate` moves a pool for the registry's owner; `stamp` / `setAsks` are
 // the policy's; the desk's `setAllowed` / `isAllowed` are `setMinters` / `setTakers` / `isMinter` /
 // `isTaker`; a pad and a POL hold one base (`OneBase`).
-export const EXPECTED_F_VERSION = 19n;
+// 18–19: no role, no kind and no name on the manager (049); the events carry what a reader needs (050).
+// 20 (2026-09-25, logswap-contract #53): policy isolation — `PolicyRegistry.migrate(manager, key, to)`
+// takes the pool's KEY (was its id), `kindOf(policy)` is the tag recorded at approval, the
+// registry emits `Migrated`; `IFPolicy.onMigrate` is brought the creator, authority and name;
+// the desk's lists are keyed by `listEpoch`. The manager's ABI did not move.
+// 21 (2026-09-26, #54): `regenerate` is the generation step — the policy's `Terms` name a
+// `carried` holder (a fifth word, 160 B), every other holder is frozen out pro rata into
+// generation g's bundle and redeems it (`fPoolRedeem` / `fPoolRollIn` with gen = g), and the
+// pool goes on as g + 1. The manager lost `FEE_MIN` / `FEE_MAX` (see keys.ts), `harvestable`
+// (the bid: `getPool().Q` when L > 0), `idOf(FPoolKey)` (hashed locally, `fPoolIdOfKey`) and
+// `reserveOf` (`legOf`'s fourth word). `PadPolicy.rung` is gone: the pad's rung is `gen`, the
+// next threshold `threshold(gen)`. A pad never retires; a public pool refuses `regenerate`.
+export const EXPECTED_F_VERSION = 21n;
 
 export async function assertVersion(c: LogswapClient, expected = EXPECTED_VERSION): Promise<void> {
   const { cPoolManagerAbi, fPoolManagerAbi } = await import("./generated.js");

package/src/fpool.ts

@@ -30,7 +30,7 @@
  * `addresses.router`.
  */
 
-import { encodeFunctionData, toFunctionSelector, type Address, type Hash, type Hex } from "viem";
+import { encodeAbiParameters, encodeFunctionData, keccak256, toFunctionSelector, type Address, type Hash, type Hex } from "viem";
 import { fPoolManagerAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 
 /**
@@ -99,9 +99,12 @@ export interface FPoolState {
   /** False before the first seed — and between a retire and the next one. */
   seeded: boolean;
   /**
-   * The live GENERATION. Every retire freezes one into a bundle its shares
-   * redeem ({@link fPoolRedeem}) and opens the next; the share id carries it
-   * ({@link fPoolShareId}), so generations `0 … gen-1` are retired claims and `gen` is the pool.
+   * The live GENERATION. Every retire freezes one into a bundle its shares redeem
+   * ({@link fPoolRedeem}) and opens the next; since F version 21 so does every `regenerate`
+   * (the generation step, {@link fPoolRegenerate}): the carried holder and the dead shares go on
+   * as `gen + 1`, every other holder of `gen` is frozen out into its bundle. The share id carries
+   * it ({@link fPoolShareId}), so generations `0 … gen-1` are claims ({@link fPoolClaimsOf}) and
+   * `gen` is the pool. On a pad, `gen` is the graduation count — the rung.
    */
   gen: number;
   totalSupply: bigint;
@@ -272,7 +275,7 @@ export interface FPoolRoles {
   pendingOperator: Address;
   gateMint: boolean;
   gateSwap: boolean;
-  /** The policy's own ceiling on a harvest now — the manager's `harvestable` narrowed by the policy's rule. */
+  /** The policy's own ceiling on a harvest now — the bid ({@link FPoolDescription.harvestable}) narrowed by the policy's rule. */
   maxHarvest: bigint;
 }
 
@@ -314,7 +317,12 @@ export interface FPoolDescription {
    * from the first wei after it.
    */
   unharvested: bigint;
-  /** The most a harvest may take now by the KIND's promise: the bid, and on a pad the income. The policy may allow less — {@link FPoolRoles.maxHarvest}. */
+  /**
+   * The most a harvest may take now by the MANAGER's rule: the bid, `Q` once seeded (0 before).
+   * The manager's `harvestable()` getter was cut in F version 21; this is the same number, read
+   * off `getPool`. The policy may allow less (a pad: the income; a POL: above `keepQuote`) —
+   * {@link FPoolRoles.maxHarvest}.
+   */
   harvestable: bigint;
   /** The dead shares' banked dividend — a pad's pot, the creator's income until a rung is climbed. */
   pot: bigint;
@@ -328,10 +336,12 @@ export async function describeFPool(c: LogswapClient, s: FPoolState): Promise<FP
       functionName,
       args,
     } as never) as Promise<T>;
-  // an unseeded pool has no L: nothing earned, nothing to harvest, no pot
-  const [unharvested, harvestable, pot] = s.L > 0n
-    ? await Promise.all([rd<bigint>("unharvested"), rd<bigint>("harvestable"), rd<bigint>("dividendOf", [s.poolId, BigInt(s.gen), DEAD_ADDRESS])])
-    : [0n, 0n, 0n];
+  // an unseeded pool has no L: nothing earned, nothing to harvest, no pot. The bid is the
+  // manager's ceiling (`harvestable()` until F version 21, which cut the getter): Q once seeded.
+  const harvestable = s.L > 0n ? s.Q : 0n;
+  const [unharvested, pot] = s.L > 0n
+    ? await Promise.all([rd<bigint>("unharvested"), rd<bigint>("dividendOf", [s.poolId, BigInt(s.gen), DEAD_ADDRESS])])
+    : [0n, 0n];
   return {
     shape: s.kind === "pad" ? "launch": "basket", // the kind, not n = 1 
     legs: s.bases.length,
@@ -985,7 +995,50 @@ export function sortFPoolLegs<T>(bases: Address[], ...companions: T[][]): { base
 }
 
 /** The key as the manager hashes it: legs sorted, the kind's policy filled in when none is named; no kind in it (049). */
-export function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">) {
+/**
+ * The tuple an F pool's id hashes — `src/types/FPoolKey.sol`, field order load-bearing (it is
+ * the ABI encoding order). Stored by the manager at `initialize` and never in calldata again,
+ * except `PolicyRegistry.migrate` (F version 20), which is handed it to check against the id.
+ */
+export interface FPoolKey {
+  quote: Address;
+  /** Sorted ascending, unique. */
+  bases: Address[];
+  /** WAD, aligned with `bases`, summing to 1e18. */
+  weights: bigint[];
+  phi: bigint;
+  /** The policy AT BIRTH — not the live one after a move. */
+  policy: Address;
+  creator: Address;
+  salt: Hex;
+}
+
+const F_POOL_KEY_ABI = [
+  {
+    type: "tuple",
+    components: [
+      { name: "quote", type: "address" },
+      { name: "bases", type: "address[]" },
+      { name: "weights", type: "uint256[]" },
+      { name: "phi", type: "uint256" },
+      { name: "policy", type: "address" },
+      { name: "creator", type: "address" },
+      { name: "salt", type: "bytes32" },
+    ],
+  },
+] as const;
+
+/**
+ * An F pool's id: `keccak256(abi.encode(key))`, offline — what `initialize` computes inline. The
+ * manager's `idOf(FPoolKey)` getter was cut in F version 21; this is the same hash (checked
+ * against Foundry's encoder and the local deployment's pools in the tests). The key must be the
+ * one the pool was initialized with: legs sorted ({@link fPoolKeyOf} sorts them), the birth policy.
+ */
+export function fPoolIdOfKey(key: FPoolKey): Hex {
+  return keccak256(encodeAbiParameters(F_POOL_KEY_ABI, [key]));
+}
+
+export function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): FPoolKey {
   const { bases, companions } = sortFPoolLegs(a.bases, a.weights);
   return {
     quote: a.quote,
@@ -1014,15 +1067,47 @@ export async function fPoolInitialize(c: LogswapClient, a: FPoolCreateArgs) {
   return c.wallet!.writeContract(request as never);
 }
 
-/** The pool id is the key's hash — pure, so it can be read before or after creation. */
+/**
+ * The pool id is the key's hash — pure, so it can be read before or after creation. Computed
+ * locally since F version 21 ({@link fPoolIdOfKey}; the manager's `idOf` is gone): no RPC. Still
+ * async, so callers written against the read keep working.
+ */
 export async function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): Promise<Hex> {
-  const key = fPoolKeyOf(c, a);
-  return c.public.readContract({
+  return fPoolIdOfKey(fPoolKeyOf(c, a));
+}
+
+/**
+ * Rebuild a live pool's KEY from its id: the `FInitialize` log carries every field but the salt,
+ * which is taken from `opts.salt` (zero by default — every pool the SDK's create flow makes
+ * without naming one). The result is checked against the id, so a wrong salt throws rather than
+ * returning a key that names another pool. What {@link fPoolMigrate} needs when handed an id.
+ */
+export async function fPoolKeyOfPool(c: LogswapClient, poolId: Hex, opts: { salt?: Hex; fromBlock?: bigint } = {}): Promise<FPoolKey> {
+  type Ev = Extract<(typeof fPoolManagerAbi)[number], { type: "event"; name: "FInitialize" }>;
+  const ev = fPoolManagerAbi.find((x): x is Ev => x.type === "event" && x.name === "FInitialize")!;
+  const logs = await c.public.getLogs({
     address: c.addresses.fPoolManager!,
-    abi: fPoolManagerAbi,
-    functionName: "idOf",
-    args: [key],
-  } as never) as Promise<Hex>;
+    event: ev,
+    args: { poolId },
+    fromBlock: opts.fromBlock ?? 0n,
+    toBlock: "latest",
+  });
+  const l = logs[0];
+  if (!l) throw new Error(`logswap: no FInitialize for F pool ${poolId}`);
+  const a = l.args as { quote: Address; creator: Address; bases: readonly Address[]; weights: readonly bigint[]; phi: bigint; policy: Address };
+  const key: FPoolKey = {
+    quote: a.quote,
+    bases: [...a.bases],
+    weights: [...a.weights],
+    phi: a.phi,
+    policy: a.policy,
+    creator: a.creator,
+    salt: opts.salt ?? ZERO_SALT,
+  };
+  if (fPoolIdOfKey(key).toLowerCase() !== poolId.toLowerCase()) {
+    throw new Error(`logswap: F pool ${poolId} was not born with salt ${key.salt} — pass its salt, or its whole key`);
+  }
+  return key;
 }
 
 /**
@@ -1068,7 +1153,7 @@ export async function fPoolRetireRaw(c: LogswapClient, a: { poolId: Hex; account
  * Retire the live generation as ONE transaction: the harvest that empties the bid
  * ({@link fPoolEmptyingHarvests} — a dividend to every share; none when it is already empty),
  * then `retire` — the manager's `multicall`, the operator as sender. What a sponsor's
- * "retire" button should call. Throws before sending on a pad that still bids.
+ * "retire" button should call. Throws before sending on a pad: a pad never retires (F version 21).
  */
 export async function fPoolRetire(c: LogswapClient, a: { poolId: Hex; account: Address }) {
   const harvests = await fPoolEmptyingHarvests(c, a.poolId);
@@ -1083,26 +1168,39 @@ export async function fPoolRetire(c: LogswapClient, a: { poolId: Hex; account: A
  * The harvests that empty an unlocked pool's bid, in order — what a relaunch sends before its
  * `retire` (a retire needs an empty bid on every pool). Since F version 14 one
  * `harvest(Q)` does it: the protocol's cut leaves the pool with the amount (with no collector
- * there is no cut). `[]` when the bid is already empty. Throws on a pad that still bids (its bid
- * empties only as the market sells it down), and when the pool's policy keeps a floor on the bid
+ * there is no cut). `[]` when the bid is already empty. Throws on a pad (F version 21: a pad
+ * never retires, whatever its bid), and when the pool's policy keeps a floor on the bid
  * (`PolPolicy.keepQuote`): a `retire` under that policy waits for the market.
  */
 export async function fPoolEmptyingHarvests(c: LogswapClient, poolId: Hex): Promise<bigint[]> {
   const s = await getFPool(c, poolId);
+  // F version 21: `PadPolicy` refuses `retire` at any bid — a pad graduates (regenerate), it
+  // never closes; a fresh start is a new pad with a new id
+  if (s.kind === "pad") throw new Error("logswap: a pad never retires (F version 21) — it graduates by regenerate; a fresh start is a new pad");
   if (s.Q === 0n) return [];
-  if (s.kind === "pad") throw new Error("logswap: a pad is retired only once its bid is empty");
   const { maxHarvest } = await getFPoolRoles(c, poolId, s);
   if (maxHarvest < s.Q) throw new Error("logswap: the pool's policy keeps a floor on the bid — it cannot be harvested empty");
   return [s.Q];
 }
 
 /**
- * Release the dead shares' pot under the policy's terms — a pad's graduation.
- * The manager harvests the generation's income first (the pot then holds everything the dead
- * shares earned), asks the policy, and applies its answer: a share to the payee it names (the pad's
- * creator — the pool's authority), a cut to the collector, the rest bought in as more of the
- * float the pool owns, a slice of every reserve burned. The policy refuses under its rung's
- * threshold (`PadPolicy.NotGraduated`). Whoever runs the pool.
+ * The GENERATION STEP (F version 21) — on a pad, its graduation. The manager harvests the
+ * generation's income first, releases the dead shares' pot, and asks the policy
+ * (`onRegenerate`), whose {@link FPolicyTerms} name a `carried` holder. Then, for live
+ * generation `g`:
+ *
+ * - the carried holder's and the dead shares' `g` shares are re-minted 1:1 as `g + 1`: they go on
+ *   as the pool;
+ * - every OTHER holder of `g` is frozen out pro rata into generation `g`'s bundle (`Retired(g, …)`)
+ *   and redeems it with {@link fPoolRedeem} / rolls it with {@link fPoolRollIn} (`gen: g`); their
+ *   dividends on `g` stay claimable ({@link fPoolClaim} with `gen: g`). {@link fPoolClaimsOf}
+ *   lists them;
+ * - the pot: `toPayee` to the payee, `protocolCut` to the collector, the rest bought in as dead
+ *   shares of `g + 1`; then the burn.
+ *
+ * A pad's gate is `threshold(gen)` (`PadPolicy.NotGraduated` below it); POL and private carry the
+ * authority and send it the whole pot; a public pool refuses (`Refused`). A carried holder with no
+ * share is `BadTerms`. Whoever runs the pool.
  */
 export async function fPoolRegenerate(c: LogswapClient, a: { poolId: Hex; to?: Address; account: Address }) {
   return writeFPool(c, a.poolId, "regenerate", [a.to ?? a.account], a.account);
@@ -1534,13 +1632,26 @@ export interface FPoolControlled {
   pool: DiscoveredFPool;
   roles: FPoolRoles;
   state: FPoolState;
-  /** The policy's numbers for this pool's kind — a pad's rung and threshold, a POL's floors, the desk's list flags. */
+  /** The policy's numbers for this pool's kind — a pad's gen (its rung) and threshold, a POL's floors, the desk's list flags. */
   rules: FPoolRules;
 }
 
 /** What a pool's policy says about it, by kind: the terms a buyer reads before entering. */
 export type FPoolRules =
-  | { kind: "pad"; harvestCut: bigint; rung: number; threshold: bigint; pot: bigint; creatorShare: bigint; protocolShare: bigint; burnPerRung: bigint }
+  | {
+      kind: "pad";
+      harvestCut: bigint;
+      /** The pad's graduation count: the pool's generation (F version 21 — `PadPolicy.rung` is gone). */
+      gen: number;
+      /** @deprecated Equal to {@link gen} since F version 21, kept for callers; read `gen`. */
+      rung: number;
+      /** The pot the next graduation needs: `PadPolicy.threshold(gen)`. */
+      threshold: bigint;
+      pot: bigint;
+      creatorShare: bigint;
+      protocolShare: bigint;
+      burnPerRung: bigint;
+    }
   | { kind: "pol"; harvestCut: bigint; keepQuote: bigint; minQuoteAtSeed: bigint }
   | { kind: "public"; harvestCut: bigint; curated: boolean }
   | { kind: "private"; harvestCut: bigint; gateMint: boolean; gateSwap: boolean; operator: Address };
@@ -1552,15 +1663,16 @@ export async function getFPoolRules(c: LogswapClient, s: Pick<FPoolState, "poolI
   const harvestCut = await rd<bigint>(fPolicyBaseAbi, "harvestCut");
   switch (s.kind) {
     case "pad": {
-      const [rung, creatorShare, protocolShare, burnPerRung, pot] = await Promise.all([
-        rd<bigint>(padPolicyAbi, "rung", [s.poolId]),
+      // the rung is the manager's generation (F version 21): a move carries it, nothing to ask the policy
+      const gen = s.gen;
+      const [creatorShare, protocolShare, burnPerRung, pot, threshold] = await Promise.all([
         rd<bigint>(padPolicyAbi, "creatorShare"),
         rd<bigint>(padPolicyAbi, "protocolShare"),
         rd<bigint>(padPolicyAbi, "burnPerRung"),
-        fPoolDividendOf(c, s.poolId, DEAD_ADDRESS, s.gen),
+        fPoolDividendOf(c, s.poolId, DEAD_ADDRESS, gen),
+        rd<bigint>(padPolicyAbi, "threshold", [BigInt(gen)]),
       ]);
-      const threshold = await rd<bigint>(padPolicyAbi, "threshold", [rung]);
-      return { kind: "pad", harvestCut, rung: Number(rung), threshold, pot, creatorShare, protocolShare, burnPerRung };
+      return { kind: "pad", harvestCut, gen, rung: gen, threshold, pot, creatorShare, protocolShare, burnPerRung };
     }
     case "pol": {
       const [keepQuote, minQuoteAtSeed] = await Promise.all([rd<bigint>(polPolicyAbi, "keepQuote"), rd<bigint>(polPolicyAbi, "minQuoteAtSeed")]);
@@ -1640,6 +1752,19 @@ export async function fPoolShareHolders(
     .sort((a, b) => (b.shares > a.shares ? 1 : -1));
 }
 
+/**
+ * What a policy answers `onRegenerate` with (and `onHarvest`'s split, the first four words):
+ * `IFPolicy.Terms`. `carried` is F version 21's fifth word — the holder the next generation
+ * carries beside the dead shares; the reply is exactly 160 bytes.
+ */
+export interface FPolicyTerms {
+  payee: Address;
+  toPayee: bigint;
+  protocolCut: bigint;
+  burn: bigint;
+  carried: Address;
+}
+
 /** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, kind, seeded, gen, n, Q, L, shares, theta0, bigSigma, harvestedTheta). */
 export async function getFPoolsRaw(c: LogswapClient, poolIds: Hex[]): Promise<readonly unknown[]> {
   const { logswapLensAbi } = await import("./generated.js");

package/src/generated.ts

@@ -1100,20 +1100,6 @@ export const fPoolManagerAbi = [
     outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
     stateMutability: 'view',
   },
-  {
-    type: 'function',
-    inputs: [],
-    name: 'FEE_MAX',
-    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
-    stateMutability: 'view',
-  },
-  {
-    type: 'function',
-    inputs: [],
-    name: 'FEE_MIN',
-    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
-    stateMutability: 'view',
-  },
   {
     type: 'function',
     inputs: [],
@@ -1330,35 +1316,6 @@ export const fPoolManagerAbi = [
     outputs: [],
     stateMutability: 'nonpayable',
   },
-  {
-    type: 'function',
-    inputs: [{ name: 'poolId', internalType: 'bytes32', type: 'bytes32' }],
-    name: 'harvestable',
-    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
-    stateMutability: 'view',
-  },
-  {
-    type: 'function',
-    inputs: [
-      {
-        name: 'key',
-        internalType: 'struct FPoolKey',
-        type: 'tuple',
-        components: [
-          { name: 'quote', internalType: 'address', type: 'address' },
-          { name: 'bases', internalType: 'address[]', type: 'address[]' },
-          { name: 'weights', internalType: 'uint256[]', type: 'uint256[]' },
-          { name: 'phi', internalType: 'uint256', type: 'uint256' },
-          { name: 'policy', internalType: 'address', type: 'address' },
-          { name: 'creator', internalType: 'address', type: 'address' },
-          { name: 'salt', internalType: 'bytes32', type: 'bytes32' },
-        ],
-      },
-    ],
-    name: 'idOf',
-    outputs: [{ name: '', internalType: 'bytes32', type: 'bytes32' }],
-    stateMutability: 'pure',
-  },
   {
     type: 'function',
     inputs: [
@@ -1516,16 +1473,6 @@ export const fPoolManagerAbi = [
     ],
     stateMutability: 'view',
   },
-  {
-    type: 'function',
-    inputs: [
-      { name: 'poolId', internalType: 'bytes32', type: 'bytes32' },
-      { name: 'j', internalType: 'uint256', type: 'uint256' },
-    ],
-    name: 'reserveOf',
-    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
-    stateMutability: 'view',
-  },
   {
     type: 'function',
     inputs: [{ name: 'poolId', internalType: 'bytes32', type: 'bytes32' }],
@@ -3951,6 +3898,7 @@ export const padPolicyAbi = [
           { name: 'toPayee', internalType: 'uint256', type: 'uint256' },
           { name: 'protocolCut', internalType: 'uint256', type: 'uint256' },
           { name: 'burn', internalType: 'uint256', type: 'uint256' },
+          { name: 'carried', internalType: 'address', type: 'address' },
         ],
       },
     ],
@@ -3994,13 +3942,6 @@ export const padPolicyAbi = [
     outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
     stateMutability: 'view',
   },
-  {
-    type: 'function',
-    inputs: [{ name: '', internalType: 'bytes32', type: 'bytes32' }],
-    name: 'rung',
-    outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
-    stateMutability: 'view',
-  },
   {
     type: 'function',
     inputs: [{ name: '_harvestCut', internalType: 'uint256', type: 'uint256' }],
@@ -4178,26 +4119,6 @@ export const padPolicyAbi = [
     ],
     name: 'QuoteListed',
   },
-  {
-    type: 'event',
-    anonymous: false,
-    inputs: [
-      {
-        name: 'poolId',
-        internalType: 'bytes32',
-        type: 'bytes32',
-        indexed: true,
-      },
-      { name: 'from', internalType: 'address', type: 'address', indexed: true },
-      {
-        name: 'rung',
-        internalType: 'uint256',
-        type: 'uint256',
-        indexed: false,
-      },
-    ],
-    name: 'RungCarried',
-  },
   {
     type: 'event',
     anonymous: false,
@@ -4470,6 +4391,7 @@ export const polPolicyAbi = [
           { name: 'toPayee', internalType: 'uint256', type: 'uint256' },
           { name: 'protocolCut', internalType: 'uint256', type: 'uint256' },
           { name: 'burn', internalType: 'uint256', type: 'uint256' },
+          { name: 'carried', internalType: 'address', type: 'address' },
         ],
       },
     ],
@@ -5240,6 +5162,7 @@ export const privatePolicyAbi = [
           { name: 'toPayee', internalType: 'uint256', type: 'uint256' },
           { name: 'protocolCut', internalType: 'uint256', type: 'uint256' },
           { name: 'burn', internalType: 'uint256', type: 'uint256' },
+          { name: 'carried', internalType: 'address', type: 'address' },
         ],
       },
     ],
@@ -5770,6 +5693,7 @@ export const publicPolicyAbi = [
           { name: 'toPayee', internalType: 'uint256', type: 'uint256' },
           { name: 'protocolCut', internalType: 'uint256', type: 'uint256' },
           { name: 'burn', internalType: 'uint256', type: 'uint256' },
+          { name: 'carried', internalType: 'address', type: 'address' },
         ],
       },
     ],

package/src/keys.ts

@@ -13,6 +13,16 @@
 
 import { encodeAbiParameters, keccak256, type Address, type Hex } from "viem";
 
+/**
+ * The fee domain of the family, `FeeParams.FEE_MIN` / `FEE_MAX` (decisions 043): one bound for a
+ * C market's φ and an F pool's alike, WAD. 1 bp and 1%. The F manager no longer answers
+ * `FEE_MIN()` / `FEE_MAX()` (F version 21 cut the getters for bytecode); every F policy still
+ * checks φ against these at `onInitialize`, and the C side re-exposes them through the lens's
+ * `cParams()`. Constants here, so a create form bounds φ with no read.
+ */
+export const FEE_MIN = 10n ** 14n;
+export const FEE_MAX = 10n ** 16n;
+
 /**
  * The economic tuple that IS the market. Field order is load-bearing: it is the ABI encoding order,
  * so it must match `src/types/PoolKey.sol` exactly.
@@ -23,7 +33,7 @@ export interface PoolKey {
   /** Log-tick spacing, WAD. The LP-boundary ladder — position floors and caps. */
   tickSpacing: bigint;
   /**
-   * The swap fee, WAD, fixed for the life of the market: `FEE_MIN` (1 bp) ≤ φ ≤ `FEE_MAX` (25%),
+   * The swap fee, WAD, fixed for the life of the market: {@link FEE_MIN} (1 bp) ≤ φ ≤ {@link FEE_MAX} (1%),
    * or `0n`, which selects `DEFAULT_FEE` (2 bp) at read time. Four fields since C version 4
    *: `kappa` and `alpha` left with the variance kernel, and `phiMin` — a floor with
    * nothing above it — became `phi`. Every pool id changed with the shape.

package/src/pools.ts

@@ -82,6 +82,46 @@ export function priceScale(baseDecimals: number, quoteDecimals: number): number
   return 10 ** (baseDecimals - quoteDecimals);
 }
 
+/** The C manager's log-price wall: |x| ≤ 46 on the WEI ratio (`MAX_ABS_FLOOR`). */
+export const C_MAX_ABS_X = 46;
+
+/** The least derived base reserve a C book keeps, in base wei (`MIN_RESERVE`, decisions 023). */
+export const C_MIN_RESERVE = 10n ** 6n;
+
+/**
+ * The prices a C market can hold, in human units — quote per whole base token (decisions 054).
+ *
+ * - `listMin`, `listMax`: the wall, `10^(base − quote) · e^{∓46}`. A market cannot be initialized,
+ *   and no floor or cap placed, outside it. An 18-dec token against 6-dec USDC cannot list under
+ *   1.05e-8; against an 18-dec quote the same token lists down to 1.05e-20.
+ * - `ceiling`: the highest price the book can trade to with `lActive` of active exposure (quote
+ *   wei): the derived reserve `lActive / p` must stay at or above `C_MIN_RESERVE` base wei, so
+ *   `ceiling = lActive · 10^(base − quote) / 1e6`, capped by `listMax`. In whole units that is
+ *   `L · 10^(base − 6)`: the quote's decimals cancel and the base's set it — harmless on an
+ *   18-dec base, but a WBTC book of 1,000 USDC of depth stops at 100,000. Omit `lActive` for the
+ *   wall alone.
+ *
+ * Floats, for display and warnings; the chain is the authority.
+ */
+export function cPriceRange(
+  baseDecimals: number,
+  quoteDecimals: number,
+  lActive?: bigint,
+): { listMin: number; listMax: number; ceiling: number } {
+  const scale = priceScale(baseDecimals, quoteDecimals);
+  const listMin = Math.exp(-C_MAX_ABS_X) * scale;
+  const listMax = Math.exp(C_MAX_ABS_X) * scale;
+  const ceiling =
+    lActive === undefined || lActive === 0n ? listMax : Math.min(listMax, (Number(lActive) / Number(C_MIN_RESERVE)) * scale);
+  return { listMin, listMax, ceiling };
+}
+
+/** Whether a C market can be initialized at `price` (human units) for this pair's decimals. */
+export function cListable(price: number, baseDecimals: number, quoteDecimals: number): boolean {
+  const { listMin, listMax } = cPriceRange(baseDecimals, quoteDecimals);
+  return price >= listMin && price <= listMax;
+}
+
 /**
  * The model-free LP edge, $F - \tfrac12\Sigma$ — the protocol's headline metric, in quote per unit
  * of exposure.

package/src/write.ts

@@ -15,6 +15,7 @@
 
 import type { Address, Hash, Hex } from "viem";
 import type { LogswapClient } from "./client.js";
+import { cPoolManagerAbi, fPoolManagerAbi } from "./generated.js";
 
 /** Disables the deadline check. Deliberate opt-out, never a default. */
 export const NEVER = (1n << 256n) - 1n;
@@ -87,6 +88,64 @@ export function withSlippage(quoted: bigint, bps: number, side: "output" | "inpu
   return side === "output" ? (quoted * (10_000n - b)) / 10_000n : (quoted * (10_000n + b) + 9_999n) / 10_000n;
 }
 
+type AbiError = { type: "error"; name: string; inputs: readonly { type: string }[] };
+
+/** Permit2's pull errors — Uniswap's and the devnet mock's — which a router write can revert with. */
+const permit2Errors: readonly AbiError[] = [
+  { type: "error", name: "AllowanceExpired", inputs: [{ type: "uint256" }] },
+  { type: "error", name: "InsufficientAllowance", inputs: [{ type: "uint256" }] },
+  { type: "error", name: "AllowanceExpired", inputs: [] },
+  { type: "error", name: "NotAllowed", inputs: [] },
+];
+
+const errorKey = (e: AbiError) => `${e.name}(${e.inputs.map((i) => i.type).join(",")})`;
+
+/**
+ * Every custom error a router call can revert with that the router's own ABI does not declare: the
+ * C and F managers' (a mint, a swap or a settlement bubbles them up unchanged) and Permit2's.
+ * Without them viem can name only the router's errors, and anything raised in the manager comes
+ * back as a bare selector.
+ */
+export const routerRevertErrors: readonly AbiError[] = (() => {
+  const seen = new Set<string>();
+  const out: AbiError[] = [];
+  for (const x of [...cPoolManagerAbi, ...fPoolManagerAbi, ...permit2Errors] as readonly { type: string }[]) {
+    if (x.type !== "error") continue;
+    const e = x as AbiError;
+    if (!seen.has(errorKey(e))) {
+      seen.add(errorKey(e));
+      out.push(e);
+    }
+  }
+  return out;
+})();
+
+/** `abi` plus every error in {@link routerRevertErrors} it does not already declare. */
+export function withRevertErrors(abi: readonly unknown[]): readonly unknown[] {
+  const have = new Set(
+    (abi as readonly { type: string }[]).filter((x) => x.type === "error").map((x) => errorKey(x as AbiError)),
+  );
+  return [...abi, ...routerRevertErrors.filter((e) => !have.has(errorKey(e)))];
+}
+
+/**
+ * The decoded revert of a contract call, e.g. `SlippageIn()` or `AllowanceExpired(1700000000)`,
+ * found however deep viem nested it; the raw selector when the error is not in the ABI; undefined
+ * when the failure was not a revert. viem's `message` puts the name on its second line, so a UI
+ * that shows only the first line ("The contract function … reverted.") loses it.
+ */
+export function revertName(e: unknown): string | undefined {
+  const seen = new Set<unknown>();
+  for (let x: unknown = e; x && typeof x === "object" && !seen.has(x); x = (x as { cause?: unknown }).cause) {
+    seen.add(x);
+    const o = x as { name?: string; data?: { errorName?: string; args?: readonly unknown[] }; signature?: string };
+    if (o.name !== "ContractFunctionRevertedError") continue;
+    if (o.data?.errorName) return `${o.data.errorName}(${(o.data.args ?? []).map(String).join(", ")})`;
+    if (o.signature) return o.signature;
+  }
+  return undefined;
+}
+
 /**
  * Send a router write with a gas buffer over an explicit estimate.
  *
@@ -102,7 +161,7 @@ export async function sendRouterWrite(
   const { account } = requireWallet(c);
   const params = {
     address: c.addresses.router,
-    abi: args.abi,
+    abi: withRevertErrors(args.abi),
     functionName: args.functionName,
     args: args.args,
     account,
@@ -147,7 +206,7 @@ export async function simulateRouterWrite<T>(
   const account = args.account ?? c.wallet?.account?.address;
   const { result } = await c.public.simulateContract({
     address: c.addresses.router,
-    abi: args.abi,
+    abi: withRevertErrors(args.abi),
     functionName: args.functionName,
     args: args.args,
     account,