@logswap/sdk 0.5.47 → 0.5.49

package/dist/admin.d.ts

@@ -1,12 +1,12 @@
 /**
  * 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.
+ * 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.
  *
  * 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
+ * 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`).
  */
 import type { Address, Hash } from "viem";
@@ -17,30 +17,30 @@ export declare function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: b
 /** 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.
+ * Approve a policy 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 policy.
  */
-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: {
+export declare function setPolicyApproved(c: LogswapClient, kind: FPoolKind, policy: Address, approved: boolean): Promise<Hash>;
+/** Whether `policy` is approved for pools of `kind`. */
+export declare function policyApproved(c: LogswapClient, kind: FPoolKind, policy: Address): Promise<boolean>;
+/** The protocol's rate on the income part of every harvest under `policy`, WAD ≤ `HARVEST_CUT_MAX`. */
+export declare function setHarvestCut(c: LogswapClient, policy: Address, rateWad: bigint): Promise<Hash>;
+/** `PadPolicy.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, policy: 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: {
+/** `PolPolicy.setRules`: what every harvest leaves in the bid and what a relaunch's seed must bring, WAD fractions of L. */
+export declare function polSetRules(c: LogswapClient, policy: 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>;
+/** `PublicPolicy.setListed`: an asset a curated seed may hold. */
+export declare function publicSetListed(c: LogswapClient, policy: Address, token: Address, listed: boolean): Promise<Hash>;
+/** `PublicPolicy.setCurated`: whether every public seed is checked against the list. */
+export declare function publicSetCurated(c: LogswapClient, policy: 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,16 +1,16 @@
 /**
  * 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.
+ * 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.
  *
  * 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
+ * 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`).
  */
-import { cPoolManagerAbi, fPoolManagerAbi, padHookAbi, polHookAbi, publicHookAbi } from "./generated.js";
-import { F_KIND, fHookBaseAbi } from "./fpool.js";
+import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, publicPolicyAbi } from "./generated.js";
+import { F_KIND, fPolicyBaseAbi } from "./fpool.js";
 function wallet(c) {
     if (!c.wallet)
         throw new Error("a wallet client is required");
@@ -28,36 +28,36 @@ 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.
+ * Approve a policy 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 policy.
  */
-export async function setHookApproved(c, kind, hook, approved) {
-    return write(c, c.addresses.fPoolManager, fPoolManagerAbi, "setHookApproved", [F_KIND[kind], hook, approved]);
+export async function setPolicyApproved(c, kind, policy, approved) {
+    return write(c, c.addresses.fPoolManager, fPoolManagerAbi, "setPolicyApproved", [F_KIND[kind], policy, 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] });
+/** Whether `policy` is approved for pools of `kind`. */
+export async function policyApproved(c, kind, policy) {
+    return c.public.readContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "policyApproved", args: [F_KIND[kind], policy] });
 }
-// ─── 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]);
+// ─── the policies' numbers (the collector's; each bounded where it reaches the manager) ─────
+/** The protocol's rate on the income part of every harvest under `policy`, WAD ≤ `HARVEST_CUT_MAX`. */
+export async function setHarvestCut(c, policy, rateWad) {
+    return write(c, policy, fPolicyBaseAbi, "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]);
+/** `PadPolicy.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, policy, s) {
+    return write(c, policy, padPolicyAbi, "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]);
+/** `PolPolicy.setRules`: what every harvest leaves in the bid and what a relaunch's seed must bring, WAD fractions of L. */
+export async function polSetRules(c, policy, s) {
+    return write(c, policy, polPolicyAbi, "setRules", [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]);
+/** `PublicPolicy.setListed`: an asset a curated seed may hold. */
+export async function publicSetListed(c, policy, token, listed) {
+    return write(c, policy, publicPolicyAbi, "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]);
+/** `PublicPolicy.setCurated`: whether every public seed is checked against the list. */
+export async function publicSetCurated(c, policy, curated) {
+    return write(c, policy, publicPolicyAbi, "setCurated", [curated]);
 }
 export async function proposeCollector(c, side, next) {
     const address = side === "C" ? c.addresses.cPoolManager : c.addresses.fPoolManager;

package/dist/client.d.ts

@@ -22,13 +22,13 @@ export interface LogswapAddresses {
      */
     fPoolManager?: Address;
     /**
-     * The protocol's four F hooks, one per kind (decisions 044): every F pool names one in its key,
+     * The protocol's four F policies, 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;
+    publicPolicy?: Address;
+    privatePolicy?: Address;
+    polPolicy?: Address;
+    padPolicy?: Address;
     /** Optional — the router falls back to plain approvals when absent. */
     permit2?: Address;
 }
@@ -77,5 +77,5 @@ export declare const EXPECTED_VERSION = 4n;
  * 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 = 15n;
+export declare const EXPECTED_F_VERSION = 16n;
 export declare function assertVersion(c: LogswapClient, expected?: bigint): Promise<void>;

package/dist/client.js

@@ -71,16 +71,19 @@ 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.
-// 14 (2026-09-20): the hook (decisions 041) — `FPoolKey.hook`, every pool id moves; `dissolve` is
+// 14 (2026-09-20): the policy (decisions 041) — `FPoolKey.policy`, 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;
+// 15 (2026-09-20): the policy answers every question (decisions 044) — `FPoolKey.authority` is
+// `creator` (every pool id moves again); the roles, gates and list are the pool's POLICY's
+// (`FPolicyBase` / `PrivatePolicy`), not the manager's: `getPool` has `policy` and `asks` and no
+// role; `proposeAuthority`, `appointOperator`, `setGates`, `setAllowed` are policy writes;
+// `policyApproved(kind, policy)` / `setPolicyApproved(kind, policy, ok)`; `Regenerated` names the payee;
+// `HARVEST_CUT_MAX` / `POT_CUT_MAX` cap what a policy may route to the protocol.
+// 16 (2026-09-21): the word is POLICY (decisions 045) — a rename, no pool id moves: `FPoolKey.policy`,
+// `IFPolicy`, `FPolicyBase`, `PublicPolicy` … `PadPolicy`, `policyApproved` / `setPolicyApproved`,
+// `PolicyApproved`; `PolPolicy.setPolicy` / `PolicySet` are `setRules` / `RulesSet`.
+export const EXPECTED_F_VERSION = 16n;
 export async function assertVersion(c, expected = EXPECTED_VERSION) {
     const { cPoolManagerAbi } = await import("./generated.js");
     const got = await c.public.readContract({