@logswap/sdk 0.5.74 → 0.5.75

package/README.md

@@ -69,6 +69,21 @@ Since logswap-contract #60 (decisions 064–065) creation is curated at launch,
   collector's helpers: `policySetCreatorListed`, `policySetMintFeeListed`, `gateSetPairListed`,
   `gateSetSpacingListed`, `gateSetForwarderTrusted`, `setCGate`.
 
+## History from the indexer (indexer phase 1)
+
+Every event read goes through `getEventLogs` (one event) or `getEventsLogs` (several, tagged by
+`eventName`): the rindexer GraphQL endpoint when one is given, the node otherwise or when it fails.
+Since logswap-be #43 the indexer also holds the four policies (one `Policy` table per event, tracked
+from the registry's `Approved`), the registry, the token factory and the managers' admin events, so
+nothing has to scan the node from block 0 — which the devnet node, pruning logs after about a day,
+answers only partly.
+
+- `swapFees`, `holdingsOf`, `discoverMarkets` and `fPoolKeyOfPool` take `indexer` (the salt is not in
+  `FInitialize`, so a pad's key is still rebuilt from its split with nonce 0).
+- `getEventLogs` takes several emitters (`address: [...]`); a policy outside the artifact names its
+  shared tables with `contract: indexedContractOf(kind, event)` (or `kind` on `getEventsLogs`).
+- `tokensCreated` lists the factory's tokens (`addresses.tokenFactory`): the token list's provenance.
+
 ## Capped F pools and the lien (F version 25)
 
 - **The cap** (decisions 061) is a key field: `FPoolKey.cap` / `FPoolCreateArgs.cap`, d =

package/dist/client.d.ts

@@ -35,6 +35,8 @@ export interface LogswapAddresses {
      * absent; a deployment with none asks nobody.
      */
     policyRegistry?: Address;
+    /** The devnet's token factory (`TokenFactory`, a mock): where launchable tokens come from. Optional. */
+    tokenFactory?: Address;
     /** Optional — the router falls back to plain approvals when absent. */
     permit2?: Address;
 }

package/dist/fees.d.ts

@@ -55,7 +55,8 @@ export declare function blockAtOrAfter(c: LogswapClient, t: bigint, lo: bigint,
 export declare function swapFees(c: LogswapClient, m: DiscoveredMarket, opts?: {
     since?: bigint;
     fromBlock?: bigint;
-    toBlock?: bigint;
+    toBlock?: bigint; /** The rindexer GraphQL endpoint: the Swap rows from there, the node otherwise. */
+    indexer?: string;
 }): Promise<SwapFeeWindow>;
 /**
  * The window's swap fees over the market's CURRENT active L, annualised linearly over the window.

package/dist/fees.js

@@ -11,6 +11,7 @@
  * Both equal φ·L·|Δx| summed over the swap's segments — the same φ·|dx| per unit L that `F` books.
  */
 import { cPoolManagerAbi } from "./generated.js";
+import { getEventLogs } from "./history.js";
 const WAD = 10n ** 18n;
 const YEAR_SECONDS = 31_536_000;
 /**
@@ -89,7 +90,7 @@ export async function swapFees(c, m, opts = {}) {
         throw new Error("logswap: Swap event missing from the generated ABI");
     const logs = fromBlock > toBlock
         ? []
-        : await c.public.getLogs({ address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock });
+        : (await getEventLogs(c, { indexer: opts.indexer, address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock })).logs;
     // the event carries the fee the swap charged (decisions 050), exactly — no re-derivation from φ
     let fees = 0n;
     for (const l of logs)

package/dist/fpool.d.ts

@@ -1412,7 +1412,8 @@ export declare function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "ac
  */
 export declare function fPoolKeyOfPool(c: LogswapClient, poolId: Hex, opts?: {
     salt?: Hex;
-    fromBlock?: bigint;
+    fromBlock?: bigint; /** The rindexer GraphQL endpoint: `FInitialize` from there, the node otherwise. The salt is in neither (the event does not carry it). */
+    indexer?: string;
 }): Promise<FPoolKey>;
 /**
  * The reserve a leg holds at a mark: `R = Lj·e^{−x}`, WAD math. The seed names RESERVES —

package/dist/fpool.js

@@ -779,13 +779,7 @@ export async function fPoolIdOf(c, a) {
  */
 export async function fPoolKeyOfPool(c, poolId, opts = {}) {
     const ev = fPoolManagerAbi.find((x) => x.type === "event" && x.name === "FInitialize");
-    const logs = await c.public.getLogs({
-        address: c.addresses.fPoolManager,
-        event: ev,
-        args: { poolId },
-        fromBlock: opts.fromBlock ?? 0n,
-        toBlock: "latest",
-    });
+    const { logs } = await getEventLogs(c, { indexer: opts.indexer, address: c.addresses.fPoolManager, event: ev, args: { poolId }, fromBlock: opts.fromBlock ?? 0n });
     const l = logs[0];
     if (!l)
         throw new Error(`logswap: no FInitialize for F pool ${poolId}`);

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/pools.d.ts

@@ -119,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.

package/dist/pools.js

@@ -17,6 +17,7 @@ import { signerFor } from "./write.js";
 import { readCachedToken, registerCacheClear, writeCachedToken } from "./tokencache.js";
 import { poolId } from "./keys.js";
 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({
@@ -111,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;

package/dist/positions.d.ts

@@ -166,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<{

package/dist/positions.js

@@ -12,6 +12,7 @@ import { FEE_MAX, poolId } from "./keys.js";
 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, read through `extsload` (C version 7: the manager's public
  * `positions` mapping is gone behind it, decisions 065). The slot is `CPoolState`'s:
@@ -191,9 +192,9 @@ 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, key, owner, fromBlock = 0n) {
+export async function holdingsOf(c, key, owner, fromBlock = 0n, opts = {}) {
     const pool = poolId(key);
-    const logs = await c.public.getLogs({ address: c.addresses.cPoolManager, event: ID_REGISTERED, args: { poolId: pool }, fromBlock, toBlock: "latest" });
+    const { logs } = await getEventLogs(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 [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.74",
+  "version": "0.5.75",
   "description": "TypeScript SDK for Logswap, the liquidity primitive introducing the logarithmic invariant — typed wrappers over the CPoolManager / FPoolManager / Router / Lens surface.",
   "license": "GPL-2.0-or-later",
   "type": "module",

package/src/client.ts

@@ -37,6 +37,8 @@ export interface LogswapAddresses {
    * absent; a deployment with none asks nobody.
    */
   policyRegistry?: Address;
+  /** The devnet's token factory (`TokenFactory`, a mock): where launchable tokens come from. Optional. */
+  tokenFactory?: Address;
   /** Optional — the router falls back to plain approvals when absent. */
   permit2?: Address;
 }

package/src/fees.ts

@@ -14,6 +14,7 @@
 import type { LogswapClient } from "./client.js";
 import { cPoolManagerAbi } from "./generated.js";
 import type { DiscoveredMarket } from "./pools.js";
+import { getEventLogs } from "./history.js";
 
 const WAD = 10n ** 18n;
 const YEAR_SECONDS = 31_536_000;
@@ -85,7 +86,7 @@ export async function blockAtOrAfter(c: LogswapClient, t: bigint, lo: bigint, hi
 export async function swapFees(
   c: LogswapClient,
   m: DiscoveredMarket,
-  opts: { since?: bigint; fromBlock?: bigint; toBlock?: bigint } = {},
+  opts: { since?: bigint; fromBlock?: bigint; toBlock?: bigint; /** The rindexer GraphQL endpoint: the Swap rows from there, the node otherwise. */ indexer?: string } = {},
 ): Promise<SwapFeeWindow> {
   const toBlock = opts.toBlock ?? (await c.public.getBlockNumber());
   const [opened, last] = await Promise.all([
@@ -112,11 +113,11 @@ export async function swapFees(
 
   const logs = fromBlock > toBlock
     ? []
-    : await c.public.getLogs({ address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock });
+    : (await getEventLogs<{ fee: bigint }>(c, { indexer: opts.indexer, address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock })).logs;
 
   // the event carries the fee the swap charged (decisions 050), exactly — no re-derivation from φ
   let fees = 0n;
-  for (const l of logs) fees += l.args.fee!;
+  for (const l of logs) fees += l.args.fee;
 
   const to = last.timestamp;
   return { fromBlock, toBlock, from, to, seconds: to > from ? to - from : 0n, swapFees: fees, swaps: logs.length };

package/src/fpool.ts

@@ -1150,19 +1150,13 @@ export async function fPoolIdOf(c: LogswapClient, a: Omit<FPoolCreateArgs, "acco
  * without naming one; a pad's carries its split, so it is rebuilt from the policy's record with nonce 0 — pass `opts.salt` for another nonce). The result is checked against the id, so a wrong salt throws rather than
  * returning a key that names another pool. What {@link fPoolMigrate} needs when handed an id.
  */
-export async function fPoolKeyOfPool(c: LogswapClient, poolId: Hex, opts: { salt?: Hex; fromBlock?: bigint } = {}): Promise<FPoolKey> {
+export async function fPoolKeyOfPool(c: LogswapClient, poolId: Hex, opts: { salt?: Hex; fromBlock?: bigint; /** The rindexer GraphQL endpoint: `FInitialize` from there, the node otherwise. The salt is in neither (the event does not carry it). */ indexer?: string } = {}): Promise<FPoolKey> {
   type Ev = Extract<(typeof fPoolManagerAbi)[number], { type: "event"; name: "FInitialize" }>;
   const ev = fPoolManagerAbi.find((x): x is Ev => x.type === "event" && x.name === "FInitialize")!;
-  const logs = await c.public.getLogs({
-    address: c.addresses.fPoolManager!,
-    event: ev,
-    args: { poolId },
-    fromBlock: opts.fromBlock ?? 0n,
-    toBlock: "latest",
-  });
+  const { logs } = await getEventLogs(c, { indexer: opts.indexer, address: c.addresses.fPoolManager!, event: ev as never, args: { poolId }, fromBlock: opts.fromBlock ?? 0n });
   const l = logs[0];
   if (!l) throw new Error(`logswap: no FInitialize for F pool ${poolId}`);
-  const a = l.args as { quote: Address; creator: Address; bases: readonly Address[]; weights: readonly bigint[]; swapFee: bigint; policy: Address; cap: number };
+  const a = l.args as unknown as { quote: Address; creator: Address; bases: readonly Address[]; weights: readonly bigint[]; swapFee: bigint; policy: Address; cap: number | bigint };
   const key: FPoolKey = {
     quote: a.quote,
     bases: [...a.bases],

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/pools.ts

@@ -19,6 +19,7 @@ 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";
 
 /**
  * A market's scalar state, field-for-field with `CPoolState.PoolView` — what the manager's `getPool`
@@ -162,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.
@@ -170,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,
     };
   });
 }

package/src/positions.ts

@@ -16,6 +16,7 @@ import { FEE_MAX, poolId, type PoolKey } from "./keys.js";
 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 {
@@ -272,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({