@logswap/sdk 0.5.45 → 0.5.47

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.45",
+  "version": "0.5.47",
   "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,39 +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.
+ * 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` — one cut on C (since version 4,
- * decisions 042; `setProtocolFeeCut` / `PROTOCOL_FEE_CUT` before), two on F.
+ * `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;
 }
 
+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);
+}
+
 /** The C manager's `setFeeParams(mintFeeProtocolCut)` — one cut. */
 export async function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash> {
-  return wallet(c).writeContract({ address: c.addresses.cPoolManager, abi: cPoolManagerAbi, functionName: "setFeeParams", args: [mintFeeProtocolCutWad], chain: c.wallet!.chain, account: c.wallet!.account! } as never);
+  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]);
 }
-/** The F manager's `setFeeParams(mintFeeProtocolCut, harvestProtocolCut)` — two cuts. */
-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);
+
+/** 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;
 }
@@ -102,7 +110,16 @@ export const EXPECTED_VERSION = 4n;
 // 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");