@logswap/sdk 0.5.47 → 0.5.49

package/src/admin.ts

@@ -1,19 +1,19 @@
 /**
  * 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";
 import type { LogswapClient } from "./client.js";
-import { cPoolManagerAbi, fPoolManagerAbi, padHookAbi, polHookAbi, publicHookAbi } from "./generated.js";
-import { F_KIND, fHookBaseAbi, type FPoolKind } from "./fpool.js";
+import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, publicPolicyAbi } from "./generated.js";
+import { F_KIND, fPolicyBaseAbi, type FPoolKind } from "./fpool.js";
 
 function wallet(c: LogswapClient) {
   if (!c.wallet) throw new Error("a wallet client is required");
@@ -34,47 +34,47 @@ export async function setFeeParams(c: LogswapClient, mintFeeProtocolCutWad: bigi
 }
 
 /**
- * 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: LogswapClient, kind: FPoolKind, hook: Address, approved: boolean): Promise<Hash> {
-  return write(c, c.addresses.fPoolManager as Address, fPoolManagerAbi, "setHookApproved", [F_KIND[kind], hook, approved]);
+export async function setPolicyApproved(c: LogswapClient, kind: FPoolKind, policy: Address, approved: boolean): Promise<Hash> {
+  return write(c, c.addresses.fPoolManager as Address, fPoolManagerAbi, "setPolicyApproved", [F_KIND[kind], policy, 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>;
+/** Whether `policy` is approved for pools of `kind`. */
+export async function policyApproved(c: LogswapClient, kind: FPoolKind, policy: Address): Promise<boolean> {
+  return c.public.readContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "policyApproved", args: [F_KIND[kind], policy] } as never) as Promise<boolean>;
 }
 
-// ─── the hooks' numbers (the collector's; each bounded where it reaches the manager) ─────
+// ─── 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 `hook`, WAD ≤ `HARVEST_CUT_MAX`. */
-export async function setHarvestCut(c: LogswapClient, hook: Address, rateWad: bigint): Promise<Hash> {
-  return write(c, hook, fHookBaseAbi, "setHarvestCut", [rateWad]);
+/** The protocol's rate on the income part of every harvest under `policy`, WAD ≤ `HARVEST_CUT_MAX`. */
+export async function setHarvestCut(c: LogswapClient, policy: Address, rateWad: bigint): Promise<Hash> {
+  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`). */
+/** `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: LogswapClient,
-  hook: Address,
+  policy: 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]);
+  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: LogswapClient, hook: Address, s: { keepQuote: bigint; minQuoteAtSeed: bigint }): Promise<Hash> {
-  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: LogswapClient, policy: Address, s: { keepQuote: bigint; minQuoteAtSeed: bigint }): Promise<Hash> {
+  return write(c, policy, polPolicyAbi, "setRules", [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]);
+/** `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]);
 }
 
-/** `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]);
+/** `PublicPolicy.setCurated`: whether every public seed is checked against the list. */
+export async function publicSetCurated(c: LogswapClient, policy: Address, curated: boolean): Promise<Hash> {
+  return write(c, policy, publicPolicyAbi, "setCurated", [curated]);
 }
 
 export async function proposeCollector(c: LogswapClient, side: "C" | "F", next: Address): Promise<Hash> {

package/src/client.ts

@@ -24,13 +24,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;
 }
@@ -110,16 +110,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: LogswapClient, expected = EXPECTED_VERSION): Promise<void> {
   const { cPoolManagerAbi } = await import("./generated.js");