@apibara/evm-rpc 2.1.0-beta.49 → 2.1.0-beta.51

package/src/log-fetcher.ts

@@ -1,7 +1,14 @@
 import type { LogFilter } from "@apibara/evm";
 import type { Bytes } from "@apibara/protocol";
 import type { RpcLog } from "viem";
-import { hexToNumber, isHex, numberToHex, pad, trim } from "viem";
+import {
+  hexToNumber,
+  isAddressEqual,
+  isHex,
+  numberToHex,
+  pad,
+  trim,
+} from "viem";
 import type { Log } from "./block";
 import type { Filter } from "./filter";
 import type { ViemRpcClient } from "./stream-config";
@@ -11,56 +18,53 @@ export async function fetchLogsByBlockHash({
   client,
   blockHash,
   filter,
+  mergeGetLogs,
 }: {
   client: ViemRpcClient;
   blockHash: Bytes;
   filter: Filter;
+  mergeGetLogs: boolean;
 }): Promise<{ logs: Log[] }> {
   if (!filter.logs || filter.logs.length === 0) {
     return { logs: [] };
   }
 
-  const responses = await Promise.all(
-    filter.logs.map(async (logFilter) => {
-      const logs = await client.request({
-        method: "eth_getLogs",
-        params: [
-          {
-            blockHash,
-            address: logFilter.address,
-            topics: logFilter.topics ? [...logFilter.topics] : undefined,
-          },
-        ],
+  const responses = mergeGetLogs
+    ? await mergedGetLogsCalls({
+        client,
+        filter,
+        blockHash,
+      })
+    : await standardGetLogsCalls({
+        client,
+        filter,
+        blockHash,
       });
-      return { logs, logFilter };
-    }),
-  );
 
-  // Multiple calls may have produced the same log.
-  // We track all the logs (by their logIndex, which is unique within a block).
-  // logIndex -> position
   const allLogs: Log[] = [];
   const seenLogsByIndex: Record<number, number> = {};
 
-  for (const { logFilter, logs } of responses) {
+  for (const { logFilters, logs } of responses) {
     for (const log of logs) {
       if (log.blockNumber === null) {
         throw new Error("Log block number is null");
       }
 
-      const refinedLog = refineLog(log, logFilter);
+      for (const logFilter of logFilters) {
+        const refinedLog = refineLog(log, logFilter);
 
-      if (refinedLog) {
-        const existingPosition = seenLogsByIndex[refinedLog.logIndex];
+        if (refinedLog) {
+          const existingPosition = seenLogsByIndex[refinedLog.logIndex];
 
-        if (existingPosition !== undefined) {
-          const existingLog = allLogs[existingPosition];
-          (existingLog.filterIds as number[]).push(logFilter.id ?? 0);
-        } else {
-          (refinedLog.filterIds as number[]).push(logFilter.id ?? 0);
+          if (existingPosition !== undefined) {
+            const existingLog = allLogs[existingPosition];
+            (existingLog.filterIds as number[]).push(logFilter.id ?? 0);
+          } else {
+            (refinedLog.filterIds as number[]).push(logFilter.id ?? 0);
 
-          allLogs.push(refinedLog);
-          seenLogsByIndex[refinedLog.logIndex] = allLogs.length - 1;
+            allLogs.push(refinedLog);
+            seenLogsByIndex[refinedLog.logIndex] = allLogs.length - 1;
+          }
         }
       }
     }
@@ -74,11 +78,13 @@ export async function fetchLogsForRange({
   fromBlock,
   toBlock,
   filter,
+  mergeGetLogs,
 }: {
   client: ViemRpcClient;
   fromBlock: bigint;
   toBlock: bigint;
   filter: Filter;
+  mergeGetLogs: boolean;
 }): Promise<{ logs: Record<number, Log[]>; blockNumbers: bigint[] }> {
   const logsByBlock: Record<number, Log[]> = {};
 
@@ -86,68 +92,61 @@ export async function fetchLogsForRange({
     return { logs: logsByBlock, blockNumbers: [] };
   }
 
-  const responses = await Promise.all(
-    filter.logs.map(async (logFilter) => {
-      const logs = await client.request({
-        method: "eth_getLogs",
-        params: [
-          {
-            fromBlock: numberToHex(fromBlock),
-            toBlock: numberToHex(toBlock),
-            address: logFilter.address,
-            topics:
-              logFilter.topics !== undefined
-                ? [...logFilter.topics]
-                : undefined,
-          },
-        ],
+  const responses = mergeGetLogs
+    ? await mergedGetLogsCalls({
+        client,
+        filter,
+        fromBlock: numberToHex(fromBlock),
+        toBlock: numberToHex(toBlock),
+      })
+    : await standardGetLogsCalls({
+        client,
+        filter,
+        fromBlock: numberToHex(fromBlock),
+        toBlock: numberToHex(toBlock),
       });
-      return { logs, logFilter };
-    }),
-  );
 
   const blockNumbers = new Set<bigint>();
 
-  // Multiple calls may have produced the same log.
-  // We track all the logs (by their logIndex, which is unique within a block).
-  // blockNumber -> logIndex -> position
   const seenLogsByBlockNumberAndIndex: Record<
     number,
     Record<number, number>
   > = {};
 
-  for (const { logFilter, logs } of responses) {
+  for (const { logFilters, logs } of responses) {
     for (const log of logs) {
       if (log.blockNumber === null) {
         throw new Error("Log block number is null");
       }
 
-      const refinedLog = refineLog(log, logFilter);
+      for (const logFilter of logFilters) {
+        const refinedLog = refineLog(log, logFilter);
 
-      if (refinedLog) {
-        const blockNumber = hexToNumber(log.blockNumber);
-        blockNumbers.add(BigInt(blockNumber));
+        if (refinedLog) {
+          const blockNumber = hexToNumber(log.blockNumber);
+          blockNumbers.add(BigInt(blockNumber));
 
-        if (!logsByBlock[blockNumber]) {
-          logsByBlock[blockNumber] = [];
-        }
+          if (!logsByBlock[blockNumber]) {
+            logsByBlock[blockNumber] = [];
+          }
 
-        if (!seenLogsByBlockNumberAndIndex[blockNumber]) {
-          seenLogsByBlockNumberAndIndex[blockNumber] = {};
-        }
+          if (!seenLogsByBlockNumberAndIndex[blockNumber]) {
+            seenLogsByBlockNumberAndIndex[blockNumber] = {};
+          }
 
-        const existingPosition =
-          seenLogsByBlockNumberAndIndex[blockNumber][refinedLog.logIndex];
+          const existingPosition =
+            seenLogsByBlockNumberAndIndex[blockNumber][refinedLog.logIndex];
 
-        if (existingPosition !== undefined) {
-          const existingLog = logsByBlock[blockNumber][existingPosition];
-          (existingLog.filterIds as number[]).push(logFilter.id ?? 0);
-        } else {
-          (refinedLog.filterIds as number[]).push(logFilter.id ?? 0);
+          if (existingPosition !== undefined) {
+            const existingLog = logsByBlock[blockNumber][existingPosition];
+            (existingLog.filterIds as number[]).push(logFilter.id ?? 0);
+          } else {
+            (refinedLog.filterIds as number[]).push(logFilter.id ?? 0);
 
-          logsByBlock[blockNumber].push(refinedLog);
-          seenLogsByBlockNumberAndIndex[blockNumber][refinedLog.logIndex] =
-            logsByBlock[blockNumber].length - 1;
+            logsByBlock[blockNumber].push(refinedLog);
+            seenLogsByBlockNumberAndIndex[blockNumber][refinedLog.logIndex] =
+              logsByBlock[blockNumber].length - 1;
+          }
         }
       }
     }
@@ -165,8 +164,11 @@ function refineLog(log: RpcLog, filter: LogFilter): Log | null {
     return null;
   }
 
+  if (filter.address && !isAddressEqual(log.address, filter.address)) {
+    return null;
+  }
+
   const filterTopics = filter.topics ?? [];
-  // Strict mode
   if (filter.strict && log.topics.length !== filterTopics.length) {
     return null;
   }
@@ -201,3 +203,102 @@ function refineLog(log: RpcLog, filter: LogFilter): Log | null {
 
   return viemRpcLogToDna(log);
 }
+
+async function mergedGetLogsCalls({
+  client,
+  filter,
+  blockHash,
+  fromBlock,
+  toBlock,
+}: {
+  client: ViemRpcClient;
+  filter: Filter;
+  blockHash?: Bytes;
+  fromBlock?: `0x${string}`;
+  toBlock?: `0x${string}`;
+}) {
+  const blockParams = blockHash ? { blockHash } : { fromBlock, toBlock };
+
+  const filtersWithAddress = filter.logs.filter((f) => f.address !== undefined);
+  const filtersWithoutAddress = filter.logs.filter(
+    (f) => f.address === undefined,
+  );
+
+  const promises: Promise<{
+    logs: RpcLog[];
+    logFilters: typeof filter.logs;
+  }>[] = [];
+
+  if (filtersWithAddress.length > 0) {
+    const addresses = filtersWithAddress.map((f) => f.address!);
+
+    promises.push(
+      client
+        .request({
+          method: "eth_getLogs",
+          params: [
+            {
+              address: addresses,
+              ...blockParams,
+            },
+          ],
+        })
+        .then((logs: RpcLog[]) => ({ logs, logFilters: filtersWithAddress })),
+    );
+  }
+
+  if (filtersWithoutAddress.length > 0) {
+    promises.push(
+      client
+        .request({
+          method: "eth_getLogs",
+          params: [
+            {
+              ...blockParams,
+            },
+          ],
+        })
+        .then((logs: RpcLog[]) => ({
+          logs,
+          logFilters: filtersWithoutAddress,
+        })),
+    );
+  }
+
+  return await Promise.all(promises);
+}
+
+async function standardGetLogsCalls({
+  client,
+  filter,
+  blockHash,
+  fromBlock,
+  toBlock,
+}: {
+  client: ViemRpcClient;
+  filter: Filter;
+  blockHash?: Bytes;
+  fromBlock?: `0x${string}`;
+  toBlock?: `0x${string}`;
+}) {
+  const blockParams = blockHash ? { blockHash } : { fromBlock, toBlock };
+  return await Promise.all(
+    filter.logs.map(async (logFilter) => {
+      const logs = await client.request({
+        method: "eth_getLogs",
+        params: [
+          {
+            address: logFilter.address,
+            topics:
+              logFilter.topics !== undefined
+                ? [...logFilter.topics]
+                : undefined,
+            ...blockParams,
+          },
+        ],
+      });
+
+      return { logs, logFilters: [logFilter] };
+    }),
+  );
+}

package/src/retry.ts

@@ -0,0 +1,22 @@
+export async function retry<T>({
+  fn,
+  maxAttempts = 3,
+  delay = 100,
+}: {
+  fn: () => Promise<T>;
+  maxAttempts?: number;
+  delay?: number;
+}): Promise<T> {
+  let attempts = 0;
+
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      attempts++;
+      if (attempts >= maxAttempts) throw error;
+      console.warn(`RPC error ${error}. Retrying in ${delay}ms`);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+}

package/src/stream-config.ts

@@ -22,6 +22,7 @@ import type { Block, Log } from "./block";
 import { type Filter, validateFilter } from "./filter";
 import { fetchLogsByBlockHash, fetchLogsForRange } from "./log-fetcher";
 import { type BlockRangeOracle, createBlockRangeOracle } from "./range-oracle";
+import { retry } from "./retry";
 import { rpcBlockHeaderToDna } from "./transform";
 
 export type RequestParameters = EIP1193Parameters<PublicRpcSchema>;
@@ -45,6 +46,8 @@ export type EvmRpcStreamOptions = {
   finalizedRefreshIntervalMs?: number;
   /** Force sending accepted headers even if no data matched. */
   alwaysSendAcceptedHeaders?: boolean;
+  /** Merge multiple `eth_getLogs` calls into a single one, filtering data on the client. */
+  mergeGetLogsFilter?: "always" | "accepted" | false;
 };
 
 export class EvmRpcStream extends RpcStreamConfig<Filter, Block> {
@@ -269,13 +272,16 @@ export class EvmRpcStream extends RpcStreamConfig<Filter, Block> {
     toBlock: bigint;
     filter: Filter;
   }): Promise<{ logs: Record<number, Log[]>; blockNumbers: bigint[] }> {
-    // TODO: implement retry
     try {
-      return await fetchLogsForRange({
-        client: this.client,
-        fromBlock,
-        toBlock,
-        filter,
+      return await retry({
+        fn: () =>
+          fetchLogsForRange({
+            client: this.client,
+            fromBlock,
+            toBlock,
+            filter,
+            mergeGetLogs: this.options.mergeGetLogsFilter === "always",
+          }),
       });
     } catch (error) {
       this.blockRangeOracle.handleError(error);
@@ -290,11 +296,16 @@ export class EvmRpcStream extends RpcStreamConfig<Filter, Block> {
     blockHash: Bytes;
     filter: Filter;
   }): Promise<{ logs: Log[] }> {
-    // TODO: implement retry
-    return await fetchLogsByBlockHash({
-      client: this.client,
-      blockHash,
-      filter,
+    return await retry({
+      fn: () =>
+        fetchLogsByBlockHash({
+          client: this.client,
+          blockHash,
+          filter,
+          mergeGetLogs:
+            this.options.mergeGetLogsFilter === "always" ||
+            this.options.mergeGetLogsFilter === "accepted",
+        }),
     });
   }
 
@@ -303,10 +314,12 @@ export class EvmRpcStream extends RpcStreamConfig<Filter, Block> {
   }: {
     blockNumber: bigint;
   }) {
-    // TODO: implement retry
-    const block = await this.client.request({
-      method: "eth_getBlockByNumber",
-      params: [numberToHex(blockNumber), false],
+    const block = await retry({
+      fn: () =>
+        this.client.request({
+          method: "eth_getBlockByNumber",
+          params: [numberToHex(blockNumber), false],
+        }),
     });
 
     if (block === null) {