@aztec/world-state 0.7.2 → 0.7.3

package/dest/synchroniser/world_state_synchroniser.js

@@ -0,0 +1,11 @@
+/**
+ * Defines the possible states of the world state synchroniser.
+ */
+export var WorldStateRunningState;
+(function (WorldStateRunningState) {
+    WorldStateRunningState[WorldStateRunningState["IDLE"] = 0] = "IDLE";
+    WorldStateRunningState[WorldStateRunningState["SYNCHING"] = 1] = "SYNCHING";
+    WorldStateRunningState[WorldStateRunningState["RUNNING"] = 2] = "RUNNING";
+    WorldStateRunningState[WorldStateRunningState["STOPPED"] = 3] = "STOPPED";
+})(WorldStateRunningState || (WorldStateRunningState = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGRfc3RhdGVfc3luY2hyb25pc2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N5bmNocm9uaXNlci93b3JsZF9zdGF0ZV9zeW5jaHJvbmlzZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBWSxzQkFLWDtBQUxELFdBQVksc0JBQXNCO0lBQ2hDLG1FQUFJLENBQUE7SUFDSiwyRUFBUSxDQUFBO0lBQ1IseUVBQU8sQ0FBQTtJQUNQLHlFQUFPLENBQUE7QUFDVCxDQUFDLEVBTFcsc0JBQXNCLEtBQXRCLHNCQUFzQixRQUtqQyJ9

package/dest/utils.d.ts

@@ -0,0 +1,18 @@
+import { GlobalVariables } from '@aztec/circuits.js';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+import { IWasmModule } from '@aztec/foundation/wasm';
+/**
+ * Computes the index in the public data tree for a given contract and storage slot.
+ * @param contract - Address of the contract who owns the storage.
+ * @param slot - Slot within the contract storage.
+ * @param bbWasm - Wasm module for computing the hash.
+ * @returns The leaf index of the public data tree that maps to this storage slot.
+ */
+export declare function computePublicDataTreeLeafIndex(contract: AztecAddress, slot: Fr, wasm: IWasmModule): bigint;
+/**
+ * Computes the hash of the global variables.
+ * @returns The hash of the global variables.
+ */
+export declare function computeGlobalVariablesHash(globalVariables?: GlobalVariables): Promise<Fr>;
+//# sourceMappingURL=utils.d.ts.map

package/dest/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGnF,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAQ1G;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAC9C,eAAe,GAAE,eAAyC,GACzD,OAAO,CAAC,EAAE,CAAC,CAGb"}

package/dest/utils.js

@@ -0,0 +1,23 @@
+import { CircuitsWasm, GeneratorIndex, GlobalVariables } from '@aztec/circuits.js';
+import { computeGlobalsHash } from '@aztec/circuits.js/abis';
+import { pedersenCompressWithHashIndex } from '@aztec/circuits.js/barretenberg';
+import { toBigInt } from '@aztec/foundation/serialize';
+/**
+ * Computes the index in the public data tree for a given contract and storage slot.
+ * @param contract - Address of the contract who owns the storage.
+ * @param slot - Slot within the contract storage.
+ * @param bbWasm - Wasm module for computing the hash.
+ * @returns The leaf index of the public data tree that maps to this storage slot.
+ */
+export function computePublicDataTreeLeafIndex(contract, slot, wasm) {
+    return toBigInt(pedersenCompressWithHashIndex(wasm, [contract, slot].map(f => f.toBuffer()), GeneratorIndex.PUBLIC_LEAF_INDEX));
+}
+/**
+ * Computes the hash of the global variables.
+ * @returns The hash of the global variables.
+ */
+export async function computeGlobalVariablesHash(globalVariables = GlobalVariables.empty()) {
+    const wasm = await CircuitsWasm.get();
+    return computeGlobalsHash(wasm, globalVariables);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsZUFBZSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbkYsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDN0QsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFHaEYsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBR3ZEOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSw4QkFBOEIsQ0FBQyxRQUFzQixFQUFFLElBQVEsRUFBRSxJQUFpQjtJQUNoRyxPQUFPLFFBQVEsQ0FDYiw2QkFBNkIsQ0FDM0IsSUFBSSxFQUNKLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxFQUN2QyxjQUFjLENBQUMsaUJBQWlCLENBQ2pDLENBQ0YsQ0FBQztBQUNKLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLDBCQUEwQixDQUM5QyxrQkFBbUMsZUFBZSxDQUFDLEtBQUssRUFBRTtJQUUxRCxNQUFNLElBQUksR0FBRyxNQUFNLFlBQVksQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUN0QyxPQUFPLGtCQUFrQixDQUFDLElBQUksRUFBRSxlQUFlLENBQUMsQ0FBQztBQUNuRCxDQUFDIn0=

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

@@ -0,0 +1,189 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { LeafData, LowLeafWitnessData } from '@aztec/merkle-tree';
+import { L2Block, MerkleTreeId, SiblingPath } from '@aztec/types';
+export * from './merkle_trees.js';
+export { LeafData } from '@aztec/merkle-tree';
+/**
+ * Type alias for the nullifier tree ID.
+ */
+export type IndexedTreeId = MerkleTreeId.NULLIFIER_TREE;
+/**
+ * Type alias for the public data tree ID.
+ */
+export type PublicTreeId = MerkleTreeId.PUBLIC_DATA_TREE;
+/**
+ *
+ * @remarks Short explanation:
+ *    The nullifier tree must be initially padded as the pre-populated 0 index prevents efficient subtree insertion.
+ *    Padding with some values solves this issue.
+ *
+ * @remarks Thorough explanation:
+ *    There needs to be an initial (0,0,0) leaf in the tree, so that when we insert the first 'proper' leaf, we can
+ *    prove that any value greater than 0 doesn't exist in the tree yet. We prefill/pad the tree with "the number of
+ *    leaves that are added by one block" so that the first 'proper' block can insert a full subtree.
+ *
+ *    Without this padding, there would be a leaf (0,0,0) at leaf index 0, making it really difficult to insert e.g.
+ *    1024 leaves for the first block, because there's only neat space for 1023 leaves after 0. By padding with 1023
+ *    more leaves, we can then insert the first block of 1024 leaves into indices 1024:2047.
+ */
+export declare const INITIAL_NULLIFIER_TREE_SIZE: number;
+/**
+ *  Defines tree information.
+ */
+export interface TreeInfo {
+    /**
+     * The tree ID.
+     */
+    treeId: MerkleTreeId;
+    /**
+     * The tree root.
+     */
+    root: Buffer;
+    /**
+     * The number of leaves in the tree.
+     */
+    size: bigint;
+    /**
+     * The depth of the tree.
+     */
+    depth: 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;
+/**
+ * The current roots of the commitment trees
+ */
+export type CurrentTreeRoots = {
+    /** Private data tree root. */
+    privateDataTreeRoot: Buffer;
+    /** Contract data tree root. */
+    contractDataTreeRoot: Buffer;
+    /** L1 to L2 Messages data tree root. */
+    l1Tol2MessagesTreeRoot: Buffer;
+    /** Nullifier data tree root. */
+    nullifierTreeRoot: Buffer;
+    /** Blocks tree root. */
+    blocksTreeRoot: Buffer;
+    /** Public data tree root */
+    publicDataTreeRoot: Buffer;
+};
+/**
+ * Defines the names of the setters on Merkle Trees.
+ */
+type MerkleTreeSetters = 'appendLeaves' | 'updateLeaf' | 'commit' | 'rollback' | 'handleL2Block' | 'batchInsert';
+/**
+ * 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>;
+/**
+ * Defines the interface for operations on a set of Merkle Trees.
+ */
+export interface MerkleTreeOperations {
+    /**
+     * Appends leaves to a given tree.
+     * @param treeId - The tree to be updated.
+     * @param leaves - The set of leaves to be appended.
+     */
+    appendLeaves(treeId: MerkleTreeId, leaves: Buffer[]): Promise<void>;
+    /**
+     * Returns information about the given tree.
+     * @param treeId - The tree to be queried.
+     */
+    getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo>;
+    /**
+     * Gets the current roots of the commitment trees.
+     */
+    getTreeRoots(): Promise<CurrentTreeRoots>;
+    /**
+     * Gets sibling path for a leaf.
+     * @param treeId - The tree to be queried for a sibling path.
+     * @param index - The index of the leaf for which a sibling path should be returned.
+     */
+    getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>>;
+    /**
+     * Returns the previous index for a given value in an indexed tree.
+     * @param treeId - The tree for which the previous value index is required.
+     * @param value - The value to be queried.
+     */
+    getPreviousValueIndex(treeId: IndexedTreeId, 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;
+    }>;
+    /**
+     * Returns the data at a specific leaf.
+     * @param treeId - The tree for which leaf data should be returned.
+     * @param index - The index of the leaf required.
+     */
+    getLeafData(treeId: IndexedTreeId, index: number): Promise<LeafData | undefined>;
+    /**
+     * Update the leaf data at the given index.
+     * @param treeId - The tree for which leaf data should be edited.
+     * @param leaf - The updated leaf value.
+     * @param index - The index of the leaf to be updated.
+     */
+    updateLeaf(treeId: IndexedTreeId | PublicTreeId, leaf: LeafData | Buffer, index: bigint): Promise<void>;
+    /**
+     * Returns the index containing a leaf value.
+     * @param treeId - The tree for which the index should be returned.
+     * @param value - The value to search for in the tree.
+     */
+    findLeafIndex(treeId: MerkleTreeId, value: Buffer): Promise<bigint | undefined>;
+    /**
+     * Gets the value for a leaf in the tree.
+     * @param treeId - The tree for which the index should be returned.
+     * @param index - The index of the leaf.
+     */
+    getLeafValue(treeId: MerkleTreeId, index: bigint): Promise<Buffer | undefined>;
+    /**
+     * Inserts the new block hash into the new block hashes tree.
+     * This includes all of the current roots of all of the data trees and the current blocks global vars.
+     * @param globalVariablesHash - The global variables hash to insert into the block hash.
+     */
+    updateHistoricBlocksTree(globalVariablesHash: Fr): Promise<void>;
+    /**
+     * Updates the latest global variables hash
+     * @param globalVariablesHash - The latest global variables hash
+     */
+    updateLatestGlobalVariablesHash(globalVariablesHash: Fr): Promise<void>;
+    /**
+     * Gets the global variables hash from the previous block
+     */
+    getLatestGlobalVariablesHash(): Promise<Fr>;
+    /**
+     * Batch insert multiple leaves into the tree.
+     * @param leaves - Leaves to insert into the tree.
+     * @param treeId - The tree on which to insert.
+     * @param subtreeHeight - Height of the subtree.
+     * @returns The witness data for the leaves to be updated when inserting the new ones.
+     */
+    batchInsert(treeId: MerkleTreeId, leaves: Buffer[], subtreeHeight: number): Promise<[LowLeafWitnessData<number>[], SiblingPath<number>] | [undefined, SiblingPath<number>]>;
+    /**
+     * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
+     * @param block - The L2 block to handle.
+     */
+    handleL2Block(block: L2Block): Promise<void>;
+    /**
+     * Commits pending changes to the underlying store.
+     */
+    commit(): Promise<void>;
+    /**
+     * Rolls back pending changes.
+     */
+    rollback(): Promise<void>;
+}
+/**
+ * Outputs a tree leaves using for debugging purposes.
+ */
+export declare function inspectTree(db: MerkleTreeOperations, treeId: MerkleTreeId, log?: import("@aztec/foundation/log").DebugLogger): Promise<void>;
+//# 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":"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"}

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

@@ -0,0 +1,31 @@
+import { MAX_NEW_NULLIFIERS_PER_TX } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+export * from './merkle_trees.js';
+/**
+ *
+ * @remarks Short explanation:
+ *    The nullifier tree must be initially padded as the pre-populated 0 index prevents efficient subtree insertion.
+ *    Padding with some values solves this issue.
+ *
+ * @remarks Thorough explanation:
+ *    There needs to be an initial (0,0,0) leaf in the tree, so that when we insert the first 'proper' leaf, we can
+ *    prove that any value greater than 0 doesn't exist in the tree yet. We prefill/pad the tree with "the number of
+ *    leaves that are added by one block" so that the first 'proper' block can insert a full subtree.
+ *
+ *    Without this padding, there would be a leaf (0,0,0) at leaf index 0, making it really difficult to insert e.g.
+ *    1024 leaves for the first block, because there's only neat space for 1023 leaves after 0. By padding with 1023
+ *    more leaves, we can then insert the first block of 1024 leaves into indices 1024:2047.
+ */
+export const INITIAL_NULLIFIER_TREE_SIZE = 2 * MAX_NEW_NULLIFIERS_PER_TX;
+/**
+ * Outputs a tree leaves using for debugging purposes.
+ */
+export async function inspectTree(db, treeId, log = createDebugLogger('aztec:inspect-tree')) {
+    const info = await db.getTreeInfo(treeId);
+    const output = [`Tree id=${treeId} size=${info.size} root=0x${info.root.toString('hex')}`];
+    for (let i = 0; i < info.size; i++) {
+        output.push(` Leaf ${i}: ${await db.getLeafValue(treeId, BigInt(i)).then(x => x?.toString('hex') ?? '[undefined]')}`);
+    }
+    log(output.join('\n'));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd29ybGQtc3RhdGUtZGIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFL0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFJMUQsY0FBYyxtQkFBbUIsQ0FBQztBQWFsQzs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQU0sQ0FBQyxNQUFNLDJCQUEyQixHQUFHLENBQUMsR0FBRyx5QkFBeUIsQ0FBQztBQTZMekU7O0dBRUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFdBQVcsQ0FDL0IsRUFBd0IsRUFDeEIsTUFBb0IsRUFDcEIsR0FBRyxHQUFHLGlCQUFpQixDQUFDLG9CQUFvQixDQUFDO0lBRTdDLE1BQU0sSUFBSSxHQUFHLE1BQU0sRUFBRSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUMxQyxNQUFNLE1BQU0sR0FBRyxDQUFDLFdBQVcsTUFBTSxTQUFTLElBQUksQ0FBQyxJQUFJLFdBQVcsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQzNGLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsRUFBRSxFQUFFO1FBQ2xDLE1BQU0sQ0FBQyxJQUFJLENBQ1QsU0FBUyxDQUFDLEtBQUssTUFBTSxFQUFFLENBQUMsWUFBWSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsUUFBUSxDQUFDLEtBQUssQ0FBQyxJQUFJLGFBQWEsQ0FBQyxFQUFFLENBQ3pHLENBQUM7S0FDSDtJQUNELEdBQUcsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7QUFDekIsQ0FBQyJ9

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

@@ -0,0 +1,228 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Fr, GlobalVariables } from '@aztec/circuits.js';
+import { IWasmModule } from '@aztec/foundation/wasm';
+import { LeafData, LowLeafWitnessData } from '@aztec/merkle-tree';
+import { L2Block, MerkleTreeId, SiblingPath } from '@aztec/types';
+import { default as levelup } from 'levelup';
+import { CurrentTreeRoots, IndexedTreeId, MerkleTreeDb, MerkleTreeOperations, PublicTreeId, TreeInfo } from './index.js';
+/**
+ * Data necessary to reinitialise the merkle trees from Db.
+ */
+interface FromDbOptions {
+    /**
+     * The global variables from the last block.
+     */
+    globalVariables: GlobalVariables;
+}
+/**
+ * A convenience class for managing multiple merkle trees.
+ */
+export declare class MerkleTrees implements MerkleTreeDb {
+    private db;
+    private log;
+    private trees;
+    private latestGlobalVariablesHash;
+    private jobQueue;
+    constructor(db: levelup.LevelUp, log?: import("@aztec/foundation/log").DebugLogger);
+    /**
+     * Initialises the collection of Merkle Trees.
+     * @param optionalWasm - WASM instance to use for hashing (if not provided PrimitivesWasm will be used).
+     * @param fromDbOptions - Options to initialise the trees from the database.
+     */
+    init(optionalWasm?: IWasmModule, fromDbOptions?: FromDbOptions): Promise<void>;
+    /**
+     * 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 new(db: levelup.LevelUp, wasm?: IWasmModule): Promise<MerkleTrees>;
+    /**
+     * Stops the job queue (waits for all jobs to finish).
+     */
+    stop(): Promise<void>;
+    /**
+     * Gets a view of this db that returns uncommitted data.
+     * @returns - A facade for this instance.
+     */
+    asLatest(): MerkleTreeOperations;
+    /**
+     * Gets a view of this db that returns committed data only.
+     * @returns - A facade for this instance.
+     */
+    asCommitted(): MerkleTreeOperations;
+    /**
+     * 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 globalsHash - The current global variables hash.
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     */
+    updateHistoricBlocksTree(globalsHash: Fr, includeUncommitted: boolean): Promise<void>;
+    /**
+     * Updates the latest global variables hash
+     * @param globalVariablesHash - The latest global variables hash
+     */
+    updateLatestGlobalVariablesHash(globalVariablesHash: Fr): Promise<void>;
+    /**
+     * Gets the global variables hash from the previous block
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     */
+    getLatestGlobalVariablesHash(includeUncommitted: boolean): Promise<Fr>;
+    /**
+     * 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.
+     */
+    getTreeInfo(treeId: MerkleTreeId, includeUncommitted: boolean): Promise<TreeInfo>;
+    /**
+     * Get the current roots of the commitment trees.
+     * @param includeUncommitted - Indicates whether to include uncommitted data.
+     * @returns The current roots of the trees.
+     */
+    getTreeRoots(includeUncommitted: boolean): Promise<CurrentTreeRoots>;
+    private _getCurrentBlockHash;
+    private _getAllTreeRoots;
+    /**
+     * 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, includeUncommitted: boolean): Promise<Buffer | undefined>;
+    /**
+     * 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.
+     */
+    getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint, includeUncommitted: boolean): Promise<SiblingPath<N>>;
+    /**
+     * Appends leaves to a tree.
+     * @param treeId - The ID of the tree.
+     * @param leaves - The leaves to append.
+     * @returns Empty promise.
+     */
+    appendLeaves(treeId: MerkleTreeId, leaves: Buffer[]): Promise<void>;
+    /**
+     * Commits all pending updates.
+     * @returns Empty promise.
+     */
+    commit(): Promise<void>;
+    /**
+     * Rolls back all pending updates.
+     * @returns Empty promise.
+     */
+    rollback(): Promise<void>;
+    /**
+     * 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: IndexedTreeId, value: bigint, includeUncommitted: boolean): Promise<{
+        /**
+         * The index of the found leaf.
+         */
+        index: number;
+        /**
+         * A flag indicating if the corresponding leaf's value is equal to `newValue`.
+         */
+        alreadyPresent: boolean;
+    }>;
+    /**
+     * 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.
+     */
+    getLeafData(treeId: IndexedTreeId, index: number, includeUncommitted: boolean): Promise<LeafData | undefined>;
+    /**
+     * 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).
+     */
+    findLeafIndex(treeId: MerkleTreeId, value: Buffer, includeUncommitted: boolean): Promise<bigint | 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.
+     */
+    updateLeaf(treeId: IndexedTreeId | PublicTreeId, leaf: LeafData | Buffer, index: bigint): Promise<void>;
+    /**
+     * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
+     * @param block - The L2 block to handle.
+     */
+    handleL2Block(block: L2Block): Promise<void>;
+    /**
+     * Batch insert multiple leaves into the tree.
+     * @param treeId - The ID of the tree.
+     * @param leaves - Leaves to insert into the tree.
+     * @param subtreeHeight - Height of the subtree.
+     * @returns The data for the leaves to be updated when inserting the new ones.
+     */
+    batchInsert<TreeHeight extends number, SubtreeHeight extends number, SubtreeSiblingPathHeight extends number>(treeId: MerkleTreeId, leaves: Buffer[], subtreeHeight: SubtreeHeight): Promise<[LowLeafWitnessData<TreeHeight>[], SiblingPath<SubtreeSiblingPathHeight>] | [undefined, SiblingPath<SubtreeSiblingPathHeight>]>;
+    /**
+     * 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.
+     */
+    private synchronise;
+    private _updateLatestGlobalVariablesHash;
+    private _getGlobalVariablesHash;
+    private _updateHistoricBlocksTree;
+    /**
+     * 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.
+     */
+    private _getTreeInfo;
+    /**
+     * 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.
+     */
+    private _getIndexedTree;
+    /**
+     * 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.
+     */
+    private _getSiblingPath;
+    /**
+     * Appends leaves to a tree.
+     * @param treeId - Id of the tree to append leaves to.
+     * @param leaves - Leaves to append.
+     * @returns Empty promise.
+     */
+    private _appendLeaves;
+    private _updateLeaf;
+    /**
+     * Commits all pending updates.
+     * @returns Empty promise.
+     */
+    private _commit;
+    /**
+     * Rolls back all pending updates.
+     * @returns Empty promise.
+     */
+    private _rollback;
+    /**
+     * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
+     * @param l2Block - The L2 block to handle.
+     */
+    private _handleL2Block;
+}
+export {};
+//# sourceMappingURL=merkle_trees.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merkle_trees.d.ts","sourceRoot":"","sources":["../../src/world-state-db/merkle_trees.ts"],"names":[],"mappings":"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"}