@aztec/archiver 0.0.1-commit.d431d1c → 0.0.1-commit.e3c1de76

package/src/store/log_store.ts

@@ -6,7 +6,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2BlockHash, L2BlockNew } from '@aztec/stdlib/block';
+import { BlockHash, L2Block } from '@aztec/stdlib/block';
 import { MAX_LOGS_PER_TAG } from '@aztec/stdlib/interfaces/api-limit';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import {
@@ -59,7 +59,7 @@ export class LogStore {
    * @param block - The L2 block to extract logs from.
    * @returns An object containing the private and public tagged logs for the block.
    */
-  #extractTaggedLogsFromBlock(block: L2BlockNew) {
+  #extractTaggedLogsFromBlock(block: L2Block) {
     // SiloedTag (as string) -> array of log buffers.
     const privateTaggedLogs = new Map<string, Buffer[]>();
     // "{contractAddress}_{tag}" (as string) -> array of log buffers.
@@ -120,7 +120,7 @@ export class LogStore {
    * @returns A map from tag (as string) to an array of serialized private logs belonging to that tag, and a map from
    * "{contractAddress}_{tag}" (as string) to an array of serialized public logs belonging to that key.
    */
-  #extractTaggedLogs(blocks: L2BlockNew[]): {
+  #extractTaggedLogs(blocks: L2Block[]): {
     privateTaggedLogs: Map<string, Buffer[]>;
     publicTaggedLogs: Map<string, Buffer[]>;
   } {
@@ -146,7 +146,7 @@ export class LogStore {
     return { privateTaggedLogs, publicTaggedLogs };
   }
 
-  async #addPrivateLogs(blocks: L2BlockNew[]): Promise<void> {
+  async #addPrivateLogs(blocks: L2Block[]): Promise<void> {
     const newBlocks = await filterAsync(
       blocks,
       async block => !(await this.#privateLogKeysByBlock.hasAsync(block.number)),
@@ -181,7 +181,7 @@ export class LogStore {
     }
   }
 
-  async #addPublicLogs(blocks: L2BlockNew[]): Promise<void> {
+  async #addPublicLogs(blocks: L2Block[]): Promise<void> {
     const newBlocks = await filterAsync(
       blocks,
       async block => !(await this.#publicLogKeysByBlock.hasAsync(block.number)),
@@ -229,7 +229,7 @@ export class LogStore {
     }
   }
 
-  async #addContractClassLogs(blocks: L2BlockNew[]): Promise<void> {
+  async #addContractClassLogs(blocks: L2Block[]): Promise<void> {
     const newBlocks = await filterAsync(
       blocks,
       async block => !(await this.#contractClassLogsByBlock.hasAsync(block.number)),
@@ -260,7 +260,7 @@ export class LogStore {
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
+  addLogs(blocks: L2Block[]): Promise<boolean> {
     return this.db.transactionAsync(async () => {
       await Promise.all([
         this.#addPrivateLogs(blocks),
@@ -271,21 +271,21 @@ export class LogStore {
     });
   }
 
-  #packWithBlockHash(blockHash: Fr, data: Buffer<ArrayBufferLike>[]): Buffer<ArrayBufferLike> {
+  #packWithBlockHash(blockHash: BlockHash, data: Buffer<ArrayBufferLike>[]): Buffer<ArrayBufferLike> {
     return Buffer.concat([blockHash.toBuffer(), ...data]);
   }
 
-  #unpackBlockHash(reader: BufferReader): L2BlockHash {
+  #unpackBlockHash(reader: BufferReader): BlockHash {
     const blockHash = reader.remainingBytes() > 0 ? reader.readObject(Fr) : undefined;
 
     if (!blockHash) {
       throw new Error('Failed to read block hash from log entry buffer');
     }
 
-    return L2BlockHash.fromField(blockHash);
+    return new BlockHash(blockHash);
   }
 
-  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
+  deleteLogs(blocks: L2Block[]): Promise<boolean> {
     return this.db.transactionAsync(async () => {
       await Promise.all(
         blocks.map(async block => {
@@ -543,7 +543,7 @@ export class LogStore {
   #accumulateLogs(
     results: (ExtendedContractClassLog | ExtendedPublicLog)[],
     blockNumber: number,
-    blockHash: L2BlockHash,
+    blockHash: BlockHash,
     txIndex: number,
     txLogs: (ContractClassLog | PublicLog)[],
     filter: LogFilter = {},

package/src/test/fake_l1_state.ts

@@ -10,7 +10,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts';
-import { CommitteeAttestation, CommitteeAttestationsAndSigners, L2BlockNew } from '@aztec/stdlib/block';
+import { CommitteeAttestation, CommitteeAttestationsAndSigners, L2Block } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
@@ -51,7 +51,7 @@ type AddCheckpointOptions = {
   /** Number of L2 blocks in the checkpoint. Default: 1 */
   numBlocks?: number;
   /** Or the actual blocks for the checkpoint */
-  blocks?: L2BlockNew[];
+  blocks?: L2Block[];
   /** Number of transactions per block. Default: 4 */
   txsPerBlock?: number;
   /** Max number of effects per tx (for generating large blobs). Default: undefined */

package/src/test/index.ts

@@ -2,3 +2,6 @@ export * from './mock_structs.js';
 export * from './mock_l2_block_source.js';
 export * from './mock_l1_to_l2_message_source.js';
 export * from './mock_archiver.js';
+// NOTE: noop_l1_archiver.js is intentionally NOT exported here because it imports
+// jest-mock-extended, which depends on @jest/globals and can only run inside Jest.
+// Import it directly: import { NoopL1Archiver } from '@aztec/archiver/test/noop-l1';

package/src/test/mock_archiver.ts

@@ -57,7 +57,7 @@ export class MockPrefilledArchiver extends MockArchiver {
 
     const fromBlock = this.l2Blocks.length;
     // TODO: Add L2 blocks and checkpoints separately once archiver has the apis for that.
-    this.addBlocks(this.prefilled.slice(fromBlock, fromBlock + numBlocks).flatMap(c => c.blocks));
+    this.addProposedBlocks(this.prefilled.slice(fromBlock, fromBlock + numBlocks).flatMap(c => c.blocks));
     return Promise.resolve();
   }
 }

package/src/test/mock_l2_block_source.ts

@@ -8,9 +8,9 @@ import { createLogger } from '@aztec/foundation/log';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
+  BlockHash,
   CheckpointedL2Block,
-  L2BlockHash,
-  L2BlockNew,
+  L2Block,
   type L2BlockSource,
   type L2Tips,
   type ValidateCheckpointResult,
@@ -18,14 +18,14 @@ import {
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { EmptyL1RollupConstants, type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
-import { type BlockHeader, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+import { type BlockHeader, TxExecutionResult, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
 /**
  * A mocked implementation of L2BlockSource to be used in tests.
  */
 export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
-  protected l2Blocks: L2BlockNew[] = [];
+  protected l2Blocks: L2Block[] = [];
 
   private provenBlockNumber: number = 0;
   private finalizedBlockNumber: number = 0;
@@ -36,16 +36,16 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   public async createBlocks(numBlocks: number) {
     for (let i = 0; i < numBlocks; i++) {
       const blockNum = this.l2Blocks.length + 1;
-      const block = await L2BlockNew.random(BlockNumber(blockNum), { slotNumber: SlotNumber(blockNum) });
+      const block = await L2Block.random(BlockNumber(blockNum), { slotNumber: SlotNumber(blockNum) });
       this.l2Blocks.push(block);
     }
 
     this.log.verbose(`Created ${numBlocks} blocks in the mock L2 block source`);
   }
 
-  public addBlocks(blocks: L2BlockNew[]) {
+  public addProposedBlocks(blocks: L2Block[]) {
     this.l2Blocks.push(...blocks);
-    this.log.verbose(`Added ${blocks.length} blocks to the mock L2 block source`);
+    this.log.verbose(`Added ${blocks.length} proposed blocks to the mock L2 block source`);
   }
 
   public removeBlocks(numBlocks: number) {
@@ -96,6 +96,14 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(BlockNumber(this.provenBlockNumber));
   }
 
+  public getCheckpointedL2BlockNumber() {
+    return Promise.resolve(BlockNumber(this.checkpointedBlockNumber));
+  }
+
+  public getFinalizedL2BlockNumber() {
+    return Promise.resolve(BlockNumber(this.finalizedBlockNumber));
+  }
+
   public getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
     if (number > this.checkpointedBlockNumber) {
       return Promise.resolve(undefined);
@@ -105,7 +113,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
       return Promise.resolve(undefined);
     }
     const checkpointedBlock = new CheckpointedL2Block(
-      CheckpointNumber(number),
+      CheckpointNumber.fromBlockNumber(number),
       block,
       new L1PublishedData(BigInt(number), BigInt(number), `0x${number.toString(16).padStart(64, '0')}`),
       [],
@@ -113,11 +121,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(checkpointedBlock);
   }
 
-  public async getCheckpointedBlocks(
-    from: BlockNumber,
-    limit: number,
-    _proven?: boolean,
-  ): Promise<CheckpointedL2Block[]> {
+  public async getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
     const result: CheckpointedL2Block[] = [];
     for (let i = 0; i < limit; i++) {
       const blockNum = from + i;
@@ -137,7 +141,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */
-  public getBlock(number: number): Promise<L2BlockNew | undefined> {
+  public getBlock(number: number): Promise<L2Block | undefined> {
     const block = this.l2Blocks[number - 1];
     return Promise.resolve(block);
   }
@@ -147,7 +151,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @param number - The block number to return.
    * @returns The requested L2 block.
    */
-  public getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined> {
+  public getL2Block(number: BlockNumber): Promise<L2Block | undefined> {
     const block = this.l2Blocks[number - 1];
     return Promise.resolve(block);
   }
@@ -158,20 +162,16 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @param limit - The maximum number of blocks to return.
    * @returns The requested mocked L2 blocks.
    */
-  public getBlocks(from: number, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
-    return Promise.resolve(
-      this.l2Blocks
-        .slice(from - 1, from - 1 + limit)
-        .filter(b => !proven || this.provenBlockNumber === undefined || b.number <= this.provenBlockNumber),
-    );
+  public getBlocks(from: number, limit: number): Promise<L2Block[]> {
+    return Promise.resolve(this.l2Blocks.slice(from - 1, from - 1 + limit));
   }
 
-  public getPublishedCheckpoints(from: CheckpointNumber, limit: number) {
+  public getCheckpoints(from: CheckpointNumber, limit: number) {
     // 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 });
         checkpoint.blocks = [block];
         return new PublishedCheckpoint(
@@ -189,39 +189,18 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     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 });
     checkpoint.blocks = [block];
     return checkpoint;
   }
 
-  public getPublishedBlocks(from: number, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]> {
-    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: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
-    // getBlocks already returns L2BlockNew[], so just return directly
-    return this.getBlocks(from, limit, proven);
-  }
-
-  public async getPublishedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
+  public async getCheckpointedBlockByHash(blockHash: BlockHash): Promise<CheckpointedL2Block | undefined> {
     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: [],
@@ -231,14 +210,14 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return undefined;
   }
 
-  public getPublishedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
+  public getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
     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: [],
@@ -246,7 +225,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     );
   }
 
-  public async getL2BlockNewByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
+  public async getL2BlockByHash(blockHash: BlockHash): Promise<L2Block | undefined> {
     for (const block of this.l2Blocks) {
       const hash = await block.hash();
       if (hash.equals(blockHash)) {
@@ -256,12 +235,12 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return undefined;
   }
 
-  public getL2BlockNewByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
+  public getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined> {
     const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
     return Promise.resolve(block);
   }
 
-  public async getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
+  public async getBlockHeaderByHash(blockHash: BlockHash): Promise<BlockHeader | undefined> {
     for (const block of this.l2Blocks) {
       const hash = await block.hash();
       if (hash.equals(blockHash)) {
@@ -288,7 +267,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
       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 });
@@ -298,24 +277,33 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     );
   }
 
-  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2BlockNew[]> {
+  getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]> {
     const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
     const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
     const blocks = this.l2Blocks.filter(b => {
       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: SlotNumber): Promise<L2BlockNew[]> {
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
     const blocks = this.l2Blocks.filter(b => b.header.globalVariables.slotNumber === slotNumber);
     return Promise.resolve(blocks);
   }
 
-  async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
-    const blocks = await this.getBlocksForEpoch(epochNumber);
-    return blocks.map(b => b.header);
+  async getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
+    const checkpointedBlocks = await this.getCheckpointedBlocksForEpoch(epochNumber);
+    return checkpointedBlocks.map(b => b.block.header);
   }
 
   /**
@@ -334,7 +322,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return {
       data: txEffect,
       l2BlockNumber: block.number,
-      l2BlockHash: L2BlockHash.fromField(await block.hash()),
+      l2BlockHash: await block.hash(),
       txIndexInBlock: block.body.txEffects.indexOf(txEffect),
     };
   }
@@ -348,12 +336,14 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     for (const block of this.l2Blocks) {
       for (const txEffect of block.body.txEffects) {
         if (txEffect.txHash.equals(txHash)) {
+          // In mock, assume all txs are checkpointed with successful execution
           return new TxReceipt(
             txHash,
-            TxStatus.SUCCESS,
-            '',
+            TxStatus.CHECKPOINTED,
+            TxExecutionResult.SUCCESS,
+            undefined,
             txEffect.transactionFee.toBigInt(),
-            L2BlockHash.fromField(await block.hash()),
+            await block.hash(),
             block.number,
           );
         }
@@ -394,7 +384,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
 
     const makeTipId = (blockId: typeof latestBlockId) => ({
       block: blockId,
-      checkpoint: { number: CheckpointNumber(blockId.number), hash: blockId.hash },
+      checkpoint: { number: CheckpointNumber.fromBlockNumber(blockId.number), hash: blockId.hash },
     });
 
     return {

package/src/test/mock_structs.ts

@@ -12,7 +12,7 @@ import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer'
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 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';
@@ -46,24 +46,40 @@ export function makeInboxMessage(
 }
 
 export function makeInboxMessages(
-  count: number,
+  totalCount: number,
   opts: {
     initialHash?: Buffer16;
     initialCheckpointNumber?: CheckpointNumber;
+    messagesPerCheckpoint?: number;
     overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
   } = {},
 ): InboxMessage[] {
-  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialCheckpointNumber = 1 } = opts;
+  const {
+    initialHash = Buffer16.ZERO,
+    overrideFn = msg => msg,
+    initialCheckpointNumber = CheckpointNumber(1),
+    messagesPerCheckpoint = 1,
+  } = opts;
+
   const messages: InboxMessage[] = [];
   let rollingHash = initialHash;
-  for (let i = 0; i < count; i++) {
+  for (let i = 0; i < totalCount; i++) {
+    const msgIndex = i % messagesPerCheckpoint;
+    const checkpointNumber = CheckpointNumber.fromBigInt(
+      BigInt(initialCheckpointNumber) + BigInt(i) / BigInt(messagesPerCheckpoint),
+    );
     const leaf = Fr.random();
-    const checkpointNumber = CheckpointNumber(i + initialCheckpointNumber);
-    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, checkpointNumber }), i);
+    const message = overrideFn(
+      makeInboxMessage(rollingHash, {
+        leaf,
+        checkpointNumber,
+        index: InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) + BigInt(msgIndex),
+      }),
+      i,
+    );
     rollingHash = message.rollingHash;
     messages.push(message);
   }
-
   return messages;
 }
 
@@ -268,8 +284,8 @@ export async function makeCheckpointWithLogs(
 ): Promise<PublishedCheckpoint> {
   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 ? { lastArchive: previousArchive } : {}),
@@ -289,7 +305,7 @@ export async function makeCheckpointWithLogs(
     AppendOnlyTreeSnapshot.random(),
     CheckpointHeader.random(),
     [block],
-    CheckpointNumber(blockNumber),
+    CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)),
   );
   return makePublishedCheckpoint(checkpoint, blockNumber);
 }

package/src/test/noop_l1_archiver.ts

@@ -0,0 +1,109 @@
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { FunctionsOf } from '@aztec/foundation/types';
+import type { ArchiverEmitter } from '@aztec/stdlib/block';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { type TelemetryClient, type Tracer, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { mock } from 'jest-mock-extended';
+import { EventEmitter } from 'node:events';
+
+import { Archiver } from '../archiver.js';
+import { ArchiverInstrumentation } from '../modules/instrumentation.js';
+import type { ArchiverL1Synchronizer } from '../modules/l1_synchronizer.js';
+import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
+
+/** Noop L1 synchronizer for testing without L1 connectivity. */
+class NoopL1Synchronizer implements FunctionsOf<ArchiverL1Synchronizer> {
+  public readonly tracer: Tracer;
+
+  constructor(tracer: Tracer) {
+    this.tracer = tracer;
+  }
+
+  setConfig(_config: unknown) {}
+  getL1BlockNumber(): bigint | undefined {
+    return 0n;
+  }
+  getL1Timestamp(): bigint | undefined {
+    return 0n;
+  }
+  testEthereumNodeSynced(): Promise<void> {
+    return Promise.resolve();
+  }
+  syncFromL1(_initialSyncComplete: boolean): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+/**
+ * Archiver with mocked L1 connectivity for testing.
+ * Uses mock L1 clients and a noop synchronizer, enabling tests that
+ * don't require real Ethereum connectivity.
+ */
+export class NoopL1Archiver extends Archiver {
+  constructor(
+    dataStore: KVArchiverDataStore,
+    l1Constants: L1RollupConstants & { genesisArchiveRoot: Fr },
+    instrumentation: ArchiverInstrumentation,
+  ) {
+    // Create mocks for L1 clients
+    const publicClient = mock<ViemPublicClient>();
+    const debugClient = mock<ViemPublicDebugClient>();
+    const rollup = mock<RollupContract>();
+    const blobClient = mock<BlobClientInterface>();
+
+    // Mock methods called during start()
+    blobClient.testSources.mockResolvedValue();
+    publicClient.getBlockNumber.mockResolvedValue(1n);
+
+    const events = new EventEmitter() as ArchiverEmitter;
+    const synchronizer = new NoopL1Synchronizer(instrumentation.tracer);
+
+    super(
+      publicClient,
+      debugClient,
+      rollup,
+      {
+        registryAddress: EthAddress.ZERO,
+        governanceProposerAddress: EthAddress.ZERO,
+        slashFactoryAddress: EthAddress.ZERO,
+        slashingProposerAddress: EthAddress.ZERO,
+      },
+      dataStore,
+      {
+        pollingIntervalMs: 1000,
+        batchSize: 100,
+        skipValidateCheckpointAttestations: true,
+        maxAllowedEthClientDriftSeconds: 300,
+        ethereumAllowNoDebugHosts: true, // Skip trace validation
+      },
+      blobClient,
+      instrumentation,
+      { ...l1Constants, l1StartBlockHash: Buffer32.random() },
+      synchronizer as ArchiverL1Synchronizer,
+      events,
+    );
+  }
+
+  /** Override start to skip L1 validation checks. */
+  public override start(_blockUntilSynced?: boolean): Promise<void> {
+    // Just start the running promise without L1 checks
+    this.runningPromise.start();
+    return Promise.resolve();
+  }
+}
+
+/** Creates an archiver with mocked L1 connectivity for testing. */
+export async function createNoopL1Archiver(
+  dataStore: KVArchiverDataStore,
+  l1Constants: L1RollupConstants & { genesisArchiveRoot: Fr },
+  telemetry: TelemetryClient = getTelemetryClient(),
+): Promise<NoopL1Archiver> {
+  const instrumentation = await ArchiverInstrumentation.new(telemetry, () => dataStore.estimateSize());
+  return new NoopL1Archiver(dataStore, l1Constants, instrumentation);
+}