@logswap/sdk 0.5.36 → 0.5.37

package/dist/fpool.js

@@ -22,8 +22,16 @@
  * twice, forever. One router is one spender — see `fPoolZapIn`/`fPoolZapOut` below, which target
  * `addresses.router`.
  */
-import { toFunctionSelector } from "viem";
-import { fPoolManagerAbi, logswapRouterAbi } from "./generated.js";
+import { encodeFunctionData, toFunctionSelector } 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];
 const WAD = 10n ** 18n;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 /** Read a basket pool whole. Batched — viem multicalls these when the transport allows. */
@@ -57,11 +65,9 @@ export async function getFPool(c, poolId) {
     ]);
     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, dissolved, successor } = p;
     const totalSupply = p.shares;
     return {
         poolId,
@@ -84,9 +90,10 @@ export async function getFPool(c, poolId) {
         gateMint,
         gateSwap,
         restructureBlock: Number(restructureBlock),
-        feesOnly,
+        lockStrike,
         seeded,
         dissolved,
+        successor,
         totalSupply,
         reserves,
     };
@@ -200,14 +207,61 @@ export async function fPoolZapOut(c, a) {
     const to = a.to ?? a.account;
     return writeRouter(c, "zapOut", [a.poolId, a.shares, a.tokenOut, a.minOut ?? 0n, to, a.deadline ?? defaultDeadline()], a.account);
 }
+/**
+ * Roll a dissolved pool's bundle into its successor (decisions 025), on the router under one
+ * lock: burn `shares` of `fromPool` in place — the legs, the quote and any unpulled dividend come
+ * back — buy through `toPool`'s own curve only what its 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, a) {
+    const to = a.to ?? a.account;
+    return writeRouter(c, "rollIn", [a.fromPool, a.toPool, a.shares, a.dL, a.maxQuoteIn ?? 0n, a.minShares ?? 0n, to, a.deadline ?? defaultDeadline()], a.account);
+}
+/**
+ * The roll `holder`'s `shares` of `fromPool` fund into `toPool` WITHOUT a trade: the largest `dL`
+ * the bundle's base covers on every successor 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
+ * successor leg the bundle does not hold makes `dL` zero: such a roll must buy, so size it below
+ * with `previewZapIn` in mind.
+ */
+export async function fPoolPreviewRollIn(c, fromPool, toPool, holder, shares) {
+    const { logswapLensAbi } = await import("./generated.js");
+    const [dL, quoteShort, quoteExcess] = (await c.public.readContract({
+        address: c.addresses.lens,
+        abi: logswapLensAbi,
+        functionName: "previewRollIn",
+        args: [fromPool, toPool, holder, shares],
+    }));
+    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, a) {
     return writeFPool(c, a.poolId, "harvest", [a.amount, a.to ?? a.account], a.account);
 }
+/** Pull one's settled dividend (decisions 028) without moving shares; anyone with shares. */
+export async function fPoolClaim(c, a) {
+    return writeFPool(c, a.poolId, "claim", [a.to ?? a.account], a.account);
+}
+/** A holder's dividend as of now — banked plus pending on the current balance (decisions 028). */
+export async function fPoolDividendOf(c, poolId, holder) {
+    return c.public.readContract({
+        address: c.addresses.fPoolManager,
+        abi: fPoolManagerAbi,
+        functionName: "dividendOf",
+        args: [poolId, 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);
@@ -235,6 +289,18 @@ async function writeFPool(c, poolId, functionName, args, account) {
     });
     return wallet.writeContract(request);
 }
+/** A manager write that is NOT keyed by a poolId — `multicall`. */
+async function writeFPool0(c, functionName, args, account) {
+    const wallet = requireWallet(c);
+    const { request } = await c.public.simulateContract({
+        address: c.addresses.fPoolManager,
+        abi: fPoolManagerAbi,
+        functionName,
+        args,
+        account,
+    });
+    return wallet.writeContract(request);
+}
 async function writeRouter(c, functionName, args, account, 
 /** Tokens the call pulls: missing Permit2 allowances are SIGNED and ride in the same tx. */
 pullTokens = []) {
@@ -433,7 +499,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, 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,
@@ -447,7 +513,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, 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,
@@ -456,16 +522,61 @@ export async function fPoolIdOf(c, a) {
     });
 }
 /**
- * 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, x) {
+    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, a) {
-    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). */
+/**
+ * End of life (decisions 025). 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, provided `successor` names an initialized
+ * pool of the same authority and quote: the relaunch. After it every share is a frozen in-kind
+ * claim redeemed by `burn` (or rolled with {@link fPoolRollIn}), forever; the pool's `successor`
+ * carries the lineage. Never a second dissolve on one pool: the successor is a NEW pool.
+ */
 export async function fPoolDissolve(c, a) {
-    return writeFPool(c, a.poolId, "dissolve", [], a.account);
+    return writeFPool(c, a.poolId, "dissolve", [a.successor ?? ZERO_SALT], a.account);
+}
+/**
+ * The sponsor's relaunch as ONE transaction (decisions 025): `initialize` the successor key,
+ * `dissolve` the old pool into it, `burn` the sponsor's own shares, `seed` the successor with what
+ * came back — the manager's `multicall`, the sponsor as sender throughout. Gates, allowlist,
+ * operator, floor guard and name are re-applied afterwards, or appended to `extra` pre-encoded
+ * against {@link fPoolManagerAbi}. Returns the tx hash; the successor's id is {@link fPoolIdOf}
+ * of `nextKey`.
+ */
+export async function fPoolRelaunch(c, a) {
+    const { bases, companions } = sortFPoolLegs(a.nextKey.bases, a.nextKey.weights);
+    const key = {
+        quote: a.nextKey.quote, bases, weights: companions[0], phi: a.nextKey.phi, lockStrike: a.nextKey.lockStrike,
+        authority: a.nextKey.authority, salt: a.nextKey.salt ?? ZERO_SALT,
+    };
+    const next = await fPoolIdOf(c, a.nextKey);
+    const enc = (functionName, args) => encodeFunctionData({ abi: fPoolManagerAbi, functionName, args });
+    const calls = [
+        enc("initialize", [key]),
+        enc("dissolve", [a.poolId, next]),
+        enc("burn", [a.poolId, a.account, a.shares, 0n]),
+        enc("seed", [next, a.L0, a.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
@@ -480,8 +591,6 @@ export async function fPoolAcceptAuthority(c, a) {
     return writeFPool(c, a.poolId, "acceptAuthority", [], a.account);
 }
 // ─── 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, a) {
     return writeFPool(c, a.poolId, "setGates", [a.gateMint, a.gateSwap], a.account);
@@ -541,15 +650,17 @@ export async function fPoolRaiseMinBuffer(c, a) {
 }
 /**
  * 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, a) {
-    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, a) {
-    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);
 }
 /**
  * Move shares (ERC-6909 `transfer`) — to another holder, or to `0xdead` to lock them for good.
@@ -569,7 +680,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, 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(c, opts = {}) {
@@ -602,7 +713,7 @@ export async function discoverFPools(c, opts = {}) {
             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,
@@ -641,7 +752,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, 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, dissolved, successor, n, Q, L, shares, theta0, bigSigma, leverTheta). */
 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] }));