@logswap/sdk 0.5.45 → 0.5.46

package/dist/fpool.d.ts

@@ -12,10 +12,17 @@
  * key is variable-length and only ever partially needed (no swap path is O(n)), so it is stored
  * once at `initialize` and every later call names `(poolId, j)`. Callers hold a `bytes32`.
  *
- * **Two products, one contract.** The basket (n > 1, public authority) and the launch (n = 1, the
- * creator alone on the lever) are the same bytecode under different settings — what separates them
- * is who holds `authority` and how many bases there are, and nothing in the maths. `describeFPool`
- * below reports which shape a given pool is, because a UI has to decide what to render.
+ * **Two products, one contract.** The basket (n > 1) and the launch (n = 1, the creator alone on
+ * the lever) are the same bytecode under two key fields — the KIND (what the manager promises
+ * structurally) and the HOOK (the pool's policy: its roles, its gates, the terms of every harvest
+ * and release; decisions 041, 044) — and nothing in the maths. `describeFPool` below reports
+ * which shape a given pool is, because a UI has to decide what to render.
+ *
+ * **The roles are the hook's, not the manager's** (F version 15). The manager holds no
+ * authority, operator, gate or list: it asks the pool's hook `may(who, action)` and acts on the
+ * answer. So `getFPool` carries the hook and what it declared, {@link getFPoolRoles} reads the
+ * roles FROM the hook, and every role write — the handover, the operator, the gates, the list —
+ * is a write to the hook ({@link fPoolProposeAuthority}, {@link fPoolSetGates}, …).
  *
  * **Zaps live on the ROUTER, not here.** Permit2 is AllowanceTransfer mode, whose standing
  * allowance is keyed by spender, so a second router would cost the user an allowance per token
@@ -23,16 +30,491 @@
  * `addresses.router`.
  */
 import { type Address, type Hash, type Hex } from "viem";
-import { fPoolManagerAbi } from "./generated.js";
+import { fPoolManagerAbi, padHookAbi, polHookAbi, privateHookAbi, publicHookAbi } from "./generated.js";
+/**
+ * One contract, one ABI (decisions 039, F version 12): `harvest`, `claim`, `retire`, `regenerate`,
+ * `setLegs`, the names, the fee parameters are `FPoolManager`'s own code. The roles left it for
+ * the hooks in F version 15 (decisions 044): {@link fHookBaseAbi} is what every hook shares,
+ * {@link privateHookAbi} the desk's, {@link padHookAbi} / {@link polHookAbi} / {@link publicHookAbi}
+ * the kinds'.
+ */
+export { fPoolManagerAbi, padHookAbi, polHookAbi, privateHookAbi, publicHookAbi };
 /**
- * One contract, one ABI (decisions 039, F version 12): the sponsor surface — `harvest`, `claim`,
- * `dissolve`, the handover, the gates, the operator, `setLegs`, the names, the fee parameters —
- * is `FPoolManager`'s own code again. From 031 to 038 it was a delegatecall facet
- * (`FPoolSponsor`) and this ABI was the union of the two compiled halves; the union is gone with
- * the facet, and the generated ABI is the whole surface.
+ * What every protocol hook shares (`FHookBase`): the roles and their handover, `harvestCut`,
+ * `maxHarvest`. `polHookAbi` is a superset of it and carries nothing that collides, so it stands
+ * in for the base — a call through it to any of the four hooks decodes the base's functions.
  */
