@logswap/sdk 0.5.74 → 0.5.76

package/README.md

@@ -69,6 +69,53 @@ 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.
+
+## Indexer views (indexing phase 2)
+
+The indexer also serves derived views (logswap-be `devnet/VIEWS.md`), joining its event tables with
+the snapshotter's state. `views.ts` reads each as typed rows: amounts as `bigint`, prices, APYs and
+progress as `number`, times as unix seconds. Every reader takes the GraphQL endpoint and a
+`{ condition, filter, orderBy, first, signal }` query, and pages by offset.
+
+| Reader | View | What a row is |
+| --- | --- | --- |
+| `poolDirectory` | `allPoolDirectories` | a pool of either manager, its kind and birth |
+| `eventUsers` | `allEventUsers` | a manager event and who did it (the router's caller when routed) |
+| `poolHolders` | `allPoolHolders` | a current ERC-6909 balance, with C's backstop and F's dead shares flagged |
+| `walletPositions` | `allWalletPositions` | a wallet's holding; F valued at the latest share value |
+| `walletPoolFlows` | `allWalletPoolFlows` | a wallet's in/out, fees and dividends per pool |
+| `swapFlows` | `allSwapFlows` | a swap's volume and fee in quote |
+| `priceTicks` | `allPriceTicks` | a price point per (pool, base) |
+| `candles(url, "minute" \| "hour" \| "day")` | `allCandle…s` | OHLC with volume and fees |
+| `poolTvlHours` | `allPoolTvlHours` | the hour's last snapshot: TVL, liquidity |
+| `poolSummaries` | `allPoolSummaries` | 24 h / 7 d volume, fees, APY; latest TVL |
+| `generationSteps` | `allGenerationSteps` | a `regenerate` step and its pot split |
+| `padStatuses` | `allPadStatuses` | each pad and POL now, with the next threshold and progress |
+| `protocolRevenueDays` | `allProtocolRevenueDays` | protocol revenue per day and source |
+
+Given an `indexer`, three functions now take their figure from a view and keep their previous path
+as the fallback, with the same answer on the same data:
+- `holdingsOf`: the owner's held class ids from `pool_holder`, then the lens as before;
+- `fPoolShareHolders`: the holders from `pool_holder`;
+- `swapFees`: the window from `swap_flow`.
+
+What stays a live read: a C position's value and every unclaimed fee or dividend (the lens: `legsOf`,
+`heldByIds`, `fDividendOf`). They accrue without events, so no view holds them.
+
 ## 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 window from its swap_flow view (the Swap rows as fallback), 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,24 @@
  * 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";
+import { swapFlows } from "./views.js";
+/** A C market's swap fees over [fromBlock, toBlock] from the indexer's swap_flow view; null when the indexer cannot answer. */
+async function windowFromView(c, indexer, poolId, fromBlock, toBlock) {
+    try {
+        const rows = await swapFlows(indexer, {
+            condition: { side: "C", poolId: poolId.toLowerCase(), manager: c.addresses.cPoolManager.toLowerCase() },
+            filter: { blockNumber: { greaterThanOrEqualTo: fromBlock.toString(), lessThanOrEqualTo: toBlock.toString() } },
+        });
+        let fees = 0n;
+        for (const r of rows)
+            fees += r.feeQuote;
+        return { fees, swaps: rows.length };
+    }
+    catch {
+        return null; // the view is a cache: the Swap rows answer the same
+    }
+}
 const WAD = 10n ** 18n;
 const YEAR_SECONDS = 31_536_000;
 /**
@@ -87,15 +105,22 @@ export async function swapFees(c, m, opts = {}) {
     const ev = cPoolManagerAbi.find((x) => x.type === "event" && x.name === "Swap");
     if (!ev)
         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 });
-    // the event carries the fee the swap charged (decisions 050), exactly — no re-derivation from φ
+    // the event carries the fee the swap charged (decisions 050), exactly — no re-derivation from φ;
+    // the indexer's swap_flow view carries the same figure per swap (`feeQuote`, C)
     let fees = 0n;
-    for (const l of logs)
-        fees += l.args.fee;
+    let swaps = 0;
+    const viewed = fromBlock > toBlock || !opts.indexer ? null : await windowFromView(c, opts.indexer, m.poolId, fromBlock, toBlock);
+    if (viewed) {
+        ({ fees, swaps } = viewed);
+    }
+    else if (fromBlock <= toBlock) {
+        const { logs } = await getEventLogs(c, { indexer: opts.indexer, address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock });
+        for (const l of logs)
+            fees += l.args.fee;
+        swaps = logs.length;
+    }
     const to = last.timestamp;
-    return { fromBlock, toBlock, from, to, seconds: to > from ? to - from : 0n, swapFees: fees, swaps: logs.length };
+    return { fromBlock, toBlock, from, to, seconds: to > from ? to - from : 0n, swapFees: fees, swaps };
 }
 /**
  * The window's swap fees over the market's CURRENT active L, annualised linearly over the window.

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 —
@@ -1913,7 +1914,7 @@ export declare function fPoolsControlledBy(c: LogswapClient, who: Address, opts?
 /**
  * Every holder of a pool's shares, from the ERC-6909 Transfer stream — the id is an indexed
  * topic, so one filtered log query aggregates the whole ledger. The 0xdead entry is the
- * MIN_SHARES lock from seeding; callers usually label rather than hide it. Pass `indexer`: a node
+ * MIN_SHARES lock from seeding; callers usually label rather than hide it. Pass `indexer`: the indexer's `pool_holder` view answers directly (the Transfer replay is the fallback) — a node
  * prunes its logs (anvil keeps about a day), and a ledger rebuilt from a pruned stream loses every
  * holder minted before the cut.
  */

