@logswap/sdk 0.5.36 → 0.5.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.36",
+  "version": "0.5.38",
   "description": "TypeScript SDK for Logswap, the liquidity primitive introducing the logarithmic invariant — typed wrappers over the CPoolManager / FPoolManager / Router / Lens surface.",
   "license": "GPL-2.0-or-later",
   "type": "module",
@@ -26,7 +26,7 @@
     "clean": "rm -rf dist src/generated.ts",
     "test": "vitest run",
     "test:watch": "vitest",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run codegen && npm run build"
   },
   "peerDependencies": {
     "viem": "^2.0.0"

package/src/client.ts

@@ -71,7 +71,14 @@ export const EXPECTED_VERSION = 3n;
  * passes it; when one lands, raise this constant in the same change, which is the discipline
  * `EXPECTED_VERSION` enforces mechanically and this one asks for.
  */
-export const EXPECTED_F_VERSION = 5n;
+// 7 (2026-09-15): the reserves are the state and the marks derived, `lockStrike`, the dividend
+// harvest, the relaunch (`dissolve(poolId, successor)`, `rollIn`), the reserve-named seed, the
+// sponsor facet — decisions 025–031.
+// 8 (2026-09-15): the relaunch is in place (decisions 032) — every share id carries the
+// generation (`fPoolShareId(poolId, gen)`), `dissolve(poolId)`, `redeem`, `claim` / `dividendOf`
+// / `rollIn` / `previewRollIn` take the generation, `Pool.gen` replaces `dissolved` and
+// `successor`. A 7 deployment's share ids do not even resolve with this SDK.
+export const EXPECTED_F_VERSION = 8n;
 
 export async function assertVersion(c: LogswapClient, expected = EXPECTED_VERSION): Promise<void> {
   const { cPoolManagerAbi } = await import("./generated.js");

package/src/fpool.ts

@@ -23,8 +23,17 @@
  * `addresses.router`.
  */
 
-import { toFunctionSelector, type Address, type Hash, type Hex } from "viem";
-import { fPoolManagerAbi, logswapRouterAbi } from "./generated.js";
+import { encodeFunctionData, toFunctionSelector, type Address, type Hash, type Hex } from "viem";
+import { fPoolManagerAbi as fPoolPrimitiveAbi, fPoolSponsorAbi, logswapRouterAbi } from "./generated.js";
+
+/**
+ * The F manager's ABI is the UNION of its two compiled halves (decisions 031): `FPoolManager`
+ * holds the primitive and forwards every other selector from its fallback to `FPoolSponsor` —
+ * the lever, `claim`, `dissolve`, the handover, the gates, the desk, the names — by delegatecall.
+ * One address from outside, so one ABI here; both halves carry the base's events and errors,
+ * and viem tolerates the duplicates.
+ */
+export const fPoolManagerAbi = [...fPoolPrimitiveAbi, ...fPoolSponsorAbi] as const;
 import type { LogswapClient } from "./client.js";
 
 const WAD = 10n ** 18n;
@@ -70,12 +79,22 @@ export interface FPoolState {
   gateSwap: boolean;
   /** The block of the last lever / composition action: no swap runs in it. */
   restructureBlock: number;
-  /** Whether harvest is bounded by θ ≤ θ₀ — income only, never the floor's backing. */
-  feesOnly: boolean;
+  /**
+   * 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;
+  /** False before the first seed — and between a dissolve and the next one (decisions 032). */
   seeded: boolean;
-  dissolved: 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
+   * ({@link fPoolShareId}), so generations `0 … gen-1` are retired claims and `gen` is the pool.
+   */
+  gen: number;
   totalSupply: bigint;
-  /** Base holdings the state implies, `R_j = w_j·L·e^{−x_j}`. */
+  /** What the pool holds of each base — the STATE since decisions 026; the mark `x` is derived from it. */
   reserves: bigint[];
 }
 
@@ -97,9 +116,9 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
     quote: Address;
     phi: bigint;
     authority: Address;
-    feesOnly: boolean;
+    lockStrike: boolean;
     seeded: boolean;
-    dissolved: boolean;
+    gen: number;
     n: number;
     restructureBlock: number;
     gateMint: boolean;
@@ -136,11 +155,9 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
 
   const bases = legs.map((l) => l[0]);
   const weights = legs.map((l) => l[1]);
-  const x = legs.map((l) => l[2]);
-  // the ISOLATION SHADOW, not the derived reserve: what this pool actually holds of the token.
-  // In a singleton the contract's balance backs many pools, so this is the only per-pool figure.
-  const reserves = legs.map((l) => l[3]);
-  const { quote, Q, L, phi, theta0, bigSigma, authority, pendingAuthority, operator, minBuffer, gateMint, gateSwap, restructureBlock, feesOnly, seeded, dissolved } = p;
+  const x = legs.map((l) => l[2]); // derived by the manager: x_j = ln(w_j·L / R_j) (decisions 026)
+  const reserves = legs.map((l) => l[3]); // the state
+  const { quote, Q, L, phi, theta0, bigSigma, authority, pendingAuthority, operator, minBuffer, gateMint, gateSwap, restructureBlock, lockStrike, seeded, gen } = p;
   const totalSupply = p.shares;
 
   return {
@@ -164,9 +181,9 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
     gateMint,
     gateSwap,
     restructureBlock: Number(restructureBlock),
-    feesOnly,
+    lockStrike,
     seeded,
-    dissolved,
+    gen: Number(gen),
     totalSupply,
     reserves,
   };
@@ -355,16 +372,101 @@ export async function fPoolZapOut(
   );
 }
 
+/**
+ * Roll a retired generation's bundle into the pool's live one (decisions 025, 032), on the
+ * router under one lock: redeem `shares` of generation `gen` in place — the legs, the quote and
+ * any unpulled dividend come back — buy through the pool's own curve only what the live
+ * generation's ratio lacks, mint `dL` of it to `to`, and refund the rest in kind. Quote the
+ * bundle does not cover is pulled from the payer, at most `maxQuoteIn`; surplus base is
+ * refunded, never sold. Size `dL` with {@link fPoolPreviewRollIn}. The router must be the
+ * caller's ERC-6909 operator ({@link approveRouterForFPool}).
+ */
+export async function fPoolRollIn(
+  c: LogswapClient,
+  a: {
+    poolId: Hex;
+    /** the retired generation whose shares roll */
+    gen: bigint | number;
+    shares: bigint;
+    dL: bigint;
+    maxQuoteIn?: bigint;
+    minShares?: bigint;
+    to?: Address;
+    account: Address;
+    deadline?: bigint;
+  },
+) {
+  const to = a.to ?? a.account;
+  return writeRouter(
+    c,
+    "rollIn",
+    [a.poolId, BigInt(a.gen), a.shares, a.dL, a.maxQuoteIn ?? 0n, a.minShares ?? 0n, to, a.deadline ?? defaultDeadline()],
+    a.account,
+  );
+}
+
+/**
+ * The roll `holder`'s `shares` of retired generation `gen` fund into the live one WITHOUT a
+ * trade: the largest `dL` the bundle's base covers on every leg, and the quote the bundle is
+ * short of (pass it as `maxQuoteIn`) or over (refunded — the up direction's distribution) at
+ * that `dL`. A leg the live generation admitted since makes `dL` zero: such a roll must buy, so
+ * size it below with `previewZapIn` in mind. Zero for the live generation, or before the next
+ * seed.
+ */
+export async function fPoolPreviewRollIn(
+  c: LogswapClient,
+  poolId: Hex,
+  gen: bigint | number,
+  holder: Address,
+  shares: bigint,
+): Promise<{ dL: bigint; quoteShort: bigint; quoteExcess: bigint }> {
+  const { logswapLensAbi } = await import("./generated.js");
+  const [dL, quoteShort, quoteExcess] = (await c.public.readContract({
+    address: c.addresses.lens,
+    abi: logswapLensAbi,
+    functionName: "previewRollIn",
+    args: [poolId, BigInt(gen), holder, shares],
+  } as never)) as readonly [bigint, bigint, bigint];
+  return { dL, quoteShort, quoteExcess };
+}
+
 // ─── the floor lever (authority only) ─────────────────────────────────────────
 
 /**
- * Remove quote, lifting θ — price-neutral, pro-rata, no base moves. Under `feesOnly` the lift
- * stops at θ₀, so the authority extracts income and never the proceeds backing the floor.
+ * 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).
  */
 export async function fPoolHarvest(c: LogswapClient, a: { poolId: Hex; amount: bigint; to?: Address; account: Address }) {
   return writeFPool(c, a.poolId, "harvest", [a.amount, a.to ?? a.account], a.account);
 }
 
+/**
+ * Pull one's settled dividend (decisions 028) on a generation's shares without moving them;
+ * anyone with shares. `gen` defaults to the live generation; a retired generation's harvests
+ * stay claimable under its own id (decisions 032).
+ */
+export async function fPoolClaim(c: LogswapClient, a: { poolId: Hex; gen?: bigint | number; to?: Address; account: Address }) {
+  const gen = a.gen ?? (await fPoolGen(c, a.poolId));
+  return writeFPool(c, a.poolId, "claim", [BigInt(gen), a.to ?? a.account], a.account);
+}
+
+/** 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 async function fPoolDividendOf(c: LogswapClient, poolId: Hex, holder: Address, gen?: bigint | number): Promise<bigint> {
+  const g = gen ?? (await fPoolGen(c, poolId));
+  return c.public.readContract({
+    address: c.addresses.fPoolManager!,
+    abi: fPoolManagerAbi,
+    functionName: "dividendOf",
+    args: [poolId, BigInt(g), holder],
+  } as never) as 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 const LEVER_FLOOR = 223143551314209755n;
+
 /** Commit quote, deepening θ — the other sign of `harvest`, the same word as the C floor edit (decisions 011). The mark does not move: governance may write θ, never x. */
 export async function fPoolDeepen(c: LogswapClient, a: { poolId: Hex; amount: bigint; account: Address }) {
   return writeFPool(c, a.poolId, "deepen", [a.amount], a.account);
@@ -396,6 +498,19 @@ async function writeFPool(c: LogswapClient, poolId: Hex, functionName: string, a
   return wallet.writeContract(request as never);
 }
 
+/** A manager write that is NOT keyed by a poolId — `multicall`. */
+async function writeFPool0(c: LogswapClient, functionName: string, args: unknown[], account: Address) {
+  const wallet = requireWallet(c);
+  const { request } = await c.public.simulateContract({
+    address: c.addresses.fPoolManager!,
+    abi: fPoolManagerAbi,
+    functionName,
+    args,
+    account,
+  } as never);
+  return wallet.writeContract(request as never);
+}
+
 async function writeRouter(
   c: LogswapClient,
   functionName: string,
@@ -494,9 +609,29 @@ export async function approveRouterForFPool(c: LogswapClient, account: Address)
 // than read from the chain: it is pure, and a client that has to call to learn an id cannot build
 // a multicall that uses it.
 
-/** The ERC-6909 id carrying a pool's shares. Bit 255 set. */
-export function fPoolShareId(poolId: Hex): bigint {
-  return (1n << 255n) | (BigInt(poolId) >> 1n);
+/**
+ * The ERC-6909 id carrying generation `gen` of a pool's shares (decisions 032): bit 255 set (the
+ * share flag), the pool id's top 239 bits, the generation in the low 16. Each generation's shares
+ * are their own asset — a retired one is a claim on its bundle, the live one on the pool.
+ */
+export function fPoolShareId(poolId: Hex, gen: bigint | number = 0n): bigint {
+  return (1n << 255n) | ((BigInt(poolId) >> 17n) << 16n) | BigInt(gen);
+}
+
+/** The generation a share id carries — its low 16 bits. */
+export function fPoolGenOfShareId(id: bigint): number {
+  return Number(id & 0xffffn);
+}
+
+/** The pool's live generation, one read. */
+export async function fPoolGen(c: LogswapClient, poolId: Hex): Promise<number> {
+  const p = (await c.public.readContract({
+    address: c.addresses.fPoolManager!,
+    abi: fPoolManagerAbi,
+    functionName: "getPool",
+    args: [poolId],
+  } as never)) as { gen: number };
+  return Number(p.gen);
 }
 
 /** The ERC-6909 id carrying claims on a token. Bit 255 clear, so it can never meet a share id. */
@@ -504,15 +639,65 @@ export function fPoolClaimId(token: Address): bigint {
   return BigInt(token);
 }
 
-export async function fPoolShareBalance(c: LogswapClient, poolId: Hex, owner: Address): Promise<bigint> {
+/** A holder's shares of generation `gen` — the live one by default. */
+export async function fPoolShareBalance(c: LogswapClient, poolId: Hex, owner: Address, gen?: bigint | number): Promise<bigint> {
+  const g = gen ?? (await fPoolGen(c, poolId));
   return c.public.readContract({
     address: c.addresses.fPoolManager!,
     abi: fPoolManagerAbi,
     functionName: "balanceOf",
-    args: [owner, fPoolShareId(poolId)],
+    args: [owner, fPoolShareId(poolId, g)],
   } as never) as Promise<bigint>;
 }
 
+/** A retired generation's bundle (decisions 032): what is left to redeem — supply, quote, base per leg index. */
+export async function fPoolBundleOf(
+  c: LogswapClient,
+  poolId: Hex,
+  gen: bigint | number,
+): Promise<{ supply: bigint; quote: bigint; base: bigint[] }> {
+  const [supply, quote, base] = (await c.public.readContract({
+    address: c.addresses.fPoolManager!,
+    abi: fPoolManagerAbi,
+    functionName: "bundleOf",
+    args: [poolId, BigInt(gen)],
+  } as never)) as readonly [bigint, bigint, readonly bigint[]];
+  return { supply, quote, base: [...base] };
+}
+
+/** A holder's claim on one retired generation, as the lens reports it: what `redeem` pays now. */
+export interface FPoolClaimRow {
+  gen: number;
+  shares: bigint;
+  base: bigint[];
+  quote: bigint;
+  dividend: bigint;
+}
+
+/** A holder's claims on a pool's retired generations — one row per generation still held (decisions 032). */
+export async function fPoolClaimsOf(c: LogswapClient, poolId: Hex, owner: Address): Promise<FPoolClaimRow[]> {
+  const { logswapLensAbi } = await import("./generated.js");
+  const rows = (await c.public.readContract({
+    address: c.addresses.lens,
+    abi: logswapLensAbi,
+    functionName: "fClaimsOf",
+    args: [poolId, owner],
+  } as never)) as readonly { gen: bigint; shares: bigint; base: readonly bigint[]; quote: bigint; dividend: bigint }[];
+  return rows.map((r) => ({ gen: Number(r.gen), shares: r.shares, base: [...r.base], quote: r.quote, dividend: r.dividend }));
+}
+
+/**
+ * Redeem `shares` of a RETIRED generation (decisions 032): its bundle, pro rata — the base per
+ * leg and the quote — plus the owner's settled dividend. Not `burn`: nothing can move a bundle's
+ * ratio, so there is no slippage to bound. The owner, or an operator of theirs.
+ */
+export async function fPoolRedeem(
+  c: LogswapClient,
+  a: { poolId: Hex; gen: bigint | number; shares: bigint; owner?: Address; account: Address },
+) {
+  return writeFPool(c, a.poolId, "redeem", [BigInt(a.gen), a.owner ?? a.account, a.shares], a.account);
+}
+
 export async function fPoolClaimBalance(c: LogswapClient, token: Address, owner: Address): Promise<bigint> {
   return c.public.readContract({
     address: c.addresses.fPoolManager!,
@@ -599,8 +784,8 @@ export interface FPoolCreateArgs {
   weights: bigint[];
   /** Fixed fee, WAD. The base-for-base fee is pinned at 2φ on-chain. */
   phi: bigint;
-  /** true: the authority's harvest stops at the seed strike θ₀ (the launch posture). */
-  feesOnly: boolean;
+  /** true: the strike is locked — harvest stops at θ₀ and the pool cannot be dissolved live (the pad's posture; decisions 027). */
+  lockStrike: boolean;
   authority: Address;
   /**
    * The differentiator, and nothing else. Identity is the key's hash, so one sponsor cannot run
@@ -640,7 +825,7 @@ export async function fPoolInitialize(c: LogswapClient, a: FPoolCreateArgs) {
   const sum = a.weights.reduce((x, y) => x + y, 0n);
   if (sum !== 10n ** 18n) throw new Error(`logswap: weights sum to ${sum}, expected 1e18`);
   const { bases, companions } = sortFPoolLegs(a.bases, a.weights);
-  const key = { quote: a.quote, bases, weights: companions[0]!, phi: a.phi, feesOnly: a.feesOnly, authority: a.authority, salt: a.salt ?? ZERO_SALT };
+  const key = { quote: a.quote, bases, weights: companions[0]!, phi: a.phi, lockStrike: a.lockStrike, authority: a.authority, salt: a.salt ?? ZERO_SALT };
   const wallet = requireWallet(c);
   const { request } = await c.public.simulateContract({
     address: c.addresses.fPoolManager!,
@@ -655,7 +840,7 @@ export async function fPoolInitialize(c: LogswapClient, a: FPoolCreateArgs) {
 /** The pool id is the key's hash — pure, so it can be read before or after creation. */
 export async function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): Promise<Hex> {
   const { bases, companions } = sortFPoolLegs(a.bases, a.weights);
-  const key = { quote: a.quote, bases, weights: companions[0]!, phi: a.phi, feesOnly: a.feesOnly, authority: a.authority, salt: a.salt ?? ZERO_SALT };
+  const key = { quote: a.quote, bases, weights: companions[0]!, phi: a.phi, lockStrike: a.lockStrike, authority: a.authority, salt: a.salt ?? ZERO_SALT };
   return c.public.readContract({
     address: c.addresses.fPoolManager!,
     abi: fPoolManagerAbi,
@@ -665,22 +850,76 @@ export async function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "acco
 }
 
 /**
- * Arm the pool: deposit the full basket at marks `x0` plus `Q0` of quote. Authority-only on-chain
- * (an open seed lets anyone front-run the creator for the strike). `x0` must align with the
- * SORTED bases — use {@link sortFPoolLegs} on (bases, weights, x0) together when building forms.
+ * 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 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.
+ */
+export function fPoolReserveAt(Lj: bigint, x: bigint): bigint {
+  const e = Math.exp(-Number(x) / 1e18);
+  return (Lj * BigInt(Math.round(e * 1e18))) / 10n ** 18n;
+}
+
+/**
+ * Arm the pool: deposit `r0[j]` of each base plus `Q0` of quote against exposure `L0`. Pass either
+ * the reserves outright (`r0`) or the marks the pool should open at (`x0`, converted here with
+ * {@link fPoolReserveAt} against the key's weights). Authority-only on-chain (an open seed lets
+ * anyone front-run the creator for the strike). Arrays align with the SORTED bases — use
+ * {@link sortFPoolLegs} on (bases, weights, x0) together when building forms.
  */
 export async function fPoolSeed(
   c: LogswapClient,
-  a: { poolId: Hex; L0: bigint; x0: bigint[]; Q0: bigint; account: Address },
+  a: { poolId: Hex; L0: bigint; Q0: bigint; account: Address } & ({ r0: bigint[] } | { x0: bigint[]; weights: bigint[] }),
 ) {
-  return writeFPool(c, a.poolId, "seed", [a.L0, a.x0, a.Q0], a.account);
+  const r0 = "r0" in a ? a.r0 : a.x0.map((x, j) => fPoolReserveAt((a.weights[j]! * a.L0) / 10n ** 18n, x));
+  return writeFPool(c, a.poolId, "seed", [a.L0, r0, a.Q0], a.account);
 }
 
-/** End of life. Gated on-chain to the authority and to Q at dust (the raise is not abortable). */
+/**
+ * Retire the live generation (decisions 025, 032). Allowed at Q ≤ L/1e9 on every pool — the
+ * market filled the ask — and on a pool that is not strike-locked at any Q. The live (S, Q, R_j)
+ * become a frozen bundle every share of this generation redeems ({@link fPoolRedeem}) or rolls
+ * ({@link fPoolRollIn}), forever; the pool is unseeded until the next {@link fPoolSeed}, which
+ * opens generation `gen + 1` under the same id, gates, lists and promises.
+ */
 export async function fPoolDissolve(c: LogswapClient, a: { poolId: Hex; account: Address }) {
   return writeFPool(c, a.poolId, "dissolve", [], a.account);
 }
 
+/**
+ * The sponsor's relaunch as ONE transaction (decisions 025, 032): `dissolve` the live generation,
+ * `redeem` the sponsor's own shares of it (when `shares` > 0), `seed` the next generation with
+ * what came back — the manager's `multicall`, the sponsor as sender throughout, the same pool.
+ * Gates, allowlist, operator, `minBuffer` and names carry over; anything else goes in `extra`,
+ * pre-encoded against {@link fPoolManagerAbi}. The seed names reserves (decisions 029): `r0`
+ * outright, or `x0` marks against the key's `weights`.
+ */
+export async 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 */
+    shares: bigint;
+    L0: bigint;
+    Q0: bigint;
+    extra?: Hex[];
+    account: Address;
+  } & ({ r0: bigint[] } | { x0: bigint[]; weights: bigint[] }),
+) {
+  const gen = await fPoolGen(c, a.poolId);
+  const r0 = "r0" in a ? a.r0 : a.x0.map((x, j) => fPoolReserveAt((a.weights[j]! * a.L0) / WAD, x));
+  const enc = (functionName: string, args: unknown[]) =>
+    encodeFunctionData({ abi: fPoolManagerAbi, functionName, args } as never) as Hex;
+  const calls: Hex[] = [
+    enc("dissolve", [a.poolId]),
+    ...(a.shares > 0n ? [enc("redeem", [a.poolId, BigInt(gen), a.account, a.shares])] : []),
+    enc("seed", [a.poolId, a.L0, r0, a.Q0]),
+    ...(a.extra ?? []),
+  ];
+  return writeFPool0(c, "multicall", [calls], a.account);
+}
+
 /**
  * Propose the next authority — step one of two (contracts `2aa6b7b`, decisions 020). Nothing moves
  * until `next` accepts; proposing again (the zero address included) cancels a pending proposal.
@@ -697,9 +936,6 @@ export async function fPoolAcceptAuthority(c: LogswapClient, a: { poolId: Hex; a
 
 // ─── the sponsor's controls and the desk (contracts bd3dd87, decisions 021) ───────────────
 
-/** `setLegL`'s "keep the stored mark" sentinel — the only legal `x` for a live leg. */
-export const NO_X = -(2n ** 255n);
-
 /** Turn the mint / swap gates on or off (authority). `burn` is never gated. */
 export async function fPoolSetGates(
   c: LogswapClient,
@@ -773,22 +1009,24 @@ export async function fPoolRaiseMinBuffer(c: LogswapClient, a: { poolId: Hex; mi
 
 /**
  * Set leg `j`'s liquidity (operator, sole LP only): grow, shrink, retire (`newLj = 0`), or re-admit
- * a retired leg at a named mark `x`. For a live leg leave `x` undefined — its mark is the market's.
- * The base moves single-sidedly through the lock; shares adjust to hold the share value.
+ * 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.
  */
 export async function fPoolSetLegL(
   c: LogswapClient,
-  a: { poolId: Hex; j: number; newLj: bigint; x?: bigint; account: Address },
+  a: { poolId: Hex; j: number; newLj: bigint; r?: bigint; account: Address },
 ) {
-  return writeFPool(c, a.poolId, "setLegL", [BigInt(a.j), a.newLj, a.x ?? NO_X], a.account);
+  return writeFPool(c, a.poolId, "setLegL", [BigInt(a.j), a.newLj, a.r ?? 0n], a.account);
 }
 
-/** Admit a base the pool has never held, at a named mark, with liquidity `Lj` (operator, sole LP only). */
+/** Admit a base the pool has never held: `R` of it against liquidity `Lj`, so at `p = Lj / R` (operator, sole LP only). */
 export async function fPoolAdmitLeg(
   c: LogswapClient,
-  a: { poolId: Hex; base: Address; Lj: bigint; x: bigint; account: Address },
+  a: { poolId: Hex; base: Address; Lj: bigint; R: bigint; account: Address },
 ) {
-  return writeFPool(c, a.poolId, "admitLeg", [a.base, a.Lj, a.x], a.account);
+  return writeFPool(c, a.poolId, "admitLeg", [a.base, a.Lj, a.R], a.account);
 }
 
 /**
@@ -798,14 +1036,15 @@ export async function fPoolAdmitLeg(
  */
 export async function fPoolTransferShares(
   c: LogswapClient,
-  a: { poolId: Hex; to: Address; shares: bigint; account: Address },
+  a: { poolId: Hex; to: Address; shares: bigint; account: Address; gen?: bigint | number },
 ) {
   const wallet = requireWallet(c);
+  const gen = a.gen ?? (await fPoolGen(c, a.poolId));
   const { request } = await c.public.simulateContract({
     address: c.addresses.fPoolManager!,
     abi: fPoolManagerAbi,
     functionName: "transfer",
-    args: [a.to, fPoolShareId(a.poolId), a.shares],
+    args: [a.to, fPoolShareId(a.poolId, gen), a.shares],
     account: a.account,
   } as never);
   return wallet.writeContract(request as never);
@@ -819,7 +1058,7 @@ export interface DiscoveredFPool {
   bases: Address[];
   weights: bigint[];
   phi: bigint;
-  feesOnly: boolean;
+  lockStrike: boolean;
   authority: Address;
   /** The block the pool was initialized in — its age, for annualising realized income. */
   block: bigint;
@@ -838,7 +1077,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, feesOnly) — the poolId is a hash and could
+ * carries the full key preimage (bases, weights, phi, lockStrike) — the poolId is a hash and could
  * never be inverted; contracts PR #17 exists for exactly this call.
  */
 export async function discoverFPools(
@@ -869,7 +1108,7 @@ export async function discoverFPools(
   return logs.map((l) => {
     const a = l.args as {
       poolId: Hex; quote: Address; authority: Address; bases: readonly Address[];
-      weights: readonly bigint[]; phi: bigint; feesOnly: boolean;
+      weights: readonly bigint[]; phi: bigint; lockStrike: boolean;
     };
     const q0 = q0Of.get(a.poolId.toLowerCase());
     return {
@@ -878,7 +1117,7 @@ export async function discoverFPools(
       bases: [...a.bases],
       weights: [...a.weights],
       phi: a.phi,
-      feesOnly: a.feesOnly,
+      lockStrike: a.lockStrike,
       authority: a.authority,
       block: l.blockNumber ?? 0n,
       seeded: q0 !== undefined,
@@ -897,12 +1136,12 @@ export async function discoverFPools(
 export async function fPoolShareHolders(
   c: LogswapClient,
   poolIdHex: Hex,
-  opts: { fromBlock?: bigint } = {},
+  opts: { fromBlock?: bigint; gen?: bigint | number } = {},
 ): Promise<Array<{ holder: Address; shares: bigint }>> {
   type Ev = Extract<(typeof fPoolManagerAbi)[number], { type: "event"; name: "Transfer" }>;
   const ev = fPoolManagerAbi.find((x): x is Ev => x.type === "event" && x.name === "Transfer");
   if (!ev) throw new Error("logswap: 6909 Transfer event missing from the generated ABI");
-  const id = fPoolShareId(poolIdHex);
+  const id = fPoolShareId(poolIdHex, opts.gen ?? (await fPoolGen(c, poolIdHex)));
   const logs = await c.public.getLogs({
     address: c.addresses.fPoolManager!,
     event: ev,
@@ -922,7 +1161,7 @@ export async function fPoolShareHolders(
     .sort((a, b) => (b.shares > a.shares ? 1 : -1));
 }
 
-/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, feesOnly, seeded, dissolved, n, Q, L, shares, theta0, bigSigma, leverTheta). */
+/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, lockStrike, seeded, gen, n, Q, L, shares, theta0, bigSigma, leverTheta). */
 export async function getFPoolsRaw(c: LogswapClient, poolIds: Hex[]): Promise<readonly unknown[]> {
   const { logswapLensAbi } = await import("./generated.js");
   return (await c.public.readContract({ address: c.addresses.lens, abi: logswapLensAbi, functionName: "getFPools", args: [poolIds] } as never)) as readonly unknown[];