-export { fPoolManagerAbi };
+export declare const fHookBaseAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "_manager";
+        readonly internalType: "contract FPoolManager";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "acceptAuthority";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "authority";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "creator";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "harvestCut";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "keepQuote";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "manager";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "contract FPoolManager";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "maxHarvest";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "a";
+        readonly internalType: "struct IFHook.Ask";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "poolId";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "gen";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "action";
+            readonly internalType: "enum IFHook.Action";
+            readonly type: "uint8";
+        }, {
+            readonly name: "who";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "income";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "Q";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "L";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "n";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+    }];
+    readonly name: "may";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes4";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "minQuoteAtSeed";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "a";
+        readonly internalType: "struct IFHook.Ask";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "poolId";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "gen";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "action";
+            readonly internalType: "enum IFHook.Action";
+            readonly type: "uint8";
+        }, {
+            readonly name: "who";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "income";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "Q";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "L";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "n";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+    }];
+    readonly name: "onHarvest";
+    readonly outputs: readonly [{
+        readonly name: "amount";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "cut";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "key";
+        readonly internalType: "struct FPoolKey";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "quote";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "bases";
+            readonly internalType: "address[]";
+            readonly type: "address[]";
+        }, {
+            readonly name: "weights";
+            readonly internalType: "uint256[]";
+            readonly type: "uint256[]";
+        }, {
+            readonly name: "phi";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "kind";
+            readonly internalType: "enum Kind";
+            readonly type: "uint8";
+        }, {
+            readonly name: "hook";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "creator";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "salt";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }];
+    }];
+    readonly name: "onInitialize";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint8";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "a";
+        readonly internalType: "struct IFHook.Ask";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "poolId";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "gen";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "action";
+            readonly internalType: "enum IFHook.Action";
+            readonly type: "uint8";
+        }, {
+            readonly name: "who";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "income";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "Q";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "L";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "n";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+    }];
+    readonly name: "onRegenerate";
+    readonly outputs: readonly [{
+        readonly name: "t";
+        readonly internalType: "struct IFHook.Terms";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "payee";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "toPayee";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "protocolCut";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "burn";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "pendingAuthority";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "next";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "proposeAuthority";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_harvestCut";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "setHarvestCut";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_keepQuote";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_minQuoteAtSeed";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "setPolicy";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    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: "AuthorityProposed";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "prev";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "next";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }];
+    readonly name: "AuthoritySet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "harvestCut";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+    readonly name: "HarvestCutSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "keepQuote";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "minQuoteAtSeed";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+    readonly name: "PolicySet";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "BadRate";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotAuthority";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotCollector";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotManager";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "QuoteTooThin";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "Refused";
+}];
 import type { LogswapClient } from "./client.js";