package/dist/fpool.js

@@ -47,6 +47,7 @@ export { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPo
 export const fPolicyBaseAbi = polPolicyAbi;
 import { fallBackUnlessRejected, signerFor } from "./write.js";
 import { getEventLogs } from "./history.js";
+import { poolHolders } from "./views.js";
 import { presetMintFee } from "./positions.js";
 const WAD = 10n ** 18n;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
@@ -779,13 +780,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}`);
@@ -1428,7 +1423,7 @@ export async function fPoolsControlledBy(c, who, opts = {}) {
 /**
  * Every holder of a pool's shares, from the ERC-6909 Transfer stream — the id is an indexed
  * topic, so one filtered log query aggregates the whole ledger. The 0xdead entry is the
- * MIN_SHARES lock from seeding; callers usually label rather than hide it. Pass `indexer`: a node
+ * MIN_SHARES lock from seeding; callers usually label rather than hide it. Pass `indexer`: the indexer's `pool_holder` view answers directly (the Transfer replay is the fallback) — a node
  * prunes its logs (anvil keeps about a day), and a ledger rebuilt from a pruned stream loses every
  * holder minted before the cut.
  */
@@ -1436,7 +1431,20 @@ export async function fPoolShareHolders(c, poolIdHex, opts = {}) {
     const ev = fPoolManagerAbi.find((x) => x.type === "event" && x.name === "Transfer");
     if (!ev)
         throw new Error("logswap: 6909 Transfer event missing from the generated ABI");
-    const id = fPoolShareId(poolIdHex, opts.gen ?? (await fPoolGen(c, poolIdHex)));
+    const gen = opts.gen ?? (await fPoolGen(c, poolIdHex));
+    if (opts.indexer) {
+        try {
+            const rows = await poolHolders(opts.indexer, { condition: { side: "F", poolId: poolIdHex.toLowerCase(), gen: Number(gen), manager: c.addresses.fPoolManager.toLowerCase() } });
+            return rows
+                .filter((r) => r.balance > 0n)
+                .map((r) => ({ holder: r.holder, shares: r.balance }))
+                .sort((a, b) => (b.shares > a.shares ? 1 : -1));
+        }
+        catch {
+            /* the view is a cache: the Transfer replay below answers the same */
+        }
+    }
+    const id = fPoolShareId(poolIdHex, gen);
     const { logs } = await getEventLogs(c, { indexer: opts.indexer, address: c.addresses.fPoolManager, event: ev, args: { id }, fromBlock: opts.fromBlock });
     const bal = new Map();
     for (const l of logs) {

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

@@ -21,5 +21,6 @@ export * from "./tokencache.js";
 export * from "./fpool.js";
 export * from "./fees.js";
 export * from "./history.js";
+export * from "./views.js";
 export { cPoolManagerAbi, fPoolManagerAbi, logswapLensAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 export * from "./admin.js";

package/dist/index.js

@@ -21,5 +21,6 @@ export * from "./tokencache.js";
 export * from "./fpool.js";
 export * from "./fees.js";
 export * from "./history.js";
+export * from "./views.js";
 export { cPoolManagerAbi, fPoolManagerAbi, logswapLensAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 export * from "./admin.js";

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,8 @@ 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";
+import { poolHolders } from "./views.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:
@@ -181,6 +183,21 @@ export async function positionsOf(c, key, owner) {
     return rows.map((r) => ({ id: r.id, floor: r.floor, cap: NO_CAP, capped: false, shares: r.shares, L: r.L, fees: r.fees }));
 }
 const ID_REGISTERED = parseAbiItem("event IdRegistered(uint256 indexed id, bytes32 indexed poolId, int256 floor, int256 cap, bool capped)");
+/** The class ids `owner` holds in `pool`, from the indexer's `pool_holder` view; null when the indexer cannot answer. */
+async function heldIdsFromView(c, indexer, pool, owner) {
+    try {
+        const rows = await poolHolders(indexer, { condition: { side: "C", poolId: pool.toLowerCase(), holder: owner.toLowerCase(), manager: c.addresses.cPoolManager.toLowerCase() } });
+        return rows.filter((r) => r.balance > 0n && !r.isBackstop).map((r) => r.id);
+    }
+    catch {
+        return null; // the view is a cache: the IdRegistered replay below answers the same
+    }
+}
+/** Every class id ever registered in `pool` (`IdRegistered`), from the indexer's table or the node. */
+async function registeredIds(c, pool, fromBlock, indexer) {
+    const { logs } = await getEventLogs(c, { indexer, address: c.addresses.cPoolManager, event: ID_REGISTERED, args: { poolId: pool }, fromBlock });
+    return logs.map((l) => l.args.id ?? 0n).filter((id) => id !== 0n);
+}
 /**
  * EVERY class this owner holds in a pool, capped ones included — the complete book.
  *
@@ -191,10 +208,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 ids = logs.map((l) => l.args.id ?? 0n).filter((id) => id !== 0n);
+    const ids = (opts.indexer ? await heldIdsFromView(c, opts.indexer, pool, owner) : null) ?? (await registeredIds(c, pool, fromBlock, opts.indexer));
     if (ids.length === 0)
         return [];
     // one lens call: balance, class L, fees, floor and cap for every id the owner holds