@aztec/world-state 0.57.0 → 0.59.0

package/dest/synchronizer/server_world_state_synchronizer.js

@@ -1,58 +1,34 @@
-var _ServerWorldStateSynchronizer_instances, _ServerWorldStateSynchronizer_verifyMessagesHashToInHash;
-import { __classPrivateFieldGet } from "tslib";
-import { L2BlockDownloader, WorldStateRunningState, } from '@aztec/circuit-types';
+import { L2BlockStream, MerkleTreeId, WorldStateRunningState, } from '@aztec/circuit-types';
 import { MerkleTreeCalculator } from '@aztec/circuits.js';
 import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js/constants';
 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 { 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';
 /**
- * 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 {
-    constructor(store, merkleTreeDb, l2BlockSource, config, log = createDebugLogger('aztec:world_state')) {
-        _ServerWorldStateSynchronizer_instances.add(this);
+    constructor(merkleTreeDb, l2BlockSource, config, log = createDebugLogger('aztec:world_state')) {
         this.merkleTreeDb = merkleTreeDb;
         this.l2BlockSource = l2BlockSource;
         this.config = config;
         this.log = log;
         this.latestBlockNumberAtStart = 0;
-        this.syncPromise = Promise.resolve();
-        this.syncResolve = undefined;
-        this.jobQueue = new SerialQueue();
-        this.stopping = false;
-        this.runningPromise = Promise.resolve();
-        this.pausedPromise = undefined;
-        this.pausedResolve = undefined;
         this.currentState = WorldStateRunningState.IDLE;
-        this.blockNumber = store.openSingleton('world_state_synch_last_block_number');
-        this.l2BlockDownloader = new L2BlockDownloader(l2BlockSource, {
-            maxQueueSize: config.l2QueueSize,
-            pollIntervalMS: config.worldStateBlockCheckIntervalMS,
-            proven: config.worldStateProvenBlocksOnly,
-        });
-    }
-    getLatest() {
-        return new MerkleTreeAdminOperationsFacade(this.merkleTreeDb, true);
+        this.syncPromise = promiseWithResolvers();
+        this.merkleTreeCommitted = this.merkleTreeDb.getCommitted();
     }
     getCommitted() {
-        return new MerkleTreeAdminOperationsFacade(this.merkleTreeDb, false);
+        return this.merkleTreeDb.getCommitted();
     }
     getSnapshot(blockNumber) {
-        return new MerkleTreeSnapshotOperationsFacade(this.merkleTreeDb, blockNumber);
+        return this.merkleTreeDb.getSnapshot(blockNumber);
     }
-    async ephemeralFork() {
-        return new MerkleTreeOperationsFacade(await this.merkleTreeDb.ephemeralFork(), true);
-    }
-    async getFork(includeUncommitted) {
-        this.log.verbose(`Forking world state at ${this.blockNumber.get()}`);
-        return new MerkleTreeAdminOperationsFacade(await this.merkleTreeDb.fork(), includeUncommitted);
+    fork(blockNumber) {
+        return this.merkleTreeDb.fork(blockNumber);
     }
     async start() {
         if (this.currentState === WorldStateRunningState.STOPPED) {
@@ -61,77 +37,50 @@ export class ServerWorldStateSynchronizer {
         if (this.currentState !== WorldStateRunningState.IDLE) {
             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;
-        // if there are blocks to be retrieved, go to a synching state
+        const blockToDownloadFrom = (await this.getLatestBlockNumber()) + 1;
         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;
+    }
+    createBlockStream() {
+        return new L2BlockStream(this.l2BlockSource, this, this, {
+            proven: this.config.worldStateProvenBlocksOnly,
+            pollIntervalMS: this.config.worldStateBlockCheckIntervalMS,
+            batchSize: this.config.worldStateBlockRequestBatchSize,
+        });
     }
     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.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`);
-    }
-    get currentL2BlockNum() {
-        return this.blockNumber.get() ?? 0;
-    }
-    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');
-    }
-    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');
-        }
+        this.log.info(`Stopped world state synchronizer`);
     }
-    status() {
-        const status = {
-            syncedToL2Block: this.currentL2BlockNum,
+    async status() {
+        return {
+            syncedToL2Block: (await this.getL2Tips()).latest,
             state: this.currentState,
         };
-        return Promise.resolve(status);
+    }
+    async getLatestBlockNumber() {
+        return (await this.getL2Tips()).latest.number;
     }
     /**
      * Forces an immediate sync.
@@ -139,69 +88,80 @@ export class ServerWorldStateSynchronizer {
      * @returns A promise that resolves with the block number the world state was synced to
      */
     async syncImmediate(targetBlockNumber) {
-        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;
+    }
+    /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */
+    getL2BlockHash(number) {
+        return number === 0
+            ? Promise.resolve(this.merkleTreeCommitted.getInitialHeader().hash().toString())
+            : 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). */
+    async getL2Tips() {
+        const status = await this.merkleTreeDb.getStatus();
+        const unfinalisedBlockHash = await this.getL2BlockHash(Number(status.unfinalisedBlockNumber));
+        const latestBlockId = { number: Number(status.unfinalisedBlockNumber), hash: unfinalisedBlockHash };
+        return {
+            latest: latestBlockId,
+            finalized: { number: Number(status.finalisedBlockNumber), hash: '' },
+            proven: { number: Number(status.finalisedBlockNumber), hash: '' }, // TODO(palla/reorg): Using finalised as proven for now
+        };
     }
-    async syncImmediateAndFork(targetBlockNumber, forkIncludeUncommitted) {
+    /** Handles an event emitted by the block stream. */
+    async handleBlockStreamEvent(event) {
         try {
-            await this.pause();
-            await this.syncImmediate(targetBlockNumber);
-            return await this.getFork(forkIncludeUncommitted);
+            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;
+            }
         }
-        finally {
-            this.resume();
+        catch (err) {
+            this.log.error('Error processing block stream', err);
         }
     }
-    /**
-     * Checks for the availability of new blocks and processes them.
-     */
-    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 = await Promise.all(messagePromises);
-        await this.handleL2BlocksAndMessages(blocks, l1ToL2Messages);
-    }
     /**
      * 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.
      */
-    async handleL2BlocksAndMessages(l2Blocks, l1ToL2Messages) {
+    async handleL2Blocks(l2Blocks) {
+        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 = 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(),
             });
         }
