fix: get logs batching

Author: vasyl-ivanchuk

src/adapters/ethers/resources/interop/address.ts

@@ -13,12 +13,7 @@ export function formatInteropEvmChain(chainId: bigint): Hex {
   const chainRef = toBeArray(chainId);
   const chainRefLength = getBytes(toBeHex(chainRef.length, 1));
 
-  const payload = concat([
-    PREFIX_EVM_CHAIN,
-    chainRefLength,
-    chainRef,
-    new Uint8Array([0]),
-  ]);
+  const payload = concat([PREFIX_EVM_CHAIN, chainRefLength, chainRef, new Uint8Array([0])]);
 
   return hexlify(payload) as Hex;
 }

src/adapters/ethers/resources/interop/context.ts

@@ -42,8 +42,8 @@ export async function commonCtx(
   attributes: AttributesResource,
 ): Promise<BuildCtx> {
   const sender = (await client.signer.getAddress()) as Address;
-  const chainId = BigInt((await client.l2.getNetwork()).chainId);
-  const dstChainId = BigInt((await dstProvider.getNetwork()).chainId);
+  const chainId = (await client.l2.getNetwork()).chainId;
+  const dstChainId = (await dstProvider.getNetwork()).chainId;
 
   const {
     bridgehub,

src/adapters/ethers/resources/interop/index.ts

@@ -33,6 +33,7 @@ import {
   createInteropFinalizationServices,
   type InteropFinalizationServices,
 } from './services/finalization';
+import type { DestinationLogsQueryOptions } from './services/finalization/data-fetchers';
 
 const { wrap, toResult } = createErrorHandlers('interop');
 
@@ -72,7 +73,7 @@ function resolveWaitableInput(waitableInput: InteropWaitable): {
   const input = waitableInput as { waitable?: InteropWaitableBase };
   return {
     dstProvider: resolveDstProvider(waitableInput.dstChain),
-    waitable: input.waitable ? input.waitable : waitableInput as InteropHandle<unknown>,
+    waitable: input.waitable ? input.waitable : (waitableInput as InteropHandle<unknown>),
   };
 }
 
@@ -97,7 +98,7 @@ export interface InteropResource {
     { ok: true; value: InteropHandle<TransactionRequest> } | { ok: false; error: unknown }
   >;
 
-  status(h: InteropWaitable): Promise<InteropStatus>;
+  status(h: InteropWaitable, opts?: DestinationLogsQueryOptions): Promise<InteropStatus>;
 
   wait(
     h: InteropWaitable,
@@ -109,10 +110,14 @@ export interface InteropResource {
     opts?: { pollMs?: number; timeoutMs?: number },
   ): Promise<{ ok: true; value: InteropFinalizationInfo } | { ok: false; error: unknown }>;
 
-  finalize(h: InteropWaitable | InteropFinalizationInfo): Promise<InteropFinalizationResult>;
+  finalize(
+    h: InteropWaitable | InteropFinalizationInfo,
+    opts?: DestinationLogsQueryOptions,
+  ): Promise<InteropFinalizationResult>;
 
   tryFinalize(
     h: InteropWaitable | InteropFinalizationInfo,
+    opts?: DestinationLogsQueryOptions,
   ): Promise<{ ok: true; value: InteropFinalizationResult } | { ok: false; error: unknown }>;
 }
 
@@ -296,9 +301,12 @@ export function createInteropResource(
     toResult<InteropHandle<TransactionRequest>>(OP_INTEROP.tryCreate, () => create(params));
 
   // status → non-blocking lifecycle inspection
-  const status = (h: InteropWaitable): Promise<InteropStatus> => {
+  const status = (
+    h: InteropWaitable,
+    opts?: DestinationLogsQueryOptions,
+  ): Promise<InteropStatus> => {
     const { dstProvider, waitable } = resolveWaitableInput(h);
-    return wrap(OP_INTEROP.status, () => svc.status(dstProvider, waitable), {
+    return wrap(OP_INTEROP.status, () => svc.status(dstProvider, waitable, opts), {
       message: 'Internal error while checking interop status.',
       ctx: { where: 'interop.status' },
     });
@@ -331,6 +339,7 @@ export function createInteropResource(
   // returns finalization metadata for UI / explorers.
   const finalize = (
     h: InteropWaitable | InteropFinalizationInfo,
+    opts?: DestinationLogsQueryOptions,
   ): Promise<InteropFinalizationResult> =>
     wrap(
       OP_INTEROP.finalize,
@@ -345,21 +354,23 @@ export function createInteropResource(
             });
           }
           const dstProvider = resolveDstProvider(h.dstChain);
-          return svc.finalize(dstProvider, h);
+          return svc.finalize(dstProvider, h, opts);
         }
 
         const { dstProvider, waitable } = resolveWaitableInput(h);
         const info = await svc.wait(dstProvider, waitable);
-        return svc.finalize(dstProvider, info);
+        return svc.finalize(dstProvider, info, opts);
       },
       {
         message: 'Failed to finalize/execute interop bundle on destination.',
         ctx: { where: 'interop.finalize' },
       },
     );
 
-  const tryFinalize = (h: InteropWaitable | InteropFinalizationInfo) =>
-    toResult<InteropFinalizationResult>(OP_INTEROP.tryFinalize, () => finalize(h));
+  const tryFinalize = (
+    h: InteropWaitable | InteropFinalizationInfo,
+    opts?: DestinationLogsQueryOptions,
+  ) => toResult<InteropFinalizationResult>(OP_INTEROP.tryFinalize, () => finalize(h, opts));
 
   return {
     quote,

src/adapters/ethers/resources/interop/services/erc20.ts

@@ -62,4 +62,3 @@ export async function resolveErc20AssetIds(
 
   return assetIds;
 }
-

src/adapters/ethers/resources/interop/services/finalization/bundle.ts

@@ -1,4 +1,9 @@
-import { Contract, type AbstractProvider, type TransactionResponse, type TransactionReceipt } from 'ethers';
+import {
+  Contract,
+  type AbstractProvider,
+  type TransactionResponse,
+  type TransactionReceipt,
+} from 'ethers';
 import type { Hex } from '../../../../../../core/types/primitives';
 import type { InteropFinalizationInfo } from '../../../../../../core/types/flows/interop';
 import type { EthersClient } from '../../../../client';
@@ -10,7 +15,7 @@ import IInteropHandlerAbi from '../../../../../../core/internal/abis/IInteropHan
 import { getTopics } from './topics';
 import type { InteropPhase } from '../../../../../../core/types/flows/interop';
 import type { InteropTopics } from '../../../../../../core/resources/interop/events';
-import { getDestinationLogs } from './data-fetchers';
+import { getDestinationLogs, type DestinationLogsQueryOptions } from './data-fetchers';
 
 const { wrap } = createErrorHandlers('interop');
 
@@ -19,13 +24,16 @@ export async function getBundleStatus(
   dstProvider: AbstractProvider,
   topics: InteropTopics,
   bundleHash: Hex,
+  opts?: DestinationLogsQueryOptions,
 ): Promise<{ phase: InteropPhase; dstExecTxHash?: Hex }> {
   const { interopHandler } = await client.ensureAddresses();
   // Single call: filter only by bundleHash (topic1), then classify via topic0 locally.
-  const bundleLogs = await getDestinationLogs(dstProvider, interopHandler, [
-    null,
-    bundleHash,
-  ]);
+  const bundleLogs = await getDestinationLogs(
+    dstProvider,
+    interopHandler,
+    [null, bundleHash],
+    opts,
+  );
 
   const findLastByTopic = (eventTopic: Hex) =>
     bundleLogs.findLast((log) => log.topics[0].toLowerCase() === eventTopic.toLowerCase());
@@ -53,11 +61,12 @@ export async function executeBundle(
   client: EthersClient,
   dstProvider: AbstractProvider,
   info: InteropFinalizationInfo,
+  opts?: DestinationLogsQueryOptions,
 ): Promise<{ hash: Hex; wait: () => Promise<TransactionReceipt> }> {
   const { topics } = getTopics();
   const { bundleHash, encodedData, proof } = info;
 
-  const dstStatus = await getBundleStatus(client, dstProvider, topics, bundleHash);
+  const dstStatus = await getBundleStatus(client, dstProvider, topics, bundleHash, opts);
 
   if (['EXECUTED', 'UNBUNDLED'].includes(dstStatus.phase)) {
     throw createError('STATE', {

src/adapters/ethers/resources/interop/services/finalization/data-fetchers.ts

@@ -8,8 +8,14 @@ import { InteropRootStorageABI } from '../../../../../../core/abi';
 import { L2_INTEROP_ROOT_STORAGE_ADDRESS } from '../../../../../../core/constants';
 
 const { wrap } = createErrorHandlers('interop');
-const DEFAULT_LOG_CHUNK_SIZE = 1_000;
+const DEFAULT_BLOCKS_RANGE_SIZE = 10_000;
 const DEFAULT_MAX_BLOCKS_BACK = 20_000;
+const SAFE_BLOCKS_RANGE_SIZE = 1_000;
+
+export interface DestinationLogsQueryOptions {
+  maxBlocksBack?: number;
+  logChunkSize?: number;
+}
 
 // Server returns an error if the there is a block range limit and the requested range exceeds it.
 // The error returned in such case is UNKNOWN_ERROR with a message containing "query exceeds max block range {limit}".
@@ -48,15 +54,19 @@ export async function getDestinationLogs(
   dstProvider: AbstractProvider,
   address: Address,
   topics: Array<Hex | null>,
+  opts?: DestinationLogsQueryOptions,
 ): Promise<Log[]> {
+  const maxBlocksBack = opts?.maxBlocksBack ?? DEFAULT_MAX_BLOCKS_BACK;
+  const initialChunkSize = opts?.logChunkSize ?? DEFAULT_BLOCKS_RANGE_SIZE;
+
   return await wrap(
     OP_INTEROP.svc.status.dstLogs,
     async () => {
       const currentBlock = await dstProvider.getBlockNumber();
-      const minBlock = Math.max(0, currentBlock - DEFAULT_MAX_BLOCKS_BACK);
+      const minBlock = Math.max(0, currentBlock - maxBlocksBack);
 
       let toBlock = currentBlock;
-      let chunkSize = DEFAULT_LOG_CHUNK_SIZE;
+      let chunkSize = initialChunkSize;
 
       while (toBlock >= minBlock) {
         const fromBlock = Math.max(minBlock, toBlock - chunkSize + 1);
@@ -84,16 +94,23 @@ export async function getDestinationLogs(
           const serverLimit = parseMaxBlockRangeLimit(error);
           // If we can't determine the server limit, rethrow the error.
           if (serverLimit == null) {
-            throw error;
+            // In case the error message cannot be parsed or a different error message format is returned by
+            // a provider, try once again with a small chunk size.
+            if (chunkSize > SAFE_BLOCKS_RANGE_SIZE) {
+              chunkSize = SAFE_BLOCKS_RANGE_SIZE;
+            } else {
+              throw error;
+            }
+          } else {
+            chunkSize = Math.min(chunkSize, serverLimit);
           }
-          chunkSize = serverLimit;
         }
       }
 
       return [];
     },
     {
-      ctx: { address },
+      ctx: { address, maxBlocksBack, logChunkSize: initialChunkSize },
       message: 'Failed to query destination bundle lifecycle logs.',
     },
   );

src/adapters/ethers/resources/interop/services/finalization/index.ts

@@ -9,9 +9,14 @@ import type { EthersClient } from '../../../../client';
 import { executeBundle } from './bundle';
 import { waitForFinalization } from './polling';
 import { getStatus } from './status';
+import type { DestinationLogsQueryOptions } from './data-fetchers';
 
 export interface InteropFinalizationServices {
-  status(dstProvider: AbstractProvider, input: InteropWaitable): Promise<InteropStatus>;
+  status(
+    dstProvider: AbstractProvider,
+    input: InteropWaitable,
+    opts?: DestinationLogsQueryOptions,
+  ): Promise<InteropStatus>;
   wait(
     dstProvider: AbstractProvider,
     input: InteropWaitable,
@@ -20,23 +25,24 @@ export interface InteropFinalizationServices {
   finalize(
     dstProvider: AbstractProvider,
     info: InteropFinalizationInfo,
+    opts?: DestinationLogsQueryOptions,
   ): Promise<InteropFinalizationResult>;
 }
 
 export function createInteropFinalizationServices(
   client: EthersClient,
 ): InteropFinalizationServices {
   return {
-    status(dstProvider, input) {
-      return getStatus(client, dstProvider, input);
+    status(dstProvider, input, opts) {
+      return getStatus(client, dstProvider, input, opts);
     },
 
     wait(dstProvider, input, opts) {
       return waitForFinalization(client, dstProvider, input, opts);
     },
 
-    async finalize(dstProvider, info) {
-      const execResult = await executeBundle(client, dstProvider, info);
+    async finalize(dstProvider, info, opts) {
+      const execResult = await executeBundle(client, dstProvider, info, opts);
       await execResult.wait();
 
       return {

src/adapters/ethers/resources/interop/services/finalization/status.ts

@@ -14,11 +14,13 @@ import { getTopics } from './topics';
 import { decodeInteropBundleSent } from './decoders';
 import { getSourceReceipt } from './data-fetchers';
 import { getBundleStatus } from './bundle';
+import type { DestinationLogsQueryOptions } from './data-fetchers';
 
 export async function getStatus(
   client: EthersClient,
   dstProvider: AbstractProvider,
   input: InteropWaitable,
+  opts?: DestinationLogsQueryOptions,
 ): Promise<InteropStatus> {
   const { topics, centerIface } = getTopics();
   const baseIds = resolveIdsFromWaitable(input);
@@ -51,12 +53,7 @@ export async function getStatus(
     };
   }
 
-  const dstInfo = await getBundleStatus(
-    client,
-    dstProvider,
-    topics,
-    enrichedIds.bundleHash,
-  );
+  const dstInfo = await getBundleStatus(client, dstProvider, topics, enrichedIds.bundleHash, opts);
 
   return {
     phase: dstInfo.phase,