@logswap/sdk 0.5.50 → 0.5.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.50",
+  "version": "0.5.51",
   "description": "TypeScript SDK for Logswap, the liquidity primitive introducing the logarithmic invariant — typed wrappers over the CPoolManager / FPoolManager / Router / Lens surface.",
   "license": "GPL-2.0-or-later",
   "type": "module",

package/src/admin.ts

@@ -1,19 +1,20 @@
 /**
- * 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 { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, publicPolicyAbi } from "./generated.js";
-import { F_KIND, bytes32ToText, fPolicyBaseAbi, textToBytes32, type FPoolKind } from "./fpool.js";
+import { bytes32ToText, fPolicyBaseAbi, fPoolKindOfPolicy, textToBytes32, type FPoolKind } from "./fpool.js";
 
 function wallet(c: LogswapClient) {
   if (!c.wallet) throw new Error("a wallet client is required");
@@ -28,9 +29,9 @@ function write(c: LogswapClient, address: Address, abi: readonly unknown[], func
 export async function setFeeParamsC(c: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash> {
   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: LogswapClient, mintFeeProtocolCutWad: bigint): Promise<Hash> {
-  return write(c, c.addresses.fPoolManager as Address, 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: LogswapClient): Promise<bigint> {
+  return c.public.readContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "MINT_FEE_PROTOCOL_CUT" } as never) as Promise<bigint>;
 }
 
 // ─── the registry (decisions 046): the LOG authority's, not the collector's ─────────────────
@@ -47,16 +48,18 @@ export async function policyRegistryOf(c: LogswapClient): Promise<Address> {
   return (await c.public.readContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "registry" } as never)) as Address;
 }
 
-/** 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: LogswapClient, kind: FPoolKind, policy: Address): Promise<boolean> {
+/** Whether `policy` is approved now — listed and not yet sunset. True everywhere on a deployment with no registry. */
+export async function policyApproved(c: LogswapClient, policy: Address): Promise<boolean> {
   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] } as never) as Promise<boolean>;
+  return c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "isApproved", args: [policy] } as never) as Promise<boolean>;
 }
 
-/** One policy on a kind's list, as the registry holds it. */
+/** 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;
@@ -64,18 +67,26 @@ export interface RegistryEntry {
   approved: boolean;
 }
 
-/** Every policy listed for `kind`, sunset ones included — what a create form's dropdown reads. Empty with no registry. */
-export async 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 async function registryPolicies(c: LogswapClient, kind?: FPoolKind): Promise<RegistryEntry[]> {
   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]] } as never)) as readonly Address[];
+  const list = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "policies" } as never)) as readonly Address[];
   const block = await c.public.getBlockNumber();
-  return Promise.all(
+  const all = await 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] } as never)) as [boolean, bigint, number, `0x${string}`];
-      return { policy, name: bytes32ToText(name), until, approved: listed && (until === 0n || block < until) };
+      const [[listed, until, , name], tag] = await Promise.all([
+        c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "entries", args: [policy] } as never) as Promise<[boolean, bigint, number, `0x${string}`]>,
+        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. */
@@ -95,19 +106,19 @@ async function registryWrite(c: LogswapClient, functionName: string, args: reado
   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: LogswapClient, kind: FPoolKind, policy: Address, name: string): Promise<Hash> {
-  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: LogswapClient, policy: Address, name: string): Promise<Hash> {
+  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: LogswapClient, kind: FPoolKind, policy: Address, untilBlock: bigint): Promise<Hash> {
-  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: LogswapClient, policy: Address, untilBlock: bigint): Promise<Hash> {
+  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: LogswapClient, kind: FPoolKind, policy: Address): Promise<Hash> {
-  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: LogswapClient, policy: Address): Promise<Hash> {
+  return registryWrite(c, "revoke", [policy]);
 }
 
 /** The registry owner's two-step handover. */
