@logswap/sdk 0.5.73 → 0.5.75

package/dist/history.d.ts

@@ -15,6 +15,7 @@
  */
 import { type AbiEvent, type Address, type Hex } from "viem";
 import type { LogswapClient } from "./client.js";
+import type { FPoolKind } from "./fpool.js";
 /** One event, as `getLogs` returns it plus its block's timestamp (unix seconds). */
 export interface HistoryLog<A = Record<string, unknown>> {
     address: Address;
@@ -28,7 +29,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>;
@@ -53,9 +61,81 @@ export declare function getEventLogs<A = Record<string, unknown>>(c: LogswapClie
     logs: HistoryLog<A>[];
     source: "indexer" | "chain";
 }>;
-export declare function tableFor(c: LogswapClient, address: Address, event: string): {
+/**
+ * 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 declare function indexedContractOf(kind: FPoolKind, event: string): string;
+export declare function tableFor(c: LogswapClient, address: Address, event: string, contract?: string): {
     field: string;
     type: string;
 };
 /** How far back the chain path looks for a `latest` tape: a tape is recent by definition. */
 export declare const LATEST_SCAN_BLOCKS = 5000n;
+/** 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 declare 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";
+}>;
+/** The devnet's token factory event (`src/mocks/TokenFactory.sol`): provenance for every launchable token. */
+export declare const TOKEN_CREATED: {
+    readonly name: "TokenCreated";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "creator";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "token";
+        readonly indexed: true;
+    }, {
+        readonly type: "string";
+        readonly name: "name";
+    }, {
+        readonly type: "string";
+        readonly name: "symbol";
+    }, {
+        readonly type: "uint256";
+        readonly name: "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 declare function tokensCreated(c: LogswapClient, q: {
+    indexer?: string;
+    creator?: Address;
+    fromBlock?: bigint;
+    signal?: AbortSignal;
+}): Promise<{
+    tokens: CreatedToken[];
+    source: "indexer" | "chain";
+}>;

package/dist/history.js

@@ -13,7 +13,7 @@
  * 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 } from "viem";
+import { getAddress, parseAbiItem } from "viem";
 import { bytea, gql } from "./indexer.js";
 import { blockAtOrAfter } from "./fees.js";
 /**
@@ -32,29 +32,57 @@ export async function getEventLogs(c, q) {
     return { logs: await fromChain(c, q), source: "chain" };
 }
 // ─── the indexer path ────────────────────────────────────────────────────────
-/** What the rindexer deployment calls each manager — the prefix of a table two contracts share. */
-function contractName(c, address) {
+/**
+ * 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, address, event) {
     const a = address.toLowerCase();
-    if (a === c.addresses.cPoolManager.toLowerCase())
+    const is = (x) => x !== undefined && a === x.toLowerCase();
+    const { addresses: d } = c;
+    if (is(d.cPoolManager))
         return "LogswapManager";
-    if (c.addresses.fPoolManager && a === c.addresses.fPoolManager.toLowerCase())
+    if (is(d.fPoolManager))
         return "FPoolManager";
-    if (a === c.addresses.router.toLowerCase())
+    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, event) {
+    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) => (/(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) => name[0].toLowerCase() + name.slice(1);
-export function tableFor(c, address, event) {
-    const prefix = SHARED.has(event) ? contractName(c, address) : "";
+export function tableFor(c, address, event, contract) {
+    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) => (Array.isArray(q.address) ? [...q.address] : [q.address]);
 function decode(type, v) {
     if (v === null || v === undefined)
         return v;
@@ -71,7 +99,10 @@ const MAX_PAGES = 200;
 /** Pages in flight at once, after the first. */
 const PARALLEL_PAGES = 8;
 async function fromIndexer(c, q) {
-    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 = {};
     const filter = {};
@@ -134,11 +165,11 @@ async function fromIndexer(c, q) {
         }
     }
     // 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)])])),
         blockNumber: BigInt(r.blockNumber),
         blockTimestamp: Math.floor(Date.parse(r.blockTimestamp) / 1000),
@@ -152,12 +183,15 @@ async function fromIndexer(c, q) {
 export const LATEST_SCAN_BLOCKS = 5000n;
 async function fromChain(c, q) {
     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 }));
