@logswap/sdk 0.5.47 → 0.5.49

package/dist/fpool.js

@@ -14,15 +14,15 @@
  *
  * **Two products, one contract.** The basket (n > 1) and the launch (n = 1, the creator alone on
  * the lever) are the same bytecode under two key fields — the KIND (what the manager promises
- * structurally) and the HOOK (the pool's policy: its roles, its gates, the terms of every harvest
+ * structurally) and the POLICY (the pool's policy: its roles, its gates, the terms of every harvest
  * and release; decisions 041, 044) — and nothing in the maths. `describeFPool` below reports
  * which shape a given pool is, because a UI has to decide what to render.
  *
- * **The roles are the hook's, not the manager's** (F version 15). The manager holds no
- * authority, operator, gate or list: it asks the pool's hook `may(who, action)` and acts on the
- * answer. So `getFPool` carries the hook and what it declared, {@link getFPoolRoles} reads the
- * roles FROM the hook, and every role write — the handover, the operator, the gates, the list —
- * is a write to the hook ({@link fPoolProposeAuthority}, {@link fPoolSetGates}, …).
+ * **The roles are the policy's, not the manager's** (F version 15). The manager holds no
+ * authority, operator, gate or list: it asks the pool's policy `may(who, action)` and acts on the
+ * answer. So `getFPool` carries the policy and what it declared, {@link getFPoolRoles} reads the
+ * roles FROM the policy, and every role write — the handover, the operator, the gates, the list —
+ * is a write to the policy ({@link fPoolProposeAuthority}, {@link fPoolSetGates}, …).
  *
  * **Zaps live on the ROUTER, not here.** Permit2 is AllowanceTransfer mode, whose standing
  * allowance is keyed by spender, so a second router would cost the user an allowance per token
@@ -30,24 +30,24 @@
  * `addresses.router`.
  */
 import { encodeFunctionData, toFunctionSelector } from "viem";
-import { fPoolManagerAbi, logswapRouterAbi, padHookAbi, polHookAbi, privateHookAbi, publicHookAbi } from "./generated.js";
+import { fPoolManagerAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 /**
  * One contract, one ABI (decisions 039, F version 12): `harvest`, `claim`, `retire`, `regenerate`,
  * `setLegs`, the names, the fee parameters are `FPoolManager`'s own code. The roles left it for
- * the hooks in F version 15 (decisions 044): {@link fHookBaseAbi} is what every hook shares,
- * {@link privateHookAbi} the desk's, {@link padHookAbi} / {@link polHookAbi} / {@link publicHookAbi}
+ * the policies in F version 15 (decisions 044): {@link fPolicyBaseAbi} is what every policy shares,
+ * {@link privatePolicyAbi} the desk's, {@link padPolicyAbi} / {@link polPolicyAbi} / {@link publicPolicyAbi}
  * the kinds'.
  */
-export { fPoolManagerAbi, padHookAbi, polHookAbi, privateHookAbi, publicHookAbi };
+export { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPolicyAbi };
 /**
- * What every protocol hook shares (`FHookBase`): the roles and their handover, `harvestCut`,
- * `maxHarvest`. `polHookAbi` is a superset of it and carries nothing that collides, so it stands
- * in for the base — a call through it to any of the four hooks decodes the base's functions.
+ * What every protocol policy shares (`FPolicyBase`): the roles and their handover, `harvestCut`,
+ * `maxHarvest`. `polPolicyAbi` is a superset of it and carries nothing that collides, so it stands
+ * in for the base — a call through it to any of the four policies decodes the base's functions.
  */
-export const fHookBaseAbi = polHookAbi;
+export const fPolicyBaseAbi = polPolicyAbi;
 const WAD = 10n ** 18n;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-/** The optional questions a hook declared at birth (decisions 044), as bits of `Pool.asks`. */
+/** The optional questions a policy declared at birth (decisions 044), as bits of `Pool.asks`. */
 export const ASK_SWAP = 1;
 export const ASK_MINT = 2;
 /** Read a basket pool whole. Batched — viem multicalls these when the transport allows. */
@@ -61,7 +61,7 @@ export async function getFPool(c, poolId) {
         args,
     });
     // `getPool` returns the whole scalar struct in one call — the singleton's shape makes what used
