@aztec/world-state 0.16.0 → 0.16.2

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -8,6 +8,7 @@ import { LevelUp } from 'levelup';
 
 import { HandleL2BlockResult, MerkleTreeOperations, MerkleTrees } from '../index.js';
 import { MerkleTreeOperationsFacade } from '../merkle-tree/merkle_tree_operations_facade.js';
+import { MerkleTreeSnapshotOperationsFacade } from '../merkle-tree/merkle_tree_snapshot_operations_facade.js';
 import { WorldStateConfig } from './config.js';
 import { WorldStateRunningState, WorldStateStatus, WorldStateSynchronizer } from './world_state_synchronizer.js';
 
@@ -52,6 +53,10 @@ export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
     return new MerkleTreeOperationsFacade(this.merkleTreeDb, false);
   }
 
+  public getSnapshot(blockNumber: number): MerkleTreeOperations {
+    return new MerkleTreeSnapshotOperationsFacade(this.merkleTreeDb, blockNumber);
+  }
+
   public static async new(
     db: LevelUp,
     merkleTreeDb: MerkleTrees,
@@ -130,16 +135,16 @@ export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
   /**
    * Forces an immediate sync
    * @param minBlockNumber - The minimum block number that we must sync to
-   * @returns A promise that resolves once the sync has completed.
+   * @returns A promise that resolves with the block number the world state was synced to
    */
-  public async syncImmediate(minBlockNumber?: number): Promise<void> {
+  public async syncImmediate(minBlockNumber?: number): Promise<number> {
     if (this.currentState !== WorldStateRunningState.RUNNING) {
       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.
     if (minBlockNumber !== undefined && minBlockNumber <= this.currentL2BlockNum) {
-      return;
+      return this.currentL2BlockNum;
     }
     const blockToSyncTo = minBlockNumber === undefined ? 'latest' : `${minBlockNumber}`;
     this.log(`World State at block ${this.currentL2BlockNum}, told to sync to block ${blockToSyncTo}...`);
@@ -148,7 +153,7 @@ export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
     while (true) {
       // Check the block number again
       if (minBlockNumber !== undefined && minBlockNumber <= this.currentL2BlockNum) {
-        return;
+        return this.currentL2BlockNum;
       }
       // Poll for more blocks
       const numBlocks = await this.l2BlockDownloader.pollImmediate();
@@ -164,7 +169,7 @@ export class ServerWorldStateSynchronizer implements WorldStateSynchronizer {
           `Unable to sync to block number ${minBlockNumber}, currently synced to block ${this.currentL2BlockNum}`,
         );
       }
-      return;
+      return this.currentL2BlockNum;
     }
   }
 

package/src/synchronizer/world_state_synchronizer.ts

@@ -48,9 +48,9 @@ export interface WorldStateSynchronizer {
   /**
    * Forces an immediate sync to an optionally provided minimum block number
    * @param minBlockNumber - The minimum block number that we must sync to
-   * @returns A promise that resolves once the sync has completed.
+   * @returns A promise that resolves with the block number the world state was synced to
    */
-  syncImmediate(minBlockNumber?: number): Promise<void>;
+  syncImmediate(minBlockNumber?: number): Promise<number>;
 
   /**
    * Returns an instance of MerkleTreeOperations that will include uncommitted data.
@@ -63,4 +63,11 @@ export interface WorldStateSynchronizer {
    * @returns An instance of MerkleTreeOperations that will not include uncommitted data.
    */
   getCommitted(): MerkleTreeOperations;
+
+  /**
+   * Returns a readonly instance of MerkleTreeOperations where the state is as it was at the given block number
+   * @param block - The block number to look at
+   * @returns An instance of MerkleTreeOperations
+   */
+  getSnapshot(block: number): MerkleTreeOperations;
 }

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

@@ -1,3 +1,2 @@
 export * from './merkle_trees.js';
 export * from './merkle_tree_db.js';
-export { LeafData } from '@aztec/merkle-tree';

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

@@ -1,7 +1,8 @@
-import { MAX_NEW_NULLIFIERS_PER_TX } from '@aztec/circuits.js';
+import { MAX_NEW_NULLIFIERS_PER_TX, NullifierLeafPreimage } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { LeafData, LowLeafWitnessData } from '@aztec/merkle-tree';
+import { IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+import { BatchInsertionResult, IndexedTreeSnapshot, TreeSnapshot } from '@aztec/merkle-tree';
 import { L2Block, MerkleTreeId, SiblingPath } from '@aztec/types';
 
 /**
@@ -91,7 +92,13 @@ export type MerkleTreeDb = {
   [Property in keyof MerkleTreeOperations as Exclude<Property, MerkleTreeSetters>]: WithIncludeUncommitted<
     MerkleTreeOperations[Property]
   >;
-} & Pick<MerkleTreeOperations, MerkleTreeSetters>;
+} & Pick<MerkleTreeOperations, MerkleTreeSetters> & {
+    /**
+     * Returns a snapshot of the current state of the trees.
+     * @param block - The block number to take the snapshot at.
+     */
+    getSnapshot(block: number): Promise<ReadonlyArray<TreeSnapshot | IndexedTreeSnapshot>>;
+  };
 
 /**
  * Defines the interface for operations on a set of Merkle Trees.
@@ -130,23 +137,26 @@ export interface MerkleTreeOperations {
   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;
-  }>;
+  ): Promise<
+    | {
+        /**
+         * The index of the found leaf.
+         */
+        index: bigint;
+        /**
+         * A flag indicating if the corresponding leaf's value is equal to `newValue`.
+         */
+        alreadyPresent: boolean;
+      }
+    | undefined
+  >;
 
   /**
    * 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>;
+  getLeafPreimage(treeId: IndexedTreeId, index: bigint): Promise<IndexedTreeLeafPreimage | undefined>;
 
   /**
    * Update the leaf data at the given index.
@@ -154,7 +164,7 @@ export interface MerkleTreeOperations {
    * @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>;
+  updateLeaf(treeId: IndexedTreeId | PublicTreeId, leaf: NullifierLeafPreimage | Buffer, index: bigint): Promise<void>;
 
   /**
    * Returns the index containing a leaf value.
@@ -175,7 +185,7 @@ export interface MerkleTreeOperations {
    * 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>;
+  updateBlocksTree(globalVariablesHash: Fr): Promise<void>;
 
   /**
    * Updates the latest global variables hash
@@ -195,11 +205,11 @@ export interface MerkleTreeOperations {
    * @param subtreeHeight - Height of the subtree.
    * @returns The witness data for the leaves to be updated when inserting the new ones.
    */
-  batchInsert(
+  batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number>(
     treeId: MerkleTreeId,
     leaves: Buffer[],
     subtreeHeight: number,
-  ): Promise<[LowLeafWitnessData<number>[], SiblingPath<number>] | [undefined, SiblingPath<number>]>;
+  ): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>>;
 
   /**
    * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).

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

@@ -1,23 +1,25 @@
 import {
+  BLOCKS_TREE_HEIGHT,
   CONTRACT_TREE_HEIGHT,
   Fr,
   GlobalVariables,
-  HISTORIC_BLOCKS_TREE_HEIGHT,
   L1_TO_L2_MSG_TREE_HEIGHT,
   NOTE_HASH_TREE_HEIGHT,
   NULLIFIER_SUBTREE_HEIGHT,
   NULLIFIER_TREE_HEIGHT,
+  NullifierLeaf,
+  NullifierLeafPreimage,
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/circuits.js';
 import { computeBlockHash, computeGlobalsHash } from '@aztec/circuits.js/abis';
 import { Committable } from '@aztec/foundation/committable';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
 import {
   AppendOnlyTree,
+  BatchInsertionResult,
   IndexedTree,
-  LeafData,
-  LowLeafWitnessData,
   Pedersen,
   SparseTree,
   StandardIndexedTree,
@@ -26,7 +28,7 @@ import {
   loadTree,
   newTree,
 } from '@aztec/merkle-tree';
-import { L2Block, MerkleTreeId, SiblingPath } from '@aztec/types';
+import { Hasher, L2Block, MerkleTreeId, SiblingPath } from '@aztec/types';
 
 import { default as levelup } from 'levelup';
 
@@ -47,9 +49,20 @@ import {
  */
 interface FromDbOptions {
   /**
-   * The global variables from the last block.
+   * The global variables hash from the last block.
    */
-  globalVariables: GlobalVariables;
+  globalVariablesHash: Fr;
+}
+
+const LAST_GLOBAL_VARS_HASH = 'lastGlobalVarsHash';
+
+/**
+ * The nullifier tree is an indexed tree.
+ */
+class NullifierTree extends StandardIndexedTree {
+  constructor(db: levelup.LevelUp, hasher: Hasher, name: string, depth: number, size: bigint = 0n, root?: Buffer) {
+    super(db, hasher, name, depth, size, NullifierLeafPreimage, NullifierLeaf, root);
+  }
 }
 
 /**
@@ -81,7 +94,7 @@ export class MerkleTrees implements MerkleTreeDb {
       CONTRACT_TREE_HEIGHT,
     );
     const nullifierTree = await initializeTree(
-      StandardIndexedTree,
+      NullifierTree,
       this.db,
       hasher,
       `${MerkleTreeId[MerkleTreeId.NULLIFIER_TREE]}`,
@@ -109,14 +122,14 @@ export class MerkleTrees implements MerkleTreeDb {
       `${MerkleTreeId[MerkleTreeId.L1_TO_L2_MESSAGES_TREE]}`,
       L1_TO_L2_MSG_TREE_HEIGHT,
     );
-    const historicBlocksTree: AppendOnlyTree = await initializeTree(
+    const blocksTree: AppendOnlyTree = await initializeTree(
       StandardTree,
       this.db,
       hasher,
       `${MerkleTreeId[MerkleTreeId.BLOCKS_TREE]}`,
-      HISTORIC_BLOCKS_TREE_HEIGHT,
+      BLOCKS_TREE_HEIGHT,
     );
-    this.trees = [contractTree, nullifierTree, noteHashTree, publicDataTree, l1Tol2MessagesTree, historicBlocksTree];
+    this.trees = [contractTree, nullifierTree, noteHashTree, publicDataTree, l1Tol2MessagesTree, blocksTree];
 
     this.jobQueue.start();
 
@@ -124,10 +137,12 @@ export class MerkleTrees implements MerkleTreeDb {
     if (!fromDb) {
       const initialGlobalVariablesHash = computeGlobalsHash(GlobalVariables.empty());
       await this._updateLatestGlobalVariablesHash(initialGlobalVariablesHash);
-      await this._updateHistoricBlocksTree(initialGlobalVariablesHash, true);
+      await this._updateBlocksTree(initialGlobalVariablesHash, true);
       await this._commit();
     } else {
-      await this._updateLatestGlobalVariablesHash(computeGlobalsHash(fromDbOptions.globalVariables));
+      await this._updateLatestGlobalVariablesHash(fromDbOptions.globalVariablesHash);
+      // make the restored global variables hash and tree roots current
+      await this._commit();
     }
   }
 
@@ -138,7 +153,10 @@ export class MerkleTrees implements MerkleTreeDb {
    */
   public static async new(db: levelup.LevelUp) {
     const merkleTrees = new MerkleTrees(db);
-    await merkleTrees.init();
+    const globalVariablesHash: Buffer | undefined = await db.get(LAST_GLOBAL_VARS_HASH).catch(() => undefined);
+    await merkleTrees.init(
+      globalVariablesHash ? { globalVariablesHash: Fr.fromBuffer(globalVariablesHash) } : undefined,
+    );
     return merkleTrees;
   }
 
@@ -171,8 +189,8 @@ export class MerkleTrees implements MerkleTreeDb {
    * @param globalsHash - The current global variables hash.
    * @param includeUncommitted - Indicates whether to include uncommitted data.
    */
-  public async updateHistoricBlocksTree(globalsHash: Fr, includeUncommitted: boolean) {
-    await this.synchronize(() => this._updateHistoricBlocksTree(globalsHash, includeUncommitted));
+  public async updateBlocksTree(globalsHash: Fr, includeUncommitted: boolean) {
+    await this.synchronize(() => this._updateBlocksTree(globalsHash, includeUncommitted));
   }
 
   /**
@@ -304,19 +322,20 @@ export class MerkleTrees implements MerkleTreeDb {
     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;
-  }> {
-    return await this.synchronize(() =>
-      Promise.resolve(this._getIndexedTree(treeId).findIndexOfPreviousValue(value, includeUncommitted)),
-    );
+  ): Promise<
+    | {
+        /**
+         * The index of the found leaf.
+         */
+        index: bigint;
+        /**
+         * A flag indicating if the corresponding leaf's value is equal to `newValue`.
+         */
+        alreadyPresent: boolean;
+      }
+    | undefined
+  > {
+    return await this.synchronize(() => this._getIndexedTree(treeId).findIndexOfPreviousKey(value, includeUncommitted));
   }
 
   /**
@@ -324,15 +343,15 @@ export class MerkleTrees implements MerkleTreeDb {
    * @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.
+   * @returns Leaf preimage.
    */
-  public async getLeafData(
+  public async getLeafPreimage(
     treeId: IndexedTreeId,
-    index: number,
+    index: bigint,
     includeUncommitted: boolean,
-  ): Promise<LeafData | undefined> {
+  ): Promise<IndexedTreeLeafPreimage | undefined> {
     return await this.synchronize(() =>
-      Promise.resolve(this._getIndexedTree(treeId).getLatestLeafDataCopy(index, includeUncommitted)),
+      this._getIndexedTree(treeId).getLatestLeafPreimageCopy(index, includeUncommitted),
     );
   }
 
@@ -350,13 +369,7 @@ export class MerkleTrees implements MerkleTreeDb {
   ): Promise<bigint | undefined> {
     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);
-        if (currentValue && currentValue.equals(value)) {
-          return i;
-        }
-      }
-      return undefined;
+      return await tree.findLeafIndex(value, includeUncommitted);
     });
   }
 
