@aztec/aztec-node 0.1.0-alpha43 → 0.1.0-alpha45

package/src/aztec-node/server.ts

@@ -32,8 +32,10 @@ import {
 import {
   MerkleTrees,
   ServerWorldStateSynchroniser,
+  WorldStateConfig,
   WorldStateSynchroniser,
   computePublicDataTreeLeafIndex,
+  getConfigEnvVars as getWorldStateConfig,
 } from '@aztec/world-state';
 
 import { default as levelup } from 'levelup';
@@ -54,7 +56,6 @@ export class AztecNodeService implements AztecNode {
     protected unencryptedLogsSource: L2LogsSource,
     protected contractDataSource: ContractDataSource,
     protected l1ToL2MessageSource: L1ToL2MessageSource,
-    protected merkleTreeDB: MerkleTrees,
     protected worldStateSynchroniser: WorldStateSynchroniser,
     protected sequencer: SequencerClient,
     protected chainId: number,
@@ -80,7 +81,8 @@ export class AztecNodeService implements AztecNode {
 
     // now create the merkle trees and the world state syncher
     const merkleTreeDB = await MerkleTrees.new(levelup(createMemDown()), await CircuitsWasm.get());
-    const worldStateSynchroniser = new ServerWorldStateSynchroniser(merkleTreeDB, archiver);
+    const worldStateConfig: WorldStateConfig = getWorldStateConfig();
+    const worldStateSynchroniser = new ServerWorldStateSynchroniser(merkleTreeDB, archiver, worldStateConfig);
 
     // start both and wait for them to sync from the block source
     await Promise.all([p2pClient.start(), worldStateSynchroniser.start()]);
@@ -101,7 +103,6 @@ export class AztecNodeService implements AztecNode {
       archiver,
       archiver,
       archiver,
-      merkleTreeDB,
       worldStateSynchroniser,
       sequencer,
       config.chainId,
@@ -137,11 +138,11 @@ export class AztecNodeService implements AztecNode {
   }
 
   /**
-   * Method to fetch the current block height.
-   * @returns The block height as a number.
+   * Method to fetch the current block number.
+   * @returns The block number.
    */
-  public async getBlockHeight(): Promise<number> {
-    return await this.blockSource.getBlockHeight();
+  public async getBlockNumber(): Promise<number> {
+    return await this.blockSource.getBlockNumber();
   }
 
   /**
@@ -216,7 +217,6 @@ export class AztecNodeService implements AztecNode {
     await this.sequencer.stop();
     await this.p2pClient.stop();
     await this.worldStateSynchroniser.stop();
-    await this.merkleTreeDB.stop();
     await this.blockSource.stop();
     this.log.info(`Stopped`);
   }
@@ -243,8 +243,9 @@ export class AztecNodeService implements AztecNode {
    * @param leafValue - The value to search for.
    * @returns The index of the given leaf in the contracts tree or undefined if not found.
    */
-  public findContractIndex(leafValue: Buffer): Promise<bigint | undefined> {
-    return this.merkleTreeDB.findLeafIndex(MerkleTreeId.CONTRACT_TREE, leafValue, false);
+  public async findContractIndex(leafValue: Buffer): Promise<bigint | undefined> {
+    const committedDb = await this.getWorldState();
+    return committedDb.findLeafIndex(MerkleTreeId.CONTRACT_TREE, leafValue);
   }
 
   /**
@@ -252,8 +253,9 @@ export class AztecNodeService implements AztecNode {
    * @param leafIndex - The index of the leaf for which the sibling path is required.
    * @returns The sibling path for the leaf index.
    */
-  public getContractPath(leafIndex: bigint): Promise<SiblingPath<typeof CONTRACT_TREE_HEIGHT>> {
-    return this.merkleTreeDB.getSiblingPath(MerkleTreeId.CONTRACT_TREE, leafIndex, false);
+  public async getContractPath(leafIndex: bigint): Promise<SiblingPath<typeof CONTRACT_TREE_HEIGHT>> {
+    const committedDb = await this.getWorldState();
+    return committedDb.getSiblingPath(MerkleTreeId.CONTRACT_TREE, leafIndex);
   }
 
   /**
@@ -261,8 +263,9 @@ export class AztecNodeService implements AztecNode {
    * @param leafValue - The value to search for.
    * @returns The index of the given leaf in the private data tree or undefined if not found.
    */
-  public findCommitmentIndex(leafValue: Buffer): Promise<bigint | undefined> {
-    return this.merkleTreeDB.findLeafIndex(MerkleTreeId.PRIVATE_DATA_TREE, leafValue, false);
+  public async findCommitmentIndex(leafValue: Buffer): Promise<bigint | undefined> {
+    const committedDb = await this.getWorldState();
+    return committedDb.findLeafIndex(MerkleTreeId.PRIVATE_DATA_TREE, leafValue);
   }
 
   /**
@@ -270,8 +273,9 @@ export class AztecNodeService implements AztecNode {
    * @param leafIndex - The index of the leaf for which the sibling path is required.
    * @returns The sibling path for the leaf index.
    */
-  public getDataTreePath(leafIndex: bigint): Promise<SiblingPath<typeof PRIVATE_DATA_TREE_HEIGHT>> {
-    return this.merkleTreeDB.getSiblingPath(MerkleTreeId.PRIVATE_DATA_TREE, leafIndex, false);
+  public async getDataTreePath(leafIndex: bigint): Promise<SiblingPath<typeof PRIVATE_DATA_TREE_HEIGHT>> {
+    const committedDb = await this.getWorldState();
+    return committedDb.getSiblingPath(MerkleTreeId.PRIVATE_DATA_TREE, leafIndex);
   }
 
   /**
@@ -282,12 +286,9 @@ export class AztecNodeService implements AztecNode {
    */
   public async getL1ToL2MessageAndIndex(messageKey: Fr): Promise<L1ToL2MessageAndIndex> {
     // todo: #697 - make this one lookup.
+    const committedDb = await this.getWorldState();
     const message = await this.l1ToL2MessageSource.getConfirmedL1ToL2Message(messageKey);
-    const index = (await this.merkleTreeDB.findLeafIndex(
-      MerkleTreeId.L1_TO_L2_MESSAGES_TREE,
-      messageKey.toBuffer(),
-      false,
-    ))!;
+    const index = (await committedDb.findLeafIndex(MerkleTreeId.L1_TO_L2_MESSAGES_TREE, messageKey.toBuffer()))!;
     return Promise.resolve({ message, index });
   }
 
@@ -296,8 +297,9 @@ export class AztecNodeService implements AztecNode {
    * @param leafIndex - Index of the leaf in the tree.
    * @returns The sibling path.
    */
-  public getL1ToL2MessagesTreePath(leafIndex: bigint): Promise<SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
-    return this.merkleTreeDB.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGES_TREE, leafIndex, false);
+  public async getL1ToL2MessagesTreePath(leafIndex: bigint): Promise<SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
+    const committedDb = await this.getWorldState();
+    return committedDb.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGES_TREE, leafIndex);
   }
 
   /**
@@ -308,8 +310,9 @@ export class AztecNodeService implements AztecNode {
    * Note: Aztec's version of `eth_getStorageAt`.
    */
   public async getPublicStorageAt(contract: AztecAddress, slot: bigint): Promise<Buffer | undefined> {
+    const committedDb = await this.getWorldState();
     const leafIndex = computePublicDataTreeLeafIndex(contract, new Fr(slot), await CircuitsWasm.get());
-    return this.merkleTreeDB.getLeafValue(MerkleTreeId.PUBLIC_DATA_TREE, leafIndex, false);
+    return committedDb.getLeafValue(MerkleTreeId.PUBLIC_DATA_TREE, leafIndex);
   }
 
   /**
@@ -317,16 +320,26 @@ export class AztecNodeService implements AztecNode {
    * @returns The current committed roots for the data trees.
    */
   public async getTreeRoots(): Promise<Record<MerkleTreeId, Fr>> {
-    const getTreeRoot = async (id: MerkleTreeId) =>
-      Fr.fromBuffer((await this.merkleTreeDB.getTreeInfo(id, false)).root);
+    const committedDb = await this.getWorldState();
+    const getTreeRoot = async (id: MerkleTreeId) => Fr.fromBuffer((await committedDb.getTreeInfo(id)).root);
+
+    const [privateDataTree, nullifierTree, contractTree, l1ToL2MessagesTree, blocksTree, publicDataTree] =
+      await Promise.all([
+        getTreeRoot(MerkleTreeId.PRIVATE_DATA_TREE),
+        getTreeRoot(MerkleTreeId.NULLIFIER_TREE),
+        getTreeRoot(MerkleTreeId.CONTRACT_TREE),
+        getTreeRoot(MerkleTreeId.L1_TO_L2_MESSAGES_TREE),
+        getTreeRoot(MerkleTreeId.BLOCKS_TREE),
+        getTreeRoot(MerkleTreeId.PUBLIC_DATA_TREE),
+      ]);
 
     return {
-      [MerkleTreeId.CONTRACT_TREE]: await getTreeRoot(MerkleTreeId.CONTRACT_TREE),
-      [MerkleTreeId.PRIVATE_DATA_TREE]: await getTreeRoot(MerkleTreeId.PRIVATE_DATA_TREE),
-      [MerkleTreeId.NULLIFIER_TREE]: await getTreeRoot(MerkleTreeId.NULLIFIER_TREE),
-      [MerkleTreeId.PUBLIC_DATA_TREE]: await getTreeRoot(MerkleTreeId.PUBLIC_DATA_TREE),
-      [MerkleTreeId.L1_TO_L2_MESSAGES_TREE]: await getTreeRoot(MerkleTreeId.L1_TO_L2_MESSAGES_TREE),
-      [MerkleTreeId.BLOCKS_TREE]: await getTreeRoot(MerkleTreeId.BLOCKS_TREE),
+      [MerkleTreeId.CONTRACT_TREE]: contractTree,
+      [MerkleTreeId.PRIVATE_DATA_TREE]: privateDataTree,
+      [MerkleTreeId.NULLIFIER_TREE]: nullifierTree,
+      [MerkleTreeId.PUBLIC_DATA_TREE]: publicDataTree,
+      [MerkleTreeId.L1_TO_L2_MESSAGES_TREE]: l1ToL2MessagesTree,
+      [MerkleTreeId.BLOCKS_TREE]: blocksTree,
     };
   }
 
@@ -335,20 +348,41 @@ export class AztecNodeService implements AztecNode {
    * @returns The current committed block data.
    */
   public async getHistoricBlockData(): Promise<HistoricBlockData> {
-    const getTreeRoot = async (id: MerkleTreeId) =>
-      Fr.fromBuffer((await this.merkleTreeDB.getTreeInfo(id, false)).root);
-
-    const globalsHash = this.worldStateSynchroniser.latestGlobalVariablesHash;
+    const committedDb = await this.getWorldState();
+    const [roots, globalsHash] = await Promise.all([this.getTreeRoots(), committedDb.getLatestGlobalVariablesHash()]);
 
     return new HistoricBlockData(
-      await getTreeRoot(MerkleTreeId.PRIVATE_DATA_TREE),
-      await getTreeRoot(MerkleTreeId.NULLIFIER_TREE),
-      await getTreeRoot(MerkleTreeId.CONTRACT_TREE),
-      await getTreeRoot(MerkleTreeId.L1_TO_L2_MESSAGES_TREE),
-      await getTreeRoot(MerkleTreeId.BLOCKS_TREE),
+      roots[MerkleTreeId.PRIVATE_DATA_TREE],
+      roots[MerkleTreeId.NULLIFIER_TREE],
+      roots[MerkleTreeId.CONTRACT_TREE],
+      roots[MerkleTreeId.L1_TO_L2_MESSAGES_TREE],
+      roots[MerkleTreeId.BLOCKS_TREE],
       Fr.ZERO,
-      await getTreeRoot(MerkleTreeId.PUBLIC_DATA_TREE),
+      roots[MerkleTreeId.PUBLIC_DATA_TREE],
       globalsHash,
     );
   }
+
+  /**
+   * Returns an instance of MerkleTreeOperations having first ensured the world state is fully synched
+   * @returns An instance of a committed MerkleTreeOperations
+   */
+  private async getWorldState() {
+    try {
+      // Attempt to sync the world state if necessary
+      await this.syncWorldState();
+    } catch (err) {
+      this.log.error(`Error getting world state: ${err}`);
+    }
+    return this.worldStateSynchroniser.getCommitted();
+  }
+
+  /**
+   * Ensure we fully sync the world state
+   * @returns A promise that fulfils once the world state is synced
+   */
+  private async syncWorldState() {
+    const blockSourceHeight = await this.blockSource.getBlockNumber();
+    await this.worldStateSynchroniser.syncImmediate(blockSourceHeight);
+  }
 }