@aztec/p2p 0.72.1 → 0.74.0

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -1,7 +1,8 @@
 import { BlockAttestation } from '@aztec/circuit-types';
 import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMapWithSize, type AztecMultiMap } from '@aztec/kv-store';
+import { type AztecAsyncKVStore, type AztecAsyncMap, type AztecAsyncMultiMap } from '@aztec/kv-store';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { PoolInstrumentation, PoolName } from '../instrumentation.js';
@@ -10,144 +11,149 @@ import { type AttestationPool } from './attestation_pool.js';
 export class KvAttestationPool implements AttestationPool {
   private metrics: PoolInstrumentation<BlockAttestation>;
 
-  // Index of all proposal ids in a slot
-  private attestations: AztecMultiMap<string, string>;
+  private attestations: AztecAsyncMap<string, Buffer>;
+  private proposalsForSlot: AztecAsyncMultiMap<string, string>;
+  private attestationsForProposal: AztecAsyncMultiMap<string, string>;
 
   constructor(
-    private store: AztecKVStore,
+    private store: AztecAsyncKVStore,
     telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('aztec:attestation_pool'),
   ) {
-    this.attestations = store.openMultiMap('attestations');
+    this.attestations = store.openMap('attestations');
+    this.proposalsForSlot = store.openMultiMap('proposals_for_slot');
+    this.attestationsForProposal = store.openMultiMap('attestations_for_proposal');
+
     this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
   }
 
-  private getProposalMapKey(slot: string, proposalId: string): string {
-    return `proposal-${slot}-${proposalId}`;
+  private getProposalKey(slot: number | bigint | Fr | string, proposalId: Fr | string | Buffer): string {
+    const slotStr = typeof slot === 'string' ? slot : new Fr(slot).toString();
+    const proposalIdStr =
+      typeof proposalId === 'string'
+        ? proposalId
+        : Buffer.isBuffer(proposalId)
+        ? Fr.fromBuffer(proposalId).toString()
+        : proposalId.toString();
+
+    return `${slotStr}-${proposalIdStr}`;
   }
 
-  /**
-   * Get the proposal map for a given slot and proposalId
-   *
-   * Essentially a nested mapping of address -> attestation
-   *
-   * @param slot - The slot to get the proposal map for
-   * @param proposalId - The proposalId to get the map for
-   * @returns The proposal map
-   */
-  private getProposalMap(slot: string, proposalId: string): AztecMapWithSize<string, Buffer> {
-    const mapKey = this.getProposalMapKey(slot, proposalId);
-    return this.store.openMapWithSize(mapKey);
+  private getAttestationKey(slot: number | bigint | Fr | string, proposalId: Fr | string, address: string): string {
+    return `${this.getProposalKey(slot, proposalId)}-${address}`;
   }
 
   public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
-    for (const attestation of attestations) {
-      const slotNumber = attestation.payload.header.globalVariables.slotNumber.toString();
-      const proposalId = attestation.archive.toString();
-      const address = attestation.getSender().toString();
+    await this.store.transactionAsync(async () => {
+      for (const attestation of attestations) {
+        const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+        const proposalId = attestation.archive;
+        const address = (await attestation.getSender()).toString();
 
-      // Index the proposalId in the slot map
-      await this.attestations.set(slotNumber, proposalId);
+        await this.attestations.set(this.getAttestationKey(slotNumber, proposalId, address), attestation.toBuffer());
 
-      // Store the actual attestation in the proposal map
-      const proposalMap = this.getProposalMap(slotNumber, proposalId);
-      await proposalMap.set(address, attestation.toBuffer());
+        await this.proposalsForSlot.set(slotNumber.toString(), proposalId.toString());
+        await this.attestationsForProposal.set(
+          this.getProposalKey(slotNumber, proposalId),
+          this.getAttestationKey(slotNumber, proposalId, address),
+        );
 
-      this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
-    }
+        this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
+      }
+    });
 
     this.metrics.recordAddedObjects(attestations.length);
   }
 
-  public getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
-    const slotNumber = new Fr(slot).toString();
-    const proposalMap = this.getProposalMap(slotNumber, proposalId);
-    const attestations = proposalMap.values();
-    const attestationsArray = Array.from(attestations).map(attestation => BlockAttestation.fromBuffer(attestation));
-    return Promise.resolve(attestationsArray);
-  }
+  public async getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
+    const attestationIds = await toArray(
+      this.attestationsForProposal.getValuesAsync(this.getProposalKey(slot, proposalId)),
+    );
+    const attestations: BlockAttestation[] = [];
 
-  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
-    const olderThan = [];
+    // alternatively iterate this.attestaions starting from slot-proposal-EthAddress.zero
+    for (const id of attestationIds) {
+      const buf = await this.attestations.getAsync(id);
 
-    const slots = this.attestations.keys();
-    for (const slot of slots) {
-      if (BigInt(slot) < oldestSlot) {
-        olderThan.push(slot);
+      if (!buf) {
+        // this should not happen unless we lost writes
+        throw new Error('Attestation not found ' + id);
       }
+
+      const attestation = BlockAttestation.fromBuffer(buf);
+      attestations.push(attestation);
     }
 
-    await Promise.all(olderThan.map(oldSlot => this.deleteAttestationsForSlot(BigInt(oldSlot))));
-    return Promise.resolve();
+    return attestations;
   }
 
-  public async deleteAttestationsForSlot(slot: bigint): Promise<void> {
-    const deletionPromises = [];
+  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
+    const olderThan = await toArray(this.proposalsForSlot.keysAsync({ end: new Fr(oldestSlot).toString() }));
+    for (const oldSlot of olderThan) {
+      await this.deleteAttestationsForSlot(BigInt(oldSlot));
+    }
+  }
 
-    const slotString = new Fr(slot).toString();
+  public async deleteAttestationsForSlot(slot: bigint): Promise<void> {
+    const slotFr = new Fr(slot);
     let numberOfAttestations = 0;
-    const proposalIds = this.attestations.getValues(slotString);
-
-    if (proposalIds) {
+    await this.store.transactionAsync(async () => {
+      const proposalIds = await toArray(this.proposalsForSlot.getValuesAsync(slotFr.toString()));
       for (const proposalId of proposalIds) {
-        const proposalMap = this.getProposalMap(slotString, proposalId);
-        numberOfAttestations += proposalMap.size();
-        deletionPromises.push(proposalMap.clear());
-      }
-    }
+        const attestations = await toArray(
+          this.attestationsForProposal.getValuesAsync(this.getProposalKey(slotFr, proposalId)),
+        );
 
-    await Promise.all(deletionPromises);
+        numberOfAttestations += attestations.length;
+        for (const attestation of attestations) {
+          await this.attestations.delete(attestation);
+        }
+
+        await this.attestationsForProposal.delete(this.getProposalKey(slotFr, proposalId));
+      }
+    });
 
     this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
     this.metrics.recordRemovedObjects(numberOfAttestations);
-    return Promise.resolve();
   }
 
   public async deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
-    const deletionPromises = [];
-
-    const slotString = new Fr(slot).toString();
-    const exists = this.attestations.get(slotString);
-
-    if (exists) {
-      // Remove the proposalId from the slot index
-      deletionPromises.push(this.attestations.deleteValue(slotString, proposalId));
-
-      // Delete all attestations for the proposalId
-      const proposalMap = this.getProposalMap(slotString, proposalId);
-      const numberOfAttestations = proposalMap.size();
-      deletionPromises.push(proposalMap.clear());
+    let numberOfAttestations = 0;
+    await this.store.transactionAsync(async () => {
+      const slotString = new Fr(slot).toString();
+      const attestations = await toArray(
+        this.attestationsForProposal.getValuesAsync(this.getProposalKey(slot, proposalId)),
+      );
+
+      numberOfAttestations += attestations.length;
+      for (const attestation of attestations) {
+        await this.attestations.delete(attestation);
+      }
 
-      this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
-      this.metrics.recordRemovedObjects(numberOfAttestations);
-    }
+      await this.proposalsForSlot.deleteValue(slotString, proposalId);
+      await this.attestationsForProposal.delete(this.getProposalKey(slotString, proposalId));
+    });
 
-    await Promise.all(deletionPromises);
-    return Promise.resolve();
+    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
+    this.metrics.recordRemovedObjects(numberOfAttestations);
   }
 
   public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
