@aztec/world-state 0.1.0-alpha11

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

@@ -0,0 +1,373 @@
+import { CONTRACT_TREE_HEIGHT, CONTRACT_TREE_ROOTS_TREE_HEIGHT, CircuitsWasm, L1_TO_L2_MESSAGES_ROOTS_TREE_HEIGHT, L1_TO_L2_MESSAGES_TREE_HEIGHT, NULLIFIER_TREE_HEIGHT, PRIVATE_DATA_TREE_HEIGHT, PRIVATE_DATA_TREE_ROOTS_TREE_HEIGHT, PUBLIC_DATA_TREE_HEIGHT, } from '@aztec/circuits.js';
+import { Pedersen, SparseTree, StandardIndexedTree, StandardTree, newTree, } from '@aztec/merkle-tree';
+import { INITIAL_NULLIFIER_TREE_SIZE, } from './index.js';
+import { MerkleTreeOperationsFacade } from '../merkle-tree/merkle_tree_operations_facade.js';
+import { MerkleTreeId, merkleTreeIds } from '@aztec/types';
+import { SerialQueue } from '@aztec/foundation/fifo';
+import { createDebugLogger } from '@aztec/foundation/log';
+/**
+ * A convenience class for managing multiple merkle trees.
+ */
+export class MerkleTrees {
+    constructor(db, log = createDebugLogger('aztec:merkle_trees')) {
+        this.db = db;
+        this.log = log;
+        this.trees = [];
+        this.jobQueue = new SerialQueue();
+    }
+    /**
+     * Initialises the collection of Merkle Trees.
+     * @param optionalWasm - WASM instance to use for hashing (if not provided PrimitivesWasm will be used).
+     */
+    async init(optionalWasm) {
+        const wasm = optionalWasm ?? (await CircuitsWasm.get());
+        const hasher = new Pedersen(wasm);
+        const contractTree = await newTree(StandardTree, this.db, hasher, `${MerkleTreeId[MerkleTreeId.CONTRACT_TREE]}`, CONTRACT_TREE_HEIGHT);
+        const contractTreeRootsTree = await newTree(StandardTree, this.db, hasher, `${MerkleTreeId[MerkleTreeId.CONTRACT_TREE_ROOTS_TREE]}`, CONTRACT_TREE_ROOTS_TREE_HEIGHT);
+        const nullifierTree = await newTree(StandardIndexedTree, this.db, hasher, `${MerkleTreeId[MerkleTreeId.NULLIFIER_TREE]}`, NULLIFIER_TREE_HEIGHT, INITIAL_NULLIFIER_TREE_SIZE);
+        const privateDataTree = await newTree(StandardTree, this.db, hasher, `${MerkleTreeId[MerkleTreeId.PRIVATE_DATA_TREE]}`, PRIVATE_DATA_TREE_HEIGHT);
+        const privateDataTreeRootsTree = await newTree(StandardTree, this.db, hasher, `${MerkleTreeId[MerkleTreeId.PRIVATE_DATA_TREE_ROOTS_TREE]}`, PRIVATE_DATA_TREE_ROOTS_TREE_HEIGHT);
+        const publicDataTree = await newTree(SparseTree, this.db, hasher, `${MerkleTreeId[MerkleTreeId.PUBLIC_DATA_TREE]}`, PUBLIC_DATA_TREE_HEIGHT);
+        const l1Tol2MessagesTree = await newTree(StandardTree, this.db, hasher, `${MerkleTreeId[MerkleTreeId.L1_TO_L2_MESSAGES_TREE]}`, L1_TO_L2_MESSAGES_TREE_HEIGHT);
+        const l1Tol2MessagesRootsTree = await newTree(StandardTree, this.db, hasher, `${MerkleTreeId[MerkleTreeId.L1_TO_L2_MESSAGES_ROOTS_TREE]}`, L1_TO_L2_MESSAGES_ROOTS_TREE_HEIGHT);
+        this.trees = [
+            contractTree,
+            contractTreeRootsTree,
+            nullifierTree,
+            privateDataTree,
+            privateDataTreeRootsTree,
+            publicDataTree,
+            l1Tol2MessagesTree,
+            l1Tol2MessagesRootsTree,
+        ];
+        this.jobQueue.start();
+        // The roots trees must contain the empty roots of their data trees
+        await this.updateHistoricRootsTrees(true);
+        const historicRootsTrees = [contractTreeRootsTree, privateDataTreeRootsTree, l1Tol2MessagesRootsTree];
+        await Promise.all(historicRootsTrees.map(tree => tree.commit()));
+    }
+    /**
+     * Method to asynchronously create and initialise a MerkleTrees instance.
+     * @param db - The db instance to use for data persistance.
+     * @param wasm - WASM instance to use for hashing (if not provided PrimitivesWasm will be used).
+     * @returns - A fully initialised MerkleTrees instance.
+     */
+    static async new(db, wasm) {
+        const merkleTrees = new MerkleTrees(db);
+        await merkleTrees.init(wasm);
+        return merkleTrees;
+    }
+    /**
+     * Stops the job queue (waits for all jobs to finish).
+     */
+    async stop() {
+        await this.jobQueue.end();
+    }
+    /**
+     * Gets a view of this db that returns uncommitted data.
+     * @returns - A facade for this instance.
+     */
+    asLatest() {
+        return new MerkleTreeOperationsFacade(this, true);
+    }
+    /**
+     * Gets a view of this db that returns committed data only.
+     * @returns - A facade for this instance.
+     */
+    asCommitted() {
+        return new MerkleTreeOperationsFacade(this, false);
+    }
+    /**
+     * Inserts into the roots trees (CONTRACT_TREE_ROOTS_TREE, PRIVATE_DATA_TREE_ROOTS_TREE, L1_TO_L2_MESSAGES_TREE_ROOTS_TREE)
+     * the current roots of the corresponding trees (CONTRACT_TREE, PRIVATE_DATA_TREE, L1_TO_L2_MESSAGES_TREE).
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     */
+    async updateHistoricRootsTrees(includeUncommitted) {
+        for (const [newTree, rootTree] of [
+            [MerkleTreeId.PRIVATE_DATA_TREE, MerkleTreeId.PRIVATE_DATA_TREE_ROOTS_TREE],
+            [MerkleTreeId.CONTRACT_TREE, MerkleTreeId.CONTRACT_TREE_ROOTS_TREE],
+            [MerkleTreeId.L1_TO_L2_MESSAGES_TREE, MerkleTreeId.L1_TO_L2_MESSAGES_ROOTS_TREE],
+        ]) {
+            const newTreeInfo = await this.getTreeInfo(newTree, includeUncommitted);
+            await this.appendLeaves(rootTree, [newTreeInfo.root]);
+        }
+    }
+    /**
+     * Gets the tree info for the specified tree.
+     * @param treeId - Id of the tree to get information from.
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     * @returns The tree info for the specified tree.
+     */
+    async getTreeInfo(treeId, includeUncommitted) {
+        return await this.synchronise(() => this._getTreeInfo(treeId, includeUncommitted));
+    }
+    /**
+     * Get the current roots of the commitment trees.
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     * @returns The current roots of the trees.
+     */
+    getCommitmentTreeRoots(includeUncommitted) {
+        const roots = [
+            MerkleTreeId.PRIVATE_DATA_TREE,
+            MerkleTreeId.CONTRACT_TREE,
+            MerkleTreeId.L1_TO_L2_MESSAGES_TREE,
+            MerkleTreeId.NULLIFIER_TREE,
+        ].map(tree => this.trees[tree].getRoot(includeUncommitted));
+        return {
+            privateDataTreeRoot: roots[0],
+            contractDataTreeRoot: roots[1],
+            l1Tol2MessagesTreeRoot: roots[2],
+            nullifierTreeRoot: roots[3],
+        };
+    }
+    /**
+     * Gets the value at the given index.
+     * @param treeId - The ID of the tree to get the leaf value from.
+     * @param index - The index of the leaf.
+     * @param includeUncommitted - Indicates whether to include uncommitted changes.
+     * @returns Leaf value at the given index (undefined if not found).
+     */
+    async getLeafValue(treeId, index, includeUncommitted) {
+        return await this.synchronise(() => this.trees[treeId].getLeafValue(index, includeUncommitted));
+    }
+    /**
+     * Gets the sibling path for a leaf in a tree.
+     * @param treeId - The ID of the tree.
+     * @param index - The index of the leaf.
+     * @param includeUncommitted - Indicates whether the sibling path should incro include uncommitted data.
+     * @returns The sibling path for the leaf.
+     */
+    async getSiblingPath(treeId, index, includeUncommitted) {
+        return await this.synchronise(() => this._getSiblingPath(treeId, index, includeUncommitted));
+    }
+    /**
+     * Appends leaves to a tree.
+     * @param treeId - The ID of the tree.
+     * @param leaves - The leaves to append.
+     * @returns Empty promise.
+     */
+    async appendLeaves(treeId, leaves) {
+        return await this.synchronise(() => this._appendLeaves(treeId, leaves));
+    }
+    /**
+     * Commits all pending updates.
+     * @returns Empty promise.
+     */
+    async commit() {
+        return await this.synchronise(() => this._commit());
+    }
+    /**
+     * Rolls back all pending updates.
+     * @returns Empty promise.
+     */
+    async rollback() {
+        return await this.synchronise(() => this._rollback());
+    }
+    /**
+     * Finds the index of the largest leaf whose value is less than or equal to the provided value.
+     * @param treeId - The ID of the tree to search.
+     * @param value - The value to be inserted into the tree.
+     * @param includeUncommitted - If true, the uncommitted changes are included in the search.
+     * @returns The found leaf index and a flag indicating if the corresponding leaf's value is equal to `newValue`.
+     */
+    async getPreviousValueIndex(treeId, value, includeUncommitted) {
+        return await this.synchronise(() => Promise.resolve(this._getIndexedTree(treeId).findIndexOfPreviousValue(value, includeUncommitted)));
+    }
+    /**
+     * Gets the leaf data at a given index and tree.
+     * @param treeId - The ID of the tree get the leaf from.
+     * @param index - The index of the leaf to get.
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     * @returns Leaf data.
+     */
+    async getLeafData(treeId, index, includeUncommitted) {
+        return await this.synchronise(() => Promise.resolve(this._getIndexedTree(treeId).getLatestLeafDataCopy(index, includeUncommitted)));
+    }
+    /**
+     * Returns the index of a leaf given its value, or undefined if no leaf with that value is found.
+     * @param treeId - The ID of the tree.
+     * @param value - The leaf value to look for.
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     * @returns The index of the first leaf found with a given value (undefined if not found).
+     */
+    async findLeafIndex(treeId, value, includeUncommitted) {
+        return await this.synchronise(async () => {
+            const tree = this.trees[treeId];
+            for (let i = 0n; i < tree.getNumLeaves(includeUncommitted); i++) {
+                const currentValue = await tree.getLeafValue(i, includeUncommitted);
+                if (currentValue && currentValue.equals(value)) {
+                    return i;
+                }
+            }
+            return undefined;
+        });
+    }
+    /**
+     * Updates a leaf in a tree at a given index.
+     * @param treeId - The ID of the tree.
+     * @param leaf - The new leaf value.
+     * @param index - The index to insert into.
+     * @returns Empty promise.
+     */
+    async updateLeaf(treeId, leaf, index) {
+        return await this.synchronise(() => this._updateLeaf(treeId, leaf, index));
+    }
+    /**
+     * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
+     * @param block - The L2 block to handle.
+     */
+    async handleL2Block(block) {
+        await this.synchronise(() => this._handleL2Block(block));
+    }
+    /**
+     * Batch insert multiple leaves into the tree.
+     * @param treeId - The ID of the tree.
+     * @param leaves - Leaves to insert into the tree.
+     * @param treeHeight - Height of the tree.
+     * @param subtreeHeight - Height of the subtree.
+     * @returns The data for the leaves to be updated when inserting the new ones.
+     */
+    async batchInsert(treeId, leaves, treeHeight, subtreeHeight) {
+        const tree = this.trees[treeId];
+        if (!('batchInsert' in tree)) {
+            throw new Error('Tree does not support `batchInsert` method');
+        }
+        return await this.synchronise(() => tree.batchInsert(leaves, treeHeight, subtreeHeight));
+    }
+    /**
+     * Waits for all jobs to finish before executing the given function.
+     * @param fn - The function to execute.
+     * @returns Promise containing the result of the function.
+     */
+    async synchronise(fn) {
+        return await this.jobQueue.put(fn);
+    }
+    /**
+     * Returns the tree info for the specified tree id.
+     * @param treeId - Id of the tree to get information from.
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     * @returns The tree info for the specified tree.
+     */
+    _getTreeInfo(treeId, includeUncommitted) {
+        const treeInfo = {
+            treeId,
+            root: this.trees[treeId].getRoot(includeUncommitted),
+            size: this.trees[treeId].getNumLeaves(includeUncommitted),
+            depth: this.trees[treeId].getDepth(),
+        };
+        return Promise.resolve(treeInfo);
+    }
+    /**
+     * Returns an instance of an indexed tree.
+     * @param treeId - Id of the tree to get an instance of.
+     * @returns The indexed tree for the specified tree id.
+     */
+    _getIndexedTree(treeId) {
+        return this.trees[treeId];
+    }
+    /**
+     * Returns the sibling path for a leaf in a tree.
+     * @param treeId - Id of the tree to get the sibling path from.
+     * @param index - Index of the leaf to get the sibling path for.
+     * @param includeUncommitted - Indicates whether to include uncommitted updates in the sibling path.
+     * @returns Promise containing the sibling path for the leaf.
+     */
+    _getSiblingPath(treeId, index, includeUncommitted) {
+        return Promise.resolve(this.trees[treeId].getSiblingPath(index, includeUncommitted));
+    }
+    /**
+     * Appends leaves to a tree.
+     * @param treeId - Id of the tree to append leaves to.
+     * @param leaves - Leaves to append.
+     * @returns Empty promise.
+     */
+    async _appendLeaves(treeId, leaves) {
+        const tree = this.trees[treeId];
+        if (!('appendLeaves' in tree)) {
+            throw new Error('Tree does not support `appendLeaves` method');
+        }
+        return await tree.appendLeaves(leaves);
+    }
+    async _updateLeaf(treeId, leaf, index) {
+        const tree = this.trees[treeId];
+        if (!('updateLeaf' in tree)) {
+            throw new Error('Tree does not support `updateLeaf` method');
+        }
+        return await tree.updateLeaf(leaf, index);
+    }
+    /**
+     * Commits all pending updates.
+     * @returns Empty promise.
+     */
+    async _commit() {
+        for (const tree of this.trees) {
+            await tree.commit();
+        }
+    }
+    /**
+     * Rolls back all pending updates.
+     * @returns Empty promise.
+     */
+    async _rollback() {
+        for (const tree of this.trees) {
+            await tree.rollback();
+        }
+    }
+    /**
+     * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
+     * @param l2Block - The L2 block to handle.
+     */
+    async _handleL2Block(l2Block) {
+        const compareRoot = (root, treeId) => {
+            const treeRoot = this.trees[treeId].getRoot(true);
+            return treeRoot.equals(root.toBuffer());
+        };
+        const rootChecks = [
+            compareRoot(l2Block.endContractTreeSnapshot.root, MerkleTreeId.CONTRACT_TREE),
+            compareRoot(l2Block.endNullifierTreeSnapshot.root, MerkleTreeId.NULLIFIER_TREE),
+            compareRoot(l2Block.endPrivateDataTreeSnapshot.root, MerkleTreeId.PRIVATE_DATA_TREE),
+            compareRoot(l2Block.endPublicDataTreeRoot, MerkleTreeId.PUBLIC_DATA_TREE),
+            compareRoot(l2Block.endTreeOfHistoricContractTreeRootsSnapshot.root, MerkleTreeId.CONTRACT_TREE_ROOTS_TREE),
+            compareRoot(l2Block.endTreeOfHistoricPrivateDataTreeRootsSnapshot.root, MerkleTreeId.PRIVATE_DATA_TREE_ROOTS_TREE),
+            compareRoot(l2Block.endL1ToL2MessageTreeSnapshot.root, MerkleTreeId.L1_TO_L2_MESSAGES_TREE),
+            compareRoot(l2Block.endTreeOfHistoricL1ToL2MessageTreeRootsSnapshot.root, MerkleTreeId.L1_TO_L2_MESSAGES_ROOTS_TREE),
+        ];
+        const ourBlock = rootChecks.every(x => x);
+        if (ourBlock) {
+            this.log(`Block ${l2Block.number} is ours, committing world state..`);
+            await this._commit();
+        }
+        else {
+            this.log(`Block ${l2Block.number} is not ours, rolling back world state and committing state from chain..`);
+            await this._rollback();
+            for (const [tree, leaves] of [
+                [MerkleTreeId.CONTRACT_TREE, l2Block.newContracts],
+                [MerkleTreeId.NULLIFIER_TREE, l2Block.newNullifiers],
+                [MerkleTreeId.PRIVATE_DATA_TREE, l2Block.newCommitments],
+                [MerkleTreeId.L1_TO_L2_MESSAGES_TREE, l2Block.newL1ToL2Messages],
+            ]) {
+                await this._appendLeaves(tree, leaves.map(fr => fr.toBuffer()));
+            }
+            for (const dataWrite of l2Block.newPublicDataWrites) {
+                if (dataWrite.isEmpty())
+                    continue;
+                const { newValue, leafIndex } = dataWrite;
+                await this._updateLeaf(MerkleTreeId.PUBLIC_DATA_TREE, newValue.toBuffer(), leafIndex.value);
+            }
+            for (const [newTree, rootTree] of [
+                [MerkleTreeId.PRIVATE_DATA_TREE, MerkleTreeId.PRIVATE_DATA_TREE_ROOTS_TREE],
+                [MerkleTreeId.CONTRACT_TREE, MerkleTreeId.CONTRACT_TREE_ROOTS_TREE],
+                [MerkleTreeId.L1_TO_L2_MESSAGES_TREE, MerkleTreeId.L1_TO_L2_MESSAGES_ROOTS_TREE],
+            ]) {
+                const newTreeRoot = this.trees[newTree].getRoot(true);
+                await this._appendLeaves(rootTree, [newTreeRoot]);
+            }
+            await this._commit();
+        }
+        for (const treeId of merkleTreeIds()) {
+            const info = await this._getTreeInfo(treeId, false);
+            this.log(`Tree ${MerkleTreeId[treeId]} synched with size ${info.size} root ${info.root.toString('hex')}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"merkle_trees.js","sourceRoot":"","sources":["../../src/world-state-db/merkle_trees.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@aztec/world-state",
+  "version": "0.1.0-alpha11",
+  "exports": "./dest/index.js",
+  "type": "module",
+  "dependencies": {
+    "@aztec/circuits.js": "0.1.0-alpha11",
+    "@aztec/foundation": "0.1.0-alpha11",
+    "@aztec/merkle-tree": "0.1.0-alpha11",
+    "@aztec/types": "0.1.0-alpha11",
+    "levelup": "^5.1.1",
+    "memdown": "^6.1.1",
+    "tslib": "^2.4.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './synchroniser/index.js';
+export * from './world-state-db/index.js';
+export * from './utils.js';

package/src/merkle-tree/merkle_tree_operations_facade.ts

@@ -0,0 +1,164 @@
+import { LeafData, MerkleTreeDb, TreeInfo, MerkleTreeOperations, CurrentCommitmentTreeRoots } from '../index.js';
+import { L2Block, MerkleTreeId } from '@aztec/types';
+import { LowLeafWitnessData, SiblingPath } from '@aztec/merkle-tree';
+
+/**
+ * Wraps a MerkleTreeDbOperations to call all functions with a preset includeUncommitted flag.
+ */
+export class MerkleTreeOperationsFacade implements MerkleTreeOperations {
+  constructor(private trees: MerkleTreeDb, private includeUncommitted: boolean) {}
+
+  /**
+   * Returns the tree info for the specified tree id.
+   * @param treeId - Id of the tree to get information from.
+   * @param includeUncommitted - Indicates whether to include uncommitted data.
+   * @returns The tree info for the specified tree.
+   */
+  getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo> {
+    return this.trees.getTreeInfo(treeId, this.includeUncommitted);
+  }
+
+  /**
+   * Get the current roots of the commitment trees.
+   * @returns The current roots of the trees.
+   */
+  getCommitmentTreeRoots(): CurrentCommitmentTreeRoots {
+    return this.trees.getCommitmentTreeRoots(this.includeUncommitted);
+  }
+
+  /**
+   * Appends a set of leaf values to the tree.
+   * @param treeId - Id of the tree to append leaves to.
+   * @param leaves - The set of leaves to be appended.
+   * @returns The tree info of the specified tree.
+   */
+  appendLeaves(treeId: MerkleTreeId, leaves: Buffer[]): Promise<void> {
+    return this.trees.appendLeaves(treeId, leaves);
+  }
+
+  /**
+   * Returns the sibling path for a requested leaf index.
+   * @param treeId - Id of the tree to get the sibling path from.
+   * @param index - The index of the leaf for which a sibling path is required.
+   * @returns A promise with the sibling path of the specified leaf index.
+   */
+  getSiblingPath(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<number>> {
+    return this.trees.getSiblingPath(treeId, index, this.includeUncommitted);
+  }
+
+  /**
+   * Finds the index of the largest leaf whose value is less than or equal to the provided value.
+   * @param treeId - The ID of the tree to search.
+   * @param value - The value to be inserted into the tree.
+   * @param includeUncommitted - If true, the uncommitted changes are included in the search.
+   * @returns The found leaf index and a flag indicating if the corresponding leaf's value is equal to `newValue`.
+   */
+  getPreviousValueIndex(
+    treeId: MerkleTreeId.NULLIFIER_TREE,
+    value: bigint,
+  ): Promise<{
+    /**
+     * The index of the found leaf.
+     */
+    index: number;
+    /**
+     * A flag indicating if the corresponding leaf's value is equal to `newValue`.
+     */
+    alreadyPresent: boolean;
+  }> {
+    return this.trees.getPreviousValueIndex(treeId, value, this.includeUncommitted);
+  }
+
+  /**
+   * Updates a leaf in a tree at a given index.
+   * @param treeId - The ID of the tree.
+   * @param leaf - The new leaf value.
+   * @param index - The index to insert into.
+   * @returns Empty promise.
+   */
+  updateLeaf(treeId: MerkleTreeId.NULLIFIER_TREE, leaf: LeafData, index: bigint): Promise<void> {
+    return this.trees.updateLeaf(treeId, leaf, index);
+  }
+
+  /**
+   * Gets the leaf data at a given index and tree.
+   * @param treeId - The ID of the tree get the leaf from.
+   * @param index - The index of the leaf to get.
+   * @returns Leaf data.
+   */
+  getLeafData(treeId: MerkleTreeId.NULLIFIER_TREE, index: number): Promise<LeafData | undefined> {
+    return this.trees.getLeafData(treeId, index, this.includeUncommitted);
+  }
+
+  /**
+   * Returns the index of a leaf given its value, or undefined if no leaf with that value is found.
+   * @param treeId - The ID of the tree.
+   * @param value - The leaf value to look for.
+   * @returns The index of the first leaf found with a given value (undefined if not found).
+   */
+  findLeafIndex(treeId: MerkleTreeId, value: Buffer): Promise<bigint | undefined> {
+    return this.trees.findLeafIndex(treeId, value, this.includeUncommitted);
+  }
+
+  /**
+   * Gets the value at the given index.
+   * @param treeId - The ID of the tree to get the leaf value from.
+   * @param index - The index of the leaf.
+   * @param includeUncommitted - Indicates whether to include uncommitted changes.
+   * @returns Leaf value at the given index (undefined if not found).
+   */
+  getLeafValue(treeId: MerkleTreeId, index: bigint): Promise<Buffer | undefined> {
+    return this.trees.getLeafValue(treeId, index, this.includeUncommitted);
+  }
+
+  /**
+   * Inserts into the roots trees (CONTRACT_TREE_ROOTS_TREE, PRIVATE_DATA_TREE_ROOTS_TREE)
+   * the current roots of the corresponding trees (CONTRACT_TREE, PRIVATE_DATA_TREE).
+   * @returns Empty promise.
+   */
+  public updateHistoricRootsTrees(): Promise<void> {
+    return this.trees.updateHistoricRootsTrees(this.includeUncommitted);
+  }
+
+  /**
+   * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
+   * @param block - The L2 block to handle.
+   * @returns Empty promise.
+   */
+  public handleL2Block(block: L2Block): Promise<void> {
+    return this.trees.handleL2Block(block);
+  }
+
+  /**
+   * Commits all pending updates.
+   * @returns Empty promise.
+   */
+  public async commit(): Promise<void> {
+    return await this.trees.commit();
+  }
+
+  /**
+   * Rolls back all pending updates.
+   * @returns Empty promise.
+   */
+  public async rollback(): Promise<void> {
+    return await this.trees.rollback();
+  }
+
+  /**
+   * Batch insert multiple leaves into the tree.
+   * @param treeId - The ID of the tree.
+   * @param leaves - Leaves to insert into the tree.
+   * @param treeHeight - Height of the tree.
+   * @param subtreeHeight - Height of the subtree.
+   * @returns The data for the leaves to be updated when inserting the new ones.
+   */
+  public batchInsert(
+    treeId: MerkleTreeId,
+    leaves: Buffer[],
+    treeHeight: number,
+    subtreeHeight: number,
+  ): Promise<[LowLeafWitnessData<number>[], SiblingPath<number>] | [undefined, SiblingPath<number>]> {
+    return this.trees.batchInsert(treeId, leaves, treeHeight, subtreeHeight);
+  }
+}

package/src/synchroniser/config.ts

@@ -0,0 +1,27 @@
+/**
+ * World State synchroniser configuration values.
+ */
+export interface WorldStateConfig {
+  /**
+   * The frequency in which to check.
+   */
+  checkInterval: number;
+
+  /**
+   * Size of queue of L2 blocks to store.
+   */
+  l2QueueSize: number;
+}
+
+/**
+ * Returns the configuration values for the world state synchroniser.
+ * @returns The configuration values for the world state synchroniser.
+ */
+export function getConfigEnvVars(): WorldStateConfig {
+  const { WS_CHECK_INTERVAL, WS_L2_BLOCK_QUEUE_SIZE } = process.env;
+  const envVars: WorldStateConfig = {
+    checkInterval: WS_CHECK_INTERVAL ? +WS_CHECK_INTERVAL : 100,
+    l2QueueSize: WS_L2_BLOCK_QUEUE_SIZE ? +WS_L2_BLOCK_QUEUE_SIZE : 1000,
+  };
+  return envVars;
+}

package/src/synchroniser/index.ts

@@ -0,0 +1,2 @@
+export * from './server_world_state_synchroniser.js';
+export * from './world_state_synchroniser.js';