@logswap/sdk 0.5.61 → 0.5.62

package/dist/history.d.ts

@@ -36,6 +36,13 @@ export interface EventLogsQuery {
     toBlock?: bigint;
     /** Unix seconds: only events at or after this time. On the chain path it becomes a block search. */
     since?: number;
+    /**
+     * Only the newest `latest` events (still returned oldest first) — a pool's tape, not its history.
+     * On the chain path the node is asked for the last {@link LATEST_SCAN_BLOCKS} blocks only.
+     */
+    latest?: number;
+    /** Only events from these transactions — e.g. the `RouterCall`s behind a page of routed swaps. */
+    transactionHashes?: Hex[];
     signal?: AbortSignal;
 }
 /**
@@ -50,3 +57,5 @@ export declare function tableFor(c: LogswapClient, address: Address, event: stri
     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;

package/dist/history.js

@@ -97,9 +97,19 @@ async function fromIndexer(c, q) {
         filter.blockNumber = range;
     if (q.since !== undefined)
         filter.blockTimestamp = { greaterThanOrEqualTo: new Date(q.since * 1000).toISOString() };
+    if (q.transactionHashes)
+        filter.txHash = { in: q.transactionHashes.map((h) => h.toLowerCase()) };
+    // a tape is one page from the head, newest first; history is every page from the start
+    const pageSize = q.latest ?? PAGE;
+    const order = q.latest !== undefined ? "[BLOCK_NUMBER_DESC, LOG_INDEX_DESC]" : "PRIMARY_KEY_ASC";
     const selection = [...inputs.map((i) => column(i.name)), "contractAddress", "blockNumber", "blockTimestamp", "txHash", "logIndex"].join(" ");
-    const query = `query History($after: Cursor, $condition: ${type}Condition, $filter: ${type}Filter) {
-    ${field}(first: ${PAGE}, after: $after, orderBy: PRIMARY_KEY_ASC, condition: $condition, filter: $filter) {
+    // postgraphile refuses a null or an empty filter, so each argument appears only when it has content
+    const hasCondition = Object.keys(condition).length > 0;
+    const hasFilter = Object.keys(filter).length > 0;
+    const decl = `$after: Cursor${hasCondition ? `, $condition: ${type}Condition` : ""}${hasFilter ? `, $filter: ${type}Filter` : ""}`;
+    const argsOf = `first: ${pageSize}, after: $after, orderBy: ${order}${hasCondition ? ", condition: $condition" : ""}${hasFilter ? ", filter: $filter" : ""}`;
+    const query = `query History(${decl}) {
+    ${field}(${argsOf}) {
       pageInfo { hasNextPage endCursor } nodes { ${selection} }
     }
   }`;
@@ -108,10 +118,10 @@ async function fromIndexer(c, q) {
     for (let i = 0;; i++) {
         if (i === MAX_PAGES)
             throw new Error(`history: ${field} has more than ${PAGE * MAX_PAGES} rows`);
-        const d = await gql(q.indexer, query, { after, condition: Object.keys(condition).length ? condition : null, filter: Object.keys(filter).length ? filter : null }, q.signal);
+        const d = await gql(q.indexer, query, { after, ...(hasCondition ? { condition } : {}), ...(hasFilter ? { filter } : {}) }, q.signal);
         const page = d[field];
         rows.push(...page.nodes);
-        if (!page.pageInfo.hasNextPage || !page.pageInfo.endCursor)
+        if (q.latest !== undefined || !page.pageInfo.hasNextPage || !page.pageInfo.endCursor)
             break;
         after = page.pageInfo.endCursor;
     }
@@ -130,12 +140,22 @@ async function fromIndexer(c, q) {
         .sort((a, b) => (a.blockNumber === b.blockNumber ? a.logIndex - b.logIndex : a.blockNumber < b.blockNumber ? -1 : 1));
 }
 // ─── the chain path ──────────────────────────────────────────────────────────
+/** How far back the chain path looks for a `latest` tape: a tape is recent by definition. */
+export const LATEST_SCAN_BLOCKS = 5000n;
 async function fromChain(c, q) {
     let fromBlock = q.fromBlock ?? 0n;
     const toBlock = q.toBlock ?? (await c.public.getBlockNumber());
     if (q.since !== undefined)
         fromBlock = await blockAtOrAfter(c, BigInt(q.since), fromBlock, toBlock);
-    const logs = await c.public.getLogs({ address: q.address, event: q.event, args: q.args, 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 }));
+    if (q.transactionHashes) {
+        const want = new Set(q.transactionHashes.map((h) => h.toLowerCase()));
+        logs = logs.filter((l) => want.has(l.transactionHash.toLowerCase()));
+    }
+    if (q.latest !== undefined)
+        logs = logs.slice(-q.latest);
     return logs.map((l) => ({
         address: q.address,
         args: l.args,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.61",
+  "version": "0.5.62",
   "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/history.ts

@@ -40,6 +40,13 @@ export interface EventLogsQuery {
   toBlock?: bigint;
   /** Unix seconds: only events at or after this time. On the chain path it becomes a block search. */
   since?: number;
+  /**
+   * Only the newest `latest` events (still returned oldest first) — a pool's tape, not its history.
+   * On the chain path the node is asked for the last {@link LATEST_SCAN_BLOCKS} blocks only.
+   */
+  latest?: number;
+  /** Only events from these transactions — e.g. the `RouterCall`s behind a page of routed swaps. */
+  transactionHashes?: Hex[];
   signal?: AbortSignal;
 }
 
@@ -119,10 +126,19 @@ async function fromIndexer<A>(c: LogswapClient, q: EventLogsQuery): Promise<Hist
   if (q.toBlock !== undefined) range.lessThanOrEqualTo = q.toBlock.toString();
   if (Object.keys(range).length) filter.blockNumber = range;
   if (q.since !== undefined) filter.blockTimestamp = { greaterThanOrEqualTo: new Date(q.since * 1000).toISOString() };
+  if (q.transactionHashes) filter.txHash = { in: q.transactionHashes.map((h) => h.toLowerCase()) };
+  // a tape is one page from the head, newest first; history is every page from the start
+  const pageSize = q.latest ?? PAGE;
+  const order = q.latest !== undefined ? "[BLOCK_NUMBER_DESC, LOG_INDEX_DESC]" : "PRIMARY_KEY_ASC";
 
   const selection = [...inputs.map((i) => column(i.name!)), "contractAddress", "blockNumber", "blockTimestamp", "txHash", "logIndex"].join(" ");
-  const query = `query History($after: Cursor, $condition: ${type}Condition, $filter: ${type}Filter) {
-    ${field}(first: ${PAGE}, after: $after, orderBy: PRIMARY_KEY_ASC, condition: $condition, filter: $filter) {
+  // postgraphile refuses a null or an empty filter, so each argument appears only when it has content
+  const hasCondition = Object.keys(condition).length > 0;
+  const hasFilter = Object.keys(filter).length > 0;
+  const decl = `$after: Cursor${hasCondition ? `, $condition: ${type}Condition` : ""}${hasFilter ? `, $filter: ${type}Filter` : ""}`;
+  const argsOf = `first: ${pageSize}, after: $after, orderBy: ${order}${hasCondition ? ", condition: $condition" : ""}${hasFilter ? ", filter: $filter" : ""}`;
+  const query = `query History(${decl}) {
+    ${field}(${argsOf}) {
       pageInfo { hasNextPage endCursor } nodes { ${selection} }
     }
   }`;
@@ -135,12 +151,12 @@ async function fromIndexer<A>(c: LogswapClient, q: EventLogsQuery): Promise<Hist
     const d: Record<string, Conn> = await gql<Record<string, Conn>>(
       q.indexer!,
       query,
-      { after, condition: Object.keys(condition).length ? condition : null, filter: Object.keys(filter).length ? filter : null },
+      { after, ...(hasCondition ? { condition } : {}), ...(hasFilter ? { filter } : {}) },
       q.signal,
     );
     const page: Conn = d[field]!;
     rows.push(...page.nodes);
-    if (!page.pageInfo.hasNextPage || !page.pageInfo.endCursor) break;
+    if (q.latest !== undefined || !page.pageInfo.hasNextPage || !page.pageInfo.endCursor) break;
     after = page.pageInfo.endCursor;
   }
   // a table can hold a previous deployment's rows (an indexer not yet reset): keep this contract's
@@ -160,12 +176,26 @@ async function fromIndexer<A>(c: LogswapClient, q: EventLogsQuery): Promise<Hist
 
 // ─── the chain path ──────────────────────────────────────────────────────────
 
+/** How far back the chain path looks for a `latest` tape: a tape is recent by definition. */
+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());
   if (q.since !== undefined) fromBlock = await blockAtOrAfter(c, BigInt(q.since), fromBlock, toBlock);
-  const logs = await c.public.getLogs({ address: q.address, event: q.event, args: q.args, fromBlock, toBlock } as never);
-  return (logs as unknown as Array<{ args: A; blockNumber: bigint; transactionHash: Hex; logIndex: number }>).map((l) => ({
+  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<{
+    args: A;
+    blockNumber: bigint;
+    transactionHash: Hex;
+    logIndex: number;
+  }>;
+  if (q.transactionHashes) {
+    const want = new Set(q.transactionHashes.map((h) => h.toLowerCase()));
+    logs = logs.filter((l) => want.has(l.transactionHash.toLowerCase()));
+  }
+  if (q.latest !== undefined) logs = logs.slice(-q.latest);
+  return logs.map((l) => ({
     address: q.address,
     args: l.args,
     blockNumber: l.blockNumber,