@aztec/world-state 0.0.0-test.1 → 0.0.1-commit.5daedc8

package/src/native/native_world_state_instance.ts

@@ -8,7 +8,7 @@ import {
   NULLIFIER_TREE_HEIGHT,
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { NativeWorldState as BaseNativeWorldState, MsgpackChannel } from '@aztec/native';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
@@ -17,6 +17,7 @@ import assert from 'assert';
 import { cpus } from 'os';
 
 import type { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
+import type { WorldStateTreeMapSizes } from '../synchronizer/factory.js';
 import {
   WorldStateMessageType,
   type WorldStateRequest,
@@ -35,6 +36,8 @@ export interface NativeWorldStateInstance {
     messageType: T,
     body: WorldStateRequest[T] & WorldStateRequestCategories,
   ): Promise<WorldStateResponse[T]>;
+  // TODO(dbanks12): this returns any type, but we should strongly type it
+  getHandle(): any;
 }
 
 /**
@@ -50,15 +53,17 @@ export class NativeWorldState implements NativeWorldStateInstance {
 
   /** Creates a new native WorldState instance */
   constructor(
-    dataDir: string,
-    dbMapSizeKb: number,
-    prefilledPublicData: PublicDataTreeLeaf[] = [],
-    private instrumentation: WorldStateInstrumentation,
-    private log = createLogger('world-state:database'),
+    private readonly dataDir: string,
+    private readonly wsTreeMapSizes: WorldStateTreeMapSizes,
+    private readonly prefilledPublicData: PublicDataTreeLeaf[] = [],
+    private readonly instrumentation: WorldStateInstrumentation,
+    private readonly log: Logger = createLogger('world-state:database'),
   ) {
     const threads = Math.min(cpus().length, MAX_WORLD_STATE_THREADS);
     log.info(
-      `Creating world state data store at directory ${dataDir} with map size ${dbMapSizeKb} KB and ${threads} threads.`,
+      `Creating world state data store at directory ${dataDir} with map sizes ${JSON.stringify(
+        wsTreeMapSizes,
+      )} and ${threads} threads.`,
     );
     const prefilledPublicDataBufferArray = prefilledPublicData.map(d => [d.slot.toBuffer(), d.value.toBuffer()]);
     const ws = new BaseNativeWorldState(
@@ -76,7 +81,13 @@ export class NativeWorldState implements NativeWorldStateInstance {
       },
       prefilledPublicDataBufferArray,
       GeneratorIndex.BLOCK_HASH,
-      dbMapSizeKb,
+      {
+        [MerkleTreeId.NULLIFIER_TREE]: wsTreeMapSizes.nullifierTreeMapSizeKb,
+        [MerkleTreeId.NOTE_HASH_TREE]: wsTreeMapSizes.noteHashTreeMapSizeKb,
+        [MerkleTreeId.PUBLIC_DATA_TREE]: wsTreeMapSizes.publicDataTreeMapSizeKb,
+        [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: wsTreeMapSizes.messageTreeMapSizeKb,
+        [MerkleTreeId.ARCHIVE]: wsTreeMapSizes.archiveTreeMapSizeKb,
+      },
       threads,
     );
     this.instance = new MsgpackChannel(ws);
@@ -84,6 +95,46 @@ export class NativeWorldState implements NativeWorldStateInstance {
     this.queues.set(0, new WorldStateOpsQueue());
   }
 
+  public getDataDir() {
+    return this.dataDir;
+  }
+
+  public clone() {
+    return new NativeWorldState(
+      this.dataDir,
+      this.wsTreeMapSizes,
+      this.prefilledPublicData,
+      this.instrumentation,
+      this.log,
+    );
+  }
+
+  /**
+   * Gets the native WorldState handle from the underlying native instance.
+   * We call the getHandle() method on the native WorldState to get a NAPI External
+   * that wraps the underlying C++ WorldState pointer.
+   * @returns The NAPI External handle to the native WorldState instance,since
+   * the NAPI external type is opaque, we return any (we could also use an opaque symbol type)
+   */
+  public getHandle(): any {
+    const worldStateWrapper = (this.instance as any).dest;
+
+    if (!worldStateWrapper) {
+      throw new Error('No WorldStateWrapper found');
+    }
+
+    if (typeof worldStateWrapper.getHandle !== 'function') {
+      throw new Error('WorldStateWrapper does not have getHandle method');
+    }
+
+    // Call getHandle() to get the NAPI External
+    try {
+      return worldStateWrapper.getHandle();
+    } catch (error) {
+      this.log.error('Failed to get native WorldState handle', error);
+    }
+  }
+
   /**
    * Sends a message to the native instance and returns the response.
    * @param messageType - The type of message to send

package/src/native/world_state_ops_queue.ts

@@ -35,7 +35,7 @@ export const MUTATING_MSG_TYPES = new Set([
   WorldStateMessageType.SYNC_BLOCK,
   WorldStateMessageType.CREATE_FORK,
   WorldStateMessageType.DELETE_FORK,
-  WorldStateMessageType.FINALISE_BLOCKS,
+  WorldStateMessageType.FINALIZE_BLOCKS,
   WorldStateMessageType.UNWIND_BLOCKS,
   WorldStateMessageType.REMOVE_HISTORICAL_BLOCKS,
   WorldStateMessageType.CREATE_CHECKPOINT,

package/src/synchronizer/config.ts

@@ -16,9 +16,24 @@ export interface WorldStateConfig {
   /** Size of the batch for each get-blocks request from the synchronizer to the archiver. */
   worldStateBlockRequestBatchSize?: number;
 
-  /** The map size to be provided to LMDB for each world state tree DB, optional, will inherit from the general dataStoreMapSizeKB if not specified*/
+  /** The map size to be provided to LMDB for each world state tree DB, optional, will inherit from the general dataStoreMapSizeKb if not specified*/
   worldStateDbMapSizeKb?: number;
 
+  /** The map size to be provided to LMDB for each world state archive tree, optional, will inherit from the general worldStateDbMapSizeKb if not specified*/
+  archiveTreeMapSizeKb?: number;
+
+  /** The map size to be provided to LMDB for each world state nullifier tree, optional, will inherit from the general worldStateDbMapSizeKb if not specified*/
+  nullifierTreeMapSizeKb?: number;
+
+  /** The map size to be provided to LMDB for each world state note hash tree, optional, will inherit from the general worldStateDbMapSizeKb if not specified*/
+  noteHashTreeMapSizeKb?: number;
+
+  /** The map size to be provided to LMDB for each world state message tree, optional, will inherit from the general worldStateDbMapSizeKb if not specified*/
+  messageTreeMapSizeKb?: number;
+
+  /** The map size to be provided to LMDB for each world state public data tree, optional, will inherit from the general worldStateDbMapSizeKb if not specified*/
+  publicDataTreeMapSizeKb?: number;
+
   /** Optional directory for the world state DB, if unspecified will default to the general data directory */
   worldStateDataDirectory?: string;
 
@@ -46,7 +61,37 @@ export const worldStateConfigMappings: ConfigMappingsType<WorldStateConfig> = {
   worldStateDbMapSizeKb: {
     env: 'WS_DB_MAP_SIZE_KB',
     parseEnv: (val: string | undefined) => (val ? +val : undefined),
-    description: 'The maximum possible size of the world state DB',
+    description: 'The maximum possible size of the world state DB in KB. Overwrites the general dataStoreMapSizeKb.',
+  },
+  archiveTreeMapSizeKb: {
+    env: 'ARCHIVE_TREE_MAP_SIZE_KB',
+    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    description:
+      'The maximum possible size of the world state archive tree in KB. Overwrites the general worldStateDbMapSizeKb.',
+  },
+  nullifierTreeMapSizeKb: {
+    env: 'NULLIFIER_TREE_MAP_SIZE_KB',
+    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    description:
+      'The maximum possible size of the world state nullifier tree in KB. Overwrites the general worldStateDbMapSizeKb.',
+  },
+  noteHashTreeMapSizeKb: {
+    env: 'NOTE_HASH_TREE_MAP_SIZE_KB',
+    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    description:
+      'The maximum possible size of the world state note hash tree in KB. Overwrites the general worldStateDbMapSizeKb.',
+  },
+  messageTreeMapSizeKb: {
+    env: 'MESSAGE_TREE_MAP_SIZE_KB',
+    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    description:
+      'The maximum possible size of the world state message tree in KB. Overwrites the general worldStateDbMapSizeKb.',
+  },
+  publicDataTreeMapSizeKb: {
+    env: 'PUBLIC_DATA_TREE_MAP_SIZE_KB',
+    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    description:
+      'The maximum possible size of the world state public data tree in KB. Overwrites the general worldStateDbMapSizeKb.',
   },
   worldStateDataDirectory: {
     env: 'WS_DATA_DIRECTORY',

package/src/synchronizer/errors.ts

@@ -0,0 +1,5 @@
+export class WorldStateSynchronizerError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+  }
+}

package/src/synchronizer/factory.ts

@@ -9,6 +9,14 @@ import { NativeWorldStateService } from '../native/native_world_state.js';
 import type { WorldStateConfig } from './config.js';
 import { ServerWorldStateSynchronizer } from './server_world_state_synchronizer.js';
 
+export interface WorldStateTreeMapSizes {
+  archiveTreeMapSizeKb: number;
+  nullifierTreeMapSizeKb: number;
+  noteHashTreeMapSizeKb: number;
+  messageTreeMapSizeKb: number;
+  publicDataTreeMapSizeKb: number;
+}
+
 export async function createWorldStateSynchronizer(
   config: WorldStateConfig & DataStoreConfig,
   l2BlockSource: L2BlockSource & L1ToL2MessageSource,
@@ -21,25 +29,40 @@ export async function createWorldStateSynchronizer(
 }
 
 export async function createWorldState(
-  config: WorldStateConfig & DataStoreConfig,
+  config: Pick<
+    WorldStateConfig,
+    | 'worldStateDataDirectory'
+    | 'worldStateDbMapSizeKb'
+    | 'archiveTreeMapSizeKb'
+    | 'nullifierTreeMapSizeKb'
+    | 'noteHashTreeMapSizeKb'
+    | 'messageTreeMapSizeKb'
+    | 'publicDataTreeMapSizeKb'
+  > &
+    Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb' | 'l1Contracts'>,
   prefilledPublicData: PublicDataTreeLeaf[] = [],
   instrumentation: WorldStateInstrumentation = new WorldStateInstrumentation(getTelemetryClient()),
 ) {
-  const newConfig = {
-    dataDirectory: config.worldStateDataDirectory ?? config.dataDirectory,
-    dataStoreMapSizeKB: config.worldStateDbMapSizeKb ?? config.dataStoreMapSizeKB,
-  } as DataStoreConfig;
+  const dataDirectory = config.worldStateDataDirectory ?? config.dataDirectory;
+  const dataStoreMapSizeKb = config.worldStateDbMapSizeKb ?? config.dataStoreMapSizeKb;
+  const wsTreeMapSizes: WorldStateTreeMapSizes = {
+    archiveTreeMapSizeKb: config.archiveTreeMapSizeKb ?? dataStoreMapSizeKb,
+    nullifierTreeMapSizeKb: config.nullifierTreeMapSizeKb ?? dataStoreMapSizeKb,
+    noteHashTreeMapSizeKb: config.noteHashTreeMapSizeKb ?? dataStoreMapSizeKb,
+    messageTreeMapSizeKb: config.messageTreeMapSizeKb ?? dataStoreMapSizeKb,
+    publicDataTreeMapSizeKb: config.publicDataTreeMapSizeKb ?? dataStoreMapSizeKb,
+  };
 
   if (!config.l1Contracts?.rollupAddress) {
     throw new Error('Rollup address is required to create a world state synchronizer.');
   }
 
   // If a data directory is provided in config, then create a persistent store.
-  const merkleTrees = newConfig.dataDirectory
+  const merkleTrees = dataDirectory
     ? await NativeWorldStateService.new(
         config.l1Contracts.rollupAddress,
-        newConfig.dataDirectory,
-        newConfig.dataStoreMapSizeKB,
+        dataDirectory,
+        wsTreeMapSizes,
         prefilledPublicData,
         instrumentation,
       )

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,10 +1,10 @@
 import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import { SHA256Trunc } from '@aztec/foundation/crypto';
 import type { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+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,
@@ -22,6 +22,7 @@ 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';
@@ -30,6 +31,9 @@ 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.
@@ -49,12 +53,16 @@ export class ServerWorldStateSynchronizer
   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: bigint | 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;
@@ -77,6 +85,14 @@ export class ServerWorldStateSynchronizer
     return this.merkleTreeDb.fork(blockNumber);
   }
 
+  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() {
     if (this.currentState === WorldStateRunningState.STOPPED) {
       throw new Error('Synchronizer already stopped');
@@ -131,9 +147,9 @@ 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),
+      latestBlockNumber: Number(summary.unfinalizedBlockNumber),
+      latestBlockHash: (await this.getL2BlockHash(Number(summary.unfinalizedBlockNumber))) ?? '',
+      finalizedBlockNumber: Number(summary.finalizedBlockNumber),
       oldestHistoricBlockNumber: Number(summary.oldestHistoricalBlock),
       treesAreSynched: summary.treesAreSynched,
     };
@@ -147,16 +163,36 @@ export class ServerWorldStateSynchronizer
     return (await this.getL2Tips()).latest.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?: number, skipThrowIfTargetNotReached?: boolean): Promise<number> {
+    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,13 +200,32 @@ 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 = 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;
@@ -195,35 +250,31 @@ export class ServerWorldStateSynchronizer
   /** 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 unfinalizedBlockHash = await this.getL2BlockHash(Number(status.unfinalizedBlockNumber));
+    const latestBlockId: L2BlockId = { number: Number(status.unfinalizedBlockNumber), hash: unfinalizedBlockHash! };
 
     return {
       latest: latestBlockId,
-      finalized: { number: Number(status.finalisedBlockNumber), hash: '' },
-      proven: { number: Number(status.finalisedBlockNumber), hash: '' }, // TODO(palla/reorg): Using finalised as proven for now
+      finalized: { number: Number(status.finalizedBlockNumber), hash: '' },
+      proven: { number: Number(this.provenBlockNumber ?? status.finalizedBlockNumber), hash: '' }, // TODO(palla/reorg): Using finalized as proven for now
     };
   }
 
   /** 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.map(b => b.block));
+        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;
     }
   }
 
@@ -235,17 +286,17 @@ export class ServerWorldStateSynchronizer
   private async handleL2Blocks(l2Blocks: L2Block[]) {
     this.log.trace(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1)!.number}`);
 
-    const messagePromises = l2Blocks.map(block => this.l2BlockSource.getL1ToL2Messages(BigInt(block.number)));
+    const messagePromises = l2Blocks.map(block => this.l2BlockSource.getL1ToL2Messages(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}`, {
+      this.log.info(`World state updated with L2 block ${l2Blocks[i].number}`, {
         eventName: 'l2-block-handled',
         duration,
-        unfinalisedBlockNumber: result.summary.unfinalisedBlockNumber,
-        finalisedBlockNumber: result.summary.finalisedBlockNumber,
+        unfinalizedBlockNumber: result.summary.unfinalizedBlockNumber,
+        finalizedBlockNumber: result.summary.finalizedBlockNumber,
         oldestHistoricBlock: result.summary.oldestHistoricalBlock,
         ...l2Blocks[i].getStats(),
       } satisfies L2BlockHandledStats);
@@ -288,11 +339,11 @@ export class ServerWorldStateSynchronizer
 
   private async handleChainFinalized(blockNumber: number) {
     this.log.verbose(`Finalized chain is now at block ${blockNumber}`);
-    const summary = await this.merkleTreeDb.setFinalised(BigInt(blockNumber));
+    const summary = await this.merkleTreeDb.setFinalized(BigInt(blockNumber));
     if (this.historyToKeep === undefined) {
       return;
     }
-    const newHistoricBlock = summary.finalisedBlockNumber - BigInt(this.historyToKeep) + 1n;
+    const newHistoricBlock = summary.finalizedBlockNumber - BigInt(this.historyToKeep) + 1n;
     if (newHistoricBlock <= 1) {
       return;
     }
@@ -302,6 +353,7 @@ export class ServerWorldStateSynchronizer
   }
 
   private handleChainProven(blockNumber: number) {
+    this.provenBlockNumber = BigInt(blockNumber);
     this.log.debug(`Proven chain is now at block ${blockNumber}`);
     return Promise.resolve();
   }
@@ -310,6 +362,7 @@ export class ServerWorldStateSynchronizer
     this.log.warn(`Chain pruned to block ${blockNumber}`);
     const status = await this.merkleTreeDb.unwindBlocks(BigInt(blockNumber));
     this.latestBlockHashQuery = undefined;
+    this.provenBlockNumber = undefined;
     this.instrumentation.updateWorldStateMetrics(status);
   }
 
@@ -328,7 +381,7 @@ export class ServerWorldStateSynchronizer
    * @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) {
+  protected async verifyMessagesHashToInHash(l1ToL2Messages: Fr[], inHash: Fr) {
     const treeCalculator = await MerkleTreeCalculator.create(
       L1_TO_L2_MSG_SUBTREE_HEIGHT,
       Buffer.alloc(32),
@@ -337,7 +390,7 @@ export class ServerWorldStateSynchronizer
 
     const root = await treeCalculator.computeTreeRoot(l1ToL2Messages.map(msg => msg.toBuffer()));
 
-    if (!root.equals(inHash)) {
+    if (!root.equals(inHash.toBuffer())) {
       throw new Error('Obtained L1 to L2 messages failed to be hashed to the block inHash');
     }
   }

package/src/test/utils.ts

@@ -7,49 +7,64 @@ import {
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 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 { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 
 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);
+export async function mockBlock(
+  blockNum: number,
+  size: number,
+  fork: MerkleTreeWriteOperations,
+  maxEffects: number | undefined = 1000, // Defaults to the maximum tx effects.
+) {
+  const l2Block = await L2Block.random(blockNum, size, undefined, undefined, undefined, undefined, maxEffects);
+  const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.random);
 
-  // Sync the append only trees
   {
+    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,
+      l2Block.body.txEffects.map(txEffect => txEffect.publicDataWrites.map(write => write.toBuffer())),
+      0,
+      fork,
+    );
+    const nullifierInsert = insertData(
+      MerkleTreeId.NULLIFIER_TREE,
+      l2Block.body.txEffects.map(txEffect =>
+        padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(nullifier => nullifier.toBuffer()),
+      ),
+      NULLIFIER_SUBTREE_HEIGHT,
+      fork,
+    );
     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);
+    const l1ToL2MessagesPadded = padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
 
-      await fork.batchInsert(
-        MerkleTreeId.NULLIFIER_TREE,
-        nullifiersPadded.map(nullifier => nullifier.toBuffer()),
-        NULLIFIER_SUBTREE_HEIGHT,
-      );
-    }
+    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);
+  await fork.updateArchive(l2Block.getBlockHeader());
 
   const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
 
@@ -65,7 +80,7 @@ export async function mockEmptyBlock(blockNum: number, fork: MerkleTreeWriteOper
   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
   {
@@ -74,7 +89,7 @@ export async function mockEmptyBlock(blockNum: number, fork: MerkleTreeWriteOper
     );
     await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
 
-    const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    const l1ToL2MessagesPadded = padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
     await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
   }
 
@@ -100,7 +115,7 @@ export async function mockEmptyBlock(blockNum: number, fork: MerkleTreeWriteOper
 
   const state = await fork.getStateReference();
   l2Block.header.state = state;
-  await fork.updateArchive(l2Block.header);
+  await fork.updateArchive(l2Block.getBlockHeader());
 
   const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);