@logswap/sdk 0.5.44 → 0.5.46

package/dist/index.d.ts

@@ -19,5 +19,5 @@ export * from "./onboard.js";
 export * from "./indexer.js";
 export * from "./tokencache.js";
 export * from "./fpool.js";
-export { cPoolManagerAbi, fPoolManagerAbi, logswapLensAbi, logswapRouterAbi } from "./generated.js";
+export { cPoolManagerAbi, fPoolManagerAbi, logswapLensAbi, logswapRouterAbi, padHookAbi, polHookAbi, privateHookAbi, publicHookAbi } from "./generated.js";
 export * from "./admin.js";

package/dist/index.js

@@ -19,5 +19,5 @@ export * from "./onboard.js";
 export * from "./indexer.js";
 export * from "./tokencache.js";
 export * from "./fpool.js";
-export { cPoolManagerAbi, fPoolManagerAbi, logswapLensAbi, logswapRouterAbi } from "./generated.js";
+export { cPoolManagerAbi, fPoolManagerAbi, logswapLensAbi, logswapRouterAbi, padHookAbi, polHookAbi, privateHookAbi, publicHookAbi } from "./generated.js";
 export * from "./admin.js";

package/dist/indexer.js

@@ -100,7 +100,7 @@ export async function indexerHealthy(url, signal) {
  */
 export async function discoverMarketsIndexed(url, signal) {
     const q = `{ allInitializes(first: 1000) { nodes {
-    poolId base quote tickSpacing phiMin kappa alpha x0 blockNumber txHash
+    poolId base quote tickSpacing phi x0 blockNumber txHash
   } } }`;
     const d = await gql(url, q, undefined, signal);
     return d.allInitializes.nodes.map((n) => {
@@ -108,9 +108,7 @@ export async function discoverMarketsIndexed(url, signal) {
             base: n.base,
             quote: n.quote,
             tickSpacing: BigInt(n.tickSpacing),
-            phiMin: BigInt(n.phiMin),
-            kappa: BigInt(n.kappa),
-            alpha: BigInt(n.alpha),
+            phi: BigInt(n.phi),
         };
         return {
             key,
@@ -142,7 +140,7 @@ export async function discoverMarketsBest(c, url, signal) {
                         await c.public.readContract({
                             address: c.addresses.cPoolManager,
                             abi: cPoolManagerAbi,
-                            functionName: "phiEff",
+                            functionName: "phiOf",
                             args: [m.key],
                         });
                         return m;

package/dist/keys.d.ts

@@ -20,18 +20,19 @@ export interface PoolKey {
     quote: Address;
     /** Log-tick spacing, WAD. The LP-boundary ladder — position floors and caps. */
     tickSpacing: bigint;
-    /** Fee floor, WAD. `0n` selects `DEFAULT_FEE_MIN` (2 bp) at read time. */
-    phiMin: bigint;
-    /** Variance-fee coefficient, WAD. `0n` disables the dynamic fee. */
-    kappa: bigint;
-    /** EMA decay, WAD. `0n` selects `DEFAULT_ALPHA` (1/2) at read time. */
-    alpha: bigint;
+    /**
+     * The swap fee, WAD, fixed for the life of the market: `FEE_MIN` (1 bp) ≤ φ ≤ `FEE_MAX` (25%),
+     * or `0n`, which selects `DEFAULT_FEE` (2 bp) at read time. Four fields since C version 4
+     * (decisions 042): `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.
+     */
+    phi: bigint;
 }
 /**
  * `poolId = keccak256(abi.encode(key))` — the primary key of the entire read model.
  *
- * Note the zero-vs-default caveat the Solidity type documents: `phiMin` and `alpha` of `0` resolve
- * to their defaults at READ time, so a key carrying `0n` and one carrying the resolved default are
+ * Note the zero-vs-default caveat the Solidity type documents: a `phi` 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

@@ -18,17 +18,15 @@ const POOL_KEY_ABI = [
             { name: "base", type: "address" },
             { name: "quote", type: "address" },
             { name: "tickSpacing", type: "int256" },
-            { name: "phiMin", type: "uint256" },
-            { name: "kappa", type: "uint256" },
-            { name: "alpha", type: "uint256" },
+            { name: "phi", 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: `phiMin` and `alpha` of `0` resolve
- * to their defaults at READ time, so a key carrying `0n` and one carrying the resolved default are
+ * Note the zero-vs-default caveat the Solidity type documents: a `phi` 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.
  */
@@ -38,9 +36,7 @@ export function poolId(key) {
             base: key.base,
             quote: key.quote,
             tickSpacing: key.tickSpacing,
-            phiMin: key.phiMin,
-            kappa: key.kappa,
-            alpha: key.alpha,
+            phi: key.phi,
         },
     ]));
 }

package/dist/liquidity.d.ts

@@ -72,6 +72,8 @@ export interface ZapArgs extends WriteOptions {
     /** Fund entirely from base (true) or entirely from quote (false). */
     fundWithBase: boolean;
     amountIn: bigint;
+    /** The least the swap leg may return (contracts 7c82eed, decisions 043): the zap's own slippage bound, as `swapExactIn`'s. 0 = unbounded. */
+    minSwapOut?: bigint;
     targetFloor: bigint;
     cap?: bigint;
     L: bigint;

package/dist/liquidity.js

@@ -94,6 +94,7 @@ export async function zapIn(c, a) {
             a.key,
             a.fundWithBase,
             a.amountIn,
+            a.minSwapOut ?? 0n,
             a.targetFloor,
             a.cap ?? NO_CAP,
             a.L,

package/dist/pools.d.ts

@@ -26,9 +26,8 @@ export interface PoolState {
     reserveQuote: bigint;
     /** Fee-per-unit-L accumulator: $\phi \cdot \mathrm{TV}(\log p)$. */
     F: bigint;
-    /** Quadratic variation of log-price, $\Sigma = \int (dx)^2$. */
+    /** Quadratic variation of log-price, $\Sigma = \sum_{\text{swaps}} (\Delta x_{\text{swap}})^2$ — one term per swap (decisions 042). */
     bigSigma: bigint;
-    sigma2Ema: bigint;
     currentK: bigint;
     protocolOwed: bigint;
     minBackstopL: bigint;
@@ -36,8 +35,12 @@ export interface PoolState {
 }
 /** Read a market's full state by key. */
 export declare function getPool(c: LogswapClient, key: PoolKey): Promise<PoolState>;
-/** The effective fee right now: $\max(\phi_{\min}, \kappa\sqrt{\sigma^2_{\text{ema}}})$, capped. */
-export declare function phiEff(c: LogswapClient, key: PoolKey): Promise<bigint>;
+/**
+ * The market's fee: the key's `phi` with `0n` resolved to `DEFAULT_FEE`. Constant for the market's
+ * life (C version 4, decisions 042 — `phiEff` and the variance kernel before). Reverts for a key
+ * nobody initialized, which `discoverMarkets` relies on to drop a stale indexer's rows.
+ */
+export declare function phiOf(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

@@ -25,12 +25,16 @@ export async function getPool(c, key) {
     });
     return v;
 }
-/** The effective fee right now: $\max(\phi_{\min}, \kappa\sqrt{\sigma^2_{\text{ema}}})$, capped. */
-export async function phiEff(c, key) {
+/**
+ * The market's fee: the key's `phi` with `0n` resolved to `DEFAULT_FEE`. Constant for the market's
+ * life (C version 4, decisions 042 — `phiEff` and the variance kernel before). Reverts for a key
+ * nobody initialized, which `discoverMarkets` relies on to drop a stale indexer's rows.
+ */
+export async function phiOf(c, key) {
     return c.public.readContract({
         address: c.addresses.cPoolManager,
         abi: cPoolManagerAbi,
-        functionName: "phiEff",
+        functionName: "phiOf",
         args: [key],
     });
 }
@@ -88,9 +92,7 @@ export async function discoverMarkets(c, opts = {}) {
             base: a.base,
             quote: a.quote,
             tickSpacing: a.tickSpacing,
-            phiMin: a.phiMin,
-            kappa: a.kappa,
-            alpha: a.alpha,
+            phi: a.phi,
         };
         return {
             key,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.44",
+  "version": "0.5.46",
   "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,36 +1,89 @@
 /**
- * admin — the protocol's (feeCollector's) writes: the protocol's cuts, the harvest-cut exemption,
- * and the two-step collector handover, on both managers. Plain writes to the managers; no router.
- * One vocabulary (decisions 040): the C manager's `setProtocolFeeCut` / `PROTOCOL_FEE_CUT` are the
- * same words as F's `setFeeParams` / `MINT_FEE_PROTOCOL_CUT` until C version 4 renames them.
+ * admin — the protocol's (feeCollector's) writes: the protocol's cut of the mint fee on both
+ * managers, the hooks a pool of each kind may be born with, the hooks' own numbers, and the
+ * two-step collector handover. Plain writes to the managers and the hooks; 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 hook's answer at every harvest (decisions
+ * 044), set on the hook (`setHarvestCut`) and capped by the manager (`HARVEST_CUT_MAX`); the
+ * release's protocol share likewise (`POT_CUT_MAX`).
  */
 
-import type { Address, Hash, Hex } from "viem";
+import type { Address, Hash } from "viem";
 import type { LogswapClient } from "./client.js";
-import { cPoolManagerAbi, fPoolManagerAbi } from "./generated.js";
+import { cPoolManagerAbi, fPoolManagerAbi, padHookAbi, polHookAbi, publicHookAbi } from "./generated.js";
+import { F_KIND, fHookBaseAbi, type FPoolKind } from "./fpool.js";
 
 function wallet(c: LogswapClient) {
   if (!c.wallet) throw new Error("a wallet client is required");
   return c.wallet;
 }
 
-export async function setProtocolFeeCut(c: LogswapClient, cutWad: bigint): Promise<Hash> {
-  return wallet(c).writeContract({ address: c.addresses.cPoolManager, abi: cPoolManagerAbi, functionName: "setProtocolFeeCut", args: [cutWad], chain: c.wallet!.chain, account: c.wallet!.account! } as never);
+function write(c: LogswapClient, address: Address, abi: readonly unknown[], functionName: string, args: readonly unknown[]): Promise<Hash> {
+  return wallet(c).writeContract({ address, abi, functionName, args, chain: c.wallet!.chain, account: c.wallet!.account! } as never);
 }
-export async function setFeeParams(c: LogswapClient, mintFeeProtocolCutWad: bigint, harvestProtocolCutWad: bigint): Promise<Hash> {
-  return wallet(c).writeContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "setFeeParams", args: [mintFeeProtocolCutWad, harvestProtocolCutWad], 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 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]);
+}
+
+/**
+ * Approve a hook for pools of `kind` to be born with, or withdraw the approval (decisions 041,
+ * 044). Read at `initialize` and never again: a live pool keeps its hook.
+ */
+export async function setHookApproved(c: LogswapClient, kind: FPoolKind, hook: Address, approved: boolean): Promise<Hash> {
+  return write(c, c.addresses.fPoolManager as Address, fPoolManagerAbi, "setHookApproved", [F_KIND[kind], hook, approved]);
+}
+
+/** Whether `hook` is approved for pools of `kind`. */
+export async function hookApproved(c: LogswapClient, kind: FPoolKind, hook: Address): Promise<boolean> {
+  return c.public.readContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "hookApproved", args: [F_KIND[kind], hook] } as never) as Promise<boolean>;
 }
-/** Waive the protocol's cut of harvested income for one pool (`HARVEST_PROTOCOL_CUT`; F version 13 — `setHarvestFeeExempt` before). */
-export async function setHarvestCutExempt(c: LogswapClient, poolId: Hex, exempt: boolean): Promise<Hash> {
-  return wallet(c).writeContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "setHarvestCutExempt", args: [poolId, exempt], chain: c.wallet!.chain, account: c.wallet!.account! } as never);
+
+// ─── the hooks' numbers (the collector's; each bounded where it reaches the manager) ─────
+
+/** The protocol's rate on the income part of every harvest under `hook`, WAD ≤ `HARVEST_CUT_MAX`. */
+export async function setHarvestCut(c: LogswapClient, hook: Address, rateWad: bigint): Promise<Hash> {
+  return write(c, hook, fHookBaseAbi, "setHarvestCut", [rateWad]);
 }
+
+/** `PadHook.setSchedule`: `T(0)`, the rung's growth, the creator's and the protocol's shares of the pot (≤ `POT_CUT_MAX`), the burn per rung (≤ `BURN_MAX`). */
+export async function padSetSchedule(
+  c: LogswapClient,
+  hook: Address,
+  s: { thresholdBase: bigint; thresholdGrowth: bigint; creatorShare: bigint; protocolShare: bigint; burnPerRung: bigint },
+): Promise<Hash> {
+  return write(c, hook, padHookAbi, "setSchedule", [s.thresholdBase, s.thresholdGrowth, s.creatorShare, s.protocolShare, s.burnPerRung]);
+}
+
+/** `PolHook.setPolicy`: what every harvest leaves in the bid and what a relaunch's seed must bring, WAD fractions of L. */
+export async function polSetPolicy(c: LogswapClient, hook: Address, s: { keepQuote: bigint; minQuoteAtSeed: bigint }): Promise<Hash> {
+  return write(c, hook, polHookAbi, "setPolicy", [s.keepQuote, s.minQuoteAtSeed]);
+}
+
+/** `PublicHook.setListed`: an asset a curated seed may hold. */
+export async function publicSetListed(c: LogswapClient, hook: Address, token: Address, listed: boolean): Promise<Hash> {
+  return write(c, hook, publicHookAbi, "setListed", [token, listed]);
+}
+
+/** `PublicHook.setCurated`: whether every public seed is checked against the list. */
+export async function publicSetCurated(c: LogswapClient, hook: Address, curated: boolean): Promise<Hash> {
+  return write(c, hook, publicHookAbi, "setCurated", [curated]);
+}
+
 export async function proposeCollector(c: LogswapClient, side: "C" | "F", next: Address): Promise<Hash> {
   const address = side === "C" ? c.addresses.cPoolManager : (c.addresses.fPoolManager as Address);
   const abi = side === "C" ? cPoolManagerAbi : fPoolManagerAbi;
-  return wallet(c).writeContract({ address, abi, functionName: "proposeCollector", args: [next], chain: c.wallet!.chain, account: c.wallet!.account! } as never);
+  return write(c, address, abi, "proposeCollector", [next]);
 }
 export async function acceptCollector(c: LogswapClient, side: "C" | "F"): Promise<Hash> {
   const address = side === "C" ? c.addresses.cPoolManager : (c.addresses.fPoolManager as Address);
   const abi = side === "C" ? cPoolManagerAbi : fPoolManagerAbi;
-  return wallet(c).writeContract({ address, abi, functionName: "acceptCollector", args: [], chain: c.wallet!.chain, account: c.wallet!.account! } as never);
+  return write(c, address, abi, "acceptCollector", []);
 }

package/src/client.ts

@@ -23,6 +23,14 @@ export interface LogswapAddresses {
    * deployment predating it will not carry the address; every F-pool call needs it.
    */
   fPoolManager?: Address;
+  /**
+   * The protocol's four F hooks, one per kind (decisions 044): every F pool names one in its key,
+   * and the pool's roles, gates and terms live on it. A deployment predating them carries none.
+   */
+  publicHook?: Address;
+  privateHook?: Address;
+  polHook?: Address;
+  padHook?: Address;
   /** Optional — the router falls back to plain approvals when absent. */
   permit2?: Address;
 }
@@ -58,8 +66,13 @@ export function createLogswapClient(args: {
  * **3** since 2026-09-03 (contracts `d8406fb`): `burnById` and `update` take an `owner`, `update`
  * mints to `to`, `positions()` returns `aps` as uint128 — and a returned quote flow now carries the
  * swept fees (decisions 018), which is why `exit`'s settle-to-one-asset math changed with it.
+ *
+ * **4** since 2026-09-18 (decisions 042 + 040): `PoolKey` is `(base, quote, tickSpacing, phi)` —
+ * 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`.
  */
-export const EXPECTED_VERSION = 3n;
+export const EXPECTED_VERSION = 4n;
 /**
  * The F manager's own tag (contracts 25a7bcf: 5 — the key's salt, pool names, the sponsor registry;
  * 4 was the income-only harvest cut).
@@ -97,7 +110,16 @@ export const EXPECTED_VERSION = 3n;
 // is voided by the handover of the role that granted it); `setLegs` needs a generation to have
 // lived (`gen > 0`); `initialize` refuses a codeless base and `mint` refuses `to = address(0)`
 // on both managers. Layout unchanged.
-export const EXPECTED_F_VERSION = 13n;
+// 14 (2026-09-20): the hook (decisions 041) — `FPoolKey.hook`, every pool id moves; `dissolve` is
+// `retire`, `regenerate` releases the dead shares' pot, `harvestable`/`unharvested` are the
+// readouts; `feePerL`, `edgePerL`, `HARVEST_PROTOCOL_CUT`, `harvestCutExempt` are gone.
+// 15 (2026-09-20): the hook answers every question (decisions 044) — `FPoolKey.authority` is
+// `creator` (every pool id moves again); the roles, gates and list are the pool's HOOK's
+// (`FHookBase` / `PrivateHook`), not the manager's: `getPool` has `hook` and `asks` and no
+// role; `proposeAuthority`, `appointOperator`, `setGates`, `setAllowed` are hook writes;
+// `hookApproved(kind, hook)` / `setHookApproved(kind, hook, ok)`; `Regenerated` names the payee;
+// `HARVEST_CUT_MAX` / `POT_CUT_MAX` cap what a hook may route to the protocol.
+export const EXPECTED_F_VERSION = 15n;
 
 export async function assertVersion(c: LogswapClient, expected = EXPECTED_VERSION): Promise<void> {
   const { cPoolManagerAbi } = await import("./generated.js");