@logswap/sdk 0.5.50 → 0.5.51

package/dist/admin.d.ts

@@ -1,63 +1,71 @@
 /**
- * admin — the protocol's (feeCollector's) writes: the protocol's cut of the mint fee on both
- * 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.
+ * admin — the protocol's writes: the C manager's cut of the mint fee (the F manager's is a
+ * constant, decisions 049), the policies a pool may be born with (the registry's), the
+ * policies' own numbers, and the two-step collector handover. Plain writes to the managers,
+ * the registry 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 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`).
+ * `MINT_FEE_PROTOCOL_CUT`; C sets it through `setFeeParams(uint256)`, F holds it as a constant
+ * (049). 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 { type FPoolKind } from "./fpool.js";
 /** The C manager's `setFeeParams(mintFeeProtocolCut)` — one cut. */
 export declare function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash>;
-/** 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>;
+/** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18 (decisions 049); there is no setter. */
+export declare function fMintFeeProtocolCut(c: LogswapClient): Promise<bigint>;
 /**
  * The policy registry the F manager asks at every birth — `addresses.policyRegistry` when the
  * deployment carries it, else read once from the manager. The zero address is a deployment with
  * no registry: it asks nobody, and nothing here can be written.
  */
 export declare function policyRegistryOf(c: LogswapClient): Promise<Address>;
-/** Whether `policy` is approved for pools of `kind` now — listed and not yet sunset. True everywhere on a deployment with no registry. */
-export declare function policyApproved(c: LogswapClient, kind: FPoolKind, policy: Address): Promise<boolean>;
-/** One policy on a kind's list, as the registry holds it. */
+/** Whether `policy` is approved now — listed and not yet sunset. True everywhere on a deployment with no registry. */
+export declare function policyApproved(c: LogswapClient, policy: Address): Promise<boolean>;
+/** One policy on the registry's list, with what it says it is. */
 export interface RegistryEntry {
     policy: Address;
+    /** The policy's own `kind()` tag (decisions 049) — what a pool born under it is. */
+    kind: FPoolKind;
     name: string;
     /** The block it closes to new pools from; 0 = open. */
     until: bigint;
     /** Approved now: listed and not yet sunset. */
     approved: boolean;
 }
-/** Every policy listed for `kind`, sunset ones included — what a create form's dropdown reads. Empty with no registry. */
-export declare function registryPolicies(c: LogswapClient, kind: FPoolKind): Promise<RegistryEntry[]>;
+/**
+ * Every policy listed, sunset ones included — one flat list (decisions 049), each with the kind
+ * it says it is; `kind` narrows it to one, which is what a create form's dropdown reads. Empty
+ * with no registry.
+ */
+export declare function registryPolicies(c: LogswapClient, kind?: FPoolKind): Promise<RegistryEntry[]>;
 /** The registry's owner — the LOG authority — and the proposed next one. */
 export declare function registryOwner(c: LogswapClient): Promise<{
     owner: Address;
     pending: Address;
 }>;
-/** `PolicyRegistry.approve`: list `policy` for pools of `kind`, under `name` (at most 31 bytes). Again renames it and clears its sunset. The owner's. */
-export declare function registryApprove(c: LogswapClient, kind: FPoolKind, policy: Address, name: string): Promise<Hash>;
-/** `PolicyRegistry.sunset`: close `policy` to new pools of `kind` from `untilBlock` on; 0 reopens. The owner's. */
-export declare function registrySunset(c: LogswapClient, kind: FPoolKind, policy: Address, untilBlock: bigint): Promise<Hash>;
-/** `PolicyRegistry.revoke`: remove `policy` from `kind`'s list at once. Live pools are untouched. The owner's. */
-export declare function registryRevoke(c: LogswapClient, kind: FPoolKind, policy: Address): Promise<Hash>;
+/** `PolicyRegistry.approve`: list `policy` under `name` (at most 31 bytes). Again renames it and clears its sunset. The owner's. */
+export declare function registryApprove(c: LogswapClient, policy: Address, name: string): Promise<Hash>;
+/** `PolicyRegistry.sunset`: close `policy` to new pools from `untilBlock` on; 0 reopens. The owner's. */
+export declare function registrySunset(c: LogswapClient, policy: Address, untilBlock: bigint): Promise<Hash>;
+/** `PolicyRegistry.revoke`: remove `policy` from the list at once. Live pools are untouched. The owner's. */
+export declare function registryRevoke(c: LogswapClient, policy: Address): Promise<Hash>;
 /** The registry owner's two-step handover. */
 export declare function registryProposeOwner(c: LogswapClient, next: Address): Promise<Hash>;
 export declare function registryAcceptOwner(c: LogswapClient): Promise<Hash>;
 /**
  * Approve or revoke, the F version 15–16 shape kept for callers: `approved` true is
- * {@link registryApprove} under the kind's name, false is {@link registryRevoke}.
+ * {@link registryApprove} under the policy's own tag as its name, false is {@link registryRevoke}.
  */