+/** The optional questions a hook declared at birth (decisions 044), as bits of `Pool.asks`. */
+export declare const ASK_SWAP = 1;
+export declare const ASK_MINT = 2;
 /** Everything scalar about a basket pool, in one round trip's worth of reads. */
 export interface FPoolState {
     /** The pool's id — the hash of its key. There is no per-pool address. */
@@ -57,32 +539,25 @@ export interface FPoolState {
     compositeX: bigint;
     /** Σ = ∫ Σ_j w_j (dx_j)², accrued even though the fee is fixed — the kernel stays calculable. */
     bigSigma: bigint;
-    /** 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 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.
+     * The pool's policy (decisions 041, 044): the contract the key names, holding the pool's roles
+     * and answering every question the manager does not decide itself. Read its roles with
+     * {@link getFPoolRoles}; one of the deployment's four ({@link fPoolHookFor}) on every protocol pool.
      */
-    operator: Address;
-    /** The proposed next operator, until it accepts — zero when nothing is pending. */
-    pendingOperator: Address;
+    hook: Address;
+    /** Whether the hook asked to be consulted on swaps ({@link ASK_SWAP}) and mints ({@link ASK_MINT}) — the desk's hook does, no other. */
+    asks: number;
     /** The sponsor's own label for this pool, mutable and never identity. "" when unnamed. */
     name: string;
-    /** Only `allowed` accounts may receive minted shares. */
-    gateMint: boolean;
-    /** Only `allowed` takers may swap. */
-    gateSwap: boolean;
     /** The block of the last harvest / composition action: no swap runs in it. */
     restructureBlock: number;
     /** The rung — see {@link FPoolKind}. */
     kind: FPoolKind;
-    /** False before the first seed — and between a dissolve and the next one (decisions 032). */
+    /** False before the first seed — and between a retire and the next one (decisions 032). */
     seeded: boolean;
     /**
-     * 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
+     * The live GENERATION (decisions 032). 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.
      */
     gen: number;
@@ -93,14 +568,14 @@ 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>;
 /**
- * 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.
+ * The kind of pool (decisions 036, 038, 044) — what the manager promises structurally, whatever
+ * the pool's hook answers. `public`: the protocol's own pool — its hook requires the collector as
+ * creator; no gate, no operator. `private`, the desk: the one kind whose hook may gate swaps and
+ * mints, with an operator that reshapes the legs between generations. `pol`, a treasury's pool
+ * or a basket: composition and access fixed at birth. `pad`, a launch: a POL whose harvest is
+ * income only whatever its hook says 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. Every rate, role and gate is the hook's.
  */
 export type FPoolKind = "public" | "private" | "pol" | "pad";
 /** The key's enum values. */
@@ -111,18 +586,50 @@ export declare const F_KIND: {
     readonly pad: 3;
 };
 export declare function fPoolKindOf(n: number | bigint): FPoolKind;
+/** The deployment's hook for a kind (decisions 044): what a key of that kind names. */
+export declare function fPoolHookFor(c: LogswapClient, kind: FPoolKind): Address;
+/** The hook a pool named in its key — one read; {@link getFPool} carries it too. */
+export declare function fPoolHookOf(c: LogswapClient, poolId: Hex): Promise<Address>;
+/**
+ * A pool's roles, as its HOOK holds them (decisions 044). `creator` is immutable identity —
+ * who was born holding the pool; `authority` is the cold key that owns it now, the creator until
+ * a two-step handover; on the desk's kind the `operator` runs it (zero = the authority itself,
+ * {@link fPoolOperatorOf}) and the two gates and the list are its. Every other kind has no
+ * operator and no gate: those fields read zero / false.
+ */
+export interface FPoolRoles {
+    hook: Address;
+    creator: Address;
+    authority: Address;
+    /** The proposed next authority, until it accepts — zero when nothing is pending (decisions 020). */
+    pendingAuthority: Address;
+    operator: Address;
+    pendingOperator: Address;
+    gateMint: boolean;
+    gateSwap: boolean;
+    /** The hook's own ceiling on a harvest now — the manager's `harvestable` narrowed by the hook's rule. */
+    maxHarvest: bigint;
+}
+/** Read a pool's roles from its hook. `state` saves the `getPool` round trip when already in hand. */
+export declare function getFPoolRoles(c: LogswapClient, poolId: Hex, state?: Pick<FPoolState, "hook" | "kind">): Promise<FPoolRoles>;
 /** 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;
-    /** n = 1 with a private authority is the launch shape (f-pool §6.5). */
+    /** The pad is the launch shape, by the kind (decisions 036). */
     legs: number;
     /** True when the pool holds no quote: an all-base resting ask. base→quote is the one blocked path. */
     atFloor: boolean;
-    /** Fee income earned per unit L so far, `θ₀ − θ` with the lever's displacement backed out. */
-    feePerL: bigint;
-    /** The model-free LP edge, `F − ½Σ`. Exact at any n: V is separable in the logs. */
-    edgePerL: bigint;
+    /**
+     * This generation's fee income still in the pool, quote: `L·(θ₀ − θ)` (F version 14 —
+     * `feePerL` before, per unit L). A harvest of capital moves the reference floor, so this counts
+     * 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 hook may allow less — {@link FPoolRoles.maxHarvest}. */
+    harvestable: bigint;
+    /** The dead shares' banked dividend — a pad's pot, the creator's income until a rung is climbed (decisions 041). */
+    pot: bigint;
 }
 export declare function describeFPool(c: LogswapClient, s: FPoolState): Promise<FPoolDescription>;
 /** `p_j = e^{x_j}`, lossy the way any float conversion is. Compare in log space when it matters. */
@@ -352,7 +859,14 @@ export interface FPoolCreateArgs {
     phi: bigint;
     /** The rung (decisions 036) — see {@link FPoolKind}. In the key: the pool's identity, never changed after. */
     kind: FPoolKind;
-    authority: Address;
+    /**
+     * The pool's policy (decisions 041, 044): the contract the key names, approved by the protocol
+     * for the kind. Defaults to the deployment's hook for `kind` ({@link fPoolHookFor}) — the one
+     * every protocol pool names.
+     */
+    hook?: Address;
+    /** Who is born holding the pool: immutable identity, the pool's first authority (the hook records it). */
+    creator: Address;
     /**
      * The differentiator, and nothing else. Identity is the key's hash, so one sponsor cannot run
      * two pools of the same shape without varying it — the second `initialize` would land on the
@@ -370,6 +884,17 @@ export declare function sortFPoolLegs<T>(bases: Address[], ...companions: T[][])
     bases: Address[];
     companions: T[][];
 };
+/** The key as the manager hashes it: legs sorted, the kind's hook filled in when none is named. */
+export declare function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): {
+    quote: `0x${string}`;
+    bases: `0x${string}`[];
+    weights: bigint[];
+    phi: bigint;
+    kind: 0 | 1 | 3 | 2;
+    hook: `0x${string}`;
+    creator: `0x${string}`;
+    salt: `0x${string}`;
+};
 /** 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. */
@@ -401,22 +926,22 @@ export declare function fPoolSeed(c: LogswapClient, a: {
     weights: bigint[];
 })): Promise<`0x${string}`>;
 /**
- * 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.
+ * Retire the live generation (decisions 025, 032, 035) — the raw entry (`dissolve` before F
+ * version 14). Allowed only at an empty bid, Q ≤ L/1e9, on every pool: the market took it, or the
+ * operator 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, hook, roles, gates and lists.
  */
