@logswap/sdk 0.5.50 → 0.5.52

package/dist/index.d.ts

@@ -19,5 +19,6 @@ export * from "./onboard.js";
 export * from "./indexer.js";
 export * from "./tokencache.js";
 export * from "./fpool.js";
+export * from "./fees.js";
 export { cPoolManagerAbi, fPoolManagerAbi, logswapLensAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 export * from "./admin.js";

package/dist/index.js

@@ -19,5 +19,6 @@ export * from "./onboard.js";
 export * from "./indexer.js";
 export * from "./tokencache.js";
 export * from "./fpool.js";
+export * from "./fees.js";
 export { cPoolManagerAbi, fPoolManagerAbi, logswapLensAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 export * from "./admin.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.50",
+  "version": "0.5.52",
   "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",
@@ -25,6 +25,7 @@
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist src/generated.ts",
     "test": "vitest run",
+    "test:isolated": "bash scripts/test-isolated.sh",
     "test:watch": "vitest",
     "prepublishOnly": "npm run codegen && npm run build"
   },

package/src/admin.ts

@@ -1,19 +1,20 @@
 /**
- * admin — the protocol's (feeCollector's) writes: the protocol's cut of the mint fee on both
- * managers, the policies a pool of each kind may be born with, the policies' own numbers, and the
- * two-step collector handover. Plain writes to the managers and the policies; no router.
+ * admin — the protocol's writes: the C manager's cut of the mint fee (the F manager's is a
+ * constant, decisions 049), 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.
  *
  * One vocabulary (decisions 040): both managers call the protocol's cut of the mint fee
- * `MINT_FEE_PROTOCOL_CUT` and set it through `setFeeParams(uint256)` — one cut each since C
- * version 4 / F version 14. The harvest's cut is the policy's answer at every harvest (decisions
- * 044), set on the policy (`setHarvestCut`) and capped by the manager (`HARVEST_CUT_MAX`); the
- * release's protocol share likewise (`POT_CUT_MAX`).
+ * `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 (decisions 044), set on the
+ * policy (`setHarvestCut`) and capped by the manager (`HARVEST_CUT_MAX`); the release's
+ * protocol share likewise (`POT_CUT_MAX`).
  */
 
 import type { Address, Hash } from "viem";
 import type { LogswapClient } from "./client.js";
 import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, publicPolicyAbi } from "./generated.js";
-import { F_KIND, bytes32ToText, fPolicyBaseAbi, textToBytes32, type FPoolKind } from "./fpool.js";
+import { bytes32ToText, fPolicyBaseAbi, fPoolKindOfPolicy, textToBytes32, type FPoolKind } from "./fpool.js";
 
 function wallet(c: LogswapClient) {
   if (!c.wallet) throw new Error("a wallet client is required");
@@ -28,9 +29,9 @@ function write(c: LogswapClient, address: Address, abi: readonly unknown[], func
 export async function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash> {
   return write(c, c.addresses.cPoolManager, cPoolManagerAbi, "setFeeParams", [mintFeeProtocolCutWad]);
 }
-/** The F manager's `setFeeParams(mintFeeProtocolCut)` — one cut, the C manager's shape (F version 14). */
-export async function setFeeParams(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash> {
-  return write(c, c.addresses.fPoolManager as Address, fPoolManagerAbi, "setFeeParams", [mintFeeProtocolCutWad]);
+/** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18 (decisions 049); 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>;
 }
 
 // ─── the registry (decisions 046): the LOG authority's, not the collector's ─────────────────
@@ -47,16 +48,18 @@ export async function policyRegistryOf(c: LogswapClient): Promise<Address> {
   return (await c.public.readContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "registry" } as never)) as Address;
 }
 
-/** Whether `policy` is approved for pools of `kind` now — listed and not yet sunset. True everywhere on a deployment with no registry. */
-export async function policyApproved(c: LogswapClient, kind: FPoolKind, policy: Address): Promise<boolean> {
+/** Whether `policy` is approved now — listed and not yet sunset. True everywhere on a deployment with no registry. */
+export async function policyApproved(c: LogswapClient, policy: Address): Promise<boolean> {
   const registry = await policyRegistryOf(c);
   if (registry === ZERO) return true;
-  return c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "isApproved", args: [F_KIND[kind], policy] } as never) as Promise<boolean>;
+  return c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "isApproved", args: [policy] } as never) as Promise<boolean>;
 }
 
-/** One policy on a kind's list, as the registry holds it. */
+/** One policy on the registry's list, with what it says it is. */
 export interface RegistryEntry {
   policy: Address;
+  /** The policy's own `kind()` tag (decisions 049) — what a pool born under it is. */
+  kind: FPoolKind;
   name: string;
   /** The block it closes to new pools from; 0 = open. */
   until: bigint;
@@ -64,18 +67,26 @@ export interface RegistryEntry {
   approved: boolean;
 }
 
-/** Every policy listed for `kind`, sunset ones included — what a create form's dropdown reads. Empty with no registry. */
-export async function registryPolicies(c: LogswapClient, kind: FPoolKind): Promise<RegistryEntry[]> {
+/**
+ * Every policy listed, sunset ones included — one flat list (decisions 049), each with the kind
+ * it says it is; `kind` narrows it to one, which is what a create form's dropdown reads. Empty
+ * with no registry.
+ */
+export async function registryPolicies(c: LogswapClient, kind?: FPoolKind): Promise<RegistryEntry[]> {
   const registry = await policyRegistryOf(c);
   if (registry === ZERO) return [];
-  const list = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "policiesOf", args: [F_KIND[kind]] } as never)) as readonly Address[];
+  const list = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "policies" } as never)) as readonly Address[];
   const block = await c.public.getBlockNumber();
