@aztec/world-state 0.1.0-alpha22 → 0.1.0-alpha39

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

@@ -1,32 +1,38 @@
 import {
   BaseRollupInputs,
   CONTRACT_TREE_HEIGHT,
-  CONTRACT_TREE_ROOTS_TREE_HEIGHT,
   CircuitsWasm,
   Fr,
-  L1_TO_L2_MSG_ROOTS_TREE_HEIGHT,
+  GlobalVariables,
+  HISTORIC_BLOCKS_TREE_HEIGHT,
   L1_TO_L2_MSG_TREE_HEIGHT,
   NULLIFIER_TREE_HEIGHT,
   PRIVATE_DATA_TREE_HEIGHT,
-  PRIVATE_DATA_TREE_ROOTS_TREE_HEIGHT,
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/circuits.js';
+import { computeBlockHashWithGlobals } from '@aztec/circuits.js/abis';
+import { SerialQueue } from '@aztec/foundation/fifo';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { IWasmModule } from '@aztec/foundation/wasm';
 import {
   AppendOnlyTree,
   IndexedTree,
   LeafData,
   LowLeafWitnessData,
   Pedersen,
-  SiblingPath,
   SparseTree,
   StandardIndexedTree,
   StandardTree,
   UpdateOnlyTree,
   newTree,
 } from '@aztec/merkle-tree';
+import { L2Block, MerkleTreeId, SiblingPath, merkleTreeIds } from '@aztec/types';
+
 import { default as levelup } from 'levelup';
+
+import { MerkleTreeOperationsFacade } from '../merkle-tree/merkle_tree_operations_facade.js';
 import {
-  CurrentCommitmentTreeRoots,
+  CurrentTreeRoots,
   INITIAL_NULLIFIER_TREE_SIZE,
   IndexedTreeId,
   MerkleTreeDb,
@@ -34,11 +40,6 @@ import {
   PublicTreeId,
   TreeInfo,
 } from './index.js';
-import { MerkleTreeOperationsFacade } from '../merkle-tree/merkle_tree_operations_facade.js';
-import { L2Block, MerkleTreeId, merkleTreeIds } from '@aztec/types';
-import { SerialQueue } from '@aztec/foundation/fifo';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { IWasmModule } from '@aztec/foundation/wasm';
 
 /**
  * A convenience class for managing multiple merkle trees.
@@ -63,13 +64,6 @@ export class MerkleTrees implements MerkleTreeDb {
       `${MerkleTreeId[MerkleTreeId.CONTRACT_TREE]}`,
       CONTRACT_TREE_HEIGHT,
     );
-    const contractTreeRootsTree: AppendOnlyTree = await newTree(
-      StandardTree,
-      this.db,
-      hasher,
-      `${MerkleTreeId[MerkleTreeId.CONTRACT_TREE_ROOTS_TREE]}`,
-      CONTRACT_TREE_ROOTS_TREE_HEIGHT,
-    );
     const nullifierTree = await newTree(
       StandardIndexedTree,
       this.db,
@@ -85,13 +79,6 @@ export class MerkleTrees implements MerkleTreeDb {
       `${MerkleTreeId[MerkleTreeId.PRIVATE_DATA_TREE]}`,
       PRIVATE_DATA_TREE_HEIGHT,
     );
-    const privateDataTreeRootsTree: AppendOnlyTree = await newTree(
-      StandardTree,
-      this.db,
-      hasher,
-      `${MerkleTreeId[MerkleTreeId.PRIVATE_DATA_TREE_ROOTS_TREE]}`,
-      PRIVATE_DATA_TREE_ROOTS_TREE_HEIGHT,
-    );
     const publicDataTree: UpdateOnlyTree = await newTree(
       SparseTree,
       this.db,
@@ -106,30 +93,20 @@ export class MerkleTrees implements MerkleTreeDb {
       `${MerkleTreeId[MerkleTreeId.L1_TO_L2_MESSAGES_TREE]}`,
       L1_TO_L2_MSG_TREE_HEIGHT,
     );
-    const l1Tol2MessagesRootsTree: AppendOnlyTree = await newTree(
+    const historicBlocksTree: AppendOnlyTree = await newTree(
       StandardTree,
       this.db,
       hasher,
-      `${MerkleTreeId[MerkleTreeId.L1_TO_L2_MESSAGES_ROOTS_TREE]}`,
-      L1_TO_L2_MSG_ROOTS_TREE_HEIGHT,
+      `${MerkleTreeId[MerkleTreeId.BLOCKS_TREE]}`,
+      HISTORIC_BLOCKS_TREE_HEIGHT,
     );
-    this.trees = [
-      contractTree,
-      contractTreeRootsTree,
-      nullifierTree,
-      privateDataTree,
-      privateDataTreeRootsTree,
-      publicDataTree,
-      l1Tol2MessagesTree,
-      l1Tol2MessagesRootsTree,
-    ];
+    this.trees = [contractTree, nullifierTree, privateDataTree, publicDataTree, l1Tol2MessagesTree, historicBlocksTree];
 
     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()));
+    // The first leaf in the blocks tree contains the empty roots of the other trees and empty global variables.
+    await this.updateHistoricBlocksTree(GlobalVariables.empty(), true);
+    await historicBlocksTree.commit();
   }
 
   /**
@@ -170,17 +147,12 @@ export class MerkleTrees implements MerkleTreeDb {
   /**
    * 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 globals - The global variables to use for hashing.
    * @param includeUncommitted - Indicates whether to include uncommitted data.
    */
-  public async updateHistoricRootsTrees(includeUncommitted: boolean) {
-    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],
-    ] as const) {
-      const newTreeInfo = await this.getTreeInfo(newTree, includeUncommitted);
-      await this.appendLeaves(rootTree, [newTreeInfo.root]);
-    }
+  public async updateHistoricBlocksTree(globals: GlobalVariables, includeUncommitted: boolean) {
+    const blockHash = await this.getCurrentBlockHash(globals, includeUncommitted);
+    await this.appendLeaves(MerkleTreeId.BLOCKS_TREE, [blockHash.toBuffer()]);
   }
 
   /**
@@ -198,22 +170,36 @@ export class MerkleTrees implements MerkleTreeDb {
    * @param includeUncommitted - Indicates whether to include uncommitted data.
    * @returns The current roots of the trees.
    */