-export declare function setPolicyApproved(c: LogswapClient, kind: FPoolKind, policy: Address, approved: boolean): Promise<Hash>;
+export declare function setPolicyApproved(c: LogswapClient, policy: Address, approved: boolean): Promise<Hash>;
 /**
- * Move a pool to another policy the registry approves for its kind (decisions 046): the registry
- * owner's alone. The new policy takes the authority from the old; the operator and the lists
- * void; no swap lands in the block.
+ * Move a pool to another approved policy of the same kind (decisions 046, 049): the registry
+ * owner's alone, orchestrated on the registry — `migrate(manager, poolId, to)`. The new policy
+ * takes the authority and the name from the old; the operator and the lists void; no swap lands
+ * in the block.
  */
 export declare function fPoolMigrate(c: LogswapClient, a: {
     poolId: `0x${string}`;
@@ -78,6 +86,16 @@ export declare function polSetRules(c: LogswapClient, policy: Address, s: {
     keepQuote: bigint;
     minQuoteAtSeed: bigint;
 }): Promise<Hash>;
+/** `setQuoteListed` on any protocol policy: a quote a pool of that kind may be born against while it curates quotes. The collector's. */
+export declare function policySetQuoteListed(c: LogswapClient, policy: Address, quote: Address, listed: boolean): Promise<Hash>;
+/** `setQuoteCurated` on any protocol policy: on, a birth against an unlisted quote is refused. The collector's. */
+export declare function policySetQuoteCurated(c: LogswapClient, policy: Address, curated: boolean): Promise<Hash>;
+/** Whether `quote` passes `policy`'s birth check now: listed, or the policy does not curate quotes. */
+export declare function policyQuoteAllowed(c: LogswapClient, policy: Address, quote: Address): Promise<{
+    curated: boolean;
+    listed: boolean;
+    allowed: boolean;
+}>;
 /** `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. */

package/dist/admin.js

@@ -1,16 +1,17 @@
 /**
- * admin — the protocol's (feeCollector's) writes: the protocol's cut of the mint fee on both
- * 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.
+ * admin — the protocol's writes: the C manager's cut of the mint fee (the F manager's is a
+ * constant, decisions 049), the policies a pool may be born with (the registry's), the
+ * policies' own numbers, and the two-step collector handover. Plain writes to the managers,
+ * the registry 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 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`).
+ * `MINT_FEE_PROTOCOL_CUT`; C sets it through `setFeeParams(uint256)`, F holds it as a constant
+ * (049). 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, padPolicyAbi, polPolicyAbi, policyRegistryAbi, publicPolicyAbi } from "./generated.js";
-import { F_KIND, bytes32ToText, fPolicyBaseAbi, textToBytes32 } from "./fpool.js";
+import { bytes32ToText, fPolicyBaseAbi, fPoolKindOfPolicy, textToBytes32 } from "./fpool.js";
 function wallet(c) {
     if (!c.wallet)
         throw new Error("a wallet client is required");
@@ -23,9 +24,9 @@ function write(c, address, abi, functionName, args) {
 export async function setFeeParamsC(c, mintFeeProtocolCutWad) {
     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, mintFeeProtocolCutWad) {
-    return write(c, c.addresses.fPoolManager, fPoolManagerAbi, "setFeeParams", [mintFeeProtocolCutWad]);
+/** The F manager's `MINT_FEE_PROTOCOL_CUT` — a constant since F version 18 (decisions 049); there is no setter. */
+export async function fMintFeeProtocolCut(c) {
+    return c.public.readContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "MINT_FEE_PROTOCOL_CUT" });
 }
 // ─── the registry (decisions 046): the LOG authority's, not the collector's ─────────────────
 const ZERO = "0x0000000000000000000000000000000000000000";
