@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -1,22 +1,29 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import EventEmitter from 'node:events';
+
+import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
-import type { TxPool } from './tx_pool.js';
+import type { TxPool, TxPoolEvents, TxPoolOptions } from './tx_pool.js';
 
 /**
  * In-memory implementation of the Transaction Pool.
  */
-export class InMemoryTxPool implements TxPool {
+export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter<TxPoolEvents>) 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: Map<bigint, number>;
+  private minedTxs: Map<bigint, BlockNumber>;
   private pendingTxs: Set<bigint>;
+  private deletedMinedTxHashes: Map<bigint, BlockNumber>;
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  private blockToDeletedMinedTxHash: Map<BlockNumber, Set<bigint>>;
 
   private metrics: PoolInstrumentation<Tx>;
 
@@ -24,21 +31,52 @@ export class InMemoryTxPool implements TxPool {
    * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
    * @param log - A logger.
    */
-  constructor(telemetry: TelemetryClient = getTelemetryClient(), private log = createLogger('p2p:tx_pool')) {
+  constructor(
+    telemetry: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('p2p:tx_pool'),
+  ) {
+    super();
     this.txs = new Map<bigint, Tx>();
     this.minedTxs = new Map();
     this.pendingTxs = new Set();
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL);
+    this.deletedMinedTxHashes = new Map();
+    this.blockToDeletedMinedTxHash = new Map();
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, this.countTx);
+  }
+
+  private countTx: PoolStatsCallback = () => {
+    return Promise.resolve({
+      itemCount: {
+        mined: this.minedTxs.size,
+        pending: this.pendingTxs.size,
+      },
+    });
+  };
+
+  public isEmpty(): Promise<boolean> {
+    return Promise.resolve(this.txs.size === 0);
   }
 
-  public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
+  public markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void> {
     const keys = txHashes.map(x => x.toBigInt());
     for (const key of keys) {
-      this.minedTxs.set(key, blockNumber);
+      // If this tx was previously soft-deleted, remove it from the deleted sets
+      if (this.deletedMinedTxHashes.has(key)) {
+        const originalBlock = this.deletedMinedTxHashes.get(key)!;
+        this.deletedMinedTxHashes.delete(key);
+        // Remove from block-to-hash mapping
+        const txHashesForBlock = this.blockToDeletedMinedTxHash.get(originalBlock);
+        if (txHashesForBlock) {
+          txHashesForBlock.delete(key);
+          if (txHashesForBlock.size === 0) {
+            this.blockToDeletedMinedTxHash.delete(originalBlock);
+          }
+        }
+      }
+      this.minedTxs.set(key, blockHeader.globalVariables.blockNumber);
       this.pendingTxs.delete(key);
     }
-    this.metrics.recordRemovedObjects(txHashes.length, 'pending');
-    this.metrics.recordAddedObjects(txHashes.length, 'mined');
+    this.metrics.transactionsRemoved(txHashes);
     return Promise.resolve();
   }
 
@@ -48,23 +86,15 @@ export class InMemoryTxPool implements TxPool {
     }
 
     const keys = txHashes.map(x => x.toBigInt());
-    let deleted = 0;
-    let added = 0;
     for (const key of keys) {
-      if (this.minedTxs.delete(key)) {
-        deleted++;
-      }
+      this.minedTxs.delete(key);
 
       // only add back to the pending set if we have the tx object
       if (this.txs.has(key)) {
-        added++;
         this.pendingTxs.add(key);
       }
     }
 
-    this.metrics.recordRemovedObjects(deleted, 'mined');
-    this.metrics.recordAddedObjects(added, 'pending');
-
     return Promise.resolve();
   }
 
@@ -73,23 +103,37 @@ export class InMemoryTxPool implements TxPool {
       (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()));
+
+    // No need to check deleted since pending txs are never soft-deleted
+    return txHashes.filter(txHash => {
+      const key = txHash.toBigInt();
+      return this.pendingTxs.has(key);
+    });
   }
 
