@logswap/sdk 0.5.48 → 0.5.50

package/src/admin.ts

@@ -12,8 +12,8 @@
 
 import type { Address, Hash } from "viem";
 import type { LogswapClient } from "./client.js";
-import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, publicPolicyAbi } from "./generated.js";
-import { F_KIND, fPolicyBaseAbi, type FPoolKind } from "./fpool.js";
+import { cPoolManagerAbi, fPoolManagerAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, publicPolicyAbi } from "./generated.js";
+import { F_KIND, bytes32ToText, fPolicyBaseAbi, textToBytes32, type FPoolKind } from "./fpool.js";
 
 function wallet(c: LogswapClient) {
   if (!c.wallet) throw new Error("a wallet client is required");
@@ -33,17 +33,106 @@ export async function setFeeParams(c: LogswapClient, mintFeeProtocolCutWad: bigi
   return write(c, c.addresses.fPoolManager as Address, fPoolManagerAbi, "setFeeParams", [mintFeeProtocolCutWad]);
 }
 
+// ─── the registry (decisions 046): the LOG authority's, not the collector's ─────────────────
+
+const ZERO = "0x0000000000000000000000000000000000000000" as const;
+
 /**
- * Approve a policy for pools of `kind` to be born with, or withdraw the approval (decisions 041,
- * 044). Read at `initialize` and never again: a live pool keeps its policy.
+ * The policy registry the F manager asks at every birth — `addresses.policyRegistry` when the
+ * deployment carries it, else read once from the manager. The zero address is a deployment with
+ * no registry: it asks nobody, and nothing here can be written.
  */
-export async function setPolicyApproved(c: LogswapClient, kind: FPoolKind, policy: Address, approved: boolean): Promise<Hash> {
-  return write(c, c.addresses.fPoolManager as Address, fPoolManagerAbi, "setPolicyApproved", [F_KIND[kind], policy, approved]);
+export async function policyRegistryOf(c: LogswapClient): Promise<Address> {
+  if (c.addresses.policyRegistry) return c.addresses.policyRegistry;
+  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`. */
+/** 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> {
-  return c.public.readContract({ address: c.addresses.fPoolManager as Address, abi: fPoolManagerAbi, functionName: "policyApproved", args: [F_KIND[kind], policy] } as never) as 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>;
+}
+
+/** One policy on a kind's list, as the registry holds it. */
+export interface RegistryEntry {
+  policy: Address;
+  name: string;
+  /** The block it closes to new pools from; 0 = open. */
+  until: bigint;
+  /** Approved now: listed and not yet sunset. */
+  approved: boolean;
+}
+
+/** Every policy listed for `kind`, sunset ones included — what a create form's dropdown reads. Empty with no registry. */
+export 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 block = await c.public.getBlockNumber();
+  return Promise.all(
+    list.map(async (policy) => {
+      const [listed, until, , name] = (await c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "entries", args: [F_KIND[kind], policy] } as never)) as [boolean, bigint, number, `0x${string}`];
+      return { policy, name: bytes32ToText(name), until, approved: listed && (until === 0n || block < until) };
+    }),
+  );
+}
+
+/** The registry's owner — the LOG authority — and the proposed next one. */
+export async function registryOwner(c: LogswapClient): Promise<{ owner: Address; pending: Address }> {
+  const registry = await policyRegistryOf(c);
+  if (registry === ZERO) return { owner: ZERO, pending: ZERO };
+  const [owner, pending] = await Promise.all([
+    c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "owner" } as never) as Promise<Address>,
+    c.public.readContract({ address: registry, abi: policyRegistryAbi, functionName: "pendingOwner" } as never) as Promise<Address>,
+  ]);
+  return { owner, pending };
+}
+
+async function registryWrite(c: LogswapClient, functionName: string, args: readonly unknown[]): Promise<Hash> {
+  const registry = await policyRegistryOf(c);
+  if (registry === ZERO) throw new Error("logswap: this deployment carries no policy registry");
+  return write(c, registry, policyRegistryAbi, functionName, args);
+}
+
+/** `PolicyRegistry.approve`: list `policy` for pools of `kind`, under `name` (at most 31 bytes). Again renames it and clears its sunset. The owner's. */
+export async function registryApprove(c: LogswapClient, kind: FPoolKind, policy: Address, name: string): Promise<Hash> {
+  return registryWrite(c, "approve", [F_KIND[kind], 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.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]);
+}
+
+/** The registry owner's two-step handover. */
+export async function registryProposeOwner(c: LogswapClient, next: Address): Promise<Hash> {
+  return registryWrite(c, "proposeOwner", [next]);
+}
+export async function registryAcceptOwner(c: LogswapClient): Promise<Hash> {
+  return registryWrite(c, "acceptOwner", []);
+}
+
+/**
+ * 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}.
+ */
+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);
+}
+
+/**
+ * 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.
+ */
+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]);
 }
 
 // ─── the policies' numbers (the collector's; each bounded where it reaches the manager) ─────

package/src/client.ts

@@ -31,6 +31,12 @@ export interface LogswapAddresses {
   privatePolicy?: Address;
   polPolicy?: Address;
   padPolicy?: Address;
+  /**
+   * The policy registry (decisions 046): what a pool of each kind may be born under, and the
+   * owner that may move a pool between policies. Read from the F manager (`registry()`) when
+   * absent; a deployment with none asks nobody.
+   */
+  policyRegistry?: Address;
   /** Optional — the router falls back to plain approvals when absent. */
   permit2?: Address;
 }
@@ -116,13 +122,19 @@ export const EXPECTED_VERSION = 4n;
 // 15 (2026-09-20): the policy answers every question (decisions 044) — `FPoolKey.authority` is
 // `creator` (every pool id moves again); the roles, gates and list are the pool's POLICY's
 // (`FPolicyBase` / `PrivatePolicy`), not the manager's: `getPool` has `policy` and `asks` and no
-// role; `proposeAuthority`, `appointOperator`, `setGates`, `setAllowed` are policy writes;
+// role; `proposeAuthority`, `appointOperator`, `setGates`, `setAllowed` (`setMinters` / `setTakers` since 17) are policy writes;
 // `policyApproved(kind, policy)` / `setPolicyApproved(kind, policy, ok)`; `Regenerated` names the payee;
 // `HARVEST_CUT_MAX` / `POT_CUT_MAX` cap what a policy may route to the protocol.
 // 16 (2026-09-21): the word is POLICY (decisions 045) — a rename, no pool id moves: `FPoolKey.policy`,
 // `IFPolicy`, `FPolicyBase`, `PublicPolicy` … `PadPolicy`, `policyApproved` / `setPolicyApproved`,
 // `PolicyApproved`; `PolPolicy.setPolicy` / `PolicySet` are `setRules` / `RulesSet`.
-export const EXPECTED_F_VERSION = 16n;
+// 17 (2026-09-21): the registry, the move, the stamp, two lists, one base (decisions 046–048) — no
+// pool id moves: the F manager takes a `PolicyRegistry` at construction and asks it at a birth
+// (`policyApproved` / `setPolicyApproved` left the manager: `registryApprove` …); the key's policy
+// 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 async function assertVersion(c: LogswapClient, expected = EXPECTED_VERSION): Promise<void> {
   const { cPoolManagerAbi } = await import("./generated.js");

package/src/fpool.ts

@@ -1142,15 +1142,15 @@ export function fPoolLaunchCalls(
 }
 
 /**
- * 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: LogswapClient, a: { poolId: Hex; account: Address; policy?: Address }): Promise<Hash[]> {
   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 }),
   ];
 }
 
@@ -1229,25 +1229,44 @@ export async function fPoolSetGates(
 }
 
 /**
- * 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(
+export async function fPoolSetMinters(
   c: LogswapClient,
   a: { poolId: Hex; who: readonly Address[]; allowed: boolean; account: Address; policy?: Address },
 ) {
-  return writePolicy(c, privatePolicyAbi, a, "setAllowed", [a.who, a.allowed]);
+  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: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean> {
+/** 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: LogswapClient,
+  a: { poolId: Hex; who: readonly Address[]; allowed: boolean; account: Address; policy?: Address },
+) {
+  return writePolicy(c, privatePolicyAbi, a, "setTakers", [a.who, a.allowed]);
+}
+
+async function readDesk<T>(c: LogswapClient, poolId: Hex, who: Address, functionName: string, policy?: Address): Promise<T> {
   const address = policy ?? (await fPoolPolicyOf(c, poolId));
-  return (await c.public.readContract({
-    address,
-    abi: privatePolicyAbi,
-    functionName: "isAllowed",
-    args: [poolId, who],
-  } as never)) as boolean;
+  return (await c.public.readContract({ address, abi: privatePolicyAbi, functionName, args: [poolId, who] } as never)) as T;
+}
+
+/** On the pool's minters under its current authority: may mint, and swap. */
+export async function fPoolIsMinter(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean> {
+  return readDesk<boolean>(c, poolId, who, "isMinter", policy);
+}
+
+/** On the pool's takers under its current authority: may swap only. */
+export async function fPoolIsTaker(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean> {
+  return readDesk<boolean>(c, poolId, who, "isTaker", policy);
+}
+
+/** May swap: a minter or a taker (consulted only while the swap gate is on). */
+export async function fPoolIsAllowed(c: LogswapClient, poolId: Hex, who: Address, policy?: Address): Promise<boolean> {
+  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. */
@@ -1346,7 +1365,7 @@ export interface DiscoveredFPool {
   weights: bigint[];
   phi: bigint;
   kind: FPoolKind;
-  /** The pool's policy — the contract the key names (decisions 041, 044, 045). */
+  /** The pool's policy AT BIRTH — the contract the key names (decisions 041, 044, 045). The LIVE one is {@link getFPool}'s `policy`: the registry's owner may have moved the pool (046, `PolicyMigrated`). */
   policy: Address;
   /** Who was born holding the pool (immutable). The LIVE authority is the policy's — {@link getFPoolRoles}. */
   creator: Address;
@@ -1483,20 +1502,22 @@ export async function fPoolsControlledBy(
   opts: { pools?: DiscoveredFPool[]; fromBlock?: bigint } = {},
 ): Promise<FPoolControlled[]> {
   const pools = opts.pools ?? (await discoverFPools(c, { fromBlock: opts.fromBlock }));
+  // 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(
-    pools.map((p) =>
-      c.public.readContract({ address: p.policy, abi: fPolicyBaseAbi, functionName: "authority", args: [p.poolId] } as never) as Promise<Address>,
+    states.map((s) =>
+      c.public.readContract({ address: s.policy, abi: fPolicyBaseAbi, functionName: "authority", args: [s.poolId] } as never) as Promise<Address>,
     ),
   );
-  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);
-      const rules = await getFPoolRules(c, state, roles);
-      return { pool, roles, state, rules };
-    }),
-  );
+  const out: FPoolControlled[] = [];
+  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);
+    out.push({ pool: pools[i]!, roles, state, rules });
+  }
+  return out;
 }