@aztec/world-state 0.0.0-test.0

package/dest/synchronizer/factory.d.ts

@@ -0,0 +1,12 @@
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
+import { NativeWorldStateService } from '../native/native_world_state.js';
+import type { WorldStateConfig } from './config.js';
+import { ServerWorldStateSynchronizer } from './server_world_state_synchronizer.js';
+export declare function createWorldStateSynchronizer(config: WorldStateConfig & DataStoreConfig, l2BlockSource: L2BlockSource & L1ToL2MessageSource, prefilledPublicData?: PublicDataTreeLeaf[], client?: TelemetryClient): Promise<ServerWorldStateSynchronizer>;
+export declare function createWorldState(config: WorldStateConfig & DataStoreConfig, prefilledPublicData?: PublicDataTreeLeaf[], instrumentation?: WorldStateInstrumentation): Promise<NativeWorldStateService>;
+//# sourceMappingURL=factory.d.ts.map

package/dest/synchronizer/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/synchronizer/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AAEpF,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,gBAAgB,GAAG,eAAe,EAC1C,aAAa,EAAE,aAAa,GAAG,mBAAmB,EAClD,mBAAmB,GAAE,kBAAkB,EAAO,EAC9C,MAAM,GAAE,eAAsC,yCAK/C;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,gBAAgB,GAAG,eAAe,EAC1C,mBAAmB,GAAE,kBAAkB,EAAO,EAC9C,eAAe,GAAE,yBAA+E,oCA2BjG"}

package/dest/synchronizer/factory.js

