@aztec/p2p 3.0.0-rc.5 → 4.0.0-nightly.20260107

package/dest/mem_pools/tx_pool/memory_tx_pool.js

@@ -1,239 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import EventEmitter from 'node:events';
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
-import { getPendingTxPriority } from './priority.js';
-/**
- * In-memory implementation of the Transaction Pool.
- */ export class InMemoryTxPool extends EventEmitter {
-    log;
-    /**
-   * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
-   */ txs;
-    minedTxs;
-    pendingTxs;
-    deletedMinedTxHashes;
-    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-    blockToDeletedMinedTxHash;
-    metrics;
-    /**
-   * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
-   * @param log - A logger.
-   */ constructor(telemetry = getTelemetryClient(), log = createLogger('p2p:tx_pool')){
-        super(), this.log = log, this.countTx = ()=>{
-            return Promise.resolve({
-                itemCount: {
-                    mined: this.minedTxs.size,
-                    pending: this.pendingTxs.size
-                }
-            });
-        };
-        this.txs = new Map();
-        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);
-    }
-    countTx;
-    isEmpty() {
-        return Promise.resolve(this.txs.size === 0);
-    }
-    markAsMined(txHashes, blockHeader) {
-        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();
-    }
-    markMinedAsPending(txHashes) {
-        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();
-    }
-    async getPendingTxHashes() {
-        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);
-        });
-    }
-    getMinedTxHashes() {
-        return Promise.resolve(Array.from(this.minedTxs.entries()).map(([txHash, blockNumber])=>[
-                TxHash.fromBigInt(txHash),
-                blockNumber
-            ]));
-    }
-    getPendingTxCount() {
-        // Soft-deleted transactions are always mined, never pending
-        return Promise.resolve(this.pendingTxs.size);
-    }
-    getTxStatus(txHash) {
-        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.
-   */ getTxByHash(txHash) {
-        const result = this.txs.get(txHash.toBigInt());
-        return Promise.resolve(result === undefined ? undefined : Tx.clone(result));
-    }
-    getTxsByHash(txHashes) {
-        return Promise.all(txHashes.map((txHash)=>this.getTxByHash(txHash)));
-    }
-    hasTxs(txHashes) {
-        return Promise.resolve(txHashes.map((txHash)=>this.txs.has(txHash.toBigInt())));
-    }
-    async hasTx(txHash) {
-        const result = await this.hasTxs([
-            txHash
-        ]);
-        return result[0];
-    }
-    getArchivedTxByHash() {
-        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.
-   */ addTxs(txs, opts = {}) {
-        const added = [];
-        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()
-            });
-            const key = txHash.toBigInt();
-            if (!this.txs.has(key)) {
-                added.push(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.
-   */ deleteTxs(txHashes, opts) {
-        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.
-   */ getAllTxs() {
-        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.
-   */ getAllTxHashes() {
-        return Promise.resolve(Array.from(this.txs.keys()).map((x)=>TxHash.fromBigInt(x)));
-    }
-    updateConfig(_config) {}
-    markTxsAsNonEvictable(_) {
-        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.
-   */ cleanupDeletedMinedTxs(blockNumber) {
-        let deletedCount = 0;
-        const blocksToDelete = [];
-        // 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/memory_tx_pool.ts

@@ -1,285 +0,0 @@
-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 { 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, 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>;
-
-  /**
-   * 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, BlockNumber][]> {
-    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: 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);
-  }
-}