fix(fast-inbox): guard between-buckets lower bound and bound timestamp fetch (A-1379)

Author: spalladino

yarn-project/archiver/src/store/message_store.test.ts

@@ -439,6 +439,8 @@ describe('MessageStore', () => {
       expect(await messageStore.getL1ToL2MessagesBetweenBuckets(3n, 3n)).toEqual([]);
       // Unknown upper bucket yields no messages.
       expect(await messageStore.getL1ToL2MessagesBetweenBuckets(0n, 9n)).toEqual([]);
+      // An unknown nonzero lower bucket is treated as unavailable, not as genesis.
+      expect(await messageStore.getL1ToL2MessagesBetweenBuckets(4n, 3n)).toEqual([]);
     });
 
     it('rewinds buckets when messages are removed', async () => {

yarn-project/archiver/src/store/message_store.ts

@@ -433,8 +433,17 @@ export class MessageStore {
     if (toBucket === undefined) {
       return [];
     }
-    const fromBucket = fromExclusive > 0n ? await this.getBucketSnapshotBySeq(fromExclusive) : undefined;
-    const startIndex = fromBucket ? fromBucket.lastMessageIndex + 1n : 0n;
+    // A nonzero lower bound must reference a synced bucket; otherwise the range is unavailable (rather than
+    // defaulting to genesis, which would silently over-return). Sequence 0 is the genesis base case: start from
+    // the beginning of the Inbox.
+    let startIndex = 0n;
+    if (fromExclusive > 0n) {
+      const fromBucket = await this.getBucketSnapshotBySeq(fromExclusive);
+      if (fromBucket === undefined) {
+        return [];
+      }
+      startIndex = fromBucket.lastMessageIndex + 1n;
+    }
     const endIndexExclusive = toBucket.lastMessageIndex + 1n;
 
     const leaves: Fr[] = [];

yarn-project/ethereum/src/contracts/inbox.ts

@@ -1,3 +1,4 @@
+import { asyncPool } from '@aztec/foundation/async-pool';
 import { maxBigint } from '@aztec/foundation/bigint';
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
@@ -108,16 +109,19 @@ export class InboxContract {
     return this.mapMessageSentLog(log, timestamp);
   }
 
-  /** Fetches the timestamp of each distinct L1 block number, so each MessageSent log can carry its bucket key. */
+  /**
+   * Fetches the timestamp of each distinct L1 block number, so each MessageSent log can carry its bucket key.
+   * Fetched with bounded concurrency to keep a large sync batch from fanning out unbounded RPC requests. Blocks
+   * are resolved by number rather than hash so a concurrent L1 reorg does not throw; a resulting cross-fork
+   * timestamp is transient and re-corrected by the archiver's rolling-hash reorg detection on the next sync.
+   */
   private async getBlockTimestamps(blockNumbers: bigint[]): Promise<Map<bigint, bigint>> {
     const uniqueBlockNumbers = [...new Set(blockNumbers)];
     const timestamps = new Map<bigint, bigint>();
-    await Promise.all(
-      uniqueBlockNumbers.map(async blockNumber => {
-        const block = await this.client.getBlock({ blockNumber, includeTransactions: false });
-        timestamps.set(blockNumber, block.timestamp);
-      }),
-    );
+    await asyncPool(10, uniqueBlockNumbers, async blockNumber => {
+      const block = await this.client.getBlock({ blockNumber, includeTransactions: false });
+      timestamps.set(blockNumber, block.timestamp);
+    });
     return timestamps;
   }