@aztec/archiver 0.0.1-commit.f650c0a5c → 0.0.1-commit.f7ea82942

package/src/modules/l1_synchronizer.ts

@@ -2,12 +2,13 @@ import type { BlobClientInterface } from '@aztec/blob-client/client';
 import { EpochCache } from '@aztec/epoch-cache';
 import { InboxContract, type InboxContractState, RollupContract } from '@aztec/ethereum/contracts';
 import type { L1BlockId } from '@aztec/ethereum/l1-types';
+import { getFinalizedL1Block } from '@aztec/ethereum/queries';
 import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { asyncPool } from '@aztec/foundation/async-pool';
 import { maxBigint } from '@aztec/foundation/bigint';
 import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import { pick } from '@aztec/foundation/collection';
+import { partition, pick } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { retryTimes } from '@aztec/foundation/retry';
@@ -15,14 +16,16 @@ import { count } from '@aztec/foundation/string';
 import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
 import { isDefined, isErrorClass } from '@aztec/foundation/types';
 import { type ArchiverEmitter, L2BlockSourceEvents, type ValidateCheckpointResult } from '@aztec/stdlib/block';
-import { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants, getEpochAtSlot, getSlotAtNextL1Block } from '@aztec/stdlib/epoch-helpers';
 import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { type Traceable, type Tracer, execInSpan, trackSpan } from '@aztec/telemetry-client';
 
 import { InitialCheckpointNumberNotSequentialError } from '../errors.js';
 import {
-  retrieveCheckpointsFromRollup,
+  type RetrievedCheckpointFromCalldata,
+  getCheckpointBlobDataFromBlobs,
+  retrieveCheckpointCalldataFromRollup,
   retrieveL1ToL2Message,
   retrieveL1ToL2Messages,
   retrievedToPublishedCheckpoint,
@@ -66,6 +69,7 @@ export class ArchiverL1Synchronizer implements Traceable {
     private config: {
       batchSize: number;
       skipValidateCheckpointAttestations?: boolean;
+      skipPromoteProposedCheckpointDuringL1Sync?: boolean;
       maxAllowedEthClientDriftSeconds: number;
     },
     private readonly blobClient: BlobClientInterface,
@@ -91,6 +95,7 @@ export class ArchiverL1Synchronizer implements Traceable {
   public setConfig(newConfig: {
     batchSize: number;
     skipValidateCheckpointAttestations?: boolean;
+    skipPromoteProposedCheckpointDuringL1Sync?: boolean;
     maxAllowedEthClientDriftSeconds: number;
   }) {
     this.config = newConfig;
@@ -215,7 +220,11 @@ export class ArchiverL1Synchronizer implements Traceable {
   /** Query L1 for its finalized block and update the finalized checkpoint accordingly. */
   private async updateFinalizedCheckpoint(): Promise<void> {
     try {
-      const finalizedL1Block = await this.publicClient.getBlock({ blockTag: 'finalized', includeTransactions: false });
+      const finalizedL1Block = await getFinalizedL1Block(this.publicClient);
+      if (!finalizedL1Block) {
+        this.log.trace(`Skipping finalized checkpoint update: L1 has no finalized block yet.`);
+        return;
+      }
       const finalizedL1BlockNumber = finalizedL1Block.number;
       const finalizedCheckpointNumber = await this.rollup.getProvenCheckpointNumber({
         blockNumber: finalizedL1BlockNumber,
@@ -405,7 +414,7 @@ export class ArchiverL1Synchronizer implements Traceable {
           `Failed to store L1 to L2 messages retrieved from L1: ${error.message}. Rolling back syncpoint to retry.`,
           { inboxMessage: error.inboxMessage },
         );
-        await this.rollbackL1ToL2Messages(remoteMessagesState.treeInProgress);
+        await this.rollbackL1ToL2Messages(remoteMessagesState);
         return false;
       }
       throw error;
@@ -420,7 +429,7 @@ export class ArchiverL1Synchronizer implements Traceable {
         `Local L1 to L2 messages state does not match remote after sync attempt. Rolling back syncpoint to retry.`,
         { localLastMessageAfterSync, remoteMessagesState },
       );
-      await this.rollbackL1ToL2Messages(remoteMessagesState.treeInProgress);
+      await this.rollbackL1ToL2Messages(remoteMessagesState);
       return false;
     }
 
@@ -475,18 +484,39 @@ export class ArchiverL1Synchronizer implements Traceable {
    * Rolls back local L1 to L2 messages to the last common message with L1, and updates the syncpoint to the L1 block of that message.
    * If no common message is found, rolls back all messages and sets the syncpoint to the start block.
    */
-  private async rollbackL1ToL2Messages(remoteTreeInProgress: bigint): Promise<L1BlockId> {
-    // Slowly go back through our messages until we find the last common message.
-    // We could query the logs in batch as an optimization, but the depth of the reorg should not be deep, and this
-    // is a very rare case, so it's fine to query one log at a time.
+  private async rollbackL1ToL2Messages(remoteMessagesState: InboxContractState): Promise<L1BlockId> {
+    const { treeInProgress: remoteTreeInProgress, messagesRollingHash: remoteRollingHash } = remoteMessagesState;
+
+    // Slowly go back through our messages until we find the last common message. We could query the logs in
+    // batch as an optimization, but the depth of the reorg should not be deep, and this is a very rare case,
+    // so it's fine to query one log at a time.
     let commonMsg: undefined | InboxMessage;
     let messagesToDelete = 0;
     this.log.verbose(`Searching most recent common L1 to L2 message`);
     for await (const localMsg of this.store.iterateL1ToL2Messages({ reverse: true })) {
+      const logCtx = { remoteMsg: undefined as InboxMessage | undefined, localMsg, remoteMessagesState };
+
+      // First check if the local message rolling hash matches the current rolling hash of the inbox contract,
+      // which means we just need to rollback some local messages and we should be back in sync. This means there
+      // was an L1 reorg that removed some of the messages we had, but no new messages were added compared.
+      if (localMsg.rollingHash.equals(remoteRollingHash)) {
+        this.log.info(
+          `Found common L1 to L2 message at index ${localMsg.index} on L1 block ${localMsg.l1BlockNumber} matching current remote state`,
+          logCtx,
+        );
+        commonMsg = localMsg;
+        break;
+      }
+
+      // If there's no match with the current remote state, check if the message exists on the inbox contract at all
+      // by looking at the inbox events. If the L1 reorg *added* new messages in addition to deleting existing ones,
+      // then the current remote state's rolling hash will not match anything we have locally, so we need to check existence
+      // of individual messages via logs. Note we use logs and not historical queries so we don't have to depend on
+      // an archival rpc node, since the message could be from a long time ago if we're catching up with syncing.
       const remoteMsg = await retrieveL1ToL2Message(this.inbox, localMsg);
-      const logCtx = { remoteMsg, localMsg: localMsg };
+      logCtx.remoteMsg = remoteMsg;
       if (remoteMsg && remoteMsg.rollingHash.equals(localMsg.rollingHash)) {
-        this.log.verbose(
+        this.log.info(
           `Found most recent common L1 to L2 message at index ${localMsg.index} on L1 block ${localMsg.l1BlockNumber}`,
           logCtx,
         );
@@ -718,22 +748,20 @@ export class ArchiverL1Synchronizer implements Traceable {
 
       this.log.trace(`Retrieving checkpoints from L1 block ${searchStartBlock} to ${searchEndBlock}`);
 
-      // TODO(md): Retrieve from blob client then from consensus client, then from peers
-      const retrievedCheckpoints = await execInSpan(this.tracer, 'Archiver.retrieveCheckpointsFromRollup', () =>
-        retrieveCheckpointsFromRollup(
+      // First fetch calldata only, no blobs yet, since we may be able to just get that data out of the proposed chain
+      const calldataCheckpoints = await execInSpan(this.tracer, 'Archiver.retrieveCheckpointCalldataFromRollup', () =>
+        retrieveCheckpointCalldataFromRollup(
           this.rollup,
           this.publicClient,
           this.debugClient,
-          this.blobClient,
           searchStartBlock, // TODO(palla/reorg): If the L2 reorg was due to an L1 reorg, we need to start search earlier
           searchEndBlock,
           this.instrumentation,
           this.log,
-          !initialSyncComplete, // isHistoricalSync
         ),
       );
 
-      if (retrievedCheckpoints.length === 0) {
+      if (calldataCheckpoints.length === 0) {
         // We are not calling `setBlockSynchedL1BlockNumber` because it may cause sync issues if based off infura.
         // See further details in earlier comments.
         this.log.trace(`Retrieved no new checkpoints from L1 block ${searchStartBlock} to ${searchEndBlock}`);
@@ -741,17 +769,43 @@ export class ArchiverL1Synchronizer implements Traceable {
       }
 
       this.log.debug(
-        `Retrieved ${retrievedCheckpoints.length} new checkpoints between L1 blocks ${searchStartBlock} and ${searchEndBlock}`,
+        `Retrieved ${calldataCheckpoints.length} new checkpoint calldata between L1 blocks ${searchStartBlock} and ${searchEndBlock}`,
         {
-          lastProcessedCheckpoint: retrievedCheckpoints[retrievedCheckpoints.length - 1].l1,
+          lastProcessedCheckpoint: calldataCheckpoints[calldataCheckpoints.length - 1].l1,
           searchStartBlock,
           searchEndBlock,
         },
       );
 
-      const publishedCheckpoints = await Promise.all(retrievedCheckpoints.map(b => retrievedToPublishedCheckpoint(b)));
+      // Check if the last checkpoint matches the proposed one (so we can skip blob fetch).
+      // We only check the last one because the proposed checkpoint is always the most recent one,
+      // and if it's in a multi-checkpoint batch it will always be last (sorted by L1 block number).
+      const lastCalldataCheckpoint = calldataCheckpoints[calldataCheckpoints.length - 1];
+      const checkpointToPromote = await this.tryBuildPublishedCheckpointFromProposed(lastCalldataCheckpoint);
+
+      // Then fetch blobs in parallel and build the full published checkpoints
+      const toFetchBlobs = checkpointToPromote ? calldataCheckpoints.slice(0, -1) : calldataCheckpoints;
+      const blobFetched = await asyncPool(10, toFetchBlobs, async checkpoint =>
+        retrievedToPublishedCheckpoint({
+          ...checkpoint,
+          checkpointBlobData: await getCheckpointBlobDataFromBlobs(
+            this.blobClient,
+            checkpoint.l1.blockHash,
+            checkpoint.blobHashes,
+            checkpoint.checkpointNumber,
+            this.log,
+            !initialSyncComplete,
+            checkpoint.parentBeaconBlockRoot,
+            checkpoint.l1.timestamp,
+          ),
+        }),
+      );
+
+      // And add the promoted checkpoint to the list of all checkpoints
+      const publishedCheckpoints = checkpointToPromote ? [...blobFetched, checkpointToPromote] : blobFetched;
       const validCheckpoints: PublishedCheckpoint[] = [];
 
+      // Now loop through all checkpoints and validate their attestations
       for (const published of publishedCheckpoints) {
         const validationResult = this.config.skipValidateCheckpointAttestations
           ? { valid: true as const }
@@ -832,15 +886,34 @@ export class ArchiverL1Synchronizer implements Traceable {
       try {
         const updatedValidationResult =
           rollupStatus.validationResult === initialValidationResult ? undefined : rollupStatus.validationResult;
+
+        // Split valid checkpoints: the promoted one (if any) is persisted via the proposed-promotion path,
+        // the rest via addCheckpoints. Both paths run within the same store transaction for atomicity.
+        const [[maybeValidCheckpointToPromote], checkpointsToAdd] = partition(
+          validCheckpoints,
+          c => c.checkpoint.number === checkpointToPromote?.checkpoint.number,
+        );
+
         const [processDuration, result] = await elapsed(() =>
           execInSpan(this.tracer, 'Archiver.addCheckpoints', () =>
-            this.updater.addCheckpoints(validCheckpoints, updatedValidationResult),
+            this.updater.addCheckpoints(
+              checkpointsToAdd,
+              updatedValidationResult,
+              maybeValidCheckpointToPromote && {
+                l1: lastCalldataCheckpoint.l1,
+                attestations: lastCalldataCheckpoint.attestations,
+                checkpoint: maybeValidCheckpointToPromote,
+              },
+            ),
           ),
         );
-        this.instrumentation.processNewBlocks(
-          processDuration / validCheckpoints.length,
-          validCheckpoints.flatMap(c => c.checkpoint.blocks),
-        );
+
+        if (checkpointsToAdd.length > 0) {
+          this.instrumentation.processNewCheckpointedBlocks(
+            processDuration / checkpointsToAdd.length,
+            checkpointsToAdd.flatMap(c => c.checkpoint.blocks),
+          );
+        }
 
         // If blocks were pruned due to conflict with L1 checkpoints, emit event
         if (result.prunedBlocks && result.prunedBlocks.length > 0) {
@@ -893,7 +966,7 @@ export class ArchiverL1Synchronizer implements Traceable {
         });
       }
       lastRetrievedCheckpoint = validCheckpoints.at(-1) ?? lastRetrievedCheckpoint;
-      lastL1BlockWithCheckpoint = retrievedCheckpoints.at(-1)?.l1.blockNumber ?? lastL1BlockWithCheckpoint;
+      lastL1BlockWithCheckpoint = calldataCheckpoints.at(-1)?.l1.blockNumber ?? lastL1BlockWithCheckpoint;
     } while (searchEndBlock < currentL1BlockNumber);
 
     // Important that we update AFTER inserting the blocks.
@@ -902,6 +975,74 @@ export class ArchiverL1Synchronizer implements Traceable {
     return { ...rollupStatus, lastRetrievedCheckpoint, lastL1BlockWithCheckpoint };
   }
 
+  /** Checks if this checkpoint matches the local proposed one, and if so, loads local data to build a synthetic published checkpoint. */
+  private async tryBuildPublishedCheckpointFromProposed(
+    calldataCheckpoint: RetrievedCheckpointFromCalldata | undefined,
+  ): Promise<PublishedCheckpoint | undefined> {
+    const proposed = await this.store.getProposedCheckpointOnly();
+    if (
+      this.config.skipPromoteProposedCheckpointDuringL1Sync ||
+      !proposed ||
+      !calldataCheckpoint ||
+      proposed.checkpointNumber !== calldataCheckpoint.checkpointNumber
+    ) {
+      return undefined;
+    }
+
+    if (
+      !proposed.header.equals(calldataCheckpoint.header) ||
+      !proposed.archive.root.equals(calldataCheckpoint.archiveRoot)
+    ) {
+      this.log.warn(
+        `Local proposed checkpoint ${proposed.checkpointNumber} does not match checkpoint retrieved from L1, overriding with L1 data`,
+        {
+          proposedCheckpointNumber: proposed.checkpointNumber,
+          proposedHeader: proposed.header.toInspect(),
+          proposedArchiveRoot: proposed.archive.root.toString(),
+          calldataCheckpointNumber: calldataCheckpoint.checkpointNumber,
+          calldataHeader: calldataCheckpoint.header.toInspect(),
+          calldataArchiveRoot: calldataCheckpoint.archiveRoot.toString(),
+        },
+      );
+      return undefined;
+    }
+
+    this.log.debug(
+      `Building published checkpoint from proposed ${calldataCheckpoint.checkpointNumber} (skipping blob fetch)`,
+      { proposedHeader: proposed.header.toInspect(), proposedArchiveRoot: proposed.archive.root.toString() },
+    );
+
+    const blocks = await this.store.getBlocks(BlockNumber(proposed.startBlock), proposed.blockCount);
+    if (blocks.length !== proposed.blockCount) {
+      this.log.warn(
+        `Local proposed checkpoint ${proposed.checkpointNumber} has wrong block count (expected ${proposed.blockCount} blocks starting at ${proposed.startBlock} but got ${blocks.length})`,
+        {
+          proposedCheckpointNumber: proposed.checkpointNumber,
+          proposedStartBlock: proposed.startBlock,
+          proposedBlockCount: proposed.blockCount,
+          retrievedBlocks: blocks.map(b => b.number),
+        },
+      );
+      return undefined;
+    }
+
+    const checkpoint = Checkpoint.from({
+      archive: proposed.archive,
+      header: proposed.header,
+      blocks,
+      number: proposed.checkpointNumber,
+      feeAssetPriceModifier: proposed.feeAssetPriceModifier,
+    });
+    const promotedCheckpoint = PublishedCheckpoint.from({
+      checkpoint,
+      l1: calldataCheckpoint.l1,
+      attestations: calldataCheckpoint.attestations,
+    });
+    this.instrumentation.processCheckpointPromoted();
+
+    return promotedCheckpoint;
+  }
+
   private async checkForNewCheckpointsBeforeL1SyncPoint(
     status: RollupStatus,
     blocksSynchedTo: bigint,

package/src/store/block_store.ts

@@ -52,7 +52,10 @@ import {
   CheckpointNotFoundError,
   CheckpointNumberNotSequentialError,
   InitialCheckpointNumberNotSequentialError,
+  NoProposedCheckpointToPromoteError,
+  ProposedCheckpointArchiveRootMismatchError,
   ProposedCheckpointNotSequentialError,
+  ProposedCheckpointPromotionNotSequentialError,
   ProposedCheckpointStaleError,
 } from '../errors.js';
 
@@ -694,6 +697,55 @@ export class BlockStore {
     await this.#proposedCheckpoint.delete();
   }
 
+  /**
+   * Promotes the proposed checkpoint singleton to a confirmed checkpoint entry.
+   * This persists the checkpoint to the store, clears the proposed singleton, and updates the L1 sync point.
+   * Should only be called after the checkpoint has been validated.
+   * @param expectedArchiveRoot - The archive root to match against the proposed checkpoint, to guard against races.
+   */
+  async promoteProposedToCheckpointed(
+    l1: L1PublishedData,
+    attestations: CommitteeAttestation[],
+    expectedArchiveRoot: Fr,
+  ): Promise<void> {
+    return await this.db.transactionAsync(async () => {
+      const proposed = await this.getProposedCheckpointOnly();
+      if (!proposed) {
+        throw new NoProposedCheckpointToPromoteError();
+      }
+      if (!proposed.archive.root.equals(expectedArchiveRoot)) {
+        throw new ProposedCheckpointArchiveRootMismatchError(expectedArchiveRoot, proposed.archive.root);
+      }
+
+      // Verify sequentiality: promoted checkpoint must follow the latest confirmed one
+      const latestCheckpointNumber = await this.getLatestCheckpointNumber();
+      if (latestCheckpointNumber !== proposed.checkpointNumber - 1) {
+        throw new ProposedCheckpointPromotionNotSequentialError(proposed.checkpointNumber, latestCheckpointNumber);
+      }
+
+      // Write the checkpoint entry
+      await this.#checkpoints.set(proposed.checkpointNumber, {
+        header: proposed.header.toBuffer(),
+        archive: proposed.archive.toBuffer(),
+        checkpointOutHash: proposed.checkpointOutHash.toBuffer(),
+        l1: l1.toBuffer(),
+        attestations: attestations.map(attestation => attestation.toBuffer()),
+        checkpointNumber: proposed.checkpointNumber,
+        startBlock: proposed.startBlock,
+        blockCount: proposed.blockCount,
+      });
+
+      // Update the slot-to-checkpoint index
+      await this.#slotToCheckpoint.set(proposed.header.slotNumber, proposed.checkpointNumber);
+
+      // Clear the proposed checkpoint singleton
+      await this.#proposedCheckpoint.delete();
+
+      // Update the last synced L1 block
+      await this.#lastSynchedL1Block.set(l1.blockNumber);
+    });
+  }
+
   /** Clears the proposed checkpoint if the given confirmed checkpoint number supersedes it. */
   async clearProposedCheckpointIfSuperseded(confirmedCheckpointNumber: CheckpointNumber): Promise<void> {
     const proposedCheckpointNumber = await this.getProposedCheckpointNumber();
@@ -976,7 +1028,7 @@ export class BlockStore {
     return {
       header: BlockHeader.fromBuffer(blockStorage.header),
       archive: AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive),
-      blockHash: Fr.fromBuffer(blockStorage.blockHash),
+      blockHash: BlockHash.fromBuffer(blockStorage.blockHash),
       checkpointNumber: CheckpointNumber(blockStorage.checkpointNumber),
       indexWithinCheckpoint: IndexWithinCheckpoint(blockStorage.indexWithinCheckpoint),
     };

package/src/store/kv_archiver_store.ts

@@ -10,12 +10,14 @@ import {
   type BlockData,
   BlockHash,
   CheckpointedL2Block,
+  type CommitteeAttestation,
   L2Block,
   type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
 import type {
   CheckpointData,
   CommonCheckpointData,
+  L1PublishedData,
   ProposedCheckpointData,
   ProposedCheckpointInput,
   PublishedCheckpoint,
@@ -647,6 +649,19 @@ export class KVArchiverDataStore implements ContractDataSource {
     return this.#blockStore.deleteProposedCheckpoint();
   }
 
+  /**
+   * Promotes the proposed checkpoint to a confirmed checkpoint entry.
+   * Should only be called after the checkpoint has been validated.
+   * @param expectedArchiveRoot - The archive root to match against the proposed checkpoint, to guard against races.
+   */
+  public promoteProposedToCheckpointed(
+    l1: L1PublishedData,
+    attestations: CommitteeAttestation[],
+    expectedArchiveRoot: Fr,
+  ): Promise<void> {
+    return this.#blockStore.promoteProposedToCheckpointed(l1, attestations, expectedArchiveRoot);
+  }
+
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.

package/src/store/l2_tips_cache.ts

@@ -1,6 +1,12 @@
-import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
-import { type BlockData, type CheckpointId, GENESIS_CHECKPOINT_HEADER_HASH, type L2Tips } from '@aztec/stdlib/block';
+import {
+  type BlockData,
+  type CheckpointId,
+  GENESIS_BLOCK_HEADER_HASH,
+  GENESIS_CHECKPOINT_HEADER_HASH,
+  type L2Tips,
+} from '@aztec/stdlib/block';
 
 import type { BlockStore } from './block_store.js';
 

package/src/store/log_store.ts

@@ -1,7 +1,6 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { compactArray, filterAsync } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
@@ -302,13 +301,11 @@ export class LogStore {
   }
 
   #unpackBlockHash(reader: BufferReader): BlockHash {
-    const blockHash = reader.remainingBytes() > 0 ? reader.readObject(Fr) : undefined;
-
-    if (!blockHash) {
+    if (reader.remainingBytes() === 0) {
       throw new Error('Failed to read block hash from log entry buffer');
     }
 
-    return new BlockHash(blockHash);
+    return BlockHash.fromBuffer(reader);
   }
 
   deleteLogs(blocks: L2Block[]): Promise<boolean> {

package/src/test/fake_l1_state.ts

@@ -151,8 +151,10 @@ export class FakeL1State {
   // Computed from checkpoints based on L1 block visibility
   private pendingCheckpointNumber: CheckpointNumber = CheckpointNumber(0);
 
-  // The L1 block number reported as "finalized" (defaults to the start block)
-  private finalizedL1BlockNumber: bigint;
+  // The L1 block number reported as "finalized" (defaults to the start block).
+  // `undefined` simulates the startup window on a fresh devnet where
+  // `getBlock({ blockTag: 'finalized' })` fails with "finalized block not found".
+  private finalizedL1BlockNumber: bigint | undefined;
 
   constructor(private readonly config: FakeL1StateConfig) {
     this.l1BlockNumber = config.l1StartBlock;
@@ -288,8 +290,11 @@ export class FakeL1State {
     this.updatePendingCheckpointNumber();
   }
 
-  /** Sets the L1 block number that will be reported as "finalized". */
-  setFinalizedL1BlockNumber(blockNumber: bigint): void {
+  /**
+   * Sets the L1 block number that will be reported as "finalized". Pass `undefined` to
+   * simulate a chain that does not yet have a finalized block (devnet startup).
+   */
+  setFinalizedL1BlockNumber(blockNumber: bigint | undefined): void {
     this.finalizedL1BlockNumber = blockNumber;
   }
 
@@ -502,8 +507,8 @@ export class FakeL1State {
       Promise.resolve(this.getMessageSentLogs(fromBlock, toBlock)),
     );
 
-    mockInbox.getMessageSentEventByHash.mockImplementation((msgHash: string, l1BlockHash: string) =>
-      Promise.resolve(this.getMessageSentLogByHash(msgHash, l1BlockHash) as MessageSentLog),
+    mockInbox.getMessageSentEventByHash.mockImplementation((msgHash: string, aroundL1BlockNumber: bigint) =>
+      Promise.resolve(this.getMessageSentLogByHash(msgHash, aroundL1BlockNumber) as MessageSentLog),
     );
 
     return mockInbox;
@@ -519,6 +524,11 @@ export class FakeL1State {
     publicClient.getBlock.mockImplementation((async (args: { blockNumber?: bigint; blockTag?: string } = {}) => {
       let blockNum: bigint;
       if (args.blockTag === 'finalized') {
+        if (this.finalizedL1BlockNumber === undefined) {
+          throw Object.assign(new Error('finalized block not found'), {
+            details: 'finalized block not found',
+          });
+        }
         blockNum = this.finalizedL1BlockNumber;
       } else {
         blockNum = args.blockNumber ?? (await publicClient.getBlockNumber());
@@ -544,10 +554,10 @@ export class FakeL1State {
   createMockBlobClient(): MockProxy<BlobClientInterface> {
     const blobClient = mock<BlobClientInterface>();
 
-    // The blockId is the transaction's blockHash, which we set to the checkpoint's archive root
+    // The blockId is the L1 block hash, which we derive from the L1 block number
     blobClient.getBlobSidecar.mockImplementation((blockId: `0x${string}`) =>
       Promise.resolve(
-        this.checkpoints.find(cpData => cpData.checkpoint.archive.root.toString() === blockId)?.blobs ?? [],
+        this.checkpoints.find(cpData => Buffer32.fromBigInt(cpData.l1BlockNumber).toString() === blockId)?.blobs ?? [],
       ),
     );
 
@@ -623,9 +633,12 @@ export class FakeL1State {
       }));
   }
 
-  private getMessageSentLogByHash(msgHash: string, l1BlockHash: string): MessageSentLog | undefined {
+  private getMessageSentLogByHash(msgHash: string, aroundL1BlockNumber: bigint): MessageSentLog | undefined {
     const msg = this.messages.find(
-      msg => msg.leaf.toString() === msgHash && Buffer32.fromBigInt(msg.l1BlockNumber).toString() === l1BlockHash,
+      msg =>
+        msg.leaf.toString() === msgHash &&
+        msg.l1BlockNumber >= aroundL1BlockNumber - 5n &&
+        msg.l1BlockNumber <= aroundL1BlockNumber + 5n,
     );
     if (!msg) {
       return undefined;

package/src/test/noop_l1_archiver.ts

@@ -70,7 +70,9 @@ export class NoopL1Archiver extends Archiver {
       debugClient,
       rollup,
       {
+        rollupAddress: EthAddress.ZERO,
         registryAddress: EthAddress.ZERO,
+        inboxAddress: EthAddress.ZERO,
         governanceProposerAddress: EthAddress.ZERO,
         slashingProposerAddress: EthAddress.ZERO,
       },
@@ -81,6 +83,7 @@ export class NoopL1Archiver extends Archiver {
         skipValidateCheckpointAttestations: true,
         maxAllowedEthClientDriftSeconds: 300,
         ethereumAllowNoDebugHosts: true, // Skip trace validation
+        skipHistoricalLogsCheck: true, // Skip historical logs validation
       },
       blobClient,
       instrumentation,