@@ -39,24 +40,32 @@ export async function policyRegistryOf(c) {
         return c.addresses.policyRegistry;
     return (await c.public.readContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "registry" }));
 }
-/** Whether `policy` is approved for pools of `kind` now — listed and not yet sunset. True everywhere on a deployment with no registry. */
-export async function policyApproved(c, kind, policy) {
+/** Whether `policy` is approved now — listed and not yet sunset. True everywhere on a deployment with no registry. */
+export async function policyApproved(c, policy) {
     const registry = await policyRegistryOf(c);
     if (registry === ZERO)
         return true;
-    return c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "isApproved", args: [F_KIND[kind], policy] });
+    return c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "isApproved", args: [policy] });
 }
-/** Every policy listed for `kind`, sunset ones included — what a create form's dropdown reads. Empty with no registry. */
+/**
+ * Every policy listed, sunset ones included — one flat list (decisions 049), each with the kind
+ * it says it is; `kind` narrows it to one, which is what a create form's dropdown reads. Empty
+ * with no registry.
+ */
 export async function registryPolicies(c, kind) {
     const registry = await policyRegistryOf(c);
     if (registry === ZERO)
         return [];
-    const list = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "policiesOf", args: [F_KIND[kind]] }));
+    const list = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "policies" }));
     const block = await c.public.getBlockNumber();
-    return Promise.all(list.map(async (policy) => {
-        const [listed, until, , name] = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "entries", args: [F_KIND[kind], policy] }));
-        return { policy, name: bytes32ToText(name), until, approved: listed && (until === 0n || block < until) };
+    const all = await Promise.all(list.map(async (policy) => {
+        const [[listed, until, , name], tag] = await Promise.all([
+            c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "entries", args: [policy] }),
+            fPoolKindOfPolicy(c, policy),
+        ]);
+        return { policy, kind: tag, name: bytes32ToText(name), until, approved: listed && (until === 0n || block < until) };
     }));
