@logswap/sdk 0.5.65 → 0.5.67

package/dist/admin.d.ts

@@ -12,7 +12,7 @@
  */
 import type { Address, Hash } from "viem";
 import type { LogswapClient } from "./client.js";
-import { type FPoolKind } from "./fpool.js";
+import { type FPoolKey, type FPoolKind } from "./fpool.js";
 /** The C manager's `setFeeParams(mintFeeProtocolCut)` — one cut. */
 export declare function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash>;
 /** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18; there is no setter. */
@@ -62,18 +62,36 @@ export declare function registryAcceptOwner(c: LogswapClient): Promise<Hash>;
  */
 export declare function setPolicyApproved(c: LogswapClient, policy: Address, approved: boolean): Promise<Hash>;
 /**
- * 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 declare function fPoolMigrate(c: LogswapClient, a: {
-    poolId: `0x${string}`;
     to: Address;
-}): Promise<Hash>;
+} & ({
+    key: FPoolKey;
+} | {
+    poolId: `0x${string}`;
+    salt?: `0x${string}`;
+    fromBlock?: bigint;
+})): Promise<Hash>;
+/**
+ * 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 declare function registryKindOf(c: LogswapClient, policy: Address): Promise<FPoolKind | "">;
 /** The protocol's rate on the income part of every harvest under `policy`, WAD ≤ `HARVEST_CUT_MAX`. */
 export declare function setHarvestCut(c: LogswapClient, policy: Address, rateWad: bigint): Promise<Hash>;
-/** `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 declare function padSetSchedule(c: LogswapClient, policy: Address, s: {
     thresholdBase: bigint;
     thresholdGrowth: bigint;

package/dist/admin.js

@@ -11,7 +11,7 @@
  * protocol share likewise (`POT_CUT_MAX`).
  */
 import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, publicPolicyAbi } from "./generated.js";
-import { bytes32ToText, fPolicyBaseAbi, fPoolKindOfPolicy, textToBytes32 } from "./fpool.js";
+import { bytes32ToText, fPolicyBaseAbi, fPoolKeyOfPool, fPoolKindOfPolicy, textToBytes32 } from "./fpool.js";
 function wallet(c) {
     if (!c.wallet)
         throw new Error("a wallet client is required");
@@ -111,20 +111,40 @@ export async function setPolicyApproved(c, policy, approved) {
     return approved ? registryApprove(c, policy, await fPoolKindOfPolicy(c, policy)) : registryRevoke(c, policy);
 }
 /**
- * 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, a) {
-    return registryWrite(c, "migrate", [c.addresses.fPoolManager, a.poolId, a.to]);
+    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, 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 registryKindOf(c, policy) {
+    const registry = await policyRegistryOf(c);
+    if (registry === ZERO)
+        return "";
+    const word = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "kindOf", args: [policy] }));
+    return bytes32ToText(word);
 }
 // ─── the policies' numbers (the collector's; each bounded where it reaches the manager) ─────
 /** The protocol's rate on the income part of every harvest under `policy`, WAD ≤ `HARVEST_CUT_MAX`. */
 export async function setHarvestCut(c, policy, 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, policy, s) {
     return write(c, policy, padPolicyAbi, "setSchedule", [s.thresholdBase, s.thresholdGrowth, s.creatorShare, s.protocolShare, s.burnPerRung]);
 }

package/dist/client.d.ts

@@ -83,7 +83,7 @@ export declare const EXPECTED_VERSION = 5n;
  * passes it; when one lands, raise this constant in the same change, which is the discipline
  * `EXPECTED_VERSION` enforces mechanically and this one asks for.
  */
-export declare const EXPECTED_F_VERSION = 19n;
+export declare const EXPECTED_F_VERSION = 21n;
 export declare function assertVersion(c: LogswapClient, expected?: bigint): Promise<void>;
 /**
  * The versions say the managers are the right code; this says the rest of the addresses belong

package/dist/client.js

@@ -121,7 +121,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, expected = EXPECTED_VERSION) {
     const { cPoolManagerAbi, fPoolManagerAbi } = await import("./generated.js");
     // three independent reads: one round trip, not three in a row

package/dist/fpool.d.ts

@@ -416,6 +416,10 @@ export declare const fPolicyBaseAbi: readonly [{
             readonly name: "burn";
             readonly internalType: "uint256";
             readonly type: "uint256";
+        }, {
+            readonly name: "carried";
+            readonly internalType: "address";
+            readonly type: "address";
         }];
     }];
     readonly stateMutability: "nonpayable";
@@ -732,9 +736,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;
@@ -785,7 +792,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;
 }
 /** Read a pool's roles from its policy. `state` saves the `getPool` round trip when already in hand. */
@@ -804,7 +811,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;
@@ -1102,19 +1114,49 @@ export declare function sortFPoolLegs<T>(bases: Address[], ...companions: T[][])
     companions: T[][];
 };
 /** 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 declare function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): {
-    quote: `0x${string}`;
-    bases: `0x${string}`[];
+/**
+ * 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;
-    policy: `0x${string}`;
-    creator: `0x${string}`;
-    salt: `0x${string}`;
-};
+    /** The policy AT BIRTH — not the live one after a move. */
+    policy: Address;
+    creator: Address;
+    salt: Hex;
+}
+/**
+ * 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 declare function fPoolIdOfKey(key: FPoolKey): Hex;
+export declare function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): FPoolKey;
 /** Create the pool (no funds move — `seed` arms it). Returns the tx hash; read the id with `fPoolIdOf`. */
 export declare function fPoolInitialize(c: LogswapClient, a: FPoolCreateArgs): Promise<`0x${string}`>;
