@logswap/sdk 0.5.54 → 0.5.56

package/dist/fpool.d.ts

@@ -4,7 +4,7 @@
  * The other primitive. `CPoolManager` gives every position its own floor on a tick ladder;
  * `FPoolManager` gives every share the SAME floor and deletes the ladder, the accumulators and the
  * per-position accounting with it. Reading the two side by side is the fastest way to understand
- * either (logswap-docs:docs/multi/f-pool.md).
+ * either.
  *
  * **A pool is an ID, not an address.** Both primitives are singletons now, so neither has a
  * per-pool deployment — but they are addressed differently and for a reason. The C manager rides
@@ -15,7 +15,7 @@
  * **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 POLICY (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
+ * and release) — 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 policy's, not the manager's** (F version 15). The manager holds no
@@ -32,9 +32,9 @@
 import { type Address, type Hash, type Hex } from "viem";
 import { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 /**
- * One contract, one ABI (decisions 039, F version 12): `harvest`, `claim`, `retire`, `regenerate`,
+ * One contract, one ABI (F version 12): `harvest`, `claim`, `retire`, `regenerate`,
  * `setLegs`, the names, the fee parameters are `FPoolManager`'s own code. The roles left it for
- * the policies in F version 15 (decisions 044): {@link fPolicyBaseAbi} is what every policy shares,
+ * the policies in F version 15: {@link fPolicyBaseAbi} is what every policy shares,
  * {@link privatePolicyAbi} the desk's, {@link padPolicyAbi} / {@link polPolicyAbi} / {@link publicPolicyAbi}
  * the kinds'.
  */
@@ -676,7 +676,7 @@ export declare const fPolicyBaseAbi: readonly [{
     readonly name: "Refused";
 }];
 import type { LogswapClient } from "./client.js";
-/** The optional questions a policy declared at birth (decisions 044), as bits of `Pool.asks`. */
+/** The optional questions a policy declared at birth, 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. */
@@ -704,35 +704,35 @@ export interface FPoolState {
     /** Σ = ∫ Σ_j w_j (dx_j)², accrued even though the fee is fixed — the kernel stays calculable. */
     bigSigma: bigint;
     /**
-     * The pool's policy (decisions 041, 044): the contract the key names, holding the pool's roles
+     * The pool's policy: 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 fPoolPolicyFor}) on every protocol pool.
      */
     policy: Address;
     /** Whether the policy asked to be consulted on swaps ({@link ASK_SWAP}) and mints ({@link ASK_MINT}) — the desk's policy does, no other. */
     asks: number;
-    /** The sponsor's own label for this pool — the policy's word (decisions 049), mutable and never identity. "" when unnamed. */
+    /** The sponsor's own label for this pool — the policy's word, mutable and never identity. "" when unnamed. */
     name: string;
     /** The block of the last harvest / composition action: no swap runs in it. */
     restructureBlock: number;
-    /** What the pool is — its POLICY's self-description (decisions 049); see {@link FPoolKind}. */
+    /** What the pool is — its POLICY's self-description; see {@link FPoolKind}. */
     kind: FPoolKind;
-    /** False before the first seed — and between a retire and the next one (decisions 032). */
+    /** False before the first seed — and between a retire and the next one. */
     seeded: boolean;
     /**
-     * The live GENERATION (decisions 032). Every retire freezes one into a bundle its shares
+     * The live GENERATION. Every retire freezes one into a bundle its shares
      * redeem ({@link fPoolRedeem}) and opens the next; the share id carries it
      * ({@link fPoolShareId}), so generations `0 … gen-1` are retired claims and `gen` is the pool.
      */
     gen: number;
     totalSupply: bigint;
-    /** What the pool holds of each base — the STATE since decisions 026; the mark `x` is derived from it. */
+    /** What the pool holds of each base — the STATE; the mark `x` is derived from it. */
     reserves: bigint[];
 }
 /** 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 — the POLICY's self-description (decisions 049: the manager knows no kind; the
+ * The kind of pool — the POLICY's self-description (the manager knows no kind; the
  * policy the key names is the kind, and what it promises is its code). `public`: the protocol's
  * own pool — its policy requires the collector as creator; no gate, no operator. `private`, the
  * desk: the one whose policy may gate swaps and mints, with an operator that reshapes the legs
@@ -746,18 +746,18 @@ export type FPoolKind = "public" | "private" | "pol" | "pad";
 export declare const SEED_TO_DEAD = 4;
 /**
  * What a policy IS — its `kind()` tag, read once per policy address and cached for the client's
- * chain: a pool's kind is its policy's word (decisions 049), never the manager's. An unknown tag
+ * chain: a pool's kind is its policy's word, never the manager's. An unknown tag
  * (a policy that is not one of the protocol's four shapes) throws; the app has no screen for it.
  */
 export declare function fPoolKindOfPolicy(c: LogswapClient, policy: Address): Promise<FPoolKind>;
-/** The pool's label, as its policy holds it (decisions 049). "" when unnamed. */
+/** The pool's label, as its policy holds it. "" when unnamed. */
 export declare function fPoolNameOf(c: LogswapClient, poolId: Hex, policy?: Address): Promise<string>;
-/** The deployment's policy for a kind (decisions 044, 049): the protocol's policy that IS that kind. */
+/** The deployment's policy for a kind: the protocol's policy that IS that kind. */
 export declare function fPoolPolicyFor(c: LogswapClient, kind: FPoolKind): Address;
 /** The policy a pool named in its key — one read; {@link getFPool} carries it too. */
 export declare function fPoolPolicyOf(c: LogswapClient, poolId: Hex): Promise<Address>;
 /**
- * A pool's roles, as its POLICY holds them (decisions 044). `creator` is immutable identity —
+ * A pool's roles, as its POLICY holds them. `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
@@ -767,7 +767,7 @@ export interface FPoolRoles {
     policy: Address;
     creator: Address;
     authority: Address;
-    /** The proposed next authority, until it accepts — zero when nothing is pending (decisions 020). */
+    /** The proposed next authority, until it accepts — zero when nothing is pending. */
     pendingAuthority: Address;
     operator: Address;
     pendingOperator: Address;
@@ -782,7 +782,7 @@ export declare function getFPoolRoles(c: LogswapClient, poolId: Hex, state?: Pic
 export type FPoolShape = "launch" | "basket";
 export interface FPoolDescription {
     shape: FPoolShape;
-    /** The pad is the launch shape, by the kind (decisions 036). */
+    /** The pad is the launch shape, by the kind. */
     legs: number;
     /** True when the pool holds no quote: an all-base resting ask. base→quote is the one blocked path. */
     atFloor: boolean;
@@ -794,7 +794,7 @@ export interface FPoolDescription {
     unharvested: bigint;
     /** The most a harvest may take now by the KIND's promise: the bid, and on a pad the income. The policy may allow less — {@link FPoolRoles.maxHarvest}. */
     harvestable: bigint;
-    /** The dead shares' banked dividend — a pad's pot, the creator's income until a rung is climbed (decisions 041). */
+    /** The dead shares' banked dividend — a pad's pot, the creator's income until a rung is climbed. */
     pot: bigint;
 }
 export declare function describeFPool(c: LogswapClient, s: FPoolState): Promise<FPoolDescription>;
@@ -841,7 +841,7 @@ a: {
 }): Promise<`0x${string}`>;
 /**
  * Burn shares for the pro-rata slice of every reserve. Available at any Q, and after dissolution.
- * By owner since contracts `c782811` (decisions 019): the account burns its own shares; an
+ * By owner: the account burns its own shares; an
  * operator may pass another owner's address, as on the C manager's `burnById`.
  */
 export declare function fPoolBurn(c: LogswapClient, 
@@ -877,7 +877,7 @@ export declare function fPoolPreviewZapIn(c: LogswapClient, poolId: Hex, dL: big
  *
  * The imbalanced part goes through the pool's own curve before anything is minted. That is not a
  * penalty: minting against a quote-only deposit would be a zero-slippage, zero-fee swap at stale
- * spot, paid for by the existing LPs — 27.4% in f-pool §6's worked example. Routing it through
+ * spot, paid for by the existing LPs. Routing it through
  * the curve deletes the subsidy and hands the fee and impact to the incumbents instead.
  */
 export declare function fPoolZapIn(c: LogswapClient, a: {
@@ -919,7 +919,7 @@ export declare function fPoolPreviewZapOut(c: LogswapClient, a: {
     account: Address;
 }): Promise<bigint>;
 /**
- * Roll a retired generation's bundle into the pool's live one (decisions 025, 032), on the
+ * Roll a retired generation's bundle into the pool's live one, 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
@@ -953,11 +953,11 @@ export declare function fPoolPreviewRollIn(c: LogswapClient, poolId: Hex, gen: b
     quoteExcess: bigint;
 }>;
 /**
- * Remove quote, lifting θ — price-neutral, no base moves, and since decisions 028 a DIVIDEND to
+ * Remove quote, lifting θ — price-neutral, no base moves, and 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. On a pad
- * the lift stops at the seed floor θ₀ (income only); nothing else bounds it (decisions 035) — an
+ * the lift stops at the seed floor θ₀ (income only); nothing else bounds it — an
  * unlocked pool's authority may take Q to zero.
  */
 export declare function fPoolHarvest(c: LogswapClient, a: {
@@ -967,9 +967,9 @@ export declare function fPoolHarvest(c: LogswapClient, a: {
     account: Address;
 }): Promise<`0x${string}`>;
 /**
- * Pull one's settled dividend (decisions 028) on a generation's shares without moving them;
+ * Pull one's settled dividend 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).
+ * stay claimable under its own id.
  */
 export declare function fPoolClaim(c: LogswapClient, a: {
     poolId: Hex;
@@ -977,7 +977,7 @@ export declare function fPoolClaim(c: LogswapClient, a: {
     to?: Address;
     account: Address;
 }): 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). */
+/** A holder's dividend as of now on generation `gen` (the live one by default) — banked plus pending on the current balance. */
 export declare function fPoolDividendOf(c: LogswapClient, poolId: Hex, holder: Address, gen?: bigint | number): Promise<bigint>;
 /** 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>;
@@ -987,7 +987,7 @@ export declare function isRouterOperatorForFPool(c: LogswapClient, owner: Addres
 /** 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 generation `gen` of a pool's shares (decisions 032): bit 255 set (the
+ * The ERC-6909 id carrying generation `gen` of a pool's shares: 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.
  */
@@ -1000,7 +1000,7 @@ export declare function fPoolGen(c: LogswapClient, poolId: Hex): Promise<number>
 export declare function fPoolClaimId(token: Address): 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. */
+/** A retired generation's bundle: 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;
@@ -1014,10 +1014,10 @@ export interface FPoolClaimRow {
     quote: bigint;
     dividend: bigint;
 }
-/** A holder's claims on a pool's retired generations — one row per generation still held (decisions 032). */
+/** A holder's claims on a pool's retired generations — one row per generation still held. */
 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
+ * Redeem `shares` of a RETIRED generation: 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.
  */
@@ -1065,7 +1065,7 @@ export interface FPoolCreateArgs {
      */
     kind: FPoolKind;
     /**
-     * The pool's policy (decisions 041, 044, 049): the contract the key names, approved by the
+     * The pool's policy: the contract the key names, approved by the
      * registry, and the pool's kind. Defaults to the deployment's policy for `kind`
      * ({@link fPoolPolicyFor}) — the one every protocol pool names.
      */
@@ -1104,8 +1104,8 @@ export declare function fPoolInitialize(c: LogswapClient, a: FPoolCreateArgs): P
 /** The pool id is the key's hash — pure, so it can be read before or after creation. */
 export declare function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): Promise<Hex>;
 /**
- * The reserve a leg holds at a mark: `R = Lj·e^{−x}`, WAD math. The seed names RESERVES since
- * decisions 029 — the sponsor states holdings and the price follows, `p = Lj / R` — so this is
+ * The reserve a leg holds at a mark: `R = Lj·e^{−x}`, WAD math. The seed names RESERVES —
+ * the sponsor states holdings and the price follows, `p = Lj / R` — so this is
  * the one conversion from a price to what the pool will hold, done here, on the way in. Float
  * precision (~1e-16 relative) is what a seed needs: any reserve is a legal seed, and the mark
  * the pool derives from it is the one the sponsor meant to within that.
@@ -1130,7 +1130,7 @@ export declare function fPoolSeed(c: LogswapClient, a: {
     weights: bigint[];
 })): Promise<`0x${string}`>;
 /**
- * Retire the live generation (decisions 025, 032, 035) — the raw entry (`dissolve` before F
+ * Retire the live generation — 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})
@@ -1153,15 +1153,15 @@ 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
- * `retire` (decisions 035: a retire needs an empty bid on every pool). Since F version 14 one
+ * `retire` (a retire needs an empty bid on every pool). Since F version 14 one
  * `harvest(Q)` does it: the protocol's cut leaves the pool with the amount (with no collector
  * there is no cut). `[]` when the bid is already empty. Throws on a pad that still bids (its bid
  * empties only as the market sells it down), and when the pool's policy keeps a floor on the bid
- * (`PolPolicy.keepQuote`, decisions 044): a `retire` under that policy waits for the market.
+ * (`PolPolicy.keepQuote`): a `retire` under that policy waits for the market.
  */
 export declare function fPoolEmptyingHarvests(c: LogswapClient, poolId: Hex): Promise<bigint[]>;
 /**
- * Release the dead shares' pot under the policy's terms (decisions 041, 044) — a pad's graduation.
+ * Release the dead shares' pot under the policy's terms — a pad's graduation.
  * The manager harvests the generation's income first (the pot then holds everything the dead
  * shares earned), asks the policy, and applies its answer: a share to the payee it names (the pad's
  * creator — the pool's authority), a cut to the collector, the rest bought in as more of the
@@ -1174,7 +1174,7 @@ export declare function fPoolRegenerate(c: LogswapClient, a: {
     account: Address;
 }): Promise<`0x${string}`>;
 /**
- * The relaunch as ONE transaction (decisions 025, 032, 035, 037): `harvest` the bid out — a
+ * The relaunch as ONE transaction: `harvest` the bid out — a
  * 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
@@ -1191,7 +1191,7 @@ export declare function fPoolRelaunch(c: LogswapClient, a: {
     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 */
+    /** the next generation's composition: one weight per existing leg (0 retires it), then one per new base */
     legs?: {
         weights: bigint[];
         newBases?: Address[];
@@ -1204,7 +1204,7 @@ export declare function fPoolRelaunch(c: LogswapClient, a: {
     x0: bigint[];
     weights: bigint[];
 })): Promise<`0x${string}`>;
-/** Where a pad's seed lives (decisions 036): `seed` mints every share of a pad here itself. */
+/** Where a pad's seed lives: `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 on every pool, the rest to the seeder — or, on a pad, to 0xdead too. */
 export declare const F_MIN_SHARES = 1000n;
@@ -1248,8 +1248,8 @@ export declare function fPoolLaunchCalls(poolId: Hex, a: FPoolLaunchArgs & ({
     x0: bigint[];
 })): Hex[];
 /**
- * The desk's opening posture, on its policy (decisions 044, 048): gated minting, the creator a
- * minter. No appointment: the authority is the operator until one is appointed (decisions 037).
+ * The desk's opening posture, on its policy: gated minting, the creator a
+ * minter. No appointment: the authority is the operator until one is appointed.
  * Two writes to `PrivatePolicy`; the launch batch cannot carry them (they are not manager calls).
  */
 export declare function fPoolDeskOpening(c: LogswapClient, a: {
@@ -1283,7 +1283,7 @@ export declare function fPoolLaunch(c: LogswapClient, a: FPoolLaunchArgs & ({
     poolId: Hex;
 }>;
 /**
- * Propose the next authority — step one of two (decisions 020), on the pool's policy. Nothing moves
+ * Propose the next authority — step one of two, on the pool's policy. Nothing moves
  * until `next` accepts; proposing again (the zero address included) cancels a pending proposal.
  * Indexed on-chain via the policy's AuthorityProposed.
  */
@@ -1296,7 +1296,7 @@ export declare function fPoolProposeAuthority(c: LogswapClient, a: {
 /**
  * Accept a pending proposal — step two; only the proposed address can. Indexed via the policy's
  * AuthoritySet. On the desk's policy this clears the operator (pending and accepted) and voids the
- * seller's list (decisions 040, 044).
+ * seller's list.
  */
 export declare function fPoolAcceptAuthority(c: LogswapClient, a: {
     poolId: Hex;
@@ -1313,7 +1313,7 @@ export declare function fPoolSetGates(c: LogswapClient, a: {
 }): Promise<`0x${string}`>;
 /**
  * Add to or remove from the pool's MINTERS — who may mint, and swap (a zap in is both under one
- * lock) — in one call (the authority, on the desk's policy; decisions 048). The list is keyed by
+ * lock) — in one call (the authority, on the desk's policy). The list is keyed by
  * the authority that granted it: a handover starts the buyer with an empty one. Stamps the
  * block: no swap lands in it (047).
  */
@@ -1324,7 +1324,7 @@ export declare function fPoolSetMinters(c: LogswapClient, a: {
     account: Address;
     policy?: Address;
 }): Promise<`0x${string}`>;
-/** Add to or remove from the pool's TAKERS — who may swap only — in one call (the authority; decisions 048). Stamps the block. */
+/** Add to or remove from the pool's TAKERS — who may swap only — in one call (the authority). Stamps the block. */
 export declare function fPoolSetTakers(c: LogswapClient, a: {
     poolId: Hex;
     who: readonly Address[];
@@ -1338,7 +1338,7 @@ export declare function fPoolIsMinter(c: LogswapClient, poolId: Hex, who: Addres
 export declare function fPoolIsTaker(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean>;
 /** May swap: a minter or a taker (consulted only while the swap gate is on). */
 export declare function fPoolIsAllowed(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean>;
-/** Label the pool — the authority's own words on the pool's POLICY (decisions 049), mutable, never identity. At most 31 bytes of UTF-8. */
+/** Label the pool — the authority's own words on the pool's POLICY, mutable, never identity. At most 31 bytes of UTF-8. */
 export declare function fPoolSetName(c: LogswapClient, a: {
     poolId: Hex;
     name: string;
@@ -1346,7 +1346,7 @@ export declare function fPoolSetName(c: LogswapClient, a: {
     policy?: Address;
 }): Promise<`0x${string}`>;
 /**
- * What the PROTOCOL says an address is — "Keyrock" — on the REGISTRY (decisions 049). Only its
+ * What the PROTOCOL says an address is — "Keyrock" — on the REGISTRY. Only its
  * owner, the LOG authority, may write it, which is what makes it an attestation rather than a
  * claim anyone could make about themselves.
  */
@@ -1359,7 +1359,7 @@ export declare function fPoolSetSponsorName(c: LogswapClient, a: {
 export declare function fPoolSponsorName(c: LogswapClient, who: Address): Promise<string>;
 /** The registry the manager asks at every birth — `addresses.policyRegistry`, else the manager's word; zero on a bare deployment. */
 export declare function fPoolRegistryOf(c: LogswapClient): Promise<Address>;
-/** Who runs the pool (decisions 037): the appointed operator, or the authority until one is. */
+/** Who runs the pool: the appointed operator, or the authority until one is. */
 export declare function fPoolOperatorOf(s: Pick<FPoolRoles, "authority" | "operator">): Address;
 /**
  * Propose the operator (the authority, on the desk's policy) — the hot key that runs the pool:
@@ -1380,7 +1380,7 @@ export declare function fPoolAcceptOperator(c: LogswapClient, a: {
 }): Promise<`0x${string}`>;
 /**
  * The next generation's composition (operator; private pools only; ONLY while the pool is
- * unseeded — between a retire and the seed that prices it, decisions 037). `weights` has one
+ * unseeded — between a retire and the seed that prices it). `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
@@ -1411,7 +1411,7 @@ export interface DiscoveredFPool {
     weights: bigint[];
     phi: bigint;
     kind: FPoolKind;
-    /** The pool's policy AT BIRTH — the contract the key names (decisions 041, 044, 045). The LIVE one is {@link getFPool}'s `policy`: the registry's owner may have moved the pool (046, `PolicyMigrated`). */
+    /** The pool's policy AT BIRTH — the contract the key names. The LIVE one is {@link getFPool}'s `policy`: the registry's owner may have moved the pool (046, `PolicyMigrated`). */
     policy: Address;
     /** Who was born holding the pool (immutable). The LIVE authority is the policy's — {@link getFPoolRoles}. */
     creator: Address;
@@ -1419,7 +1419,7 @@ export interface DiscoveredFPool {
     block: bigint;
     /** Whether `seed` has run; an unseeded pool has no floor and no float, so nothing to show. */
     seeded: boolean;
-    /** The quote the pool was born with. Zero is the launchpad's signature (launchpad.md §3). */
+    /** The quote the pool was born with. Zero is the launchpad's signature. */
     q0: bigint;
     /**
      * The PRODUCT the pool is, by the spec's definition rather than a guess: a LAUNCH is one asset