@aztec/archiver 4.0.0-nightly.20260122 → 4.0.0-nightly.20260124

package/dest/test/mock_l2_block_source.js

@@ -5,7 +5,7 @@ import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import { CheckpointedL2Block, L2BlockHash, L2BlockNew } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, L2Block, L2BlockHash } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { EmptyL1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
@@ -20,7 +20,7 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
     async createBlocks(numBlocks) {
         for(let i = 0; i < numBlocks; i++){
             const blockNum = this.l2Blocks.length + 1;
-            const block = await L2BlockNew.random(BlockNumber(blockNum), {
+            const block = await L2Block.random(BlockNumber(blockNum), {
                 slotNumber: SlotNumber(blockNum)
             });
             this.l2Blocks.push(block);
@@ -82,10 +82,10 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         if (!block) {
             return Promise.resolve(undefined);
         }
-        const checkpointedBlock = new CheckpointedL2Block(CheckpointNumber(number), block, new L1PublishedData(BigInt(number), BigInt(number), `0x${number.toString(16).padStart(64, '0')}`), []);
+        const checkpointedBlock = new CheckpointedL2Block(CheckpointNumber.fromBlockNumber(number), block, new L1PublishedData(BigInt(number), BigInt(number), `0x${number.toString(16).padStart(64, '0')}`), []);
         return Promise.resolve(checkpointedBlock);
     }
-    async getCheckpointedBlocks(from, limit, _proven) {
+    async getCheckpointedBlocks(from, limit) {
         const result = [];
         for(let i = 0; i < limit; i++){
             const blockNum = from + i;
@@ -111,7 +111,7 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
    * Gets an L2 block (new format).
    * @param number - The block number to return.
    * @returns The requested L2 block.
-   */ getL2BlockNew(number) {
+   */ getL2Block(number) {
         const block = this.l2Blocks[number - 1];
         return Promise.resolve(block);
     }
@@ -120,14 +120,14 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
    * @param from - Number of the first block to return (inclusive).
    * @param limit - The maximum number of blocks to return.
    * @returns The requested mocked L2 blocks.
-   */ getBlocks(from, limit, proven) {
-        return Promise.resolve(this.l2Blocks.slice(from - 1, from - 1 + limit).filter((b)=>!proven || this.provenBlockNumber === undefined || b.number <= this.provenBlockNumber));
+   */ getBlocks(from, limit) {
+        return Promise.resolve(this.l2Blocks.slice(from - 1, from - 1 + limit));
     }
-    getPublishedCheckpoints(from, limit) {
+    getCheckpoints(from, limit) {
         // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
         const blocks = this.l2Blocks.slice(from - 1, from - 1 + limit);
         return Promise.all(blocks.map(async (block)=>{
-            // Create a checkpoint from the block - manually construct since L2BlockNew doesn't have toCheckpoint()
+            // Create a checkpoint from the block - manually construct since L2Block doesn't have toCheckpoint()
             const checkpoint = await Checkpoint.random(block.checkpointNumber, {
                 numBlocks: 1
             });
@@ -143,7 +143,7 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         if (!block) {
             return undefined;
         }
-        // Create a checkpoint from the block - manually construct since L2BlockNew doesn't have toCheckpoint()
+        // Create a checkpoint from the block - manually construct since L2Block doesn't have toCheckpoint()
         const checkpoint = await Checkpoint.random(block.checkpointNumber, {
             numBlocks: 1
         });
@@ -152,25 +152,12 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         ];
         return checkpoint;
     }
-    getPublishedBlocks(from, limit, proven) {
-        const blocks = this.l2Blocks.slice(from - 1, from - 1 + limit).filter((b)=>!proven || this.provenBlockNumber === undefined || b.number <= this.provenBlockNumber);
-        return Promise.resolve(blocks.map((block)=>CheckpointedL2Block.fromFields({
-                checkpointNumber: CheckpointNumber(block.number),
-                block,
-                l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
-                attestations: []
-            })));
-    }
-    getL2BlocksNew(from, limit, proven) {
-        // getBlocks already returns L2BlockNew[], so just return directly
-        return this.getBlocks(from, limit, proven);
-    }
-    async getPublishedBlockByHash(blockHash) {
+    async getCheckpointedBlockByHash(blockHash) {
         for (const block of this.l2Blocks){
             const hash = await block.hash();
             if (hash.equals(blockHash)) {
                 return CheckpointedL2Block.fromFields({
-                    checkpointNumber: CheckpointNumber(block.number),
+                    checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
                     block,
                     l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
                     attestations: []
@@ -179,19 +166,19 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         }
         return undefined;
     }
-    getPublishedBlockByArchive(archive) {
+    getCheckpointedBlockByArchive(archive) {
         const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
         if (!block) {
             return Promise.resolve(undefined);
         }
         return Promise.resolve(CheckpointedL2Block.fromFields({
-            checkpointNumber: CheckpointNumber(block.number),
+            checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
             block,
             l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
             attestations: []
         }));
     }
-    async getL2BlockNewByHash(blockHash) {
+    async getL2BlockByHash(blockHash) {
         for (const block of this.l2Blocks){
             const hash = await block.hash();
             if (hash.equals(blockHash)) {
@@ -200,7 +187,7 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         }
         return undefined;
     }
-    getL2BlockNewByArchive(archive) {
+    getL2BlockByArchive(archive) {
         const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
         return Promise.resolve(block);
     }
@@ -230,7 +217,7 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
             const slot = b.header.globalVariables.slotNumber;
             return slot >= start && slot <= end;
         });
-        // Create checkpoints from blocks - manually construct since L2BlockNew doesn't have toCheckpoint()
+        // Create checkpoints from blocks - manually construct since L2Block doesn't have toCheckpoint()
         return Promise.all(blocks.map(async (block)=>{
             const checkpoint = await Checkpoint.random(block.checkpointNumber, {
                 numBlocks: 1
@@ -241,7 +228,7 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
             return checkpoint;
         }));
     }
-    getBlocksForEpoch(epochNumber) {
+    getCheckpointedBlocksForEpoch(epochNumber) {
         const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
         const [start, end] = getSlotRangeForEpoch(epochNumber, {
             epochDuration
@@ -250,15 +237,20 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
             const slot = b.header.globalVariables.slotNumber;
             return slot >= start && slot <= end;
         });
-        return Promise.resolve(blocks);
+        return Promise.resolve(blocks.map((block)=>CheckpointedL2Block.fromFields({
+                checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
+                block,
+                l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
+                attestations: []
+            })));
     }
     getBlocksForSlot(slotNumber) {
         const blocks = this.l2Blocks.filter((b)=>b.header.globalVariables.slotNumber === slotNumber);
         return Promise.resolve(blocks);
     }
-    async getBlockHeadersForEpoch(epochNumber) {
-        const blocks = await this.getBlocksForEpoch(epochNumber);
-        return blocks.map((b)=>b.header);
+    async getCheckpointedBlockHeadersForEpoch(epochNumber) {
+        const checkpointedBlocks = await this.getCheckpointedBlocksForEpoch(epochNumber);
+        return checkpointedBlocks.map((b)=>b.block.header);
     }
     /**
    * Gets a tx effect.
@@ -325,7 +317,7 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         const makeTipId = (blockId)=>({
                 block: blockId,
                 checkpoint: {
-                    number: CheckpointNumber(blockId.number),
+                    number: CheckpointNumber.fromBlockNumber(blockId.number),
                     hash: blockId.hash
                 }
             });

package/dest/test/mock_structs.js

@@ -6,7 +6,7 @@ import { times, timesParallel } from '@aztec/foundation/collection';
 import { randomBigInt, randomInt } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
+import { CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { PrivateLog, PublicLog, SiloedTag, Tag } from '@aztec/stdlib/logs';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
@@ -147,8 +147,8 @@ export function makeInboxMessages(count, opts = {}) {
 }
 /** Creates a checkpoint with specified logs on each tx effect. */ export async function makeCheckpointWithLogs(blockNumber, options = {}) {
     const { previousArchive, numTxsPerBlock = 4, privateLogs, publicLogs } = options;
-    const block = await L2BlockNew.random(BlockNumber(blockNumber), {
-        checkpointNumber: CheckpointNumber(blockNumber),
+    const block = await L2Block.random(BlockNumber(blockNumber), {
+        checkpointNumber: CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)),
         indexWithinCheckpoint: IndexWithinCheckpoint(0),
         state: makeStateForBlock(blockNumber, numTxsPerBlock),
         ...previousArchive ? {
@@ -164,6 +164,6 @@ export function makeInboxMessages(count, opts = {}) {
     });
     const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
         block
-    ], CheckpointNumber(blockNumber));
+    ], CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)));
     return makePublishedCheckpoint(checkpoint, blockNumber);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/archiver",
-  "version": "4.0.0-nightly.20260122",
+  "version": "4.0.0-nightly.20260124",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -64,18 +64,18 @@
     ]
   },
   "dependencies": {
-    "@aztec/blob-client": "4.0.0-nightly.20260122",
-    "@aztec/blob-lib": "4.0.0-nightly.20260122",
-    "@aztec/constants": "4.0.0-nightly.20260122",
-    "@aztec/epoch-cache": "4.0.0-nightly.20260122",
-    "@aztec/ethereum": "4.0.0-nightly.20260122",
-    "@aztec/foundation": "4.0.0-nightly.20260122",
-    "@aztec/kv-store": "4.0.0-nightly.20260122",
-    "@aztec/l1-artifacts": "4.0.0-nightly.20260122",
-    "@aztec/noir-protocol-circuits-types": "4.0.0-nightly.20260122",
-    "@aztec/protocol-contracts": "4.0.0-nightly.20260122",
-    "@aztec/stdlib": "4.0.0-nightly.20260122",
-    "@aztec/telemetry-client": "4.0.0-nightly.20260122",
+    "@aztec/blob-client": "4.0.0-nightly.20260124",
+    "@aztec/blob-lib": "4.0.0-nightly.20260124",
+    "@aztec/constants": "4.0.0-nightly.20260124",
+    "@aztec/epoch-cache": "4.0.0-nightly.20260124",
+    "@aztec/ethereum": "4.0.0-nightly.20260124",
+    "@aztec/foundation": "4.0.0-nightly.20260124",
+    "@aztec/kv-store": "4.0.0-nightly.20260124",
+    "@aztec/l1-artifacts": "4.0.0-nightly.20260124",
+    "@aztec/noir-protocol-circuits-types": "4.0.0-nightly.20260124",
+    "@aztec/protocol-contracts": "4.0.0-nightly.20260124",
+    "@aztec/stdlib": "4.0.0-nightly.20260124",
+    "@aztec/telemetry-client": "4.0.0-nightly.20260124",
     "lodash.groupby": "^4.6.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.5.0",

package/src/archiver.ts

@@ -17,7 +17,7 @@ import {
   type ArchiverEmitter,
   type CheckpointId,
   GENESIS_CHECKPOINT_HEADER_HASH,
-  L2BlockNew,
+  L2Block,
   type L2BlockSink,
   type L2Tips,
   type ValidateCheckpointResult,
@@ -46,7 +46,7 @@ export type { ArchiverEmitter };
 
 /** Request to add a block to the archiver, queued for processing by the sync loop. */
 type AddBlockRequest = {
-  block: L2BlockNew;
+  block: L2Block;
   resolve: () => void;
   reject: (err: Error) => void;
 };
@@ -187,7 +187,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
    * @param block - The L2 block to add.
    * @returns A promise that resolves when the block has been added to the store, or rejects on error.
    */
-  public addBlock(block: L2BlockNew): Promise<void> {
+  public addBlock(block: L2Block): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       this.blockQueue.push({ block, resolve, reject });
       this.log.debug(`Queued block ${block.number} for processing`);
@@ -323,8 +323,11 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   }
 
   public async isEpochComplete(epochNumber: EpochNumber): Promise<boolean> {
-    // The epoch is complete if the current L2 block is the last one in the epoch (or later)
-    const header = await this.getBlockHeader('latest');
+    // The epoch is complete if the current checkpointed L2 block is the last one in the epoch (or later).
+    // We use the checkpointed block number (synced from L1) instead of 'latest' to avoid returning true
+    // prematurely when proposed blocks have been pushed to the archiver but not yet checkpointed on L1.
+    const checkpointedBlockNumber = await this.getCheckpointedL2BlockNumber();
+    const header = checkpointedBlockNumber > 0 ? await this.getBlockHeader(checkpointedBlockNumber) : undefined;
     const slot = header ? header.globalVariables.slotNumber : undefined;
     const [_startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
     if (slot && slot >= endSlot) {
@@ -421,14 +424,12 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     // 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)
+        ? await this.getCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1)
         : [undefined],
       finalizedCheckpointedBlock !== undefined
-        ? await this.getPublishedCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1)
-        : [undefined],
-      checkpointedBlock !== undefined
-        ? await this.getPublishedCheckpoints(checkpointedBlock?.checkpointNumber, 1)
+        ? await this.getCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1)
         : [undefined],
+      checkpointedBlock !== undefined ? await this.getCheckpoints(checkpointedBlock?.checkpointNumber, 1) : [undefined],
     ]);
 
     const initialcheckpointId: CheckpointId = {
@@ -502,7 +503,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     }
     const targetL1BlockHash = Buffer32.fromString(targetL1Block.hash);
     this.log.info(`Unwinding ${blocksToUnwind} checkpoints from L2 block ${currentL2Block}`);
-    await this.updater.unwindCheckpoints(CheckpointNumber(currentL2Block), blocksToUnwind);
+    await this.updater.unwindCheckpoints(CheckpointNumber.fromBlockNumber(currentL2Block), blocksToUnwind);
     this.log.info(`Unwinding L1 to L2 messages to checkpoint ${targetCheckpointNumber}`);
     await this.store.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
     this.log.info(`Setting L1 syncpoints to ${targetL1BlockNumber}`);

package/src/l1/bin/retrieve-calldata.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
-import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 
@@ -142,7 +142,12 @@ async function main() {
     logger.info('');
 
     // For this script, we don't have blob hashes or expected hashes, so pass empty arrays/objects
-    const result = await retriever.getCheckpointFromRollupTx(txHash, [], CheckpointNumber(l2BlockNumber), {});
+    const result = await retriever.getCheckpointFromRollupTx(
+      txHash,
+      [],
+      CheckpointNumber.fromBlockNumber(BlockNumber(l2BlockNumber)),
+      {},
+    );
 
     logger.info(' Successfully retrieved block header!');
     logger.info('');

package/src/l1/data_retrieval.ts

@@ -20,7 +20,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
+import { Body, CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { Proof } from '@aztec/stdlib/proofs';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
@@ -69,7 +69,7 @@ export async function retrievedToPublishedCheckpoint({
   const l1toL2MessageTreeRoot = blocksBlobData[0].l1ToL2MessageRoot!;
 
   const spongeBlob = SpongeBlob.init();
-  const l2Blocks: L2BlockNew[] = [];
+  const l2Blocks: L2Block[] = [];
   for (let i = 0; i < blocksBlobData.length; i++) {
     const blockBlobData = blocksBlobData[i];
     const { blockEndMarker, blockEndStateField, lastArchiveRoot, noteHashRoot, nullifierRoot, publicDataRoot } =
@@ -119,7 +119,7 @@ export async function retrievedToPublishedCheckpoint({
 
     const newArchive = new AppendOnlyTreeSnapshot(newArchiveRoots[i], l2BlockNumber + 1);
 
-    l2Blocks.push(new L2BlockNew(newArchive, header, body, checkpointNumber, IndexWithinCheckpoint(i)));
+    l2Blocks.push(new L2Block(newArchive, header, body, checkpointNumber, IndexWithinCheckpoint(i)));
   }
 
   const lastBlock = l2Blocks.at(-1)!;

package/src/modules/data_source_base.ts

@@ -4,7 +4,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { isDefined } from '@aztec/foundation/types';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CheckpointedL2Block, CommitteeAttestation, L2BlockNew, type L2Tips } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, CommitteeAttestation, L2Block, type L2Tips } from '@aztec/stdlib/block';
 import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
@@ -117,18 +117,8 @@ export abstract class ArchiverDataSourceBase
     return BlockNumber(checkpointData.startBlock + checkpointData.numBlocks - 1);
   }
 
-  public async getCheckpointedBlocks(
-    from: BlockNumber,
-    limit: number,
-    proven?: boolean,
-  ): Promise<CheckpointedL2Block[]> {
-    const blocks = await this.store.getCheckpointedBlocks(from, limit);
-
-    if (proven === true) {
-      const provenBlockNumber = await this.store.getProvenBlockNumber();
-      return blocks.filter(b => b.block.number <= provenBlockNumber);
-    }
-    return blocks;
+  public getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
+    return this.store.getCheckpointedBlocks(from, limit);
   }
 
   public getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
@@ -139,7 +129,7 @@ export abstract class ArchiverDataSourceBase
     return this.store.getBlockHeaderByArchive(archive);
   }
 
-  public async getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined> {
+  public async getL2Block(number: BlockNumber): Promise<L2Block | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
       number = await this.store.getLatestBlockNumber();
@@ -167,16 +157,6 @@ export abstract class ArchiverDataSourceBase
     return (await this.store.getPendingChainValidationStatus()) ?? { valid: true };
   }
 
-  public async getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
-    const blocks = await this.store.getBlocks(from, limit);
-
-    if (proven === true) {
-      const provenBlockNumber = await this.store.getProvenBlockNumber();
-      return blocks.filter(b => b.number <= provenBlockNumber);
-    }
-    return blocks;
-  }
-
   public getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]> {
     return this.store.getPrivateLogsByTags(tags, page);
   }
@@ -241,10 +221,7 @@ export abstract class ArchiverDataSourceBase
     return this.store.getL1ToL2MessageIndex(l1ToL2Message);
   }
 
-  public async getPublishedCheckpoints(
-    checkpointNumber: CheckpointNumber,
-    limit: number,
-  ): Promise<PublishedCheckpoint[]> {
+  public async getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]> {
     const checkpoints = await this.store.getRangeOfCheckpoints(checkpointNumber, limit);
     const blocks = (
       await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
@@ -270,17 +247,17 @@ export abstract class ArchiverDataSourceBase
     return fullCheckpoints;
   }
 
-  public getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]> {
+  public getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
     return this.store.getBlocksForSlot(slotNumber);
   }
 
-  public async getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2BlockNew[]> {
+  public async getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]> {
     if (!this.l1Constants) {
       throw new Error('L1 constants not set');
     }
 
     const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
-    const blocks: L2BlockNew[] = [];
+    const blocks: CheckpointedL2Block[] = [];
 
     // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
     // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
@@ -291,9 +268,9 @@ export abstract class ArchiverDataSourceBase
         // push the blocks on backwards
         const endBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
         for (let i = endBlock; i >= checkpoint.startBlock; i--) {
-          const block = await this.getBlock(BlockNumber(i));
-          if (block) {
-            blocks.push(block);
+          const checkpointedBlock = await this.getCheckpointedBlock(BlockNumber(i));
+          if (checkpointedBlock) {
+            blocks.push(checkpointedBlock);
           }
         }
       }
@@ -303,7 +280,7 @@ export abstract class ArchiverDataSourceBase
     return blocks.reverse();
   }
 
-  public async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
+  public async getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
     if (!this.l1Constants) {
       throw new Error('L1 constants not set');
     }
@@ -346,7 +323,7 @@ export abstract class ArchiverDataSourceBase
     while (checkpointData && slot(checkpointData) >= start) {
       if (slot(checkpointData) <= end) {
         // push the checkpoints on backwards
-        const [checkpoint] = await this.getPublishedCheckpoints(checkpointData.checkpointNumber, 1);
+        const [checkpoint] = await this.getCheckpoints(checkpointData.checkpointNumber, 1);
         checkpoints.push(checkpoint.checkpoint);
       }
       checkpointData = await this.store.getCheckpointData(CheckpointNumber(checkpointData.checkpointNumber - 1));
@@ -355,33 +332,7 @@ export abstract class ArchiverDataSourceBase
     return checkpoints.reverse();
   }
 
-  public async getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]> {
-    const checkpoints = await this.store.getRangeOfCheckpoints(CheckpointNumber(from), limit);
-    const provenCheckpointNumber = await this.store.getProvenCheckpointNumber();
-    const blocks = (
-      await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
-    ).filter(isDefined);
-
-    const publishedBlocks: CheckpointedL2Block[] = [];
-    for (let i = 0; i < checkpoints.length; i++) {
-      const blockForCheckpoint = blocks[i][0];
-      const checkpoint = checkpoints[i];
-      if (checkpoint.checkpointNumber > provenCheckpointNumber && proven === true) {
-        // this checkpoint isn't proven and we only want proven
-        continue;
-      }
-      const publishedBlock = new CheckpointedL2Block(
-        checkpoint.checkpointNumber,
-        blockForCheckpoint,
-        checkpoint.l1,
-        checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
-      );
-      publishedBlocks.push(publishedBlock);
-    }
-    return publishedBlocks;
-  }
-
-  public async getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
+  public async getBlock(number: BlockNumber): Promise<L2Block | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
       number = await this.store.getLatestBlockNumber();
@@ -392,30 +343,24 @@ export abstract class ArchiverDataSourceBase
     return this.store.getBlock(number);
   }
 
-  public async getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
-    const blocks = await this.store.getBlocks(from, limit);
-
-    if (proven === true) {
-      const provenBlockNumber = await this.store.getProvenBlockNumber();
-      return blocks.filter(b => b.number <= provenBlockNumber);
-    }
-    return blocks;
+  public getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]> {
+    return this.store.getBlocks(from, limit);
   }
 
-  public getPublishedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
+  public getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.store.getCheckpointedBlockByHash(blockHash);
   }
 
-  public getPublishedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
+  public getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.store.getCheckpointedBlockByArchive(archive);
   }
 
-  public async getL2BlockNewByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
+  public async getL2BlockByHash(blockHash: Fr): Promise<L2Block | undefined> {
     const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
     return checkpointedBlock?.block;
   }
 
-  public async getL2BlockNewByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
+  public async getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined> {
     const checkpointedBlock = await this.store.getCheckpointedBlockByArchive(archive);
     return checkpointedBlock?.block;
   }

package/src/modules/data_store_updater.ts

@@ -10,7 +10,7 @@ import {
   ContractInstancePublishedEvent,
   ContractInstanceUpdatedEvent,
 } from '@aztec/protocol-contracts/instance-registry';
-import type { L2BlockNew, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { L2Block, ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import {
   type ExecutablePrivateFunctionWithMembershipProof,
@@ -35,7 +35,7 @@ enum Operation {
 /** Result of adding checkpoints with information about any pruned blocks. */
 type ReconcileCheckpointsResult = {
   /** Blocks that were pruned due to conflict with L1 checkpoints. */
-  prunedBlocks: L2BlockNew[] | undefined;
+  prunedBlocks: L2Block[] | undefined;
   /** Last block number that was already inserted locally, or undefined if none. */
   lastAlreadyInsertedBlockNumber: BlockNumber | undefined;
 };
@@ -55,7 +55,7 @@ export class ArchiverDataStoreUpdater {
    * @param pendingChainValidationStatus - Optional validation status to set.
    * @returns True if the operation is successful.
    */
-  public addBlocks(blocks: L2BlockNew[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean> {
+  public addBlocks(blocks: L2Block[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean> {
     return this.store.transactionAsync(async () => {
       await this.store.addBlocks(blocks);
 
@@ -191,7 +191,7 @@ export class ArchiverDataStoreUpdater {
    * @param blockNumber - Remove all blocks with number greater than this.
    * @returns The removed blocks.
    */
-  public removeBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
+  public removeBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
     return this.store.transactionAsync(async () => {
       // First get the blocks to be removed so we can clean up contract data
       const removedBlocks = await this.store.removeBlocksAfter(blockNumber);
@@ -248,17 +248,17 @@ export class ArchiverDataStoreUpdater {
   }
 
   /** Extracts and stores contract data from a single block. */
-  private addBlockDataToDB(block: L2BlockNew): Promise<boolean> {
+  private addBlockDataToDB(block: L2Block): Promise<boolean> {
     return this.editContractBlockData(block, Operation.Store);
   }
 
   /** Removes contract data associated with a block. */
-  private removeBlockDataFromDB(block: L2BlockNew): Promise<boolean> {
+  private removeBlockDataFromDB(block: L2Block): Promise<boolean> {
     return this.editContractBlockData(block, Operation.Delete);
   }
 
   /** Adds or remove contract data associated with a block. */
-  private async editContractBlockData(block: L2BlockNew, operation: Operation): Promise<boolean> {
+  private async editContractBlockData(block: L2Block, operation: Operation): Promise<boolean> {
     const contractClassLogs = block.body.txEffects.flatMap(txEffect => txEffect.contractClassLogs);
     const privateLogs = block.body.txEffects.flatMap(txEffect => txEffect.privateLogs);
     const publicLogs = block.body.txEffects.flatMap(txEffect => txEffect.publicLogs);

package/src/modules/instrumentation.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import type { L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block } from '@aztec/stdlib/block';
 import {
   Attributes,
   type Gauge,
@@ -97,7 +97,7 @@ export class ArchiverInstrumentation {
     return this.telemetry.isEnabled();
   }
 
-  public processNewBlocks(syncTimePerBlock: number, blocks: L2BlockNew[]) {
+  public processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]) {
     this.syncDurationPerBlock.record(Math.ceil(syncTimePerBlock));
     this.blockHeight.record(Math.max(...blocks.map(b => b.number)));
     this.syncBlockCount.add(blocks.length);