@aztec/world-state 0.57.0 → 0.58.0

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,13 +1,19 @@
 import {
-  type HandleL2BlockAndMessagesResult,
   type L1ToL2MessageSource,
   type L2Block,
-  L2BlockDownloader,
+  type L2BlockId,
   type L2BlockSource,
-  type MerkleTreeAdminOperations,
+  L2BlockStream,
+  type L2BlockStreamEvent,
+  type L2BlockStreamEventHandler,
+  type L2BlockStreamLocalDataProvider,
+  type L2Tips,
+  MerkleTreeId,
+  type MerkleTreeReadOperations,
+  type MerkleTreeWriteOperations,
   WorldStateRunningState,
-  type WorldStateStatus,
   type WorldStateSynchronizer,
+  type WorldStateSynchronizerStatus,
 } from '@aztec/circuit-types';
 import { type L2BlockHandledStats } from '@aztec/circuit-types/stats';
 import { MerkleTreeCalculator } from '@aztec/circuits.js';
@@ -15,74 +21,48 @@ import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js/constants';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
-import { SerialQueue } from '@aztec/foundation/queue';
 import { elapsed } from '@aztec/foundation/timer';
-import { type AztecKVStore, type AztecSingleton } from '@aztec/kv-store';
 import { SHA256Trunc } from '@aztec/merkle-tree';
 
-import {
-  MerkleTreeAdminOperationsFacade,
-  MerkleTreeOperationsFacade,
-} from '../world-state-db/merkle_tree_operations_facade.js';
-import { MerkleTreeSnapshotOperationsFacade } from '../world-state-db/merkle_tree_snapshot_operations_facade.js';
-import { type MerkleTrees } from '../world-state-db/merkle_trees.js';
+import { type WorldStateStatus } from '../native/message.js';
+import { type MerkleTreeAdminDatabase } from '../world-state-db/merkle_tree_db.js';
 import { type WorldStateConfig } from './config.js';
 
 /**
- * Synchronizes the world state with the L2 blocks from a L2BlockSource.
- * The synchronizer will download the L2 blocks from the L2BlockSource and insert the new note hashes into the merkle
- * tree.
+ * Synchronizes the world state with the L2 blocks from a L2BlockSource via a block stream.
+ * The synchronizer will download the L2 blocks from the L2BlockSource and update the merkle trees.
+ * Handles chain reorgs via the L2BlockStream.
  */