@@ -120,19 +131,20 @@ export async 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 async function setPolicyApproved(c: LogswapClient, kind: FPoolKind, policy: Address, approved: boolean): Promise<Hash> {
-  return approved ? registryApprove(c, kind, policy, kind) : registryRevoke(c, kind, policy);
+export async function setPolicyApproved(c: LogswapClient, policy: Address, approved: boolean): Promise<Hash> {
+  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: LogswapClient, a: { poolId: `0x${string}`; to: Address }): Promise<Hash> {
-  return write(c, c.addresses.fPoolManager as Address, fPoolManagerAbi, "migrate", [a.poolId, a.to]);
+  return registryWrite(c, "migrate", [c.addresses.fPoolManager as Address, a.poolId, a.to]);
 }
 
 // ─── the policies' numbers (the collector's; each bounded where it reaches the manager) ─────
@@ -156,6 +168,25 @@ export async function polSetRules(c: LogswapClient, policy: Address, s: { keepQu
   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: LogswapClient, policy: Address, quote: Address, listed: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, curated: boolean): Promise<Hash> {
+  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: LogswapClient, policy: Address, quote: Address): Promise<{ curated: boolean; listed: boolean; allowed: boolean }> {
+  const [curated, listed] = await Promise.all([
+    c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "quoteCurated" } as never) as Promise<boolean>,
+    c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "quoteListed", args: [quote] } as never) as Promise<boolean>,
+  ]);
+  return { curated, listed, allowed: !curated || 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]);

package/src/client.ts

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

package/src/fpool.ts

@@ -31,7 +31,7 @@
  */
 
 import { encodeFunctionData, toFunctionSelector, type Address, type Hash, type Hex } from "viem";
-import { fPoolManagerAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
+import { fPoolManagerAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 
 /**
  * One contract, one ABI (decisions 039, F version 12): `harvest`, `claim`, `retire`, `regenerate`,
@@ -88,11 +88,11 @@ export interface FPoolState {
   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. */
+  /** The sponsor's own label for this pool — the policy's word (decisions 049), mutable and never identity. "" when unnamed. */
   name: string;
   /** The block of the last harvest / composition action: no swap runs in it. */
   restructureBlock: number;
-  /** The rung — see {@link FPoolKind}. */
+  /** What the pool is — its POLICY's self-description (decisions 049); see {@link FPoolKind}. */
   kind: FPoolKind;
   /** False before the first seed — and between a retire and the next one (decisions 032). */
   seeded: boolean;
@@ -120,12 +120,12 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
     } as never) as Promise<T>;
 
   // `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 policy's.
+  // to be a dozen getters a single read. No role in it since F version 15, no kind and no name
+  // since 18: those are the policy's.
   const p = await rd<{
     quote: Address;
     phi: bigint;
     policy: Address;
-    kind: number;
     seeded: boolean;
     gen: number;
     n: number;
@@ -136,7 +136,6 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
     L: bigint;
     shares: bigint;
     theta0: bigint;
-    name: Hex;
   }>("getPool", [poolId]);
 
   // A pool that was never created reads as an all-zero struct rather than reverting, so the
@@ -148,12 +147,14 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
 
   const n = Number(p.n);
   const idx = Array.from({ length: n }, (_, i) => BigInt(i));