-export declare function fPoolDissolve(c: LogswapClient, a: {
+export declare function fPoolRetireRaw(c: LogswapClient, a: {
     poolId: Hex;
     account: Address;
 }): Promise<`0x${string}`>;
 /**
- * Retire the live generation as ONE transaction: the harvests that empty the bid
+ * 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 `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.
+ * 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.
  */
 export declare function fPoolRetire(c: LogswapClient, a: {
     poolId: Hex;
@@ -424,25 +949,37 @@ export declare function fPoolRetire(c: LogswapClient, a: {
 }): 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).
+ * `retire` (decisions 035: 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 hook keeps a floor on the bid
+ * (`PolHook.keepQuote`, decisions 044): a `retire` under that hook waits for the market.
  */
 export declare function fPoolEmptyingHarvests(c: LogswapClient, poolId: Hex): Promise<bigint[]>;
+/**
+ * Release the dead shares' pot under the hook's terms (decisions 041, 044) — a pad's graduation.
+ * The manager harvests the generation's income first (the pot then holds everything the dead
+ * shares earned), asks the hook, 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 hook refuses under its rung's
+ * threshold (`PadHook.NotGraduated`). Whoever runs the pool.
+ */
+export declare function fPoolRegenerate(c: LogswapClient, a: {
+    poolId: Hex;
+    to?: Address;
+    account: Address;
+}): Promise<`0x${string}`>;
 /**
  * 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
+ * dividend to every share, {@link fPoolEmptyingHarvests} — `retire` 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`.
+ * authority's. The hook, its roles, gates, allowlist and the name 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;
@@ -506,6 +1043,16 @@ export declare function fPoolLaunchCalls(poolId: Hex, a: FPoolLaunchArgs & ({
 } | {
     x0: bigint[];
 })): Hex[];
+/**
+ * The desk's opening posture, on its hook (decisions 044): gated minting, the creator listed. No
+ * appointment: the authority is the operator until one is appointed (decisions 037). Two writes
+ * to `PrivateHook`; the launch batch cannot carry them (they are not manager calls).
+ */
+export declare function fPoolDeskOpening(c: LogswapClient, a: {
+    poolId: Hex;
+    account: Address;
+    hook?: Address;
+}): Promise<Hash[]>;
 /**
  * Create a pool as ONE transaction: `initialize`, `seed`, the seed lock, the opening buy, the
  * name, the private-pool gates — the manager's `multicall`, the creator as sender throughout.
@@ -532,36 +1079,47 @@ export declare function fPoolLaunch(c: LogswapClient, a: FPoolLaunchArgs & ({
     poolId: Hex;
 }>;
 /**
- * Propose the next authority — step one of two (contracts `2aa6b7b`, decisions 020). Nothing moves
+ * Propose the next authority — step one of two (decisions 020), on the pool's hook. Nothing moves
  * until `next` accepts; proposing again (the zero address included) cancels a pending proposal.
- * Indexed on-chain via AuthorityProposed.
+ * Indexed on-chain via the hook's AuthorityProposed.
  */
 export declare function fPoolProposeAuthority(c: LogswapClient, a: {
     poolId: Hex;
     next: Address;
     account: Address;
+    hook?: Address;
 }): Promise<`0x${string}`>;
-/** Accept a pending proposal — step two; only the proposed address can. Indexed via AuthoritySet. */
+/**
+ * Accept a pending proposal — step two; only the proposed address can. Indexed via the hook's
+ * AuthoritySet. On the desk's hook this clears the operator (pending and accepted) and voids the
+ * seller's list (decisions 040, 044).
+ */
 export declare function fPoolAcceptAuthority(c: LogswapClient, a: {
     poolId: Hex;
     account: Address;
+    hook?: Address;
 }): Promise<`0x${string}`>;
-/** Turn the mint / swap gates on or off (authority). `burn` is never gated. */
+/** Turn the mint / swap gates on or off (the authority, on the desk's hook). `burn` is never gated. */
 export declare function fPoolSetGates(c: LogswapClient, a: {
     poolId: Hex;
     gateMint: boolean;
     gateSwap: boolean;
     account: Address;
+    hook?: Address;
 }): Promise<`0x${string}`>;
-/** Add to or remove from the pool's list, in one call (authority). */
+/**
+ * Add to or remove from the pool's list, in one call (the authority, on the desk's hook). The list
+ * is keyed by the authority that granted it: a handover starts the buyer with an empty one.
+ */
 export declare function fPoolSetAllowed(c: LogswapClient, a: {
     poolId: Hex;
     who: readonly Address[];
     allowed: boolean;
     account: Address;
+    hook?: Address;
 }): Promise<`0x${string}`>;
-/** Whether `who` is on the pool's list (consulted only while a gate is on). */
-export declare function fPoolIsAllowed(c: LogswapClient, poolId: Hex, who: Address): Promise<boolean>;
+/** Whether `who` is on the pool's list under its current authority (consulted only while a gate is on). */
+export declare function fPoolIsAllowed(c: LogswapClient, poolId: Hex, who: Address, hook?: Address): Promise<boolean>;
 /** Label the pool — the sponsor's own words, mutable, never identity. At most 31 bytes of UTF-8. */
 export declare function fPoolSetName(c: LogswapClient, a: {
     poolId: Hex;
@@ -580,25 +1138,27 @@ export declare function fPoolSetSponsorName(c: LogswapClient, a: {
 /** The protocol's attestation for an address, or "" when unattested — which most addresses are. */
 export declare function fPoolSponsorName(c: LogswapClient, who: Address): Promise<string>;
 /** 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;
+export declare function fPoolOperatorOf(s: Pick<FPoolRoles, "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
+ * Propose the operator (the authority, on the desk's hook) — the hot key that runs the pool:
+ * `harvest`, `retire`, `regenerate`, `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;
+    hook?: Address;
 }): Promise<`0x${string}`>;
 /** The proposed operator takes the role. */
 export declare function fPoolAcceptOperator(c: LogswapClient, a: {
     poolId: Hex;
     account: Address;
+    hook?: Address;
 }): Promise<`0x${string}`>;
 /**
  * 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
+ * unseeded — between a retire 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
@@ -629,7 +1189,10 @@ export interface DiscoveredFPool {
     weights: bigint[];
     phi: bigint;
     kind: FPoolKind;
-    authority: Address;
+    /** The pool's policy — the hook the key names (decisions 041, 044). */
+    hook: Address;
+    /** Who was born holding the pool (immutable). The LIVE authority is the hook's — {@link getFPoolRoles}. */
+    creator: Address;
     /** The block the pool was initialized in — its age, for annualising realized income. */
     block: bigint;
     /** Whether `seed` has run; an unseeded pool has no floor and no float, so nothing to show. */
@@ -653,6 +1216,51 @@ export declare function discoverFPools(c: LogswapClient, opts?: {
     fromBlock?: bigint;
     toBlock?: bigint;
 }): Promise<DiscoveredFPool[]>;
+/** A pool an authority controls, with what the policy page shows of it. */
+export interface FPoolControlled {
+    pool: DiscoveredFPool;
+    roles: FPoolRoles;
+    state: FPoolState;
+    /** The hook's numbers for this pool's kind — a pad's rung and threshold, a POL's floors, the desk's list flags. */
+    policy: FPoolPolicy;
+}
+/** What a pool's hook says about it, by kind: the terms a buyer reads before entering. */
+export type FPoolPolicy = {
+    kind: "pad";
+    harvestCut: bigint;
+    rung: number;
+    threshold: bigint;
+    pot: bigint;
+    creatorShare: bigint;
+    protocolShare: bigint;
+    burnPerRung: bigint;
+} | {
+    kind: "pol";
+    harvestCut: bigint;
+    keepQuote: bigint;
+    minQuoteAtSeed: bigint;
+} | {
+    kind: "public";
+    harvestCut: bigint;
+    curated: boolean;
+} | {
+    kind: "private";
+    harvestCut: bigint;
+    gateMint: boolean;
+    gateSwap: boolean;
+    operator: Address;
+};
+/** The hook's terms for one pool, by its kind. */
+export declare function getFPoolPolicy(c: LogswapClient, s: Pick<FPoolState, "poolId" | "hook" | "kind" | "gen">, roles?: FPoolRoles): Promise<FPoolPolicy>;
+/**
+ * Every F pool `who` is the AUTHORITY of, across the four hooks — the policy page's list. Pools
+ * `who` created and handed over are not here (the buyer's page shows them); pools handed TO
+ * `who` are. `pools` may be passed (from the indexer, say) to skip the log scan.
+ */
+export declare function fPoolsControlledBy(c: LogswapClient, who: Address, opts?: {
+    pools?: DiscoveredFPool[];
+    fromBlock?: bigint;
+}): Promise<FPoolControlled[]>;
 /**
  * Every holder of a pool's shares, from the ERC-6909 Transfer stream — the id is an indexed
  * topic, so one filtered log query aggregates the whole ledger. The 0xdead entry is the