@aztec/p2p 0.71.0 → 0.73.0

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -1,8 +1,9 @@
 import { Tx, TxHash } from '@aztec/circuit-types';
 import { type TxAddedToPoolStats } from '@aztec/circuit-types/stats';
 import { ClientIvcProof } from '@aztec/circuits.js';
+import { toArray } from '@aztec/foundation/iterable';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMap, type AztecMultiMap } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { PoolInstrumentation, PoolName } from '../instrumentation.js';
@@ -13,25 +14,25 @@ import { type TxPool } from './tx_pool.js';
  * KV implementation of the Transaction Pool.
  */
 export class AztecKVTxPool implements TxPool {
-  #store: AztecKVStore;
+  #store: AztecAsyncKVStore;
 
   /** Our tx pool, stored as a Map, with K: tx hash and V: the transaction. */
-  #txs: AztecMap<string, Buffer>;
+  #txs: AztecAsyncMap<string, Buffer>;
 
   /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */
-  #minedTxHashToBlock: AztecMap<string, number>;
+  #minedTxHashToBlock: AztecAsyncMap<string, number>;
 
   /** Index from tx priority (stored as hex) to its tx hash, filtered by pending txs. */
-  #pendingTxPriorityToHash: AztecMultiMap<string, string>;
+  #pendingTxPriorityToHash: AztecAsyncMultiMap<string, string>;
 
   /** KV store for archived txs. */
-  #archive: AztecKVStore;
+  #archive: AztecAsyncKVStore;
 
   /** Archived txs map for future lookup. */
-  #archivedTxs: AztecMap<string, Buffer>;
+  #archivedTxs: AztecAsyncMap<string, Buffer>;
 
   /** Indexes of the archived txs by insertion order. */
-  #archivedTxIndices: AztecMap<number, string>;
+  #archivedTxIndices: AztecAsyncMap<number, string>;
 
   /** Number of txs to archive. */
   #archivedTxLimit: number;
@@ -49,8 +50,8 @@ export class AztecKVTxPool implements TxPool {
    * @param log - A logger.
    */
   constructor(
-    store: AztecKVStore,
-    archive: AztecKVStore,
+    store: AztecAsyncKVStore,
+    archive: AztecAsyncKVStore,
     telemetry: TelemetryClient = getTelemetryClient(),
     archivedTxLimit: number = 0,
     log = createLogger('p2p:tx_pool'),
@@ -75,16 +76,16 @@ export class AztecKVTxPool implements TxPool {
     }
 
     let deletedPending = 0;
-    return this.#store.transaction(() => {
+    return this.#store.transactionAsync(async () => {
       for (const hash of txHashes) {
         const key = hash.toString();
-        void this.#minedTxHashToBlock.set(key, blockNumber);
+        await this.#minedTxHashToBlock.set(key, blockNumber);
 
-        const tx = this.getTxByHash(hash);
+        const tx = await this.getTxByHash(hash);
         if (tx) {
           deletedPending++;
           const fee = getPendingTxPriority(tx);
-          void this.#pendingTxPriorityToHash.deleteValue(fee, key);
+          await this.#pendingTxPriorityToHash.deleteValue(fee, key);
         }
       }
       this.#metrics.recordAddedObjects(txHashes.length, 'mined');
@@ -98,14 +99,14 @@ export class AztecKVTxPool implements TxPool {
     }
 
     let markedAsPending = 0;
-    return this.#store.transaction(() => {
+    return this.#store.transactionAsync(async () => {
       for (const hash of txHashes) {
         const key = hash.toString();
-        void this.#minedTxHashToBlock.delete(key);
+        await this.#minedTxHashToBlock.delete(key);
 
-        const tx = this.getTxByHash(hash);
+        const tx = await this.getTxByHash(hash);
         if (tx) {
-          void this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
+          await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
           markedAsPending++;
         }
       }
@@ -115,22 +116,23 @@ export class AztecKVTxPool implements TxPool {
     });
   }
 
-  public getPendingTxHashes(): TxHash[] {
-    return Array.from(this.#pendingTxPriorityToHash.values({ reverse: true })).map(x => TxHash.fromString(x));
+  public async getPendingTxHashes(): Promise<TxHash[]> {
+    const vals = await toArray(this.#pendingTxPriorityToHash.valuesAsync({ reverse: true }));
+    return vals.map(x => TxHash.fromString(x));
   }
 
-  public getMinedTxHashes(): [TxHash, number][] {
-    return Array.from(this.#minedTxHashToBlock.entries()).map(([txHash, blockNumber]) => [
-      TxHash.fromString(txHash),
-      blockNumber,
-    ]);
+  public async getMinedTxHashes(): Promise<[TxHash, number][]> {
+    const vals = await toArray(this.#minedTxHashToBlock.entriesAsync());
+    return vals.map(([txHash, blockNumber]) => [TxHash.fromString(txHash), blockNumber]);
   }
 
-  public getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined {
+  public async getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
     const key = txHash.toString();
-    if (this.#minedTxHashToBlock.has(key)) {
+    const [isMined, isKnown] = await Promise.all([this.#minedTxHashToBlock.hasAsync(key), this.#txs.hasAsync(key)]);
+
+    if (isMined) {
       return 'mined';
-    } else if (this.#txs.has(key)) {
+    } else if (isKnown) {
       return 'pending';
     } else {
       return undefined;
@@ -142,8 +144,8 @@ export class AztecKVTxPool implements TxPool {
    * @param txHash - The generated tx hash.
    * @returns The transaction, if found, 'undefined' otherwise.
    */
-  public getTxByHash(txHash: TxHash): Tx | undefined {
-    const buffer = this.#txs.get(txHash.toString());
+  public async getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
+    const buffer = await this.#txs.getAsync(txHash.toString());
     if (buffer) {
       const tx = Tx.fromBuffer(buffer);
       tx.setTxHash(txHash);
@@ -157,8 +159,8 @@ export class AztecKVTxPool implements TxPool {
    * @param txHash - The tx hash.
    * @returns The transaction metadata, if found, 'undefined' otherwise.
    */
-  public getArchivedTxByHash(txHash: TxHash): Tx | undefined {
-    const buffer = this.#archivedTxs.get(txHash.toString());
+  public async getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined> {
+    const buffer = await this.#archivedTxs.getAsync(txHash.toString());
     if (buffer) {
       const tx = Tx.fromBuffer(buffer);
       tx.setTxHash(txHash);
@@ -172,26 +174,31 @@ export class AztecKVTxPool implements TxPool {
    * @param txs - An array of txs to be added to the pool.
    * @returns Empty promise.
    */
-  public addTxs(txs: Tx[]): Promise<void> {
-    return this.#store.transaction(() => {
+  public async addTxs(txs: Tx[]): Promise<void> {
+    const hashesAndStats = await Promise.all(
+      txs.map(async tx => ({ txHash: await tx.getTxHash(), txStats: await tx.getStats() })),
+    );
+    await this.#store.transactionAsync(async () => {
       let pendingCount = 0;
-      for (const tx of txs) {
-        const txHash = tx.getTxHash();
-        this.#log.verbose(`Adding tx ${txHash.toString()} to pool`, {
-          eventName: 'tx-added-to-pool',
-          ...tx.getStats(),
-        } satisfies TxAddedToPoolStats);
-
-        const key = txHash.toString();
-        void this.#txs.set(key, tx.toBuffer());
-
-        if (!this.#minedTxHashToBlock.has(key)) {
-          pendingCount++;
-          // REFACTOR: Use an lmdb conditional write to avoid race conditions with this write tx
-          void this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
-          this.#metrics.recordSize(tx);
-        }
-      }
+      await Promise.all(
+        txs.map(async (tx, i) => {
+          const { txHash, txStats } = hashesAndStats[i];
+          this.#log.verbose(`Adding tx ${txHash.toString()} to pool`, {
+            eventName: 'tx-added-to-pool',
+            ...txStats,
+          } satisfies TxAddedToPoolStats);
+
+          const key = txHash.toString();
+          await this.#txs.set(key, tx.toBuffer());
+
+          if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
+            pendingCount++;
+            // REFACTOR: Use an lmdb conditional write to avoid race conditions with this write tx
+            await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
+            this.#metrics.recordSize(tx);
+          }
+        }),
+      );
 
       this.#metrics.recordAddedObjects(pendingCount, 'pending');
     });
@@ -207,16 +214,16 @@ export class AztecKVTxPool implements TxPool {
     let minedDeleted = 0;
 
     const deletedTxs: Tx[] = [];
-    const poolDbTx = this.#store.transaction(() => {
+    const poolDbTx = this.#store.transactionAsync(async () => {
       for (const hash of txHashes) {
         const key = hash.toString();
-        const tx = this.getTxByHash(hash);
+        const tx = await this.getTxByHash(hash);
 
         if (tx) {
           const fee = getPendingTxPriority(tx);
-          void this.#pendingTxPriorityToHash.deleteValue(fee, key);
+          await this.#pendingTxPriorityToHash.deleteValue(fee, key);
 
-          const isMined = this.#minedTxHashToBlock.has(key);
+          const isMined = await this.#minedTxHashToBlock.hasAsync(key);
           if (isMined) {
             minedDeleted++;
           } else {
@@ -227,8 +234,8 @@ export class AztecKVTxPool implements TxPool {
             deletedTxs.push(tx);
           }
 
-          void this.#txs.delete(key);
-          void this.#minedTxHashToBlock.delete(key);
+          await this.#txs.delete(key);
+          await this.#minedTxHashToBlock.delete(key);
         }
       }
 
@@ -243,8 +250,9 @@ export class AztecKVTxPool 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.entries()).map(([hash, buffer]) => {
+  public async getAllTxs(): Promise<Tx[]> {
+    const vals = await toArray(this.#txs.entriesAsync());
+    return vals.map(([hash, buffer]) => {
       const tx = Tx.fromBuffer(buffer);
       tx.setTxHash(TxHash.fromString(hash));
       return tx;
@@ -255,8 +263,9 @@ export class AztecKVTxPool implements TxPool {
    * 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.fromString(x));
+  public async getAllTxHashes(): Promise<TxHash[]> {
+    const vals = await toArray(this.#txs.keysAsync());
+    return vals.map(x => TxHash.fromString(x));
   }
 
   /**
@@ -264,18 +273,21 @@ export class AztecKVTxPool implements TxPool {
    * @param txs - The list of transactions to archive.
    * @returns Empty promise.
    */
-  private archiveTxs(txs: Tx[]): Promise<void> {
-    return this.#archive.transaction(() => {
+  private async archiveTxs(txs: Tx[]): Promise<void> {
+    const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    await this.#archive.transactionAsync(async () => {
       // calcualte the head and tail indices of the archived txs by insertion order.
-      let headIdx = (this.#archivedTxIndices.entries({ limit: 1, reverse: true }).next().value?.[0] ?? -1) + 1;
-      let tailIdx = this.#archivedTxIndices.entries({ limit: 1 }).next().value?.[0] ?? 0;
+      let headIdx =
+        ((await this.#archivedTxIndices.entriesAsync({ limit: 1, reverse: true }).next()).value?.[0] ?? -1) + 1;
+      let tailIdx = (await this.#archivedTxIndices.entriesAsync({ limit: 1 }).next()).value?.[0] ?? 0;
 
-      for (const tx of txs) {
+      for (let i = 0; i < txs.length; i++) {
+        const tx = txs[i];
         while (headIdx - tailIdx >= this.#archivedTxLimit) {
-          const txHash = this.#archivedTxIndices.get(tailIdx);
+          const txHash = await this.#archivedTxIndices.getAsync(tailIdx);
           if (txHash) {
-            void this.#archivedTxs.delete(txHash);
-            void this.#archivedTxIndices.delete(tailIdx);
+            await this.#archivedTxs.delete(txHash);
+            await this.#archivedTxIndices.delete(tailIdx);
           }
           tailIdx++;
         }
@@ -283,14 +295,13 @@ export class AztecKVTxPool implements TxPool {
         const archivedTx: Tx = new Tx(
           tx.data,
           ClientIvcProof.empty(),
-          tx.unencryptedLogs,
           tx.contractClassLogs,
           tx.enqueuedPublicFunctionCalls,
           tx.publicTeardownFunctionCall,
         );
-        const txHash = tx.getTxHash().toString();
-        void this.#archivedTxs.set(txHash, archivedTx.toBuffer());
-        void this.#archivedTxIndices.set(headIdx, txHash);
+        const txHash = txHashes[i].toString();
+        await this.#archivedTxs.set(txHash, archivedTx.toBuffer());
+        await this.#archivedTxIndices.set(headIdx, txHash);
         headIdx++;
       }
     });

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())));
   });
 }