@logswap/sdk 0.5.50 → 0.5.51

package/dist/fpool.d.ts

@@ -110,6 +110,16 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "kind";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "pure";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];
@@ -195,6 +205,20 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "nameOf";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -276,10 +300,6 @@ export declare const fPolicyBaseAbi: readonly [{
             readonly name: "phi";
             readonly internalType: "uint256";
             readonly type: "uint256";
-        }, {
-            readonly name: "kind";
-            readonly internalType: "enum Kind";
-            readonly type: "uint8";
         }, {
             readonly name: "policy";
             readonly internalType: "address";
@@ -415,6 +435,30 @@ export declare const fPolicyBaseAbi: readonly [{
     readonly name: "proposeAuthority";
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "quoteCurated";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "quoteListed";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -425,6 +469,44 @@ export declare const fPolicyBaseAbi: readonly [{
     readonly name: "setHarvestCut";
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "name_";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "setName";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "curated";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setQuoteCurated";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "quote";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setQuoteListed";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -489,6 +571,46 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly indexed: false;
     }];
     readonly name: "HarvestCutSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "name";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: false;
+    }];
+    readonly name: "NameSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "curated";
+        readonly internalType: "bool";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+    readonly name: "QuoteCuratedSet";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "quote";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "listed";
+        readonly internalType: "bool";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+    readonly name: "QuoteListed";
 }, {
     readonly type: "event";
     readonly anonymous: false;
@@ -504,10 +626,18 @@ export declare const fPolicyBaseAbi: readonly [{
         readonly indexed: false;
     }];
     readonly name: "RulesSet";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "BadFee";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "BadRate";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NoCreator";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -520,6 +650,22 @@ export declare const fPolicyBaseAbi: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
     readonly name: "NotManager";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "NotRegistry";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "OneBase";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "quote";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "QuoteNotListed";
 }, {
     readonly type: "error";
     readonly inputs: readonly [];
@@ -565,11 +711,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;
@@ -586,25 +732,27 @@ export interface FPoolState {
 /** Read a basket pool whole. Batched — viem multicalls these when the transport allows. */
 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 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 declare const F_KIND: {
-    readonly public: 0;
-    readonly private: 1;
-    readonly pol: 2;
-    readonly pad: 3;
-};
-export declare function fPoolKindOf(n: number | bigint): FPoolKind;
-/** The deployment's policy for a kind (decisions 044): what a key of that kind names. */
+/** The policy's birth-time declaration that the seed's shares are the pool's (a pad's), in `asks`. */
+export declare const SEED_TO_DEAD = 4;
+/**
+ * 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 declare function fPoolKindOfPolicy(c: LogswapClient, policy: Address): Promise<FPoolKind>;
+/** The pool's label, as its policy holds it (decisions 049). "" when unnamed. */
+export declare function fPoolNameOf(c: LogswapClient, poolId: Hex, policy?: Address): Promise<string>;
+/** The deployment's policy for a kind (decisions 044, 049): the protocol's policy that IS that kind. */
 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>;
@@ -875,12 +1023,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). */
@@ -889,7 +1041,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;
@@ -902,13 +1054,12 @@ 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 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 declare function fPoolKeyOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "account">): {
     quote: `0x${string}`;
     bases: `0x${string}`[];
     weights: bigint[];
     phi: bigint;
-    kind: 0 | 1 | 3 | 2;
     policy: `0x${string}`;
     creator: `0x${string}`;
     salt: `0x${string}`;
@@ -1038,7 +1189,7 @@ export interface FPoolLaunchArgs extends Omit<FPoolCreateArgs, "account"> {
         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
@@ -1152,23 +1303,27 @@ export declare function fPoolIsMinter(c: LogswapClient, poolId: Hex, who: Addres
 export declare function fPoolIsTaker(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean>;
 /** May swap: a minter or a taker (consulted only while the swap gate is on). */
 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. */
+/** 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 declare function fPoolSetName(c: LogswapClient, a: {
     poolId: Hex;
     name: string;
     account: Address;
+    policy?: Address;
 }): Promise<`0x${string}`>;
 /**
- * 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 declare function fPoolSetSponsorName(c: LogswapClient, a: {
     who: Address;
     name: string;
     account: Address;
 }): Promise<`0x${string}`>;
-/** 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 declare function fPoolSponsorName(c: LogswapClient, who: Address): Promise<string>;
+/** The registry the manager asks at every birth — `addresses.policyRegistry`, else the manager's word; zero on a bare deployment. */
+export declare function fPoolRegistryOf(c: LogswapClient): Promise<Address>;
 /** 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;
 /**
@@ -1240,9 +1395,10 @@ export interface DiscoveredFPool {
     shape: FPoolShape;
 }
 /**
- * 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 declare function discoverFPools(c: LogswapClient, opts?: {
     fromBlock?: bigint;

package/dist/fpool.js

@@ -30,7 +30,7 @@
  * `addresses.router`.
  */
 import { encodeFunctionData, toFunctionSelector } 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`,
  * `setLegs`, the names, the fee parameters are `FPoolManager`'s own code. The roles left it for
@@ -61,7 +61,8 @@ 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 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("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
@@ -72,12 +73,14 @@ export async function getFPool(c, poolId) {
         throw new Error(`logswap: no F pool with id ${poolId}`);
     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("theta", [poolId]) : rd("compositeX", [poolId]),
         rd("compositeX", [poolId]),
         Promise.all(idx.map((i) => rd("legOf", [poolId, i]))),
+        fPoolKindOfPolicy(c, p.policy),
+        fPoolNameOf(c, poolId, p.policy),
     ]);
     const bases = legs.map((l) => l[0]);
     const weights = legs.map((l) => l[1]);
@@ -100,25 +103,46 @@ export async function getFPool(c, poolId) {
         bigSigma,
         policy,
         asks: Number(p.asks),
-        name: bytes32ToText(p.name),
+        name,
         restructureBlock: Number(restructureBlock),
-        kind: fPoolKindOf(p.kind),
+        kind,
         seeded,
         gen: Number(gen),
         totalSupply,
         reserves,
     };
 }
-/** The key's enum values. */
-export const F_KIND = { public: 0, private: 1, pol: 2, pad: 3 };
 const F_KIND_NAMES = ["public", "private", "pol", "pad"];
-export function fPoolKindOf(n) {
-    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();
+/**
+ * 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, policy) {
+    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" }).then((word) => {
+            const tag = bytes32ToText(word);
+            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 deployment's policy for a kind (decisions 044): what a key of that kind names. */
+/** The pool's label, as its policy holds it (decisions 049). "" when unnamed. */
+export async function fPoolNameOf(c, poolId, policy) {
+    const p = policy ?? (await fPoolPolicyOf(c, poolId));
+    const word = (await c.public.readContract({ address: p, abi: fPolicyBaseAbi, functionName: "nameOf", args: [poolId] }));
+    return bytes32ToText(word);
+}
+/** The deployment's policy for a kind (decisions 044, 049): the protocol's policy that IS that kind. */
 export function fPoolPolicyFor(c, kind) {
     const a = c.addresses;
     const policy = kind === "public" ? a.publicPolicy : kind === "private" ? a.privatePolicy : kind === "pol" ? a.polPolicy : a.padPolicy;
@@ -541,8 +565,8 @@ export var FPoolQuoteKind;
 export async function fPoolQuoteSwap(c, a) {
     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],
@@ -606,7 +630,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 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, a) {
     const { bases, companions } = sortFPoolLegs(a.bases, a.weights);
     return {
@@ -614,7 +638,6 @@ export function fPoolKeyOf(c, a) {
         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,
@@ -769,7 +792,7 @@ export function fPoolLaunchCalls(poolId, a) {
     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, args) => encodeFunctionData({ abi: fPoolManagerAbi, functionName, args });
     const calls = [];
     if (!a.initialized)
@@ -783,10 +806,9 @@ export function fPoolLaunchCalls(poolId, a) {
             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;
 }
@@ -821,8 +843,11 @@ export async function fPoolDeskOpening(c, a) {
  */
 export async function fPoolLaunch(c, a) {
     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 };
 }
 // ─── the roles, on the policy (decisions 044) ─────────────────────────────────────────────
@@ -892,35 +917,47 @@ export async function fPoolIsTaker(c, poolId, who, policy) {
 export async function fPoolIsAllowed(c, poolId, who, policy) {
     return readDesk(c, poolId, who, "isAllowed", policy);
 }
-/** Label the pool — the sponsor's own words, mutable, never identity. At most 31 bytes of UTF-8. */
+/** 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, a) {
-    return writeFPool(c, a.poolId, "setName", [textToBytes32(a.name)], a.account);
+    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, a) {
     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,
     });
     return wallet.writeContract(request);
 }
-/** 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, who) {
-    const word = (await c.public.readContract({
-        address: c.addresses.fPoolManager,
-        abi: fPoolManagerAbi,
-        functionName: "sponsorName",
-        args: [who],
-    }));
+    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] }));
     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) {
+    if (c.addresses.policyRegistry)
+        return c.addresses.policyRegistry;
+    return (await c.public.readContract({ address: c.addresses.fPoolManager, abi: fPoolManagerAbi, functionName: "registry" }));
+}
+async function registryAddress(c) {
+    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) {
     return s.operator === ZERO_ADDRESS ? s.authority : s.operator;
@@ -966,9 +1003,10 @@ export async function fPoolTransferShares(c, a) {
     return wallet.writeContract(request);
 }
 /**
- * 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, opts = {}) {
     const ev = fPoolManagerAbi.find((x) => x.type === "event" && x.name === "Initialize");
@@ -991,24 +1029,25 @@ export async function discoverFPools(c, opts = {}) {
         const a = l.args;
         q0Of.set(a.poolId.toLowerCase(), a.Q0);
     }
-    return logs.map((l) => {
+    return Promise.all(logs.map(async (l) => {
         const a = l.args;
         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: fPoolKindOf(a.kind),
+            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)
+            shape: kind === "pad" ? "launch" : "basket", // the policy's word, not n = 1: a mono POL is a pool (decisions 036, 049)
         };
-    });
+    }));
 }
 /** The policy's terms for one pool, by its kind. */
 export async function getFPoolRules(c, s, roles) {