@aztec/p2p 0.72.1 → 0.74.0

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -68,26 +68,29 @@ export class InMemoryTxPool implements TxPool {
     return Promise.resolve();
   }
 
-  public getPendingTxHashes(): TxHash[] {
-    return this.getAllTxs()
-      .sort((tx1, tx2) => -getPendingTxPriority(tx1).localeCompare(getPendingTxPriority(tx2)))
-      .map(tx => tx.getTxHash())
-      .filter(txHash => this.pendingTxs.has(txHash.toBigInt()));
+  public async getPendingTxHashes(): Promise<TxHash[]> {
+    const txs = (await this.getAllTxs()).sort(
+      (tx1, tx2) => -getPendingTxPriority(tx1).localeCompare(getPendingTxPriority(tx2)),
+    );
+    const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    return txHashes.filter(txHash => this.pendingTxs.has(txHash.toBigInt()));
   }
 
-  public getMinedTxHashes(): [TxHash, number][] {
-    return Array.from(this.minedTxs.entries()).map(([txHash, blockNumber]) => [TxHash.fromBigInt(txHash), blockNumber]);
+  public getMinedTxHashes(): Promise<[TxHash, number][]> {
+    return Promise.resolve(
+      Array.from(this.minedTxs.entries()).map(([txHash, blockNumber]) => [TxHash.fromBigInt(txHash), blockNumber]),
+    );
   }
 
-  public getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined {
+  public getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
     const key = txHash.toBigInt();
     if (this.pendingTxs.has(key)) {
-      return 'pending';
+      return Promise.resolve('pending');
     }
     if (this.minedTxs.has(key)) {
-      return 'mined';
+      return Promise.resolve('mined');
     }
-    return undefined;
+    return Promise.resolve(undefined);
   }
 
   /**
@@ -95,13 +98,13 @@ export class InMemoryTxPool implements TxPool {
    * @param txHash - The generated tx hash.
    * @returns The transaction, if found, 'undefined' otherwise.
    */
-  public getTxByHash(txHash: TxHash): Tx | undefined {
+  public getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
     const result = this.txs.get(txHash.toBigInt());
-    return result === undefined ? undefined : Tx.clone(result);
+    return Promise.resolve(result === undefined ? undefined : Tx.clone(result));
   }
 
-  public getArchivedTxByHash(): Tx | undefined {
-    return undefined;
+  public getArchivedTxByHash(): Promise<Tx | undefined> {
+    return Promise.resolve(undefined);
   }
 
   /**
@@ -109,13 +112,13 @@ export class InMemoryTxPool implements TxPool {
    * @param txs - An array of txs to be added to the pool.
    * @returns Empty promise.
    */
-  public addTxs(txs: Tx[]): Promise<void> {
+  public async addTxs(txs: Tx[]): Promise<void> {
     let pending = 0;
     for (const tx of txs) {
-      const txHash = tx.getTxHash();
+      const txHash = await tx.getTxHash();
       this.log.verbose(`Adding tx ${txHash.toString()} to pool`, {
         eventName: 'tx-added-to-pool',
-        ...tx.getStats(),
+        ...(await tx.getStats()),
       } satisfies TxAddedToPoolStats);
 
       const key = txHash.toBigInt();
@@ -128,7 +131,7 @@ export class InMemoryTxPool implements TxPool {
     }
 
     this.metrics.recordAddedObjects(pending, 'pending');
-    return Promise.resolve();
+    return;
   }
 
   /**
@@ -157,15 +160,15 @@ export class InMemoryTxPool implements TxPool {
    * Gets all the transactions stored in the pool.
    * @returns Array of tx objects in the order they were added to the pool.
    */
-  public getAllTxs(): Tx[] {
-    return Array.from(this.txs.values()).map(x => Tx.clone(x));
+  public getAllTxs(): Promise<Tx[]> {
+    return Promise.resolve(Array.from(this.txs.values()).map(x => Tx.clone(x)));
   }
 
   /**
    * Gets the hashes of all transactions currently in the tx pool.
    * @returns An array of transaction hashes found in the tx pool.
    */
-  public getAllTxHashes(): TxHash[] {
-    return Array.from(this.txs.keys()).map(x => TxHash.fromBigInt(x));
+  public getAllTxHashes(): Promise<TxHash[]> {
+    return Promise.resolve(Array.from(this.txs.keys()).map(x => TxHash.fromBigInt(x)));
   }
 }

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -15,14 +15,14 @@ export interface TxPool {
    * @param txHash - The hash of the transaction, used as an ID.
    * @returns The transaction, if found, 'undefined' otherwise.
    */
-  getTxByHash(txHash: TxHash): Tx | undefined;
+  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
 
   /**
    * Checks if an archived transaction exists in the pool and returns it.
    * @param txHash - The hash of the transaction, used as an ID.
    * @returns The transaction, if found, 'undefined' otherwise.
    */
-  getArchivedTxByHash(txHash: TxHash): Tx | undefined;
+  getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined>;
 
   /**
    * Marks the set of txs as mined, as opposed to pending.
@@ -47,30 +47,30 @@ export interface TxPool {
    * Gets all transactions currently in the tx pool.
    * @returns An array of transaction objects found in the tx pool.
    */
-  getAllTxs(): Tx[];
+  getAllTxs(): Promise<Tx[]>;
 
   /**
    * Gets the hashes of all transactions currently in the tx pool.
    * @returns An array of transaction hashes found in the tx pool.
    */
-  getAllTxHashes(): TxHash[];
+  getAllTxHashes(): Promise<TxHash[]>;
 
   /**
    * Gets the hashes of pending transactions currently in the tx pool sorted by priority (see getPendingTxPriority).
    * @returns An array of pending transaction hashes found in the tx pool.
    */
-  getPendingTxHashes(): TxHash[];
+  getPendingTxHashes(): Promise<TxHash[]>;
 
   /**
    * Gets the hashes of mined transactions currently in the tx pool.
    * @returns An array of mined transaction hashes found in the tx pool.
    */
-  getMinedTxHashes(): [tx: TxHash, blockNumber: number][];
+  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: number][]>;
 
   /**
    * Returns whether the given tx hash is flagged as pending or mined.
    * @param txHash - Hash of the tx to query.
    * @returns Pending or mined depending on its status, or undefined if not found.
    */
-  getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined;
+  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined>;
 }

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -16,94 +16,97 @@ export function describeTxPool(getTxPool: () => TxPool) {
   });
 
   it('Adds txs to the pool as pending', async () => {
-    const tx1 = mockTx();
+    const tx1 = await mockTx();
 
     await pool.addTxs([tx1]);
-    const poolTx = pool.getTxByHash(tx1.getTxHash());
-    expect(poolTx!.getTxHash()).toEqual(tx1.getTxHash());
-    expect(pool.getTxStatus(tx1.getTxHash())).toEqual('pending');
-    expect(pool.getPendingTxHashes()).toEqual([tx1.getTxHash()]);
+    const poolTx = await pool.getTxByHash(await tx1.getTxHash());
+    expect(await poolTx!.getTxHash()).toEqual(await tx1.getTxHash());
+    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('pending');
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]);
   });
 
   it('Removes txs from the pool', async () => {
-    const tx1 = mockTx();
+    const tx1 = await mockTx();
 
     await pool.addTxs([tx1]);
-    await pool.deleteTxs([tx1.getTxHash()]);
+    await pool.deleteTxs([await tx1.getTxHash()]);
 
-    expect(pool.getTxByHash(tx1.getTxHash())).toBeFalsy();
-    expect(pool.getTxStatus(tx1.getTxHash())).toBeUndefined();
+    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
+    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
   });
 
   it('Marks txs as mined', async () => {
-    const tx1 = mockTx(1);
-    const tx2 = mockTx(2);
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([tx1.getTxHash()], 1);
+    await pool.markAsMined([await tx1.getTxHash()], 1);
 
-    expect(pool.getTxByHash(tx1.getTxHash())).toEqual(tx1);
-    expect(pool.getTxStatus(tx1.getTxHash())).toEqual('mined');
-    expect(pool.getMinedTxHashes()).toEqual([[tx1.getTxHash(), 1]]);
-    expect(pool.getPendingTxHashes()).toEqual([tx2.getTxHash()]);
+    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
+    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([[await tx1.getTxHash(), 1]]);
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx2.getTxHash()]);
   });
 
   it('Marks txs as pending after being mined', async () => {
-    const tx1 = mockTx(1);
-    const tx2 = mockTx(2);
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([tx1.getTxHash()], 1);
+    await pool.markAsMined([await tx1.getTxHash()], 1);
 
-    await pool.markMinedAsPending([tx1.getTxHash()]);
-    expect(pool.getMinedTxHashes()).toEqual([]);
-    const pending = pool.getPendingTxHashes();
+    await pool.markMinedAsPending([await tx1.getTxHash()]);
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
+    const pending = await pool.getPendingTxHashes();
     expect(pending).toHaveLength(2);
-    expect(pending).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash()]));
+    expect(pending).toEqual(expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash()]));
   });
 
   it('Only marks txs as pending if they are known', async () => {
-    const tx1 = mockTx(1);
+    const tx1 = await mockTx(1);
     // simulate a situation where not all peers have all the txs
-    const someTxHashThatThisPeerDidNotSee = mockTx(2).getTxHash();
+    const tx2 = await mockTx(2);
+    const someTxHashThatThisPeerDidNotSee = await tx2.getTxHash();
     await pool.addTxs([tx1]);
     // this peer knows that tx2 was mined, but it does not have the tx object
-    await pool.markAsMined([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], 1);
-    expect(new Set(pool.getMinedTxHashes())).toEqual(
-      new Set([
-        [tx1.getTxHash(), 1],
+    await pool.markAsMined([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], 1);
+    expect(await pool.getMinedTxHashes()).toEqual(
+      expect.arrayContaining([
+        [await tx1.getTxHash(), 1],
         [someTxHashThatThisPeerDidNotSee, 1],
       ]),
     );
 
     // reorg: both txs should now become available again
-    await pool.markMinedAsPending([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
-    expect(pool.getMinedTxHashes()).toEqual([]);
-    expect(pool.getPendingTxHashes()).toEqual([tx1.getTxHash()]); // tx2 is not in the pool
+    await pool.markMinedAsPending([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]); // tx2 is not in the pool
   });
 
   it('Returns all transactions in the pool', async () => {
-    const tx1 = mockTx(1);
-    const tx2 = mockTx(2);
-    const tx3 = mockTx(3);
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
 
     await pool.addTxs([tx1, tx2, tx3]);
 
-    const poolTxs = pool.getAllTxs();
+    const poolTxs = await pool.getAllTxs();
     expect(poolTxs).toHaveLength(3);
     expect(poolTxs).toEqual(expect.arrayContaining([tx1, tx2, tx3]));
   });
 
   it('Returns all txHashes in the pool', async () => {
-    const tx1 = mockTx(1);
-    const tx2 = mockTx(2);
-    const tx3 = mockTx(3);
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
 
     await pool.addTxs([tx1, tx2, tx3]);
 
-    const poolTxHashes = pool.getAllTxHashes();
+    const poolTxHashes = await pool.getAllTxHashes();
     expect(poolTxHashes).toHaveLength(3);
-    expect(poolTxHashes).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash(), tx3.getTxHash()]));
+    expect(poolTxHashes).toEqual(
+      expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash(), await tx3.getTxHash()]),
+    );
   });
 
   it('Returns pending tx hashes sorted by priority', async () => {
@@ -112,15 +115,15 @@ export function describeTxPool(getTxPool: () => TxPool) {
       return tx;
     };
 
-    const tx1 = withPriorityFee(mockTx(0), 1000);
-    const tx2 = withPriorityFee(mockTx(1), 100);
-    const tx3 = withPriorityFee(mockTx(2), 200);
-    const tx4 = withPriorityFee(mockTx(3), 3000);
+    const tx1 = withPriorityFee(await mockTx(0), 1000);
+    const tx2 = withPriorityFee(await mockTx(1), 100);
+    const tx3 = withPriorityFee(await mockTx(2), 200);
+    const tx4 = withPriorityFee(await mockTx(3), 3000);
 
     await pool.addTxs([tx1, tx2, tx3, tx4]);
 
-    const poolTxHashes = pool.getPendingTxHashes();
+    const poolTxHashes = await pool.getPendingTxHashes();
     expect(poolTxHashes).toHaveLength(4);
-    expect(poolTxHashes).toEqual([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash()));
+    expect(poolTxHashes).toEqual(await Promise.all([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash())));
   });
 }

