@aztec/archiver 0.0.1-commit.b655e406 → 0.0.1-commit.d3ec352c

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,4 +1,5 @@
 import type { L1BlockId } from '@aztec/ethereum';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
@@ -65,7 +66,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.db.transactionAsync(callback);
   }
 
-  public getBlockNumber(): Promise<number> {
+  public getBlockNumber(): Promise<BlockNumber> {
     return this.getSynchedL2BlockNumber();
   }
 
@@ -124,7 +125,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
   async addContractClasses(
     data: ContractClassPublic[],
     bytecodeCommitments: Fr[],
-    blockNumber: number,
+    blockNumber: BlockNumber,
   ): Promise<boolean> {
     return (
       await Promise.all(
@@ -133,7 +134,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     ).every(Boolean);
   }
 
-  async deleteContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
+  async deleteContractClasses(data: ContractClassPublic[], blockNumber: BlockNumber): Promise<boolean> {
     return (await Promise.all(data.map(c => this.#contractClassStore.deleteContractClasses(c, blockNumber)))).every(
       Boolean,
     );
@@ -151,13 +152,13 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, utilityFunctions);
   }
 
-  async addContractInstances(data: ContractInstanceWithAddress[], blockNumber: number): Promise<boolean> {
+  async addContractInstances(data: ContractInstanceWithAddress[], blockNumber: BlockNumber): Promise<boolean> {
     return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c, blockNumber)))).every(
       Boolean,
     );
   }
 