@@ -212,23 +172,32 @@ export class ServerWorldStateSynchronizer {
      * @param l1ToL2Messages - The L1 to L2 messages for the block.
      * @returns Whether the block handled was produced by this same node.
      */
-    async handleL2BlockAndMessages(l2Block, l1ToL2Messages) {
+    async handleL2Block(l2Block, l1ToL2Messages) {
         // 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.
-        __classPrivateFieldGet(this, _ServerWorldStateSynchronizer_instances, "m", _ServerWorldStateSynchronizer_verifyMessagesHashToInHash).call(this, 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;
     }
+    async handleChainFinalized(blockNumber) {
+        this.log.verbose(`Chain finalized at block ${blockNumber}`);
+        await this.merkleTreeDb.setFinalised(BigInt(blockNumber));
+    }
+    handleChainProven(blockNumber) {
+        this.log.verbose(`Chain proven at block ${blockNumber}`);
+        return Promise.resolve();
+    }
+    async handleChainPruned(blockNumber) {
+        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.
@@ -237,12 +206,18 @@ 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.
+     */
+    verifyMessagesHashToInHash(l1ToL2Messages, inHash) {
+        const treeCalculator = new MerkleTreeCalculator(L1_TO_L2_MSG_SUBTREE_HEIGHT, Buffer.alloc(32), new SHA256Trunc().hash);
+        const root = 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');
+        }
+    }
 }
-_ServerWorldStateSynchronizer_instances = new WeakSet(), _ServerWorldStateSynchronizer_verifyMessagesHashToInHash = function _ServerWorldStateSynchronizer_verifyMessagesHashToInHash(l1ToL2Messages, inHash) {
-    const treeCalculator = new MerkleTreeCalculator(L1_TO_L2_MSG_SUBTREE_HEIGHT, Buffer.alloc(32), new SHA256Trunc().hash);
-    const root = 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');
-    }
-};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server_world_state_synchronizer.js","sourceRoot":"","sources":["../../src/synchronizer/server_world_state_synchronizer.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server_world_state_synchronizer.js","sourceRoot":"","sources":["../../src/synchronizer/server_world_state_synchronizer.ts"],"names":[],"mappings":"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"}

package/dest/test/utils.d.ts

@@ -0,0 +1,14 @@
+import { L2Block, type MerkleTreeReadOperations, type MerkleTreeWriteOperations } from '@aztec/circuit-types';
+import { Fr } from '@aztec/circuits.js';
+import { type NativeWorldStateService } from '../native/native_world_state.js';
+export declare function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations): Promise<{
+    block: L2Block;
+    messages: Fr[];
+}>;
+export declare function mockBlocks(from: number, count: number, numTxs: number, worldState: NativeWorldStateService): Promise<{
+    blocks: L2Block[];
+    messages: Fr[][];
+}>;
+export declare function assertSameState(forkA: MerkleTreeReadOperations, forkB: MerkleTreeReadOperations): Promise<void>;
+export declare function compareChains(left: MerkleTreeReadOperations, right: MerkleTreeReadOperations): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dest/test/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAEP,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAG/B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,EAAE,EAQH,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB;;;GA2D9F;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,uBAAuB;;;GAchH;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAQrG;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAYlG"}