-export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
-  private latestBlockNumberAtStart = 0;
+export class ServerWorldStateSynchronizer
+  implements WorldStateSynchronizer, L2BlockStreamLocalDataProvider, L2BlockStreamEventHandler
+{
+  private readonly merkleTreeCommitted: MerkleTreeReadOperations;
 
-  // TODO(palla/prover-node): JobQueue, stopping, runningPromise, pausedPromise, pausedResolve
-  // should all be hidden under a single abstraction. Also, check if we actually need the jobqueue.
-  private l2BlockDownloader: L2BlockDownloader;
-  private syncPromise: Promise<void> = Promise.resolve();
-  private syncResolve?: () => void = undefined;
-  private jobQueue = new SerialQueue();
-  private stopping = false;
-  private runningPromise: Promise<void> = Promise.resolve();
-  private pausedPromise?: Promise<void> = undefined;
-  private pausedResolve?: () => void = undefined;
+  private latestBlockNumberAtStart = 0;
   private currentState: WorldStateRunningState = WorldStateRunningState.IDLE;
-  private blockNumber: AztecSingleton<number>;
+
+  private syncPromise = promiseWithResolvers<void>();
+  protected blockStream: L2BlockStream | undefined;
 
   constructor(
-    store: AztecKVStore,
-    private merkleTreeDb: MerkleTrees,
-    private l2BlockSource: L2BlockSource & L1ToL2MessageSource,
-    private config: WorldStateConfig,
-    private log = createDebugLogger('aztec:world_state'),
+    private readonly merkleTreeDb: MerkleTreeAdminDatabase,
+    private readonly l2BlockSource: L2BlockSource & L1ToL2MessageSource,
+    private readonly config: WorldStateConfig,
+    private readonly log = createDebugLogger('aztec:world_state'),
   ) {
-    this.blockNumber = store.openSingleton('world_state_synch_last_block_number');
-    this.l2BlockDownloader = new L2BlockDownloader(l2BlockSource, {
-      maxQueueSize: config.l2QueueSize,
-      pollIntervalMS: config.worldStateBlockCheckIntervalMS,
-      proven: config.worldStateProvenBlocksOnly,
-    });
-  }
-
-  public getLatest(): MerkleTreeAdminOperations {
-    return new MerkleTreeAdminOperationsFacade(this.merkleTreeDb, true);
+    this.merkleTreeCommitted = this.merkleTreeDb.getCommitted();
   }
 
-  public getCommitted(): MerkleTreeAdminOperations {
-    return new MerkleTreeAdminOperationsFacade(this.merkleTreeDb, false);
+  public getCommitted(): MerkleTreeReadOperations {
+    return this.merkleTreeDb.getCommitted();
   }
 
-  public getSnapshot(blockNumber: number): MerkleTreeAdminOperations {
-    return new MerkleTreeSnapshotOperationsFacade(this.merkleTreeDb, blockNumber);
+  public getSnapshot(blockNumber: number): MerkleTreeReadOperations {
+    return this.merkleTreeDb.getSnapshot(blockNumber);
   }
 
-  public async ephemeralFork(): Promise<MerkleTreeOperationsFacade> {
-    return new MerkleTreeOperationsFacade(await this.merkleTreeDb.ephemeralFork(), true);
-  }
-
-  private async getFork(includeUncommitted: boolean): Promise<MerkleTreeAdminOperationsFacade> {
-    this.log.verbose(`Forking world state at ${this.blockNumber.get()}`);
-    return new MerkleTreeAdminOperationsFacade(await this.merkleTreeDb.fork(), includeUncommitted);
+  public fork(blockNumber?: number): Promise<MerkleTreeWriteOperations> {
+    return this.merkleTreeDb.fork(blockNumber);
   }
 
   public async start() {
@@ -93,86 +73,56 @@ export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
       return this.syncPromise;
     }
 
-    // get the current latest block number
+    // Get the current latest block number
     this.latestBlockNumberAtStart = await (this.config.worldStateProvenBlocksOnly
       ? this.l2BlockSource.getProvenBlockNumber()
       : this.l2BlockSource.getBlockNumber());
 
-    const blockToDownloadFrom = this.currentL2BlockNum + 1;
+    const blockToDownloadFrom = (await this.getLatestBlockNumber()) + 1;
 
-    // if there are blocks to be retrieved, go to a synching state
     if (blockToDownloadFrom <= this.latestBlockNumberAtStart) {
+      // If there are blocks to be retrieved, go to a synching state
       this.setCurrentState(WorldStateRunningState.SYNCHING);
-      this.syncPromise = new Promise(resolve => {
-        this.syncResolve = resolve;
-      });
-      this.log.info(`Starting sync from ${blockToDownloadFrom}, latest block ${this.latestBlockNumberAtStart}`);
+      this.log.verbose(`Starting sync from ${blockToDownloadFrom} to latest block ${this.latestBlockNumberAtStart}`);
     } else {
-      // if no blocks to be retrieved, go straight to running
+      // If no blocks to be retrieved, go straight to running
       this.setCurrentState(WorldStateRunningState.RUNNING);
-      this.syncPromise = Promise.resolve();
-      this.log.debug(
-        `Next block ${blockToDownloadFrom} already beyond latest block at ${this.latestBlockNumberAtStart}`,
-      );
+      this.syncPromise.resolve();
+      this.log.debug(`Next block ${blockToDownloadFrom} already beyond latest block ${this.latestBlockNumberAtStart}`);
     }
 
-    // start looking for further blocks
-    const blockProcess = async () => {
-      while (!this.stopping) {
-        await this.jobQueue.put(() => this.collectAndProcessBlocks());
-        if (this.pausedPromise) {
-          await this.pausedPromise;
-        }
-      }
-    };
-    this.jobQueue.start();
-    this.runningPromise = blockProcess();
-    this.l2BlockDownloader.start(blockToDownloadFrom);
-    this.log.info(`Started block downloader from block ${blockToDownloadFrom}`);
-    return this.syncPromise;
+    this.blockStream = this.createBlockStream();
+    this.blockStream.start();
+    this.log.info(`Started world state synchronizer from block ${blockToDownloadFrom}`);
+    return this.syncPromise.promise;
   }
 
-  public async stop() {
-    this.log.debug('Stopping world state...');
-    this.stopping = true;
-    await this.l2BlockDownloader.stop();
-    this.log.debug('Cancelling job queue...');
-    await this.jobQueue.cancel();
-    this.log.debug('Stopping Merkle trees');
-    await this.merkleTreeDb.stop();
-    this.log.debug('Awaiting promise');
-    await this.runningPromise;
-    this.setCurrentState(WorldStateRunningState.STOPPED);
-    this.log.info(`Stopped`);
-  }
-
-  private get currentL2BlockNum(): number {
-    return this.blockNumber.get() ?? 0;
+  protected createBlockStream() {
+    return new L2BlockStream(this.l2BlockSource, this, this, {
+      proven: this.config.worldStateProvenBlocksOnly,
+      pollIntervalMS: this.config.worldStateBlockCheckIntervalMS,
+      batchSize: this.config.worldStateBlockRequestBatchSize,
+    });
   }
 
-  private async pause() {
-    this.log.debug('Pausing world state synchronizer');
-    ({ promise: this.pausedPromise, resolve: this.pausedResolve } = promiseWithResolvers());
-    await this.jobQueue.syncPoint();
-    this.log.debug('Paused world state synchronizer');
+  public async stop() {
+    this.log.debug('Stopping block stream...');
+    await this.blockStream?.stop();
+    this.log.debug('Stopping merkle trees...');
+    await this.merkleTreeDb.close();
+    this.setCurrentState(WorldStateRunningState.STOPPED);
+    this.log.info(`Stopped world state synchronizer`);
   }
 
-  private resume() {
-    if (this.pausedResolve) {
-      this.log.debug('Resuming world state synchronizer');
-      this.pausedResolve();
-      this.pausedResolve = undefined;
-      this.pausedPromise = undefined;
-      this.log.debug('Resumed world state synchronizer');
-    }
+  public async status(): Promise<WorldStateSynchronizerStatus> {
+    return {
+      syncedToL2Block: (await this.getL2Tips()).latest,
+      state: this.currentState,
+    };
   }
 
-  public status(): Promise<WorldStateStatus> {
-    const status = {
-      syncedToL2Block: this.currentL2BlockNum,
-      state: this.currentState,
-    } as WorldStateStatus;
-    return Promise.resolve(status);
+  public async getLatestBlockNumber() {
+    return (await this.getL2Tips()).latest.number;
   }
 
   /**
@@ -181,78 +131,89 @@ export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
    * @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) {
-      throw new Error(`World State is not running, unable to perform sync`);
+    if (this.currentState !== WorldStateRunningState.RUNNING || this.blockStream === undefined) {
+      throw new Error(`World State is not running. Unable to perform sync.`);
     }
-    // If we have been given a block number to sync to and we have reached that number then return.
-    if (targetBlockNumber !== undefined && targetBlockNumber <= this.currentL2BlockNum) {
-      return this.currentL2BlockNum;
+
+    // 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) {
+      return currentBlockNumber;
     }
-    this.log.debug(`World State at ${this.currentL2BlockNum} told to sync to ${targetBlockNumber ?? 'latest'}`);
-    // ensure any outstanding block updates are completed first
-    await this.jobQueue.syncPoint();
-
-    while (true) {
-      // Check the block number again
-      if (targetBlockNumber !== undefined && targetBlockNumber <= this.currentL2BlockNum) {
-        return this.currentL2BlockNum;
-      }
-      // Poll for more blocks, requesting even unproven blocks.
-      const numBlocks = await this.l2BlockDownloader.pollImmediate(targetBlockNumber, false);
-      this.log.debug(`Block download immediate poll yielded ${numBlocks} blocks`);
-      if (numBlocks) {
-        // More blocks were received, process them and go round again
-        await this.jobQueue.put(() => this.collectAndProcessBlocks());
-        continue;
-      }
-      // No blocks are available, if we have been given a block number then we can't achieve it
-      if (targetBlockNumber !== undefined) {
-        throw new Error(
-          `Unable to sync to block number ${targetBlockNumber}, currently synced to block ${this.currentL2BlockNum}`,
-        );
-      }
-      return this.currentL2BlockNum;
+    this.log.debug(`World State at ${currentBlockNumber} told to sync to ${targetBlockNumber ?? 'latest'}`);
+
+    // 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})`);
     }
+
+    return updatedBlockNumber;
   }
 
-  public async syncImmediateAndFork(
-    targetBlockNumber: number,
-    forkIncludeUncommitted: boolean,
-  ): Promise<MerkleTreeAdminOperationsFacade> {
-    try {
-      await this.pause();
-      await this.syncImmediate(targetBlockNumber);
-      return await this.getFork(forkIncludeUncommitted);
-    } finally {
-      this.resume();
-    }
+  /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */
+  public getL2BlockHash(number: number): Promise<string | undefined> {
+    return number === 0
+      ? Promise.resolve(this.merkleTreeCommitted.getInitialHeader().hash().toString())
+      : this.merkleTreeCommitted.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(number)).then(leaf => leaf?.toString());
   }
 
-  /**
-   * Checks for the availability of new blocks and processes them.
-   */
-  private async collectAndProcessBlocks() {
-    // This request for blocks will timeout after 1 second if no blocks are received
-    const blocks = await this.l2BlockDownloader.getBlocks(1);
-    const messagePromises = blocks.map(block => this.l2BlockSource.getL1ToL2Messages(BigInt(block.number)));
-    const l1ToL2Messages: Fr[][] = await Promise.all(messagePromises);
+  /** 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.getStatus();
+    const unfinalisedBlockHash = await this.getL2BlockHash(Number(status.unfinalisedBlockNumber));
+    const latestBlockId: L2BlockId = { number: Number(status.unfinalisedBlockNumber), hash: unfinalisedBlockHash! };
 
-    await this.handleL2BlocksAndMessages(blocks, l1ToL2Messages);
+    return {
+      latest: latestBlockId,
+      finalized: { number: Number(status.finalisedBlockNumber), hash: '' },
+      proven: { number: Number(status.finalisedBlockNumber), hash: '' }, // TODO(palla/reorg): Using finalised 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);
+    }
   }
 
   /**
    * Handles a list of L2 blocks (i.e. Inserts the new note hashes into the merkle tree).
    * @param l2Blocks - The L2 blocks to handle.
-   * @param l1ToL2Messages - The L1 to L2 messages for each block.
    * @returns Whether the block handled was produced by this same node.
    */
-  private async handleL2BlocksAndMessages(l2Blocks: L2Block[], l1ToL2Messages: Fr[][]) {
+  private async handleL2Blocks(l2Blocks: L2Block[]) {
+    this.log.verbose(`Handling new L2 blocks from ${l2Blocks[0].number} to ${l2Blocks[l2Blocks.length - 1].number}`);
+    const messagePromises = l2Blocks.map(block => this.l2BlockSource.getL1ToL2Messages(BigInt(block.number)));
+    const l1ToL2Messages: Fr[][] = await Promise.all(messagePromises);
+
     for (let i = 0; i < l2Blocks.length; i++) {
-      const [duration, result] = await elapsed(() => this.handleL2BlockAndMessages(l2Blocks[i], l1ToL2Messages[i]));
+      const [duration, result] = await elapsed(() => this.handleL2Block(l2Blocks[i], l1ToL2Messages[i]));
       this.log.verbose(`Handled new L2 block`, {
         eventName: 'l2-block-handled',
         duration,
-        isBlockOurs: result.isBlockOurs,
+        unfinalisedBlockNumber: result.unfinalisedBlockNumber,
+        finalisedBlockNumber: result.finalisedBlockNumber,
+        oldestHistoricBlock: result.oldestHistoricalBlock,
         ...l2Blocks[i].getStats(),
       } satisfies L2BlockHandledStats);
     }
@@ -264,29 +225,39 @@ export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
    * @param l1ToL2Messages - The L1 to L2 messages for the block.
    * @returns Whether the block handled was produced by this same node.
    */
-  private async handleL2BlockAndMessages(
-    l2Block: L2Block,
-    l1ToL2Messages: Fr[],
-  ): Promise<HandleL2BlockAndMessagesResult> {
+  private async handleL2Block(l2Block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatus> {
     // 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.
-    this.#verifyMessagesHashToInHash(l1ToL2Messages, l2Block.header.contentCommitment.inHash);
+    this.verifyMessagesHashToInHash(l1ToL2Messages, l2Block.header.contentCommitment.inHash);
 
     // If the above check succeeds, we can proceed to handle the block.
     const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
-    await this.blockNumber.set(l2Block.number);
 
     if (this.currentState === WorldStateRunningState.SYNCHING && l2Block.number >= this.latestBlockNumberAtStart) {
       this.setCurrentState(WorldStateRunningState.RUNNING);
-      if (this.syncResolve !== undefined) {
-        this.syncResolve();
-      }
+      this.syncPromise.resolve();
     }
+
     return result;
   }
 
+  private async handleChainFinalized(blockNumber: number) {
+    this.log.verbose(`Chain finalized at block ${blockNumber}`);
+    await this.merkleTreeDb.setFinalised(BigInt(blockNumber));
+  }
+
+  private handleChainProven(blockNumber: number) {
+    this.log.verbose(`Chain proven at block ${blockNumber}`);
+    return Promise.resolve();
+  }
+
+  private async handleChainPruned(blockNumber: number) {
+    this.log.info(`Chain pruned to block ${blockNumber}`);
+    await this.merkleTreeDb.unwindBlocks(BigInt(blockNumber));
+  }
+
   /**
    * Method to set the value of the current state.
    * @param newState - New state value.
@@ -302,7 +273,7 @@ export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
    * @param inHash - The inHash of the block.
    * @throws If the L1 to L2 messages do not hash to the block inHash.
    */
-  #verifyMessagesHashToInHash(l1ToL2Messages: Fr[], inHash: Buffer) {
+  protected verifyMessagesHashToInHash(l1ToL2Messages: Fr[], inHash: Buffer) {
     const treeCalculator = new MerkleTreeCalculator(
       L1_TO_L2_MSG_SUBTREE_HEIGHT,
       Buffer.alloc(32),

package/src/test/utils.ts

@@ -0,0 +1,123 @@
+import {
+  L2Block,
+  MerkleTreeId,
+  type MerkleTreeReadOperations,
+  type MerkleTreeWriteOperations,
+  PublicDataWrite,
+  TxEffect,
+} from '@aztec/circuit-types';
+import {
+  AppendOnlyTreeSnapshot,
+  Fr,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  NULLIFIER_SUBTREE_HEIGHT,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  PUBLIC_DATA_SUBTREE_HEIGHT,
+  PublicDataTreeLeaf,
+} from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
+
+import { type NativeWorldStateService } from '../native/native_world_state.js';
+
+export async function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations) {
+  const l2Block = L2Block.random(blockNum, size);
+  const l1ToL2Messages = Array(16).fill(0).map(Fr.random);
+
+  const paddedTxEffects = padArrayEnd(
+    l2Block.body.txEffects,
+    TxEffect.empty(),
+    l2Block.body.numberOfTxsIncludingPadded,
+  );
+
+  // Sync the append only trees
+  {
+    const noteHashesPadded = paddedTxEffects.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 paddedTxEffects) {
+      const publicDataWrites = padArrayEnd(
+        txEffect.publicDataWrites,
+        PublicDataWrite.empty(),
+        MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+      );
+
+      await fork.batchInsert(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        publicDataWrites.map(write => new PublicDataTreeLeaf(write.leafIndex, write.newValue).toBuffer()),
+        PUBLIC_DATA_SUBTREE_HEIGHT,
+      );
+
+      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));
+
+  return {
+    block: l2Block,
+    messages: l1ToL2Messages,
+  };
+}
+
+export async function mockBlocks(from: number, count: number, numTxs: number, worldState: NativeWorldStateService) {
+  const tempFork = await worldState.fork(from - 1);
+
+  const blocks = [];
+  const messagesArray = [];
+  for (let blockNumber = from; blockNumber < from + count; blockNumber++) {
+    const { block, messages } = await mockBlock(blockNumber, numTxs, tempFork);
+    blocks.push(block);
+    messagesArray.push(messages);
+  }
+
+  await tempFork.close();
+
+  return { blocks, messages: messagesArray };
+}
+
+export async function assertSameState(forkA: MerkleTreeReadOperations, forkB: MerkleTreeReadOperations) {
+  const nativeStateRef = await forkA.getStateReference();
+  const nativeArchive = await forkA.getTreeInfo(MerkleTreeId.ARCHIVE);
+  const legacyStateRef = await forkB.getStateReference();
+  const legacyArchive = await forkB.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+  expect(nativeStateRef).toEqual(legacyStateRef);
+  expect(nativeArchive).toEqual(legacyArchive);
+}
+
+export async function compareChains(left: MerkleTreeReadOperations, right: MerkleTreeReadOperations) {
+  for (const treeId of [
+    MerkleTreeId.ARCHIVE,
+    MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+    MerkleTreeId.NOTE_HASH_TREE,
+    MerkleTreeId.NULLIFIER_TREE,
+    MerkleTreeId.PUBLIC_DATA_TREE,
+  ]) {
+    expect(await left.getTreeInfo(treeId)).toEqual(await right.getTreeInfo(treeId));
+
+    expect(await left.getSiblingPath(treeId, 0n)).toEqual(await right.getSiblingPath(treeId, 0n));
+  }
+}

package/src/world-state-db/index.ts

@@ -3,4 +3,4 @@ export * from './merkle_tree_db.js';
 export * from './merkle_tree_operations_facade.js';
 export * from './merkle_tree_snapshot_operations_facade.js';
 
-export { MerkleTreeOperations, MerkleTreeAdminOperations } from '@aztec/circuit-types/interfaces';
+export { MerkleTreeReadOperations } from '@aztec/circuit-types/interfaces';