@aztec/world-state 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,19 +1,19 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM, INITIAL_L2_CHECKPOINT_NUM } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { elapsed } from '@aztec/foundation/timer';
-import { MerkleTreeCalculator } from '@aztec/foundation/trees';
-import { SHA256Trunc } from '@aztec/merkle-tree';
-import type {
-  L2Block,
-  L2BlockId,
-  L2BlockSource,
+import {
+  GENESIS_CHECKPOINT_HEADER_HASH,
+  type L2Block,
+  type L2BlockId,
+  type L2BlockSource,
   L2BlockStream,
-  L2BlockStreamEvent,
-  L2BlockStreamEventHandler,
-  L2BlockStreamLocalDataProvider,
-  L2Tips,
+  type L2BlockStreamEvent,
+  type L2BlockStreamEventHandler,
+  type L2BlockStreamLocalDataProvider,
+  type L2Tips,
 } from '@aztec/stdlib/block';
 import {
   WorldStateRunningState,
@@ -22,14 +22,18 @@ import {
   type WorldStateSynchronizerStatus,
 } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { SnapshotDataKeys } from '@aztec/stdlib/snapshots';
 import type { L2BlockHandledStats } from '@aztec/stdlib/stats';
 import { MerkleTreeId, type MerkleTreeReadOperations, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
-import { TraceableL2BlockStream, getTelemetryClient } from '@aztec/telemetry-client';
+import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
 import type { WorldStateStatusFull } from '../native/message.js';
 import type { MerkleTreeAdminDatabase } from '../world-state-db/merkle_tree_db.js';
 import type { WorldStateConfig } from './config.js';
+import { WorldStateSynchronizerError } from './errors.js';
+
+export type { SnapshotDataKeys };
 
 /**
  * Synchronizes the world state with the L2 blocks from a L2BlockSource via a block stream.
@@ -41,20 +45,23 @@ export class ServerWorldStateSynchronizer
 {
   private readonly merkleTreeCommitted: MerkleTreeReadOperations;
 
-  private latestBlockNumberAtStart = 0;
+  private latestBlockNumberAtStart = BlockNumber.ZERO;
   private historyToKeep: number | undefined;
   private currentState: WorldStateRunningState = WorldStateRunningState.IDLE;
-  private latestBlockHashQuery: { blockNumber: number; hash: string | undefined } | undefined = undefined;
 
   private syncPromise = promiseWithResolvers<void>();
   protected blockStream: L2BlockStream | undefined;
 
+  // WorldState doesn't track the proven block number, it only tracks the latest tips of the pending chain and the finalized chain
+  // store the proven block number here, in the synchronizer, so that we don't end up spamming the logs with 'chain-proved' events
+  private provenBlockNumber: BlockNumber | undefined;
+
   constructor(
     private readonly merkleTreeDb: MerkleTreeAdminDatabase,
     private readonly l2BlockSource: L2BlockSource & L1ToL2MessageSource,
     private readonly config: WorldStateConfig,
     private instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
-    private readonly log = createLogger('world_state'),
+    private readonly log: Logger = createLogger('world_state'),
   ) {
     this.merkleTreeCommitted = this.merkleTreeDb.getCommitted();
     this.historyToKeep = config.worldStateBlockHistory < 1 ? undefined : config.worldStateBlockHistory;
@@ -69,12 +76,20 @@ export class ServerWorldStateSynchronizer
     return this.merkleTreeDb.getCommitted();
   }
 
-  public getSnapshot(blockNumber: number): MerkleTreeReadOperations {
+  public getSnapshot(blockNumber: BlockNumber): MerkleTreeReadOperations {
     return this.merkleTreeDb.getSnapshot(blockNumber);
   }
 
-  public fork(blockNumber?: number): Promise<MerkleTreeWriteOperations> {
-    return this.merkleTreeDb.fork(blockNumber);
+  public fork(blockNumber?: BlockNumber, opts?: { closeDelayMs?: number }): Promise<MerkleTreeWriteOperations> {
+    return this.merkleTreeDb.fork(blockNumber, opts);
+  }
+
+  public backupTo(dstPath: string, compact?: boolean): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>> {
+    return this.merkleTreeDb.backupTo(dstPath, compact);
+  }
+
+  public clear(): Promise<void> {
+    return this.merkleTreeDb.clear();
   }
 
   public async start() {
@@ -86,9 +101,7 @@ export class ServerWorldStateSynchronizer
     }
 
     // Get the current latest block number
-    this.latestBlockNumberAtStart = await (this.config.worldStateProvenBlocksOnly
-      ? this.l2BlockSource.getProvenBlockNumber()
-      : this.l2BlockSource.getBlockNumber());
+    this.latestBlockNumberAtStart = BlockNumber(await this.l2BlockSource.getBlockNumber());
 
     const blockToDownloadFrom = (await this.getLatestBlockNumber()) + 1;
 
@@ -110,12 +123,11 @@ export class ServerWorldStateSynchronizer
   }
 
   protected createBlockStream(): L2BlockStream {
-    const tracer = this.instrumentation.telemetry.getTracer('WorldStateL2BlockStream');
     const logger = createLogger('world-state:block_stream');
-    return new TraceableL2BlockStream(this.l2BlockSource, this, this, tracer, 'WorldStateL2BlockStream', logger, {
-      proven: this.config.worldStateProvenBlocksOnly,
+    return new L2BlockStream(this.l2BlockSource, this, this, logger, {
       pollIntervalMS: this.config.worldStateBlockCheckIntervalMS,
       batchSize: this.config.worldStateBlockRequestBatchSize,
+      ignoreCheckpoints: true,
     });
   }
 
@@ -131,10 +143,10 @@ export class ServerWorldStateSynchronizer
   public async status(): Promise<WorldStateSynchronizerStatus> {
     const summary = await this.merkleTreeDb.getStatusSummary();
     const status: WorldStateSyncStatus = {
-      latestBlockNumber: Number(summary.unfinalisedBlockNumber),
-      latestBlockHash: (await this.getL2BlockHash(Number(summary.unfinalisedBlockNumber))) ?? '',
-      finalisedBlockNumber: Number(summary.finalisedBlockNumber),
-      oldestHistoricBlockNumber: Number(summary.oldestHistoricalBlock),
+      latestBlockNumber: summary.unfinalizedBlockNumber,
+      latestBlockHash: (await this.getL2BlockHash(summary.unfinalizedBlockNumber)) ?? '',
+      finalizedBlockNumber: summary.finalizedBlockNumber,
+      oldestHistoricBlockNumber: summary.oldestHistoricalBlock,
       treesAreSynched: summary.treesAreSynched,
     };
     return {
@@ -144,19 +156,42 @@ export class ServerWorldStateSynchronizer
   }
 
   public async getLatestBlockNumber() {
-    return (await this.getL2Tips()).latest.number;
+    return (await this.getL2Tips()).proposed.number;
+  }
+
+  public async stopSync() {
+    this.log.debug('Stopping sync...');
+    await this.blockStream?.stop();
+    this.log.info('Stopped sync');
+  }
+
+  public resumeSync() {
+    if (!this.blockStream) {
+      throw new Error('Cannot resume sync as block stream is not initialized');
+    }
+    this.log.debug('Resuming sync...');
+    this.blockStream.start();
+    this.log.info('Resumed sync');
   }
 
   /**
    * Forces an immediate sync.
-   * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it. Throws if cannot be reached.
+   * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
+   * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
    * @returns A promise that resolves with the block number the world state was synced to
    */
-  public async syncImmediate(targetBlockNumber?: number): Promise<number> {
-    if (this.currentState !== WorldStateRunningState.RUNNING || this.blockStream === undefined) {
+  public async syncImmediate(
+    targetBlockNumber?: BlockNumber,
+    skipThrowIfTargetNotReached?: boolean,
+  ): Promise<BlockNumber> {
+    if (this.currentState !== WorldStateRunningState.RUNNING) {
       throw new Error(`World State is not running. Unable to perform sync.`);
     }
 
+    if (this.blockStream === undefined) {
+      throw new Error('Block stream is not initialized. Unable to perform sync.');
+    }
+
     // If we have been given a block number to sync to and we have reached that number then return
     const currentBlockNumber = await this.getLatestBlockNumber();
     if (targetBlockNumber !== undefined && targetBlockNumber <= currentBlockNumber) {
@@ -164,66 +199,98 @@ export class ServerWorldStateSynchronizer
     }
     this.log.debug(`World State at ${currentBlockNumber} told to sync to ${targetBlockNumber ?? 'latest'}`);
 
+    // If the archiver is behind the target block, force an archiver sync
+    if (targetBlockNumber) {
+      const archiverLatestBlock = BlockNumber(await this.l2BlockSource.getBlockNumber());
+      if (archiverLatestBlock < targetBlockNumber) {
+        this.log.debug(`Archiver is at ${archiverLatestBlock} behind target block ${targetBlockNumber}.`);
+        await this.l2BlockSource.syncImmediate();
+      }
+    }
+
     // Force the block stream to sync against the archiver now
     await this.blockStream.sync();
 
     // If we have been given a block number to sync to and we have not reached that number then fail
     const updatedBlockNumber = await this.getLatestBlockNumber();
-    if (targetBlockNumber !== undefined && targetBlockNumber > updatedBlockNumber) {
-      throw new Error(`Unable to sync to block number ${targetBlockNumber} (last synced is ${updatedBlockNumber})`);
+    if (!skipThrowIfTargetNotReached && targetBlockNumber !== undefined && targetBlockNumber > updatedBlockNumber) {
+      throw new WorldStateSynchronizerError(
+        `Unable to sync to block number ${targetBlockNumber} (last synced is ${updatedBlockNumber})`,
+        {
+          cause: {
+            reason: 'block_not_available',
+            previousBlockNumber: currentBlockNumber,
+            updatedBlockNumber,
+            targetBlockNumber,
+          },
+        },
+      );
     }
 
     return updatedBlockNumber;
   }
 
   /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */
-  public async getL2BlockHash(number: number): Promise<string | undefined> {
-    if (number === 0) {
+  public async getL2BlockHash(number: BlockNumber): Promise<string | undefined> {
+    if (number === BlockNumber.ZERO) {
       return (await this.merkleTreeCommitted.getInitialHeader().hash()).toString();
     }
-    if (this.latestBlockHashQuery?.hash === undefined || number !== this.latestBlockHashQuery.blockNumber) {
-      this.latestBlockHashQuery = {
-        hash: await this.merkleTreeCommitted
-          .getLeafValue(MerkleTreeId.ARCHIVE, BigInt(number))
-          .then(leaf => leaf?.toString()),
-        blockNumber: number,
-      };
-    }
-    return this.latestBlockHashQuery.hash;
+    return this.merkleTreeCommitted.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(number)).then(leaf => leaf?.toString());
   }
 
   /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */
   public async getL2Tips(): Promise<L2Tips> {
     const status = await this.merkleTreeDb.getStatusSummary();
-    const unfinalisedBlockHash = await this.getL2BlockHash(Number(status.unfinalisedBlockNumber));
-    const latestBlockId: L2BlockId = { number: Number(status.unfinalisedBlockNumber), hash: unfinalisedBlockHash! };
-
+    const unfinalizedBlockHashPromise = this.getL2BlockHash(status.unfinalizedBlockNumber);
+    const finalizedBlockHashPromise = this.getL2BlockHash(status.finalizedBlockNumber);
+
+    const provenBlockNumber = this.provenBlockNumber ?? status.finalizedBlockNumber;
+    const provenBlockHashPromise =
+      this.provenBlockNumber === undefined ? finalizedBlockHashPromise : this.getL2BlockHash(this.provenBlockNumber);
+
+    const [unfinalizedBlockHash, finalizedBlockHash, provenBlockHash] = await Promise.all([
+      unfinalizedBlockHashPromise,
+      finalizedBlockHashPromise,
+      provenBlockHashPromise,
+    ]);
+    const latestBlockId: L2BlockId = { number: status.unfinalizedBlockNumber, hash: unfinalizedBlockHash! };
+
+    // World state doesn't track checkpointed blocks or checkpoints themselves.
+    // but we use a block stream so we need to provide 'local' L2Tips.
+    // We configure the block stream to ignore checkpoints and set checkpoint values to genesis here.
+    const genesisCheckpointHeaderHash = GENESIS_CHECKPOINT_HEADER_HASH.toString();
     return {
-      latest: latestBlockId,
-      finalized: { number: Number(status.finalisedBlockNumber), hash: '' },
-      proven: { number: Number(status.finalisedBlockNumber), hash: '' }, // TODO(palla/reorg): Using finalised as proven for now
+      proposed: latestBlockId,
+      checkpointed: {
+        block: { number: INITIAL_L2_BLOCK_NUM, hash: GENESIS_BLOCK_HEADER_HASH.toString() },
+        checkpoint: { number: INITIAL_L2_CHECKPOINT_NUM, hash: genesisCheckpointHeaderHash },
+      },
+      finalized: {
+        block: { number: status.finalizedBlockNumber, hash: finalizedBlockHash ?? '' },
+        checkpoint: { number: INITIAL_L2_CHECKPOINT_NUM, hash: genesisCheckpointHeaderHash },
+      },
+      proven: {
+        block: { number: provenBlockNumber, hash: provenBlockHash ?? '' },
+        checkpoint: { number: INITIAL_L2_CHECKPOINT_NUM, hash: genesisCheckpointHeaderHash },
+      },
     };
   }
 
   /** Handles an event emitted by the block stream. */
   public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
-    try {
-      switch (event.type) {
-        case 'blocks-added':
-          await this.handleL2Blocks(event.blocks);
-          break;
-        case 'chain-pruned':
-          await this.handleChainPruned(event.blockNumber);
-          break;
-        case 'chain-proven':
-          await this.handleChainProven(event.blockNumber);
-          break;
-        case 'chain-finalized':
-          await this.handleChainFinalized(event.blockNumber);
-          break;
-      }
-    } catch (err) {
-      this.log.error('Error processing block stream', err);
+    switch (event.type) {
+      case 'blocks-added':
+        await this.handleL2Blocks(event.blocks);
+        break;
+      case 'chain-pruned':
+        await this.handleChainPruned(event.block.number);
+        break;
+      case 'chain-proven':
+        await this.handleChainProven(event.block.number);
+        break;
+      case 'chain-finalized':
+        await this.handleChainFinalized(event.block.number);
+        break;
     }
   }
 
@@ -233,21 +300,31 @@ export class ServerWorldStateSynchronizer
    * @returns Whether the block handled was produced by this same node.
    */
   private async handleL2Blocks(l2Blocks: L2Block[]) {
-    this.log.trace(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1)!.number}`);
+    this.log.debug(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1)!.number}`);
+
+    // Fetch the L1->L2 messages for the first block in a checkpoint.
+    const messagesForBlocks = new Map<BlockNumber, Fr[]>();
+    await Promise.all(
+      l2Blocks
+        .filter(b => b.indexWithinCheckpoint === 0)
+        .map(async block => {
+          const l1ToL2Messages = await this.l2BlockSource.getL1ToL2Messages(block.checkpointNumber);
+          messagesForBlocks.set(block.number, l1ToL2Messages);
+        }),
+    );
 
-    const messagePromises = l2Blocks.map(block => this.l2BlockSource.getL1ToL2Messages(BigInt(block.number)));
-    const l1ToL2Messages: Fr[][] = await Promise.all(messagePromises);
     let updateStatus: WorldStateStatusFull | undefined = undefined;
-
-    for (let i = 0; i < l2Blocks.length; i++) {
-      const [duration, result] = await elapsed(() => this.handleL2Block(l2Blocks[i], l1ToL2Messages[i]));
-      this.log.verbose(`World state updated with L2 block ${l2Blocks[i].number}`, {
+    for (const block of l2Blocks) {
+      const [duration, result] = await elapsed(() =>
+        this.handleL2Block(block, messagesForBlocks.get(block.number) ?? []),
+      );
+      this.log.info(`World state updated with L2 block ${block.number}`, {
         eventName: 'l2-block-handled',
         duration,
-        unfinalisedBlockNumber: result.summary.unfinalisedBlockNumber,
-        finalisedBlockNumber: result.summary.finalisedBlockNumber,
-        oldestHistoricBlock: result.summary.oldestHistoricalBlock,
-        ...l2Blocks[i].getStats(),
+        unfinalizedBlockNumber: BigInt(result.summary.unfinalizedBlockNumber),
+        finalizedBlockNumber: BigInt(result.summary.finalizedBlockNumber),
+        oldestHistoricBlock: BigInt(result.summary.oldestHistoricalBlock),
+        ...block.getStats(),
       } satisfies L2BlockHandledStats);
       updateStatus = result;
     }
@@ -264,17 +341,12 @@ export class ServerWorldStateSynchronizer
    * @returns Whether the block handled was produced by this same node.
    */
   private async handleL2Block(l2Block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull> {
-    // First we check that the L1 to L2 messages hash to the block inHash.
-    // Note that we cannot optimize this check by checking the root of the subtree after inserting the messages
-    // to the real L1_TO_L2_MESSAGE_TREE (like we do in merkleTreeDb.handleL2BlockAndMessages(...)) because that
-    // tree uses pedersen and we don't have access to the converted root.
-    await this.verifyMessagesHashToInHash(l1ToL2Messages, l2Block.header.contentCommitment.inHash);
-
-    // If the above check succeeds, we can proceed to handle the block.
-    this.log.trace(`Pushing L2 block ${l2Block.number} to merkle tree db `, {
+    this.log.debug(`Pushing L2 block ${l2Block.number} to merkle tree db `, {
       blockNumber: l2Block.number,
       blockHash: await l2Block.hash().then(h => h.toString()),
       l1ToL2Messages: l1ToL2Messages.map(msg => msg.toString()),
+      blockHeader: l2Block.header.toInspect(),
+      blockStats: l2Block.getStats(),
     });
     const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
 
@@ -286,30 +358,31 @@ export class ServerWorldStateSynchronizer
     return result;
   }
 
-  private async handleChainFinalized(blockNumber: number) {
+  private async handleChainFinalized(blockNumber: BlockNumber) {
     this.log.verbose(`Finalized chain is now at block ${blockNumber}`);
-    const summary = await this.merkleTreeDb.setFinalised(BigInt(blockNumber));
+    const summary = await this.merkleTreeDb.setFinalized(blockNumber);
     if (this.historyToKeep === undefined) {
       return;
     }
-    const newHistoricBlock = summary.finalisedBlockNumber - BigInt(this.historyToKeep) + 1n;
+    const newHistoricBlock = summary.finalizedBlockNumber - this.historyToKeep + 1;
     if (newHistoricBlock <= 1) {
       return;
     }
     this.log.verbose(`Pruning historic blocks to ${newHistoricBlock}`);
-    const status = await this.merkleTreeDb.removeHistoricalBlocks(newHistoricBlock);
+    const status = await this.merkleTreeDb.removeHistoricalBlocks(BlockNumber(newHistoricBlock));
     this.log.debug(`World state summary `, status.summary);
   }
 
-  private handleChainProven(blockNumber: number) {
+  private handleChainProven(blockNumber: BlockNumber) {
+    this.provenBlockNumber = blockNumber;
     this.log.debug(`Proven chain is now at block ${blockNumber}`);
     return Promise.resolve();
   }
 
-  private async handleChainPruned(blockNumber: number) {
+  private async handleChainPruned(blockNumber: BlockNumber) {
     this.log.warn(`Chain pruned to block ${blockNumber}`);
-    const status = await this.merkleTreeDb.unwindBlocks(BigInt(blockNumber));
-    this.latestBlockHashQuery = undefined;
+    const status = await this.merkleTreeDb.unwindBlocks(blockNumber);
+    this.provenBlockNumber = undefined;
     this.instrumentation.updateWorldStateMetrics(status);
   }
 
@@ -321,24 +394,4 @@ export class ServerWorldStateSynchronizer
     this.currentState = newState;
     this.log.debug(`Moved to state ${WorldStateRunningState[this.currentState]}`);
   }
-
-  /**
-   * Verifies that the L1 to L2 messages hash to the block inHash.
-   * @param l1ToL2Messages - The L1 to L2 messages for the block.
-   * @param inHash - The inHash of the block.
-   * @throws If the L1 to L2 messages do not hash to the block inHash.
-   */
-  protected async verifyMessagesHashToInHash(l1ToL2Messages: Fr[], inHash: Buffer) {
-    const treeCalculator = await MerkleTreeCalculator.create(
-      L1_TO_L2_MSG_SUBTREE_HEIGHT,
-      Buffer.alloc(32),
-      (lhs, rhs) => Promise.resolve(new SHA256Trunc().hash(lhs, rhs)),
-    );
-
-    const root = await treeCalculator.computeTreeRoot(l1ToL2Messages.map(msg => msg.toBuffer()));
-
-    if (!root.equals(inHash)) {
-      throw new Error('Obtained L1 to L2 messages failed to be hashed to the block inHash');
-    }
-  }
 }

package/src/test/utils.ts

@@ -4,107 +4,100 @@ import {
   NULLIFIER_SUBTREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
 } from '@aztec/constants';
+import { asyncMap } from '@aztec/foundation/async-map';
+import { BlockNumber, type CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { L2Block } from '@aztec/stdlib/block';
-import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import type {
+  IndexedTreeId,
+  MerkleTreeReadOperations,
+  MerkleTreeWriteOperations,
+} from '@aztec/stdlib/interfaces/server';
+import { mockCheckpointAndMessages, mockL1ToL2Messages } from '@aztec/stdlib/testing';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { NativeWorldStateService } from '../native/native_world_state.js';
 
-export async function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations) {
-  const l2Block = await L2Block.random(blockNum, size);
-  const l1ToL2Messages = Array(16).fill(0).map(Fr.random);
-
-  // Sync the append only trees
-  {
-    const noteHashesPadded = l2Block.body.txEffects.flatMap(txEffect =>
-      padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-    );
-    await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
-
-    const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-    await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-  }
-
-  // Sync the indexed trees
-  {
-    // We insert the public data tree leaves with one batch per tx to avoid updating the same key twice
-    for (const txEffect of l2Block.body.txEffects) {
-      await fork.batchInsert(
-        MerkleTreeId.PUBLIC_DATA_TREE,
-        txEffect.publicDataWrites.map(write => write.toBuffer()),
-        0,
-      );
-
-      const nullifiersPadded = padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX);
-
-      await fork.batchInsert(
-        MerkleTreeId.NULLIFIER_TREE,
-        nullifiersPadded.map(nullifier => nullifier.toBuffer()),
-        NULLIFIER_SUBTREE_HEIGHT,
-      );
+export async function updateBlockState(block: L2Block, l1ToL2Messages: Fr[], fork: MerkleTreeWriteOperations) {
+  const insertData = async (
+    treeId: IndexedTreeId,
+    data: Buffer[][],
+    subTreeHeight: number,
+    fork: MerkleTreeWriteOperations,
+  ) => {
+    for (const dataBatch of data) {
+      await fork.batchInsert(treeId, dataBatch, subTreeHeight);
     }
-  }
+  };
+
+  const publicDataInsert = insertData(
+    MerkleTreeId.PUBLIC_DATA_TREE,
+    block.body.txEffects.map(txEffect => txEffect.publicDataWrites.map(write => write.toBuffer())),
+    0,
+    fork,
+  );
+  const nullifierInsert = insertData(
+    MerkleTreeId.NULLIFIER_TREE,
+    block.body.txEffects.map(txEffect =>
+      padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(nullifier => nullifier.toBuffer()),
+    ),
+    NULLIFIER_SUBTREE_HEIGHT,
+    fork,
+  );
+  const noteHashesPadded = block.body.txEffects.flatMap(txEffect =>
+    padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+  );
+
+  const l1ToL2MessagesPadded =
+    block.indexWithinCheckpoint === 0
+      ? padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)
+      : l1ToL2Messages;
+
+  const noteHashInsert = fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
+  const messageInsert = fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+  await Promise.all([publicDataInsert, nullifierInsert, noteHashInsert, messageInsert]);
 
   const state = await fork.getStateReference();
-  l2Block.header.state = state;
-  await fork.updateArchive(l2Block.header);
+  block.header = BlockHeader.from({ ...block.header, state });
+  await fork.updateArchive(block.header);
 
   const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
 
-  l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
+  block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
+}
+
+export async function mockBlock(
+  blockNum: BlockNumber,
+  size: number,
+  fork: MerkleTreeWriteOperations,
+  maxEffects: number | undefined = 1000, // Defaults to the maximum tx effects.
+  numL1ToL2Messages: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  isFirstBlockInCheckpoint: boolean = true,
+) {
+  const block = await L2Block.random(blockNum, {
+    indexWithinCheckpoint: isFirstBlockInCheckpoint ? IndexWithinCheckpoint(0) : IndexWithinCheckpoint(1),
+    txsPerBlock: size,
+    txOptions: { maxEffects },
+  });
+  const l1ToL2Messages = mockL1ToL2Messages(numL1ToL2Messages);
+
+  await updateBlockState(block, l1ToL2Messages, fork);
 
   return {
-    block: l2Block,
+    block,
     messages: l1ToL2Messages,
   };
 }
 
-export async function mockEmptyBlock(blockNum: number, fork: MerkleTreeWriteOperations) {
+export async function mockEmptyBlock(blockNum: BlockNumber, fork: MerkleTreeWriteOperations) {
   const l2Block = L2Block.empty();
   const l1ToL2Messages = Array(16).fill(0).map(Fr.zero);
 
-  l2Block.header.globalVariables.blockNumber = new Fr(blockNum);
+  l2Block.header.globalVariables.blockNumber = blockNum;
 
-  // Sync the append only trees
-  {
-    const noteHashesPadded = l2Block.body.txEffects.flatMap(txEffect =>
-      padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-    );
-    await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
-
-    const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-    await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-  }
-
-  // Sync the indexed trees
-  {
-    // We insert the public data tree leaves with one batch per tx to avoid updating the same key twice
-    for (const txEffect of l2Block.body.txEffects) {
-      await fork.batchInsert(
-        MerkleTreeId.PUBLIC_DATA_TREE,
-        txEffect.publicDataWrites.map(write => write.toBuffer()),
-        0,
-      );
-
-      const nullifiersPadded = padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX);
-
-      await fork.batchInsert(
-        MerkleTreeId.NULLIFIER_TREE,
-        nullifiersPadded.map(nullifier => nullifier.toBuffer()),
-        NULLIFIER_SUBTREE_HEIGHT,
-      );
-    }
-  }
-
-  const state = await fork.getStateReference();
-  l2Block.header.state = state;
-  await fork.updateArchive(l2Block.header);
-
-  const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
-
-  l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
+  await updateBlockState(l2Block, l1ToL2Messages, fork);
 
   return {
     block: l2Block,
@@ -112,13 +105,18 @@ export async function mockEmptyBlock(blockNum: number, fork: MerkleTreeWriteOper
   };
 }
 
-export async function mockBlocks(from: number, count: number, numTxs: number, worldState: NativeWorldStateService) {
-  const tempFork = await worldState.fork(from - 1);
+export async function mockBlocks(
+  from: BlockNumber,
+  count: number,
+  numTxs: number,
+  worldState: NativeWorldStateService,
+) {
+  const tempFork = await worldState.fork(BlockNumber(from - 1));
 
   const blocks = [];
   const messagesArray = [];
   for (let blockNumber = from; blockNumber < from + count; blockNumber++) {
-    const { block, messages } = await mockBlock(blockNumber, numTxs, tempFork);
+    const { block, messages } = await mockBlock(BlockNumber(blockNumber), numTxs, tempFork);
     blocks.push(block);
     messagesArray.push(messages);
   }
@@ -128,6 +126,18 @@ export async function mockBlocks(from: number, count: number, numTxs: number, wo
   return { blocks, messages: messagesArray };
 }
 
+export async function mockCheckpoint(
+  checkpointNumber: CheckpointNumber,
+  fork: MerkleTreeWriteOperations,
+  options: Partial<Parameters<typeof mockCheckpointAndMessages>[1]> = {},
+) {
+  const { checkpoint, messages } = await mockCheckpointAndMessages(checkpointNumber, options);
+  await asyncMap(checkpoint.blocks, async (block, i) => {
+    await updateBlockState(block, i === 0 ? messages : [], fork);
+  });
+  return { checkpoint, messages };
+}
+
 export async function assertSameState(forkA: MerkleTreeReadOperations, forkB: MerkleTreeReadOperations) {
   const nativeStateRef = await forkA.getStateReference();
   const nativeArchive = await forkA.getTreeInfo(MerkleTreeId.ARCHIVE);