+    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 }));
     if (q.transactionHashes) {
         const want = new Set(q.transactionHashes.map((h) => h.toLowerCase()));
         logs = logs.filter((l) => want.has(l.transactionHash.toLowerCase()));
@@ -165,10 +199,68 @@ async function fromChain(c, q) {
     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 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, q) {
+    const order = (a, b) => (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(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 }));
+    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)");
+/**
+ * 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, q) {
+    const factory = c.addresses.tokenFactory;
+    if (!factory)
+        throw new Error("logswap: tokensCreated needs addresses.tokenFactory");
+    const { logs, source } = await getEventLogs(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/dist/indexer.js

@@ -204,12 +204,7 @@ export async function poolPositionsFromChain(c, key, x) {
             functionName: "idOf",
             args: [key, floor],
         }));
-        const [L, shares] = (await c.public.readContract({
-            address: c.addresses.cPoolManager,
-            abi: cPoolManagerAbi,
-            functionName: "positions",
-            args: [id],
-        }));
+        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 };

package/dist/keys.d.ts

@@ -13,7 +13,9 @@
 import { 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.
@@ -31,7 +33,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.
@@ -41,10 +44,9 @@ export interface PoolKey {
 /**
  * `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 declare function poolId(key: PoolKey): Hex;
 /** Structural equality of two keys — i.e. "the same market". */

package/dist/keys.js

