@aztec/p2p 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/src/mem_pools/tx_pool/index.ts

@@ -1,3 +0,0 @@
-export * from './tx_pool.js';
-export * from './memory_tx_pool.js';
-export * from './aztec_kv_tx_pool.js';

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -1,283 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import type { TypedEventEmitter } from '@aztec/foundation/types';
-import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
-import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import EventEmitter from 'node:events';
-
-import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
-import { getPendingTxPriority } from './priority.js';
-import type { TxPool, TxPoolEvents, TxPoolOptions } from './tx_pool.js';
-
-/**
- * In-memory implementation of the Transaction Pool.
- */
-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 pendingTxs: Set<bigint>;
-  private deletedMinedTxHashes: Map<bigint, number>;
-  private blockToDeletedMinedTxHash: Map<number, Set<bigint>>;
-
-  private metrics: PoolInstrumentation<Tx>;
-
-  /**
-   * 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'),
-  ) {
-    super();
-    this.txs = new Map<bigint, Tx>();
-    this.minedTxs = new Map();
-    this.pendingTxs = new Set();
-    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[], blockHeader: BlockHeader): Promise<void> {
-    const keys = txHashes.map(x => x.toBigInt());
-    for (const key of keys) {
-      // 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);
-    }
-    return Promise.resolve();
-  }
-
-  public markMinedAsPending(txHashes: TxHash[]): Promise<void> {
-    if (txHashes.length === 0) {
-      return Promise.resolve();
-    }
-
-    const keys = txHashes.map(x => x.toBigInt());
-    for (const key of keys) {
-      this.minedTxs.delete(key);
-
-      // only add back to the pending set if we have the tx object
-      if (this.txs.has(key)) {
-        this.pendingTxs.add(key);
-      }
-    }
-
-    return Promise.resolve();
-  }
-
-  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()));
-
-    // 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][]> {
-    return Promise.resolve(
-      Array.from(this.minedTxs.entries()).map(([txHash, blockNumber]) => [TxHash.fromBigInt(txHash), blockNumber]),
-    );
-  }
-
-  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.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);
-  }
-
-  /**
-   * Checks if a transaction exists in the pool and returns it.
-   * @param txHash - The generated tx hash.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */
-  public getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
-    const result = this.txs.get(txHash.toBigInt());
-    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);
-  }
-
-  /**
-   * Adds a list of transactions to the pool. Duplicates are ignored.
-   * @param txs - An array of txs to be added to the pool.
-   * @returns Empty promise.
-   */
-  public addTxs(txs: Tx[], opts: { source?: string } = {}): Promise<number> {
-    const added: Tx[] = [];
-    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.toBigInt();
-      if (!this.txs.has(key)) {
-        added.push(tx as Tx);
-        this.txs.set(key, tx);
-      }
-
-      if (!this.minedTxs.has(key)) {
-        this.metrics.recordSize(tx);
-        this.pendingTxs.add(key);
-      }
-    }
-    if (added.length > 0) {
-      this.emit('txs-added', { ...opts, txs: added });
-    }
-    return Promise.resolve(added.length);
-  }
-
-  /**
-   * Deletes transactions from the pool. Tx hashes that are not present are ignored.
-   * 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[], opts?: { permanently?: boolean }): Promise<void> {
-    for (const txHash of txHashes) {
-      const key = txHash.toBigInt();
-      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);
-        }
-      }
-    }
-
-    return Promise.resolve();
-  }
-
-  /**
-   * Gets all the transactions stored in the pool.
-   * @returns Array of tx objects in the order they were added to the pool.
-   */
-  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(): 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: number): Promise<number> {
-    let deletedCount = 0;
-    const blocksToDelete: number[] = [];
-
-    // 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

@@ -1,13 +0,0 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
-import type { Tx } from '@aztec/stdlib/tx';
-
-/**
- * Returns a string representing the priority of a tx.
- * Txs with a higher priority value are returned first when retrieving pending tx hashes.
- * We currently use the sum of the priority fees for the tx for this value, represented as hex.
- */
-export function getPendingTxPriority(tx: Tx): string {
-  const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
-  const totalFees = priorityFees.feePerDaGas + priorityFees.feePerL2Gas;
-  return Buffer32.fromBigInt(totalFees).toString();
-}

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,135 +0,0 @@
-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 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[], opts?: { source?: string }): Promise<number>;
-
-  /**
-   * Checks if a 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.
-   */
-  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.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */
-  getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-
-  /**
-   * 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[], blockHeader: BlockHeader): Promise<void>;
-
-  /**
-   * Moves mined txs back to the pending set in the case of a reorg.
-   * Note: txs not known by this peer will be ignored.
-   * @param txHashes - Hashes of the txs to flag as pending.
-   */
-  markMinedAsPending(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.
-   */
-  deleteTxs(txHashes: TxHash[], opts?: { permanently?: boolean }): Promise<void>;
-
-  /**
-   * Gets all transactions currently in the tx pool.
-   * @returns An array of transaction objects found in the tx pool.
-   */
-  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(): 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(): 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][]>;
-
-  /**
-   * Returns whether the given tx hash is flagged as pending, mined, or deleted.
-   * @param txHash - Hash of the tx to query.
-   * @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.
-   */
-  cleanupDeletedMinedTxs(blockNumber: number): Promise<number>;
-}