-  async deleteContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
+  async deleteContractInstances(data: ContractInstanceWithAddress[], _blockNumber: BlockNumber): Promise<boolean> {
     return (await Promise.all(data.map(c => this.#contractInstanceStore.deleteContractInstance(c)))).every(Boolean);
   }
 
@@ -196,11 +197,11 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * @param blocksToUnwind - The number of blocks we are to unwind
    * @returns True if the operation is successful
    */
-  unwindBlocks(from: number, blocksToUnwind: number): Promise<boolean> {
+  unwindBlocks(from: BlockNumber, blocksToUnwind: number): Promise<boolean> {
     return this.#blockStore.unwindBlocks(from, blocksToUnwind);
   }
 
-  getPublishedBlock(number: number): Promise<PublishedL2Block | undefined> {
+  getPublishedBlock(number: BlockNumber): Promise<PublishedL2Block | undefined> {
     return this.#blockStore.getBlock(number);
   }
 
@@ -219,7 +220,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  getPublishedBlocks(start: number, limit: number): Promise<PublishedL2Block[]> {
+  getPublishedBlocks(start: BlockNumber, limit: number): Promise<PublishedL2Block[]> {
     return toArray(this.#blockStore.getBlocks(start, limit));
   }
 
@@ -230,7 +231,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  getBlockHeaders(start: number, limit: number): Promise<BlockHeader[]> {
+  getBlockHeaders(start: BlockNumber, limit: number): Promise<BlockHeader[]> {
     return toArray(this.#blockStore.getBlockHeaders(start, limit));
   }
 
@@ -303,7 +304,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * @param blockNumber - L2 block number to get messages for.
    * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
    */
-  getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
+  getL1ToL2Messages(blockNumber: BlockNumber): Promise<Fr[]> {
     return this.#messageStore.getL1ToL2Messages(blockNumber);
   }
 
@@ -313,7 +314,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * @param limit - The maximum number of blocks to retrieve logs from.
    * @returns An array of private logs from the specified range of blocks.
    */
-  getPrivateLogs(from: number, limit: number): Promise<PrivateLog[]> {
+  getPrivateLogs(from: BlockNumber, limit: number): Promise<PrivateLog[]> {
     return this.#logStore.getPrivateLogs(from, limit);
   }
 
@@ -362,15 +363,15 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
    */
-  getSynchedL2BlockNumber(): Promise<number> {
+  getSynchedL2BlockNumber(): Promise<BlockNumber> {
     return this.#blockStore.getSynchedL2BlockNumber();
   }
 
-  getProvenL2BlockNumber(): Promise<number> {
+  getProvenL2BlockNumber(): Promise<BlockNumber> {
     return this.#blockStore.getProvenL2BlockNumber();
   }
 
-  async setProvenL2BlockNumber(blockNumber: number) {
+  async setProvenL2BlockNumber(blockNumber: BlockNumber) {
     await this.#blockStore.setProvenL2BlockNumber(blockNumber);
   }
 
@@ -400,7 +401,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.db.estimateSize();
   }
 
-  public rollbackL1ToL2MessagesToL2Block(targetBlockNumber: number): Promise<void> {
+  public rollbackL1ToL2MessagesToL2Block(targetBlockNumber: BlockNumber): Promise<void> {
     return this.#messageStore.rollbackL1ToL2MessagesToL2Block(targetBlockNumber);
   }
 

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,4 +1,5 @@
 import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
@@ -389,9 +390,9 @@ export class LogStore {
       const log = txLogs[logIndex];
       if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) {
         if (log instanceof ContractClassLog) {
-          results.push(new ExtendedContractClassLog(new LogId(blockNumber, txIndex, logIndex), log));
+          results.push(new ExtendedContractClassLog(new LogId(BlockNumber(blockNumber), txIndex, logIndex), log));
         } else {
-          results.push(new ExtendedPublicLog(new LogId(blockNumber, txIndex, logIndex), log));
+          results.push(new ExtendedPublicLog(new LogId(BlockNumber(blockNumber), txIndex, logIndex), log));
         }
 
         if (results.length >= this.#logsMaxPageSize) {

package/src/archiver/structs/inbox_message.ts

@@ -1,14 +1,15 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, bigintToUInt64BE, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { UInt32 } from '@aztec/stdlib/types';
 
 export type InboxMessage = {
   index: bigint;
   leaf: Fr;
-  l2BlockNumber: UInt32;
-  l1BlockNumber: bigint;
+  // TODO: should be checkpointNumber
+  l2BlockNumber: BlockNumber;
+  l1BlockNumber: bigint; // L1 block number - NOT Aztec L2
   l1BlockHash: Buffer32;
   rollingHash: Buffer16;
 };
@@ -35,7 +36,7 @@ export function deserializeInboxMessage(buffer: Buffer): InboxMessage {
   const leaf = reader.readObject(Fr);
   const l1BlockHash = reader.readObject(Buffer32);
   const l1BlockNumber = BigInt(reader.readNumber());
-  const l2BlockNumber = reader.readNumber();
+  const l2BlockNumber = BlockNumber(reader.readNumber());
   const rollingHash = reader.readObject(Buffer16);
   return { index, leaf, l1BlockHash, l1BlockNumber, l2BlockNumber, rollingHash };
 }

package/src/archiver/structs/published.ts

@@ -1 +1,2 @@
-export type { PublishedL2Block, L1PublishedData } from '@aztec/stdlib/block';
+export type { PublishedL2Block } from '@aztec/stdlib/block';
+export type { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';

package/src/archiver/validation.ts

@@ -1,60 +1,77 @@
 import type { EpochCache } from '@aztec/epoch-cache';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import type { Logger } from '@aztec/foundation/log';
 import {
-  type PublishedL2Block,
+  type AttestationInfo,
   type ValidateBlockNegativeResult,
   type ValidateBlockResult,
-  getAttestationInfoFromPublishedL2Block,
+  getAttestationInfoFromPayload,
 } from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { ConsensusPayload } from '@aztec/stdlib/p2p';
 
 export type { ValidateBlockResult };
 
 /**
- * Validates the attestations submitted for the given block.
+ * Extracts attestation information from a published checkpoint.
+ * Returns info for each attestation, preserving array indices.
+ */
+export function getAttestationInfoFromPublishedCheckpoint({
+  checkpoint,
+  attestations,
+}: PublishedCheckpoint): AttestationInfo[] {
+  const payload = ConsensusPayload.fromCheckpoint(checkpoint);
+  return getAttestationInfoFromPayload(payload, attestations);
+}
+
+/**
+ * Validates the attestations submitted for the given checkpoint.
  * Returns true if the attestations are valid and sufficient, false otherwise.
  */
-export async function validateBlockAttestations(
-  publishedBlock: PublishedL2Block,
+export async function validateCheckpointAttestations(
+  publishedCheckpoint: PublishedCheckpoint,
   epochCache: EpochCache,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
   logger?: Logger,
 ): Promise<ValidateBlockResult> {
-  const attestorInfos = getAttestationInfoFromPublishedL2Block(publishedBlock);
+  const attestorInfos = getAttestationInfoFromPublishedCheckpoint(publishedCheckpoint);
   const attestors = compactArray(attestorInfos.map(info => ('address' in info ? info.address : undefined)));
-  const { block } = publishedBlock;
-  const blockHash = await block.hash().then(hash => hash.toString());
-  const archiveRoot = block.archive.root.toString();
-  const slot = block.header.getSlot();
-  const epoch = getEpochAtSlot(slot, constants);
+  const { checkpoint, attestations } = publishedCheckpoint;
+  const headerHash = checkpoint.header.hash();
+  const archiveRoot = checkpoint.archive.root.toString();
+  const slot = checkpoint.header.slotNumber;
+  const epoch: EpochNumber = getEpochAtSlot(slot, constants);
   const { committee, seed } = await epochCache.getCommitteeForEpoch(epoch);
-  const logData = { blockNumber: block.number, slot, epoch, blockHash, archiveRoot };
+  const logData = { checkpointNumber: checkpoint.number, slot, epoch, headerHash, archiveRoot };
 
-  logger?.debug(`Validating attestations for block ${block.number} at slot ${slot} in epoch ${epoch}`, {
+  logger?.debug(`Validating attestations for checkpoint ${checkpoint.number} at slot ${slot} in epoch ${epoch}`, {
     committee: (committee ?? []).map(member => member.toString()),
     recoveredAttestors: attestorInfos,
-    postedAttestations: publishedBlock.attestations.map(a => (a.address.isZero() ? a.signature : a.address).toString()),
+    postedAttestations: attestations.map(a => (a.address.isZero() ? a.signature : a.address).toString()),
     ...logData,
   });
 
   if (!committee || committee.length === 0) {
-    logger?.warn(`No committee found for epoch ${epoch} at slot ${slot}. Accepting block without validation.`, logData);
+    logger?.warn(
+      `No committee found for epoch ${epoch} at slot ${slot}. Accepting checkpoint without validation.`,
+      logData,
+    );
     return { valid: true };
   }
 
-  const committeeSet = new Set(committee.map(member => member.toString()));
   const requiredAttestationCount = Math.floor((committee.length * 2) / 3) + 1;
 
   const failedValidationResult = <TReason extends ValidateBlockNegativeResult['reason']>(reason: TReason) => ({
     valid: false as const,
     reason,
-    block: publishedBlock.block.toBlockInfo(),
+    block: checkpoint.blocks[0].toBlockInfo(),
     committee,
     seed,
     epoch,
     attestors,
-    attestations: publishedBlock.attestations,
+    attestations,
   });
 
   for (let i = 0; i < attestorInfos.length; i++) {
@@ -70,15 +87,20 @@ export async function validateBlockAttestations(
       return { ...failedValidationResult('invalid-attestation'), invalidIndex: i };
     }
 
-    // Check if the attestor is in the committee
+    // Check if the attestor at this index matches the committee member at the same index
     if (info.status === 'recovered-from-signature' || info.status === 'provided-as-address') {
       const signer = info.address.toString();
-      if (!committeeSet.has(signer)) {
-        logger?.warn(`Attestation from non-committee member ${signer} at slot ${slot}`, {
-          committee,
-          invalidIndex: i,
-          ...logData,
-        });
+      const expectedCommitteeMember = committee[i]?.toString();
+
+      if (!expectedCommitteeMember || signer !== expectedCommitteeMember) {
+        logger?.warn(
+          `Attestation at index ${i} from ${signer} does not match expected committee member ${expectedCommitteeMember} at slot ${slot}`,
+          {
+            committee,
+            invalidIndex: i,
+            ...logData,
+          },
+        );
         return { ...failedValidationResult('invalid-attestation'), invalidIndex: i };
       }
     }
@@ -86,7 +108,7 @@ export async function validateBlockAttestations(
 
   const validAttestationCount = attestorInfos.filter(info => info.status === 'recovered-from-signature').length;
   if (validAttestationCount < requiredAttestationCount) {
-    logger?.warn(`Insufficient attestations for block at slot ${slot}`, {
+    logger?.warn(`Insufficient attestations for checkpoint at slot ${slot}`, {
       requiredAttestations: requiredAttestationCount,
       actualAttestations: validAttestationCount,
       ...logData,
@@ -94,6 +116,9 @@ export async function validateBlockAttestations(
     return failedValidationResult('insufficient-attestations');
   }
 
-  logger?.debug(`Block attestations validated successfully for block ${block.number} at slot ${slot}`, logData);
+  logger?.debug(
+    `Checkpoint attestations validated successfully for checkpoint ${checkpoint.number} at slot ${slot}`,
+    logData,
+  );
   return { valid: true };
 }

package/src/factory.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
@@ -59,7 +60,7 @@ async function registerProtocolContracts(store: KVArchiverDataStore) {
 
     await store.registerContractFunctionSignatures(publicFunctionSignatures);
     const bytecodeCommitment = await computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
-    await store.addContractClasses([contractClassPublic], [bytecodeCommitment], blockNumber);
-    await store.addContractInstances([contract.instance], blockNumber);
+    await store.addContractClasses([contractClassPublic], [bytecodeCommitment], BlockNumber(blockNumber));
+    await store.addContractInstances([contract.instance], BlockNumber(blockNumber));
   }
 }

package/src/index.ts

@@ -2,4 +2,4 @@ export * from './archiver/index.js';
 export * from './factory.js';
 export * from './rpc/index.js';
 
-export { retrieveBlocksFromRollup, retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';
+export { retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';

package/src/test/mock_archiver.ts

@@ -1,5 +1,7 @@
+import type { CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/fields';
-import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+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';
@@ -22,36 +24,45 @@ export class MockArchiver extends MockL2BlockSource implements L2BlockSource, L1
   getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined> {
     return this.messageSource.getL1ToL2MessageIndex(_l1ToL2Message);
   }
+
+  getL1ToL2MessagesForCheckpoint(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
+    // TODO: Implement this properly. This only works when we have one block per checkpoint.
+    return this.messageSource.getL1ToL2Messages(checkpointNumber);
+  }
 }
 
 /**
  * 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.blocks[0].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,3 +1,4 @@
+import { BlockNumber, type CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import type { L2Tips } from '@aztec/stdlib/block';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
@@ -18,6 +19,11 @@ export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
     this.blockNumber = blockNumber;
   }
 
+  getL1ToL2MessagesForCheckpoint(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
+    // TODO: Implement this properly. This only works when we have one block per checkpoint.
+    return this.getL1ToL2Messages(checkpointNumber);
+  }
+
   getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
     return Promise.resolve(this.messagesPerBlock.get(blockNumber) ?? []);
   }
@@ -26,13 +32,13 @@ export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
     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 tip = { number: BlockNumber(number), hash: new Fr(number).toString() };
     return Promise.resolve({
       latest: tip,
       proven: tip,

package/src/test/mock_l2_block_source.ts

@@ -1,5 +1,6 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -14,6 +15,7 @@ import {
   PublishedL2Block,
   type ValidateBlockResult,
 } from '@aztec/stdlib/block';
+import type { Checkpoint } 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';
@@ -33,7 +35,7 @@ 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 L2Block.random(blockNum);
+      const block = await L2Block.random(BlockNumber(blockNum));
       this.l2Blocks.push(block);
     }
 
@@ -82,11 +84,11 @@ 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));
   }
 
   /**
@@ -112,6 +114,16 @@ 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 =>
@@ -182,17 +194,22 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
   }
 
-  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
+  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 });
     const blocks = this.l2Blocks.filter(b => {
-      const slot = b.header.globalVariables.slotNumber.toBigInt();
+      const slot = b.header.globalVariables.slotNumber;
       return slot >= start && slot <= end;
     });
     return Promise.resolve(blocks);
   }
 
-  async getBlockHeadersForEpoch(epochNumber: bigint): Promise<BlockHeader[]> {
+  async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
     const blocks = await this.getBlocksForEpoch(epochNumber);
     return blocks.map(b => b.getBlockHeader());
   }
@@ -254,29 +271,29 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
 
     return {
       latest: {
-        number: latest,
+        number: BlockNumber(latest),
         hash: (await latestBlock?.hash())?.toString(),
       },
       proven: {
-        number: proven,
+        number: BlockNumber(proven),
         hash: (await provenBlock?.hash())?.toString(),
       },
       finalized: {
-        number: finalized,
+        number: BlockNumber(finalized),
         hash: (await finalizedBlock?.hash())?.toString(),
       },
     };
   }
 
-  getL2EpochNumber(): Promise<bigint> {
+  getL2EpochNumber(): Promise<EpochNumber> {
     throw new Error('Method not implemented.');
   }
 
-  getL2SlotNumber(): Promise<bigint> {
+  getL2SlotNumber(): Promise<SlotNumber> {
     throw new Error('Method not implemented.');
   }
 
-  isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+  isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
     throw new Error('Method not implemented.');
   }
 

package/src/test/mock_structs.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } 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';
@@ -19,7 +20,7 @@ export function makeInboxMessage(
   return {
     index,
     leaf,
-    l2BlockNumber,
+    l2BlockNumber: BlockNumber(l2BlockNumber),
     l1BlockNumber,
     l1BlockHash,
     rollingHash,
@@ -39,7 +40,7 @@ export function makeInboxMessages(
   let rollingHash = initialHash;
   for (let i = 0; i < count; i++) {
     const leaf = Fr.random();
-    const l2BlockNumber = i + initialL2BlockNumber;
+    const l2BlockNumber = BlockNumber(i + initialL2BlockNumber);
     const message = overrideFn(makeInboxMessage(rollingHash, { leaf, l2BlockNumber }), i);
     rollingHash = message.rollingHash;
     messages.push(message);