@aztec/archiver 0.0.1-commit.6c91f13 → 0.0.1-commit.96bb3f7

package/src/archiver/archiver.ts

@@ -1,5 +1,5 @@
 import type { BlobClientInterface } from '@aztec/blob-client/client';
-import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { EpochCache } from '@aztec/epoch-cache';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { BlockTagTooOldError, InboxContract, RollupContract } from '@aztec/ethereum/contracts';
@@ -33,8 +33,10 @@ import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
   type ArchiverEmitter,
+  type CheckpointId,
   CheckpointedL2Block,
   CommitteeAttestation,
+  GENESIS_CHECKPOINT_HEADER_HASH,
   L2Block,
   L2BlockNew,
   type L2BlockSink,
@@ -81,6 +83,7 @@ import {
   type TelemetryClient,
   type Traceable,
   type Tracer,
+  execInSpan,
   getTelemetryClient,
   trackSpan,
 } from '@aztec/telemetry-client';
@@ -102,7 +105,7 @@ import {
 } from './l1/data_retrieval.js';
 import { validateAndLogTraceAvailability } from './l1/validate_trace.js';
 import type { InboxMessage } from './structs/inbox_message.js';
-import { type ValidateBlockResult, validateCheckpointAttestations } from './validation.js';
+import { type ValidateCheckpointResult, validateCheckpointAttestations } from './validation.js';
 
 /**
  * Helper interface to combine all sources this archiver implementation provides.
@@ -127,7 +130,7 @@ function mapArchiverConfig(config: Partial<ArchiverConfig>) {
   return {
     pollingIntervalMs: config.archiverPollingIntervalMS,
     batchSize: config.archiverBatchSize,
-    skipValidateBlockAttestations: config.skipValidateBlockAttestations,
+    skipValidateCheckpointAttestations: config.skipValidateCheckpointAttestations,
     maxAllowedEthClientDriftSeconds: config.maxAllowedEthClientDriftSeconds,
     ethereumAllowNoDebugHosts: config.ethereumAllowNoDebugHosts,
   };
@@ -138,7 +141,7 @@ type RollupStatus = {
   provenArchive: Hex;
   pendingCheckpointNumber: CheckpointNumber;
   pendingArchive: Hex;
-  validationResult: ValidateBlockResult | undefined;
+  validationResult: ValidateCheckpointResult | undefined;
   lastRetrievedCheckpoint?: PublishedCheckpoint;
   lastL1BlockWithCheckpoint?: bigint;
 };
@@ -192,7 +195,7 @@ export class Archiver
     private config: {
       pollingIntervalMs: number;
       batchSize: number;
-      skipValidateBlockAttestations?: boolean;
+      skipValidateCheckpointAttestations?: boolean;
       maxAllowedEthClientDriftSeconds: number;
       ethereumAllowNoDebugHosts?: boolean;
     },
@@ -275,7 +278,7 @@ export class Archiver
       slotDuration,
       ethereumSlotDuration,
       proofSubmissionEpochs: Number(proofSubmissionEpochs),
-      genesisArchiveRoot: Fr.fromHexString(genesisArchiveRoot),
+      genesisArchiveRoot: Fr.fromString(genesisArchiveRoot.toString()),
     };
 
     const opts = merge(
@@ -409,6 +412,7 @@ export class Archiver
     }
   }
 
+  @trackSpan('Archiver.syncFromL1')
   private async syncFromL1() {
     /**
      * We keep track of three "pointers" to L1 blocks:
@@ -555,6 +559,7 @@ export class Archiver
   }
 
   /** Checks if there'd be a reorg for the next checkpoint submission and start pruning now. */
+  @trackSpan('Archiver.handleEpochPrune')
   private async handleEpochPrune(
     provenCheckpointNumber: CheckpointNumber,
     currentL1BlockNumber: bigint,
@@ -590,14 +595,11 @@ export class Archiver
       );
       const newBlocks = blockPromises.filter(isDefined).flat();
 