package/dest/test/utils.js

@@ -0,0 +1,67 @@
+import { L2Block, MerkleTreeId, 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';
+export async function mockBlock(blockNum, size, fork) {
+    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, count, numTxs, worldState) {
+    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, forkB) {
+    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, right) {
+    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));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsT0FBTyxFQUNQLFlBQVksRUFHWixlQUFlLEVBQ2YsUUFBUSxHQUNULE1BQU0sc0JBQXNCLENBQUM7QUFDOUIsT0FBTyxFQUNMLHNCQUFzQixFQUN0QixFQUFFLEVBQ0Ysc0JBQXNCLEVBQ3RCLHFCQUFxQixFQUNyQiw0Q0FBNEMsRUFDNUMsd0JBQXdCLEVBQ3hCLG1DQUFtQyxFQUNuQywwQkFBMEIsRUFDMUIsa0JBQWtCLEdBQ25CLE1BQU0sb0JBQW9CLENBQUM7QUFDNUIsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBSTNELE1BQU0sQ0FBQyxLQUFLLFVBQVUsU0FBUyxDQUFDLFFBQWdCLEVBQUUsSUFBWSxFQUFFLElBQStCO0lBQzdGLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQy9DLE1BQU0sY0FBYyxHQUFHLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUV4RCxNQUFNLGVBQWUsR0FBRyxXQUFXLENBQ2pDLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUN0QixRQUFRLENBQUMsS0FBSyxFQUFFLEVBQ2hCLE9BQU8sQ0FBQyxJQUFJLENBQUMsMEJBQTBCLENBQ3hDLENBQUM7SUFFRiw2QkFBNkI7SUFDN0IsQ0FBQztRQUNDLE1BQU0sZ0JBQWdCLEdBQUcsZUFBZSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUMxRCxXQUFXLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUMsSUFBSSxFQUFFLHNCQUFzQixDQUFDLENBQ2xFLENBQUM7UUFDRixNQUFNLElBQUksQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUFDLGNBQWMsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO1FBRXZFLE1BQU0sb0JBQW9CLEdBQUcsV0FBVyxDQUFDLGNBQWMsRUFBRSxFQUFFLENBQUMsSUFBSSxFQUFFLG1DQUFtQyxDQUFDLENBQUM7UUFDdkcsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBQyxxQkFBcUIsRUFBRSxvQkFBb0IsQ0FBQyxDQUFDO0lBQ3BGLENBQUM7SUFFRCx5QkFBeUI7SUFDekIsQ0FBQztRQUNDLG1HQUFtRztRQUNuRyxLQUFLLE1BQU0sUUFBUSxJQUFJLGVBQWUsRUFBRSxDQUFDO1lBQ3ZDLE1BQU0sZ0JBQWdCLEdBQUcsV0FBVyxDQUNsQyxRQUFRLENBQUMsZ0JBQWdCLEVBQ3pCLGVBQWUsQ0FBQyxLQUFLLEVBQUUsRUFDdkIsNENBQTRDLENBQzdDLENBQUM7WUFFRixNQUFNLElBQUksQ0FBQyxXQUFXLENBQ3BCLFlBQVksQ0FBQyxnQkFBZ0IsRUFDN0IsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsSUFBSSxrQkFBa0IsQ0FBQyxLQUFLLENBQUMsU0FBUyxFQUFFLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxFQUNqRywwQkFBMEIsQ0FDM0IsQ0FBQztZQUVGLE1BQU0sZ0JBQWdCLEdBQUcsV0FBVyxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDLElBQUksRUFBRSxxQkFBcUIsQ0FBQyxDQUFDO1lBRTFGLE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FDcEIsWUFBWSxDQUFDLGNBQWMsRUFDM0IsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRSxDQUFDLEVBQ3ZELHdCQUF3QixDQUN6QixDQUFDO1FBQ0osQ0FBQztJQUNILENBQUM7SUFFRCxNQUFNLEtBQUssR0FBRyxNQUFNLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO0lBQzdDLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUM3QixNQUFNLElBQUksQ0FBQyxhQUFhLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRXpDLE1BQU0sWUFBWSxHQUFHLE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFbEUsT0FBTyxDQUFDLE9BQU8sR0FBRyxJQUFJLHNCQUFzQixDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxFQUFFLE1BQU0sQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUUxRyxPQUFPO1FBQ0wsS0FBSyxFQUFFLE9BQU87UUFDZCxRQUFRLEVBQUUsY0FBYztLQUN6QixDQUFDO0FBQ0osQ0FBQztBQUVELE1BQU0sQ0FBQyxLQUFLLFVBQVUsVUFBVSxDQUFDLElBQVksRUFBRSxLQUFhLEVBQUUsTUFBYyxFQUFFLFVBQW1DO0lBQy9HLE1BQU0sUUFBUSxHQUFHLE1BQU0sVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFFakQsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFDO0lBQ2xCLE1BQU0sYUFBYSxHQUFHLEVBQUUsQ0FBQztJQUN6QixLQUFLLElBQUksV0FBVyxHQUFHLElBQUksRUFBRSxXQUFXLEdBQUcsSUFBSSxHQUFHLEtBQUssRUFBRSxXQUFXLEVBQUUsRUFBRSxDQUFDO1FBQ3ZFLE1BQU0sRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLEdBQUcsTUFBTSxTQUFTLENBQUMsV0FBVyxFQUFFLE1BQU0sRUFBRSxRQUFRLENBQUMsQ0FBQztRQUMzRSxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ25CLGFBQWEsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVELE1BQU0sUUFBUSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBRXZCLE9BQU8sRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBRSxDQUFDO0FBQzdDLENBQUM7QUFFRCxNQUFNLENBQUMsS0FBSyxVQUFVLGVBQWUsQ0FBQyxLQUErQixFQUFFLEtBQStCO0lBQ3BHLE1BQU0sY0FBYyxHQUFHLE1BQU0sS0FBSyxDQUFDLGlCQUFpQixFQUFFLENBQUM7SUFDdkQsTUFBTSxhQUFhLEdBQUcsTUFBTSxLQUFLLENBQUMsV0FBVyxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNwRSxNQUFNLGNBQWMsR0FBRyxNQUFNLEtBQUssQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO0lBQ3ZELE1BQU0sYUFBYSxHQUFHLE1BQU0sS0FBSyxDQUFDLFdBQVcsQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFcEUsTUFBTSxDQUFDLGNBQWMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUMvQyxNQUFNLENBQUMsYUFBYSxDQUFDLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0FBQy9DLENBQUM7QUFFRCxNQUFNLENBQUMsS0FBSyxVQUFVLGFBQWEsQ0FBQyxJQUE4QixFQUFFLEtBQStCO0lBQ2pHLEtBQUssTUFBTSxNQUFNLElBQUk7UUFDbkIsWUFBWSxDQUFDLE9BQU87UUFDcEIsWUFBWSxDQUFDLHFCQUFxQjtRQUNsQyxZQUFZLENBQUMsY0FBYztRQUMzQixZQUFZLENBQUMsY0FBYztRQUMzQixZQUFZLENBQUMsZ0JBQWdCO0tBQzlCLEVBQUUsQ0FBQztRQUNGLE1BQU0sQ0FBQyxNQUFNLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsTUFBTSxLQUFLLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7UUFFaEYsTUFBTSxDQUFDLE1BQU0sSUFBSSxDQUFDLGNBQWMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsTUFBTSxLQUFLLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ2hHLENBQUM7QUFDSCxDQUFDIn0=

