@logswap/sdk 0.5.39 → 0.5.41

package/dist/fpool.js

@@ -67,7 +67,7 @@ export async function getFPool(c, poolId) {
     const weights = legs.map((l) => l[1]);
     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 { quote, Q, L, phi, theta0, bigSigma, authority, pendingAuthority, operator, pendingOperator, gateMint, gateSwap, restructureBlock, seeded, gen } = p;
     const totalSupply = p.shares;
     return {
         poolId,
@@ -85,18 +85,27 @@ export async function getFPool(c, poolId) {
         authority,
         pendingAuthority,
         operator,
+        pendingOperator,
         name: bytes32ToText(p.name),
-        minBuffer,
         gateMint,
         gateSwap,
         restructureBlock: Number(restructureBlock),
-        lockStrike,
+        kind: fPoolKindOf(p.kind),
         seeded,
         gen: Number(gen),
         totalSupply,
         reserves,
     };
 }
+/** The key's enum values. */
+export const F_KIND = { public: 0, private: 1, pol: 2, pad: 3 };
+const F_KIND_NAMES = ["public", "private", "pol", "pad"];
+export function fPoolKindOf(n) {
+    const k = F_KIND_NAMES[Number(n)];
+    if (!k)
+        throw new Error(`logswap: unknown pool kind ${n}`);
+    return k;
+}
 export async function describeFPool(c, s) {
     const rd = (functionName) => c.public.readContract({
         address: c.addresses.fPoolManager,
@@ -110,7 +119,7 @@ export async function describeFPool(c, s) {
         ? await Promise.all([rd("feePerL"), rd("edgePerL")])
         : [0n, 0n];
     return {
-        shape: s.bases.length === 1 ? "launch" : "basket",
+        shape: s.kind === "pad" ? "launch" : "basket", // the kind, not n = 1 (decisions 036)
         legs: s.bases.length,
         atFloor: s.Q === 0n,
         feePerL,
@@ -242,8 +251,9 @@ export async function fPoolPreviewRollIn(c, poolId, gen, holder, shares) {
  * Remove quote, lifting θ — price-neutral, no base moves, and since decisions 028 a DIVIDEND to
  * every share: the amount goes into the pool's pot and each holder's slice is settled lazily on
  * their next transfer, mint or burn, or pulled with {@link fPoolClaim}. The sponsor's own slice —
- * its shares' and the locked seed's at 0xdead — is pushed to `to` at once. Under `lockStrike`
- * the lift stops at θ₀ (income only); on every live pool it stops at `LEVER_FLOOR` (Q/L ≥ ln 1.25).
+ * its shares' and the locked seed's at 0xdead — is pushed to `to` at once. On a pad
+ * the lift stops at the seed floor θ₀ (income only); nothing else bounds it (decisions 035) — an
+ * unlocked pool's authority may take Q to zero.
  */
 export async function fPoolHarvest(c, a) {
     return writeFPool(c, a.poolId, "harvest", [a.amount, a.to ?? a.account], a.account);
@@ -267,12 +277,6 @@ export async function fPoolDividendOf(c, poolId, holder, gen) {
         args: [poolId, BigInt(g), holder],
     });
 }
-/** 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, a) {
-    return writeFPool(c, a.poolId, "deepen", [a.amount], a.account);
-}
 // ─── internals ────────────────────────────────────────────────────────────────
 function defaultDeadline() {
     return BigInt(Math.floor(Date.now() / 1000) + 1800);
@@ -555,7 +559,7 @@ export async function fPoolInitialize(c, a) {
     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, lockStrike: a.lockStrike, authority: a.authority, salt: a.salt ?? ZERO_SALT };
+    const key = { quote: a.quote, bases, weights: companions[0], phi: a.phi, kind: F_KIND[a.kind], authority: a.authority, salt: a.salt ?? ZERO_SALT };
     const wallet = requireWallet(c);
     const { request } = await c.public.simulateContract({
         address: c.addresses.fPoolManager,
@@ -569,7 +573,7 @@ export async function fPoolInitialize(c, a) {
 /** The pool id is the key's hash — pure, so it can be read before or after creation. */
 export async function fPoolIdOf(c, a) {
     const { bases, companions } = sortFPoolLegs(a.bases, a.weights);
-    const key = { quote: a.quote, bases, weights: companions[0], phi: a.phi, lockStrike: a.lockStrike, authority: a.authority, salt: a.salt ?? ZERO_SALT };
+    const key = { quote: a.quote, bases, weights: companions[0], phi: a.phi, kind: F_KIND[a.kind], authority: a.authority, salt: a.salt ?? ZERO_SALT };
     return c.public.readContract({
         address: c.addresses.fPoolManager,
         abi: fPoolManagerAbi,
@@ -600,38 +604,99 @@ export async function fPoolSeed(c, a) {
     return writeFPool(c, a.poolId, "seed", [a.L0, r0, a.Q0], a.account);
 }
 /**
- * Retire the live generation (decisions 025, 032). Allowed at Q ≤ L/1e9 on every pool — the
- * market filled the ask — and on a pool that is not strike-locked at any Q. The live (S, Q, R_j)
- * become a frozen bundle every share of this generation redeems ({@link fPoolRedeem}) or rolls
- * ({@link fPoolRollIn}), forever; the pool is unseeded until the next {@link fPoolSeed}, which
- * opens generation `gen + 1` under the same id, gates, lists and promises.
+ * Retire the live generation (decisions 025, 032, 035) — the raw entry. Allowed only at an empty
+ * bid, Q ≤ L/1e9, on every pool: the market took it, or the authority harvested it out first
+ * ({@link fPoolRetire} does both in one transaction). The live (S, Q, R_j) become a frozen bundle
+ * every share of this generation redeems ({@link fPoolRedeem}) or rolls ({@link fPoolRollIn}),
+ * forever; the pool is unseeded until the next {@link fPoolSeed}, which opens generation
+ * `gen + 1` under the same id, gates and lists.
  */
 export async function fPoolDissolve(c, a) {
     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`.
+ * Retire the live generation as ONE transaction: the harvests that empty the bid
+ * ({@link fPoolEmptyingHarvests} — a dividend to every share; none when it is already empty),
+ * then `dissolve` — the manager's `multicall`, the authority as sender. What a sponsor's
+ * "dissolve" button should call. Throws before sending on a pad that still bids.
+ */
+export async function fPoolRetire(c, a) {
+    const harvests = await fPoolEmptyingHarvests(c, a.poolId);
+    if (harvests.length === 0)
+        return fPoolDissolve(c, a);
+    const enc = (functionName, args) => encodeFunctionData({ abi: fPoolManagerAbi, functionName, args });
+    const calls = [...harvests.map((amount) => enc("harvest", [a.poolId, amount, a.account])), enc("dissolve", [a.poolId])];
+    return writeFPool0(c, "multicall", [calls], a.account);
+}
+/**
+ * The harvests that empty an unlocked pool's bid, in order — what a relaunch sends before its
+ * `dissolve` (decisions 035: a dissolve needs an empty bid on every pool). One `harvest(Q)` when a
+ * collector is set. With none, the cut on income STAYS in the pool as LP quote (decisions 002)
+ * and reads as taken income, so a second harvest — capital, no cut — takes the rest; the
+ * contract's own arithmetic, replayed. `[]` when the bid is already empty. Throws on a
+ * pad that still bids (its bid empties only as the market sells it down), and in
+ * the one shape two harvests cannot empty (no collector, income above Q — harvest by hand).
+ */
+export async function fPoolEmptyingHarvests(c, poolId) {
+    const rd = (functionName, args = []) => c.public.readContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName, args });
+    const [p, feePerL, fee, exempt, collector] = await Promise.all([
+        rd("getPool", [poolId]),
+        rd("feePerL", [poolId]),
+        rd("HARVEST_FEE"),
+        rd("harvestFeeExempt", [poolId]),
+        rd("feeCollector"),
+    ]);
+    if (p.Q === 0n)
+        return [];
+    if (p.kind === F_KIND.pad)
+        throw new Error("logswap: a pad is retired only once its bid is empty (decisions 035)");
+    const earned = feePerL > 0n ? (feePerL * p.L) / WAD : 0n;
+    let taken = p.incomeTaken;
+    let q = p.Q;
+    const amounts = [];
+    for (let i = 0; i < 2 && q > 0n; i++) {
+        const amount = q;
+        const left = earned > taken ? earned - taken : 0n;
+        const taxable = amount < left ? amount : left;
+        taken += taxable;
+        const pFee = exempt ? 0n : (taxable * fee) / WAD;
+        const leaving = pFee !== 0n && collector !== ZERO_ADDRESS ? amount : amount - pFee;
+        q -= leaving;
+        amounts.push(amount);
+    }
+    if (q > 0n)
+        throw new Error("logswap: the bid does not empty in two harvests (no collector, income above Q) — harvest by hand first");
+    return amounts;
+}
+/**
+ * The relaunch as ONE transaction (decisions 025, 032, 035, 037): `harvest` the bid out — a
+ * dividend to every share, {@link fPoolEmptyingHarvests} — `dissolve` the live generation at the
+ * empty bid, `redeem` the caller's own shares of it (when `shares` > 0), optionally `setLegs` the
+ * next generation's composition (`legs`: a private pool's reshape — retire, admit, reweight), and
+ * `seed` it with what came back — the manager's `multicall`, one sender throughout, the same
+ * pool. The operator's when one is appointed and the seed's inventory is its own; by default the
+ * authority's. Gates, allowlist and names carry over; anything else goes in `extra`, pre-encoded
+ * against {@link fPoolManagerAbi}. The seed names reserves (decisions 029): `r0` outright — one
+ * per leg of the NEXT table, 0 for a retired leg — or `x0` marks against the next table's
+ * `weights`.
  */
 export async function fPoolRelaunch(c, a) {
-    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 [gen, harvests] = await Promise.all([fPoolGen(c, a.poolId), fPoolEmptyingHarvests(c, a.poolId)]);
+    const r0 = "r0" in a ? a.r0 : a.x0.map((x, j) => (a.weights[j] === 0n ? 0n : fPoolReserveAt((a.weights[j] * a.L0) / WAD, x)));
     const enc = (functionName, args) => encodeFunctionData({ abi: fPoolManagerAbi, functionName, args });
     const calls = [
+        ...harvests.map((amount) => enc("harvest", [a.poolId, amount, a.account])),
         enc("dissolve", [a.poolId]),
         ...(a.shares > 0n ? [enc("redeem", [a.poolId, BigInt(gen), a.account, a.shares])] : []),
+        ...(a.legs ? [enc("setLegs", [a.poolId, a.legs.weights, a.legs.newBases ?? []])] : []),
         enc("seed", [a.poolId, a.L0, r0, a.Q0]),
         ...(a.extra ?? []),
     ];
     return writeFPool0(c, "multicall", [calls], a.account);
 }
-/** ERC-6909 shares sent here are locked for good — the seed's custody (custody.md §4(b)). */
+/** Where a pad's seed lives (decisions 036): `seed` mints every share of a pad here itself. */
 export const DEAD_ADDRESS = "0x000000000000000000000000000000000000dEaD";
-/** The manager's `MIN_SHARES`: the seed mints this much to 0xdead itself, the rest to the seeder. */
+/** The manager's `MIN_SHARES`: the seed mints this much to 0xdead on every pool, the rest to the seeder — or, on a pad, to 0xdead too. */
 export const F_MIN_SHARES = 1000n;
 /**
  * The launch's calls, in order — the batch {@link fPoolLaunch} sends. Pure, so a form can show
@@ -647,15 +712,14 @@ export function fPoolLaunchCalls(poolId, a) {
     if (given.length !== a.bases.length)
         throw new Error(`logswap: ${given.length} reserves for ${a.bases.length} legs`);
     const { bases, companions } = sortFPoolLegs(a.bases, a.weights, given);
-    const key = { quote: a.quote, bases, weights: companions[0], phi: a.phi, lockStrike: a.lockStrike, authority: a.authority, salt: a.salt ?? ZERO_SALT };
+    const key = { quote: a.quote, bases, weights: companions[0], phi: a.phi, kind: F_KIND[a.kind], authority: a.authority, salt: a.salt ?? ZERO_SALT };
     const enc = (functionName, args) => encodeFunctionData({ abi: fPoolManagerAbi, functionName, args });
     const calls = [];
     if (!a.initialized)
         calls.push(enc("initialize", [key]));
     calls.push(enc("seed", [poolId, a.L0, companions[1], a.Q0]));
-    // gen 0 by construction: a launch is the pool's FIRST seed — a relaunch is `fPoolRelaunch`
-    if (a.lockSeed)
-        calls.push(enc("transfer", [DEAD_ADDRESS, fPoolShareId(poolId, 0), a.L0 - F_MIN_SHARES]));
+    // gen 0 by construction: a launch is the pool's FIRST seed — a relaunch is `fPoolRelaunch`.
+    // No transfer to 0xdead: on a pad `seed` mints every share there itself (decisions 036).
     if (a.openBuy) {
         const j = bases.indexOf(a.bases[a.openBuy.j]);
         if (j < 0)
@@ -664,10 +728,11 @@ export function fPoolLaunchCalls(poolId, a) {
     }
     if (a.name)
         calls.push(enc("setName", [poolId, textToBytes32(a.name)]));
-    if (a.privatePool) {
+    if (a.kind === "private") {
+        // the desk's opening posture: gated minting, the creator listed. No appointment: the
+        // authority is the operator until one is appointed (decisions 037)
         calls.push(enc("setGates", [poolId, true, false]));
         calls.push(enc("setAllowed", [poolId, [a.account], true]));
-        calls.push(enc("appointOperator", [poolId, a.account]));
     }
     calls.push(...(a.extra ?? []));
     return calls;
@@ -753,35 +818,37 @@ export async function fPoolSponsorName(c, who) {
     }));
     return bytes32ToText(word);
 }
-/** Appoint (or clear, with the zero address) the operator — the hot key that reshapes and never moves value out. */
-export async function fPoolAppointOperator(c, a) {
-    return writeFPool(c, a.poolId, "appointOperator", [a.operator], a.account);
+/** Who runs the pool (decisions 037): the appointed operator, or the authority until one is. */
+export function fPoolOperatorOf(s) {
+    return s.operator === ZERO_ADDRESS ? s.authority : s.operator;
 }
 /**
- * Raise the floor guard: `harvest` may not take Q/L under `minBuffer` (WAD log-distance; 20% below
- * spot is ln 1.25 ≈ 0.223e18). Raise-only — a commitment the authority cannot walk back.
+ * Propose the operator (authority; private pools only) — the hot key that runs the pool: `harvest`,
+ * `dissolve`, `setLegs`. Two-step: the proposed address takes the role with
+ * {@link fPoolAcceptOperator}. The zero address clears at once — the role returns to the authority.
  */
-export async function fPoolRaiseMinBuffer(c, a) {
-    return writeFPool(c, a.poolId, "raiseMinBuffer", [a.minBuffer], a.account);
+export async function fPoolAppointOperator(c, a) {
+    return writeFPool(c, a.poolId, "appointOperator", [a.operator], a.account);
+}
+/** The proposed operator takes the role. */
+export async function fPoolAcceptOperator(c, a) {
+    return writeFPool(c, a.poolId, "acceptOperator", [], a.account);
 }
 /**
- * Set leg `j`'s liquidity (operator, sole LP only): grow, shrink, retire (`newLj = 0`), or re-admit
- * a retired leg holding `r` of the base (decisions 029 — the price follows, `p = newLj / r`; use
- * {@link fPoolReserveAt} from a mark). For a live leg leave `r` undefined — its price is the
- * market's, the reserve scales with the liquidity. Base moves single-sidedly through the lock;
- * shares adjust to hold the share value.
+ * The next generation's composition (operator; private pools only; ONLY while the pool is
+ * unseeded — between a dissolve and the seed that prices it, decisions 037). `weights` has one
+ * entry per leg the pool has ever had, in index order (0 retires a leg; indices are never reused),
+ * then one per base in `newBases`, appended; they sum to 1e18 exactly. No value moves: the
+ * following {@link fPoolSeed} names every reserve. A live reshape is {@link fPoolRelaunch} with
+ * `legs` set.
  */
-export async function fPoolSetLegL(c, a) {
-    return writeFPool(c, a.poolId, "setLegL", [BigInt(a.j), a.newLj, a.r ?? 0n], a.account);
-}
-/** 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, a) {
-    return writeFPool(c, a.poolId, "admitLeg", [a.base, a.Lj, a.R], a.account);
+export async function fPoolSetLegs(c, a) {
+    return writeFPool(c, a.poolId, "setLegs", [a.weights, a.newBases ?? []], a.account);
 }
 /**
  * Move shares (ERC-6909 `transfer`) — to another holder, or to `0xdead` to lock them for good.
  * Burning to the dead address is a sponsor's way to make its liquidity permanent: the shares can
- * never be redeemed, and they never count against the sole-LP precondition.
+ * never be redeemed.
  */
 export async function fPoolTransferShares(c, a) {
     const wallet = requireWallet(c);
@@ -797,7 +864,7 @@ export async function fPoolTransferShares(c, a) {
 }
 /**
  * Every F pool ever created, from `Initialize` logs alone. Possible only because the event
- * carries the full key preimage (bases, weights, phi, lockStrike) — the poolId is a hash and could
+ * carries the full key preimage (bases, weights, phi, pad) — the poolId is a hash and could
  * never be inverted; contracts PR #17 exists for exactly this call.
  */
 export async function discoverFPools(c, opts = {}) {
@@ -830,12 +897,12 @@ export async function discoverFPools(c, opts = {}) {
             bases: [...a.bases],
             weights: [...a.weights],
             phi: a.phi,
-            lockStrike: a.lockStrike,
+            kind: fPoolKindOf(a.kind),
             authority: a.authority,
             block: l.blockNumber ?? 0n,
             seeded: q0 !== undefined,
             q0: q0 ?? 0n,
-            shape: a.bases.length === 1 && (q0 ?? 0n) === 0n ? "launch" : "basket",
+            shape: a.kind === F_KIND.pad ? "launch" : "basket", // the kind, not n = 1: a mono POL is a pool (decisions 036)
         };
     });
 }
@@ -869,7 +936,7 @@ export async function fPoolShareHolders(c, poolIdHex, opts = {}) {
         .map(([holder, shares]) => ({ holder: holder, shares }))
         .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, lockStrike, seeded, gen, n, Q, L, shares, theta0, bigSigma, leverTheta). */
+/** Every F pool's state in one lens call (the raw manager struct: quote, phi, authority, kind, seeded, gen, n, Q, L, shares, theta0, bigSigma, harvestedTheta). */
 export async function getFPoolsRaw(c, poolIds) {
     const { logswapLensAbi } = await import("./generated.js");
     return (await c.public.readContract({ address: c.addresses.lens, abi: logswapLensAbi, functionName: "getFPools", args: [poolIds] }));