@@ -367,7 +380,7 @@ export class MerkleTrees implements MerkleTreeDb {
    * @param index - The index to insert into.
    * @returns Empty promise.
    */
-  public async updateLeaf(treeId: IndexedTreeId | PublicTreeId, leaf: LeafData | Buffer, index: bigint): Promise<void> {
+  public async updateLeaf(treeId: IndexedTreeId | PublicTreeId, leaf: Buffer, index: bigint): Promise<void> {
     return await this.synchronize(() => this._updateLeaf(treeId, leaf, index));
   }
 
@@ -395,10 +408,7 @@ export class MerkleTrees implements MerkleTreeDb {
     treeId: MerkleTreeId,
     leaves: Buffer[],
     subtreeHeight: SubtreeHeight,
-  ): Promise<
-    | [LowLeafWitnessData<TreeHeight>[], SiblingPath<SubtreeSiblingPathHeight>]
-    | [undefined, SiblingPath<SubtreeSiblingPathHeight>]
-  > {
+  ): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>> {
     const tree = this.trees[treeId] as StandardIndexedTree;
     if (!('batchInsert' in tree)) {
       throw new Error('Tree does not support `batchInsert` method');
@@ -424,7 +434,7 @@ export class MerkleTrees implements MerkleTreeDb {
     return Promise.resolve(this.latestGlobalVariablesHash.get(includeUncommitted));
   }
 
-  private async _updateHistoricBlocksTree(globalsHash: Fr, includeUncommitted: boolean) {
+  private async _updateBlocksTree(globalsHash: Fr, includeUncommitted: boolean) {
     const blockHash = await this._getCurrentBlockHash(globalsHash, includeUncommitted);
     await this._appendLeaves(MerkleTreeId.BLOCKS_TREE, [blockHash.toBuffer()]);
   }
@@ -483,11 +493,7 @@ export class MerkleTrees implements MerkleTreeDb {
     return await tree.appendLeaves(leaves);
   }
 
-  private async _updateLeaf(
-    treeId: IndexedTreeId | PublicTreeId,
-    leaf: LeafData | Buffer,
-    index: bigint,
-  ): Promise<void> {
+  private async _updateLeaf(treeId: IndexedTreeId | PublicTreeId, leaf: Buffer, index: bigint): Promise<void> {
     const tree = this.trees[treeId];
     if (!('updateLeaf' in tree)) {
       throw new Error('Tree does not support `updateLeaf` method');
@@ -504,6 +510,7 @@ export class MerkleTrees implements MerkleTreeDb {
       await tree.commit();
     }
     this.latestGlobalVariablesHash.commit();
+    await this.db.put(LAST_GLOBAL_VARS_HASH, this.latestGlobalVariablesHash.get().toBuffer());
   }
 
   /**
@@ -517,6 +524,16 @@ export class MerkleTrees implements MerkleTreeDb {
     this.latestGlobalVariablesHash.rollback();
   }
 
+  public getSnapshot(blockNumber: number) {
+    return Promise.all(this.trees.map(tree => tree.getSnapshot(blockNumber)));
+  }
+
+  private async _snapshot(blockNumber: number): Promise<void> {
+    for (const tree of this.trees) {
+      await tree.snapshot(blockNumber);
+    }
+  }
+
   /**
    * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
    * @param l2Block - The L2 block to handle.
@@ -528,7 +545,7 @@ export class MerkleTrees implements MerkleTreeDb {
       [l2Block.endNoteHashTreeSnapshot.root, MerkleTreeId.NOTE_HASH_TREE],
       [l2Block.endPublicDataTreeRoot, MerkleTreeId.PUBLIC_DATA_TREE],
       [l2Block.endL1ToL2MessagesTreeSnapshot.root, MerkleTreeId.L1_TO_L2_MESSAGES_TREE],
-      [l2Block.endHistoricBlocksTreeSnapshot.root, MerkleTreeId.BLOCKS_TREE],
+      [l2Block.endBlocksTreeSnapshot.root, MerkleTreeId.BLOCKS_TREE],
     ] as const;
     const compareRoot = (root: Fr, treeId: MerkleTreeId) => {
       const treeRoot = this.trees[treeId].getRoot(true);
@@ -569,7 +586,7 @@ export class MerkleTrees implements MerkleTreeDb {
         await this._updateLeaf(MerkleTreeId.PUBLIC_DATA_TREE, newValue.toBuffer(), leafIndex.value);
       }
 
-      // Sync and add the block to the historic blocks tree
+      // Sync and add the block to the blocks tree
       const globalVariablesHash = computeGlobalsHash(l2Block.globalVariables);
       await this._updateLatestGlobalVariablesHash(globalVariablesHash);
       this.log(`Synced global variables with hash ${globalVariablesHash}`);
@@ -595,6 +612,8 @@ export class MerkleTrees implements MerkleTreeDb {
       }
     }
 
+    await this._snapshot(l2Block.number);
+
     return { isBlockOurs: ourBlock };
   }
 }