@logswap/sdk 0.5.64 → 0.5.66

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.64",
+  "version": "0.5.66",
   "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,

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");