-    const deletionPromises = [];
-
-    for (const attestation of attestations) {
-      const slotNumber = attestation.payload.header.globalVariables.slotNumber.toString();
-      const proposalId = attestation.archive.toString();
-      const proposalMap = this.getProposalMap(slotNumber, proposalId);
+    await this.store.transactionAsync(async () => {
+      for (const attestation of attestations) {
+        const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+        const proposalId = attestation.archive;
+        const address = (await attestation.getSender()).toString();
+
+        await this.attestations.delete(this.getAttestationKey(slotNumber, proposalId, address));
+        await this.attestationsForProposal.deleteValue(
+          this.getProposalKey(slotNumber, proposalId),
+          this.getAttestationKey(slotNumber, proposalId, address),
+        );
 
-      if (proposalMap) {
-        const address = attestation.getSender().toString();
-        deletionPromises.push(proposalMap.delete(address));
         this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
       }
-
-      if (proposalMap.size() === 0) {
-        deletionPromises.push(this.attestations.deleteValue(slotNumber, proposalId));
-      }
-    }
-
-    await Promise.all(deletionPromises);
-
+    });
     this.metrics.recordRemovedObjects(attestations.length);
-    return Promise.resolve();
   }
 }

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -26,13 +26,13 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve([]);
   }
 
-  public addAttestations(attestations: BlockAttestation[]): Promise<void> {
+  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
       // Perf: order and group by slot before insertion
       const slotNumber = attestation.payload.header.globalVariables.slotNumber;
 
       const proposalId = attestation.archive.toString();
-      const address = attestation.getSender();
+      const address = await attestation.getSender();
 
       const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
       const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
@@ -105,7 +105,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  public deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
+  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
       const slotNumber = attestation.payload.header.globalVariables.slotNumber;
       const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
@@ -113,7 +113,7 @@ export class InMemoryAttestationPool implements AttestationPool {
         const proposalId = attestation.archive.toString();
         const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
         if (proposalAttestationMap) {
-          const address = attestation.getSender();
+          const address = await attestation.getSender();
           proposalAttestationMap.delete(address.toString());
           this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
         }

package/src/mem_pools/attestation_pool/mocks.ts

@@ -27,17 +27,17 @@ export const generateAccount = (): LocalAccount => {
  * @param slot The slot number the attestation is for
  * @returns A Block Attestation
  */
-export const mockAttestation = (
+export const mockAttestation = async (
   signer: Secp256k1Signer,
   slot: number = 0,
   archive: Fr = Fr.random(),
   txs: TxHash[] = [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
-): BlockAttestation => {
+): Promise<BlockAttestation> => {
   // Use arbitrary numbers for all other than slot
   const header = makeHeader(1, 2, slot);
   const payload = new ConsensusPayload(header, archive, txs);
 
-  const hash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const hash = await getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
   const signature = signer.sign(hash);
 
   return new BlockAttestation(payload, signature);

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++;
         }
@@ -287,9 +299,9 @@ export class AztecKVTxPool implements TxPool {
           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++;
       }
     });