@logswap/sdk 0.5.73 → 0.5.75

package/src/history.ts

@@ -13,8 +13,9 @@
  * the decoding (the inputs' types — numbers as bigint, addresses checksummed, arrays from JSON).
  * With no indexer URL, or when the query fails, it asks the node and says so in `source`.
  */
-import { getAddress, type AbiEvent, type Address, type Hex } from "viem";
+import { getAddress, parseAbiItem, type AbiEvent, type Address, type Hex } from "viem";
 import type { LogswapClient } from "./client.js";
+import type { FPoolKind } from "./fpool.js";
 import { bytea, gql } from "./indexer.js";
 import { blockAtOrAfter } from "./fees.js";
 
@@ -32,7 +33,14 @@ export interface HistoryLog<A = Record<string, unknown>> {
 export interface EventLogsQuery {
   /** The rindexer GraphQL endpoint; absent means the chain. */
   indexer?: string;
-  address: Address;
+  /** The emitter, or several: the four policies share one table per event (indexer phase 1). */
+  address: Address | readonly Address[];
+  /**
+   * The emitter's name in the indexer's config, for an event two indexed contracts share — only
+   * needed when the address is not in the client's artifact (a policy the registry approved later):
+   * see {@link indexedContractOf}.
+   */
+  contract?: string;
   event: AbiEvent;
   /** Indexed arguments to match, as `getLogs` takes them; an array matches any of its values. */
   args?: Record<string, unknown>;
@@ -70,29 +78,52 @@ export async function getEventLogs<A = Record<string, unknown>>(
 
 // ─── the indexer path ────────────────────────────────────────────────────────
 
-/** What the rindexer deployment calls each manager — the prefix of a table two contracts share. */
-function contractName(c: LogswapClient, address: Address): string | null {
+/**
+ * What the rindexer deployment calls each contract — the prefix of a table two contracts share
+ * (logswap-be `devnet/indexer/rindexer.yaml`). The four policies are one factory-tracked contract,
+ * `Policy`, except `Listed`, whose two signatures are two contracts (`PublicPolicy`, `PrivatePolicy`).
+ */
+function contractName(c: LogswapClient, address: Address, event: string): string | null {
   const a = address.toLowerCase();
-  if (a === c.addresses.cPoolManager.toLowerCase()) return "LogswapManager";
-  if (c.addresses.fPoolManager && a === c.addresses.fPoolManager.toLowerCase()) return "FPoolManager";
-  if (a === c.addresses.router.toLowerCase()) return "LogswapRouter";
+  const is = (x?: Address) => x !== undefined && a === x.toLowerCase();
+  const { addresses: d } = c;
+  if (is(d.cPoolManager)) return "LogswapManager";
+  if (is(d.fPoolManager)) return "FPoolManager";
+  if (is(d.router)) return "LogswapRouter";
+  if (is(d.policyRegistry)) return "PolicyRegistry";
+  if (is(d.tokenFactory)) return "TokenFactory";
+  if (is(d.publicPolicy)) return indexedContractOf("public", event);
+  if (is(d.privatePolicy)) return indexedContractOf("private", event);
+  if (is(d.polPolicy)) return indexedContractOf("pol", event);
+  if (is(d.padPolicy)) return indexedContractOf("pad", event);
   return null;
 }
 
+/**
+ * A policy's name in the indexer for one of its events: `Policy`, or the kind's own contract for the
+ * two-signature `Listed`. Pass it as {@link EventLogsQuery.contract} for a policy outside the artifact.
+ */
+export function indexedContractOf(kind: FPoolKind, event: string): string {
+  if (event === "Listed") return kind === "private" ? "PrivatePolicy" : "PublicPolicy";
+  return "Policy";
+}
+
 /** Events whose name two indexed contracts share: postgraphile prefixes their tables. */
-const SHARED = new Set(["Transfer"]);
+const SHARED = new Set(["Transfer", "Approval", "OperatorSet", "CollectorProposed", "CollectorAccepted", "Approved", "Listed"]);
 
 const plural = (n: string) => (/(s|x|ch|sh)$/.test(n) ? `${n}es` : `${n}s`);
 /** A column's GraphQL name: postgraphile camelCases the snake_case rindexer writes (`F` → `f`). */
 const column = (name: string) => name[0]!.toLowerCase() + name.slice(1);
 
-export function tableFor(c: LogswapClient, address: Address, event: string): { field: string; type: string } {
-  const prefix = SHARED.has(event) ? contractName(c, address) : "";
+export function tableFor(c: LogswapClient, address: Address, event: string, contract?: string): { field: string; type: string } {
+  const prefix = SHARED.has(event) ? (contract ?? contractName(c, address, event)) : "";
   if (prefix === null) throw new Error(`history: no indexed contract at ${address}`);
   const type = `${prefix}${event}`;
   return { field: `all${plural(type)}`, type };
 }
 
+const emitters = (q: { address: Address | readonly Address[] }): Address[] => (Array.isArray(q.address) ? [...q.address] : [q.address as Address]);
+
 function decode(type: string, v: unknown): unknown {
   if (v === null || v === undefined) return v;
   if (type.endsWith("[]")) return (v as unknown[]).map((x) => decode(type.slice(0, -2), x));
@@ -107,7 +138,9 @@ const MAX_PAGES = 200;
 const PARALLEL_PAGES = 8;
 
 async function fromIndexer<A>(c: LogswapClient, q: EventLogsQuery): Promise<HistoryLog<A>[]> {
-  const { field, type } = tableFor(c, q.address, q.event.name);
+  const all = emitters(q);
+  if (all.length === 0) return [];
+  const { field, type } = tableFor(c, all[0]!, q.event.name, q.contract);
   const inputs = q.event.inputs;
   const condition: Record<string, unknown> = {};
   const filter: Record<string, unknown> = {};
@@ -164,11 +197,11 @@ async function fromIndexer<A>(c: LogswapClient, q: EventLogsQuery): Promise<Hist
     }
   }
   // a table can hold a previous deployment's rows (an indexer not yet reset): keep this contract's
-  const want = q.address.toLowerCase();
+  const want = new Map(all.map((a) => [a.toLowerCase(), a]));
   return rows
-    .filter((r) => String(r.contractAddress).toLowerCase() === want)
+    .filter((r) => want.has(String(r.contractAddress).toLowerCase()))
     .map((r) => ({
-      address: q.address,
+      address: want.get(String(r.contractAddress).toLowerCase())!,
       args: Object.fromEntries(inputs.map((i) => [i.name!, decode(i.type, r[column(i.name!)])])) as A,
       blockNumber: BigInt(r.blockNumber as string),
       blockTimestamp: Math.floor(Date.parse(r.blockTimestamp as string) / 1000),
@@ -185,10 +218,13 @@ export const LATEST_SCAN_BLOCKS = 5_000n;
 
 async function fromChain<A>(c: LogswapClient, q: EventLogsQuery): Promise<HistoryLog<A>[]> {
   let fromBlock = q.fromBlock ?? 0n;
-  const toBlock = q.toBlock ?? (await c.public.getBlockNumber());
+  const toBlock = q.toBlock ?? (await c.public.getBlockNumber({ cacheTime: 0 })); // uncached: viem caches the head, and a scan bounded by a stale one misses the block just mined
   if (q.since !== undefined) fromBlock = await blockAtOrAfter(c, BigInt(q.since), fromBlock, toBlock);
   if (q.latest !== undefined && toBlock - fromBlock > LATEST_SCAN_BLOCKS) fromBlock = toBlock - LATEST_SCAN_BLOCKS;
-  let logs = (await c.public.getLogs({ address: q.address, event: q.event, args: q.args, fromBlock, toBlock } as never)) as unknown as Array<{
+  const all = emitters(q);
+  if (all.length === 0) return [];
+  let logs = (await c.public.getLogs({ address: Array.isArray(q.address) ? all : q.address, event: q.event, args: q.args, fromBlock, toBlock } as never)) as unknown as Array<{
+    address?: Address;
     args: A;
     blockNumber: bigint;
     transactionHash: Hex;
@@ -200,10 +236,107 @@ async function fromChain<A>(c: LogswapClient, q: EventLogsQuery): Promise<Histor
   }
   if (q.latest !== undefined) logs = logs.slice(-q.latest);
   return logs.map((l) => ({
-    address: q.address,
+    address: l.address ? getAddress(l.address) : all[0]!,
     args: l.args,
     blockNumber: l.blockNumber,
     transactionHash: l.transactionHash,
     logIndex: l.logIndex,
   }));
 }
+
+// ─── several events, and the token factory ────────────────────────────────────
+
+/** A row of {@link getEventsLogs}: one of the asked events, named. */
+export interface NamedHistoryLog extends HistoryLog {
+  eventName: string;
+}
+
+/**
+ * Several events of one contract (or of several emitters sharing them), merged oldest first and
+ * tagged with `eventName` — the shape of viem's multi-event `getLogs`, which is what the chain path
+ * runs. One indexer table per event; if any of them cannot answer, the whole read goes to the node,
+ * so a history is never half the indexer's and half the node's.
+ */
+export async function getEventsLogs(
+  c: LogswapClient,
+  q: Omit<EventLogsQuery, "event" | "args" | "latest" | "contract" | "transactionHashes"> & {
+    events: readonly AbiEvent[];
+    /** The emitters' policy kind, to name a shared event's table for a policy outside the artifact. */
+    kind?: FPoolKind;
+    /** The emitter's name in the indexer (e.g. `PolicyRegistry`), for a contract outside the artifact; `kind` wins for a policy. */
+    contract?: string;
+  },
+): Promise<{ logs: NamedHistoryLog[]; source: "indexer" | "chain" }> {
+  const order = (a: HistoryLog, b: HistoryLog) => (a.blockNumber === b.blockNumber ? a.logIndex - b.logIndex : a.blockNumber < b.blockNumber ? -1 : 1);
+  if (q.indexer && q.events.length > 0) {
+    try {
+      const got = await Promise.all(
+        q.events.map(async (event) => {
+          const contract = q.kind ? indexedContractOf(q.kind, event.name) : q.contract;
+          return (await fromIndexer<Record<string, unknown>>(c, { ...q, event, contract })).map((l) => ({ ...l, eventName: event.name }));
+        }),
+      );
+      return { logs: got.flat().sort(order), source: "indexer" };
+    } catch {
+      /* the indexer is a cache: the node holds the same events */
+    }
+  }
+  const all = emitters(q);
+  if (all.length === 0 || q.events.length === 0) return { logs: [], source: "chain" };
+  let fromBlock = q.fromBlock ?? 0n;
+  const toBlock = q.toBlock ?? (await c.public.getBlockNumber({ cacheTime: 0 })); // uncached: viem caches the head, and a scan bounded by a stale one misses the block just mined
+  if (q.since !== undefined) fromBlock = await blockAtOrAfter(c, BigInt(q.since), fromBlock, toBlock);
+  const logs = (await c.public.getLogs({ address: Array.isArray(q.address) ? all : q.address, events: q.events, fromBlock, toBlock } as never)) as unknown as Array<{
+    eventName: string;
+    address?: Address;
+    args: Record<string, unknown>;
+    blockNumber: bigint;
+    transactionHash: Hex;
+    logIndex: number;
+  }>;
+  return {
+    logs: logs
+      .map((l) => ({ eventName: l.eventName, address: l.address ? getAddress(l.address) : all[0]!, args: l.args, blockNumber: l.blockNumber, transactionHash: l.transactionHash, logIndex: l.logIndex }))
+      .sort(order),
+    source: "chain",
+  };
+}
+
+/** The devnet's token factory event (`src/mocks/TokenFactory.sol`): provenance for every launchable token. */
+export const TOKEN_CREATED = parseAbiItem("event TokenCreated(address indexed creator, address indexed token, string name, string symbol, uint256 supply)");
+
+export interface CreatedToken {
+  creator: Address;
+  token: Address;
+  name: string;
+  symbol: string;
+  supply: bigint;
+  blockNumber: bigint;
+  /** Unix seconds; set when the indexer answered. */
+  blockTimestamp?: number;
+  transactionHash: Hex;
+}
+
+/**
+ * Every token the deployment's factory created, oldest first — the token list's provenance (a token
+ * named like a factory token but deployed elsewhere is not in it). Optionally one creator's.
+ */
+export async function tokensCreated(
+  c: LogswapClient,
+  q: { indexer?: string; creator?: Address; fromBlock?: bigint; signal?: AbortSignal },
+): Promise<{ tokens: CreatedToken[]; source: "indexer" | "chain" }> {
+  const factory = c.addresses.tokenFactory;
+  if (!factory) throw new Error("logswap: tokensCreated needs addresses.tokenFactory");
+  const { logs, source } = await getEventLogs<{ creator: Address; token: Address; name: string; symbol: string; supply: bigint }>(c, {
+    indexer: q.indexer,
+    address: factory,
+    event: TOKEN_CREATED,
+    args: q.creator ? { creator: q.creator } : undefined,
+    fromBlock: q.fromBlock,
+    signal: q.signal,
+  });
+  return {
+    tokens: logs.map((l) => ({ ...l.args, blockNumber: l.blockNumber, ...(l.blockTimestamp !== undefined ? { blockTimestamp: l.blockTimestamp } : {}), transactionHash: l.transactionHash })),
+    source,
+  };
+}

package/src/indexer.ts

@@ -258,12 +258,7 @@ export async function poolPositionsFromChain(c: LogswapClient, key: PoolKey, x:
         functionName: "idOf",
         args: [key, floor],
       } as never)) as bigint;
-      const [L, shares] = (await c.public.readContract({
-        address: c.addresses.cPoolManager,
-        abi: cPoolManagerAbi,
-        functionName: "positions",
-        args: [id],
-      } as never)) as readonly [bigint, bigint, bigint, bigint];
+      const { L, shares } = await getPositionClass(c, id); // through extsload (C version 7)
       if (L === 0n) return null;
       return { id, poolId: pool, floor, cap: NO_CAP, capped: false, L, shares, active: x >= floor } as PoolPosition;
     }),

package/src/keys.ts

@@ -15,7 +15,9 @@ import { encodeAbiParameters, keccak256, type Address, type Hex } from "viem";
 
 /**
  * The fee domain of the family, `FeeParams.FEE_MIN` / `FEE_MAX` (decisions 043): one bound for a
- * C market's φ and an F pool's alike, WAD. 1 bp and 1%. The F manager no longer answers
+ * C market's φ and an F pool's alike, WAD. 1 bp and 1% — plus 0, which since C version 7 / F
+ * version 26 is a fee-free market or pool, admitted only if the policy lists it (decisions 065).
+ * The mint fee lives in the same domain. The F manager no longer answers
  * `FEE_MIN()` / `FEE_MAX()` (F version 21 cut the getters for bytecode); every F policy still
  * checks φ against these at `onInitialize`, and the C side re-exposes them through the lens's
  * `cParams()`. Constants here, so a create form bounds φ with no read.
@@ -34,7 +36,8 @@ export interface PoolKey {
   tickSpacing: bigint;
   /**
    * The swap fee, WAD, fixed for the life of the market: {@link FEE_MIN} (1 bp) ≤ φ ≤ {@link FEE_MAX} (1%),
-   * or `0n`, which selects `DEFAULT_FEE` (2 bp) at read time. Four fields since C version 4
+   * or `0n`, which since C version 7 is NO fee (decisions 065; `DEFAULT_FEE` is gone). The gate
+   * admits only its listed tiers (064: 2, 5, 10, 25, 50, 100 bp). Four fields since C version 4
    *: `kappa` and `alpha` left with the variance kernel, and `phiMin` — a floor with
    * nothing above it — became `phi`, named `swapFee` since C version 6 (decisions 059). The name
    * is not part of the encoding: no pool id changed with it.
@@ -57,10 +60,9 @@ const POOL_KEY_ABI = [
 /**
  * `poolId = keccak256(abi.encode(key))` — the primary key of the entire read model.
  *
- * Note the zero-vs-default caveat the Solidity type documents: a `swapFee` of `0` resolves to
- * `DEFAULT_FEE` at READ time, so a key carrying `0n` and one carrying the resolved default are
- * DIFFERENT markets with different ids, even though they behave identically. Always address a
- * market by the key it was initialized with.
+ * A key's `swapFee` is the market's fee as written — `0n` is a fee-free market since C version 7
+ * (decisions 065), not the 2 bp default it selected before. Always address a market by the key it
+ * was initialized with.
  */
 export function poolId(key: PoolKey): Hex {
   return keccak256(

package/src/liquidity.ts

@@ -27,7 +27,7 @@ import { logswapLensAbi, logswapRouterAbi } from "./generated.js";
 import type { LogswapClient } from "./client.js";
 import type { PoolKey } from "./keys.js";
 import { NO_CAP } from "./ids.js";
-import { describeId, getPositionClass } from "./positions.js";
+import { describeId, getPositionClass, presetMintFee } from "./positions.js";
 import {
   execute,
   OPEN_DELTA,
@@ -105,6 +105,11 @@ export interface CreateMarketArgs extends WriteOptions {
   targetFloor: bigint;
   /** The founding exposure; must exceed the manager's `minBackstopL` lock. */
   L: bigint;
+  /**
+   * The market's mint fee, WAD of newly-earning L — the creator's pick from the gate's menu
+   * (decisions 065). Defaults to {@link presetMintFee}: twice the swap fee, capped at `FEE_MAX`.
+   */
+  mintFee?: bigint;
   /** Required, as on {@link mint}. Creation is atomic at `x0`, so the flows are fixed by the arguments; {@link UNBOUNDED} is safe here only for that reason. */
   maxBaseIn: bigint;
   maxQuoteIn: bigint;
@@ -112,7 +117,9 @@ export interface CreateMarketArgs extends WriteOptions {
 
 /**
  * Create a market ATOMICALLY: `initialize` at `x0` plus the backstop-establishing first mint in
- * one transaction — the canonical creation path. The
+ * one transaction — the canonical creation path. Under the C gate (064) the router is a trusted
+ * forwarder: the gate checks the router's `user()` — the wallet sending this — against the
+ * creator list, so a listed creator opens and funds a market in this one call. The
  * two-step path let an attacker seat the PERMANENT backstop at a hostile rung between an honest
  * `initialize` and its first mint; here either both land or neither, and a front-run of the whole
  * call reverts it without moving a wei. No cap: the first mint IS the backstop and must be
@@ -125,6 +132,7 @@ export async function createMarket(c: LogswapClient, a: CreateMarketArgs): Promi
     args: [
       a.key,
       a.x0,
+      a.mintFee ?? presetMintFee(a.key.swapFee),
       a.targetFloor,
       a.L,
       a.maxBaseIn,

package/src/pools.ts

@@ -18,8 +18,13 @@ import type { LogswapClient } from "./client.js";
 import { signerFor } from "./write.js";
 import { readCachedToken, registerCacheClear, writeCachedToken } from "./tokencache.js";
 import { poolId, type PoolKey } from "./keys.js";
+import { presetMintFee } from "./positions.js";
+import { getEventLogs } from "./history.js";
 
-/** The manager's `getPool` view, decoded. Field-for-field with `PoolView` in the contract. */
+/**
+ * A market's scalar state, field-for-field with `CPoolState.PoolView` — what the manager's `getPool`
+ * returned before C version 7 moved it behind `extsload` (decisions 065); read through the lens.
+ */
 export interface PoolState {
   initialized: boolean;
   backstopSeeded: boolean;
@@ -37,32 +42,31 @@ export interface PoolState {
   protocolOwed: bigint;
   minBackstopL: bigint;
   backstopFloor: bigint;
+  /** The market's mint fee, WAD of newly-earning L: proposed at birth, the gate's answer (065). */
+  mintFee: bigint;
 }
 
-/** Read a market's full state by key. */
+/** Read a market's full state by key, through the lens (`getPools`; C version 7). All zero, `initialized` false, for a market nobody opened. */
 export async function getPool(c: LogswapClient, key: PoolKey): Promise<PoolState> {
-  const v = await c.public.readContract({
-    address: c.addresses.cPoolManager,
-    abi: cPoolManagerAbi,
-    functionName: "getPool",
-    args: [poolId(key)],
-  });
-  return v as unknown as PoolState;
+  const v = (await c.public.readContract({
+    address: c.addresses.lens,
+    abi: logswapLensAbi,
+    functionName: "getPools",
+    args: [[poolId(key)]],
+  })) as readonly unknown[];
+  return v[0] as PoolState;
 }
 
 /**
- * The market's swap fee: the key's `swapFee` with `0n` resolved to `DEFAULT_FEE` — the manager's
- * `swapFeeOf` (`phiOf` before C version 6). Constant for the market's life (C version 4 — `phiEff`
- * and the variance kernel before). Reverts for a key nobody initialized, which `discoverMarkets`
- * relies on to drop a stale indexer's rows. (`swapFeeOf` in `fees.ts` is the fee one swap paid.)
+ * The market's swap fee — the key's own `swapFee` since C version 7: a fee of 0 is no fee, and
+ * `DEFAULT_FEE` / the manager's `swapFeeOf` are gone (decisions 065). Constant for the market's
+ * life. Still a read: it refuses a key nobody initialized, which `discoverMarkets` relies on to
+ * drop a stale indexer's rows. (`swapFeeOf` in `fees.ts` is the fee one swap paid.)
  */
 export async function marketSwapFee(c: LogswapClient, key: PoolKey): Promise<bigint> {
-  return c.public.readContract({
-    address: c.addresses.cPoolManager,
-    abi: cPoolManagerAbi,
-    functionName: "swapFeeOf",
-    args: [key],
-  }) as Promise<bigint>;
+  const s = await getPool(c, key);
+  if (!s.initialized) throw new Error(`logswap: market ${poolId(key)} is not initialized`);
+  return key.swapFee;
 }
 
 /**
@@ -159,7 +163,7 @@ export interface DiscoveredMarket {
  */
 export async function discoverMarkets(
   c: LogswapClient,
-  opts: { fromBlock?: bigint; toBlock?: bigint; base?: Address; quote?: Address } = {},
+  opts: { fromBlock?: bigint; toBlock?: bigint; base?: Address; quote?: Address; /** The rindexer GraphQL endpoint: `Initialize` from there, the node otherwise. */ indexer?: string } = {},
 ): Promise<DiscoveredMarket[]> {
   // Narrow the const ABI to the Initialize entry while KEEPING its literal type, so viem can infer
   // the log shape. `as never` would compile but collapse every arg to `never` at the call site.
@@ -167,28 +171,32 @@ export async function discoverMarkets(
   const ev = cPoolManagerAbi.find((x): x is Ev => x.type === "event" && x.name === "Initialize");
   if (!ev) throw new Error("logswap: Initialize event missing from the generated ABI");
 
-  const logs = await c.public.getLogs({
+  const args: Record<string, unknown> = {};
+  if (opts.base) args.base = opts.base;
+  if (opts.quote) args.quote = opts.quote;
+  const { logs } = await getEventLogs<{ base: Address; quote: Address; tickSpacing: bigint; swapFee: bigint; x0: bigint }>(c, {
+    indexer: opts.indexer,
     address: c.addresses.cPoolManager,
     event: ev,
-    args: { base: opts.base, quote: opts.quote },
+    args,
     fromBlock: opts.fromBlock ?? 0n,
-    toBlock: opts.toBlock ?? "latest",
+    toBlock: opts.toBlock,
   });
 
   return logs.map((l) => {
     const a = l.args;
     const key: PoolKey = {
-      base: a.base!,
-      quote: a.quote!,
-      tickSpacing: a.tickSpacing!,
-      swapFee: a.swapFee!,
+      base: a.base,
+      quote: a.quote,
+      tickSpacing: a.tickSpacing,
+      swapFee: a.swapFee,
     };
     return {
       key,
       poolId: poolId(key),
-      x0: a.x0!,
-      blockNumber: l.blockNumber!,
-      transactionHash: l.transactionHash!,
+      x0: a.x0,
+      blockNumber: l.blockNumber,
+      transactionHash: l.transactionHash,
     };
   });
 }
@@ -417,16 +425,18 @@ export async function marketOpenedAt(c: LogswapClient, m: DiscoveredMarket): Pro
 }
 
 /**
- * Create a C market: `initialize(key, x0)` on the manager — a call, not a deployment. Manager-
- * direct by design: creation moves no funds, so the router adds nothing. The pool id is
- * `poolId(key)` (pure) and the market is tradeable immediately; the first mint funds it.
+ * Create a C market: `initialize(key, x0, mintFee)` on the manager — a call, not a deployment, and
+ * no funds move. The mint fee is the creator's pick from the gate's menu (065), preset at twice the
+ * swap fee ({@link presetMintFee}). Under a curated gate the CALLER must be a listed creator; the
+ * canonical path is the router's {@link createMarket}, which forwards its user to the gate and
+ * mints the backstop in the same transaction (064).
  */
-export async function initializeMarket(c: LogswapClient, a: { key: PoolKey; x0: bigint; account: Address }) {
+export async function initializeMarket(c: LogswapClient, a: { key: PoolKey; x0: bigint; mintFee?: bigint; account: Address }) {
   const { request } = await c.public.simulateContract({
     address: c.addresses.cPoolManager,
     abi: cPoolManagerAbi,
     functionName: "initialize",
-    args: [a.key, a.x0],
+    args: [a.key, a.x0, a.mintFee ?? presetMintFee(a.key.swapFee)],
     account: signerFor(c, a.account),
   } as never);
   return c.wallet!.writeContract(request as never);

package/src/positions.ts

@@ -6,12 +6,17 @@
  * accounts holding the same class can have different claimable amounts.
  */
 
-import { parseAbiItem } from "viem";
-import type { Address } from "viem";
+import { encodeAbiParameters, keccak256, parseAbiItem } from "viem";
+import type { Address, Hex } from "viem";
 import { logswapLensAbi, cPoolManagerAbi } from "./generated.js";
 import type { LogswapClient } from "./client.js";
-import { poolId, type PoolKey } from "./keys.js";
+import { FEE_MAX, poolId, type PoolKey } from "./keys.js";
+
+/** `CPoolState.POSITIONS_SLOT`: the manager's `positions` mapping (`forge inspect CPoolManager storageLayout`). */
+const C_POSITIONS_SLOT = 4n;
+const U128 = (1n << 128n) - 1n;
 import { isPosition, NO_CAP, positionId, unpackFloorCap } from "./ids.js";
+import { getEventLogs } from "./history.js";
 
 /** A class's aggregate state — the whole class, not one holder's slice. */
 export interface PositionClass {
@@ -25,14 +30,23 @@ export interface PositionClass {
   insideLast: bigint;
 }
 
+/**
+ * A class's aggregate state, read through `extsload` (C version 7: the manager's public
+ * `positions` mapping is gone behind it, decisions 065). The slot is `CPoolState`'s:
+ * `keccak256(abi.encode(id, POSITIONS_SLOT = 4))`, two words — (L | shares << 128) and
+ * (aps | insideLast << 128). Pinned on chain by the integration suite.
+ */
 export async function getPositionClass(c: LogswapClient, id: bigint): Promise<PositionClass> {
-  const r = (await c.public.readContract({
+  const slot = keccak256(encodeAbiParameters([{ type: "uint256" }, { type: "uint256" }], [id, C_POSITIONS_SLOT]));
+  const w = (await c.public.readContract({
     address: c.addresses.cPoolManager,
     abi: cPoolManagerAbi,
-    functionName: "positions",
-    args: [id],
-  })) as readonly [bigint, bigint, bigint, bigint];
-  return { L: r[0], shares: r[1], aps: r[2], insideLast: r[3] };
+    functionName: "extsload",
+    args: [slot, 2n],
+  } as never)) as readonly Hex[];
+  const w0 = BigInt(w[0]!), w1 = BigInt(w[1]!);
+  const hi = w1 >> 128n;
+  return { L: w0 & U128, shares: w0 >> 128n, aps: w1 & U128, insideLast: hi >= 1n << 127n ? hi - (1n << 128n) : hi };
 }
 
 /** A holder's share balance in a class. */
@@ -183,18 +197,27 @@ export function positionQuote(
   return (p.L * (upper - p.floor)) / 10n ** 18n;
 }
 
-/** The manager's `MINT_FEE`: 2 bp of newly-earning L, as a WAD fraction. */
-export const MINT_FEE = 2n * 10n ** 14n;
+/**
+ * The mint fee a create form presets: twice the swap fee, capped at {@link FEE_MAX} (decisions 064
+ * (f): guidance, not a contract rule). The creator picks from the gate's or the policy's menu
+ * (065); a listed entry is what the chain accepts — read it with `policyMintFeeMenu`.
+ */
+export function presetMintFee(swapFee: bigint): bigint {
+  const m = 2n * swapFee;
+  return m > FEE_MAX ? FEE_MAX : m;
+}
 
 /**
  * The one-time mint fee at log-price `x`, in quote units — the amount `_mintCore` pulls ON TOP of
- * the position's own legs, so a mint's total quote pull is `positionQuote(p, x) + mintFee(p, x)`.
+ * the position's own legs, so a mint's total quote pull is `positionQuote(p, x) + mintFee(p, x, rate)`.
+ * `rate` is the MARKET's mint fee (`getPool(...).mintFee`, WAD of L): per market since C version 7,
+ * the gate's answer at birth (065); there is no global `MINT_FEE` any more.
  *
  * Mirrors the manager's exemption cases: a DORMANT mint pays nothing — floor above spot, or a
- * capped class spot has already passed (`cap <= x`). Anything earning pays `MINT_FEE · L`, all of
- * it the protocol's since C version 6 (decisions 058); with no collector it goes through `F` to the
- * LPs already earning, and with none earning it is not charged. This is NOT the swap fee:
- * that one is charged per unit of |Δ log p| on swaps; this is a flat charge on L, once, at mint.
+ * capped class spot has already passed (`cap <= x`). Anything earning pays `rate · L`, all of it
+ * the protocol's (decisions 058); with no collector it goes through `F` to the LPs already
+ * earning, and with none earning it is not charged. This is NOT the swap fee: that one is charged
+ * per unit of |Δ log p| on swaps; this is a flat charge on L, once, at mint.
  *
  * One rung of imprecision: for a floor or cap exactly AT spot the contract consults its `currentK`
  * pointer (an up-move counts the tick, a down-move does not), which this offline mirror cannot see.
@@ -203,9 +226,10 @@ export const MINT_FEE = 2n * 10n ** 14n;
 export function mintFee(
   p: { L: bigint; floor: bigint; cap: bigint; capped: boolean },
   x: bigint,
+  rate: bigint,
 ): bigint {
   if (p.floor > x || (p.capped && p.cap <= x)) return 0n;
-  return (p.L * MINT_FEE) / 10n ** 18n;
+  return (p.L * rate) / 10n ** 18n;
 }
 
 /**
@@ -249,10 +273,10 @@ const ID_REGISTERED = parseAbiItem("event IdRegistered(uint256 indexed id, bytes
  * holder's slice is L · shares_owner / shares_class, and fees from the lens. One log query plus
  * a read per registered class; fine for a pool's lifetime of classes.
  */
-export async function holdingsOf(c: LogswapClient, key: PoolKey, owner: Address, fromBlock: bigint = 0n): Promise<HeldPositionRow[]> {
+export async function holdingsOf(c: LogswapClient, key: PoolKey, owner: Address, fromBlock: bigint = 0n, opts: { /** The rindexer GraphQL endpoint: the class registry from there, the node otherwise. */ indexer?: string } = {}): Promise<HeldPositionRow[]> {
   const pool = poolId(key);
-  const logs = await c.public.getLogs({ address: c.addresses.cPoolManager, event: ID_REGISTERED, args: { poolId: pool }, fromBlock, toBlock: "latest" });
-  const ids = logs.map((l) => (l.args as { id?: bigint }).id ?? 0n).filter((id) => id !== 0n);
+  const { logs } = await getEventLogs<{ id?: bigint }>(c, { indexer: opts.indexer, address: c.addresses.cPoolManager, event: ID_REGISTERED, args: { poolId: pool }, fromBlock });
+  const ids = logs.map((l) => l.args.id ?? 0n).filter((id) => id !== 0n);
   if (ids.length === 0) return [];
   // one lens call: balance, class L, fees, floor and cap for every id the owner holds
   const rows = (await c.public.readContract({