@logswap/sdk 0.5.71 → 0.5.72

package/README.md

@@ -36,14 +36,33 @@ Both are computed **offline** — no RPC, no deployment needed to address a mark
   `update(...)` / `harvest(...)` / `burn(...)` / `claimFees(...)` act on it.
 - F side: `discoverFPools(c)` (shape, and the `block` the pool was initialized in), `getFPool`,
   `fPoolShareBalance`, `fPoolShareValue`; `previewZapIn` reads the **lens** (the router's F flows
-  live in a facet, its previews moved to the lens).
+  live in a facet, its previews moved to the lens). Since F version 25 every F state read goes
+  through the lens (`fPool`, `getFPools`, `fBundleOf`, `fDividendOf`, `fLienOf`): the manager's
+  typed views are behind `extsload` (decisions 062), and the lens decodes them with the contracts'
+  `FPoolState`, so the SDK never hard-codes the storage layout.
+- F pool state names (F version 25): `swapFee` (was `phi`), `logFloor` θ — the log of the current
+  floor price (was `theta`), `refLogFloor` θ₀ — the reference floor income counts from (was
+  `theta0`), `cap` (d in 1e-6 log units, 0 uncapped), and per leg `virtualReserves` and `kappa`.
+
+## Capped F pools and the lien (F version 25)
+
+- **The cap** (decisions 061) is a key field: `FPoolKey.cap` / `FPoolCreateArgs.cap`, d =
+  ln(cap/floor) in 1e-6 log units. `fPoolCapOfLeverage(λ)` gives d for a leverage at the floor
+  (λ = 2 → the cap at twice the floor), `fPoolLeverageOfCap(d)` the inverse. Seeding by marks
+  (`x0`) on a capped pool scales each reserve by (1 − k), k = `fPoolCapK(cap, Q0, L0)`: the mark
+  reads the virtual reserve R̃ = R + c. A seed priced at or above its cap is refused.
+- **The lien** (decisions 063): a lending contract locks an owner's shares in place.
+  `fPoolApproveShares` (the owner's per-id allowance), `fPoolLock` / `fPoolUnlock` (the locker's;
+  `to` = owner is a release, anyone else a seizure), `fPoolBankLien` (bank the locked dividend
+  now), `fPoolLienOf` (locker, amount, and the dividend the lien holds). The dividend the locked
+  amount earns is held by the lien: a repaid loan gets it back, a seizer takes it.
 
 ## Conventions
 
 - **The SDK hides the manager/router/lens split.** Which contract hosts which action is currently
   decided by EIP-170 headroom, not by design — so a future re-homing must be an SDK patch, not a
   breaking change for consumers.
-- **Zero is not the default.** A `phi` of `0n` resolves to `DEFAULT_FEE` at *read* time, so a key
+- **Zero is not the default.** A `swapFee` of `0n` (`phi` before C version 6) resolves to `DEFAULT_FEE` at *read* time, so a key
   carrying `0n` and one carrying the resolved value are **different markets with different ids**.
   Always address a market by the key it was initialized with.
 - **Split every ERC-6909 `Transfer` on bit 255.** Clear means a token claim, not a position; an

package/dist/admin.d.ts

@@ -1,22 +1,29 @@
 /**
- * admin — the protocol's writes: the C manager's cut of the mint fee (the F manager's is a
- * constant), the policies a pool may be born with (the registry's), the
- * policies' own numbers, and the two-step collector handover. Plain writes to the managers,
- * the registry and the policies; no router.
+ * admin — the protocol's writes: the C swap-fee tax (decisions 060), the policies a pool may be
+ * born with (the registry's), the policies' own numbers (the quote list, the fee tiers, a pad's
+ * schedule, a POL's rules), and the two-step collector handover. Plain writes to the managers, the
+ * registry and the policies; no router.
  *
- * One vocabulary: both managers call the protocol's cut of the mint fee
- * `MINT_FEE_PROTOCOL_CUT`; C sets it through `setFeeParams(uint256)`, F holds it as a constant
- * (049). The harvest's cut is the policy's answer at every harvest, set on the
- * policy (`PadPolicy.setSchedule`: the protocol's pot share and the ranges a creator chooses inside) and capped by the manager (`POT_CUT_MAX`, `BURN_MAX`; a harvest has no cut, decisions 056); the release's
- * protocol share likewise (`POT_CUT_MAX`).
+ * The mint fee has no cut to set since C version 6 / F version 24 (decisions 058): the whole fee
+ * is the protocol's on both managers. A harvest has no cut (056); a pad's protocol share of the pot
+ * is the policy's (`PadPolicy.setSchedule`), capped by the manager at `POT_CUT_MAX`.
  */
 import type { Address, Hash } from "viem";
 import type { LogswapClient } from "./client.js";
 import { type FPoolKey, type FPoolKind } from "./fpool.js";
