@logswap/sdk 0.5.47 → 0.5.48

package/dist/fpool.d.ts

@@ -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,21 +30,21 @@
  * `addresses.router`.
  */
 import { type Address, type Hash, type Hex } from "viem";
-import { fPoolManagerAbi, padHookAbi, polHookAbi, privateHookAbi, publicHookAbi } from "./generated.js";
+import { fPoolManagerAbi, 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 declare const fHookBaseAbi: readonly [{
+export declare const fPolicyBaseAbi: readonly [{
     readonly type: "constructor";
     readonly inputs: readonly [{
         readonly name: "_manager";
@@ -138,7 +138,7 @@ export declare const fHookBaseAbi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [{
         readonly name: "a";
-        readonly internalType: "struct IFHook.Ask";
+        readonly internalType: "struct IFPolicy.Ask";
         readonly type: "tuple";
         readonly components: readonly [{
             readonly name: "poolId";
@@ -150,7 +150,7 @@ export declare const fHookBaseAbi: readonly [{
             readonly type: "uint256";
         }, {
             readonly name: "action";
-            readonly internalType: "enum IFHook.Action";
+            readonly internalType: "enum IFPolicy.Action";
             readonly type: "uint8";
         }, {
             readonly name: "who";
@@ -199,7 +199,7 @@ export declare const fHookBaseAbi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [{
         readonly name: "a";
-        readonly internalType: "struct IFHook.Ask";
+        readonly internalType: "struct IFPolicy.Ask";
         readonly type: "tuple";
         readonly components: readonly [{
             readonly name: "poolId";
@@ -211,7 +211,7 @@ export declare const fHookBaseAbi: readonly [{
             readonly type: "uint256";
         }, {
             readonly name: "action";
-            readonly internalType: "enum IFHook.Action";
+            readonly internalType: "enum IFPolicy.Action";
             readonly type: "uint8";
         }, {
             readonly name: "who";
@@ -281,7 +281,7 @@ export declare const fHookBaseAbi: readonly [{
             readonly internalType: "enum Kind";
             readonly type: "uint8";
         }, {
-            readonly name: "hook";
+            readonly name: "policy";
             readonly internalType: "address";
             readonly type: "address";
         }, {
@@ -305,7 +305,7 @@ export declare const fHookBaseAbi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [{
         readonly name: "a";
-        readonly internalType: "struct IFHook.Ask";
+        readonly internalType: "struct IFPolicy.Ask";
         readonly type: "tuple";
         readonly components: readonly [{
             readonly name: "poolId";
@@ -317,7 +317,7 @@ export declare const fHookBaseAbi: readonly [{
             readonly type: "uint256";
         }, {
             readonly name: "action";
-            readonly internalType: "enum IFHook.Action";
+            readonly internalType: "enum IFPolicy.Action";
             readonly type: "uint8";
         }, {
             readonly name: "who";
@@ -348,7 +348,7 @@ export declare const fHookBaseAbi: readonly [{
     readonly name: "onRegenerate";
     readonly outputs: readonly [{
         readonly name: "t";
-        readonly internalType: "struct IFHook.Terms";
+        readonly internalType: "struct IFPolicy.Terms";
         readonly type: "tuple";
         readonly components: readonly [{
             readonly name: "payee";
@@ -418,7 +418,7 @@ export declare const fHookBaseAbi: readonly [{
         readonly internalType: "uint256";
         readonly type: "uint256";
     }];
-    readonly name: "setPolicy";
+    readonly name: "setRules";
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
@@ -485,7 +485,7 @@ export declare const fHookBaseAbi: readonly [{
         readonly type: "uint256";
         readonly indexed: false;
     }];
-    readonly name: "PolicySet";
+    readonly name: "RulesSet";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -512,7 +512,7 @@ export declare const fHookBaseAbi: readonly [{
     readonly name: "Refused";
 }];
 import type { LogswapClient } from "./client.js";
-/** 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 declare const ASK_SWAP = 1;
 export declare const ASK_MINT = 2;
 /** Everything scalar about a basket pool, in one round trip's worth of reads. */
@@ -542,10 +542,10 @@ export interface FPoolState {
     /**
      * The pool's policy (decisions 041, 044): the contract the key names, holding the pool's roles
      * and answering every question the manager does not decide itself. Read its roles with
-     * {@link getFPoolRoles}; one of the deployment's four ({@link fPoolHookFor}) on every protocol pool.
+     * {@link getFPoolRoles}; one of the deployment's four ({@link fPoolPolicyFor}) on every protocol pool.
      */
-    hook: Address;
-    /** Whether the hook asked to be consulted on swaps ({@link ASK_SWAP}) and mints ({@link ASK_MINT}) — the desk's hook does, no other. */
+    policy: Address;
+    /** Whether the policy asked to be consulted on swaps ({@link ASK_SWAP}) and mints ({@link ASK_MINT}) — the desk's policy does, no other. */
     asks: number;
     /** The sponsor's own label for this pool, mutable and never identity. "" when unnamed. */
     name: string;
@@ -569,13 +569,13 @@ export interface FPoolState {
 export declare function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolState>;
 /**
  * The kind of pool (decisions 036, 038, 044) — what the manager promises structurally, whatever
- * the pool's hook answers. `public`: the protocol's own pool — its hook requires the collector as
- * creator; no gate, no operator. `private`, the desk: the one kind whose hook may gate swaps and
+ * the pool's policy answers. `public`: the protocol's own pool — its policy requires the collector as
+ * creator; no gate, no operator. `private`, the desk: the one kind whose policy may gate swaps and
  * mints, with an operator that reshapes the legs between generations. `pol`, a treasury's pool
  * or a basket: composition and access fixed at birth. `pad`, a launch: a POL whose harvest is
- * income only whatever its hook says and whose seed the contract minted to 0xdead — one asset,
+ * income only whatever its policy says and whose seed the contract minted to 0xdead — one asset,
  * open to all. private → pol → pad is the ladder of rigidity; public is a pol held by the
- * protocol. Every rate, role and gate is the hook's.
+ * protocol. Every rate, role and gate is the policy's.
  */
 export type FPoolKind = "public" | "private" | "pol" | "pad";
 /** The key's enum values. */
@@ -586,19 +586,19 @@ export declare const F_KIND: {
     readonly pad: 3;
 };
 export declare function fPoolKindOf(n: number | bigint): FPoolKind;
-/** The deployment's hook for a kind (decisions 044): what a key of that kind names. */
-export declare function fPoolHookFor(c: LogswapClient, kind: FPoolKind): Address;
-/** The hook a pool named in its key — one read; {@link getFPool} carries it too. */
-export declare function fPoolHookOf(c: LogswapClient, poolId: Hex): Promise<Address>;
+/** The deployment's policy for a kind (decisions 044): what a key of that kind names. */
+export declare function fPoolPolicyFor(c: LogswapClient, kind: FPoolKind): Address;
+/** The policy a pool named in its key — one read; {@link getFPool} carries it too. */
+export declare function fPoolPolicyOf(c: LogswapClient, poolId: Hex): Promise<Address>;
 /**
- * A pool's roles, as its HOOK holds them (decisions 044). `creator` is immutable identity —
+ * A pool's roles, as its POLICY holds them (decisions 044). `creator` is immutable identity —
  * who was born holding the pool; `authority` is the cold key that owns it now, the creator until
  * a two-step handover; on the desk's kind the `operator` runs it (zero = the authority itself,
  * {@link fPoolOperatorOf}) and the two gates and the list are its. Every other kind has no
  * operator and no gate: those fields read zero / false.
  */
 export interface FPoolRoles {
-    hook: Address;
+    policy: Address;
     creator: Address;
     authority: Address;
     /** The proposed next authority, until it accepts — zero when nothing is pending (decisions 020). */
@@ -607,11 +607,11 @@ export interface FPoolRoles {
     pendingOperator: Address;
     gateMint: boolean;
     gateSwap: boolean;
-    /** The hook's own ceiling on a harvest now — the manager's `harvestable` narrowed by the hook's rule. */
+    /** The policy's own ceiling on a harvest now — the manager's `harvestable` narrowed by the policy's rule. */
     maxHarvest: bigint;
 }
-/** Read a pool's roles from its hook. `state` saves the `getPool` round trip when already in hand. */
-export declare function getFPoolRoles(c: LogswapClient, poolId: Hex, state?: Pick<FPoolState, "hook" | "kind">): Promise<FPoolRoles>;
+/** Read a pool's roles from its policy. `state` saves the `getPool` round trip when already in hand. */
+export declare function getFPoolRoles(c: LogswapClient, poolId: Hex, state?: Pick<FPoolState, "policy" | "kind">): Promise<FPoolRoles>;
 /** Which of the two products a pool is configured as — a pad is a launch, anything else a basket/pool. A UI has to choose what to render. */
 export type FPoolShape = "launch" | "basket";
 export interface FPoolDescription {
@@ -626,7 +626,7 @@ export interface FPoolDescription {
      * from the first wei after it.
      */
     unharvested: bigint;
-    /** The most a harvest may take now by the KIND's promise: the bid, and on a pad the income. The hook may allow less — {@link FPoolRoles.maxHarvest}. */
+    /** The most a harvest may take now by the KIND's promise: the bid, and on a pad the income. The policy may allow less — {@link FPoolRoles.maxHarvest}. */
     harvestable: bigint;
     /** The dead shares' banked dividend — a pad's pot, the creator's income until a rung is climbed (decisions 041). */
     pot: bigint;
@@ -861,11 +861,11 @@ export interface FPoolCreateArgs {
     kind: FPoolKind;
     /**
      * The pool's policy (decisions 041, 044): the contract the key names, approved by the protocol
-     * for the kind. Defaults to the deployment's hook for `kind` ({@link fPoolHookFor}) — the one
+     * for the kind. Defaults to the deployment's policy for `kind` ({@link fPoolPolicyFor}) — the one
      * every protocol pool names.
      */
-    hook?: Address;
-    /** Who is born holding the pool: immutable identity, the pool's first authority (the hook records it). */
+    policy?: Address;
+    /** Who is born holding the pool: immutable identity, the pool's first authority (the policy records it). */
     creator: Address;
     /**
      * The differentiator, and nothing else. Identity is the key's hash, so one sponsor cannot run
@@ -884,14 +884,14 @@ export declare function sortFPoolLegs<T>(bases: Address[], ...companions: T[][])
     bases: Address[];
     companions: T[][];
 };
-/** 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 declare function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): {
     quote: `0x${string}`;
     bases: `0x${string}`[];
     weights: bigint[];
     phi: bigint;
     kind: 0 | 1 | 3 | 2;
-    hook: `0x${string}`;
+    policy: `0x${string}`;
     creator: `0x${string}`;
     salt: `0x${string}`;
 };
@@ -931,7 +931,7 @@ export declare function fPoolSeed(c: LogswapClient, 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 declare function fPoolRetireRaw(c: LogswapClient, a: {
     poolId: Hex;
@@ -952,17 +952,17 @@ export declare function fPoolRetire(c: LogswapClient, 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 declare function fPoolEmptyingHarvests(c: LogswapClient, poolId: Hex): Promise<bigint[]>;
 /**
- * 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 declare function fPoolRegenerate(c: LogswapClient, a: {
     poolId: Hex;
@@ -976,7 +976,7 @@ export declare function fPoolRegenerate(c: LogswapClient, 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`.
@@ -1044,14 +1044,14 @@ export declare function fPoolLaunchCalls(poolId: Hex, a: FPoolLaunchArgs & ({
     x0: bigint[];
 })): Hex[];
 /**
- * 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 declare function fPoolDeskOpening(c: LogswapClient, a: {
     poolId: Hex;
     account: Address;
-    hook?: Address;
+    policy?: Address;
 }): Promise<Hash[]>;
 /**
  * Create a pool as ONE transaction: `initialize`, `seed`, the seed lock, the opening buy, the
@@ -1079,36 +1079,36 @@ export declare function fPoolLaunch(c: LogswapClient, a: FPoolLaunchArgs & ({
     poolId: Hex;
 }>;
 /**
- * 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 declare function fPoolProposeAuthority(c: LogswapClient, a: {
     poolId: Hex;
     next: Address;
     account: Address;
-    hook?: Address;
+    policy?: Address;
 }): Promise<`0x${string}`>;
 /**
- * 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 declare function fPoolAcceptAuthority(c: LogswapClient, a: {
     poolId: Hex;
     account: Address;
-    hook?: Address;
+    policy?: Address;
 }): Promise<`0x${string}`>;
-/** Turn the mint / swap gates on or off (the authority, on the desk's hook). `burn` is never gated. */
+/** Turn the mint / swap gates on or off (the authority, on the desk's policy). `burn` is never gated. */
 export declare function fPoolSetGates(c: LogswapClient, a: {
     poolId: Hex;
     gateMint: boolean;
     gateSwap: boolean;
     account: Address;
-    hook?: Address;
+    policy?: Address;
 }): Promise<`0x${string}`>;
 /**
- * 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 declare function fPoolSetAllowed(c: LogswapClient, a: {
@@ -1116,10 +1116,10 @@ export declare function fPoolSetAllowed(c: LogswapClient, a: {
     who: readonly Address[];
     allowed: boolean;
     account: Address;
-    hook?: Address;
+    policy?: Address;
 }): Promise<`0x${string}`>;
 /** Whether `who` is on the pool's list under its current authority (consulted only while a gate is on). */
-export declare function fPoolIsAllowed(c: LogswapClient, poolId: Hex, who: Address, hook?: Address): Promise<boolean>;
+export declare function fPoolIsAllowed(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean>;
 /** Label the pool — the sponsor's own words, mutable, never identity. At most 31 bytes of UTF-8. */
 export declare function fPoolSetName(c: LogswapClient, a: {
     poolId: Hex;
@@ -1140,7 +1140,7 @@ export declare function fPoolSponsorName(c: LogswapClient, who: Address): Promis
 /** Who runs the pool (decisions 037): the appointed operator, or the authority until one is. */
 export declare function fPoolOperatorOf(s: Pick<FPoolRoles, "authority" | "operator">): Address;
 /**
- * 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.
  */
@@ -1148,13 +1148,13 @@ export declare function fPoolAppointOperator(c: LogswapClient, a: {
     poolId: Hex;
     operator: Address;
     account: Address;
-    hook?: Address;
+    policy?: Address;
 }): Promise<`0x${string}`>;
 /** The proposed operator takes the role. */
 export declare function fPoolAcceptOperator(c: LogswapClient, a: {
     poolId: Hex;
     account: Address;
-    hook?: Address;
+    policy?: Address;
 }): Promise<`0x${string}`>;
 /**
  * The next generation's composition (operator; private pools only; ONLY while the pool is
@@ -1189,9 +1189,9 @@ export interface DiscoveredFPool {
     weights: bigint[];
     phi: bigint;
     kind: FPoolKind;
-    /** The pool's policy — the hook the key names (decisions 041, 044). */
-    hook: Address;
-    /** Who was born holding the pool (immutable). The LIVE authority is the hook's — {@link getFPoolRoles}. */
+    /** The pool's policy — the contract the key names (decisions 041, 044, 045). */
+    policy: Address;
+    /** Who was born holding the pool (immutable). The LIVE authority is the policy's — {@link getFPoolRoles}. */
     creator: Address;
     /** The block the pool was initialized in — its age, for annualising realized income. */
     block: bigint;
@@ -1221,11 +1221,11 @@ export interface FPoolControlled {
     pool: DiscoveredFPool;
     roles: FPoolRoles;
     state: FPoolState;
-    /** The hook's numbers for this pool's kind — a pad's rung and threshold, a POL's floors, the desk's list flags. */
-    policy: FPoolPolicy;
+    /** The policy's numbers for this pool's kind — a pad's rung and threshold, a POL's floors, the desk's list flags. */
+    rules: FPoolRules;
 }
-/** What a pool's hook says about it, by kind: the terms a buyer reads before entering. */
-export type FPoolPolicy = {
+/** What a pool's policy says about it, by kind: the terms a buyer reads before entering. */
+export type FPoolRules = {
     kind: "pad";
     harvestCut: bigint;
     rung: number;
@@ -1250,10 +1250,10 @@ export type FPoolPolicy = {
     gateSwap: boolean;
     operator: Address;
 };
-/** The hook's terms for one pool, by its kind. */
-export declare function getFPoolPolicy(c: LogswapClient, s: Pick<FPoolState, "poolId" | "hook" | "kind" | "gen">, roles?: FPoolRoles): Promise<FPoolPolicy>;
+/** The policy's terms for one pool, by its kind. */
+export declare function getFPoolRules(c: LogswapClient, s: Pick<FPoolState, "poolId" | "policy" | "kind" | "gen">, roles?: FPoolRoles): Promise<FPoolRules>;
 /**
- * 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.
  */