-  return Promise.all(
+  const all = await Promise.all(
     list.map(async (policy) => {
-      const [listed, until, , name] = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "entries", args: [F_KIND[kind], policy] } as never)) as [boolean, bigint, number, `0x${string}`];
-      return { policy, name: bytes32ToText(name), until, approved: listed && (until === 0n || block < until) };
+      const [[listed, until, , name], tag] = await Promise.all([
+        c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "entries", args: [policy] } as never) as Promise<[boolean, bigint, number, `0x${string}`]>,
+        fPoolKindOfPolicy(c, policy),
+      ]);
+      return { policy, kind: tag, name: bytes32ToText(name), until, approved: listed && (until === 0n || block < until) };
     }),
   );
+  return kind ? all.filter((e) => e.kind === kind) : all;
 }
 
 /** The registry's owner — the LOG authority — and the proposed next one. */
@@ -95,19 +106,19 @@ async function registryWrite(c: LogswapClient, functionName: string, args: reado
   return write(c, registry, policyRegistryAbi, functionName, args);
 }
 
-/** `PolicyRegistry.approve`: list `policy` for pools of `kind`, under `name` (at most 31 bytes). Again renames it and clears its sunset. The owner's. */
-export async function registryApprove(c: LogswapClient, kind: FPoolKind, policy: Address, name: string): Promise<Hash> {
-  return registryWrite(c, "approve", [F_KIND[kind], policy, textToBytes32(name)]);
+/** `PolicyRegistry.approve`: list `policy` under `name` (at most 31 bytes). Again renames it and clears its sunset. The owner's. */
+export async function registryApprove(c: LogswapClient, policy: Address, name: string): Promise<Hash> {
+  return registryWrite(c, "approve", [policy, textToBytes32(name)]);
 }
 
-/** `PolicyRegistry.sunset`: close `policy` to new pools of `kind` from `untilBlock` on; 0 reopens. The owner's. */
-export async function registrySunset(c: LogswapClient, kind: FPoolKind, policy: Address, untilBlock: bigint): Promise<Hash> {
-  return registryWrite(c, "sunset", [F_KIND[kind], policy, untilBlock]);
+/** `PolicyRegistry.sunset`: close `policy` to new pools from `untilBlock` on; 0 reopens. The owner's. */
+export async function registrySunset(c: LogswapClient, policy: Address, untilBlock: bigint): Promise<Hash> {
+  return registryWrite(c, "sunset", [policy, untilBlock]);
 }
 
-/** `PolicyRegistry.revoke`: remove `policy` from `kind`'s list at once. Live pools are untouched. The owner's. */
-export async function registryRevoke(c: LogswapClient, kind: FPoolKind, policy: Address): Promise<Hash> {
-  return registryWrite(c, "revoke", [F_KIND[kind], policy]);
+/** `PolicyRegistry.revoke`: remove `policy` from the list at once. Live pools are untouched. The owner's. */
+export async function registryRevoke(c: LogswapClient, policy: Address): Promise<Hash> {
+  return registryWrite(c, "revoke", [policy]);
 }
 
 /** The registry owner's two-step handover. */
@@ -120,19 +131,20 @@ export async function registryAcceptOwner(c: LogswapClient): Promise<Hash> {
 
 /**
  * Approve or revoke, the F version 15–16 shape kept for callers: `approved` true is
- * {@link registryApprove} under the kind's name, false is {@link registryRevoke}.
+ * {@link registryApprove} under the policy's own tag as its name, false is {@link registryRevoke}.
  */
-export async function setPolicyApproved(c: LogswapClient, kind: FPoolKind, policy: Address, approved: boolean): Promise<Hash> {
-  return approved ? registryApprove(c, kind, policy, kind) : registryRevoke(c, kind, policy);
+export async function setPolicyApproved(c: LogswapClient, policy: Address, approved: boolean): Promise<Hash> {
+  return approved ? registryApprove(c, policy, await fPoolKindOfPolicy(c, policy)) : registryRevoke(c, policy);
 }
 
 /**
- * Move a pool to another policy the registry approves for its kind (decisions 046): the registry
- * owner's alone. The new policy takes the authority from the old; the operator and the lists
- * void; no swap lands in the block.
+ * Move a pool to another approved policy of the same kind (decisions 046, 049): the registry
+ * owner's alone, orchestrated on the registry — `migrate(manager, poolId, to)`. The new policy
+ * takes the authority and the name from the old; the operator and the lists void; no swap lands
+ * in the block.
  */
 export async function fPoolMigrate(c: LogswapClient, a: { poolId: `0x${string}`; to: Address }): Promise<Hash> {
-  return write(c, c.addresses.fPoolManager as Address, fPoolManagerAbi, "migrate", [a.poolId, a.to]);
+  return registryWrite(c, "migrate", [c.addresses.fPoolManager as Address, a.poolId, a.to]);
 }
 
 // ─── the policies' numbers (the collector's; each bounded where it reaches the manager) ─────
@@ -156,6 +168,25 @@ export async function polSetRules(c: LogswapClient, policy: Address, s: { keepQu
   return write(c, policy, polPolicyAbi, "setRules", [s.keepQuote, s.minQuoteAtSeed]);
 }
 
+/** `setQuoteListed` on any protocol policy: a quote a pool of that kind may be born against while it curates quotes. The collector's. */
+export async function policySetQuoteListed(c: LogswapClient, policy: Address, quote: Address, listed: boolean): Promise<Hash> {
+  return write(c, policy, fPolicyBaseAbi, "setQuoteListed", [quote, listed]);
+}
+
+/** `setQuoteCurated` on any protocol policy: on, a birth against an unlisted quote is refused. The collector's. */
+export async function policySetQuoteCurated(c: LogswapClient, policy: Address, curated: boolean): Promise<Hash> {
+  return write(c, policy, fPolicyBaseAbi, "setQuoteCurated", [curated]);
+}
+
+/** Whether `quote` passes `policy`'s birth check now: listed, or the policy does not curate quotes. */
+export async function policyQuoteAllowed(c: LogswapClient, policy: Address, quote: Address): Promise<{ curated: boolean; listed: boolean; allowed: boolean }> {
+  const [curated, listed] = await Promise.all([
+    c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "quoteCurated" } as never) as Promise<boolean>,
+    c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "quoteListed", args: [quote] } 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

@@ -134,7 +134,7 @@ export const EXPECTED_VERSION = 4n;
 // is the policy at birth, `migrate` moves a pool for the registry's owner; `stamp` / `setAsks` are
 // the policy's; the desk's `setAllowed` / `isAllowed` are `setMinters` / `setTakers` / `isMinter` /
 // `isTaker`; a pad and a POL hold one base (`OneBase`).
-export const EXPECTED_F_VERSION = 17n;
+export const EXPECTED_F_VERSION = 18n;
 
 export async function assertVersion(c: LogswapClient, expected = EXPECTED_VERSION): Promise<void> {
   const { cPoolManagerAbi } = await import("./generated.js");

package/src/fees.ts

@@ -0,0 +1,103 @@
+/**
+ * fees.ts — swap fees over a window, from `Swap` logs.
+ *
+ * `F` cannot answer "what did takers pay this week": it is per unit of L, it carries the mint-fee
+ * credits as well as swap fees, and it has no window. Each `Swap` event carries the quote leg and
+ * φ, and the fee is a fixed fraction of that leg, so the sum over a window is exact up to rounding:
+ *
+ *   quote in  (price up):   the curve takes q/(1+φ), the fee is q·φ/(1+φ)
+ *   quote out (price down): the curve releases q/(1−φ), the fee is q·φ/(1−φ)
+ *
+ * Both equal φ·L·|Δx| summed over the swap's segments — the same φ·|dx| per unit L that `F` books.
+ */
+
+import type { LogswapClient } from "./client.js";
+import { cPoolManagerAbi } from "./generated.js";
+import type { DiscoveredMarket } from "./pools.js";
+
+const WAD = 10n ** 18n;
+const YEAR_SECONDS = 31_536_000;
+
+/** The fee one swap paid, in quote, from its `Swap` event's fields. */
+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);
+}
+
+/** Swap fees paid over a window, in the market's quote units. */
+export interface SwapFeeWindow {
+  fromBlock: bigint;
+  toBlock: bigint;
+  /** Window start, unix seconds — `since`, or the first block's timestamp, never before the market opened. */
+  from: bigint;
+  /** Window end, unix seconds — the last block's timestamp. */
+  to: bigint;
+  seconds: bigint;
+  swapFees: bigint;
+  swaps: number;
+}
+
+/** The first block with timestamp ≥ `t`, by bisection over `[lo, hi]`; `hi` when none is earlier. */
+export async function blockAtOrAfter(c: LogswapClient, t: bigint, lo: bigint, hi: bigint): Promise<bigint> {
+  while (lo < hi) {
+    const mid = (lo + hi) / 2n;
+    if ((await c.public.getBlock({ blockNumber: mid })).timestamp < t) lo = mid + 1n;
+    else hi = mid;
+  }
+  return lo;
+}
+
+/**
+ * Sum the swap fees of market `m` over a window: from `since` (unix seconds) or `fromBlock`, to
+ * `toBlock` (default latest). Either start is clamped to the market's opening, so a period longer
+ * than the market's life measures its whole life and `seconds` says how long that was.
+ */
+export async function swapFees(
+  c: LogswapClient,
+  m: DiscoveredMarket,
+  opts: { since?: bigint; fromBlock?: bigint; toBlock?: bigint } = {},
+): Promise<SwapFeeWindow> {
+  const toBlock = opts.toBlock ?? (await c.public.getBlockNumber());
+  const [opened, last] = await Promise.all([
+    c.public.getBlock({ blockNumber: m.blockNumber }),
+    c.public.getBlock({ blockNumber: toBlock }),
+  ]);
+
+  let fromBlock: bigint;
+  let from: bigint;
+  if (opts.since !== undefined && opts.since > opened.timestamp) {
+    fromBlock = await blockAtOrAfter(c, opts.since, m.blockNumber, toBlock);
+    from = opts.since;
+  } else if (opts.fromBlock !== undefined && opts.fromBlock > m.blockNumber) {
+    fromBlock = opts.fromBlock;
+    from = (await c.public.getBlock({ blockNumber: fromBlock })).timestamp;
+  } else {
+    fromBlock = m.blockNumber;
+    from = opened.timestamp;
+  }
+
+  type Ev = Extract<(typeof cPoolManagerAbi)[number], { type: "event"; name: "Swap" }>;
+  const ev = cPoolManagerAbi.find((x): x is Ev => x.type === "event" && x.name === "Swap");
+  if (!ev) throw new Error("logswap: Swap event missing from the generated ABI");
+
+  const logs = fromBlock > toBlock
+    ? []
+    : await c.public.getLogs({ address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock });
+
+  let fees = 0n;
+  for (const l of logs) fees += swapFeeOf({ baseIn: l.args.baseIn!, amountIn: l.args.amountIn!, amountOut: l.args.amountOut! }, l.args.phi!);
+
+  const to = last.timestamp;
+  return { fromBlock, toBlock, from, to, seconds: to > from ? to - from : 0n, swapFees: fees, swaps: logs.length };
+}
+
+/**
+ * The window's swap fees over the market's CURRENT active L, annualised linearly over the window.
+ * A fraction: 0.12 is 12%. Linear: fees are paid out, so none compound.
+ *
+ * Per unit of L. An uncapped position is worth L·(x − ξ + 1), so its return on capital is this
+ * divided by (x − ξ + 1).
+ */
+export function swapFeeApy(w: Pick<SwapFeeWindow, "swapFees" | "seconds">, lActive: bigint): number {
+  if (w.seconds <= 0n || lActive <= 0n) return 0;
+  return (Number(w.swapFees) / Number(lActive)) * (YEAR_SECONDS / Number(w.seconds));
+}