-/** 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 declare function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): Promise<Hex>;
+/**
+ * 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 declare function fPoolKeyOfPool(c: LogswapClient, poolId: Hex, opts?: {
+    salt?: Hex;
+    fromBlock?: bigint;
+}): Promise<FPoolKey>;
 /**
  * The reserve a leg holds at a mark: `R = Lj·e^{−x}`, WAD math. The seed names RESERVES —
  * the sponsor states holdings and the price follows, `p = Lj / R` — so this is
@@ -1157,7 +1199,7 @@ export declare function fPoolRetireRaw(c: LogswapClient, a: {
  * 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 declare function fPoolRetire(c: LogswapClient, a: {
     poolId: Hex;
@@ -1167,18 +1209,29 @@ export declare function fPoolRetire(c: LogswapClient, 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 declare function fPoolEmptyingHarvests(c: LogswapClient, poolId: Hex): Promise<bigint[]>;
 /**
- * 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 declare function fPoolRegenerate(c: LogswapClient, a: {
     poolId: Hex;
@@ -1458,14 +1511,18 @@ 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;
+    /** 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;
@@ -1510,6 +1567,18 @@ export declare function fPoolShareHolders(c: LogswapClient, poolIdHex: Hex, opts
     holder: Address;
     shares: bigint;
 }>>;
+/**
+ * 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 declare function getFPoolsRaw(c: LogswapClient, poolIds: Hex[]): Promise<readonly unknown[]>;
 /** Share value from the lens — (L + Q)/shares, WAD per share — the same figure as `fPoolShareValue`, from one source. */

package/dist/fpool.js

@@ -29,7 +29,7 @@
  * twice, forever. One router is one spender — see `fPoolZapIn`/`fPoolZapOut` below, which target
  * `addresses.router`.
  */
-import { encodeFunctionData, toFunctionSelector } from "viem";
+import { encodeAbiParameters, encodeFunctionData, keccak256, toFunctionSelector } from "viem";
 import { fPoolManagerAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 /**
  * One contract, one ABI (F version 12): `harvest`, `claim`, `retire`, `regenerate`,
@@ -192,10 +192,12 @@ export async function describeFPool(c, s) {
         functionName,
         args,
     });
-    // an unseeded pool has no L: nothing earned, nothing to harvest, no pot
-    const [unharvested, harvestable, pot] = s.L > 0n
-        ? await Promise.all([rd("unharvested"), rd("harvestable"), rd("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("unharvested"), rd("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,
@@ -669,7 +671,29 @@ export function sortFPoolLegs(bases, ...companions) {
     const idx = bases.map((_, i) => i).sort((a, b) => (bases[a].toLowerCase() < bases[b].toLowerCase() ? -1 : 1));
     return { bases: idx.map((i) => bases[i]), companions: companions.map((arr) => idx.map((i) => arr[i])) };
 }
-/** The key as the manager hashes it: legs sorted, the kind's policy filled in when none is named; no kind in it (049). */
+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" },
+        ],
+    },
+];
+/**
+ * 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) {
+    return keccak256(encodeAbiParameters(F_POOL_KEY_ABI, [key]));
+}
 export function fPoolKeyOf(c, a) {
     const { bases, companions } = sortFPoolLegs(a.bases, a.weights);
     return {
@@ -698,15 +722,46 @@ export async function fPoolInitialize(c, a) {
     });
     return c.wallet.writeContract(request);
 }
-/** 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, a) {
-    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, poolId, opts = {}) {
+    const ev = fPoolManagerAbi.find((x) => x.type === "event" && x.name === "FInitialize");
+    const logs = await c.public.getLogs({
         address: c.addresses.fPoolManager,
-        abi: fPoolManagerAbi,
-        functionName: "idOf",
-        args: [key],
+        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;
+    const key = {
+        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;
 }
 /**
  * The reserve a leg holds at a mark: `R = Lj·e^{−x}`, WAD math. The seed names RESERVES —
@@ -745,7 +800,7 @@ export async function fPoolRetireRaw(c, a) {
  * 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, a) {
     const harvests = await fPoolEmptyingHarvests(c, a.poolId);
@@ -759,28 +814,41 @@ export async function fPoolRetire(c, 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, poolId) {
     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, a) {
     return writeFPool(c, a.poolId, "regenerate", [a.to ?? a.account], a.account);
@@ -1089,15 +1157,16 @@ export async function getFPoolRules(c, s, roles) {
     const harvestCut = await rd(fPolicyBaseAbi, "harvestCut");
     switch (s.kind) {
         case "pad": {
-            const [rung, creatorShare, protocolShare, burnPerRung, pot] = await Promise.all([
-                rd(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(padPolicyAbi, "creatorShare"),
                 rd(padPolicyAbi, "protocolShare"),
                 rd(padPolicyAbi, "burnPerRung"),
-                fPoolDividendOf(c, s.poolId, DEAD_ADDRESS, s.gen),
+                fPoolDividendOf(c, s.poolId, DEAD_ADDRESS, gen),
+                rd(padPolicyAbi, "threshold", [BigInt(gen)]),
             ]);
-            const threshold = await rd(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(polPolicyAbi, "keepQuote"), rd(polPolicyAbi, "minQuoteAtSeed")]);