@logswap/sdk 0.5.50 → 0.5.52

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) ────────────────────────