-    // to be a dozen getters a single read. No role in it since F version 15: those are the hook's.
+    // to be a dozen getters a single read. No role in it since F version 15: those are the policy's.
     const p = await rd("getPool", [poolId]);
     // A pool that was never created reads as an all-zero struct rather than reverting, so the
     // absence has to be named here or every caller mistakes "no such pool" for "a pool holding
@@ -83,7 +83,7 @@ export async function getFPool(c, poolId) {
     const weights = legs.map((l) => l[1]);
     const x = legs.map((l) => l[2]); // derived by the manager: x_j = ln(w_j·L / R_j) (decisions 026)
     const reserves = legs.map((l) => l[3]); // the state
-    const { quote, Q, L, phi, theta0, bigSigma, hook, restructureBlock, seeded, gen } = p;
+    const { quote, Q, L, phi, theta0, bigSigma, policy, restructureBlock, seeded, gen } = p;
     const totalSupply = p.shares;
     return {
         poolId,
@@ -98,7 +98,7 @@ export async function getFPool(c, poolId) {
         theta,
         compositeX,
         bigSigma,
-        hook,
+        policy,
         asks: Number(p.asks),
         name: bytes32ToText(p.name),
         restructureBlock: Number(restructureBlock),
@@ -118,16 +118,16 @@ export function fPoolKindOf(n) {
         throw new Error(`logswap: unknown pool kind ${n}`);
     return k;
 }
-/** The deployment's hook for a kind (decisions 044): what a key of that kind names. */
-export function fPoolHookFor(c, kind) {
+/** The deployment's policy for a kind (decisions 044): what a key of that kind names. */
+export function fPoolPolicyFor(c, kind) {
     const a = c.addresses;
-    const hook = kind === "public" ? a.publicHook : kind === "private" ? a.privateHook : kind === "pol" ? a.polHook : a.padHook;
-    if (!hook)
-        throw new Error(`logswap: this deployment carries no ${kind} hook`);
-    return hook;
+    const policy = kind === "public" ? a.publicPolicy : kind === "private" ? a.privatePolicy : kind === "pol" ? a.polPolicy : a.padPolicy;
+    if (!policy)
+        throw new Error(`logswap: this deployment carries no ${kind} policy`);
+    return policy;
 }
-/** The hook a pool named in its key — one read; {@link getFPool} carries it too. */
-export async function fPoolHookOf(c, poolId) {
+/** The policy a pool named in its key — one read; {@link getFPool} carries it too. */
+export async function fPoolPolicyOf(c, poolId) {
     const p = (await c.public.readContract({
         address: c.addresses.fPoolManager,
         abi: fPoolManagerAbi,
@@ -136,28 +136,28 @@ export async function fPoolHookOf(c, poolId) {
     }));
     if (/^0x0{40}$/i.test(p.quote))
         throw new Error(`logswap: no F pool with id ${poolId}`);
-    return p.hook;
+    return p.policy;
 }
-/** Read a pool's roles from its hook. `state` saves the `getPool` round trip when already in hand. */
+/** Read a pool's roles from its policy. `state` saves the `getPool` round trip when already in hand. */
 export async function getFPoolRoles(c, poolId, state) {
     const s = state ?? (await getFPool(c, poolId));
-    const rdHook = (abi, functionName) => c.public.readContract({ address: s.hook, abi, functionName, args: [poolId] });
+    const rdPolicy = (abi, functionName) => c.public.readContract({ address: s.policy, abi, functionName, args: [poolId] });
     const [creator, authority, pendingAuthority, maxHarvest] = await Promise.all([
-        rdHook(fHookBaseAbi, "creator"),
-        rdHook(fHookBaseAbi, "authority"),
-        rdHook(fHookBaseAbi, "pendingAuthority"),
-        rdHook(fHookBaseAbi, "maxHarvest"),
+        rdPolicy(fPolicyBaseAbi, "creator"),
+        rdPolicy(fPolicyBaseAbi, "authority"),
+        rdPolicy(fPolicyBaseAbi, "pendingAuthority"),
+        rdPolicy(fPolicyBaseAbi, "maxHarvest"),
     ]);
     const desk = s.kind === "private";
     const [operator, pendingOperator, gateMint, gateSwap] = desk
         ? await Promise.all([
-            rdHook(privateHookAbi, "operator"),
-            rdHook(privateHookAbi, "pendingOperator"),
-            rdHook(privateHookAbi, "gateMint"),
-            rdHook(privateHookAbi, "gateSwap"),
+            rdPolicy(privatePolicyAbi, "operator"),
+            rdPolicy(privatePolicyAbi, "pendingOperator"),
+            rdPolicy(privatePolicyAbi, "gateMint"),
+            rdPolicy(privatePolicyAbi, "gateSwap"),
         ])
         : [ZERO_ADDRESS, ZERO_ADDRESS, false, false];
-    return { hook: s.hook, creator, authority, pendingAuthority, operator, pendingOperator, gateMint, gateSwap, maxHarvest };
+    return { policy: s.policy, creator, authority, pendingAuthority, operator, pendingOperator, gateMint, gateSwap, maxHarvest };
 }
 export async function describeFPool(c, s) {
     const rd = (functionName, args = [s.poolId]) => c.public.readContract({
@@ -606,7 +606,7 @@ export function sortFPoolLegs(bases, ...companions) {
     const idx = bases.map((_, i) => i).sort((a, b) => (bases[a].toLowerCase() < bases[b].toLowerCase() ? -1 : 1));
     return { bases: idx.map((i) => bases[i]), companions: companions.map((arr) => idx.map((i) => arr[i])) };
 }
-/** The key as the manager hashes it: legs sorted, the kind's hook filled in when none is named. */
+/** The key as the manager hashes it: legs sorted, the kind's policy filled in when none is named. */
 export function fPoolKeyOf(c, a) {
     const { bases, companions } = sortFPoolLegs(a.bases, a.weights);
     return {
@@ -615,7 +615,7 @@ export function fPoolKeyOf(c, a) {
         weights: companions[0],
         phi: a.phi,
         kind: F_KIND[a.kind],
-        hook: a.hook ?? fPoolHookFor(c, a.kind),
+        policy: a.policy ?? fPoolPolicyFor(c, a.kind),
         creator: a.creator,
         salt: a.salt ?? ZERO_SALT,
     };
@@ -674,7 +674,7 @@ export async function fPoolSeed(c, a) {
  * operator harvested it out first ({@link fPoolRetire} does both in one transaction). The live
  * (S, Q, R_j) become a frozen bundle every share of this generation redeems ({@link fPoolRedeem})
  * or rolls ({@link fPoolRollIn}), forever; the pool is unseeded until the next {@link fPoolSeed},
- * which opens generation `gen + 1` under the same id, hook, roles, gates and lists.
+ * which opens generation `gen + 1` under the same id, policy, roles, gates and lists.
  */
 export async function fPoolRetireRaw(c, a) {
     return writeFPool(c, a.poolId, "retire", [], a.account);
@@ -698,8 +698,8 @@ export async function fPoolRetire(c, a) {
  * `retire` (decisions 035: a retire needs an empty bid on every pool). Since F version 14 one
  * `harvest(Q)` does it: the protocol's cut leaves the pool with the amount (with no collector
  * there is no cut). `[]` when the bid is already empty. Throws on a pad that still bids (its bid
- * empties only as the market sells it down), and when the pool's hook keeps a floor on the bid
- * (`PolHook.keepQuote`, decisions 044): a `retire` under that hook waits for the market.
+ * empties only as the market sells it down), and when the pool's policy keeps a floor on the bid
+ * (`PolPolicy.keepQuote`, decisions 044): a `retire` under that policy waits for the market.
  */
 export async function fPoolEmptyingHarvests(c, poolId) {
     const s = await getFPool(c, poolId);
@@ -709,16 +709,16 @@ export async function fPoolEmptyingHarvests(c, poolId) {
         throw new Error("logswap: a pad is retired only once its bid is empty (decisions 035)");
     const { maxHarvest } = await getFPoolRoles(c, poolId, s);
     if (maxHarvest < s.Q)
-        throw new Error("logswap: the pool's hook keeps a floor on the bid — it cannot be harvested empty (decisions 044)");
+        throw new Error("logswap: the pool's policy keeps a floor on the bid — it cannot be harvested empty (decisions 044)");
     return [s.Q];
 }
 /**
- * Release the dead shares' pot under the hook's terms (decisions 041, 044) — a pad's graduation.
+ * Release the dead shares' pot under the policy's terms (decisions 041, 044) — a pad's graduation.
  * The manager harvests the generation's income first (the pot then holds everything the dead
- * shares earned), asks the hook, and applies its answer: a share to the payee it names (the pad's
+ * shares earned), asks the policy, and applies its answer: a share to the payee it names (the pad's
  * creator — the pool's authority), a cut to the collector, the rest bought in as more of the
- * float the pool owns, a slice of every reserve burned. The hook refuses under its rung's
- * threshold (`PadHook.NotGraduated`). Whoever runs the pool.
+ * float the pool owns, a slice of every reserve burned. The policy refuses under its rung's
+ * threshold (`PadPolicy.NotGraduated`). Whoever runs the pool.
  */
 export async function fPoolRegenerate(c, a) {
     return writeFPool(c, a.poolId, "regenerate", [a.to ?? a.account], a.account);
@@ -730,7 +730,7 @@ export async function fPoolRegenerate(c, a) {
  * next generation's composition (`legs`: a private pool's reshape — retire, admit, reweight), and
  * `seed` it with what came back — the manager's `multicall`, one sender throughout, the same
  * pool. The operator's when one is appointed and the seed's inventory is its own; by default the
- * authority's. The hook, its roles, gates, allowlist and the name carry over; anything else goes
+ * authority's. The policy, its roles, gates, allowlist and the name carry over; anything else goes
  * in `extra`, pre-encoded against {@link fPoolManagerAbi}. The seed names reserves (decisions
  * 029): `r0` outright — one per leg of the NEXT table, 0 for a retired leg — or `x0` marks
  * against the next table's `weights`.
@@ -767,9 +767,9 @@ export function fPoolLaunchCalls(poolId, a) {
     if (given.length !== a.bases.length)
         throw new Error(`logswap: ${given.length} reserves for ${a.bases.length} legs`);
     const { bases, companions } = sortFPoolLegs(a.bases, a.weights, given);
-    if (!a.hook)
-        throw new Error("logswap: fPoolLaunchCalls needs the key's hook — fPoolLaunch fills it from the deployment");
-    const key = { quote: a.quote, bases, weights: companions[0], phi: a.phi, kind: F_KIND[a.kind], hook: a.hook, creator: a.creator, salt: a.salt ?? ZERO_SALT };
+    if (!a.policy)
+        throw new Error("logswap: fPoolLaunchCalls needs the key's policy — fPoolLaunch fills it from the deployment");
+    const key = { quote: a.quote, bases, weights: companions[0], phi: a.phi, kind: F_KIND[a.kind], policy: a.policy, creator: a.creator, salt: a.salt ?? ZERO_SALT };
     const enc = (functionName, args) => encodeFunctionData({ abi: fPoolManagerAbi, functionName, args });
     const calls = [];
     if (!a.initialized)
@@ -785,21 +785,21 @@ export function fPoolLaunchCalls(poolId, a) {
     }
     if (a.name)
         calls.push(enc("setName", [poolId, textToBytes32(a.name)]));
-    // the desk's gates and list are the HOOK's (decisions 044), not the manager's: they cannot ride
+    // the desk's gates and list are the POLICY's (decisions 044), not the manager's: they cannot ride
     // in this batch — `fPoolDeskOpening` sends them right after, as the same creator
     calls.push(...(a.extra ?? []));
     return calls;
 }
 /**
- * The desk's opening posture, on its hook (decisions 044): gated minting, the creator listed. No
+ * The desk's opening posture, on its policy (decisions 044): gated minting, the creator listed. No
  * appointment: the authority is the operator until one is appointed (decisions 037). Two writes
- * to `PrivateHook`; the launch batch cannot carry them (they are not manager calls).
+ * to `PrivatePolicy`; the launch batch cannot carry them (they are not manager calls).
  */
 export async function fPoolDeskOpening(c, a) {
-    const hook = a.hook ?? fPoolHookFor(c, "private");
+    const policy = a.policy ?? fPoolPolicyFor(c, "private");
     return [
-        await fPoolSetGates(c, { poolId: a.poolId, gateMint: true, gateSwap: false, account: a.account, hook }),
-        await fPoolSetAllowed(c, { poolId: a.poolId, who: [a.account], allowed: true, account: a.account, hook }),
+        await fPoolSetGates(c, { poolId: a.poolId, gateMint: true, gateSwap: false, account: a.account, policy }),
+        await fPoolSetAllowed(c, { poolId: a.poolId, who: [a.account], allowed: true, account: a.account, policy }),
     ];
 }
 /**
@@ -821,20 +821,20 @@ export async function fPoolDeskOpening(c, a) {
  */
 export async function fPoolLaunch(c, a) {
     const poolId = await fPoolIdOf(c, a);
-    const calls = fPoolLaunchCalls(poolId, { ...a, hook: a.hook ?? fPoolHookFor(c, a.kind) });
+    const calls = fPoolLaunchCalls(poolId, { ...a, policy: a.policy ?? fPoolPolicyFor(c, a.kind) });
     const hash = await writeFPool0(c, "multicall", [calls], a.account);
     return { hash, poolId };
 }
-// ─── the roles, on the hook (decisions 044) ─────────────────────────────────────────────
+// ─── the roles, on the policy (decisions 044) ─────────────────────────────────────────────
 //
-// Every write here goes to the pool's HOOK, not the manager: the manager holds no role. `hook`
-// may be passed when in hand (`FPoolState.hook`, `FPoolRoles.hook`); otherwise it is read once.
-/** A write keyed by poolId, on the pool's hook. */
-async function writeHook(c, abi, a, functionName, args) {
+// Every write here goes to the pool's POLICY, not the manager: the manager holds no role. `policy`
+// may be passed when in hand (`FPoolState.policy`, `FPoolRoles.policy`); otherwise it is read once.
+/** A write keyed by poolId, on the pool's policy. */
+async function writePolicy(c, abi, a, functionName, args) {
     const wallet = requireWallet(c);
-    const hook = a.hook ?? (await fPoolHookOf(c, a.poolId));
+    const policy = a.policy ?? (await fPoolPolicyOf(c, a.poolId));
     const { request } = await c.public.simulateContract({
-        address: hook,
+        address: policy,
         abi,
         functionName,
         args: [a.poolId, ...args],
@@ -843,39 +843,39 @@ async function writeHook(c, abi, a, functionName, args) {
     return wallet.writeContract(request);
 }
 /**
- * Propose the next authority — step one of two (decisions 020), on the pool's hook. Nothing moves
+ * Propose the next authority — step one of two (decisions 020), on the pool's policy. Nothing moves
  * until `next` accepts; proposing again (the zero address included) cancels a pending proposal.
- * Indexed on-chain via the hook's AuthorityProposed.
+ * Indexed on-chain via the policy's AuthorityProposed.
  */
 export async function fPoolProposeAuthority(c, a) {
-    return writeHook(c, fHookBaseAbi, a, "proposeAuthority", [a.next]);
+    return writePolicy(c, fPolicyBaseAbi, a, "proposeAuthority", [a.next]);
 }
 /**
- * Accept a pending proposal — step two; only the proposed address can. Indexed via the hook's
- * AuthoritySet. On the desk's hook this clears the operator (pending and accepted) and voids the
+ * Accept a pending proposal — step two; only the proposed address can. Indexed via the policy's
+ * AuthoritySet. On the desk's policy this clears the operator (pending and accepted) and voids the
  * seller's list (decisions 040, 044).
  */
 export async function fPoolAcceptAuthority(c, a) {
-    return writeHook(c, fHookBaseAbi, a, "acceptAuthority", []);
+    return writePolicy(c, fPolicyBaseAbi, a, "acceptAuthority", []);
 }
-// ─── the desk's controls (PrivateHook; decisions 021, 044) ───────────────────────────────
-/** Turn the mint / swap gates on or off (the authority, on the desk's hook). `burn` is never gated. */
+// ─── the desk's controls (PrivatePolicy; decisions 021, 044) ───────────────────────────────
+/** Turn the mint / swap gates on or off (the authority, on the desk's policy). `burn` is never gated. */
 export async function fPoolSetGates(c, a) {
-    return writeHook(c, privateHookAbi, a, "setGates", [a.gateMint, a.gateSwap]);
+    return writePolicy(c, privatePolicyAbi, a, "setGates", [a.gateMint, a.gateSwap]);
 }
 /**
- * Add to or remove from the pool's list, in one call (the authority, on the desk's hook). The list
+ * Add to or remove from the pool's list, in one call (the authority, on the desk's policy). The list
  * is keyed by the authority that granted it: a handover starts the buyer with an empty one.
  */
 export async function fPoolSetAllowed(c, a) {
-    return writeHook(c, privateHookAbi, a, "setAllowed", [a.who, a.allowed]);
+    return writePolicy(c, privatePolicyAbi, a, "setAllowed", [a.who, a.allowed]);
 }
 /** Whether `who` is on the pool's list under its current authority (consulted only while a gate is on). */
-export async function fPoolIsAllowed(c, poolId, who, hook) {
-    const address = hook ?? (await fPoolHookOf(c, poolId));
+export async function fPoolIsAllowed(c, poolId, who, policy) {
+    const address = policy ?? (await fPoolPolicyOf(c, poolId));
     return (await c.public.readContract({
         address,
-        abi: privateHookAbi,
+        abi: privatePolicyAbi,
         functionName: "isAllowed",
         args: [poolId, who],
     }));
@@ -914,16 +914,16 @@ export function fPoolOperatorOf(s) {
     return s.operator === ZERO_ADDRESS ? s.authority : s.operator;
 }
 /**
- * Propose the operator (the authority, on the desk's hook) — the hot key that runs the pool:
+ * Propose the operator (the authority, on the desk's policy) — the hot key that runs the pool:
  * `harvest`, `retire`, `regenerate`, `setLegs`. Two-step: the proposed address takes the role with
  * {@link fPoolAcceptOperator}. The zero address clears at once — the role returns to the authority.
  */
 export async function fPoolAppointOperator(c, a) {
-    return writeHook(c, privateHookAbi, a, "appointOperator", [a.operator]);
+    return writePolicy(c, privatePolicyAbi, a, "appointOperator", [a.operator]);
 }
 /** The proposed operator takes the role. */
 export async function fPoolAcceptOperator(c, a) {
-    return writeHook(c, privateHookAbi, a, "acceptOperator", []);
+    return writePolicy(c, privatePolicyAbi, a, "acceptOperator", []);
 }
 /**
  * The next generation's composition (operator; private pools only; ONLY while the pool is
@@ -989,7 +989,7 @@ export async function discoverFPools(c, opts = {}) {
             weights: [...a.weights],
             phi: a.phi,
             kind: fPoolKindOf(a.kind),
-            hook: a.hook,
+            policy: a.policy,
             creator: a.creator,
             block: l.blockNumber ?? 0n,
             seeded: q0 !== undefined,
@@ -998,28 +998,28 @@ export async function discoverFPools(c, opts = {}) {
         };
     });
 }
-/** The hook's terms for one pool, by its kind. */
-export async function getFPoolPolicy(c, s, roles) {
-    const rd = (abi, functionName, args = []) => c.public.readContract({ address: s.hook, abi, functionName, args });
-    const harvestCut = await rd(fHookBaseAbi, "harvestCut");
+/** The policy's terms for one pool, by its kind. */
+export async function getFPoolRules(c, s, roles) {
+    const rd = (abi, functionName, args = []) => c.public.readContract({ address: s.policy, abi, functionName, args });
+    const harvestCut = await rd(fPolicyBaseAbi, "harvestCut");
     switch (s.kind) {
         case "pad": {
             const [rung, creatorShare, protocolShare, burnPerRung, pot] = await Promise.all([
-                rd(padHookAbi, "rung", [s.poolId]),
-                rd(padHookAbi, "creatorShare"),
-                rd(padHookAbi, "protocolShare"),
-                rd(padHookAbi, "burnPerRung"),
+                rd(padPolicyAbi, "rung", [s.poolId]),
+                rd(padPolicyAbi, "creatorShare"),
+                rd(padPolicyAbi, "protocolShare"),
+                rd(padPolicyAbi, "burnPerRung"),
                 fPoolDividendOf(c, s.poolId, DEAD_ADDRESS, s.gen),
             ]);
-            const threshold = await rd(padHookAbi, "threshold", [rung]);
+            const threshold = await rd(padPolicyAbi, "threshold", [rung]);
             return { kind: "pad", harvestCut, rung: Number(rung), threshold, pot, creatorShare, protocolShare, burnPerRung };
         }
         case "pol": {
-            const [keepQuote, minQuoteAtSeed] = await Promise.all([rd(polHookAbi, "keepQuote"), rd(polHookAbi, "minQuoteAtSeed")]);
+            const [keepQuote, minQuoteAtSeed] = await Promise.all([rd(polPolicyAbi, "keepQuote"), rd(polPolicyAbi, "minQuoteAtSeed")]);
             return { kind: "pol", harvestCut, keepQuote, minQuoteAtSeed };
         }
         case "public": {
-            const curated = await rd(publicHookAbi, "curated");
+            const curated = await rd(publicPolicyAbi, "curated");
             return { kind: "public", harvestCut, curated };
         }
         case "private": {
@@ -1029,19 +1029,19 @@ export async function getFPoolPolicy(c, s, roles) {
     }
 }
 /**
- * Every F pool `who` is the AUTHORITY of, across the four hooks — the policy page's list. Pools
+ * Every F pool `who` is the AUTHORITY of, across the four policies — the policy page's list. Pools
  * `who` created and handed over are not here (the buyer's page shows them); pools handed TO
  * `who` are. `pools` may be passed (from the indexer, say) to skip the log scan.
  */
 export async function fPoolsControlledBy(c, who, opts = {}) {
     const pools = opts.pools ?? (await discoverFPools(c, { fromBlock: opts.fromBlock }));
-    const authorities = await Promise.all(pools.map((p) => c.public.readContract({ address: p.hook, abi: fHookBaseAbi, functionName: "authority", args: [p.poolId] })));
+    const authorities = await Promise.all(pools.map((p) => c.public.readContract({ address: p.policy, abi: fPolicyBaseAbi, functionName: "authority", args: [p.poolId] })));
     const mine = pools.filter((_, i) => authorities[i].toLowerCase() === who.toLowerCase());
     return Promise.all(mine.map(async (pool) => {
         const state = await getFPool(c, pool.poolId);
         const roles = await getFPoolRoles(c, pool.poolId, state);
-        const policy = await getFPoolPolicy(c, state, roles);
-        return { pool, roles, state, policy };
+        const rules = await getFPoolRules(c, state, roles);
+        return { pool, roles, state, rules };
     }));
 }
 /**