@aztec/archiver 0.0.1-commit.9593d84 → 0.0.1-commit.96bb3f7

package/src/test/fixtures/trace_transaction-randomRevert.json

@@ -0,0 +1,216 @@
+[
+  {
+    "action": {
+      "from": "0x28c6c06298d514db089934071355e5743bf21d60",
+      "callType": "call",
+      "gas": "0x5f1fc",
+      "input": "0x34fcd5be0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000120000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb000000000000000000000000a587116d5cf08e53bd75f3a0a434bf06671098590000000000000000000000000000000000000000000000000000000029a6d78000000000000000000000000000000000000000000000000000000000000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000009f863dfdb5df33fe5f87601b8d2f23c816d5fde8000000000000000000000000000000000000000000000000000000000b7ff86f00000000000000000000000000000000000000000000000000000000",
+      "to": "0xee7ae85f2fe2239e27d9c1e23fffe168d63b4055",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "result": {
+      "gasUsed": "0x15b9b",
+      "output": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001"
+    },
+    "subtraces": 1,
+    "traceAddress": [],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  },
+  {
+    "action": {
+      "from": "0xee7ae85f2fe2239e27d9c1e23fffe168d63b4055",
+      "callType": "delegatecall",
+      "gas": "0x5c75c",
+      "input": "0x34fcd5be0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000120000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb000000000000000000000000a587116d5cf08e53bd75f3a0a434bf06671098590000000000000000000000000000000000000000000000000000000029a6d78000000000000000000000000000000000000000000000000000000000000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000009f863dfdb5df33fe5f87601b8d2f23c816d5fde8000000000000000000000000000000000000000000000000000000000b7ff86f00000000000000000000000000000000000000000000000000000000",
+      "to": "0xd206ac7fef53d83ed4563e770b28dba90d0d9ec8",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "result": {
+      "gasUsed": "0x1483e",
+      "output": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001"
+    },
+    "subtraces": 4,
+    "traceAddress": [0],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  },
+  {
+    "action": {
+      "from": "0xee7ae85f2fe2239e27d9c1e23fffe168d63b4055",
+      "callType": "staticcall",
+      "gas": "0x7530",
+      "input": "0x01ffc9a701ffc9a700000000000000000000000000000000000000000000000000000000",
+      "to": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "error": "Reverted",
+    "result": {
+      "gasUsed": "0x1d64",
+      "output": "0x"
+    },
+    "subtraces": 1,
+    "traceAddress": [0, 0],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  },
+  {
+    "action": {
+      "from": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      "callType": "delegatecall",
+      "gas": "0x5783",
+      "input": "0x01ffc9a701ffc9a700000000000000000000000000000000000000000000000000000000",
+      "to": "0x43506849d7c04f9138d1a2050bbf3a0c054402dd",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "error": "Reverted",
+    "result": {
+      "gasUsed": "0xf0",
+      "output": "0x"
+    },
+    "subtraces": 0,
+    "traceAddress": [0, 0, 0],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  },
+  {
+    "action": {
+      "from": "0xee7ae85f2fe2239e27d9c1e23fffe168d63b4055",
+      "callType": "call",
+      "gas": "0x541ba",
+      "input": "0xa9059cbb000000000000000000000000a587116d5cf08e53bd75f3a0a434bf06671098590000000000000000000000000000000000000000000000000000000029a6d780",
+      "to": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "result": {
+      "gasUsed": "0x9ecc",
+      "output": "0x0000000000000000000000000000000000000000000000000000000000000001"
+    },
+    "subtraces": 1,
+    "traceAddress": [0, 1],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  },
+  {
+    "action": {
+      "from": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      "callType": "delegatecall",
+      "gas": "0x510d8",
+      "input": "0xa9059cbb000000000000000000000000a587116d5cf08e53bd75f3a0a434bf06671098590000000000000000000000000000000000000000000000000000000029a6d780",
+      "to": "0x43506849d7c04f9138d1a2050bbf3a0c054402dd",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "result": {
+      "gasUsed": "0x8253",
+      "output": "0x0000000000000000000000000000000000000000000000000000000000000001"
+    },
+    "subtraces": 0,
+    "traceAddress": [0, 1, 0],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  },
+  {
+    "action": {
+      "from": "0xee7ae85f2fe2239e27d9c1e23fffe168d63b4055",
+      "callType": "staticcall",
+      "gas": "0x7530",
+      "input": "0x01ffc9a701ffc9a700000000000000000000000000000000000000000000000000000000",
+      "to": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "error": "Reverted",
+    "result": {
+      "gasUsed": "0x400",
+      "output": "0x"
+    },
+    "subtraces": 1,
+    "traceAddress": [0, 2],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  },
+  {
+    "action": {
+      "from": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      "callType": "delegatecall",
+      "gas": "0x7081",
+      "input": "0x01ffc9a701ffc9a700000000000000000000000000000000000000000000000000000000",
+      "to": "0x43506849d7c04f9138d1a2050bbf3a0c054402dd",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "error": "Reverted",
+    "result": {
+      "gasUsed": "0xf0",
+      "output": "0x"
+    },
+    "subtraces": 0,
+    "traceAddress": [0, 2, 0],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  },
+  {
+    "action": {
+      "from": "0xee7ae85f2fe2239e27d9c1e23fffe168d63b4055",
+      "callType": "call",
+      "gas": "0x4997e",
+      "input": "0xa9059cbb0000000000000000000000009f863dfdb5df33fe5f87601b8d2f23c816d5fde8000000000000000000000000000000000000000000000000000000000b7ff86f",
+      "to": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "result": {
+      "gasUsed": "0x280c",
+      "output": "0x0000000000000000000000000000000000000000000000000000000000000001"
+    },
+    "subtraces": 1,
+    "traceAddress": [0, 3],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  },
+  {
+    "action": {
+      "from": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      "callType": "delegatecall",
+      "gas": "0x4843b",
+      "input": "0xa9059cbb0000000000000000000000009f863dfdb5df33fe5f87601b8d2f23c816d5fde8000000000000000000000000000000000000000000000000000000000b7ff86f",
+      "to": "0x43506849d7c04f9138d1a2050bbf3a0c054402dd",
+      "value": "0x0"
+    },
+    "blockHash": "0x5c463f21273435fbe71ab85a203ce4566e8f0d83deafcc757913ac2b5839367d",
+    "blockNumber": 23934803,
+    "result": {
+      "gasUsed": "0x24f7",
+      "output": "0x0000000000000000000000000000000000000000000000000000000000000001"
+    },
+    "subtraces": 0,
+    "traceAddress": [0, 3, 0],
+    "transactionHash": "0x622c1ca0d4c20a4d58f4111bf24cafa633318ededb24819ee3d977a73b1a1ff9",
+    "transactionPosition": 333,
+    "type": "call"
+  }
+]

package/src/test/mock_archiver.ts

@@ -1,5 +1,7 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { L2Block, type L2BlockSource } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 
 import { MockL1ToL2MessageSource } from './mock_l1_to_l2_message_source.js';
@@ -11,12 +13,12 @@ import { MockL2BlockSource } from './mock_l2_block_source.js';
 export class MockArchiver extends MockL2BlockSource implements L2BlockSource, L1ToL2MessageSource {
   private messageSource = new MockL1ToL2MessageSource(0);
 
-  public setL1ToL2Messages(blockNumber: number, msgs: Fr[]) {
-    this.messageSource.setL1ToL2Messages(blockNumber, msgs);
+  public setL1ToL2Messages(checkpointNumber: CheckpointNumber, msgs: Fr[]) {
+    this.messageSource.setL1ToL2Messages(checkpointNumber, msgs);
   }
 
-  getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
-    return this.messageSource.getL1ToL2Messages(blockNumber);
+  getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
+    return this.messageSource.getL1ToL2Messages(checkpointNumber);
   }
 
   getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined> {
@@ -28,30 +30,34 @@ export class MockArchiver extends MockL2BlockSource implements L2BlockSource, L1
  * A mocked implementation of the archiver with a set of precomputed blocks and messages.
  */
 export class MockPrefilledArchiver extends MockArchiver {
-  private precomputed: L2Block[];
+  private prefilled: Checkpoint[] = [];
 
-  constructor(precomputed: L2Block[], messages: Fr[][]) {
+  constructor(prefilled: { checkpoint: Checkpoint; messages: Fr[] }[]) {
     super();
-    this.precomputed = precomputed.slice();
-    messages.forEach((msgs, i) => this.setL1ToL2Messages(i + 1, msgs));
+    this.setPrefilled(prefilled);
   }
 
-  public setPrefilledBlocks(blocks: L2Block[], messages: Fr[][]) {
-    for (const block of blocks) {
-      this.precomputed[block.number - 1] = block;
+  public setPrefilled(prefilled: { checkpoint: Checkpoint; messages: Fr[] }[]) {
+    for (const { checkpoint, messages } of prefilled) {
+      this.prefilled[checkpoint.number - 1] = checkpoint;
+      if (checkpoint.blocks.length !== 1) {
+        throw new Error('Prefilled checkpoint must only have 1 block at the moment.');
+      }
+      this.setL1ToL2Messages(checkpoint.number, messages);
     }
-    messages.forEach((msgs, i) => this.setL1ToL2Messages(blocks[i].number, msgs));
   }
 
   public override createBlocks(numBlocks: number) {
-    if (this.l2Blocks.length + numBlocks > this.precomputed.length) {
+    const flattenedBlocks = this.prefilled.flatMap(c => c.blocks);
+    if (this.l2Blocks.length + numBlocks > flattenedBlocks.length) {
       throw new Error(
         `Not enough precomputed blocks to create ${numBlocks} more blocks (already at ${this.l2Blocks.length})`,
       );
     }
 
     const fromBlock = this.l2Blocks.length;
-    this.addBlocks(this.precomputed.slice(fromBlock, fromBlock + numBlocks));
+    // TODO: Add L2 blocks and checkpoints separately once archiver has the apis for that.
+    this.addBlocks(this.prefilled.slice(fromBlock, fromBlock + numBlocks).map(c => L2Block.fromCheckpoint(c)));
     return Promise.resolve();
   }
 }

package/src/test/mock_l1_to_l2_message_source.ts

@@ -1,40 +1,47 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { L2Tips } from '@aztec/stdlib/block';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { CheckpointId, L2BlockId, L2TipId, L2Tips } from '@aztec/stdlib/block';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 
 /**
  * A mocked implementation of L1ToL2MessageSource to be used in tests.
  */
 export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
-  private messagesPerBlock = new Map<number, Fr[]>();
+  private messagesPerCheckpoint = new Map<CheckpointNumber, Fr[]>();
 
   constructor(private blockNumber: number) {}
 
-  public setL1ToL2Messages(blockNumber: number, msgs: Fr[]) {
-    this.messagesPerBlock.set(blockNumber, msgs);
+  public setL1ToL2Messages(checkpointNumber: CheckpointNumber, msgs: Fr[]) {
+    this.messagesPerCheckpoint.set(checkpointNumber, msgs);
   }
 
   public setBlockNumber(blockNumber: number) {
     this.blockNumber = blockNumber;
   }
 
-  getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
-    return Promise.resolve(this.messagesPerBlock.get(blockNumber) ?? []);
+  getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
+    return Promise.resolve(this.messagesPerCheckpoint.get(checkpointNumber) ?? []);
   }
 
   getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined> {
     throw new Error('Method not implemented.');
   }
 
-  getBlockNumber(): Promise<number> {
-    return Promise.resolve(this.blockNumber);
+  getBlockNumber() {
+    return Promise.resolve(BlockNumber(this.blockNumber));
   }
 
   getL2Tips(): Promise<L2Tips> {
     const number = this.blockNumber;
-    const tip = { number, hash: new Fr(number).toString() };
+    const blockId: L2BlockId = { number: BlockNumber(number), hash: new Fr(number).toString() };
+    const checkpointId: CheckpointId = {
+      number: CheckpointNumber(number),
+      hash: new Fr(number + 1).toString(),
+    };
+    const tip: L2TipId = { block: blockId, checkpoint: checkpointId };
     return Promise.resolve({
-      latest: tip,
+      proposed: blockId,
+      checkpointed: tip,
       proven: tip,
       finalized: tip,
     });

package/src/test/mock_l2_block_source.ts

@@ -1,20 +1,23 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import { DefaultL1ContractsConfig } from '@aztec/ethereum';
-import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
+  CheckpointedL2Block,
   L2Block,
   L2BlockHash,
+  L2BlockNew,
   type L2BlockSource,
   type L2Tips,
   PublishedL2Block,
-  type ValidateBlockResult,
+  type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
+import { type Checkpoint, L1PublishedData } 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';
@@ -28,13 +31,14 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
 
   private provenBlockNumber: number = 0;
   private finalizedBlockNumber: number = 0;
+  private checkpointedBlockNumber: number = 0;
 
   private log = createLogger('archiver:mock_l2_block_source');
 
   public async createBlocks(numBlocks: number) {
     for (let i = 0; i < numBlocks; i++) {
       const blockNum = this.l2Blocks.length + 1;
-      const block = await L2Block.random(blockNum);
+      const block = await L2Block.random(BlockNumber(blockNum));
       this.l2Blocks.push(block);
     }
 
@@ -62,6 +66,10 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     this.finalizedBlockNumber = finalizedBlockNumber;
   }
 
+  public setCheckpointedBlockNumber(checkpointedBlockNumber: number) {
+    this.checkpointedBlockNumber = checkpointedBlockNumber;
+  }
+
   /**
    * Method to fetch the rollup contract address at the base-layer.
    * @returns The rollup address.
@@ -83,11 +91,47 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @returns In this mock instance, returns the number of L2 blocks that we've mocked.
    */
   public getBlockNumber() {
-    return Promise.resolve(this.l2Blocks.length);
+    return Promise.resolve(BlockNumber(this.l2Blocks.length));
   }
 
-  public getProvenBlockNumber(): Promise<number> {
-    return Promise.resolve(this.provenBlockNumber);
+  public getProvenBlockNumber() {
+    return Promise.resolve(BlockNumber(this.provenBlockNumber));
+  }
+
+  public getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
+    if (number > this.checkpointedBlockNumber) {
+      return Promise.resolve(undefined);
+    }
+    const block = this.l2Blocks[number - 1];
+    if (!block) {
+      return Promise.resolve(undefined);
+    }
+    const checkpointedBlock = new CheckpointedL2Block(
+      CheckpointNumber(number),
+      block.toL2Block(),
+      new L1PublishedData(BigInt(number), BigInt(number), `0x${number.toString(16).padStart(64, '0')}`),
+      [],
+    );
+    return Promise.resolve(checkpointedBlock);
+  }
+
+  public async getCheckpointedBlocks(
+    from: BlockNumber,
+    limit: number,
+    _proven?: boolean,
+  ): Promise<CheckpointedL2Block[]> {
+    const result: CheckpointedL2Block[] = [];
+    for (let i = 0; i < limit; i++) {
+      const blockNum = from + i;
+      if (blockNum > this.checkpointedBlockNumber) {
+        break;
+      }
+      const block = await this.getCheckpointedBlock(BlockNumber(blockNum));
+      if (block) {
+        result.push(block);
+      }
+    }
+    return result;
   }
 
   /**
@@ -99,6 +143,16 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(this.l2Blocks[number - 1]);
   }
 
+  /**
+   * Gets an L2 block (new format).
+   * @param number - The block number to return.
+   * @returns The requested L2 block.
+   */
+  public getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined> {
+    const block = this.l2Blocks[number - 1];
+    return Promise.resolve(block?.toL2Block());
+  }
+
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
@@ -113,32 +167,39 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     );
   }
 
+  public async getPublishedCheckpoints(from: CheckpointNumber, limit: number) {
+    // TODO: Implement this properly. This only works when we have one block per checkpoint.
+    return (await this.getPublishedBlocks(from, limit)).map(block => block.toPublishedCheckpoint());
+  }
+
+  public async getCheckpointByArchive(archive: Fr): Promise<Checkpoint | undefined> {
+    // TODO: Implement this properly. This only works when we have one block per checkpoint.
+    return (await this.getPublishedBlockByArchive(archive))?.block.toCheckpoint();
+  }
+
   public async getPublishedBlocks(from: number, limit: number, proven?: boolean) {
     const blocks = await this.getBlocks(from, limit, proven);
     return blocks.map(block =>
       PublishedL2Block.fromFields({
         block,
-        l1: {
-          blockNumber: BigInt(block.number),
-          blockHash: Buffer32.random().toString(),
-          timestamp: BigInt(block.number),
-        },
+        l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
         attestations: [],
       }),
     );
   }
 
+  async getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
+    const blocks = await this.getBlocks(from, limit, proven);
+    return blocks.map(x => x.toL2Block());
+  }
+
   public async getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
     for (const block of this.l2Blocks) {
       const hash = await block.hash();
       if (hash.equals(blockHash)) {
         return PublishedL2Block.fromFields({
           block,
-          l1: {
-            blockNumber: BigInt(block.number),
-            blockHash: Buffer32.random().toString(),
-            timestamp: BigInt(block.number),
-          },
+          l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
           attestations: [],
         });
       }
@@ -154,11 +215,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(
       PublishedL2Block.fromFields({
         block,
-        l1: {
-          blockNumber: BigInt(block.number),
-          blockHash: Buffer32.random().toString(),
-          timestamp: BigInt(block.number),
-        },
+        l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
         attestations: [],
       }),
     );
@@ -183,6 +240,11 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
   }
 
+  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]> {
+    // TODO: Implement this properly. This only works when we have one block per checkpoint.
+    return this.getBlocksForEpoch(epochNumber).then(blocks => blocks.map(b => b.toCheckpoint()));
+  }
+
   getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]> {
     const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
     const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
@@ -243,29 +305,45 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   }
 
   async getL2Tips(): Promise<L2Tips> {
-    const [latest, proven, finalized] = [
+    const [latest, proven, finalized, checkpointed] = [
       await this.getBlockNumber(),
       await this.getProvenBlockNumber(),
       this.finalizedBlockNumber,
+      this.checkpointedBlockNumber,
     ] as const;
 
     const latestBlock = this.l2Blocks[latest - 1];
     const provenBlock = this.l2Blocks[proven - 1];
     const finalizedBlock = this.l2Blocks[finalized - 1];
+    const checkpointedBlock = this.l2Blocks[checkpointed - 1];
+
+    const latestBlockId = {
+      number: BlockNumber(latest),
+      hash: (await latestBlock?.hash())?.toString(),
+    };
+    const provenBlockId = {
+      number: BlockNumber(proven),
+      hash: (await provenBlock?.hash())?.toString(),
+    };
+    const finalizedBlockId = {
+      number: BlockNumber(finalized),
+      hash: (await finalizedBlock?.hash())?.toString(),
+    };
+    const checkpointedBlockId = {
+      number: BlockNumber(checkpointed),
+      hash: (await checkpointedBlock?.hash())?.toString(),
+    };
+
+    const makeTipId = (blockId: typeof latestBlockId) => ({
+      block: blockId,
+      checkpoint: { number: CheckpointNumber(blockId.number), hash: blockId.hash },
+    });
 
     return {
-      latest: {
-        number: latest,
-        hash: (await latestBlock?.hash())?.toString(),
-      },
-      proven: {
-        number: proven,
-        hash: (await provenBlock?.hash())?.toString(),
-      },
-      finalized: {
-        number: finalized,
-        hash: (await finalizedBlock?.hash())?.toString(),
-      },
+      proposed: latestBlockId,
+      checkpointed: makeTipId(checkpointedBlockId),
+      proven: makeTipId(provenBlockId),
+      finalized: makeTipId(finalizedBlockId),
     };
   }
 
@@ -343,7 +421,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(false);
   }
 
-  getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
+  getPendingChainValidationStatus(): Promise<ValidateCheckpointResult> {
     return Promise.resolve({ valid: true });
   }
 }

package/src/test/mock_structs.ts

@@ -1,6 +1,7 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import { randomBigInt, randomInt } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { randomBigInt, randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
 
 import { type InboxMessage, updateRollingHash } from '../archiver/structs/inbox_message.js';
@@ -9,17 +10,17 @@ export function makeInboxMessage(
   previousRollingHash = Buffer16.ZERO,
   overrides: Partial<InboxMessage> = {},
 ): InboxMessage {
-  const { l2BlockNumber = randomInt(100) + 1 } = overrides;
+  const { checkpointNumber = CheckpointNumber(randomInt(100) + 1) } = overrides;
   const { l1BlockNumber = randomBigInt(100n) + 1n } = overrides;
   const { l1BlockHash = Buffer32.random() } = overrides;
   const { leaf = Fr.random() } = overrides;
   const { rollingHash = updateRollingHash(previousRollingHash, leaf) } = overrides;
-  const { index = InboxLeaf.smallestIndexFromL2Block(l2BlockNumber) } = overrides;
+  const { index = InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) } = overrides;
 
   return {
     index,
     leaf,
-    l2BlockNumber,
+    checkpointNumber,
     l1BlockNumber,
     l1BlockHash,
     rollingHash,
@@ -30,17 +31,17 @@ export function makeInboxMessages(
   count: number,
   opts: {
     initialHash?: Buffer16;
-    initialL2BlockNumber?: number;
+    initialCheckpointNumber?: CheckpointNumber;
     overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
   } = {},
 ): InboxMessage[] {
-  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialL2BlockNumber = 1 } = opts;
+  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialCheckpointNumber = 1 } = opts;
   const messages: InboxMessage[] = [];
   let rollingHash = initialHash;
   for (let i = 0; i < count; i++) {
     const leaf = Fr.random();
-    const l2BlockNumber = i + initialL2BlockNumber;
-    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, l2BlockNumber }), i);
+    const checkpointNumber = CheckpointNumber(i + initialCheckpointNumber);
+    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, checkpointNumber }), i);
     rollingHash = message.rollingHash;
     messages.push(message);
   }