@logswap/sdk 0.5.40 → 0.5.41

package/dist/fpool.d.ts

@@ -61,16 +61,6 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [];
-    readonly name: "LEVER_FLOOR";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];
@@ -416,9 +406,9 @@ export declare const fPoolManagerAbi: readonly [{
             readonly internalType: "address";
             readonly type: "address";
         }, {
-            readonly name: "lockStrike";
-            readonly internalType: "bool";
-            readonly type: "bool";
+            readonly name: "kind";
+            readonly internalType: "enum Kind";
+            readonly type: "uint8";
         }, {
             readonly name: "seeded";
             readonly internalType: "bool";
@@ -476,9 +466,9 @@ export declare const fPoolManagerAbi: readonly [{
             readonly internalType: "address";
             readonly type: "address";
         }, {
-            readonly name: "minBuffer";
-            readonly internalType: "uint96";
-            readonly type: "uint96";
+            readonly name: "pendingOperator";
+            readonly internalType: "address";
+            readonly type: "address";
         }, {
             readonly name: "incomeTaken";
             readonly internalType: "uint256";
@@ -527,9 +517,9 @@ export declare const fPoolManagerAbi: readonly [{
             readonly internalType: "uint256";
             readonly type: "uint256";
         }, {
-            readonly name: "lockStrike";
-            readonly internalType: "bool";
-            readonly type: "bool";
+            readonly name: "kind";
+            readonly internalType: "enum Kind";
+            readonly type: "uint8";
         }, {
             readonly name: "authority";
             readonly internalType: "address";
@@ -570,9 +560,9 @@ export declare const fPoolManagerAbi: readonly [{
             readonly internalType: "uint256";
             readonly type: "uint256";
         }, {
-            readonly name: "lockStrike";
-            readonly internalType: "bool";
-            readonly type: "bool";
+            readonly name: "kind";
+            readonly internalType: "enum Kind";
+            readonly type: "uint8";
         }, {
             readonly name: "authority";
             readonly internalType: "address";
@@ -1516,9 +1506,9 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "uint256";
         readonly indexed: false;
     }, {
-        readonly name: "lockStrike";
-        readonly internalType: "bool";
-        readonly type: "bool";
+        readonly name: "kind";
+        readonly internalType: "enum Kind";
+        readonly type: "uint8";
         readonly indexed: false;
     }];
     readonly name: "Initialize";
@@ -1531,62 +1521,22 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "bytes32";
         readonly indexed: true;
     }, {
-        readonly name: "j";
+        readonly name: "gen";
         readonly internalType: "uint256";
         readonly type: "uint256";
         readonly indexed: true;
     }, {
-        readonly name: "base";
-        readonly internalType: "address";
-        readonly type: "address";
-        readonly indexed: false;
-    }, {
-        readonly name: "newLj";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }, {
-        readonly name: "reserve";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }, {
-        readonly name: "L";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }, {
-        readonly name: "theta0";
-        readonly internalType: "int256";
-        readonly type: "int256";
-        readonly indexed: false;
-    }, {
-        readonly name: "dReserve";
-        readonly internalType: "int256";
-        readonly type: "int256";
-        readonly indexed: false;
-    }, {
-        readonly name: "dShares";
-        readonly internalType: "int256";
-        readonly type: "int256";
+        readonly name: "bases";
+        readonly internalType: "address[]";
+        readonly type: "address[]";
         readonly indexed: false;
-    }];
-    readonly name: "LegSet";
-}, {
-    readonly type: "event";
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-        readonly indexed: true;
     }, {
-        readonly name: "minBuffer";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
+        readonly name: "weights";
+        readonly internalType: "uint256[]";
+        readonly type: "uint256[]";
         readonly indexed: false;
     }];
-    readonly name: "MinBufferRaised";
+    readonly name: "LegsSet";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -1632,6 +1582,26 @@ export declare const fPoolManagerAbi: readonly [{
         readonly indexed: false;
     }];
     readonly name: "NameSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "current";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "proposed";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }];
+    readonly name: "OperatorProposed";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -1866,35 +1836,35 @@ export declare const fPoolManagerAbi: readonly [{
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "BalanceOverflow";
+    readonly name: "BadWeights";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "InsufficientBalance";
+    readonly name: "BalanceOverflow";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "InsufficientPermission";
+    readonly name: "FloorLocked";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "InsufficientQuote";
+    readonly name: "InsufficientBalance";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "InvalidToken";
+    readonly name: "InsufficientPermission";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "LegHeld";
+    readonly name: "InsufficientQuote";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "LegLive";
+    readonly name: "InvalidToken";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "MinBuffer";
+    readonly name: "LegHeld";
 }, {
     readonly type: "error";
     readonly inputs: readonly [{
@@ -1934,15 +1904,15 @@ export declare const fPoolManagerAbi: readonly [{
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "NotRetired";
+    readonly name: "NotPrivate";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "NotSeeded";
+    readonly name: "NotRetired";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "NotSoleLP";
+    readonly name: "NotSeeded";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -1983,10 +1953,6 @@ export declare const fPoolManagerAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "Slippage";
-}, {
-    readonly type: "error";
-    readonly inputs: readonly [];
-    readonly name: "StrikeLocked";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -2035,16 +2001,6 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [];
-    readonly name: "LEVER_FLOOR";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];
@@ -2087,29 +2043,9 @@ export declare const fPoolManagerAbi: readonly [{
         readonly name: "poolId";
         readonly internalType: "bytes32";
         readonly type: "bytes32";
-    }, {
-        readonly name: "base";
-        readonly internalType: "address";
-        readonly type: "address";
-    }, {
-        readonly name: "Lj";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }, {
-        readonly name: "R";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly name: "admitLeg";
-    readonly outputs: readonly [{
-        readonly name: "dReserve";
-        readonly internalType: "int256";
-        readonly type: "int256";
-    }, {
-        readonly name: "dShares";
-        readonly internalType: "int256";
-        readonly type: "int256";
     }];
+    readonly name: "acceptOperator";
+    readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
@@ -2539,20 +2475,6 @@ export declare const fPoolManagerAbi: readonly [{
     readonly name: "proposeCollector";
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "minBuffer";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly name: "raiseMinBuffer";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -2624,28 +2546,16 @@ export declare const fPoolManagerAbi: readonly [{
         readonly internalType: "bytes32";
         readonly type: "bytes32";
     }, {
-        readonly name: "j";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }, {
-        readonly name: "newLj";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }, {
-        readonly name: "rIfNew";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }];
-    readonly name: "setLegL";
-    readonly outputs: readonly [{
-        readonly name: "dReserve";
-        readonly internalType: "int256";
-        readonly type: "int256";
+        readonly name: "weights";
+        readonly internalType: "uint256[]";
+        readonly type: "uint256[]";
     }, {
-        readonly name: "dShares";
-        readonly internalType: "int256";
-        readonly type: "int256";
+        readonly name: "newBases";
+        readonly internalType: "address[]";
+        readonly type: "address[]";
     }];
+    readonly name: "setLegs";
+    readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
@@ -3195,9 +3105,9 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "uint256";
         readonly indexed: false;
     }, {
-        readonly name: "lockStrike";
-        readonly internalType: "bool";
-        readonly type: "bool";
+        readonly name: "kind";
+        readonly internalType: "enum Kind";
+        readonly type: "uint8";
         readonly indexed: false;
     }];
     readonly name: "Initialize";
@@ -3210,62 +3120,22 @@ export declare const fPoolManagerAbi: readonly [{
         readonly type: "bytes32";
         readonly indexed: true;
     }, {
-        readonly name: "j";
+        readonly name: "gen";
         readonly internalType: "uint256";
         readonly type: "uint256";
         readonly indexed: true;
     }, {
-        readonly name: "base";
-        readonly internalType: "address";
-        readonly type: "address";
-        readonly indexed: false;
-    }, {
-        readonly name: "newLj";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }, {
-        readonly name: "reserve";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }, {
-        readonly name: "L";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }, {
-        readonly name: "theta0";
-        readonly internalType: "int256";
-        readonly type: "int256";
-        readonly indexed: false;
-    }, {
-        readonly name: "dReserve";
-        readonly internalType: "int256";
-        readonly type: "int256";
-        readonly indexed: false;
-    }, {
-        readonly name: "dShares";
-        readonly internalType: "int256";
-        readonly type: "int256";
+        readonly name: "bases";
+        readonly internalType: "address[]";
+        readonly type: "address[]";
         readonly indexed: false;
-    }];
-    readonly name: "LegSet";
-}, {
-    readonly type: "event";
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly name: "poolId";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-        readonly indexed: true;
     }, {
-        readonly name: "minBuffer";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
+        readonly name: "weights";
+        readonly internalType: "uint256[]";
+        readonly type: "uint256[]";
         readonly indexed: false;
     }];
-    readonly name: "MinBufferRaised";
+    readonly name: "LegsSet";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -3311,6 +3181,26 @@ export declare const fPoolManagerAbi: readonly [{
         readonly indexed: false;
     }];
     readonly name: "NameSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "current";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "proposed";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }];
+    readonly name: "OperatorProposed";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -3545,35 +3435,35 @@ export declare const fPoolManagerAbi: readonly [{
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "BalanceOverflow";
+    readonly name: "BadWeights";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "InsufficientBalance";
+    readonly name: "BalanceOverflow";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "InsufficientPermission";
+    readonly name: "FloorLocked";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "InsufficientQuote";
+    readonly name: "InsufficientBalance";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "InvalidToken";
+    readonly name: "InsufficientPermission";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "LegHeld";
+    readonly name: "InsufficientQuote";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "LegLive";
+    readonly name: "InvalidToken";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "MinBuffer";
+    readonly name: "LegHeld";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -3609,15 +3499,15 @@ export declare const fPoolManagerAbi: readonly [{
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "NotRetired";
+    readonly name: "NotPrivate";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "NotSeeded";
+    readonly name: "NotRetired";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
-    readonly name: "NotSoleLP";
+    readonly name: "NotSeeded";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -3658,10 +3548,6 @@ export declare const fPoolManagerAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "Slippage";
-}, {
-    readonly type: "error";
-    readonly inputs: readonly [];
-    readonly name: "StrikeLocked";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -3712,28 +3598,27 @@ export interface FPoolState {
     compositeX: bigint;
     /** Σ = ∫ Σ_j w_j (dx_j)², accrued even though the fee is fixed — the kernel stays calculable. */
     bigSigma: bigint;
-    /** Creator (private) or a governance contract (public). Holds the floor lever. */
+    /** The cold key (decisions 037): seeds the pool, hands it over, names it, gates it (private). A creator, a treasury, a governance contract. */
     authority: Address;
     /** The proposed next authority, until it accepts — zero when nothing is pending (decisions 020). */
     pendingAuthority: Address;
-    /** The desk's hot key (`ma-private.md` §6): may reshape composition, never move value out. Zero when none. */
+    /**
+     * The hot key that RUNS the pool (decisions 037): `harvest`, `dissolve`, `setLegs`. Zero means
+     * the authority itself — see {@link fPoolOperatorOf}. Appointed two-step on a private pool.
+     */
     operator: Address;
+    /** The proposed next operator, until it accepts — zero when nothing is pending. */
+    pendingOperator: Address;
     /** The sponsor's own label for this pool, mutable and never identity. "" when unnamed. */
     name: string;
-    /** `harvest` may not take Q/L under this (WAD log-distance); raise-only (decisions 021). */
-    minBuffer: bigint;
     /** Only `allowed` accounts may receive minted shares. */
     gateMint: boolean;
     /** Only `allowed` takers may swap. */
     gateSwap: boolean;
-    /** The block of the last lever / composition action: no swap runs in it. */
+    /** The block of the last harvest / composition action: no swap runs in it. */
     restructureBlock: number;
-    /**
-     * The strike is locked (decisions 027, formerly `feesOnly`): `harvest` resets the floor to θ₀
-     * and never past it, so only income can leave; and the pool cannot be dissolved while it bids.
-     * The pad's promise. Pairs with a locked seed (shares at 0xdead) — the class is the two bits.
-     */
-    lockStrike: boolean;
+    /** The rung — see {@link FPoolKind}. */
+    kind: FPoolKind;
     /** False before the first seed — and between a dissolve and the next one (decisions 032). */
     seeded: boolean;
     /**
@@ -3748,7 +3633,26 @@ export interface FPoolState {
 }
 /** Read a basket pool whole. Batched — viem multicalls these when the transport allows. */
 export declare function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolState>;
-/** Which of the two products a pool is configured as. A UI has to choose what to render. */
+/**
+ * The kind of pool (decisions 036, 038). `public`: the protocol's own pool — born with the fee
+ * collector as its authority (which may hand it to a governance contract); no gates, no operator.
+ * `private`, the desk: every entry — gates, a list, an operator that reshapes the legs between
+ * generations, an unbounded harvest, the seed kept. `pol`, a treasury's pool or a basket: no
+ * gates, no operator — composition and access fixed at birth; harvest unbounded, seed the
+ * seeder's. `pad`, a launch: a POL whose harvest never lifts the floor above the seed floor and
+ * whose seed the contract minted to 0xdead — one asset, open to all. private → pol → pad is the
+ * ladder of rigidity; public is a pol held by the protocol.
+ */
+export type FPoolKind = "public" | "private" | "pol" | "pad";
+/** The key's enum values. */
+export declare const F_KIND: {
+    readonly public: 0;
+    readonly private: 1;
+    readonly pol: 2;
+    readonly pad: 3;
+};
+export declare function fPoolKindOf(n: number | bigint): FPoolKind;
+/** Which of the two products a pool is configured as — a pad is a launch, anything else a basket/pool. A UI has to choose what to render. */
 export type FPoolShape = "launch" | "basket";
 export interface FPoolDescription {
     shape: FPoolShape;
@@ -3885,8 +3789,9 @@ export declare function fPoolPreviewRollIn(c: LogswapClient, poolId: Hex, gen: b
  * Remove quote, lifting θ — price-neutral, no base moves, and since decisions 028 a DIVIDEND to
  * every share: the amount goes into the pool's pot and each holder's slice is settled lazily on
  * their next transfer, mint or burn, or pulled with {@link fPoolClaim}. The sponsor's own slice —
- * its shares' and the locked seed's at 0xdead — is pushed to `to` at once. Under `lockStrike`
- * the lift stops at θ₀ (income only); on every live pool it stops at `LEVER_FLOOR` (Q/L ≥ ln 1.25).
+ * its shares' and the locked seed's at 0xdead — is pushed to `to` at once. On a pad
+ * the lift stops at the seed floor θ₀ (income only); nothing else bounds it (decisions 035) — an
+ * unlocked pool's authority may take Q to zero.
  */
 export declare function fPoolHarvest(c: LogswapClient, a: {
     poolId: Hex;
@@ -3907,8 +3812,6 @@ export declare function fPoolClaim(c: LogswapClient, a: {
 }): Promise<`0x${string}`>;
 /** 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;
 /** Plain ERC-20 approval to the F manager — the allowance every DIRECT call pulls against. */
 export declare function approveTokenForFPoolManager(c: LogswapClient, token: Address): Promise<Hash>;
 /** Does `owner` have enough allowance on `token` for the MANAGER to pull `need`? */
@@ -3988,8 +3891,8 @@ export interface FPoolCreateArgs {
     weights: bigint[];
     /** Fixed fee, WAD. The base-for-base fee is pinned at 2φ on-chain. */
     phi: bigint;
-    /** true: the strike is locked — harvest stops at θ₀ and the pool cannot be dissolved live (the pad's posture; decisions 027). */
-    lockStrike: boolean;
+    /** The rung (decisions 036) — see {@link FPoolKind}. In the key: the pool's identity, never changed after. */
+    kind: FPoolKind;
     authority: Address;
     /**
      * The differentiator, and nothing else. Identity is the key's hash, so one sponsor cannot run
@@ -4039,30 +3942,60 @@ export declare function fPoolSeed(c: LogswapClient, a: {
     weights: bigint[];
 })): Promise<`0x${string}`>;
 /**
- * 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.
+ * Retire the live generation (decisions 025, 032, 035) — the raw entry. Allowed only at an empty
+ * bid, Q ≤ L/1e9, on every pool: the market took it, or the authority harvested it out first
+ * ({@link fPoolRetire} does both in one transaction). 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 and lists.
  */
 export declare function fPoolDissolve(c: LogswapClient, a: {
     poolId: Hex;
     account: Address;
 }): Promise<`0x${string}`>;
 /**
- * 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`.
+ * Retire the live generation as ONE transaction: the harvests that empty the bid
+ * ({@link fPoolEmptyingHarvests} — a dividend to every share; none when it is already empty),
+ * then `dissolve` — the manager's `multicall`, the authority as sender. What a sponsor's
+ * "dissolve" button should call. Throws before sending on a pad that still bids.
+ */
+export declare function fPoolRetire(c: LogswapClient, a: {
+    poolId: Hex;
+    account: Address;
+}): Promise<`0x${string}`>;
+/**
+ * The harvests that empty an unlocked pool's bid, in order — what a relaunch sends before its
+ * `dissolve` (decisions 035: a dissolve needs an empty bid on every pool). One `harvest(Q)` when a
+ * collector is set. With none, the cut on income STAYS in the pool as LP quote (decisions 002)
+ * and reads as taken income, so a second harvest — capital, no cut — takes the rest; the
+ * contract's own arithmetic, replayed. `[]` when the bid is already empty. Throws on a
+ * pad that still bids (its bid empties only as the market sells it down), and in
+ * the one shape two harvests cannot empty (no collector, income above Q — harvest by hand).
+ */
+export declare function fPoolEmptyingHarvests(c: LogswapClient, poolId: Hex): Promise<bigint[]>;
+/**
+ * The relaunch as ONE transaction (decisions 025, 032, 035, 037): `harvest` the bid out — a
+ * dividend to every share, {@link fPoolEmptyingHarvests} — `dissolve` the live generation at the
+ * empty bid, `redeem` the caller's own shares of it (when `shares` > 0), optionally `setLegs` the
+ * next generation's composition (`legs`: a private pool's reshape — retire, admit, reweight), and
+ * `seed` it with what came back — the manager's `multicall`, one sender throughout, the same
+ * pool. The operator's when one is appointed and the seed's inventory is its own; by default the
+ * authority's. Gates, allowlist and names carry over; anything else goes in `extra`, pre-encoded
+ * against {@link fPoolManagerAbi}. The seed names reserves (decisions 029): `r0` outright — one
+ * per leg of the NEXT table, 0 for a retired leg — or `x0` marks against the next table's
+ * `weights`.
  */
 export declare function fPoolRelaunch(c: LogswapClient, a: {
     poolId: Hex;
-    /** the sponsor's shares of the retiring generation to redeem inside the batch — its whole balance, usually; 0 to keep the claim */
+    /** the caller'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;
+    /** the next generation's composition (decisions 037): one weight per existing leg (0 retires it), then one per new base */
+    legs?: {
+        weights: bigint[];
+        newBases?: Address[];
+    };
     extra?: Hex[];
     account: Address;
 } & ({
@@ -4071,20 +4004,14 @@ export declare function fPoolRelaunch(c: LogswapClient, a: {
     x0: bigint[];
     weights: bigint[];
 })): Promise<`0x${string}`>;
-/** ERC-6909 shares sent here are locked for good — the seed's custody (custody.md §4(b)). */
+/** Where a pad's seed lives (decisions 036): `seed` mints every share of a pad here itself. */
 export declare const DEAD_ADDRESS: Address;
-/** The manager's `MIN_SHARES`: the seed mints this much to 0xdead itself, the rest to the seeder. */
+/** The manager's `MIN_SHARES`: the seed mints this much to 0xdead on every pool, the rest to the seeder — or, on a pad, to 0xdead too. */
 export declare const F_MIN_SHARES = 1000n;
 export interface FPoolLaunchArgs extends Omit<FPoolCreateArgs, "account"> {
     L0: bigint;
     /** Quote the seed pulls. A pad seeds at 0 — pure float, a resting ask, nothing raised. */
     Q0: bigint;
-    /**
-     * Send every share the seed mints to the creator (`L0 − MIN_SHARES`) to 0xdead in the same
-     * batch: the float and the raise can never be burned out from under the buyers. The lever
-     * (harvest) is the authority's and survives it; the exit does not. A pad's default posture.
-     */
-    lockSeed?: boolean;
     /**
      * An opening buy of leg `j` (an index into `bases` AS GIVEN) for `amountIn` of quote, ON THE
      * MANAGER — the same sender, a plain allowance to the manager, the router nowhere near it. A
@@ -4099,8 +4026,6 @@ export interface FPoolLaunchArgs extends Omit<FPoolCreateArgs, "account"> {
     };
     /** The pool's label, set in the batch (≤ 31 bytes of UTF-8). */
     name?: string;
-    /** Gate minting, list the creator, appoint them operator (decisions 021) — three calls, in the batch. */
-    privatePool?: boolean;
     /**
      * The pool already exists (a previous launch got as far as `initialize` and no further — a seed
      * that reverted, a closed tab, before the launch was one transaction), so `initialize` is left
@@ -4195,47 +4120,41 @@ export declare function fPoolSetSponsorName(c: LogswapClient, a: {
 }): Promise<`0x${string}`>;
 /** The protocol's attestation for an address, or "" when unattested — which most addresses are. */
 export declare function fPoolSponsorName(c: LogswapClient, who: Address): Promise<string>;
-/** Appoint (or clear, with the zero address) the operator — the hot key that reshapes and never moves value out. */
+/** Who runs the pool (decisions 037): the appointed operator, or the authority until one is. */
+export declare function fPoolOperatorOf(s: Pick<FPoolState, "authority" | "operator">): Address;
+/**
+ * Propose the operator (authority; private pools only) — the hot key that runs the pool: `harvest`,
+ * `dissolve`, `setLegs`. Two-step: the proposed address takes the role with
+ * {@link fPoolAcceptOperator}. The zero address clears at once — the role returns to the authority.
+ */
 export declare function fPoolAppointOperator(c: LogswapClient, a: {
     poolId: Hex;
     operator: Address;
     account: Address;
 }): Promise<`0x${string}`>;
-/**
- * Raise the floor guard: `harvest` may not take Q/L under `minBuffer` (WAD log-distance; 20% below
- * spot is ln 1.25 ≈ 0.223e18). Raise-only — a commitment the authority cannot walk back.
- */
-export declare function fPoolRaiseMinBuffer(c: LogswapClient, a: {
+/** The proposed operator takes the role. */
+export declare function fPoolAcceptOperator(c: LogswapClient, a: {
     poolId: Hex;
-    minBuffer: bigint;
     account: Address;
 }): Promise<`0x${string}`>;
 /**
- * Set leg `j`'s liquidity (operator, sole LP only): grow, shrink, retire (`newLj = 0`), or re-admit
- * a retired leg holding `r` of the base (decisions 029 — the price follows, `p = newLj / r`; use
- * {@link fPoolReserveAt} from a mark). For a live leg leave `r` undefined — its price is the
- * market's, the reserve scales with the liquidity. Base moves single-sidedly through the lock;
- * shares adjust to hold the share value.
+ * The next generation's composition (operator; private pools only; ONLY while the pool is
+ * unseeded — between a dissolve and the seed that prices it, decisions 037). `weights` has one
+ * entry per leg the pool has ever had, in index order (0 retires a leg; indices are never reused),
+ * then one per base in `newBases`, appended; they sum to 1e18 exactly. No value moves: the
+ * following {@link fPoolSeed} names every reserve. A live reshape is {@link fPoolRelaunch} with
+ * `legs` set.
  */
-export declare function fPoolSetLegL(c: LogswapClient, a: {
+export declare function fPoolSetLegs(c: LogswapClient, a: {
     poolId: Hex;
-    j: number;
-    newLj: bigint;
-    r?: bigint;
-    account: Address;
-}): Promise<`0x${string}`>;
-/** Admit a base the pool has never held: `R` of it against liquidity `Lj`, so at `p = Lj / R` (operator, sole LP only). */
-export declare function fPoolAdmitLeg(c: LogswapClient, a: {
-    poolId: Hex;
-    base: Address;
-    Lj: bigint;
-    R: bigint;
+    weights: bigint[];
+    newBases?: Address[];
     account: Address;
 }): Promise<`0x${string}`>;
 /**
  * Move shares (ERC-6909 `transfer`) — to another holder, or to `0xdead` to lock them for good.
  * Burning to the dead address is a sponsor's way to make its liquidity permanent: the shares can
- * never be redeemed, and they never count against the sole-LP precondition.
+ * never be redeemed.
  */
 export declare function fPoolTransferShares(c: LogswapClient, a: {
     poolId: Hex;
@@ -4250,7 +4169,7 @@ export interface DiscoveredFPool {
     bases: Address[];
     weights: bigint[];
     phi: bigint;
-    lockStrike: boolean;
+    kind: FPoolKind;
     authority: Address;
     /** The block the pool was initialized in — its age, for annualising realized income. */
     block: bigint;
@@ -4268,7 +4187,7 @@ export interface DiscoveredFPool {
 }
 /**
  * Every F pool ever created, from `Initialize` logs alone. Possible only because the event
- * carries the full key preimage (bases, weights, phi, lockStrike) — the poolId is a hash and could
+ * carries the full key preimage (bases, weights, phi, pad) — the poolId is a hash and could
  * never be inverted; contracts PR #17 exists for exactly this call.
  */
 export declare function discoverFPools(c: LogswapClient, opts?: {
@@ -4287,7 +4206,7 @@ export declare function fPoolShareHolders(c: LogswapClient, poolIdHex: Hex, opts
     holder: Address;
     shares: bigint;
 }>>;
-/** 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, harvestedTheta). */
+/** 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. */
 export declare function shareValueOnChain(c: LogswapClient, poolId: Hex): Promise<bigint>;