@@ -0,0 +1,24 @@
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
+import { NativeWorldStateService } from '../native/native_world_state.js';
+import { ServerWorldStateSynchronizer } from './server_world_state_synchronizer.js';
+export async function createWorldStateSynchronizer(config, l2BlockSource, prefilledPublicData = [], client = getTelemetryClient()) {
+    const instrumentation = new WorldStateInstrumentation(client);
+    const merkleTrees = await createWorldState(config, prefilledPublicData, instrumentation);
+    return new ServerWorldStateSynchronizer(merkleTrees, l2BlockSource, config, instrumentation);
+}
+export async function createWorldState(config, prefilledPublicData = [], instrumentation = new WorldStateInstrumentation(getTelemetryClient())) {
+    const newConfig = {
+        dataDirectory: config.worldStateDataDirectory ?? config.dataDirectory,
+        dataStoreMapSizeKB: config.worldStateDbMapSizeKb ?? config.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 ? await NativeWorldStateService.new(config.l1Contracts.rollupAddress, newConfig.dataDirectory, newConfig.dataStoreMapSizeKB, prefilledPublicData, instrumentation) : await NativeWorldStateService.tmp(config.l1Contracts.rollupAddress, ![
+        'true',
+        '1'
+    ].includes(process.env.DEBUG_WORLD_STATE), prefilledPublicData);
+    return merkleTrees;
+}

package/dest/synchronizer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './server_world_state_synchronizer.js';
+export * from './factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/synchronizer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/synchronizer/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,cAAc,CAAC"}

package/dest/synchronizer/index.js

@@ -0,0 +1,2 @@
+export * from './server_world_state_synchronizer.js';
+export * from './factory.js';

package/dest/synchronizer/server_world_state_synchronizer.d.ts

@@ -0,0 +1,79 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Fr } from '@aztec/foundation/fields';
+import type { L2BlockSource, L2BlockStream, L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider, L2Tips } from '@aztec/stdlib/block';
+import { type WorldStateSynchronizer, type WorldStateSynchronizerStatus } from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import { type MerkleTreeReadOperations, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { WorldStateInstrumentation } from '../instrumentation/instrumentation.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 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 declare class ServerWorldStateSynchronizer implements WorldStateSynchronizer, L2BlockStreamLocalDataProvider, L2BlockStreamEventHandler {
+    private readonly merkleTreeDb;
+    private readonly l2BlockSource;
+    private readonly config;
+    private instrumentation;
+    private readonly log;
+    private readonly merkleTreeCommitted;
+    private latestBlockNumberAtStart;
+    private historyToKeep;
+    private currentState;
+    private latestBlockHashQuery;
+    private syncPromise;
+    protected blockStream: L2BlockStream | undefined;
+    constructor(merkleTreeDb: MerkleTreeAdminDatabase, l2BlockSource: L2BlockSource & L1ToL2MessageSource, config: WorldStateConfig, instrumentation?: WorldStateInstrumentation, log?: import("@aztec/foundation/log").Logger);
+    getCommitted(): MerkleTreeReadOperations;
+    getSnapshot(blockNumber: number): MerkleTreeReadOperations;
+    fork(blockNumber?: number): Promise<MerkleTreeWriteOperations>;
+    start(): Promise<void | import("@aztec/foundation/promise").PromiseWithResolvers<void>>;
+    protected createBlockStream(): L2BlockStream;
+    stop(): Promise<void>;
+    status(): Promise<WorldStateSynchronizerStatus>;
+    getLatestBlockNumber(): Promise<number>;
+    /**
+     * 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.
+     * @returns A promise that resolves with the block number the world state was synced to
+     */
+    syncImmediate(targetBlockNumber?: number): Promise<number>;
+    /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */
+    getL2BlockHash(number: number): Promise<string | undefined>;
+    /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */
+    getL2Tips(): Promise<L2Tips>;
+    /** Handles an event emitted by the block stream. */
+    handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
+    /**
+     * Handles a list of L2 blocks (i.e. Inserts the new note hashes into the merkle tree).
+     * @param l2Blocks - The L2 blocks to handle.
+     * @returns Whether the block handled was produced by this same node.
+     */
+    private handleL2Blocks;
+    /**
+     * Handles a single L2 block (i.e. Inserts the new note hashes into the merkle tree).
+     * @param l2Block - The L2 block to handle.
+     * @param l1ToL2Messages - The L1 to L2 messages for the block.
+     * @returns Whether the block handled was produced by this same node.
+     */
+    private handleL2Block;
+    private handleChainFinalized;
+    private handleChainProven;
+    private handleChainPruned;
+    /**
+     * Method to set the value of the current state.
+     * @param newState - New state value.
+     */
+    private setCurrentState;
+    /**
+     * 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 verifyMessagesHashToInHash(l1ToL2Messages: Fr[], inHash: Buffer): Promise<void>;
+}
+//# sourceMappingURL=server_world_state_synchronizer.d.ts.map

package/dest/synchronizer/server_world_state_synchronizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server_world_state_synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/server_world_state_synchronizer.ts"],"names":[],"mappings":";;AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAMnD,OAAO,KAAK,EAGV,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,yBAAyB,EACzB,8BAA8B,EAC9B,MAAM,EACP,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EAClC,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAAgB,KAAK,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAGlH,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAElF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;GAIG;AACH,qBAAa,4BACX,YAAW,sBAAsB,EAAE,8BAA8B,EAAE,yBAAyB;IAa1F,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAftB,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA2B;IAE/D,OAAO,CAAC,wBAAwB,CAAK;IACrC,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,YAAY,CAAuD;IAC3E,OAAO,CAAC,oBAAoB,CAA4E;IAExG,OAAO,CAAC,WAAW,CAAgC;IACnD,SAAS,CAAC,WAAW,EAAE,aAAa,GAAG,SAAS,CAAC;gBAG9B,YAAY,EAAE,uBAAuB,EACrC,aAAa,EAAE,aAAa,GAAG,mBAAmB,EAClD,MAAM,EAAE,gBAAgB,EACjC,eAAe,4BAAsD,EAC5D,GAAG,yCAA8B;IAW7C,YAAY,IAAI,wBAAwB;IAIxC,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,wBAAwB;IAI1D,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAIxD,KAAK;IAgClB,SAAS,CAAC,iBAAiB,IAAI,aAAa;IAU/B,IAAI;IASJ,MAAM,IAAI,OAAO,CAAC,4BAA4B,CAAC;IAe/C,oBAAoB;IAIjC;;;;OAIG;IACU,aAAa,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAwBvE,oGAAoG;IACvF,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAexE,gGAAgG;IACnF,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAYzC,oDAAoD;IACvC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB7E;;;;OAIG;YACW,cAAc;IAyB5B;;;;;OAKG;YACW,aAAa;YAuBb,oBAAoB;IAelC,OAAO,CAAC,iBAAiB;YAKX,iBAAiB;IAO/B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAKvB;;;;;OAKG;cACa,0BAA0B,CAAC,cAAc,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM;CAahF"}

package/dest/synchronizer/server_world_state_synchronizer.js

@@ -0,0 +1,277 @@
+import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import { 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 { WorldStateRunningState } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { TraceableL2BlockStream, getTelemetryClient } from '@aztec/telemetry-client';
+import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
+/**
+ * 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 {
+    merkleTreeDb;
+    l2BlockSource;
+    config;
+    instrumentation;
+    log;
+    merkleTreeCommitted;
+    latestBlockNumberAtStart;
+    historyToKeep;
+    currentState;
+    latestBlockHashQuery;
+    syncPromise;
+    blockStream;
+    constructor(merkleTreeDb, l2BlockSource, config, instrumentation = new WorldStateInstrumentation(getTelemetryClient()), log = createLogger('world_state')){
+        this.merkleTreeDb = merkleTreeDb;
+        this.l2BlockSource = l2BlockSource;
+        this.config = config;
+        this.instrumentation = instrumentation;
+        this.log = log;
+        this.latestBlockNumberAtStart = 0;
+        this.currentState = WorldStateRunningState.IDLE;
+        this.latestBlockHashQuery = undefined;
+        this.syncPromise = promiseWithResolvers();
+        this.merkleTreeCommitted = this.merkleTreeDb.getCommitted();
+        this.historyToKeep = config.worldStateBlockHistory < 1 ? undefined : config.worldStateBlockHistory;
+        this.log.info(`Created world state synchroniser with block history of ${this.historyToKeep === undefined ? 'infinity' : this.historyToKeep}`);
+    }
+    getCommitted() {
+        return this.merkleTreeDb.getCommitted();
+    }
+    getSnapshot(blockNumber) {
+        return this.merkleTreeDb.getSnapshot(blockNumber);
+    }
+    fork(blockNumber) {
+        return this.merkleTreeDb.fork(blockNumber);
+    }
+    async start() {
+        if (this.currentState === WorldStateRunningState.STOPPED) {
+            throw new Error('Synchronizer already stopped');
+        }
+        if (this.currentState !== WorldStateRunningState.IDLE) {
+            return this.syncPromise;
+        }
+        // Get the current latest block number
+        this.latestBlockNumberAtStart = await (this.config.worldStateProvenBlocksOnly ? this.l2BlockSource.getProvenBlockNumber() : this.l2BlockSource.getBlockNumber());
+        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.log.verbose(`Starting sync from ${blockToDownloadFrom} to latest block ${this.latestBlockNumberAtStart}`);
+        } else {
+            // If no blocks to be retrieved, go straight to running
+            this.setCurrentState(WorldStateRunningState.RUNNING);
+            this.syncPromise.resolve();
+            this.log.debug(`Next block ${blockToDownloadFrom} already beyond latest block ${this.latestBlockNumberAtStart}`);
+        }
+        this.blockStream = this.createBlockStream();
+        this.blockStream.start();
+        this.log.info(`Started world state synchronizer from block ${blockToDownloadFrom}`);
+        return this.syncPromise.promise;
+    }
+    createBlockStream() {
+        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,
+            pollIntervalMS: this.config.worldStateBlockCheckIntervalMS,
+            batchSize: this.config.worldStateBlockRequestBatchSize
+        });
+    }
+    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`);
+    }
+    async status() {
+        const summary = await this.merkleTreeDb.getStatusSummary();
+        const status = {
+            latestBlockNumber: Number(summary.unfinalisedBlockNumber),
+            latestBlockHash: await this.getL2BlockHash(Number(summary.unfinalisedBlockNumber)) ?? '',
+            finalisedBlockNumber: Number(summary.finalisedBlockNumber),
+            oldestHistoricBlockNumber: Number(summary.oldestHistoricalBlock),
+            treesAreSynched: summary.treesAreSynched
+        };
+        return {
+            syncSummary: status,
+            state: this.currentState
+        };
+    }
+    async getLatestBlockNumber() {
+        return (await this.getL2Tips()).latest.number;
+    }
+    /**
+   * 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.
+   * @returns A promise that resolves with the block number the world state was synced to
+   */ async syncImmediate(targetBlockNumber) {
+        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
+        const currentBlockNumber = await this.getLatestBlockNumber();
+        if (targetBlockNumber !== undefined && targetBlockNumber <= currentBlockNumber) {
+            return currentBlockNumber;
+        }
+        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. */ async getL2BlockHash(number) {
+        if (number === 0) {
+            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;
+    }
+    /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */ async getL2Tips() {
+        const status = await this.merkleTreeDb.getStatusSummary();
+        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: ''
+            }
+        };
+    }
+    /** Handles an event emitted by the block stream. */ async handleBlockStreamEvent(event) {
+        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.
+   * @returns Whether the block handled was produced by this same node.
+   */ async handleL2Blocks(l2Blocks) {
+        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 l1ToL2Messages = await Promise.all(messagePromises);
+        let updateStatus = 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}`, {
+                eventName: 'l2-block-handled',
+                duration,
+                unfinalisedBlockNumber: result.summary.unfinalisedBlockNumber,
+                finalisedBlockNumber: result.summary.finalisedBlockNumber,
+                oldestHistoricBlock: result.summary.oldestHistoricalBlock,
+                ...l2Blocks[i].getStats()
+            });
+            updateStatus = result;
+        }
+        if (!updateStatus) {
+            return;
+        }
+        this.instrumentation.updateWorldStateMetrics(updateStatus);
+    }
+    /**
+   * Handles a single L2 block (i.e. Inserts the new note hashes into the merkle tree).
+   * @param l2Block - The L2 block to handle.
+   * @param l1ToL2Messages - The L1 to L2 messages for the block.
+   * @returns Whether the block handled was produced by this same node.
+   */ 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.
+        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 `, {
+            blockNumber: l2Block.number,
+            blockHash: await l2Block.hash().then((h)=>h.toString()),
+            l1ToL2Messages: l1ToL2Messages.map((msg)=>msg.toString())
+        });
+        const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
+        if (this.currentState === WorldStateRunningState.SYNCHING && l2Block.number >= this.latestBlockNumberAtStart) {
+            this.setCurrentState(WorldStateRunningState.RUNNING);
+            this.syncPromise.resolve();
+        }
+        return result;
+    }
+    async handleChainFinalized(blockNumber) {
+        this.log.verbose(`Finalized chain is now at block ${blockNumber}`);
+        const summary = await this.merkleTreeDb.setFinalised(BigInt(blockNumber));
+        if (this.historyToKeep === undefined) {
+            return;
+        }
+        const newHistoricBlock = summary.finalisedBlockNumber - BigInt(this.historyToKeep) + 1n;
+        if (newHistoricBlock <= 1) {
+            return;
+        }
+        this.log.verbose(`Pruning historic blocks to ${newHistoricBlock}`);
+        const status = await this.merkleTreeDb.removeHistoricalBlocks(newHistoricBlock);
+        this.log.debug(`World state summary `, status.summary);
+    }
+    handleChainProven(blockNumber) {
+        this.log.debug(`Proven chain is now at block ${blockNumber}`);
+        return Promise.resolve();
+    }
+    async handleChainPruned(blockNumber) {
+        this.log.warn(`Chain pruned to block ${blockNumber}`);
+        const status = await this.merkleTreeDb.unwindBlocks(BigInt(blockNumber));
+        this.latestBlockHashQuery = undefined;
+        this.instrumentation.updateWorldStateMetrics(status);
+    }
+    /**
+   * Method to set the value of the current state.
+   * @param newState - New state value.
+   */ setCurrentState(newState) {
+        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.
+   */ async verifyMessagesHashToInHash(l1ToL2Messages, inHash) {
+        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/dest/test/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dest/test/index.js

@@ -0,0 +1 @@
+export * from './utils.js';

package/dest/test/utils.d.ts

@@ -0,0 +1,19 @@
+import { Fr } from '@aztec/foundation/fields';
+import { L2Block } from '@aztec/stdlib/block';
+import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+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 mockEmptyBlock(blockNum: 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":"AAOA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAG3G,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB;;;GA+C9F;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB;;;GAiDrF;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,99 @@
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { L2Block } from '@aztec/stdlib/block';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+export async function mockBlock(blockNum, size, fork) {
+    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);
+        }
+    }
+    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 mockEmptyBlock(blockNum, fork) {
+    const l2Block = L2Block.empty();
+    const l1ToL2Messages = Array(16).fill(0).map(Fr.zero);
+    l2Block.header.globalVariables.blockNumber = new Fr(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));
+    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));
+    }
+}