-      // TODO(pw/mbps): Don't convert to legacy blocks here
-      const blocks: L2Block[] = (await Promise.all(newBlocks.map(x => this.getBlock(x.number)))).filter(isDefined);
-
       // Emit an event for listening services to react to the chain prune
       this.emit(L2BlockSourceEvents.L2PruneDetected, {
         type: L2BlockSourceEvents.L2PruneDetected,
         epochNumber: pruneFromEpochNumber,
-        blocks,
+        blocks: newBlocks,
       });
 
       this.log.debug(
@@ -628,6 +630,7 @@ export class Archiver
     return [nextStart, nextEnd];
   }
 
+  @trackSpan('Archiver.handleL1ToL2Messages')
   private async handleL1ToL2Messages(
     messagesSyncPoint: L1BlockId,
     currentL1BlockNumber: bigint,
@@ -786,23 +789,25 @@ export class Archiver
     return Buffer32.fromString(block.hash);
   }
 
+  @trackSpan('Archiver.handleCheckpoints')
   private async handleCheckpoints(blocksSynchedTo: bigint, currentL1BlockNumber: bigint): Promise<RollupStatus> {
     const localPendingCheckpointNumber = await this.getSynchedCheckpointNumber();
-    const initialValidationResult: ValidateBlockResult | undefined = await this.store.getPendingChainValidationStatus();
-    const [
-      rollupProvenCheckpointNumber,
-      provenArchive,
-      rollupPendingCheckpointNumber,
-      pendingArchive,
-      archiveForLocalPendingCheckpointNumber,
-    ] = await this.rollup.status(localPendingCheckpointNumber, { blockNumber: currentL1BlockNumber });
-    const provenCheckpointNumber = CheckpointNumber.fromBigInt(rollupProvenCheckpointNumber);
-    const pendingCheckpointNumber = CheckpointNumber.fromBigInt(rollupPendingCheckpointNumber);
-    const rollupStatus = {
+    const initialValidationResult: ValidateCheckpointResult | undefined =
+      await this.store.getPendingChainValidationStatus();
+    const {
       provenCheckpointNumber,
       provenArchive,
       pendingCheckpointNumber,
       pendingArchive,
+      archiveOfMyCheckpoint: archiveForLocalPendingCheckpointNumber,
+    } = await execInSpan(this.tracer, 'Archiver.getRollupStatus', () =>
+      this.rollup.status(localPendingCheckpointNumber, { blockNumber: currentL1BlockNumber }),
+    );
+    const rollupStatus: RollupStatus = {
+      provenCheckpointNumber,
+      provenArchive: provenArchive.toString(),
+      pendingCheckpointNumber,
+      pendingArchive: pendingArchive.toString(),
       validationResult: initialValidationResult,
     };
     this.log.trace(`Retrieved rollup status at current L1 block ${currentL1BlockNumber}.`, {
@@ -848,14 +853,12 @@ export class Archiver
 
       if (
         localCheckpointForDestinationProvenCheckpointNumber &&
-        provenArchive === localCheckpointForDestinationProvenCheckpointNumber.archive.root.toString()
+        provenArchive.equals(localCheckpointForDestinationProvenCheckpointNumber.archive.root)
       ) {
         const localProvenCheckpointNumber = await this.getProvenCheckpointNumber();
         if (localProvenCheckpointNumber !== provenCheckpointNumber) {
           await this.setProvenCheckpointNumber(provenCheckpointNumber);
-          this.log.info(`Updated proven chain to checkpoint ${provenCheckpointNumber}`, {
-            provenCheckpointNumber,
-          });
+          this.log.info(`Updated proven chain to checkpoint ${provenCheckpointNumber}`, { provenCheckpointNumber });
           const provenSlotNumber = localCheckpointForDestinationProvenCheckpointNumber.header.slotNumber;
           const provenEpochNumber: EpochNumber = getEpochAtSlot(provenSlotNumber, this.l1constants);
           const lastBlockNumberInCheckpoint =
@@ -898,7 +901,7 @@ export class Archiver
       }
 
       const localPendingArchiveRoot = localPendingCheckpoint.archive.root.toString();
-      const noCheckpointSinceLast = localPendingCheckpoint && pendingArchive === localPendingArchiveRoot;
+      const noCheckpointSinceLast = localPendingCheckpoint && pendingArchive.toString() === localPendingArchiveRoot;
       if (noCheckpointSinceLast) {
         // We believe the following line causes a problem when we encounter L1 re-orgs.
         // Basically, by setting the synched L1 block number here, we are saying that we have
@@ -912,7 +915,9 @@ export class Archiver
         return rollupStatus;
       }
 
-      const localPendingCheckpointInChain = archiveForLocalPendingCheckpointNumber === localPendingArchiveRoot;
+      const localPendingCheckpointInChain = archiveForLocalPendingCheckpointNumber.equals(
+        localPendingCheckpoint.archive.root,
+      );
       if (!localPendingCheckpointInChain) {
         // If our local pending checkpoint tip is not in the chain on L1 a "prune" must have happened
         // or the L1 have reorged.
@@ -938,7 +943,7 @@ export class Archiver
               archiveLocal: candidateCheckpoint.archive.root.toString(),
             },
           );
-          if (archiveAtContract === candidateCheckpoint.archive.root.toString()) {
+          if (archiveAtContract.equals(candidateCheckpoint.archive.root)) {
             break;
           }
           tipAfterUnwind--;
@@ -968,17 +973,19 @@ export class Archiver
       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 retrieveCheckpointsFromRollup(
-        this.rollup.getContract() as GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
-        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.l1Addresses,
-        this.instrumentation,
-        this.log,
-        !this.initialSyncComplete, // isHistoricalSync
+      const retrievedCheckpoints = await execInSpan(this.tracer, 'Archiver.retrieveCheckpointsFromRollup', () =>
+        retrieveCheckpointsFromRollup(
+          this.rollup.getContract() as GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
+          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.l1Addresses,
+          this.instrumentation,
+          this.log,
+          !this.initialSyncComplete, // isHistoricalSync
+        ),
       );
 
       if (retrievedCheckpoints.length === 0) {
@@ -1001,7 +1008,7 @@ export class Archiver
       const validCheckpoints: PublishedCheckpoint[] = [];
 
       for (const published of publishedCheckpoints) {
-        const validationResult = this.config.skipValidateBlockAttestations
+        const validationResult = this.config.skipValidateCheckpointAttestations
           ? { valid: true as const }
           : await validateCheckpointAttestations(published, this.epochCache, this.l1constants, this.log);
 
@@ -1014,7 +1021,7 @@ export class Archiver
           rollupStatus.validationResult?.valid !== validationResult.valid ||
           (!rollupStatus.validationResult.valid &&
             !validationResult.valid &&
-            rollupStatus.validationResult.block.blockNumber === validationResult.block.blockNumber)
+            rollupStatus.validationResult.checkpoint.checkpointNumber === validationResult.checkpoint.checkpointNumber)
         ) {
           rollupStatus.validationResult = validationResult;
         }
@@ -1026,9 +1033,9 @@ export class Archiver
             ...pick(validationResult, 'reason'),
           });
 
-          // Emit event for invalid block detection
-          this.emit(L2BlockSourceEvents.InvalidAttestationsBlockDetected, {
-            type: L2BlockSourceEvents.InvalidAttestationsBlockDetected,
+          // Emit event for invalid checkpoint detection
+          this.emit(L2BlockSourceEvents.InvalidAttestationsCheckpointDetected, {
+            type: L2BlockSourceEvents.InvalidAttestationsCheckpointDetected,
             validationResult,
           });
 
@@ -1043,7 +1050,7 @@ export class Archiver
         // checkpoints we just retrieved.
         const l1ToL2Messages = await this.getL1ToL2Messages(published.checkpoint.number);
         const computedInHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
-        const publishedInHash = published.checkpoint.header.contentCommitment.inHash;
+        const publishedInHash = published.checkpoint.header.inHash;
         if (!computedInHash.equals(publishedInHash)) {
           this.log.fatal(`Mismatch inHash for checkpoint ${published.checkpoint.number}`, {
             checkpointHash: published.checkpoint.hash(),
@@ -1072,7 +1079,11 @@ export class Archiver
       try {
         const updatedValidationResult =
           rollupStatus.validationResult === initialValidationResult ? undefined : rollupStatus.validationResult;
-        const [processDuration] = await elapsed(() => this.addCheckpoints(validCheckpoints, updatedValidationResult));
+        const [processDuration] = await elapsed(() =>
+          execInSpan(this.tracer, 'Archiver.addCheckpoints', () =>
+            this.addCheckpoints(validCheckpoints, updatedValidationResult),
+          ),
+        );
         this.instrumentation.processNewBlocks(
           processDuration / validCheckpoints.length,
           validCheckpoints.flatMap(c => c.checkpoint.blocks),
@@ -1351,7 +1362,7 @@ export class Archiver
 
   public addCheckpoints(
     checkpoints: PublishedCheckpoint[],
-    pendingChainValidationStatus?: ValidateBlockResult,
+    pendingChainValidationStatus?: ValidateCheckpointResult,
   ): Promise<boolean> {
     return this.store.addCheckpoints(checkpoints, pendingChainValidationStatus);
   }
@@ -1381,6 +1392,16 @@ export class Archiver
     return publishedBlock;
   }
 
+  public async getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
+    const blocks = await this.store.store.getBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.number <= provenBlockNumber);
+    }
+    return blocks;
+  }
+
   public async getBlockHeader(number: BlockNumber | 'latest'): Promise<BlockHeader | undefined> {
     if (number === 'latest') {
       number = await this.store.getSynchedL2BlockNumber();
@@ -1396,6 +1417,20 @@ export class Archiver
     return this.store.getCheckpointedBlock(number);
   }
 
+  public async getCheckpointedBlocks(
+    from: BlockNumber,
+    limit: number,
+    proven?: boolean,
+  ): Promise<CheckpointedL2Block[]> {
+    const blocks = await this.store.store.getCheckpointedBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.block.number <= provenBlockNumber);
+    }
+    return blocks;
+  }
+
   getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.store.getCheckpointedBlockByHash(blockHash);
   }
@@ -1403,6 +1438,9 @@ export class Archiver
   getProvenBlockNumber(): Promise<BlockNumber> {
     return this.store.getProvenBlockNumber();
   }
+  getCheckpointedBlockNumber(): Promise<BlockNumber> {
+    return this.store.getCheckpointedL2BlockNumber();
+  }
   getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.store.getCheckpointedBlockByArchive(archive);
   }
@@ -1504,7 +1542,7 @@ export class Archiver
     return this.store.getDebugFunctionName(address, selector);
   }
 
-  async getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
+  async getPendingChainValidationStatus(): Promise<ValidateCheckpointResult> {
     return (await this.store.getPendingChainValidationStatus()) ?? { valid: true };
   }
 
@@ -1513,9 +1551,10 @@ export class Archiver
   }
 
   async getL2Tips(): Promise<L2Tips> {
-    const [latestBlockNumber, provenBlockNumber] = await Promise.all([
+    const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber] = await Promise.all([
       this.getBlockNumber(),
       this.getProvenBlockNumber(),
+      this.getCheckpointedBlockNumber(),
     ] as const);
 
     // TODO(#13569): Compute proper finalized block number based on L1 finalized block.
@@ -1523,44 +1562,112 @@ export class Archiver
     // NOTE: update end-to-end/src/e2e_epochs/epochs_empty_blocks.test.ts as that uses finalized blocks in computations
     const finalizedBlockNumber = BlockNumber(Math.max(provenBlockNumber - this.l1constants.epochDuration * 2, 0));
 
-    const [latestBlockHeader, provenBlockHeader, finalizedBlockHeader] = await Promise.all([
-      latestBlockNumber > 0 ? this.getBlockHeader(latestBlockNumber) : undefined,
-      provenBlockNumber > 0 ? this.getBlockHeader(provenBlockNumber) : undefined,
-      finalizedBlockNumber > 0 ? this.getBlockHeader(finalizedBlockNumber) : undefined,
-    ] as const);
+    const beforeInitialblockNumber = BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
 
-    if (latestBlockNumber > 0 && !latestBlockHeader) {
+    // Get the latest block header and checkpointed blocks for proven, finalised and checkpointed blocks
+    const [latestBlockHeader, provenCheckpointedBlock, finalizedCheckpointedBlock, checkpointedBlock] =
+      await Promise.all([
+        latestBlockNumber > beforeInitialblockNumber ? this.getBlockHeader(latestBlockNumber) : undefined,
+        provenBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(provenBlockNumber) : undefined,
+        finalizedBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(finalizedBlockNumber) : undefined,
+        checkpointedBlockNumber > beforeInitialblockNumber
+          ? this.getCheckpointedBlock(checkpointedBlockNumber)
+          : undefined,
+      ] as const);
+
+    if (latestBlockNumber > beforeInitialblockNumber && !latestBlockHeader) {
       throw new Error(`Failed to retrieve latest block header for block ${latestBlockNumber}`);
     }
 
-    if (provenBlockNumber > 0 && !provenBlockHeader) {
+    // Checkpointed blocks must exist for proven, finalized and checkpointed tips if they are beyond the initial block number.
+    if (checkpointedBlockNumber > beforeInitialblockNumber && !checkpointedBlock?.block.header) {
+      throw new Error(
+        `Failed to retrieve checkpointed block header for block ${checkpointedBlockNumber} (latest block is ${latestBlockNumber})`,
+      );
+    }
+
+    if (provenBlockNumber > beforeInitialblockNumber && !provenCheckpointedBlock?.block.header) {
       throw new Error(
-        `Failed to retrieve proven block header for block ${provenBlockNumber} (latest block is ${latestBlockNumber})`,
+        `Failed to retrieve proven checkpointed for block ${provenBlockNumber} (latest block is ${latestBlockNumber})`,
       );
     }
 
-    if (finalizedBlockNumber > 0 && !finalizedBlockHeader) {
+    if (finalizedBlockNumber > beforeInitialblockNumber && !finalizedCheckpointedBlock?.block.header) {
       throw new Error(
         `Failed to retrieve finalized block header for block ${finalizedBlockNumber} (latest block is ${latestBlockNumber})`,
       );
     }
 
     const latestBlockHeaderHash = (await latestBlockHeader?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
-    const provenBlockHeaderHash = (await provenBlockHeader?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
-    const finalizedBlockHeaderHash = (await finalizedBlockHeader?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
+    const provenBlockHeaderHash = (await provenCheckpointedBlock?.block.header?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
+    const finalizedBlockHeaderHash =
+      (await finalizedCheckpointedBlock?.block.header?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
+    const checkpointedBlockHeaderHash = (await checkpointedBlock?.block.header?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
+
+    // Now attempt to retrieve checkpoints for proven, finalised and checkpointed blocks
+    const [[provenBlockCheckpoint], [finalizedBlockCheckpoint], [checkpointedBlockCheckpoint]] = await Promise.all([
+      provenCheckpointedBlock !== undefined
+        ? await this.getPublishedCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1)
+        : [undefined],
+      finalizedCheckpointedBlock !== undefined
+        ? await this.getPublishedCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1)
+        : [undefined],
+      checkpointedBlock !== undefined
+        ? await this.getPublishedCheckpoints(checkpointedBlock?.checkpointNumber, 1)
+        : [undefined],
+    ]);
+
+    const initialcheckpointId: CheckpointId = {
+      number: CheckpointNumber.ZERO,
+      hash: GENESIS_CHECKPOINT_HEADER_HASH.toString(),
+    };
 
-    return {
-      latest: { number: latestBlockNumber, hash: latestBlockHeaderHash.toString() },
-      proven: { number: provenBlockNumber, hash: provenBlockHeaderHash.toString() },
-      finalized: { number: finalizedBlockNumber, hash: finalizedBlockHeaderHash.toString() },
+    const makeCheckpointId = (checkpoint: PublishedCheckpoint | undefined) => {
+      if (checkpoint === undefined) {
+        return initialcheckpointId;
+      }
+      return {
+        number: checkpoint.checkpoint.number,
+        hash: checkpoint.checkpoint.hash().toString(),
+      };
     };
+
+    const l2Tips: L2Tips = {
+      proposed: {
+        number: latestBlockNumber,
+        hash: latestBlockHeaderHash.toString(),
+      },
+      proven: {
+        block: {
+          number: provenBlockNumber,
+          hash: provenBlockHeaderHash.toString(),
+        },
+        checkpoint: makeCheckpointId(provenBlockCheckpoint),
+      },
+      finalized: {
+        block: {
+          number: finalizedBlockNumber,
+          hash: finalizedBlockHeaderHash.toString(),
+        },
+        checkpoint: makeCheckpointId(finalizedBlockCheckpoint),
+      },
+      checkpointed: {
+        block: {
+          number: checkpointedBlockNumber,
+          hash: checkpointedBlockHeaderHash.toString(),
+        },
+        checkpoint: makeCheckpointId(checkpointedBlockCheckpoint),
+      },
+    };
+
+    return l2Tips;
   }
 
   public async rollbackTo(targetL2BlockNumber: BlockNumber): Promise<void> {
     // TODO(pw/mbps): This still assumes 1 block per checkpoint
     const currentBlocks = await this.getL2Tips();
-    const currentL2Block = currentBlocks.latest.number;
-    const currentProvenBlock = currentBlocks.proven.number;
+    const currentL2Block = currentBlocks.proposed.number;
+    const currentProvenBlock = currentBlocks.proven.block.number;
 
     if (targetL2BlockNumber >= currentL2Block) {
       throw new Error(`Target L2 block ${targetL2BlockNumber} must be less than current L2 block ${currentL2Block}`);
@@ -1766,6 +1873,7 @@ export class ArchiverStoreHelper
       | 'addBlocks'
       | 'getBlock'
       | 'getBlocks'
+      | 'getCheckpointedBlocks'
     >
 {
   #log = createLogger('archiver:block-helper');
@@ -1924,7 +2032,7 @@ export class ArchiverStoreHelper
     ).every(Boolean);
   }
 
-  public addBlocks(blocks: L2BlockNew[], pendingChainValidationStatus?: ValidateBlockResult): Promise<boolean> {
+  public addBlocks(blocks: L2BlockNew[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean> {
     // Add the blocks to the store. Store will throw if the blocks are not in order, there are gaps,
     // or if the previous block is not in the store.
     return this.store.transactionAsync(async () => {
@@ -1947,7 +2055,7 @@ export class ArchiverStoreHelper
 
   public addCheckpoints(
     checkpoints: PublishedCheckpoint[],
-    pendingChainValidationStatus?: ValidateBlockResult,
+    pendingChainValidationStatus?: ValidateCheckpointResult,
   ): Promise<boolean> {
     // Add the blocks to the store. Store will throw if the blocks are not in order, there are gaps,
     // or if the previous block is not in the store.
@@ -2091,7 +2199,7 @@ export class ArchiverStoreHelper
     return this.store.getContractClassLogs(filter);
   }
   getSynchedL2BlockNumber(): Promise<BlockNumber> {
-    return this.store.getCheckpointedL2BlockNumber();
+    return this.store.getLatestBlockNumber();
   }
   getProvenCheckpointNumber(): Promise<CheckpointNumber> {
     return this.store.getProvenCheckpointNumber();
@@ -2147,10 +2255,10 @@ export class ArchiverStoreHelper
   getLastL1ToL2Message(): Promise<InboxMessage | undefined> {
     return this.store.getLastL1ToL2Message();
   }
-  getPendingChainValidationStatus(): Promise<ValidateBlockResult | undefined> {
+  getPendingChainValidationStatus(): Promise<ValidateCheckpointResult | undefined> {
     return this.store.getPendingChainValidationStatus();
   }
-  setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void> {
+  setPendingChainValidationStatus(status: ValidateCheckpointResult | undefined): Promise<void> {
     this.#log.debug(`Setting pending chain validation status to valid ${status?.valid}`, status);
     return this.store.setPendingChainValidationStatus(status);
   }

package/src/archiver/archiver_store.ts

@@ -4,7 +4,7 @@ import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { CustomRange } from '@aztec/kv-store';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { CheckpointedL2Block, L2BlockNew, ValidateBlockResult } from '@aztec/stdlib/block';
+import type { CheckpointedL2Block, L2BlockNew, ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type {
   ContractClassPublic,
@@ -85,6 +85,14 @@ export interface ArchiverDataStore {
    */
   getCheckpointedBlock(number: number): Promise<CheckpointedL2Block | undefined>;
 
+  /**
+   * Gets up to `limit` amount of checkpointed L2 blocks starting from `from`.
+   * @param from - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested checkpointed L2 blocks.
+   */
+  getCheckpointedBlocks(from: number, limit: number): Promise<CheckpointedL2Block[]>;
+
   /**
    * Returns the block for the given hash, or undefined if not exists.
    * @param blockHash - The block hash to return.
@@ -365,8 +373,8 @@ export interface ArchiverDataStore {
   getLastL1ToL2Message(): Promise<InboxMessage | undefined>;
 
   /** Returns the last synced validation status of the pending chain. */
-  getPendingChainValidationStatus(): Promise<ValidateBlockResult | undefined>;
+  getPendingChainValidationStatus(): Promise<ValidateCheckpointResult | undefined>;
 
   /** Sets the last synced validation status of the pending chain. */
-  setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void>;
+  setPendingChainValidationStatus(status: ValidateCheckpointResult | undefined): Promise<void>;
 }

package/src/archiver/archiver_store_test_suite.ts

@@ -20,10 +20,9 @@ import {
   EthAddress,
   L2BlockHash,
   L2BlockNew,
-  type ValidateBlockResult,
-  randomBlockInfo,
+  type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
-import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint, randomCheckpointInfo } from '@aztec/stdlib/checkpoint';
 import {
   type ContractClassPublic,
   type ContractInstanceWithAddress,
@@ -2756,7 +2755,7 @@ export function describeArchiverDataStore(
       });
 
       it('should store and retrieve a valid validation status', async () => {
-        const validStatus: ValidateBlockResult = { valid: true };
+        const validStatus: ValidateCheckpointResult = { valid: true };
 
         await store.setPendingChainValidationStatus(validStatus);
         const retrievedStatus = await store.getPendingChainValidationStatus();
@@ -2765,9 +2764,9 @@ export function describeArchiverDataStore(
       });
 
       it('should store and retrieve an invalid validation status with insufficient attestations', async () => {
-        const invalidStatus: ValidateBlockResult = {
+        const invalidStatus: ValidateCheckpointResult = {
           valid: false,
-          block: randomBlockInfo(1),
+          checkpoint: randomCheckpointInfo(1),
           committee: [EthAddress.random(), EthAddress.random()],
           epoch: EpochNumber(123),
           seed: 456n,
@@ -2783,9 +2782,9 @@ export function describeArchiverDataStore(
       });
 
       it('should store and retrieve an invalid validation status with invalid attestation', async () => {
-        const invalidStatus: ValidateBlockResult = {
+        const invalidStatus: ValidateCheckpointResult = {
           valid: false,
-          block: randomBlockInfo(2),
+          checkpoint: randomCheckpointInfo(2),
           committee: [EthAddress.random()],
           attestors: [EthAddress.random()],
           epoch: EpochNumber(789),
@@ -2802,10 +2801,10 @@ export function describeArchiverDataStore(
       });
 
       it('should overwrite existing status when setting a new one', async () => {
-        const firstStatus: ValidateBlockResult = { valid: true };
-        const secondStatus: ValidateBlockResult = {
+        const firstStatus: ValidateCheckpointResult = { valid: true };
+        const secondStatus: ValidateCheckpointResult = {
           valid: false,
-          block: randomBlockInfo(3),
+          checkpoint: randomCheckpointInfo(3),
           committee: [EthAddress.random()],
           epoch: EpochNumber(999),
           seed: 888n,
@@ -2822,9 +2821,9 @@ export function describeArchiverDataStore(
       });
 
       it('should handle empty committee and attestations arrays', async () => {
-        const statusWithEmptyArrays: ValidateBlockResult = {
+        const statusWithEmptyArrays: ValidateCheckpointResult = {
           valid: false,
-          block: randomBlockInfo(4),
+          checkpoint: randomCheckpointInfo(4),
           committee: [],
           epoch: EpochNumber(0),
           seed: 0n,

package/src/archiver/config.ts

@@ -46,8 +46,8 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     parseEnv: (val: string | undefined) => (val ? +val : undefined),
     description: 'The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb.',
   },
-  skipValidateBlockAttestations: {
-    description: 'Whether to skip validating block attestations (use only for testing).',
+  skipValidateCheckpointAttestations: {
+    description: 'Skip validating checkpoint attestations (for testing purposes only)',
     ...booleanConfigHelper(false),
   },
   maxAllowedEthClientDriftSeconds: {