-  public getCommitmentTreeRoots(includeUncommitted: boolean): CurrentCommitmentTreeRoots {
-    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));
+  public getTreeRoots(includeUncommitted: boolean): CurrentTreeRoots {
+    const roots = this.getAllTreeRoots(includeUncommitted);
 
     return {
       privateDataTreeRoot: roots[0],
-      contractDataTreeRoot: roots[1],
-      l1Tol2MessagesTreeRoot: roots[2],
-      nullifierTreeRoot: roots[3],
+      nullifierTreeRoot: roots[1],
+      contractDataTreeRoot: roots[2],
+      l1Tol2MessagesTreeRoot: roots[3],
+      publicDataTreeRoot: roots[4],
+      blocksTreeRoot: roots[5],
     };
   }
 
+  async getCurrentBlockHash(globals: GlobalVariables, includeUncommitted: boolean): Promise<Fr> {
+    const roots = this.getAllTreeRoots(includeUncommitted).map(root => Fr.fromBuffer(root));
+    const wasm = await CircuitsWasm.get();
+    return computeBlockHashWithGlobals(wasm, globals, roots[0], roots[1], roots[2], roots[3], roots[4]);
+  }
+
+  getAllTreeRoots(includeUncommitted: boolean): Buffer[] {
+    return [
+      MerkleTreeId.PRIVATE_DATA_TREE,
+      MerkleTreeId.NULLIFIER_TREE,
+      MerkleTreeId.CONTRACT_TREE,
+      MerkleTreeId.L1_TO_L2_MESSAGES_TREE,
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      MerkleTreeId.BLOCKS_TREE,
+    ].map(tree => this.trees[tree].getRoot(includeUncommitted));
+  }
+
   /**
    * Gets the value at the given index.
    * @param treeId - The ID of the tree to get the leaf value from.
@@ -491,16 +477,8 @@ export class MerkleTrees implements MerkleTreeDb {
       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,
-      ),
+      compareRoot(l2Block.endHistoricBlocksTreeSnapshot.root, MerkleTreeId.BLOCKS_TREE),
     ];
     const ourBlock = rootChecks.every(x => x);
     if (ourBlock) {
@@ -510,6 +488,7 @@ export class MerkleTrees implements MerkleTreeDb {
       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
       for (const [tree, leaves] of [
         [MerkleTreeId.CONTRACT_TREE, l2Block.newContracts],
         [MerkleTreeId.PRIVATE_DATA_TREE, l2Block.newCommitments],
@@ -521,25 +500,23 @@ export class MerkleTrees implements MerkleTreeDb {
         );
       }
 
+      // Sync the indexed trees
       await (this.trees[MerkleTreeId.NULLIFIER_TREE] as StandardIndexedTree).batchInsert(
         l2Block.newNullifiers.map(fr => fr.toBuffer()),
         BaseRollupInputs.NULLIFIER_SUBTREE_HEIGHT,
       );
 
+      // Sync the public data tree
       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],
-      ] as const) {
-        const newTreeRoot = this.trees[newTree].getRoot(true);
-        await this._appendLeaves(rootTree, [newTreeRoot]);
-      }
+      // Sync and add the block to the historic blocks tree
+      const blockHash = await this.getCurrentBlockHash(l2Block.globalVariables, true);
+      await this._appendLeaves(MerkleTreeId.BLOCKS_TREE, [blockHash.toBuffer()]);
+
       await this._commit();
     }
     for (const treeId of merkleTreeIds()) {