package/dest/world-state-db/index.d.ts

@@ -2,5 +2,5 @@ export * from './merkle_trees.js';
 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';
 //# sourceMappingURL=index.d.ts.map

package/dest/world-state-db/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/world-state-db/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAE5D,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/world-state-db/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAE5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC"}

package/dest/world-state-db/merkle_tree_db.d.ts

@@ -1,7 +1,8 @@
-import { type MerkleTreeId } from '@aztec/circuit-types';
-import { type MerkleTreeAdminOperations, type MerkleTreeOperations } from '@aztec/circuit-types/interfaces';
+import { type L2Block, type MerkleTreeId } from '@aztec/circuit-types';
+import { type MerkleTreeReadOperations, type MerkleTreeWriteOperations } from '@aztec/circuit-types/interfaces';
 import { type Fr } from '@aztec/circuits.js';
 import { type IndexedTreeSnapshot, type TreeSnapshot } from '@aztec/merkle-tree';
+import { type WorldStateStatus } from '../native/message.js';
 /**
  *
  * @remarks Short explanation:
@@ -19,15 +20,6 @@ import { type IndexedTreeSnapshot, type TreeSnapshot } from '@aztec/merkle-tree'
  */
 export declare const INITIAL_NULLIFIER_TREE_SIZE: number;
 export declare const INITIAL_PUBLIC_DATA_TREE_SIZE: number;
