@aztec/world-state 0.7.10 → 0.8.6

package/src/{synchroniser/world_state_synchroniser.ts → synchronizer/world_state_synchronizer.ts}

@@ -1,7 +1,7 @@
 import { MerkleTreeOperations } from '../index.js';
 
 /**
- * Defines the possible states of the world state synchroniser.
+ * Defines the possible states of the world state synchronizer.
  */
 export enum WorldStateRunningState {
   IDLE,
@@ -11,37 +11,37 @@ export enum WorldStateRunningState {
 }
 
 /**
- * Defines the status of the world state synchroniser.
+ * Defines the status of the world state synchronizer.
  */
 export interface WorldStateStatus {
   /**
-   * The current state of the world state synchroniser.
+   * The current state of the world state synchronizer.
    */
   state: WorldStateRunningState;
   /**
-   * The block number that the world state synchroniser is synced to.
+   * The block number that the world state synchronizer is synced to.
    */
   syncedToL2Block: number;
 }
 
 /**
- * Defines the interface for a world state synchroniser.
+ * Defines the interface for a world state synchronizer.
  */
-export interface WorldStateSynchroniser {
+export interface WorldStateSynchronizer {
   /**
-   * Starts the synchroniser.
+   * Starts the synchronizer.
    * @returns A promise that resolves once the initial sync is completed.
    */
   start(): void;
 
   /**
-   * Returns the current status of the synchroniser.
-   * @returns The current status of the synchroniser.
+   * Returns the current status of the synchronizer.
+   * @returns The current status of the synchronizer.
    */
   status(): Promise<WorldStateStatus>;
 
   /**
-   * Stops the synchroniser.
+   * Stops the synchronizer.
    */
   stop(): Promise<void>;
 

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

@@ -208,7 +208,7 @@ export interface MerkleTreeOperations {
    * 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>;
+  handleL2Block(block: L2Block): Promise<HandleL2BlockResult>;
 
   /**
    * Commits pending changes to the underlying store.
@@ -221,6 +221,11 @@ export interface MerkleTreeOperations {
   rollback(): Promise<void>;
 }
 
+/** Return type for handleL2Block */
+export type HandleL2BlockResult = {
+  /** Whether the block processed was emitted by our sequencer */ isBlockOurs: boolean;
+};
+
 /**
  * Outputs a tree leaves using for debugging purposes.
  */

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

@@ -28,7 +28,7 @@ import {
   loadTree,
   newTree,
 } from '@aztec/merkle-tree';
-import { L2Block, MerkleTreeId, SiblingPath, merkleTreeIds } from '@aztec/types';
+import { L2Block, MerkleTreeId, SiblingPath } from '@aztec/types';
 
 import { default as levelup } from 'levelup';
 
@@ -36,6 +36,7 @@ import { MerkleTreeOperationsFacade } from '../merkle-tree/merkle_tree_operation
 import { computeGlobalVariablesHash } from '../utils.js';
 import {
   CurrentTreeRoots,
+  HandleL2BlockResult,
   INITIAL_NULLIFIER_TREE_SIZE,
   IndexedTreeId,
   MerkleTreeDb,
@@ -45,7 +46,7 @@ import {
 } from './index.js';
 
 /**
- * Data necessary to reinitialise the merkle trees from Db.
+ * Data necessary to reinitialize the merkle trees from Db.
  */
 interface FromDbOptions {
   /**
@@ -67,24 +68,24 @@ export class MerkleTrees implements MerkleTreeDb {
   }
 
   /**
-   * Initialises the collection of Merkle Trees.
+   * initializes 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.
+   * @param fromDbOptions - Options to initialize the trees from the database.
    */
   public async init(optionalWasm?: IWasmModule, fromDbOptions?: FromDbOptions) {
     const fromDb = fromDbOptions !== undefined;
-    const initialiseTree = fromDb ? loadTree : newTree;
+    const initializeTree = fromDb ? loadTree : newTree;
 
     const wasm = optionalWasm ?? (await CircuitsWasm.get());
     const hasher = new Pedersen(wasm);
-    const contractTree: AppendOnlyTree = await initialiseTree(
+    const contractTree: AppendOnlyTree = await initializeTree(
       StandardTree,
       this.db,
       hasher,
       `${MerkleTreeId[MerkleTreeId.CONTRACT_TREE]}`,
       CONTRACT_TREE_HEIGHT,
     );
-    const nullifierTree = await initialiseTree(
+    const nullifierTree = await initializeTree(
       StandardIndexedTree,
       this.db,
       hasher,
@@ -92,28 +93,28 @@ export class MerkleTrees implements MerkleTreeDb {
       NULLIFIER_TREE_HEIGHT,
       INITIAL_NULLIFIER_TREE_SIZE,
     );
-    const privateDataTree: AppendOnlyTree = await initialiseTree(
+    const privateDataTree: AppendOnlyTree = await initializeTree(
       StandardTree,
       this.db,
       hasher,
       `${MerkleTreeId[MerkleTreeId.PRIVATE_DATA_TREE]}`,
       PRIVATE_DATA_TREE_HEIGHT,
     );
-    const publicDataTree: UpdateOnlyTree = await initialiseTree(
+    const publicDataTree: UpdateOnlyTree = await initializeTree(
       SparseTree,
       this.db,
       hasher,
       `${MerkleTreeId[MerkleTreeId.PUBLIC_DATA_TREE]}`,
       PUBLIC_DATA_TREE_HEIGHT,
     );
-    const l1Tol2MessagesTree: AppendOnlyTree = await initialiseTree(
+    const l1Tol2MessagesTree: AppendOnlyTree = await initializeTree(
       StandardTree,
       this.db,
       hasher,
       `${MerkleTreeId[MerkleTreeId.L1_TO_L2_MESSAGES_TREE]}`,
       L1_TO_L2_MSG_TREE_HEIGHT,
     );
-    const historicBlocksTree: AppendOnlyTree = await initialiseTree(
+    const historicBlocksTree: AppendOnlyTree = await initializeTree(
       StandardTree,
       this.db,
       hasher,
@@ -136,10 +137,10 @@ export class MerkleTrees implements MerkleTreeDb {
   }
 
   /**
-   * Method to asynchronously create and initialise a MerkleTrees instance.
+   * Method to asynchronously create and initialize 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.
+   * @returns - A fully initialized MerkleTrees instance.
    */
   public static async new(db: levelup.LevelUp, wasm?: IWasmModule) {
     const merkleTrees = new MerkleTrees(db);
@@ -177,7 +178,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @param includeUncommitted - Indicates whether to include uncommitted data.
    */
   public async updateHistoricBlocksTree(globalsHash: Fr, includeUncommitted: boolean) {
-    await this.synchronise(() => this._updateHistoricBlocksTree(globalsHash, includeUncommitted));
+    await this.synchronize(() => this._updateHistoricBlocksTree(globalsHash, includeUncommitted));
   }
 
   /**
@@ -185,7 +186,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @param globalVariablesHash - The latest global variables hash
    */
   public async updateLatestGlobalVariablesHash(globalVariablesHash: Fr) {
-    return await this.synchronise(() => this._updateLatestGlobalVariablesHash(globalVariablesHash));
+    return await this.synchronize(() => this._updateLatestGlobalVariablesHash(globalVariablesHash));
   }
 
   /**
@@ -193,7 +194,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @param includeUncommitted - Indicates whether to include uncommitted data.
    */
   public async getLatestGlobalVariablesHash(includeUncommitted: boolean): Promise<Fr> {
-    return await this.synchronise(() => this._getGlobalVariablesHash(includeUncommitted));
+    return await this.synchronize(() => this._getGlobalVariablesHash(includeUncommitted));
   }
 
   /**
@@ -203,7 +204,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @returns The tree info for the specified tree.
    */
   public async getTreeInfo(treeId: MerkleTreeId, includeUncommitted: boolean): Promise<TreeInfo> {
-    return await this.synchronise(() => this._getTreeInfo(treeId, includeUncommitted));
+    return await this.synchronize(() => this._getTreeInfo(treeId, includeUncommitted));
   }
 
   /**
@@ -212,7 +213,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @returns The current roots of the trees.
    */
   public async getTreeRoots(includeUncommitted: boolean): Promise<CurrentTreeRoots> {
-    const roots = await this.synchronise(() => Promise.resolve(this._getAllTreeRoots(includeUncommitted)));
+    const roots = await this.synchronize(() => Promise.resolve(this._getAllTreeRoots(includeUncommitted)));
 
     return {
       privateDataTreeRoot: roots[0],
@@ -255,7 +256,7 @@ export class MerkleTrees implements MerkleTreeDb {
     index: bigint,
     includeUncommitted: boolean,
   ): Promise<Buffer | undefined> {
-    return await this.synchronise(() => this.trees[treeId].getLeafValue(index, includeUncommitted));
+    return await this.synchronize(() => this.trees[treeId].getLeafValue(index, includeUncommitted));
   }
 
   /**
@@ -270,7 +271,7 @@ export class MerkleTrees implements MerkleTreeDb {
     index: bigint,
     includeUncommitted: boolean,
   ): Promise<SiblingPath<N>> {
-    return await this.synchronise(() => this._getSiblingPath(treeId, index, includeUncommitted));
+    return await this.synchronize(() => this._getSiblingPath(treeId, index, includeUncommitted));
   }
 
   /**
@@ -280,7 +281,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @returns Empty promise.
    */
   public async appendLeaves(treeId: MerkleTreeId, leaves: Buffer[]): Promise<void> {
-    return await this.synchronise(() => this._appendLeaves(treeId, leaves));
+    return await this.synchronize(() => this._appendLeaves(treeId, leaves));
   }
 
   /**
@@ -288,7 +289,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @returns Empty promise.
    */
   public async commit(): Promise<void> {
-    return await this.synchronise(() => this._commit());
+    return await this.synchronize(() => this._commit());
   }
 
   /**
@@ -296,7 +297,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @returns Empty promise.
    */
   public async rollback(): Promise<void> {
-    return await this.synchronise(() => this._rollback());
+    return await this.synchronize(() => this._rollback());
   }
 
   /**
@@ -320,7 +321,7 @@ export class MerkleTrees implements MerkleTreeDb {
      */
     alreadyPresent: boolean;
   }> {
-    return await this.synchronise(() =>
+    return await this.synchronize(() =>
       Promise.resolve(this._getIndexedTree(treeId).findIndexOfPreviousValue(value, includeUncommitted)),
     );
   }
@@ -337,7 +338,7 @@ export class MerkleTrees implements MerkleTreeDb {
     index: number,
     includeUncommitted: boolean,
   ): Promise<LeafData | undefined> {
-    return await this.synchronise(() =>
+    return await this.synchronize(() =>
       Promise.resolve(this._getIndexedTree(treeId).getLatestLeafDataCopy(index, includeUncommitted)),
     );
   }
@@ -354,7 +355,7 @@ export class MerkleTrees implements MerkleTreeDb {
     value: Buffer,
     includeUncommitted: boolean,
   ): Promise<bigint | undefined> {
-    return await this.synchronise(async () => {
+    return await this.synchronize(async () => {
       const tree = this.trees[treeId];
       for (let i = 0n; i < tree.getNumLeaves(includeUncommitted); i++) {
         const currentValue = await tree.getLeafValue(i, includeUncommitted);
@@ -374,15 +375,16 @@ export class MerkleTrees implements MerkleTreeDb {
    * @returns Empty promise.
    */
   public async updateLeaf(treeId: IndexedTreeId | PublicTreeId, leaf: LeafData | Buffer, index: bigint): Promise<void> {
-    return await this.synchronise(() => this._updateLeaf(treeId, leaf, index));
+    return await this.synchronize(() => 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.
+   * @returns Whether the block handled was produced by this same node.
    */
-  public async handleL2Block(block: L2Block): Promise<void> {
-    await this.synchronise(() => this._handleL2Block(block));
+  public async handleL2Block(block: L2Block): Promise<HandleL2BlockResult> {
+    return await this.synchronize(() => this._handleL2Block(block));
   }
 
   /**
@@ -408,7 +410,7 @@ export class MerkleTrees implements MerkleTreeDb {
     if (!('batchInsert' in tree)) {
       throw new Error('Tree does not support `batchInsert` method');
     }
-    return await this.synchronise(() => tree.batchInsert(leaves, subtreeHeight));
+    return await this.synchronize(() => tree.batchInsert(leaves, subtreeHeight));
   }
 
   /**
@@ -416,7 +418,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @param fn - The function to execute.
    * @returns Promise containing the result of the function.
    */
-  private async synchronise<T>(fn: () => Promise<T>): Promise<T> {
+  private async synchronize<T>(fn: () => Promise<T>): Promise<T> {
     return await this.jobQueue.put(fn);
   }
 
@@ -526,25 +528,25 @@ export class MerkleTrees implements MerkleTreeDb {
    * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
    * @param l2Block - The L2 block to handle.
    */
-  private async _handleL2Block(l2Block: L2Block) {
+  private async _handleL2Block(l2Block: L2Block): Promise<HandleL2BlockResult> {
+    const treeRootWithIdPairs = [
+      [l2Block.endContractTreeSnapshot.root, MerkleTreeId.CONTRACT_TREE],
+      [l2Block.endNullifierTreeSnapshot.root, MerkleTreeId.NULLIFIER_TREE],
+      [l2Block.endPrivateDataTreeSnapshot.root, MerkleTreeId.PRIVATE_DATA_TREE],
+      [l2Block.endPublicDataTreeRoot, MerkleTreeId.PUBLIC_DATA_TREE],
+      [l2Block.endL1ToL2MessagesTreeSnapshot.root, MerkleTreeId.L1_TO_L2_MESSAGES_TREE],
+      [l2Block.endHistoricBlocksTreeSnapshot.root, MerkleTreeId.BLOCKS_TREE],
+    ] as const;
     const compareRoot = (root: Fr, treeId: MerkleTreeId) => {
       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.endL1ToL2MessagesTreeSnapshot.root, MerkleTreeId.L1_TO_L2_MESSAGES_TREE),
-      compareRoot(l2Block.endHistoricBlocksTreeSnapshot.root, MerkleTreeId.BLOCKS_TREE),
-    ];
-    const ourBlock = rootChecks.every(x => x);
+    const ourBlock = treeRootWithIdPairs.every(([root, id]) => compareRoot(root, id));
     if (ourBlock) {
-      this.log(`Block ${l2Block.number} is ours, committing world state..`);
+      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..`);
+      this.log(`Block ${l2Block.number} is not ours, rolling back world state and committing state from chain`);
       await this._rollback();
 
       // Sync the append only trees
@@ -575,16 +577,29 @@ export class MerkleTrees implements MerkleTreeDb {
       // Sync and add the block to the historic blocks tree
       const globalVariablesHash = await computeGlobalVariablesHash(l2Block.globalVariables);
       await this._updateLatestGlobalVariablesHash(globalVariablesHash);
-      this.log(`Synced global variables with hash ${this.latestGlobalVariablesHash.toString()}`);
+      this.log(`Synced global variables with hash ${globalVariablesHash}`);
 
       const blockHash = await this._getCurrentBlockHash(globalVariablesHash, true);
       await this._appendLeaves(MerkleTreeId.BLOCKS_TREE, [blockHash.toBuffer()]);
 
       await this._commit();
     }
-    for (const treeId of merkleTreeIds()) {
+
+    for (const [root, treeId] of treeRootWithIdPairs) {
+      const treeName = MerkleTreeId[treeId];
       const info = await this._getTreeInfo(treeId, false);
-      this.log(`Tree ${MerkleTreeId[treeId]} synched with size ${info.size} root ${info.root.toString('hex')}`);
+      const syncedStr = '0x' + info.root.toString('hex');
+      const rootStr = root.toString();
+      // Sanity check that the rebuilt trees match the roots published by the L2 block
+      if (!info.root.equals(root.toBuffer())) {
+        throw new Error(
+          `Synced tree root ${treeName} does not match published L2 block root: ${syncedStr} != ${rootStr}`,
+        );
+      } else {
+        this.log(`Tree ${treeName} synched with size ${info.size} root ${rootStr}`);
+      }
     }
+
+    return { isBlockOurs: ourBlock };
   }
 }

package/.eslintrc.cjs

@@ -1 +0,0 @@
-module.exports = require('@aztec/foundation/eslint');