-  public getMinedTxHashes(): Promise<[TxHash, number][]> {
+  public getMinedTxHashes(): Promise<[TxHash, BlockNumber][]> {
     return Promise.resolve(
       Array.from(this.minedTxs.entries()).map(([txHash, blockNumber]) => [TxHash.fromBigInt(txHash), blockNumber]),
     );
   }
 
-  public getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
+  public getPendingTxCount(): Promise<number> {
+    // Soft-deleted transactions are always mined, never pending
+    return Promise.resolve(this.pendingTxs.size);
+  }
+
+  public getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined> {
     const key = txHash.toBigInt();
-    if (this.pendingTxs.has(key)) {
-      return Promise.resolve('pending');
+
+    if (this.deletedMinedTxHashes.has(key)) {
+      return Promise.resolve('deleted');
     }
     if (this.minedTxs.has(key)) {
       return Promise.resolve('mined');
     }
+    if (this.pendingTxs.has(key)) {
+      return Promise.resolve('pending');
+    }
     return Promise.resolve(undefined);
   }
 
@@ -103,6 +147,18 @@ export class InMemoryTxPool implements TxPool {
     return Promise.resolve(result === undefined ? undefined : Tx.clone(result));
   }
 
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return Promise.all(txHashes.map(txHash => this.getTxByHash(txHash)));
+  }
+  hasTxs(txHashes: TxHash[]): Promise<boolean[]> {
+    return Promise.resolve(txHashes.map(txHash => this.txs.has(txHash.toBigInt())));
+  }
+
+  async hasTx(txHash: TxHash): Promise<boolean> {
+    const result = await this.hasTxs([txHash]);
+    return result[0];
+  }
+
   public getArchivedTxByHash(): Promise<Tx | undefined> {
     return Promise.resolve(undefined);
   }
@@ -112,46 +168,65 @@ export class InMemoryTxPool implements TxPool {
    * @param txs - An array of txs to be added to the pool.
    * @returns Empty promise.
    */
-  public async addTxs(txs: Tx[]): Promise<void> {
-    let pending = 0;
+  public addTxs(txs: Tx[], opts: { source?: string } = {}): Promise<number> {
+    const added: Tx[] = [];
     for (const tx of txs) {
-      const txHash = await tx.getTxHash();
+      const txHash = tx.getTxHash();
       this.log.verbose(`Adding tx ${txHash.toString()} to pool`, {
         eventName: 'tx-added-to-pool',
-        ...(await tx.getStats()),
+        ...tx.getStats(),
       } satisfies TxAddedToPoolStats);
 
       const key = txHash.toBigInt();
-      this.txs.set(key, tx);
+      if (!this.txs.has(key)) {
+        added.push(tx as Tx);
+        this.txs.set(key, tx);
+      }
+
       if (!this.minedTxs.has(key)) {
-        pending++;
         this.metrics.recordSize(tx);
         this.pendingTxs.add(key);
       }
     }
-
-    this.metrics.recordAddedObjects(pending, 'pending');
-    return;
+    if (added.length > 0) {
+      this.emit('txs-added', { ...opts, txs: added });
+    }
+    this.metrics.transactionsAdded(added);
+    return Promise.resolve(added.length);
   }
 
   /**
    * 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.
-   * @returns The number of transactions that was deleted from the pool.
+   * Mined transactions are soft-deleted with a timestamp, pending transactions are permanently deleted.
+   * @param txHashes - An array of tx hashes to be deleted from the tx pool.
+   * @returns Empty promise.
    */
-  public deleteTxs(txHashes: TxHash[]): Promise<void> {
-    let deletedMined = 0;
-    let deletedPending = 0;
-
+  public deleteTxs(txHashes: TxHash[], opts?: { permanently?: boolean }): Promise<void> {
     for (const txHash of txHashes) {
       const key = txHash.toBigInt();
-      this.txs.delete(key);
-      deletedPending += this.pendingTxs.delete(key) ? 1 : 0;
-      deletedMined += this.minedTxs.delete(key) ? 1 : 0;
+      if (this.txs.has(key)) {
+        if (this.minedTxs.has(key)) {
+          const blockNumber = this.minedTxs.get(key)!;
+          this.minedTxs.delete(key);
+          // Soft-delete mined transactions: remove from mined set but keep in storage
+          if (opts?.permanently) {
+            // Permanently delete mined transactions if specified
+            this.txs.delete(key);
+          } else {
+            this.deletedMinedTxHashes.set(key, blockNumber);
+            if (!this.blockToDeletedMinedTxHash.has(blockNumber)) {
+              this.blockToDeletedMinedTxHash.set(blockNumber, new Set());
+            }
+            this.blockToDeletedMinedTxHash.get(blockNumber)!.add(key);
+          }
+        } else {
+          // Permanently delete pending transactions
+          this.txs.delete(key);
+          this.pendingTxs.delete(key);
+        }
+      }
     }
-
-    this.metrics.recordRemovedObjects(deletedPending, 'pending');
-    this.metrics.recordRemovedObjects(deletedMined, 'mined');
+    this.metrics.transactionsRemoved(txHashes);
 
     return Promise.resolve();
   }
@@ -171,4 +246,43 @@ export class InMemoryTxPool implements TxPool {
   public getAllTxHashes(): Promise<TxHash[]> {
     return Promise.resolve(Array.from(this.txs.keys()).map(x => TxHash.fromBigInt(x)));
   }
+
+  updateConfig(_config: TxPoolOptions): void {}
+
+  markTxsAsNonEvictable(_: TxHash[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /**
+   * Permanently deletes deleted mined transactions from blocks up to and including the specified block number.
+   * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
+   * @returns The number of transactions permanently deleted.
+   */
+  public cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number> {
+    let deletedCount = 0;
+    const blocksToDelete: BlockNumber[] = [];
+
+    // Find all blocks up to the specified block number
+    for (const [block, txHashes] of this.blockToDeletedMinedTxHash.entries()) {
+      if (block <= blockNumber) {
+        // Permanently delete all transactions from this block
+        for (const txHash of txHashes) {
+          this.txs.delete(txHash);
+          this.deletedMinedTxHashes.delete(txHash);
+          deletedCount++;
+        }
+        blocksToDelete.push(block);
+      }
+    }
+
+    // Clean up block-to-hash mapping
+    for (const block of blocksToDelete) {
+      this.blockToDeletedMinedTxHash.delete(block);
+    }
+
+    if (deletedCount > 0) {
+      this.log.debug(`Permanently deleted ${deletedCount} deleted mined txs from blocks up to ${blockNumber}`);
+    }
+    return Promise.resolve(deletedCount);
+  }
 }

package/src/mem_pools/tx_pool/priority.ts

@@ -8,6 +8,6 @@ import type { Tx } from '@aztec/stdlib/tx';
  */
 export function getPendingTxPriority(tx: Tx): string {
   const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
-  const totalFees = priorityFees.feePerDaGas.toBigInt() + priorityFees.feePerL2Gas.toBigInt();
+  const totalFees = priorityFees.feePerDaGas + priorityFees.feePerL2Gas;
   return Buffer32.fromBigInt(totalFees).toString();
 }

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,14 +1,27 @@
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+
+export type TxPoolOptions = {
+  maxTxPoolSize?: number;
+  txPoolOverflowFactor?: number;
+  archivedTxLimit?: number;
+};
+
+export type TxPoolEvents = {
+  ['txs-added']: (args: { txs: Tx[]; source?: string }) => void | Promise<void>;
+};
 
 /**
  * Interface of a transaction pool. The pool includes tx requests and is kept up-to-date by a P2P client.
  */
-export interface TxPool {
+export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
   /**
    * Adds a list of transactions to the pool. Duplicates are ignored.
    * @param txs - An array of txs to be added to the pool.
+   * @returns The number of txs added to the pool. Note if the transaction already exists, it will not be added again.
    */
-  addTxs(txs: Tx[]): Promise<void>;
+  addTxs(txs: Tx[], opts?: { source?: string }): Promise<number>;
 
   /**
    * Checks if a transaction exists in the pool and returns it.
@@ -17,6 +30,27 @@ export interface TxPool {
    */
   getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
 
+  /**
+   * Checks if transactions exist in the pool and returns them.
+   * @param txHashes - The hashes of the transactions
+   * @returns The transactions, if found, 'undefined' otherwise.
+   */
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+
+  /**
+   * Checks if transactions exist in the pool
+   * @param txHashes - The hashes of the transactions to check for
+   * @returns True or False for each tx hash
+   */
+  hasTxs(txHashes: TxHash[]): Promise<boolean[]>;
+
+  /**
+   * Checks if a transaction exists in the pool
+   * @param txHash - The hash of the transaction to check for
+   * @returns True if the transaction exists, false otherwise
+   */
+  hasTx(txHash: TxHash): Promise<boolean>;
+
   /**
    * Checks if an archived transaction exists in the pool and returns it.
    * @param txHash - The hash of the transaction, used as an ID.
@@ -27,8 +61,9 @@ export interface TxPool {
   /**
    * Marks the set of txs as mined, as opposed to pending.
    * @param txHashes - Hashes of the txs to flag as mined.
+   * @param blockHeader - The header of the mined block.
    */
-  markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void>;
+  markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void>;
 
   /**
    * Moves mined txs back to the pending set in the case of a reorg.
@@ -41,7 +76,7 @@ export interface TxPool {
    * 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.
    */
-  deleteTxs(txHashes: TxHash[]): Promise<void>;
+  deleteTxs(txHashes: TxHash[], opts?: { permanently?: boolean }): Promise<void>;
 
   /**
    * Gets all transactions currently in the tx pool.
@@ -61,16 +96,41 @@ export interface TxPool {
    */
   getPendingTxHashes(): Promise<TxHash[]>;
 
+  /** Returns the number of pending txs in the pool. */
+  getPendingTxCount(): Promise<number>;
+
   /**
    * Gets the hashes of mined transactions currently in the tx pool.
    * @returns An array of mined transaction hashes found in the tx pool.
    */
-  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: number][]>;
+  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: BlockNumber][]>;
 
   /**
-   * Returns whether the given tx hash is flagged as pending or mined.
+   * Returns whether the given tx hash is flagged as pending, mined, or deleted.
    * @param txHash - Hash of the tx to query.
-   * @returns Pending or mined depending on its status, or undefined if not found.
+   * @returns Pending, mined, or deleted depending on its status, or undefined if not found.
+   */
+  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined>;
+
+  /**
+   * Configure the maximum size of the tx pool
+   * @param maxSizeBytes - The maximum size in bytes of the mempool. Set to undefined to disable it
+   */
+  updateConfig(config: TxPoolOptions): void;
+
+  /** Returns whether the pool is empty. */
+  isEmpty(): Promise<boolean>;
+
+  /**
+   * Marks transactions as non-evictible in the pool.
+   * @param txHashes - Hashes of the transactions to mark as non-evictible.
+   */
+  markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
+
+  /**
+   * Permanently deletes deleted mined transactions from blocks up to and including the specified block number.
+   * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
+   * @returns The number of transactions permanently deleted.
    */
-  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined>;
+  cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number>;
 }