-/**
- * Adds a last boolean flag in each function on the type.
- */
-type WithIncludeUncommitted<F> = F extends (...args: [...infer Rest]) => infer Return ? (...args: [...Rest, boolean]) => Return : F;
-/**
- * Defines the names of the setters on Merkle Trees.
- */
-type MerkleTreeSetters = 'appendLeaves' | 'updateLeaf' | 'batchInsert';
-type MerkleTreeAdmin = 'commit' | 'rollback' | 'handleL2BlockAndMessages';
 export type TreeSnapshots = {
     [MerkleTreeId.NULLIFIER_TREE]: IndexedTreeSnapshot;
     [MerkleTreeId.NOTE_HASH_TREE]: TreeSnapshot<Fr>;
@@ -35,33 +27,51 @@ export type TreeSnapshots = {
     [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: TreeSnapshot<Fr>;
     [MerkleTreeId.ARCHIVE]: TreeSnapshot<Fr>;
 };
-/** Defines the interface for operations on a set of Merkle Trees configuring whether to return committed or uncommitted data. */
-export type MerkleTreeDb = {
-    [Property in keyof MerkleTreeOperations as Exclude<Property, MerkleTreeSetters>]: WithIncludeUncommitted<MerkleTreeOperations[Property]>;
-} & Pick<MerkleTreeOperations, MerkleTreeSetters> & {
+export interface MerkleTreeAdminDatabase {
     /**
-     * Returns a snapshot of the current state of the trees.
-     * @param block - The block number to take the snapshot at.
+     * Handles a single L2 block (i.e. Inserts the new note hashes into the merkle tree).
+     * @param block - The L2 block to handle.
+     * @param l1ToL2Messages - The L1 to L2 messages for the block.
      */
-    getSnapshot(block: number): Promise<TreeSnapshots>;
-};
-/** Extends operations on MerkleTreeDb to include modifying the underlying store */
-export type MerkleTreeAdminDb = {
-    [Property in keyof MerkleTreeAdminOperations as Exclude<Property, MerkleTreeSetters | MerkleTreeAdmin>]: WithIncludeUncommitted<MerkleTreeAdminOperations[Property]>;
-} & Pick<MerkleTreeAdminOperations, MerkleTreeSetters | MerkleTreeAdmin> & {
+    handleL2BlockAndMessages(block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatus>;
+    /**
+     * Gets a handle that allows reading the latest committed state
+     */
+    getCommitted(): MerkleTreeReadOperations;
     /**
-     * Returns a snapshot of the current state of the trees.
-     * @param block - The block number to take the snapshot at.
+     * Gets a handle that allows reading the state as it was at the given block number
+     * @param blockNumber - The block number to get the snapshot for
      */
-    getSnapshot(block: number): Promise<TreeSnapshots>;
+    getSnapshot(blockNumber: number): MerkleTreeReadOperations;
     /**
      * Forks the database at its current state.
+     * @param blockNumber - The block number to fork at. If not provided, the current block number is used.
+     */
+    fork(blockNumber?: number): Promise<MerkleTreeWriteOperations>;
+    /**
+     * Removes all historical snapshots up to but not including the given block number
+     * @param toBlockNumber The block number of the new oldest historical block
+     * @returns The new WorldStateStatus
+     */
+    removeHistoricalBlocks(toBlockNumber: bigint): Promise<WorldStateStatus>;
+    /**
+     * Removes all pending blocks down to but not including the given block number
+     * @param toBlockNumber The block number of the new tip of the pending chain,
+     * @returns The new WorldStateStatus
+     */
+    unwindBlocks(toBlockNumber: bigint): Promise<WorldStateStatus>;
+    /**
+     * Advances the finalised block number to be the number provided
+     * @param toBlockNumber The block number that is now the tip of the finalised chain
+     * @returns The new WorldStateStatus
+     */
+    setFinalised(toBlockNumber: bigint): Promise<WorldStateStatus>;
+    /**
+     * Gets the current status of the database.
+     * @returns The current WorldStateStatus.
      */
-    fork(): Promise<MerkleTreeDb>;
-    /** Deletes this database. */
-    delete(): Promise<void>;
+    getStatus(): Promise<WorldStateStatus>;
     /** Stops the database */
-    stop(): Promise<void>;
-};
-export {};
+    close(): Promise<void>;
+}
 //# sourceMappingURL=merkle_tree_db.d.ts.map