@logswap/sdk 0.5.44 → 0.5.46

package/README.md

@@ -85,9 +85,9 @@ runs once and explicitly rather than being chained into both.
 - **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.** `phiMin` and `alpha` of `0n` resolve to their defaults 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.
+- **Zero is not the default.** A `phi` of `0n` 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
   indexer that ignores this reports phantom LP positions for market makers parking inventory.
 

package/dist/admin.d.ts

@@ -1,14 +1,46 @@
 /**
- * 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";
-export declare function setProtocolFeeCut(c: LogswapClient, cutWad: bigint): Promise<Hash>;
-export declare function setFeeParams(c: LogswapClient, mintFeeProtocolCutWad: bigint, harvestProtocolCutWad: bigint): Promise<Hash>;
-/** Waive the protocol's cut of harvested income for one pool (`HARVEST_PROTOCOL_CUT`; F version 13 — `setHarvestFeeExempt` before). */
-export declare function setHarvestCutExempt(c: LogswapClient, poolId: Hex, exempt: boolean): Promise<Hash>;
+import { 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 `setFeeParams(mintFeeProtocolCut)` — one cut, the C manager's shape (F version 14). */
+export declare function setFeeParams(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash>;
+/**
+ * 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 declare function setHookApproved(c: LogswapClient, kind: FPoolKind, hook: Address, approved: boolean): Promise<Hash>;
+/** Whether `hook` is approved for pools of `kind`. */
+export declare function hookApproved(c: LogswapClient, kind: FPoolKind, hook: Address): Promise<boolean>;
+/** The protocol's rate on the income part of every harvest under `hook`, WAD ≤ `HARVEST_CUT_MAX`. */
+export declare function setHarvestCut(c: LogswapClient, hook: Address, rateWad: bigint): Promise<Hash>;
+/** `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 declare function padSetSchedule(c: LogswapClient, hook: Address, s: {
+    thresholdBase: bigint;
+    thresholdGrowth: bigint;
+    creatorShare: bigint;
+    protocolShare: bigint;
+    burnPerRung: bigint;
+}): Promise<Hash>;
+/** `PolHook.setPolicy`: what every harvest leaves in the bid and what a relaunch's seed must bring, WAD fractions of L. */
+export declare function polSetPolicy(c: LogswapClient, hook: Address, s: {
+    keepQuote: bigint;
+    minQuoteAtSeed: bigint;
+}): Promise<Hash>;
+/** `PublicHook.setListed`: an asset a curated seed may hold. */
+export declare function publicSetListed(c: LogswapClient, hook: Address, token: Address, listed: boolean): Promise<Hash>;
+/** `PublicHook.setCurated`: whether every public seed is checked against the list. */
+export declare function publicSetCurated(c: LogswapClient, hook: Address, curated: boolean): Promise<Hash>;
 export declare function proposeCollector(c: LogswapClient, side: "C" | "F", next: Address): Promise<Hash>;
 export declare function acceptCollector(c: LogswapClient, side: "C" | "F"): Promise<Hash>;

package/dist/admin.js

@@ -1,32 +1,71 @@
 /**
- * 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 { cPoolManagerAbi, fPoolManagerAbi } from "./generated.js";
+import { cPoolManagerAbi, fPoolManagerAbi, padHookAbi, polHookAbi, publicHookAbi } from "./generated.js";
+import { F_KIND, fHookBaseAbi } from "./fpool.js";
 function wallet(c) {
     if (!c.wallet)
         throw new Error("a wallet client is required");
     return c.wallet;
 }
-export async function setProtocolFeeCut(c, cutWad) {
-    return wallet(c).writeContract({ address: c.addresses.cPoolManager, abi: cPoolManagerAbi, functionName: "setProtocolFeeCut", args: [cutWad], chain: c.wallet.chain, account: c.wallet.account });
+function write(c, address, abi, functionName, args) {
+    return wallet(c).writeContract({ address, abi, functionName, args, chain: c.wallet.chain, account: c.wallet.account });
 }
-export async function setFeeParams(c, mintFeeProtocolCutWad, harvestProtocolCutWad) {
-    return wallet(c).writeContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "setFeeParams", args: [mintFeeProtocolCutWad, harvestProtocolCutWad], 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]);
 }
-/** Waive the protocol's cut of harvested income for one pool (`HARVEST_PROTOCOL_CUT`; F version 13 — `setHarvestFeeExempt` before). */
-export async function setHarvestCutExempt(c, poolId, exempt) {
-    return wallet(c).writeContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "setHarvestCutExempt", args: [poolId, exempt], chain: c.wallet.chain, account: c.wallet.account });
+/** The F manager's `setFeeParams(mintFeeProtocolCut)` — one cut, the C manager's shape (F version 14). */
+export async function setFeeParams(c, mintFeeProtocolCutWad) {
+    return write(c, c.addresses.fPoolManager, 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, kind, hook, approved) {
+    return write(c, c.addresses.fPoolManager, fPoolManagerAbi, "setHookApproved", [F_KIND[kind], hook, approved]);
+}
+/** Whether `hook` is approved for pools of `kind`. */
+export async function hookApproved(c, kind, hook) {
+    return c.public.readContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "hookApproved", args: [F_KIND[kind], hook] });
+}
+// ─── 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, hook, rateWad) {
+    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, hook, s) {
+    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, hook, s) {
+    return write(c, hook, polHookAbi, "setPolicy", [s.keepQuote, s.minQuoteAtSeed]);
+}
+/** `PublicHook.setListed`: an asset a curated seed may hold. */
+export async function publicSetListed(c, hook, token, listed) {
+    return write(c, hook, publicHookAbi, "setListed", [token, listed]);
+}
+/** `PublicHook.setCurated`: whether every public seed is checked against the list. */
+export async function publicSetCurated(c, hook, curated) {
+    return write(c, hook, publicHookAbi, "setCurated", [curated]);
 }
 export async function proposeCollector(c, side, next) {
     const address = side === "C" ? c.addresses.cPoolManager : c.addresses.fPoolManager;
     const abi = side === "C" ? cPoolManagerAbi : fPoolManagerAbi;
-    return wallet(c).writeContract({ address, abi, functionName: "proposeCollector", args: [next], chain: c.wallet.chain, account: c.wallet.account });
+    return write(c, address, abi, "proposeCollector", [next]);
 }
 export async function acceptCollector(c, side) {
     const address = side === "C" ? c.addresses.cPoolManager : c.addresses.fPoolManager;
     const abi = side === "C" ? cPoolManagerAbi : fPoolManagerAbi;
-    return wallet(c).writeContract({ address, abi, functionName: "acceptCollector", args: [], chain: c.wallet.chain, account: c.wallet.account });
+    return write(c, address, abi, "acceptCollector", []);
 }

package/dist/client.d.ts

@@ -21,6 +21,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;
 }
@@ -51,8 +59,13 @@ export declare 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 declare const EXPECTED_VERSION = 3n;
+export declare 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).
@@ -64,5 +77,5 @@ export declare const EXPECTED_VERSION = 3n;
  * 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 = 13n;
+export declare const EXPECTED_F_VERSION = 15n;
 export declare function assertVersion(c: LogswapClient, expected?: bigint): Promise<void>;

package/dist/client.js

@@ -27,8 +27,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).
@@ -66,7 +71,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, expected = EXPECTED_VERSION) {
     const { cPoolManagerAbi } = await import("./generated.js");
     const got = await c.public.readContract({