+    return kind ? all.filter((e) => e.kind === kind) : all;
 }
 /** The registry's owner — the LOG authority — and the proposed next one. */
 export async function registryOwner(c) {
@@ -75,17 +84,17 @@ async function registryWrite(c, functionName, args) {
         throw new Error("logswap: this deployment carries no policy registry");
     return write(c, registry, policyRegistryAbi, functionName, args);
 }
-/** `PolicyRegistry.approve`: list `policy` for pools of `kind`, under `name` (at most 31 bytes). Again renames it and clears its sunset. The owner's. */
-export async function registryApprove(c, kind, policy, name) {
-    return registryWrite(c, "approve", [F_KIND[kind], policy, textToBytes32(name)]);
+/** `PolicyRegistry.approve`: list `policy` under `name` (at most 31 bytes). Again renames it and clears its sunset. The owner's. */
+export async function registryApprove(c, policy, name) {
+    return registryWrite(c, "approve", [policy, textToBytes32(name)]);
 }
-/** `PolicyRegistry.sunset`: close `policy` to new pools of `kind` from `untilBlock` on; 0 reopens. The owner's. */
-export async function registrySunset(c, kind, policy, untilBlock) {
-    return registryWrite(c, "sunset", [F_KIND[kind], policy, untilBlock]);
+/** `PolicyRegistry.sunset`: close `policy` to new pools from `untilBlock` on; 0 reopens. The owner's. */
+export async function registrySunset(c, policy, untilBlock) {
+    return registryWrite(c, "sunset", [policy, untilBlock]);
 }
-/** `PolicyRegistry.revoke`: remove `policy` from `kind`'s list at once. Live pools are untouched. The owner's. */
-export async function registryRevoke(c, kind, policy) {
-    return registryWrite(c, "revoke", [F_KIND[kind], policy]);
+/** `PolicyRegistry.revoke`: remove `policy` from the list at once. Live pools are untouched. The owner's. */
+export async function registryRevoke(c, policy) {
+    return registryWrite(c, "revoke", [policy]);
 }
 /** The registry owner's two-step handover. */
 export async function registryProposeOwner(c, next) {
@@ -96,18 +105,19 @@ export async function registryAcceptOwner(c) {
 }
 /**
  * Approve or revoke, the F version 15–16 shape kept for callers: `approved` true is
- * {@link registryApprove} under the kind's name, false is {@link registryRevoke}.
+ * {@link registryApprove} under the policy's own tag as its name, false is {@link registryRevoke}.
  */
-export async function setPolicyApproved(c, kind, policy, approved) {
-    return approved ? registryApprove(c, kind, policy, kind) : registryRevoke(c, kind, policy);
+export async function setPolicyApproved(c, policy, approved) {
+    return approved ? registryApprove(c, policy, await fPoolKindOfPolicy(c, policy)) : registryRevoke(c, policy);
 }
 /**
- * Move a pool to another policy the registry approves for its kind (decisions 046): the registry
- * owner's alone. The new policy takes the authority from the old; the operator and the lists
- * void; no swap lands in the block.
+ * Move a pool to another approved policy of the same kind (decisions 046, 049): the registry
+ * owner's alone, orchestrated on the registry — `migrate(manager, poolId, to)`. The new policy
+ * takes the authority and the name from the old; the operator and the lists void; no swap lands
+ * in the block.
  */
 export async function fPoolMigrate(c, a) {
-    return write(c, c.addresses.fPoolManager, fPoolManagerAbi, "migrate", [a.poolId, a.to]);
+    return registryWrite(c, "migrate", [c.addresses.fPoolManager, a.poolId, a.to]);
 }
 // ─── 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`. */
@@ -122,6 +132,22 @@ export async function padSetSchedule(c, policy, s) {
 export async function polSetRules(c, policy, s) {
     return write(c, policy, polPolicyAbi, "setRules", [s.keepQuote, s.minQuoteAtSeed]);
 }
+/** `setQuoteListed` on any protocol policy: a quote a pool of that kind may be born against while it curates quotes. The collector's. */
+export async function policySetQuoteListed(c, policy, quote, listed) {
+    return write(c, policy, fPolicyBaseAbi, "setQuoteListed", [quote, listed]);
+}
+/** `setQuoteCurated` on any protocol policy: on, a birth against an unlisted quote is refused. The collector's. */
+export async function policySetQuoteCurated(c, policy, curated) {
+    return write(c, policy, fPolicyBaseAbi, "setQuoteCurated", [curated]);
+}
+/** Whether `quote` passes `policy`'s birth check now: listed, or the policy does not curate quotes. */
+export async function policyQuoteAllowed(c, policy, quote) {
+    const [curated, listed] = await Promise.all([
+        c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "quoteCurated" }),
+        c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "quoteListed", args: [quote] }),
+    ]);
+    return { curated, listed, allowed: !curated || 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]);

package/dist/client.d.ts

@@ -83,5 +83,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 = 17n;
+export declare const EXPECTED_F_VERSION = 18n;
 export declare function assertVersion(c: LogswapClient, expected?: bigint): Promise<void>;

package/dist/client.js

@@ -89,7 +89,7 @@ export const EXPECTED_VERSION = 4n;
 // is the policy at birth, `migrate` moves a pool for the registry's owner; `stamp` / `setAsks` are
 // the policy's; the desk's `setAllowed` / `isAllowed` are `setMinters` / `setTakers` / `isMinter` /
 // `isTaker`; a pad and a POL hold one base (`OneBase`).
-export const EXPECTED_F_VERSION = 17n;
+export const EXPECTED_F_VERSION = 18n;
 export async function assertVersion(c, expected = EXPECTED_VERSION) {
     const { cPoolManagerAbi } = await import("./generated.js");
     const got = await c.public.readContract({