package/src/mocks/index.ts

@@ -8,7 +8,7 @@ import {
 import { type EpochCache } from '@aztec/epoch-cache';
 import { timesParallel } from '@aztec/foundation/collection';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
-import { openTmpStore } from '@aztec/kv-store/lmdb';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { gossipsub } from '@chainsafe/libp2p-gossipsub';
@@ -263,7 +263,7 @@ export async function createBootstrapNode(
 
 async function startBootstrapNode(config: BootnodeConfig, telemetry: TelemetryClient) {
   // Open an ephemeral store that will only exist in memory
-  const store = openTmpStore(true);
+  const store = await openTmpStore('bootstrap-node', true);
   const bootstrapNode = new BootstrapNode(store, telemetry);
   await bootstrapNode.start(config);
   return bootstrapNode;

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -16,7 +16,7 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
       return PeerErrorSeverity.HighToleranceError;
     }
 
-    const attester = message.getSender();
+    const attester = await message.getSender();
     if (!(await this.epochCache.isInCommittee(attester))) {
       return PeerErrorSeverity.HighToleranceError;
     }

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -19,7 +19,7 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
     }
 
     // Check that the block proposal is from the current or next proposer
-    const proposer = block.getSender();
+    const proposer = await block.getSender();
     if (!proposer.equals(currentProposer) && !proposer.equals(nextProposer)) {
       return PeerErrorSeverity.HighToleranceError;
     }

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -15,9 +15,9 @@ export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    const [index] = await this.#archiveSource.getArchiveIndices([tx.data.constants.historicalHeader.hash()]);
+    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.historicalHeader.hash()]);
     if (index === undefined) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for referencing an unknown block header`);
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
       return { result: 'invalid', reason: ['Block header not found'] };
     }
     return { result: 'valid' };

package/src/msg_validators/tx_validator/data_validator.ts

@@ -5,10 +5,10 @@ export class DataTxValidator implements TxValidator<Tx> {
   #log = createLogger('p2p:tx_validator:tx_data');
 
   validateTx(tx: Tx): Promise<TxValidationResult> {
-    return Promise.resolve(this.#hasCorrectExecutionRequests(tx));
+    return this.#hasCorrectExecutionRequests(tx);
   }
 
-  #hasCorrectExecutionRequests(tx: Tx): TxValidationResult {
+  async #hasCorrectExecutionRequests(tx: Tx): Promise<TxValidationResult> {
     const callRequests = [
       ...tx.data.getRevertiblePublicCallRequests(),
       ...tx.data.getNonRevertiblePublicCallRequests(),
@@ -21,13 +21,16 @@ export class DataTxValidator implements TxValidator<Tx> {
       );
       return { result: 'invalid', reason: ['Wrong number of execution requests for public calls'] };
     }
-
-    const invalidExecutionRequestIndex = tx.enqueuedPublicFunctionCalls.findIndex(
-      (execRequest, i) => !execRequest.isForCallRequest(callRequests[i]),
-    );
+    const invalidExecutionRequestIndex = (
+      await Promise.all(
+        tx.enqueuedPublicFunctionCalls.map(
+          async (execRequest, i) => !(await execRequest.isForCallRequest(callRequests[i])),
+        ),
+      )
+    ).findIndex(Boolean);
     if (invalidExecutionRequestIndex !== -1) {
       this.#log.warn(
-        `Rejecting tx ${Tx.getHash(
+        `Rejecting tx ${await Tx.getHash(
           tx,
         )} because of incorrect execution requests for public call at index ${invalidExecutionRequestIndex}.`,
       );
@@ -37,9 +40,9 @@ export class DataTxValidator implements TxValidator<Tx> {
     const teardownCallRequest = tx.data.getTeardownPublicCallRequest();
     const isInvalidTeardownExecutionRequest =
       (!teardownCallRequest && !tx.publicTeardownFunctionCall.isEmpty()) ||
-      (teardownCallRequest && !tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest));
+      (teardownCallRequest && !(await tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest)));
     if (isInvalidTeardownExecutionRequest) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of incorrect teardown execution requests.`);
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} because of incorrect teardown execution requests.`);
       return { result: 'invalid', reason: ['Incorrect teardown execution request'] };
     }
 

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -19,12 +19,12 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
     // Ditch this tx if it has repeated nullifiers
     const uniqueNullifiers = new Set(nullifiers);
     if (uniqueNullifiers.size !== nullifiers.length) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for emitting duplicate nullifiers`);
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for emitting duplicate nullifiers`);
       return { result: 'invalid', reason: ['Duplicate nullifier in tx'] };
     }
 
     if ((await this.#nullifierSource.nullifiersExist(nullifiers.map(n => n.toBuffer()))).some(Boolean)) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating a nullifier`);
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for repeating a nullifier`);
       return { result: 'invalid', reason: ['Existing nullifier'] };
     }
 

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -7,21 +7,21 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
 
   constructor(private chainId: Fr, private blockNumber: Fr) {}
 
-  validateTx(tx: T): Promise<TxValidationResult> {
+  async validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];
-    if (!this.#hasCorrectChainId(tx)) {
+    if (!(await this.#hasCorrectChainId(tx))) {
       errors.push('Incorrect chain id');
     }
-    if (!this.#isValidForBlockNumber(tx)) {
+    if (!(await this.#isValidForBlockNumber(tx))) {
       errors.push('Invalid block number');
     }
-    return Promise.resolve(errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' });
+    return errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' };
   }
 
-  #hasCorrectChainId(tx: T): boolean {
+  async #hasCorrectChainId(tx: T): Promise<boolean> {
     if (!tx.data.constants.txContext.chainId.equals(this.chainId)) {
       this.#log.warn(
-        `Rejecting tx ${Tx.getHash(
+        `Rejecting tx ${await Tx.getHash(
           tx,
         )} because of incorrect chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.chainId.toNumber()}`,
       );
@@ -31,12 +31,12 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  #isValidForBlockNumber(tx: T): boolean {
+  async #isValidForBlockNumber(tx: T): Promise<boolean> {
     const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
 
     if (maxBlockNumber.isSome && maxBlockNumber.value < this.blockNumber) {
       this.#log.warn(
-        `Rejecting tx ${Tx.getHash(tx)} for low max block number. Tx max block number: ${
+        `Rejecting tx ${await Tx.getHash(tx)} for low max block number. Tx max block number: ${
           maxBlockNumber.value
         }, current block number: ${this.blockNumber}.`,
       );

package/src/services/data_store.ts

@@ -1,5 +1,5 @@
 import { filter, map, sort, take } from '@aztec/foundation/iterable';
-import type { AztecKVStore, AztecMap } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 
 import { type Batch, type Datastore, Key, type KeyQuery, type Pair, type Query } from 'interface-datastore';
 import type { AwaitIterable } from 'interface-store';
@@ -25,31 +25,31 @@ class KeyNotFoundError extends Error {
 
 export class AztecDatastore implements Datastore {
   #memoryDatastore: Map<string, MemoryItem>;
-  #dbDatastore: AztecMap<string, Uint8Array>;
+  #dbDatastore: AztecAsyncMap<string, Uint8Array>;
 
   #batchOps: BatchOp[] = [];
 
   private maxMemoryItems: number;
 
-  constructor(db: AztecKVStore, { maxMemoryItems } = { maxMemoryItems: 50 }) {
+  constructor(db: AztecAsyncKVStore, { maxMemoryItems } = { maxMemoryItems: 50 }) {
     this.#memoryDatastore = new Map();
     this.#dbDatastore = db.openMap('p2p_datastore');
 
     this.maxMemoryItems = maxMemoryItems;
   }
 
-  has(key: Key): boolean {
-    return this.#memoryDatastore.has(key.toString()) || this.#dbDatastore.has(key.toString());
+  async has(key: Key): Promise<boolean> {
+    return this.#memoryDatastore.has(key.toString()) || (await this.#dbDatastore.hasAsync(key.toString()));
   }
 
-  get(key: Key): Uint8Array {
+  async get(key: Key): Promise<Uint8Array> {
     const keyStr = key.toString();
     const memoryItem = this.#memoryDatastore.get(keyStr);
     if (memoryItem) {
       memoryItem.lastAccessedMs = Date.now();
       return memoryItem.data;
     }
-    const dbItem = this.#dbDatastore.get(keyStr);
+    const dbItem = await this.#dbDatastore.getAsync(keyStr);
 
     if (!dbItem) {
       throw new KeyNotFoundError(`Key not found`);
@@ -73,7 +73,7 @@ export class AztecDatastore implements Datastore {
     for await (const key of source) {
       yield {
         key,
-        value: this.get(key),
+        value: await this.get(key),
       };
     }
   }
@@ -202,7 +202,7 @@ export class AztecDatastore implements Datastore {
       };
     }
 
-    for (const [key, value] of this.#dbDatastore.entries()) {
+    for await (const [key, value] of this.#dbDatastore.entriesAsync()) {
       if (!this.#memoryDatastore.has(key)) {
         yield {
           key: new Key(key),