@logswap/sdk 0.5.74 → 0.5.76

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/index.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/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,8 @@ 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";
+import { poolHolders } from "./views.js";
 
 /** A class's aggregate state — the whole class, not one holder's slice. */
 export interface PositionClass {
@@ -262,6 +264,22 @@ export async function positionsOf(c: LogswapClient, key: PoolKey, owner: Address
 
 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: LogswapClient, indexer: string, pool: Hex, owner: Address): Promise<bigint[] | null> {
+  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: LogswapClient, pool: Hex, fromBlock: bigint, indexer?: string): Promise<bigint[]> {
+  const { logs } = await getEventLogs<{ id?: bigint }>(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.
  *
@@ -272,10 +290,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: 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 owner's held ids from its `pool_holder` view (the class registry as fallback), 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 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
   const rows = (await c.public.readContract({