-  const [theta, compositeX, legs] = await Promise.all([
+  const [theta, compositeX, legs, kind, name] = await Promise.all([
     // before the seed there is no L and no floor: θ is X by convention (the manager says so since
     // bd3dd87's successor; older deployments revert with DivWadFailed, so do not ask them)
     p.L > 0n ? rd<bigint>("theta", [poolId]) : rd<bigint>("compositeX", [poolId]),
     rd<bigint>("compositeX", [poolId]),
     Promise.all(idx.map((i) => rd<readonly [Address, bigint, bigint, bigint]>("legOf", [poolId, i]))),
+    fPoolKindOfPolicy(c, p.policy),
+    fPoolNameOf(c, poolId, p.policy),
   ]);
 
   const bases = legs.map((l) => l[0]);
@@ -178,9 +179,9 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
     bigSigma,
     policy,
     asks: Number(p.asks),
-    name: bytes32ToText(p.name),
+    name,
     restructureBlock: Number(restructureBlock),
-    kind: fPoolKindOf(p.kind),
+    kind,
     seeded,
     gen: Number(gen),
     totalSupply,
@@ -189,26 +190,50 @@ export async function getFPool(c: LogswapClient, poolId: Hex): Promise<FPoolStat
 }
 
 /**
- * The kind of pool (decisions 036, 038, 044) — what the manager promises structurally, whatever
- * 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 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 policy's.
+ * The kind of pool — the POLICY's self-description (decisions 049: the manager knows no kind; the
+ * policy the key names is the kind, and what it promises is its code). `public`: the protocol's
+ * own pool — its policy requires the collector as creator; no gate, no operator. `private`, the
+ * desk: the one whose policy may gate swaps and mints, with an operator that reshapes the legs
+ * between generations. `pol`, a treasury's pool, one base: composition and access fixed at
+ * birth. `pad`, a launch, one base: its policy answers income only at every harvest and declared
+ * its seed the pool's at birth (`SEED_TO_DEAD`) — 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 policy's.
  */
 export type FPoolKind = "public" | "private" | "pol" | "pad";
-/** The key's enum values. */
-export const F_KIND = { public: 0, private: 1, pol: 2, pad: 3 } as const;
 const F_KIND_NAMES: readonly FPoolKind[] = ["public", "private", "pol", "pad"];
-export function fPoolKindOf(n: number | bigint): FPoolKind {
-  const k = F_KIND_NAMES[Number(n)];
-  if (!k) throw new Error(`logswap: unknown pool kind ${n}`);
-  return k;
+/** The policy's birth-time declaration that the seed's shares are the pool's (a pad's), in `asks`. */
+export const SEED_TO_DEAD = 4;
+
+const kindCache = new Map<string, Promise<FPoolKind>>();
+
+/**
+ * What a policy IS — its `kind()` tag, read once per policy address and cached for the client's
+ * chain: a pool's kind is its policy's word (decisions 049), never the manager's. An unknown tag
+ * (a policy that is not one of the protocol's four shapes) throws; the app has no screen for it.
+ */
+export function fPoolKindOfPolicy(c: LogswapClient, policy: Address): Promise<FPoolKind> {
+  const key = `${c.public.chain?.id ?? 0}:${policy.toLowerCase()}`;
+  let hit = kindCache.get(key);
+  if (!hit) {
+    hit = (c.public.readContract({ address: policy, abi: fPolicyBaseAbi, functionName: "kind" } as never) as Promise<Hex>).then((word) => {
+      const tag = bytes32ToText(word) as FPoolKind;
+      if (!F_KIND_NAMES.includes(tag)) throw new Error(`logswap: policy ${policy} says it is "${tag}", which is no kind this SDK knows`);
+      return tag;
+    });
+    kindCache.set(key, hit);
+    hit.catch(() => kindCache.delete(key)); // a failed read is not a fact
+  }
+  return hit;
+}
+
+/** The pool's label, as its policy holds it (decisions 049). "" when unnamed. */
+export async function fPoolNameOf(c: LogswapClient, poolId: Hex, policy?: Address): Promise<string> {
+  const p = policy ?? (await fPoolPolicyOf(c, poolId));
+  const word = (await c.public.readContract({ address: p, abi: fPolicyBaseAbi, functionName: "nameOf", args: [poolId] } as never)) as Hex;
+  return bytes32ToText(word);
 }
 
-/** The deployment's policy for a kind (decisions 044): what a key of that kind names. */
+/** The deployment's policy for a kind (decisions 044, 049): the protocol's policy that IS that kind. */
 export function fPoolPolicyFor(c: LogswapClient, kind: FPoolKind): Address {
   const a = c.addresses;
   const policy = kind === "public" ? a.publicPolicy : kind === "private" ? a.privatePolicy : kind === "pol" ? a.polPolicy : a.padPolicy;
@@ -811,8 +836,8 @@ export async function fPoolQuoteSwap(
 ): Promise<bigint> {
   try {
     await c.public.simulateContract({
-      address: c.addresses.fPoolManager!,
-      abi: fPoolManagerAbi,
+      address: c.addresses.router,
+      abi: logswapRouterAbi,
       functionName: "quoteSwap",
       // the taker matters only on a gated pool: the connected account, or the zero address
       args: [a.poolId, a.kind, BigInt(a.j), BigInt(a.k ?? 0), a.amountIn, a.taker ?? c.wallet?.account?.address ?? ZERO_ADDRESS],
@@ -866,12 +891,16 @@ export interface FPoolCreateArgs {
   weights: bigint[];
   /** Fixed fee, WAD. The base-for-base fee is pinned at 2φ on-chain. */
   phi: bigint;
-  /** The rung (decisions 036) — see {@link FPoolKind}. In the key: the pool's identity, never changed after. */
+  /**
+   * Which of the protocol's four the pool is — see {@link FPoolKind}. NOT a key field (decisions
+   * 049: the manager knows no kind): it selects the deployment's policy of that kind when `policy`
+   * is not named ({@link fPoolPolicyFor}), and it is what the policy will say it is.
+   */
   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 policy for `kind` ({@link fPoolPolicyFor}) — the one
-   * every protocol pool names.
+   * The pool's policy (decisions 041, 044, 049): the contract the key names, approved by the
+   * registry, and the pool's kind. Defaults to the deployment's policy for `kind`
+   * ({@link fPoolPolicyFor}) — the one every protocol pool names.
    */
   policy?: Address;
   /** Who is born holding the pool: immutable identity, the pool's first authority (the policy records it). */
@@ -880,7 +909,7 @@ export interface FPoolCreateArgs {
    * The differentiator, and nothing else. Identity is the key's hash, so one sponsor cannot run
    * two pools of the same shape without varying it — the second `initialize` would land on the
    * first pool's id. Defaults to zero, which is the first book of any shape. A pool's NAME is not
-   * this: names are mutable state (`fPoolSetName`), so a rename forks nothing.
+   * this: names are the policy's mutable state (`fPoolSetName`), so a rename forks nothing.
    */
   salt?: Hex;
   account: Address;
@@ -909,7 +938,7 @@ export function sortFPoolLegs<T>(bases: Address[], ...companions: T[][]): { base
   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 policy 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; no kind in it (049). */
 export function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">) {
   const { bases, companions } = sortFPoolLegs(a.bases, a.weights);
   return {
@@ -917,7 +946,6 @@ export function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">
     bases,
     weights: companions[0]!,
     phi: a.phi,
-    kind: F_KIND[a.kind],
     policy: a.policy ?? fPoolPolicyFor(c, a.kind),
     creator: a.creator,
     salt: a.salt ?? ZERO_SALT,
@@ -1092,7 +1120,7 @@ export interface FPoolLaunchArgs extends Omit<FPoolCreateArgs, "account"> {
    * this buy — they are one transaction — so `minOut` is safe at its default of 0.
    */
   openBuy?: { j: number; amountIn: bigint; minOut?: bigint };
-  /** The pool's label, set in the batch (≤ 31 bytes of UTF-8). */
+  /** The pool's label (≤ 31 bytes of UTF-8) — the policy's word (049), written right after the batch by {@link fPoolLaunch}; not in the batch. */
   name?: string;
   /**
    * The pool already exists (a previous launch got as far as `initialize` and no further — a seed
@@ -1121,7 +1149,7 @@ export function fPoolLaunchCalls(
   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.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 key = { quote: a.quote, bases, weights: companions[0]!, phi: a.phi, policy: a.policy, creator: a.creator, salt: a.salt ?? ZERO_SALT };
   const enc = (functionName: string, args: unknown[]) =>
     encodeFunctionData({ abi: fPoolManagerAbi, functionName, args } as never) as Hex;
   const calls: Hex[] = [];
@@ -1134,9 +1162,9 @@ export function fPoolLaunchCalls(
     if (j < 0) throw new Error(`logswap: openBuy.j = ${a.openBuy.j} is not a leg`);
     calls.push(enc("swapQuoteIn", [poolId, BigInt(j), a.openBuy.amountIn, a.openBuy.minOut ?? 0n, a.account]));
   }
-  if (a.name) calls.push(enc("setName", [poolId, textToBytes32(a.name)]));
-  // 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
+  // the name, the desk's gates and its list are the POLICY's (decisions 044, 049), not the
+  // manager's: they cannot ride in this batch — `fPoolLaunch` and `fPoolDeskOpening` send them
+  // right after, as the same creator
   calls.push(...(a.extra ?? []));
   return calls;
 }
@@ -1176,8 +1204,10 @@ export async function fPoolLaunch(
   a: FPoolLaunchArgs & ({ r0: bigint[] } | { x0: bigint[] }),
 ): Promise<{ hash: Hash; poolId: Hex }> {
   const poolId = await fPoolIdOf(c, a);
-  const calls = fPoolLaunchCalls(poolId, { ...a, policy: a.policy ?? fPoolPolicyFor(c, a.kind) });
+  const policy = a.policy ?? fPoolPolicyFor(c, a.kind);
+  const calls = fPoolLaunchCalls(poolId, { ...a, policy });
   const hash = await writeFPool0(c, "multicall", [calls], a.account);
+  if (a.name) await fPoolSetName(c, { poolId, name: a.name, account: a.account, policy });
   return { hash, poolId };
 }
 
@@ -1269,20 +1299,22 @@ export async function fPoolIsAllowed(c: LogswapClient, poolId: Hex, who: Address
   return readDesk<boolean>(c, poolId, who, "isAllowed", policy);
 }
 
-/** Label the pool — the sponsor's own words, mutable, never identity. At most 31 bytes of UTF-8. */
-export async function fPoolSetName(c: LogswapClient, a: { poolId: Hex; name: string; account: Address }) {
-  return writeFPool(c, a.poolId, "setName", [textToBytes32(a.name)], a.account);
+/** Label the pool — the authority's own words on the pool's POLICY (decisions 049), mutable, never identity. At most 31 bytes of UTF-8. */
+export async function fPoolSetName(c: LogswapClient, a: { poolId: Hex; name: string; account: Address; policy?: Address }) {
+  return writePolicy(c, fPolicyBaseAbi, a, "setName", [textToBytes32(a.name)]);
 }
 
 /**
- * What the PROTOCOL says an address is — "Keyrock". Only `feeCollector` may write it, which is
- * what makes it an attestation rather than a claim anyone could make about themselves.
+ * What the PROTOCOL says an address is — "Keyrock" — on the REGISTRY (decisions 049). Only its
+ * owner, the LOG authority, may write it, which is what makes it an attestation rather than a
+ * claim anyone could make about themselves.
  */
 export async function fPoolSetSponsorName(c: LogswapClient, a: { who: Address; name: string; account: Address }) {
   const wallet = requireWallet(c);
+  const registry = await registryAddress(c);
   const { request } = await c.public.simulateContract({
-    address: c.addresses.fPoolManager!,
-    abi: fPoolManagerAbi,
+    address: registry,
+    abi: policyRegistryAbi,
     functionName: "setSponsorName",
     args: [a.who, textToBytes32(a.name)],
     account: a.account,
@@ -1290,17 +1322,26 @@ export async function fPoolSetSponsorName(c: LogswapClient, a: { who: Address; n
   return wallet.writeContract(request as never);
 }
 
-/** The protocol's attestation for an address, or "" when unattested — which most addresses are. */
+/** The protocol's attestation for an address, or "" when unattested — which most addresses are, and every address on a deployment with no registry. */
 export async function fPoolSponsorName(c: LogswapClient, who: Address): Promise<string> {
-  const word = (await c.public.readContract({
-    address: c.addresses.fPoolManager!,
-    abi: fPoolManagerAbi,
-    functionName: "sponsorName",
-    args: [who],
-  } as never)) as Hex;
+  const registry = c.addresses.policyRegistry ?? (await fPoolRegistryOf(c));
+  if (registry === ZERO_ADDRESS) return "";
+  const word = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "sponsorName", args: [who] } as never)) as Hex;
   return bytes32ToText(word);
 }
 
+/** The registry the manager asks at every birth — `addresses.policyRegistry`, else the manager's word; zero on a bare deployment. */
+export async function fPoolRegistryOf(c: LogswapClient): Promise<Address> {
+  if (c.addresses.policyRegistry) return c.addresses.policyRegistry;
+  return (await c.public.readContract({ address: c.addresses.fPoolManager!, abi: fPoolManagerAbi, functionName: "registry" } as never)) as Address;
+}
+
+async function registryAddress(c: LogswapClient): Promise<Address> {
+  const registry = await fPoolRegistryOf(c);
+  if (registry === ZERO_ADDRESS) throw new Error("logswap: this deployment carries no policy registry");
+  return registry;
+}
+
 /** Who runs the pool (decisions 037): the appointed operator, or the authority until one is. */
 export function fPoolOperatorOf(s: Pick<FPoolRoles, "authority" | "operator">): Address {
   return s.operator === ZERO_ADDRESS ? s.authority : s.operator;
@@ -1385,9 +1426,10 @@ export interface DiscoveredFPool {
 }
 
 /**
- * Every F pool ever created, from `Initialize` logs alone. Possible only because the event
- * carries the full key preimage (bases, weights, phi, pad) — the poolId is a hash and could
- * never be inverted; contracts PR #17 exists for exactly this call.
+ * Every F pool ever created, from `Initialize` logs alone — plus one `kind()` read per distinct
+ * policy, cached. Possible only because the event carries the full key preimage (bases,
+ * weights, phi, policy) — the poolId is a hash and could never be inverted; contracts PR #17
+ * exists for exactly this call.
  */
 export async function discoverFPools(
   c: LogswapClient,
@@ -1414,27 +1456,30 @@ export async function discoverFPools(
     const a = l.args as { poolId: Hex; Q0: bigint };
     q0Of.set(a.poolId.toLowerCase(), a.Q0);
   }
-  return logs.map((l) => {
-    const a = l.args as {
-      poolId: Hex; quote: Address; creator: Address; bases: readonly Address[];
-      weights: readonly bigint[]; phi: bigint; kind: number; policy: Address;
-    };
-    const q0 = q0Of.get(a.poolId.toLowerCase());
-    return {
-      poolId: a.poolId,
-      quote: a.quote,
-      bases: [...a.bases],
-      weights: [...a.weights],
-      phi: a.phi,
-      kind: fPoolKindOf(a.kind),
-      policy: a.policy,
-      creator: a.creator,
-      block: l.blockNumber ?? 0n,
-      seeded: q0 !== undefined,
-      q0: q0 ?? 0n,
-      shape: a.kind === F_KIND.pad ? "launch" : "basket", // the kind, not n = 1: a mono POL is a pool (decisions 036)
-    };
-  });
+  return Promise.all(
+    logs.map(async (l) => {
+      const a = l.args as {
+        poolId: Hex; quote: Address; creator: Address; bases: readonly Address[];
+        weights: readonly bigint[]; phi: bigint; policy: Address;
+      };
+      const q0 = q0Of.get(a.poolId.toLowerCase());
+      const kind = await fPoolKindOfPolicy(c, a.policy); // one read per distinct policy, cached
+      return {
+        poolId: a.poolId,
+        quote: a.quote,
+        bases: [...a.bases],
+        weights: [...a.weights],
+        phi: a.phi,
+        kind,
+        policy: a.policy,
+        creator: a.creator,
+        block: l.blockNumber ?? 0n,
+        seeded: q0 !== undefined,
+        q0: q0 ?? 0n,
+        shape: kind === "pad" ? "launch" : "basket", // the policy's word, not n = 1: a mono POL is a pool (decisions 036, 049)
+      };
+    }),
+  );
 }
 
 // ─── the policy page: what an authority controls (decisions 044) ────────────────────────