@logswap/sdk 0.5.65 → 0.5.67

package/dist/generated.d.ts

@@ -1741,26 +1741,6 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [];
-    readonly name: "FEE_MAX";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [];
-    readonly name: "FEE_MIN";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];
@@ -2162,63 +2142,6 @@ export declare const fPoolManagerAbi: readonly [{
     readonly name: "harvest";
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly name: "harvestable";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "key";
-        readonly internalType: "struct FPoolKey";
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly name: "quote";
-            readonly internalType: "address";
-            readonly type: "address";
-        }, {
-            readonly name: "bases";
-            readonly internalType: "address[]";
-            readonly type: "address[]";
-        }, {
-            readonly name: "weights";
-            readonly internalType: "uint256[]";
-            readonly type: "uint256[]";
-        }, {
-            readonly name: "phi";
-            readonly internalType: "uint256";
-            readonly type: "uint256";
-        }, {
-            readonly name: "policy";
-            readonly internalType: "address";
-            readonly type: "address";
-        }, {
-            readonly name: "creator";
-            readonly internalType: "address";
-            readonly type: "address";
-        }, {
-            readonly name: "salt";
-            readonly internalType: "bytes32";
-            readonly type: "bytes32";
-        }];
-    }];
-    readonly name: "idOf";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly stateMutability: "pure";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -2500,24 +2423,6 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "address";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "j";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly name: "reserveOf";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -6681,6 +6586,10 @@ export declare const padPolicyAbi: readonly [{
             readonly name: "burn";
             readonly internalType: "uint256";
             readonly type: "uint256";
+        }, {
+            readonly name: "carried";
+            readonly internalType: "address";
+            readonly type: "address";
         }];
     }];
     readonly stateMutability: "nonpayable";
@@ -6746,20 +6655,6 @@ export declare const padPolicyAbi: readonly [{
         readonly type: "bool";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly name: "rung";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -6978,26 +6873,6 @@ export declare const padPolicyAbi: readonly [{
         readonly indexed: false;
     }];
     readonly name: "QuoteListed";
-}, {
-    readonly type: "event";
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-        readonly indexed: true;
-    }, {
-        readonly name: "from";
-        readonly internalType: "address";
-        readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "rung";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }];
-    readonly name: "RungCarried";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -7449,6 +7324,10 @@ export declare const polPolicyAbi: readonly [{
             readonly name: "burn";
             readonly internalType: "uint256";
             readonly type: "uint256";
+        }, {
+            readonly name: "carried";
+            readonly internalType: "address";
+            readonly type: "address";
         }];
     }];
     readonly stateMutability: "nonpayable";
@@ -8581,6 +8460,10 @@ export declare const privatePolicyAbi: readonly [{
             readonly name: "burn";
             readonly internalType: "uint256";
             readonly type: "uint256";
+        }, {
+            readonly name: "carried";
+            readonly internalType: "address";
+            readonly type: "address";
         }];
     }];
     readonly stateMutability: "nonpayable";
@@ -9385,6 +9268,10 @@ export declare const publicPolicyAbi: readonly [{
             readonly name: "burn";
             readonly internalType: "uint256";
             readonly type: "uint256";
+        }, {
+            readonly name: "carried";
+            readonly internalType: "address";
+            readonly type: "address";
         }];
     }];
     readonly stateMutability: "nonpayable";

package/dist/generated.js

@@ -1097,20 +1097,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: [],
@@ -1327,35 +1313,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: [
@@ -1513,16 +1470,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' }],
@@ -3940,6 +3887,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' },
                 ],
             },
         ],
@@ -3983,13 +3931,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' }],
@@ -4167,26 +4108,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,
@@ -4457,6 +4378,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' },
                 ],
             },
         ],
@@ -5223,6 +5145,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' },
                 ],
             },
         ],
@@ -5751,6 +5674,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/dist/keys.d.ts