-/** The C manager's `setFeeParams(mintFeeProtocolCut)` — one cut. */
-export declare function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash>;
-/** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18; there is no setter. */
-export declare function fMintFeeProtocolCut(c: LogswapClient): Promise<bigint>;
+/**
+ * The C manager's swap-fee tax (decisions 060): the protocol's share of every swap fee a C position
+ * is paid (claims and the burn's auto-claim), WAD. 0 at deployment.
+ */
+export declare function cSwapFeeTax(c: LogswapClient): Promise<{
+    tax: bigint;
+    max: bigint;
+}>;
+/**
+ * `CPoolManager.setSwapFeeTax`: the collector's, at most `SWAP_FEE_TAX_MAX` (25%). Read at payout,
+ * so a raise reaches fee income already earned and not yet claimed (decisions 060).
+ */
+export declare function setCSwapFeeTax(c: LogswapClient, taxWad: bigint): Promise<Hash>;
 /**
  * The policy registry the F manager asks at every birth — `addresses.policyRegistry` when the
  * deployment carries it, else read once from the manager. The zero address is a deployment with
@@ -90,9 +97,10 @@ export declare function fPoolMigrate(c: LogswapClient, a: {
  */
 export declare function registryKindOf(c: LogswapClient, policy: Address): Promise<FPoolKind | "">;
 /**
- * `PadPolicy.setSchedule` (decisions 056): `T(0)`, the rung's growth, the protocol's share of the pot (≤ `POT_CUT_MAX`,
- * recorded into each pad at birth), and the RANGES a creator chooses inside at creation — his cut of the pot and the burn per
- * rung (≤ `BURN_MAX`). A change applies to pads born after it. The rung is the pool's generation since F version 21.
+ * `PadPolicy.setSchedule` (decisions 056, 057): `T(0)`, the rung's growth, the protocol's share of the pot (≤ `POT_CUT_MAX`,
+ * recorded into each pad at birth), and the RANGES a creator chooses inside at creation — his cut of the pot and the burn, a
+ * fraction of the pot spent buying the token and burning it. The burn's top plus the protocol's share is at most the pot,
+ * and each pad's three shares together are. A change applies to pads born after it. The rung is the pool's generation.
  */
 export declare function padSetSchedule(c: LogswapClient, policy: Address, s: {
     thresholdBase: bigint;
@@ -118,6 +126,20 @@ export declare function policyQuoteAllowed(c: LogswapClient, policy: Address, qu
     listed: boolean;
     allowed: boolean;
 }>;
+/**
+ * `setFeeListed` on any protocol policy (decisions 059): a swap-fee tier a pool of that kind may be
+ * born with while the policy curates fees. Within the family's domain (`FEE_MIN` ≤ fee ≤ `FEE_MAX`).
+ * The collector's.
+ */
+export declare function policySetFeeListed(c: LogswapClient, policy: Address, fee: bigint, listed: boolean): Promise<Hash>;
+/** `setFeeCurated` on any protocol policy: on, a birth with an unlisted swap fee is refused (`FeeNotListed`). The collector's. */
+export declare function policySetFeeCurated(c: LogswapClient, policy: Address, curated: boolean): Promise<Hash>;
+/** Whether `fee` passes `policy`'s birth check now: listed, or the policy does not curate fees (the desk's never does). */
+export declare function policyFeeAllowed(c: LogswapClient, policy: Address, fee: bigint): Promise<{
+    curated: boolean;
+    listed: boolean;
+    allowed: boolean;
+}>;
 /** `PublicPolicy.setListed`: an asset a curated seed may hold. */
 export declare function publicSetListed(c: LogswapClient, policy: Address, token: Address, listed: boolean): Promise<Hash>;
 /** `PublicPolicy.setCurated`: whether every public seed is checked against the list. */

package/dist/admin.js

@@ -1,14 +1,12 @@
 /**
- * admin — the protocol's writes: the C manager's cut of the mint fee (the F manager's is a
- * constant), the policies a pool may be born with (the registry's), the
- * policies' own numbers, and the two-step collector handover. Plain writes to the managers,
- * the registry and the policies; no router.
+ * admin — the protocol's writes: the C swap-fee tax (decisions 060), the policies a pool may be
+ * born with (the registry's), the policies' own numbers (the quote list, the fee tiers, a pad's
+ * schedule, a POL's rules), and the two-step collector handover. Plain writes to the managers, the
+ * registry and the policies; no router.
  *
- * One vocabulary: both managers call the protocol's cut of the mint fee
- * `MINT_FEE_PROTOCOL_CUT`; C sets it through `setFeeParams(uint256)`, F holds it as a constant
- * (049). The harvest's cut is the policy's answer at every harvest, set on the
- * policy (`PadPolicy.setSchedule`: the protocol's pot share and the ranges a creator chooses inside) and capped by the manager (`POT_CUT_MAX`, `BURN_MAX`; a harvest has no cut, decisions 056); the release's
- * protocol share likewise (`POT_CUT_MAX`).
+ * The mint fee has no cut to set since C version 6 / F version 24 (decisions 058): the whole fee
+ * is the protocol's on both managers. A harvest has no cut (056); a pad's protocol share of the pot
+ * is the policy's (`PadPolicy.setSchedule`), capped by the manager at `POT_CUT_MAX`.
  */
 import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, publicPolicyAbi } from "./generated.js";
 import { bytes32ToText, fPolicyBaseAbi, fPoolKeyOfPool, fPoolKindOfPolicy, textToBytes32 } from "./fpool.js";
@@ -20,13 +18,23 @@ function wallet(c) {
 function write(c, address, abi, functionName, args) {
     return wallet(c).writeContract({ address, abi, functionName, args, chain: c.wallet.chain, account: c.wallet.account });
 }
-/** The C manager's `setFeeParams(mintFeeProtocolCut)` — one cut. */
-export async function setFeeParamsC(c, mintFeeProtocolCutWad) {
-    return write(c, c.addresses.cPoolManager, cPoolManagerAbi, "setFeeParams", [mintFeeProtocolCutWad]);
+/**
+ * The C manager's swap-fee tax (decisions 060): the protocol's share of every swap fee a C position
+ * is paid (claims and the burn's auto-claim), WAD. 0 at deployment.
+ */
+export async function cSwapFeeTax(c) {
+    const [tax, max] = await Promise.all([
+        c.public.readContract({ address: c.addresses.cPoolManager, abi: cPoolManagerAbi, functionName: "swapFeeTax" }),
+        c.public.readContract({ address: c.addresses.cPoolManager, abi: cPoolManagerAbi, functionName: "SWAP_FEE_TAX_MAX" }),
+    ]);
+    return { tax, max };
 }
-/** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18; there is no setter. */
-export async function fMintFeeProtocolCut(c) {
-    return c.public.readContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "MINT_FEE_PROTOCOL_CUT" });
+/**
+ * `CPoolManager.setSwapFeeTax`: the collector's, at most `SWAP_FEE_TAX_MAX` (25%). Read at payout,
+ * so a raise reaches fee income already earned and not yet claimed (decisions 060).
+ */
+export async function setCSwapFeeTax(c, taxWad) {
+    return write(c, c.addresses.cPoolManager, cPoolManagerAbi, "setSwapFeeTax", [taxWad]);
 }
 // ─── the registry: the LOG authority's, not the collector's ─────────────────
 const ZERO = "0x0000000000000000000000000000000000000000";
@@ -141,9 +149,10 @@ export async function registryKindOf(c, policy) {
 }
 // ─── the policies' numbers (the collector's; each bounded where it reaches the manager) ─────
 /**
- * `PadPolicy.setSchedule` (decisions 056): `T(0)`, the rung's growth, the protocol's share of the pot (≤ `POT_CUT_MAX`,
- * recorded into each pad at birth), and the RANGES a creator chooses inside at creation — his cut of the pot and the burn per
- * rung (≤ `BURN_MAX`). A change applies to pads born after it. The rung is the pool's generation since F version 21.
+ * `PadPolicy.setSchedule` (decisions 056, 057): `T(0)`, the rung's growth, the protocol's share of the pot (≤ `POT_CUT_MAX`,
+ * recorded into each pad at birth), and the RANGES a creator chooses inside at creation — his cut of the pot and the burn, a
+ * fraction of the pot spent buying the token and burning it. The burn's top plus the protocol's share is at most the pot,
+ * and each pad's three shares together are. A change applies to pads born after it. The rung is the pool's generation.
  */
 export async function padSetSchedule(c, policy, s) {
     return write(c, policy, padPolicyAbi, "setSchedule", [
@@ -176,6 +185,26 @@ export async function policyQuoteAllowed(c, policy, quote) {
     ]);
     return { curated, listed, allowed: !curated || listed };
 }
+/**
+ * `setFeeListed` on any protocol policy (decisions 059): a swap-fee tier a pool of that kind may be
+ * born with while the policy curates fees. Within the family's domain (`FEE_MIN` ≤ fee ≤ `FEE_MAX`).
+ * The collector's.
+ */
+export async function policySetFeeListed(c, policy, fee, listed) {
+    return write(c, policy, fPolicyBaseAbi, "setFeeListed", [fee, listed]);
+}
+/** `setFeeCurated` on any protocol policy: on, a birth with an unlisted swap fee is refused (`FeeNotListed`). The collector's. */
+export async function policySetFeeCurated(c, policy, curated) {
+    return write(c, policy, fPolicyBaseAbi, "setFeeCurated", [curated]);
+}
+/** Whether `fee` passes `policy`'s birth check now: listed, or the policy does not curate fees (the desk's never does). */
+export async function policyFeeAllowed(c, policy, fee) {
+    const [curated, listed] = await Promise.all([
+        c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "feeCurated" }),
+        c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "feeListed", args: [fee] }),
+    ]);
+    return { curated, listed, allowed: !curated || listed };
+}
 /** `PublicPolicy.setListed`: an asset a curated seed may hold. */
 export async function publicSetListed(c, policy, token, listed) {
     return write(c, policy, publicPolicyAbi, "setListed", [token, listed]);

package/dist/client.d.ts

@@ -70,8 +70,13 @@ export declare function createLogswapClient(args: {
  * the variance kernel and its two key fields are gone, so every pool id changed; `phiEff` is
  * `phiOf`; `getPool` lost `sigma2Ema`; `Initialize` lost two fields; the cut is
  * `MINT_FEE_PROTOCOL_CUT` / `setFeeParams`.
+ *
+ * **6** since 2026-10-09 (logswap-contract#58): the whole mint fee is the protocol's
+ * (`MINT_FEE_PROTOCOL_CUT` and `setFeeParams` are gone, decisions 058); the swap-fee tax at payout,
+ * `swapFeeTax` / `setSwapFeeTax` (060); `phi` is `swapFee` and `phiOf` `swapFeeOf` (059) — field
+ * names only, no pool id moved.
  */
-export declare const EXPECTED_VERSION = 5n;
+export declare const EXPECTED_VERSION = 6n;
 /**
  * The F manager's own tag (5 — the key's salt, pool names, the sponsor registry;
  * 4 was the income-only harvest cut).
@@ -83,7 +88,7 @@ export declare const EXPECTED_VERSION = 5n;
  * 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 declare const EXPECTED_F_VERSION = 23n;
+export declare const EXPECTED_F_VERSION = 25n;
 export declare function assertVersion(c: LogswapClient, expected?: bigint): Promise<void>;
 /**
  * The versions say the managers are the right code; this says the rest of the addresses belong

package/dist/client.js

@@ -64,8 +64,13 @@ function guardChain(wallet, pub) {
  * the variance kernel and its two key fields are gone, so every pool id changed; `phiEff` is
  * `phiOf`; `getPool` lost `sigma2Ema`; `Initialize` lost two fields; the cut is
  * `MINT_FEE_PROTOCOL_CUT` / `setFeeParams`.
+ *
+ * **6** since 2026-10-09 (logswap-contract#58): the whole mint fee is the protocol's
+ * (`MINT_FEE_PROTOCOL_CUT` and `setFeeParams` are gone, decisions 058); the swap-fee tax at payout,
+ * `swapFeeTax` / `setSwapFeeTax` (060); `phi` is `swapFee` and `phiOf` `swapFeeOf` (059) — field
+ * names only, no pool id moved.
  */
-export const EXPECTED_VERSION = 5n;
+export const EXPECTED_VERSION = 6n;
 /**
  * The F manager's own tag (5 — the key's salt, pool names, the sponsor registry;
  * 4 was the income-only harvest cut).
@@ -135,7 +140,15 @@ export const EXPECTED_VERSION = 5n;
 // next threshold `threshold(gen)`. A pad never retires; a public pool refuses `regenerate`.
 // 23: a harvest asks `may(Harvest)` and takes no terms and no cut (decisions 056): `onHarvest`, `HARVEST_CUT_MAX`,
 // `harvestCut`, `setHarvestCut` are gone; a pad's split (creator's cut, token burn) rides in the key's salt.
-export const EXPECTED_F_VERSION = 23n;
+// 24 (logswap-contract#58): the pot splits in quote — `Terms.burn` is quote spent on a buy-and-burn, the
+// rest deepens the bid, no buy-in, `Regenerated` is (pot, payee, toPayee, cut, burnt, deepened), a pad's
+// salt carries `burnShare` of the pot (057); the mint fee all to the collector (058); `phi` → `swapFee`,
+// `MINT_FEE()` → `mintFee()`, the policies' fee tiers, a canonical public pool (059).
+// 25 (logswap-contract#59): the views moved behind `extsload` (062) — this SDK reads them through the
+// lens (`fPool`, `getFPools`, `fBundleOf`, `fDividendOf`, `fLienOf`); the capped F pool, `FPoolKey.cap`
+// appended so every pool id moved (061); the lien, `lock` / `unlock` (063); θ is `logFloor`, θ₀ `refLogFloor`.
+// A breaking bump: raised in the same change.
+export const EXPECTED_F_VERSION = 25n;
 export async function assertVersion(c, expected = EXPECTED_VERSION) {
     const { cPoolManagerAbi, fPoolManagerAbi } = await import("./generated.js");
     // three independent reads: one round trip, not three in a row

package/dist/fees.d.ts

@@ -22,7 +22,7 @@ export declare function swapFeeOf(e: {
     baseIn: boolean;
     amountIn: bigint;
     amountOut: bigint;
-}, phi: bigint): bigint;
+}, swapFee: bigint): bigint;
 /** Swap fees paid over a window, in the market's quote units. */
 export interface SwapFeeWindow {
     fromBlock: bigint;

package/dist/fees.js

@@ -19,8 +19,8 @@ const YEAR_SECONDS = 31_536_000;
  * @deprecated The C `Swap` event carries its `fee` since C version 5 (decisions 050); read that.
  * This reconstruction from φ rounds where the contract does not, and is kept for older logs.
  */
-export function swapFeeOf(e, phi) {
-    return e.baseIn ? (e.amountOut * phi) / (WAD - phi) : (e.amountIn * phi) / (WAD + phi);
+export function swapFeeOf(e, swapFee) {
+    return e.baseIn ? (e.amountOut * swapFee) / (WAD - swapFee) : (e.amountIn * swapFee) / (WAD + swapFee);
 }
 /** Probes per round of {@link blockAtOrAfter}: 15 splits the bracket 16 ways. */
 const PROBES = 15n;