@logswap/sdk 0.5.71 → 0.5.73

package/dist/indexer.js

@@ -138,13 +138,13 @@ export async function indexerHealthy(url, signal) {
  * everywhere else, so a wrong id fails loudly instead of addressing the wrong pool.
  */
 export async function discoverMarketsIndexed(url, signal) {
-    const nodes = await gqlAll(url, "allInitializes", "poolId base quote tickSpacing phi x0 blockNumber txHash contractAddress", { signal });
+    const nodes = await gqlAll(url, "allInitializes", "poolId base quote tickSpacing swapFee x0 blockNumber txHash contractAddress", { signal });
     return nodes.map((n) => {
         const key = {
             base: n.base,
             quote: n.quote,
             tickSpacing: BigInt(n.tickSpacing),
-            phi: BigInt(n.phi),
+            swapFee: BigInt(n.swapFee), // rindexer names the column after the event's field: `swapFee` since C version 6 (logswap-be #40)
         };
         return {
             key,

package/dist/keys.d.ts

@@ -33,14 +33,15 @@ export interface PoolKey {
      * The swap fee, WAD, fixed for the life of the market: {@link FEE_MIN} (1 bp) ≤ φ ≤ {@link FEE_MAX} (1%),
      * or `0n`, which selects `DEFAULT_FEE` (2 bp) at read time. Four fields since C version 4
      *: `kappa` and `alpha` left with the variance kernel, and `phiMin` — a floor with
-     * nothing above it — became `phi`. Every pool id changed with the shape.
+     * nothing above it — became `phi`, named `swapFee` since C version 6 (decisions 059). The name
+     * is not part of the encoding: no pool id changed with it.
      */
-    phi: bigint;
+    swapFee: bigint;
 }
 /**
  * `poolId = keccak256(abi.encode(key))` — the primary key of the entire read model.
  *
- * Note the zero-vs-default caveat the Solidity type documents: a `phi` of `0` resolves to
+ * Note the zero-vs-default caveat the Solidity type documents: a `swapFee` of `0` resolves to
  * `DEFAULT_FEE` at READ time, so a key carrying `0n` and one carrying the resolved default are
  * DIFFERENT markets with different ids, even though they behave identically. Always address a
  * market by the key it was initialized with.

package/dist/keys.js

@@ -27,14 +27,14 @@ const POOL_KEY_ABI = [
             { name: "base", type: "address" },
             { name: "quote", type: "address" },
             { name: "tickSpacing", type: "int256" },
-            { name: "phi", type: "uint256" },
+            { name: "swapFee", type: "uint256" },
         ],
     },
 ];
 /**
  * `poolId = keccak256(abi.encode(key))` — the primary key of the entire read model.
  *
- * Note the zero-vs-default caveat the Solidity type documents: a `phi` of `0` resolves to
+ * Note the zero-vs-default caveat the Solidity type documents: a `swapFee` of `0` resolves to
  * `DEFAULT_FEE` at READ time, so a key carrying `0n` and one carrying the resolved default are
  * DIFFERENT markets with different ids, even though they behave identically. Always address a
  * market by the key it was initialized with.
@@ -45,7 +45,7 @@ export function poolId(key) {
             base: key.base,
             quote: key.quote,
             tickSpacing: key.tickSpacing,
-            phi: key.phi,
+            swapFee: key.swapFee,
         },
     ]));
 }

package/dist/pools.d.ts

@@ -36,11 +36,12 @@ export interface PoolState {
 /** Read a market's full state by key. */
 export declare function getPool(c: LogswapClient, key: PoolKey): Promise<PoolState>;
 /**
- * The market's fee: the key's `phi` with `0n` resolved to `DEFAULT_FEE`. Constant for the market's
- * life (C version 4, — `phiEff` and the variance kernel before). Reverts for a key
- * nobody initialized, which `discoverMarkets` relies on to drop a stale indexer's rows.
+ * The market's swap fee: the key's `swapFee` with `0n` resolved to `DEFAULT_FEE` — the manager's
+ * `swapFeeOf` (`phiOf` before C version 6). Constant for the market's life (C version 4 — `phiEff`
+ * and the variance kernel before). Reverts for a key nobody initialized, which `discoverMarkets`
+ * relies on to drop a stale indexer's rows. (`swapFeeOf` in `fees.ts` is the fee one swap paid.)
  */
-export declare function phiOf(c: LogswapClient, key: PoolKey): Promise<bigint>;
+export declare function marketSwapFee(c: LogswapClient, key: PoolKey): Promise<bigint>;
 /**
  * Price from the stored log-price. **Lossy** — `x` is exact and this is a float, so use it for
  * display and never for arithmetic you intend to send back on-chain.

package/dist/pools.js

@@ -27,15 +27,16 @@ export async function getPool(c, key) {
     return v;
 }
 /**
- * The market's fee: the key's `phi` with `0n` resolved to `DEFAULT_FEE`. Constant for the market's
- * life (C version 4, — `phiEff` and the variance kernel before). Reverts for a key
- * nobody initialized, which `discoverMarkets` relies on to drop a stale indexer's rows.
+ * The market's swap fee: the key's `swapFee` with `0n` resolved to `DEFAULT_FEE` — the manager's
+ * `swapFeeOf` (`phiOf` before C version 6). Constant for the market's life (C version 4 — `phiEff`
+ * and the variance kernel before). Reverts for a key nobody initialized, which `discoverMarkets`
+ * relies on to drop a stale indexer's rows. (`swapFeeOf` in `fees.ts` is the fee one swap paid.)
  */
-export async function phiOf(c, key) {
+export async function marketSwapFee(c, key) {
     return c.public.readContract({
         address: c.addresses.cPoolManager,
         abi: cPoolManagerAbi,
-        functionName: "phiOf",
+        functionName: "swapFeeOf",
         args: [key],
     });
 }
@@ -124,7 +125,7 @@ export async function discoverMarkets(c, opts = {}) {
             base: a.base,
             quote: a.quote,
             tickSpacing: a.tickSpacing,
-            phi: a.phi,
+            swapFee: a.swapFee,
         };
         return {
             key,

package/dist/positions.d.ts

@@ -110,8 +110,9 @@ export declare const MINT_FEE: bigint;
  * the position's own legs, so a mint's total quote pull is `positionQuote(p, x) + mintFee(p, x)`.
  *
  * Mirrors the manager's exemption cases: a DORMANT mint pays nothing — floor above spot, or a
- * capped class spot has already passed (`cap <= x`). Anything earning pays `MINT_FEE · L`, half
- * accrued through `F` to the LPs already earning, half to the protocol. This is NOT the swap fee:
+ * capped class spot has already passed (`cap <= x`). Anything earning pays `MINT_FEE · L`, all of
+ * it the protocol's since C version 6 (decisions 058); with no collector it goes through `F` to the
+ * LPs already earning, and with none earning it is not charged. This is NOT the swap fee:
  * that one is charged per unit of |Δ log p| on swaps; this is a flat charge on L, once, at mint.
  *
  * One rung of imprecision: for a floor or cap exactly AT spot the contract consults its `currentK`

package/dist/positions.js

@@ -136,8 +136,9 @@ export const MINT_FEE = 2n * 10n ** 14n;
  * the position's own legs, so a mint's total quote pull is `positionQuote(p, x) + mintFee(p, x)`.
  *
  * Mirrors the manager's exemption cases: a DORMANT mint pays nothing — floor above spot, or a
- * capped class spot has already passed (`cap <= x`). Anything earning pays `MINT_FEE · L`, half
- * accrued through `F` to the LPs already earning, half to the protocol. This is NOT the swap fee:
+ * capped class spot has already passed (`cap <= x`). Anything earning pays `MINT_FEE · L`, all of
+ * it the protocol's since C version 6 (decisions 058); with no collector it goes through `F` to the
+ * LPs already earning, and with none earning it is not charged. This is NOT the swap fee:
  * that one is charged per unit of |Δ log p| on swaps; this is a flat charge on L, once, at mint.
  *
  * One rung of imprecision: for a floor or cap exactly AT spot the contract consults its `currentK`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.71",
+  "version": "0.5.73",
   "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",

package/src/admin.ts

@@ -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 type { Address, Hash } from "viem";
@@ -25,13 +23,24 @@ function write(c: LogswapClient, address: Address, abi: readonly unknown[], func
   return wallet(c).writeContract({ address, abi, functionName, args, chain: c.wallet!.chain, account: c.wallet!.account! } as never);
 }
 
-/** The C manager's `setFeeParams(mintFeeProtocolCut)` — one cut. */
-export async function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash> {
-  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: LogswapClient): Promise<{ tax: bigint; max: bigint }> {
+  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: LogswapClient): Promise<bigint> {
-  return c.public.readContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "MINT_FEE_PROTOCOL_CUT" } as never) as Promise<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 async function setCSwapFeeTax(c: LogswapClient, taxWad: bigint): Promise<Hash> {
+  return write(c, c.addresses.cPoolManager, cPoolManagerAbi, "setSwapFeeTax", [taxWad]);
 }
 
 // ─── the registry: the LOG authority's, not the collector's ─────────────────
@@ -173,9 +182,10 @@ export async function registryKindOf(c: LogswapClient, policy: Address): Promise
 // ─── 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: LogswapClient,
@@ -225,6 +235,29 @@ export async function policyQuoteAllowed(c: LogswapClient, policy: Address, quot
   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: LogswapClient, policy: Address, fee: bigint, listed: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, curated: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, fee: bigint): Promise<{ curated: boolean; listed: boolean; allowed: boolean }> {
+  const [curated, listed] = await Promise.all([
+    c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "feeCurated" } as never) as Promise<boolean>,
+    c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "feeListed", args: [fee] } as never) as Promise<boolean>,
+  ]);
+  return { curated, listed, allowed: !curated || listed };
+}
+
 /** `PublicPolicy.setListed`: an asset a curated seed may hold. */
 export async function publicSetListed(c: LogswapClient, policy: Address, token: Address, listed: boolean): Promise<Hash> {
   return write(c, policy, publicPolicyAbi, "setListed", [token, listed]);

package/src/client.ts

@@ -108,8 +108,13 @@ function guardChain(wallet: WalletClient, pub: PublicClient): WalletClient {
  * 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).
@@ -179,7 +184,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: LogswapClient, expected = EXPECTED_VERSION): Promise<void> {
   const { cPoolManagerAbi, fPoolManagerAbi } = await import("./generated.js");

package/src/fees.ts

@@ -24,8 +24,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: { baseIn: boolean; amountIn: bigint; amountOut: bigint }, phi: bigint): bigint {
-  return e.baseIn ? (e.amountOut * phi) / (WAD - phi) : (e.amountIn * phi) / (WAD + phi);
+export function swapFeeOf(e: { baseIn: boolean; amountIn: bigint; amountOut: bigint }, swapFee: bigint): bigint {
+  return e.baseIn ? (e.amountOut * swapFee) / (WAD - swapFee) : (e.amountIn * swapFee) / (WAD + swapFee);
 }
 
 /** Swap fees paid over a window, in the market's quote units. */