@logswap/sdk 0.5.37 → 0.5.38

package/dist/client.d.ts

@@ -64,5 +64,5 @@ export declare const EXPECTED_VERSION = 3n;
  * 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 = 7n;
+export declare const EXPECTED_F_VERSION = 8n;
 export declare function assertVersion(c: LogswapClient, expected?: bigint): Promise<void>;

package/dist/client.js

@@ -42,9 +42,12 @@ export const EXPECTED_VERSION = 3n;
  */
 // 7 (2026-09-15): the reserves are the state and the marks derived, `lockStrike`, the dividend
 // harvest, the relaunch (`dissolve(poolId, successor)`, `rollIn`), the reserve-named seed, the
-// sponsor facet — decisions 025–031. A 5 or 6 deployment reads with this SDK but every F write
-// below `seed` / `dissolve` / `setLegL` / `admitLeg` has moved its signature.
-export const EXPECTED_F_VERSION = 7n;
+// sponsor facet — decisions 025–031.
+// 8 (2026-09-15): the relaunch is in place (decisions 032) — every share id carries the
+// generation (`fPoolShareId(poolId, gen)`), `dissolve(poolId)`, `redeem`, `claim` / `dividendOf`
+// / `rollIn` / `previewRollIn` take the generation, `Pool.gen` replaces `dissolved` and
+// `successor`. A 7 deployment's share ids do not even resolve with this SDK.
+export const EXPECTED_F_VERSION = 8n;
 export async function assertVersion(c, expected = EXPECTED_VERSION) {
     const { cPoolManagerAbi } = await import("./generated.js");
     const got = await c.public.readContract({

package/dist/fpool.d.ts

@@ -177,6 +177,32 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "bundleOf";
+    readonly outputs: readonly [{
+        readonly name: "supply";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "quote";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "base";
+        readonly internalType: "uint256[]";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -297,6 +323,10 @@ export declare const fPoolManagerAbi: readonly [{
         readonly name: "poolId";
         readonly internalType: "bytes32";
         readonly type: "bytes32";
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
     }, {
         readonly name: "holder";
         readonly internalType: "address";
@@ -394,9 +424,9 @@ export declare const fPoolManagerAbi: readonly [{
             readonly internalType: "bool";
             readonly type: "bool";
         }, {
-            readonly name: "dissolved";
-            readonly internalType: "bool";
-            readonly type: "bool";
+            readonly name: "gen";
+            readonly internalType: "uint16";
+            readonly type: "uint16";
         }, {
             readonly name: "n";
             readonly internalType: "uint8";
@@ -457,10 +487,6 @@ export declare const fPoolManagerAbi: readonly [{
             readonly name: "name";
             readonly internalType: "bytes32";
             readonly type: "bytes32";
-        }, {
-            readonly name: "successor";
-            readonly internalType: "bytes32";
-            readonly type: "bytes32";
         }];
     }];
     readonly stateMutability: "view";
@@ -796,6 +822,32 @@ export declare const fPoolManagerAbi: readonly [{
     readonly name: "quoteSwap";
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "owner";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "shares";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "redeem";
+    readonly outputs: readonly [{
+        readonly name: "quoteOut";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -874,6 +926,10 @@ export declare const fPoolManagerAbi: readonly [{
         readonly name: "poolId";
         readonly internalType: "bytes32";
         readonly type: "bytes32";
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
     }];
     readonly name: "shareIdOf";
     readonly outputs: readonly [{
@@ -1330,10 +1386,20 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "bytes32";
         readonly indexed: true;
     }, {
-        readonly name: "successor";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
         readonly indexed: true;
+    }, {
+        readonly name: "supply";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "quote";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
     }];
     readonly name: "Dissolve";
 }, {
@@ -1654,6 +1720,41 @@ export declare const fPoolManagerAbi: readonly [{
         readonly internalType: "bytes32";
         readonly type: "bytes32";
         readonly indexed: true;
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "owner";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "shares";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "quoteOut";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+    readonly name: "Redeem";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: true;
     }, {
         readonly name: "L0";
         readonly internalType: "uint256";
@@ -1782,18 +1883,10 @@ export declare const fPoolManagerAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "BadParam";
-}, {
-    readonly type: "error";
-    readonly inputs: readonly [];
-    readonly name: "BadSuccessor";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "BalanceOverflow";
-}, {
-    readonly type: "error";
-    readonly inputs: readonly [];
-    readonly name: "Dissolved_";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -1858,6 +1951,10 @@ export declare const fPoolManagerAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "NotOperator";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotRetired";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -1918,6 +2015,10 @@ export declare const fPoolManagerAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "TokensNotSettled";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "TooManyGenerations";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -2124,6 +2225,32 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "bundleOf";
+    readonly outputs: readonly [{
+        readonly name: "supply";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "quote";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "base";
+        readonly internalType: "uint256[]";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -2144,6 +2271,10 @@ export declare const fPoolManagerAbi: readonly [{
         readonly name: "poolId";
         readonly internalType: "bytes32";
         readonly type: "bytes32";
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
     }, {
         readonly name: "to";
         readonly internalType: "address";
@@ -2250,10 +2381,6 @@ export declare const fPoolManagerAbi: readonly [{
         readonly name: "poolId";
         readonly internalType: "bytes32";
         readonly type: "bytes32";
-    }, {
-        readonly name: "successor";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
     }];
     readonly name: "dissolve";
     readonly outputs: readonly [];
@@ -2616,6 +2743,10 @@ export declare const fPoolManagerAbi: readonly [{
         readonly name: "poolId";
         readonly internalType: "bytes32";
         readonly type: "bytes32";
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
     }];
     readonly name: "shareIdOf";
     readonly outputs: readonly [{
@@ -2968,10 +3099,20 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "bytes32";
         readonly indexed: true;
     }, {
-        readonly name: "successor";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
         readonly indexed: true;
+    }, {
+        readonly name: "supply";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "quote";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
     }];
     readonly name: "Dissolve";
 }, {
@@ -3292,6 +3433,41 @@ export declare const fPoolManagerAbi: readonly [{
         readonly internalType: "bytes32";
         readonly type: "bytes32";
         readonly indexed: true;
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "owner";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "shares";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "quoteOut";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+    readonly name: "Redeem";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "gen";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: true;
     }, {
         readonly name: "L0";
         readonly internalType: "uint256";
@@ -3420,18 +3596,10 @@ export declare const fPoolManagerAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "BadParam";
-}, {
-    readonly type: "error";
-    readonly inputs: readonly [];
-    readonly name: "BadSuccessor";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "BalanceOverflow";
-}, {
-    readonly type: "error";
-    readonly inputs: readonly [];
-    readonly name: "Dissolved_";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -3492,6 +3660,10 @@ export declare const fPoolManagerAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "NotOperator";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotRetired";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -3552,6 +3724,10 @@ export declare const fPoolManagerAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "TokensNotSettled";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "TooManyGenerations";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -3612,10 +3788,14 @@ export interface FPoolState {
      * The pad's promise. Pairs with a locked seed (shares at 0xdead) — the class is the two bits.
      */
     lockStrike: boolean;
+    /** False before the first seed — and between a dissolve and the next one (decisions 032). */
     seeded: boolean;
-    dissolved: boolean;
-    /** The pool this one dissolved into (decisions 025) — the relaunch's lineage; zero when none. */
-    successor: Hex;
+    /**
+     * The live GENERATION (decisions 032). Every dissolve retires one into a frozen 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.
+     */
+    gen: number;
     totalSupply: bigint;
     /** What the pool holds of each base — the STATE since decisions 026; the mark `x` is derived from it. */
     reserves: bigint[];
@@ -3722,16 +3902,18 @@ export declare function fPoolZapOut(c: LogswapClient, a: {
     deadline?: bigint;
 }): Promise<`0x${string}`>;
 /**
- * Roll a dissolved pool's bundle into its successor (decisions 025), on the router under one
- * lock: burn `shares` of `fromPool` in place — the legs, the quote and any unpulled dividend come
- * back — buy through `toPool`'s own curve only what its ratio lacks, mint `dL` of it to `to`, and
- * refund the rest in kind. Quote the bundle does not cover is pulled from the payer, at most
- * `maxQuoteIn`; surplus base is refunded, never sold. Size `dL` with {@link fPoolPreviewRollIn}.
- * The router must be the caller's ERC-6909 operator ({@link approveRouterForFPool}).
+ * Roll a retired generation's bundle into the pool's live one (decisions 025, 032), on the
+ * router under one lock: redeem `shares` of generation `gen` in place — the legs, the quote and
+ * any unpulled dividend come back — buy through the pool's own curve only what the live
+ * generation's ratio lacks, mint `dL` of it to `to`, and refund the rest in kind. Quote the
+ * bundle does not cover is pulled from the payer, at most `maxQuoteIn`; surplus base is
+ * refunded, never sold. Size `dL` with {@link fPoolPreviewRollIn}. The router must be the
+ * caller's ERC-6909 operator ({@link approveRouterForFPool}).
  */
 export declare function fPoolRollIn(c: LogswapClient, a: {
-    fromPool: Hex;
-    toPool: Hex;
+    poolId: Hex;
+    /** the retired generation whose shares roll */
+    gen: bigint | number;
     shares: bigint;
     dL: bigint;
     maxQuoteIn?: bigint;
@@ -3741,13 +3923,14 @@ export declare function fPoolRollIn(c: LogswapClient, a: {
     deadline?: bigint;
 }): Promise<`0x${string}`>;
 /**
- * The roll `holder`'s `shares` of `fromPool` fund into `toPool` WITHOUT a trade: the largest `dL`
- * the bundle's base covers on every successor leg, and the quote the bundle is short of (pass it
- * as `maxQuoteIn`) or over (refunded — the up direction's distribution) at that `dL`. A
- * successor leg the bundle does not hold makes `dL` zero: such a roll must buy, so size it below
- * with `previewZapIn` in mind.
+ * The roll `holder`'s `shares` of retired generation `gen` fund into the live one WITHOUT a
+ * trade: the largest `dL` the bundle's base covers on every leg, and the quote the bundle is
+ * short of (pass it as `maxQuoteIn`) or over (refunded — the up direction's distribution) at
+ * that `dL`. A leg the live generation admitted since makes `dL` zero: such a roll must buy, so
+ * size it below with `previewZapIn` in mind. Zero for the live generation, or before the next
+ * seed.
  */
-export declare function fPoolPreviewRollIn(c: LogswapClient, fromPool: Hex, toPool: Hex, holder: Address, shares: bigint): Promise<{
+export declare function fPoolPreviewRollIn(c: LogswapClient, poolId: Hex, gen: bigint | number, holder: Address, shares: bigint): Promise<{
     dL: bigint;
     quoteShort: bigint;
     quoteExcess: bigint;
@@ -3765,14 +3948,19 @@ export declare function fPoolHarvest(c: LogswapClient, a: {
     to?: Address;
     account: Address;
 }): Promise<`0x${string}`>;
-/** Pull one's settled dividend (decisions 028) without moving shares; anyone with shares. */
+/**
+ * Pull one's settled dividend (decisions 028) on a generation's shares without moving them;
+ * anyone with shares. `gen` defaults to the live generation; a retired generation's harvests
+ * stay claimable under its own id (decisions 032).
+ */
 export declare function fPoolClaim(c: LogswapClient, a: {
     poolId: Hex;
+    gen?: bigint | number;
     to?: Address;
     account: Address;
 }): Promise<`0x${string}`>;
-/** A holder's dividend as of now — banked plus pending on the current balance (decisions 028). */
-export declare function fPoolDividendOf(c: LogswapClient, poolId: Hex, holder: Address): Promise<bigint>;
+/** A holder's dividend as of now on generation `gen` (the live one by default) — banked plus pending on the current balance (decisions 028). */
+export declare function fPoolDividendOf(c: LogswapClient, poolId: Hex, holder: Address, gen?: bigint | number): Promise<bigint>;
 /** The lever's floor: `harvest` may not take Q/L under ln 1.25 — the floor stays ≥ 20% below the mark (decisions 025). */
 export declare const LEVER_FLOOR = 223143551314209755n;
 /** Commit quote, deepening θ — the other sign of `harvest`, the same word as the C floor edit (decisions 011). The mark does not move: governance may write θ, never x. */
@@ -3788,11 +3976,48 @@ export declare function fPoolManagerAllowanceOk(c: LogswapClient, token: Address
 export declare function isRouterOperatorForFPool(c: LogswapClient, owner: Address): Promise<boolean>;
 /** Approve the router to move this account's F-pool shares. Needed once, before any `fPoolZapOut`. */
 export declare function approveRouterForFPool(c: LogswapClient, account: Address): Promise<`0x${string}`>;
-/** The ERC-6909 id carrying a pool's shares. Bit 255 set. */
-export declare function fPoolShareId(poolId: Hex): bigint;
+/**
+ * The ERC-6909 id carrying generation `gen` of a pool's shares (decisions 032): bit 255 set (the
+ * share flag), the pool id's top 239 bits, the generation in the low 16. Each generation's shares
+ * are their own asset — a retired one is a claim on its bundle, the live one on the pool.
+ */
+export declare function fPoolShareId(poolId: Hex, gen?: bigint | number): bigint;
+/** The generation a share id carries — its low 16 bits. */
+export declare function fPoolGenOfShareId(id: bigint): number;
+/** The pool's live generation, one read. */
+export declare function fPoolGen(c: LogswapClient, poolId: Hex): Promise<number>;
 /** The ERC-6909 id carrying claims on a token. Bit 255 clear, so it can never meet a share id. */
 export declare function fPoolClaimId(token: Address): bigint;
-export declare function fPoolShareBalance(c: LogswapClient, poolId: Hex, owner: Address): Promise<bigint>;
+/** A holder's shares of generation `gen` — the live one by default. */
+export declare function fPoolShareBalance(c: LogswapClient, poolId: Hex, owner: Address, gen?: bigint | number): Promise<bigint>;
+/** A retired generation's bundle (decisions 032): what is left to redeem — supply, quote, base per leg index. */
+export declare function fPoolBundleOf(c: LogswapClient, poolId: Hex, gen: bigint | number): Promise<{
+    supply: bigint;
+    quote: bigint;
+    base: bigint[];
+}>;
+/** A holder's claim on one retired generation, as the lens reports it: what `redeem` pays now. */
+export interface FPoolClaimRow {
+    gen: number;
+    shares: bigint;
+    base: bigint[];
+    quote: bigint;
+    dividend: bigint;
+}
+/** A holder's claims on a pool's retired generations — one row per generation still held (decisions 032). */
+export declare function fPoolClaimsOf(c: LogswapClient, poolId: Hex, owner: Address): Promise<FPoolClaimRow[]>;
+/**
+ * Redeem `shares` of a RETIRED generation (decisions 032): its bundle, pro rata — the base per
+ * leg and the quote — plus the owner's settled dividend. Not `burn`: nothing can move a bundle's
+ * ratio, so there is no slippage to bound. The owner, or an operator of theirs.
+ */
+export declare function fPoolRedeem(c: LogswapClient, a: {
+    poolId: Hex;
+    gen: bigint | number;
+    shares: bigint;
+    owner?: Address;
+    account: Address;
+}): Promise<`0x${string}`>;
 export declare function fPoolClaimBalance(c: LogswapClient, token: Address, owner: Address): Promise<bigint>;
 export declare enum FPoolQuoteKind {
     QuoteIn = 0,
@@ -3874,36 +4099,38 @@ export declare function fPoolSeed(c: LogswapClient, a: {
     weights: bigint[];
 })): Promise<`0x${string}`>;
 /**
- * End of life (decisions 025). Allowed at Q ≤ L/1e9 on every pool — the market filled the ask —
- * and on a pool that is not strike-locked at any Q, provided `successor` names an initialized
- * pool of the same authority and quote: the relaunch. After it every share is a frozen in-kind
- * claim redeemed by `burn` (or rolled with {@link fPoolRollIn}), forever; the pool's `successor`
- * carries the lineage. Never a second dissolve on one pool: the successor is a NEW pool.
+ * Retire the live generation (decisions 025, 032). Allowed at Q ≤ L/1e9 on every pool — the
+ * market filled the ask — and on a pool that is not strike-locked at any Q. The live (S, Q, R_j)
+ * become a frozen bundle every share of this generation redeems ({@link fPoolRedeem}) or rolls
+ * ({@link fPoolRollIn}), forever; the pool is unseeded until the next {@link fPoolSeed}, which
+ * opens generation `gen + 1` under the same id, gates, lists and promises.
  */
 export declare function fPoolDissolve(c: LogswapClient, a: {
     poolId: Hex;
-    successor?: Hex;
     account: Address;
 }): Promise<`0x${string}`>;
 /**
- * The sponsor's relaunch as ONE transaction (decisions 025): `initialize` the successor key,
- * `dissolve` the old pool into it, `burn` the sponsor's own shares, `seed` the successor with what
- * came back — the manager's `multicall`, the sponsor as sender throughout. Gates, allowlist,
- * operator, floor guard and name are re-applied afterwards, or appended to `extra` pre-encoded
- * against {@link fPoolManagerAbi}. Returns the tx hash; the successor's id is {@link fPoolIdOf}
- * of `nextKey`.
+ * The sponsor's relaunch as ONE transaction (decisions 025, 032): `dissolve` the live generation,
+ * `redeem` the sponsor's own shares of it (when `shares` > 0), `seed` the next generation with
+ * what came back — the manager's `multicall`, the sponsor as sender throughout, the same pool.
+ * Gates, allowlist, operator, `minBuffer` and names carry over; anything else goes in `extra`,
+ * pre-encoded against {@link fPoolManagerAbi}. The seed names reserves (decisions 029): `r0`
+ * outright, or `x0` marks against the key's `weights`.
  */
 export declare function fPoolRelaunch(c: LogswapClient, a: {
     poolId: Hex;
-    nextKey: Omit<FPoolCreateArgs, "account">;
-    /** the sponsor's old shares to burn — its whole balance, usually */
+    /** the sponsor's shares of the retiring generation to redeem inside the batch — its whole balance, usually; 0 to keep the claim */
     shares: bigint;
     L0: bigint;
     Q0: bigint;
-    r0: bigint[];
     extra?: Hex[];
     account: Address;
-}): Promise<`0x${string}`>;
+} & ({
+    r0: bigint[];
+} | {
+    x0: bigint[];
+    weights: bigint[];
+})): Promise<`0x${string}`>;
 /**
  * Propose the next authority — step one of two (contracts `2aa6b7b`, decisions 020). Nothing moves
  * until `next` accepts; proposing again (the zero address included) cancels a pending proposal.
@@ -3999,6 +4226,7 @@ export declare function fPoolTransferShares(c: LogswapClient, a: {
     to: Address;
     shares: bigint;
     account: Address;
+    gen?: bigint | number;
 }): Promise<`0x${string}`>;
 export interface DiscoveredFPool {
     poolId: Hex;
@@ -4038,11 +4266,12 @@ export declare function discoverFPools(c: LogswapClient, opts?: {
  */
 export declare function fPoolShareHolders(c: LogswapClient, poolIdHex: Hex, opts?: {
     fromBlock?: bigint;
+    gen?: bigint | number;
 }): Promise<Array<{
     holder: Address;
     shares: bigint;
 }>>;
-/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, lockStrike, seeded, dissolved, successor, n, Q, L, shares, theta0, bigSigma, leverTheta). */
+/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, lockStrike, seeded, gen, n, Q, L, shares, theta0, bigSigma, leverTheta). */
 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. */
 export declare function shareValueOnChain(c: LogswapClient, poolId: Hex): Promise<bigint>;