@aztec/p2p 0.46.7 → 0.47.0

package/src/tx_pool/aztec_kv_tx_pool.ts

@@ -1,7 +1,7 @@
 import { Tx, TxHash } from '@aztec/circuit-types';
 import { type TxAddedToPoolStats } from '@aztec/circuit-types/stats';
 import { type Logger, createDebugLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
+import { type AztecKVStore, type AztecMap, type AztecSet } from '@aztec/kv-store';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import { TxPoolInstrumentation } from './instrumentation.js';
@@ -13,11 +13,14 @@ import { type TxPool } from './tx_pool.js';
 export class AztecKVTxPool implements TxPool {
   #store: AztecKVStore;
 
-  /**
-   * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
-   */
+  /** Our tx pool, stored as a Map, with K: tx hash and V: the transaction. */
   #txs: AztecMap<string, Buffer>;
 
+  /** Index for pending txs. */
+  #pendingTxs: AztecSet<string>;
+  /** Index for mined txs. */
+  #minedTxs: AztecSet<string>;
+
   #log: Logger;
 
   #metrics: TxPoolInstrumentation;
@@ -29,11 +32,43 @@ export class AztecKVTxPool implements TxPool {
    */
   constructor(store: AztecKVStore, telemetry: TelemetryClient, log = createDebugLogger('aztec:tx_pool')) {
     this.#txs = store.openMap('txs');
+    this.#minedTxs = store.openSet('minedTxs');
+    this.#pendingTxs = store.openSet('pendingTxs');
+
     this.#store = store;
     this.#log = log;
     this.#metrics = new TxPoolInstrumentation(telemetry, 'AztecKVTxPool');
   }
 
+  public markAsMined(txHashes: TxHash[]): Promise<void> {
+    return this.#store.transaction(() => {
+      for (const hash of txHashes) {
+        const key = hash.toString();
+        void this.#minedTxs.add(key);
+        void this.#pendingTxs.delete(key);
+      }
+    });
+  }
+
+  public getPendingTxHashes(): TxHash[] {
+    return Array.from(this.#pendingTxs.entries()).map(x => TxHash.fromString(x));
+  }
+
+  public getMinedTxHashes(): TxHash[] {
+    return Array.from(this.#minedTxs.entries()).map(x => TxHash.fromString(x));
+  }
+
+  public getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined {
+    const key = txHash.toString();
+    if (this.#pendingTxs.has(key)) {
+      return 'pending';
+    } else if (this.#minedTxs.has(key)) {
+      return 'mined';
+    } else {
+      return undefined;
+    }
+  }
+
   /**
    * Checks if a transaction exists in the pool and returns it.
    * @param txHash - The generated tx hash.
@@ -59,7 +94,12 @@ export class AztecKVTxPool implements TxPool {
           ...tx.getStats(),
         } satisfies TxAddedToPoolStats);
 
-        void this.#txs.set(txHash.toString(), tx.toBuffer());
+        const key = txHash.toString();
+        void this.#txs.set(key, tx.toBuffer());
+        if (!this.#minedTxs.has(key)) {
+          // REFACTOR: Use an lmdb conditional write to avoid race conditions with this write tx
+          void this.#pendingTxs.add(key);
+        }
       }
 
       this.#metrics.recordTxs(txs);
@@ -74,7 +114,10 @@ export class AztecKVTxPool implements TxPool {
   public deleteTxs(txHashes: TxHash[]): Promise<void> {
     return this.#store.transaction(() => {
       for (const hash of txHashes) {
-        void this.#txs.delete(hash.toString());
+        const key = hash.toString();
+        void this.#txs.delete(key);
+        void this.#pendingTxs.delete(key);
+        void this.#minedTxs.delete(key);
       }
 
       this.#metrics.removeTxs(txHashes.length);
@@ -96,13 +139,4 @@ export class AztecKVTxPool implements TxPool {
   public getAllTxHashes(): TxHash[] {
     return Array.from(this.#txs.keys()).map(x => TxHash.fromString(x));
   }
-
-  /**
-   * Returns a boolean indicating if the transaction is present in the pool.
-   * @param txHash - The hash of the transaction to be queried.
-   * @returns True if the transaction present, false otherwise.
-   */
-  public hasTx(txHash: TxHash): boolean {
-    return this.#txs.has(txHash.toString());
-  }
 }

package/src/tx_pool/memory_tx_pool.ts

@@ -14,6 +14,8 @@ export class InMemoryTxPool implements TxPool {
    * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
    */
   private txs: Map<bigint, Tx>;
+  private minedTxs: Set<bigint>;
+  private pendingTxs: Set<bigint>;
 
   private metrics: TxPoolInstrumentation;
 
@@ -23,9 +25,39 @@ export class InMemoryTxPool implements TxPool {
    */
   constructor(telemetry: TelemetryClient, private log = createDebugLogger('aztec:tx_pool')) {
     this.txs = new Map<bigint, Tx>();
+    this.minedTxs = new Set();
+    this.pendingTxs = new Set();
     this.metrics = new TxPoolInstrumentation(telemetry, 'InMemoryTxPool');
   }
 
+  public markAsMined(txHashes: TxHash[]): Promise<void> {
+    const keys = txHashes.map(x => x.toBigInt());
+    for (const key of keys) {
+      this.minedTxs.add(key);
+      this.pendingTxs.delete(key);
+    }
+    return Promise.resolve();
+  }
+
+  public getPendingTxHashes(): TxHash[] {
+    return Array.from(this.pendingTxs).map(x => TxHash.fromBigInt(x));
+  }
+
+  public getMinedTxHashes(): TxHash[] {
+    return Array.from(this.minedTxs).map(x => TxHash.fromBigInt(x));
+  }
+
+  public getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined {
+    const key = txHash.toBigInt();
+    if (this.pendingTxs.has(key)) {
+      return 'pending';
+    }
+    if (this.minedTxs.has(key)) {
+      return 'mined';
+    }
+    return undefined;
+  }
+
   /**
    * Checks if a transaction exists in the pool and returns it.
    * @param txHash - The generated tx hash.
@@ -49,7 +81,12 @@ export class InMemoryTxPool implements TxPool {
         eventName: 'tx-added-to-pool',
         ...tx.getStats(),
       } satisfies TxAddedToPoolStats);
-      this.txs.set(txHash.toBigInt(), tx);
+
+      const key = txHash.toBigInt();
+      this.txs.set(key, tx);
+      if (!this.minedTxs.has(key)) {
+        this.pendingTxs.add(key);
+      }
     }
     return Promise.resolve();
   }
@@ -62,7 +99,10 @@ export class InMemoryTxPool implements TxPool {
   public deleteTxs(txHashes: TxHash[]): Promise<void> {
     this.metrics.removeTxs(txHashes.length);
     for (const txHash of txHashes) {
-      this.txs.delete(txHash.toBigInt());
+      const key = txHash.toBigInt();
+      this.txs.delete(key);
+      this.pendingTxs.delete(key);
+      this.minedTxs.delete(key);
     }
     return Promise.resolve();
   }
@@ -82,13 +122,4 @@ export class InMemoryTxPool implements TxPool {
   public getAllTxHashes(): TxHash[] {
     return Array.from(this.txs.keys()).map(x => TxHash.fromBigInt(x));
   }
-
-  /**
-   * Returns a boolean indicating if the transaction is present in the pool.
-   * @param txHash - The hash of the transaction to be queried.
-   * @returns True if the transaction present, false otherwise.
-   */
-  public hasTx(txHash: TxHash): boolean {
-    return this.txs.has(txHash.toBigInt());
-  }
 }

package/src/tx_pool/tx_pool.ts

@@ -17,6 +17,12 @@ export interface TxPool {
    */
   getTxByHash(txHash: TxHash): Tx | undefined;
 
+  /**
+   * Marks the set of txs as mined, as opposed to pending.
+   * @param txHashes - Hashes of the txs to flag as mined.
+   */
+  markAsMined(txHashes: TxHash[]): Promise<void>;
+
   /**
    * Deletes transactions from the pool. Tx hashes that are not present are ignored.
    * @param txHashes - An array of tx hashes to be removed from the tx pool.
@@ -36,9 +42,21 @@ export interface TxPool {
   getAllTxHashes(): TxHash[];
 
   /**
-   * Returns a boolean indicating if the transaction is present in the pool.
-   * @param txHash - The hash of the transaction to be queried.
-   * @returns True if the transaction present, false otherwise.
+   * Gets the hashes of pending transactions currently in the tx pool.
+   * @returns An array of pending transaction hashes found in the tx pool.
+   */
+  getPendingTxHashes(): 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(): TxHash[];
+
+  /**
+   * 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.
    */
-  hasTx(txHash: TxHash): boolean;
+  getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined;
 }

package/src/tx_pool/tx_pool_test_suite.ts

@@ -13,12 +13,14 @@ export function describeTxPool(getTxPool: () => TxPool) {
     pool = getTxPool();
   });
 
-  it('Adds txs to the pool', async () => {
+  it('Adds txs to the pool as pending', async () => {
     const tx1 = 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()]);
   });
 
   it('Removes txs from the pool', async () => {
@@ -27,8 +29,21 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1]);
     await pool.deleteTxs([tx1.getTxHash()]);
 
-    const poolTx = pool.getTxByHash(tx1.getTxHash());
-    expect(poolTx).toBeFalsy();
+    expect(pool.getTxByHash(tx1.getTxHash())).toBeFalsy();
+    expect(pool.getTxStatus(tx1.getTxHash())).toBeUndefined();
+  });
+
+  it('Marks txs as mined', async () => {
+    const tx1 = mockTx(1);
+    const tx2 = mockTx(2);
+
+    await pool.addTxs([tx1, tx2]);
+    await pool.markAsMined([tx1.getTxHash()]);
+
+    expect(pool.getTxByHash(tx1.getTxHash())).toEqual(tx1);
+    expect(pool.getTxStatus(tx1.getTxHash())).toEqual('mined');
+    expect(pool.getMinedTxHashes()).toEqual([tx1.getTxHash()]);
+    expect(pool.getPendingTxHashes()).toEqual([tx2.getTxHash()]);
   });
 
   it('Returns all transactions in the pool', async () => {