@@ -13,7 +13,9 @@
 import { encodeAbiParameters, keccak256 } 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,10 +36,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) {
     return keccak256(encodeAbiParameters(POOL_KEY_ABI, [

package/dist/liquidity.d.ts

@@ -61,13 +61,20 @@ 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;
 }
 /**
  * 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

package/dist/liquidity.js

@@ -23,7 +23,7 @@
  */
 import { logswapLensAbi, logswapRouterAbi } from "./generated.js";
 import { NO_CAP } from "./ids.js";
-import { describeId, getPositionClass } from "./positions.js";
+import { describeId, getPositionClass, presetMintFee } from "./positions.js";
 import { execute, OPEN_DELTA, settleInKind, settleOnly, swapExactInAction, swapExactOutAction, updateAction, } from "./actions.js";
 import { requireWallet, resolveDeadline, resolveRecipient, sendRouterWrite, sendRouterWriteWithPermits, withSlippage, } from "./write.js";
 import { quoteExactIn, quoteExactOut } from "./swap.js";
@@ -55,7 +55,9 @@ export async function mint(c, a) {
 }
 /**
  * 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
@@ -68,6 +70,7 @@ export async function createMarket(c, a) {
         args: [
             a.key,
             a.x0,
+            a.mintFee ?? presetMintFee(a.key.swapFee),
             a.targetFloor,
             a.L,
             a.maxBaseIn,

package/dist/pools.d.ts

@@ -14,7 +14,10 @@
 import { type Address, type Hex } from "viem";
 import type { LogswapClient } from "./client.js";
 import { type PoolKey } from "./keys.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;
@@ -32,14 +35,16 @@ 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 declare function getPool(c: LogswapClient, key: PoolKey): Promise<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 declare function marketSwapFee(c: LogswapClient, key: PoolKey): Promise<bigint>;
 /**
@@ -114,7 +119,8 @@ export declare function discoverMarkets(c: LogswapClient, opts?: {
     fromBlock?: bigint;
     toBlock?: bigint;
     base?: Address;
-    quote?: Address;
+    quote?: Address; /** The rindexer GraphQL endpoint: `Initialize` from there, the node otherwise. */
+    indexer?: string;
 }): Promise<DiscoveredMarket[]>;
 /**
  * Ladder shape: the live FLOORS, in log-price WAD — **not** tick indices.
@@ -203,12 +209,15 @@ export declare function annualise(perUnitL: bigint, elapsedSeconds: bigint): num
 /** When a market was created, as a unix timestamp — the denominator for {@link annualise}. */
 export declare function marketOpenedAt(c: LogswapClient, m: DiscoveredMarket): Promise<bigint>;
 /**
- * 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 declare function initializeMarket(c: LogswapClient, a: {
     key: PoolKey;
     x0: bigint;
+    mintFee?: bigint;
     account: Address;
 }): Promise<`0x${string}`>;

package/dist/pools.js

@@ -16,29 +16,29 @@ import { logswapLensAbi, cPoolManagerAbi } from "./generated.js";
 import { signerFor } from "./write.js";
 import { readCachedToken, registerCacheClear, writeCachedToken } from "./tokencache.js";
 import { poolId } from "./keys.js";
-/** Read a market's full state by key. */
+import { presetMintFee } from "./positions.js";
+import { getEventLogs } from "./history.js";
+/** 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, key) {
-    const v = await c.public.readContract({
-        address: c.addresses.cPoolManager,
-        abi: cPoolManagerAbi,
-        functionName: "getPool",
-        args: [poolId(key)],
-    });
-    return v;
+    const v = (await c.public.readContract({
+        address: c.addresses.lens,
+        abi: logswapLensAbi,
+        functionName: "getPools",
+        args: [[poolId(key)]],
+    }));
+    return v[0];
 }
 /**
- * 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, key) {
-    return c.public.readContract({
-        address: c.addresses.cPoolManager,
-        abi: cPoolManagerAbi,
-        functionName: "swapFeeOf",
-        args: [key],
-    });
+    const s = await getPool(c, key);
+    if (!s.initialized)
+        throw new Error(`logswap: market ${poolId(key)} is not initialized`);
+    return key.swapFee;
 }
 /**
  * Price from the stored log-price. **Lossy** — `x` is exact and this is a float, so use it for
@@ -112,12 +112,18 @@ export async function discoverMarkets(c, opts = {}) {
     const ev = cPoolManagerAbi.find((x) => 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 = {};
+    if (opts.base)
+        args.base = opts.base;
+    if (opts.quote)
+        args.quote = opts.quote;
+    const { logs } = await getEventLogs(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;
@@ -332,16 +338,18 @@ export async function marketOpenedAt(c, m) {
     return b.timestamp;
 }
 /**
- * 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, a) {
     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),
     });
     return c.wallet.writeContract(request);

package/dist/positions.d.ts

@@ -19,6 +19,12 @@ export interface PositionClass {
     /** Snapshot of `F_above[floor] − F_above[cap]` at the class's last touch. */
     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 declare function getPositionClass(c: LogswapClient, id: bigint): Promise<PositionClass>;
 /** A holder's share balance in a class. */
 export declare function balanceOf(c: LogswapClient, owner: Address, id: bigint): Promise<bigint>;
@@ -103,17 +109,23 @@ export declare function positionQuote(p: {
     cap: bigint;
     capped: boolean;
 }, x: bigint): bigint;
-/** The manager's `MINT_FEE`: 2 bp of newly-earning L, as a WAD fraction. */
-export declare const MINT_FEE: bigint;
+/**
+ * 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 declare function presetMintFee(swapFee: bigint): bigint;
 /**
  * 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.
@@ -124,7 +136,7 @@ export declare function mintFee(p: {
     floor: bigint;
     cap: bigint;
     capped: boolean;
-}, x: bigint): bigint;
+}, x: bigint, rate: bigint): bigint;
 /**
  * Every UNCAPPED position `owner` holds in a market, enumerated fully on-chain by the lens — a
  * bitmap walk plus a balance check per live floor. No indexer, no log scan. Capped classes are
@@ -154,7 +166,9 @@ export declare function positionsOf(c: LogswapClient, key: PoolKey, owner: Addre
  * 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 declare function holdingsOf(c: LogswapClient, key: PoolKey, owner: Address, fromBlock?: bigint): Promise<HeldPositionRow[]>;
+export declare function holdingsOf(c: LogswapClient, key: PoolKey, owner: Address, fromBlock?: bigint, opts?: {
+    indexer?: string;
+}): Promise<HeldPositionRow[]>;
 /** A holding's legs, exact from the lens: base (base units), the quote leg, claimable fees, and
  *  value = base·p + quote + fees in quote units — L + quote + fees for an uncapped active class. */
 export declare function legsOf(c: LogswapClient, key: PoolKey, id: bigint, holder: Address): Promise<{