@@ -11,6 +11,15 @@
  * if the two ever disagree, that test fails rather than the SDK silently addressing the wrong pool.
  */
 import { 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 declare const FEE_MIN: bigint;
+export declare const FEE_MAX: bigint;
 /**
  * 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.
@@ -21,7 +30,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/dist/keys.js

@@ -11,6 +11,15 @@
  * if the two ever disagree, that test fails rather than the SDK silently addressing the wrong pool.
  */
 import { encodeAbiParameters, keccak256 } 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;
 const POOL_KEY_ABI = [
     {
         type: "tuple",

package/dist/pools.d.ts

@@ -53,6 +53,32 @@ export declare function priceOf(state: Pick<PoolState, "x">, scale?: number): nu
  * it is 1 and nothing changes.
  */
 export declare function priceScale(baseDecimals: number, quoteDecimals: number): number;
+/** The C manager's log-price wall: |x| ≤ 46 on the WEI ratio (`MAX_ABS_FLOOR`). */
+export declare const C_MAX_ABS_X = 46;
+/** The least derived base reserve a C book keeps, in base wei (`MIN_RESERVE`, decisions 023). */
+export declare const C_MIN_RESERVE: bigint;
+/**
+ * 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 declare function cPriceRange(baseDecimals: number, quoteDecimals: number, lActive?: bigint): {
+    listMin: number;
+    listMax: number;
+    ceiling: number;
+};
+/** Whether a C market can be initialized at `price` (human units) for this pair's decimals. */
+export declare function cListable(price: number, baseDecimals: number, quoteDecimals: number): boolean;
 /**
  * The model-free LP edge, $F - \tfrac12\Sigma$ — the protocol's headline metric, in quote per unit
  * of exposure.

package/dist/pools.js

@@ -55,6 +55,37 @@ export function priceOf(state, scale = 1) {
 export function priceScale(baseDecimals, quoteDecimals) {
     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, quoteDecimals, lActive) {
+    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, baseDecimals, quoteDecimals) {
+    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/dist/write.d.ts

@@ -59,6 +59,29 @@ export declare function resolveRecipient(c: LogswapClient, o?: WriteOptions): Ad
  * bound at all because it looks protective.
  */
 export declare function withSlippage(quoted: bigint, bps: number, side: "output" | "input"): bigint;
+type AbiError = {
+    type: "error";
+    name: string;
+    inputs: readonly {
+        type: string;
+    }[];
+};
+/**
+ * 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 declare const routerRevertErrors: readonly AbiError[];
+/** `abi` plus every error in {@link routerRevertErrors} it does not already declare. */
+export declare function withRevertErrors(abi: readonly unknown[]): readonly unknown[];
+/**
+ * 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 declare function revertName(e: unknown): string | undefined;
 /**
  * Send a router write with a gas buffer over an explicit estimate.
  *
@@ -104,3 +127,4 @@ export declare function sendRouterWriteWithPermits(c: LogswapClient, args: {
     args: readonly unknown[];
     bufferPct?: bigint;
 }, pullTokens: Address[]): Promise<Hash>;
+export {};

package/dist/write.js

@@ -12,6 +12,7 @@
  * raw `minOut`/`maxIn` the contract wants. `withSlippage()` derives one from a quote when that is
  * what you have — but the bound is what ships.
  */
+import { cPoolManagerAbi, fPoolManagerAbi } from "./generated.js";
 /** Disables the deadline check. Deliberate opt-out, never a default. */
 export const NEVER = (1n << 256n) - 1n;
 /** Default deadline window: 20 minutes, the same order as every major DEX front end. */
@@ -70,6 +71,59 @@ export function withSlippage(quoted, bps, side) {
     // an input bound rounds UP: flooring it would put a wei-exact quote at bps = 0 one wei short
     return side === "output" ? (quoted * (10000n - b)) / 10000n : (quoted * (10000n + b) + 9999n) / 10000n;
 }
+/** Permit2's pull errors — Uniswap's and the devnet mock's — which a router write can revert with. */
+const permit2Errors = [
+    { 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) => `${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 = (() => {
+    const seen = new Set();
+    const out = [];
+    for (const x of [...cPoolManagerAbi, ...fPoolManagerAbi, ...permit2Errors]) {
+        if (x.type !== "error")
+            continue;
+        const e = x;
+        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) {
+    const have = new Set(abi.filter((x) => x.type === "error").map((x) => errorKey(x)));
+    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) {
+    const seen = new Set();
+    for (let x = e; x && typeof x === "object" && !seen.has(x); x = x.cause) {
+        seen.add(x);
+        const o = x;
+        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.
  *
@@ -82,7 +136,7 @@ export async function sendRouterWrite(c, args) {
     const { account } = requireWallet(c);
     const params = {
         address: c.addresses.router,
-        abi: args.abi,
+        abi: withRevertErrors(args.abi),
         functionName: args.functionName,
         args: args.args,
         account,
@@ -122,7 +176,7 @@ export async function simulateRouterWrite(c, args) {
     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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.65",
+  "version": "0.5.67",
   "description": "TypeScript SDK for Logswap, the liquidity primitive introducing the logarithmic invariant — typed wrappers over the CPoolManager / FPoolManager / Router / Lens surface.",
   "license": "GPL-2.0-or-later",
   "type": "module",

package/src/admin.ts

@@ -14,7 +14,7 @@
 import type { Address, Hash } from "viem";
 import type { LogswapClient } from "./client.js";
 import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, publicPolicyAbi } from "./generated.js";
-import { bytes32ToText, fPolicyBaseAbi, fPoolKindOfPolicy, textToBytes32, type FPoolKind } from "./fpool.js";
+import { bytes32ToText, fPolicyBaseAbi, fPoolKeyOfPool, fPoolKindOfPolicy, textToBytes32, type FPoolKey, type FPoolKind } from "./fpool.js";
 
 function wallet(c: LogswapClient) {
   if (!c.wallet) throw new Error("a wallet client is required");
@@ -138,13 +138,36 @@ export async function setPolicyApproved(c: LogswapClient, policy: Address, appro
 }
 
 /**
- * Move a pool to another approved policy of the same kind: the registry
- * owner's alone, orchestrated on the registry — `migrate(manager, poolId, to)`. The new policy
- * takes the authority and the name from the old; the operator and the lists void; no swap lands
- * in the block.
+ * Move a pool to another approved policy of the same kind: the registry owner's alone,
+ * orchestrated on the registry — `migrate(manager, key, to)` since F version 20 (it took the
+ * pool's id before). The registry checks the key against the manager (`NoPool`), checks the
+ * manager is its own (`WrongManager`), and compares the two policies' tags recorded at approval
+ * ({@link registryKindOf}). The new policy is brought the creator (the key's), the authority and
+ * the name (read off the old policy defensively, the key's creator standing in when it cannot
+ * answer); the operator and the lists void; no swap lands in the block.
+ *
+ * Pass the pool's `key` when in hand. Given only `poolId`, the key is rebuilt from the pool's
+ * `FInitialize` log ({@link fPoolKeyOfPool}) with `salt` (zero by default) and checked against
+ * the id — the log does not carry the salt, so a salted pool needs it named.
+ */
+export async function fPoolMigrate(
+  c: LogswapClient,
+  a: { to: Address } & ({ key: FPoolKey } | { poolId: `0x${string}`; salt?: `0x${string}`; fromBlock?: bigint }),
+): Promise<Hash> {
+  const key = "key" in a ? a.key : await fPoolKeyOfPool(c, a.poolId, { salt: a.salt, fromBlock: a.fromBlock });
+  return registryWrite(c, "migrate", [c.addresses.fPoolManager as Address, key, a.to]);
+}
+
+/**
+ * The kind tag the registry recorded for `policy` at approval (`kindOf`, F version 20) — refreshed
+ * on re-approval and kept after a revoke; what `migrate` compares, never the policy's live
+ * answer. "" for a policy the registry never approved (or a deployment with no registry).
  */
-export async function fPoolMigrate(c: LogswapClient, a: { poolId: `0x${string}`; to: Address }): Promise<Hash> {
-  return registryWrite(c, "migrate", [c.addresses.fPoolManager as Address, a.poolId, a.to]);
+export async function registryKindOf(c: LogswapClient, policy: Address): Promise<FPoolKind | ""> {
+  const registry = await policyRegistryOf(c);
+  if (registry === ZERO) return "";
+  const word = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "kindOf", args: [policy] } as never)) as `0x${string}`;
+  return bytes32ToText(word) as FPoolKind | "";
 }
 
 // ─── the policies' numbers (the collector's; each bounded where it reaches the manager) ─────
@@ -154,7 +177,7 @@ export async function setHarvestCut(c: LogswapClient, policy: Address, rateWad:
   return write(c, policy, fPolicyBaseAbi, "setHarvestCut", [rateWad]);
 }
 
-/** `PadPolicy.setSchedule`: `T(0)`, the rung's growth, the creator's and the protocol's shares of the pot (≤ `POT_CUT_MAX`), the burn per rung (≤ `BURN_MAX`). */
+/** `PadPolicy.setSchedule`: `T(0)`, the rung's growth, the creator's and the protocol's shares of the pot (≤ `POT_CUT_MAX`), the burn per rung (≤ `BURN_MAX`). The rung is the pool's generation since F version 21. */
 export async function padSetSchedule(
   c: LogswapClient,
   policy: Address,