@logswap/sdk 0.5.49 → 0.5.51

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,23 +806,22 @@ 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;
 }
 /**
- * The desk's opening posture, on its policy (decisions 044): gated minting, the creator listed. No
- * appointment: the authority is the operator until one is appointed (decisions 037). Two writes
- * to `PrivatePolicy`; the launch batch cannot carry them (they are not manager calls).
+ * The desk's opening posture, on its policy (decisions 044, 048): gated minting, the creator a
+ * minter. No appointment: the authority is the operator until one is appointed (decisions 037).
+ * Two writes to `PrivatePolicy`; the launch batch cannot carry them (they are not manager calls).
  */
 export async function fPoolDeskOpening(c, a) {
     const policy = a.policy ?? fPoolPolicyFor(c, "private");
     return [
         await fPoolSetGates(c, { poolId: a.poolId, gateMint: true, gateSwap: false, account: a.account, policy }),
-        await fPoolSetAllowed(c, { poolId: a.poolId, who: [a.account], allowed: true, account: a.account, policy }),
+        await fPoolSetMinters(c, { poolId: a.poolId, who: [a.account], allowed: true, account: a.account, policy }),
     ];
 }
 /**
@@ -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) ─────────────────────────────────────────────
@@ -864,51 +889,75 @@ export async function fPoolSetGates(c, a) {
     return writePolicy(c, privatePolicyAbi, a, "setGates", [a.gateMint, a.gateSwap]);
 }
 /**
- * Add to or remove from the pool's list, in one call (the authority, on the desk's policy). The list
- * is keyed by the authority that granted it: a handover starts the buyer with an empty one.
+ * Add to or remove from the pool's MINTERS — who may mint, and swap (a zap in is both under one
+ * lock) — in one call (the authority, on the desk's policy; decisions 048). The list is keyed by
+ * the authority that granted it: a handover starts the buyer with an empty one. Stamps the
+ * block: no swap lands in it (047).
  */
-export async function fPoolSetAllowed(c, a) {
-    return writePolicy(c, privatePolicyAbi, a, "setAllowed", [a.who, a.allowed]);
+export async function fPoolSetMinters(c, a) {
+    return writePolicy(c, privatePolicyAbi, a, "setMinters", [a.who, a.allowed]);
 }
-/** Whether `who` is on the pool's list under its current authority (consulted only while a gate is on). */
-export async function fPoolIsAllowed(c, poolId, who, policy) {
+/** Add to or remove from the pool's TAKERS — who may swap only — in one call (the authority; decisions 048). Stamps the block. */
+export async function fPoolSetTakers(c, a) {
+    return writePolicy(c, privatePolicyAbi, a, "setTakers", [a.who, a.allowed]);
+}
+async function readDesk(c, poolId, who, functionName, policy) {
     const address = policy ?? (await fPoolPolicyOf(c, poolId));
-    return (await c.public.readContract({
-        address,
-        abi: privatePolicyAbi,
-        functionName: "isAllowed",
-        args: [poolId, who],
-    }));
+    return (await c.public.readContract({ address, abi: privatePolicyAbi, functionName, args: [poolId, who] }));
+}
+/** On the pool's minters under its current authority: may mint, and swap. */
+export async function fPoolIsMinter(c, poolId, who, policy) {
+    return readDesk(c, poolId, who, "isMinter", policy);
+}
+/** On the pool's takers under its current authority: may swap only. */
+export async function fPoolIsTaker(c, poolId, who, policy) {
+    return readDesk(c, poolId, who, "isTaker", policy);
 }
-/** Label the pool — the sponsor's own words, mutable, never identity. At most 31 bytes of UTF-8. */
+/** May swap: a minter or a taker (consulted only while the swap gate is on). */
+export async function fPoolIsAllowed(c, poolId, who, policy) {
+    return readDesk(c, poolId, who, "isAllowed", policy);
+}
+/** 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;
@@ -954,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");
@@ -979,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) {
@@ -1035,14 +1086,19 @@ export async function getFPoolRules(c, s, roles) {
  */
 export async function fPoolsControlledBy(c, who, opts = {}) {
     const pools = opts.pools ?? (await discoverFPools(c, { fromBlock: opts.fromBlock }));
-    const authorities = await Promise.all(pools.map((p) => c.public.readContract({ address: p.policy, abi: fPolicyBaseAbi, functionName: "authority", args: [p.poolId] })));
-    const mine = pools.filter((_, i) => authorities[i].toLowerCase() === who.toLowerCase());
-    return Promise.all(mine.map(async (pool) => {
-        const state = await getFPool(c, pool.poolId);
-        const roles = await getFPoolRoles(c, pool.poolId, state);
+    // the LIVE policy answers for the authority: a moved pool (046) is on another one than its birth's
+    const states = await Promise.all(pools.map((p) => getFPool(c, p.poolId)));
+    const authorities = await Promise.all(states.map((s) => c.public.readContract({ address: s.policy, abi: fPolicyBaseAbi, functionName: "authority", args: [s.poolId] })));
+    const out = [];
+    for (let i = 0; i < pools.length; ++i) {
+        if (authorities[i].toLowerCase() !== who.toLowerCase())
+            continue;
+        const state = states[i];
+        const roles = await getFPoolRoles(c, state.poolId, state);
         const rules = await getFPoolRules(c, state, roles);
-        return { pool, roles, state, rules };
-    }));
+        out.push({ pool: pools[i], roles, state, rules });
+    }
+    return out;
 }
 /**
  * Every holder of a pool's shares, from the ERC-6909 Transfer stream — the id is an indexed