package/dest/testing.d.ts

@@ -0,0 +1,10 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+export declare const defaultInitialAccountFeeJuice: Fr;
+export declare function getGenesisValues(initialAccounts: AztecAddress[], initialAccountFeeJuice?: Fr, genesisPublicData?: PublicDataTreeLeaf[]): Promise<{
+    genesisArchiveRoot: Fr;
+    genesisBlockHash: Fr;
+    prefilledPublicData: PublicDataTreeLeaf[];
+}>;
+//# sourceMappingURL=testing.d.ts.map

package/dest/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAgB,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AA6BvE,eAAO,MAAM,6BAA6B,IAAqB,CAAC;AAEhE,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,YAAY,EAAE,EAC/B,sBAAsB,KAAgC,EACtD,iBAAiB,GAAE,kBAAkB,EAAO;;;;GAqB7C"}

package/dest/testing.js

@@ -0,0 +1,37 @@
+import { GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
+import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { NativeWorldStateService } from './native/index.js';
+async function generateGenesisValues(prefilledPublicData) {
+    if (!prefilledPublicData.length) {
+        return {
+            genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT),
+            genesisBlockHash: new Fr(GENESIS_BLOCK_HASH)
+        };
+    }
+    // Create a temporary world state to compute the genesis values.
+    const ws = await NativeWorldStateService.tmp(undefined /* rollupAddress */ , true, prefilledPublicData);
+    const initialHeader = ws.getInitialHeader();
+    const genesisBlockHash = await initialHeader.hash();
+    const genesisArchiveRoot = new Fr((await ws.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
+    await ws.close();
+    return {
+        genesisArchiveRoot,
+        genesisBlockHash
+    };
+}
+export const defaultInitialAccountFeeJuice = new Fr(10n ** 22n);
+export async function getGenesisValues(initialAccounts, initialAccountFeeJuice = defaultInitialAccountFeeJuice, genesisPublicData = []) {
+    // Top up the accounts with fee juice.
+    let prefilledPublicData = await Promise.all(initialAccounts.map(async (address)=>new PublicDataTreeLeaf(await computeFeePayerBalanceLeafSlot(address), initialAccountFeeJuice)));
+    // Add user-defined public data
+    prefilledPublicData = prefilledPublicData.concat(genesisPublicData);
+    prefilledPublicData.sort((a, b)=>b.slot.lt(a.slot) ? 1 : -1);
+    const { genesisBlockHash, genesisArchiveRoot } = await generateGenesisValues(prefilledPublicData);
+    return {
+        genesisArchiveRoot,
+        genesisBlockHash,
+        prefilledPublicData
+    };
+}

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

@@ -0,0 +1,3 @@
+export * from './merkle_tree_db.js';
+export type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/world-state-db/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AAEpC,YAAY,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC"}

package/dest/world-state-db/index.js

@@ -0,0 +1 @@
+export * from './merkle_tree_db.js';