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

package/src/mem_pools/tx_pool/eviction/eviction_manager.ts

@@ -0,0 +1,71 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+
+import type { TxPoolOptions } from '../tx_pool.js';
+import { type EvictionContext, EvictionEvent, type EvictionRule, type TxPoolOperations } from './eviction_strategy.js';
+
+export class EvictionManager {
+  private rules: EvictionRule[] = [];
+
+  constructor(
+    private txPool: TxPoolOperations,
+    private log = createLogger('p2p:mempool:tx_pool:eviction_manager'),
+  ) {}
+
+  public async evictAfterNewTxs(newTxs: TxHash[]): Promise<void> {
+    const ctx: EvictionContext = {
+      event: EvictionEvent.TXS_ADDED,
+      newTxs,
+    };
+    await this.runEvictionRules(ctx);
+  }
+
+  public async evictAfterNewBlock(
+    block: BlockHeader,
+    newNullifiers: Fr[],
+    minedFeePayers: AztecAddress[],
+  ): Promise<void> {
+    const ctx: EvictionContext = {
+      event: EvictionEvent.BLOCK_MINED,
+      block,
+      newNullifiers,
+      minedFeePayers,
+    };
+
+    await this.runEvictionRules(ctx);
+  }
+
+  public async evictAfterChainPrune(blockNumber: number): Promise<void> {
+    const ctx: EvictionContext = {
+      event: EvictionEvent.CHAIN_PRUNED,
+      blockNumber,
+    };
+    await this.runEvictionRules(ctx);
+  }
+
+  public registerRule(rule: EvictionRule) {
+    this.rules.push(rule);
+  }
+
+  public updateConfig(config: TxPoolOptions): void {
+    for (const rule of this.rules) {
+      rule.updateConfig(config);
+    }
+  }
+
+  private async runEvictionRules(ctx: EvictionContext): Promise<void> {
+    for (const rule of this.rules) {
+      try {
+        await rule.evict(ctx, this.txPool);
+      } catch (err) {
+        this.log.warn(`Eviction rule ${rule.name} unexpected error: ${String(err)}`, {
+          err,
+          evictionRule: rule.name,
+          evictionEvent: ctx.event,
+        });
+      }
+    }
+  }
+}

package/src/mem_pools/tx_pool/eviction/eviction_strategy.ts

@@ -0,0 +1,93 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { TxPoolOptions } from '../tx_pool.js';
+
+export const EvictionEvent = {
+  TXS_ADDED: 'txs_added',
+  BLOCK_MINED: 'block_mined',
+  CHAIN_PRUNED: 'chain_pruned',
+} as const;
+
+type EvictionEvent = (typeof EvictionEvent)[keyof typeof EvictionEvent];
+
+export type EvictionContext =
+  | {
+      event: typeof EvictionEvent.TXS_ADDED;
+      newTxs: TxHash[];
+    }
+  | {
+      event: typeof EvictionEvent.CHAIN_PRUNED;
+      blockNumber: number;
+    }
+  | {
+      event: typeof EvictionEvent.BLOCK_MINED;
+      block: BlockHeader;
+      newNullifiers: Fr[];
+      minedFeePayers: AztecAddress[];
+    };
+
+/**
+ * Result of an eviction operation
+ */
+export interface EvictionResult {
+  readonly txsEvicted: TxHash[];
+  readonly reason: string;
+  readonly success: boolean;
+  readonly error?: Error;
+}
+
+/**
+ * Information about a pending transaction
+ */
+export interface PendingTxInfo {
+  txHash: TxHash;
+  blockHash: Fr;
+  isEvictable: boolean;
+}
+
+/**
+ * Information about a transaction that references a specific block
+ */
+export interface TxBlockReference {
+  txHash: TxHash;
+  blockHash: Fr;
+  isEvictable: boolean;
+}
+
+/**
+ * Operations that eviction strategies can perform on the pool
+ */
+export interface TxPoolOperations {
+  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+  getPendingTxInfos(): Promise<PendingTxInfo[]>;
+  getPendingTxsReferencingBlocks(blockHashes: Fr[]): Promise<TxBlockReference[]>;
+  getPendingTxsWithFeePayer(feePayer: AztecAddress[]): Promise<PendingTxInfo[]>;
+  /** Cheap count of current pending transactions. */
+  getPendingTxCount(): Promise<number>;
+  /**
+   * Returns up to `limit` lowest-priority evictable pending tx hashes.
+   * Ordering should be from lowest priority upwards.
+   */
+  getLowestPriorityEvictable(limit: number): Promise<TxHash[]>;
+  deleteTxs(txHashes: TxHash[], opts?: { permanently?: boolean }): Promise<void>;
+}
+
+/**
+ * Strategy interface for different eviction behaviors
+ */
+export interface EvictionRule {
+  readonly name: string;
+
+  /**
+   * Performs the eviction logic
+   */
+  evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult>;
+
+  /**
+   * Updates the configuration for this eviction rule.
+   * Rules should ignore config options that don't apply to them.
+   */
+  updateConfig(config: TxPoolOptions): void;
+}

package/src/mem_pools/tx_pool/eviction/insufficient_fee_payer_balance_rule.ts

@@ -0,0 +1,108 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { GasFees } from '@aztec/stdlib/gas';
+import type { ReadonlyWorldStateAccess } from '@aztec/stdlib/interfaces/server';
+import { DatabasePublicStateSource, type MerkleTreeReadOperations } from '@aztec/stdlib/trees';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import { GasTxValidator } from '../../../msg_validators/index.js';
+import type { TxPoolOptions } from '../tx_pool.js';
+import {
+  type EvictionContext,
+  EvictionEvent,
+  type EvictionResult,
+  type EvictionRule,
+  type PendingTxInfo,
+  type TxPoolOperations,
+} from './eviction_strategy.js';
+
+export class InsufficientFeePayerBalanceRule implements EvictionRule {
+  public readonly name = 'InsufficientFeePayerBalance';
+  public readonly reason = 'insufficient_fee_juice';
+
+  public constructor(private worldState: ReadonlyWorldStateAccess) {}
+
+  private log = createLogger('p2p:mempool:tx_pool:insufficient_fee_payer_balance_rule');
+
+  async evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult> {
+    try {
+      if (context.event === EvictionEvent.CHAIN_PRUNED) {
+        const affectedTxs = await txPool.getPendingTxInfos();
+        return this.evictTxs(affectedTxs, context.blockNumber, txPool);
+      }
+
+      if (context.event === EvictionEvent.BLOCK_MINED) {
+        const affectedTxs = await txPool.getPendingTxsWithFeePayer(context.minedFeePayers);
+
+        // TODO: fix this edge-case
+        // This can lead to a race condition if we are catching up in the p2p client.
+        // Let's say we have 3 txs for the same fee payer, which get mined in blocks 1, 2, 3.
+        // Tx1 consumes fee juice, tx2 increases it, tx3 consumes it again. We see block1 with tx1 first, run this rule, and evict tx3.
+        // But tx3 was valid (due to tx2) and mined on block3. And we have just removed from the mempool a tx we needed for proving/reexec.
+        // -----
+        // Proposed fix: evict only if node is synched
+        return this.evictTxs(affectedTxs, context.block.getBlockNumber(), txPool);
+      }
+
+      return {
+        reason: this.reason,
+        success: true,
+        txsEvicted: [],
+      };
+    } catch (err) {
+      this.log.error('Failed to evict invalid transactions after mining', { err });
+      return {
+        reason: this.reason,
+        success: false,
+        txsEvicted: [],
+        error: new Error('Failed to evict invalid txs after mining', { cause: err }),
+      };
+    }
+  }
+
+  private async evictTxs(
+    candidateTxs: PendingTxInfo[],
+    blockNumber: number,
+    txPool: TxPoolOperations,
+  ): Promise<EvictionResult> {
+    const txsToEvict: TxHash[] = [];
+    const gasValidator = this.createGasTxValidator(this.worldState.getSnapshot(blockNumber));
+
+    for (const { txHash, isEvictable } of candidateTxs) {
+      if (!isEvictable) {
+        continue;
+      }
+
+      const tx = await txPool.getTxByHash(txHash);
+      if (!tx) {
+        continue;
+      }
+
+      this.log.debug(`Validating tx balance ${txHash}`);
+
+      if ((await gasValidator.validateTxFee(tx)).result === 'invalid') {
+        this.log.verbose(`Evicting tx ${txHash} from pool due to an insufficient fee payer balance`);
+        txsToEvict.push(txHash);
+        continue;
+      }
+    }
+
+    if (txsToEvict.length > 0) {
+      await txPool.deleteTxs(txsToEvict);
+    }
+
+    this.log.verbose(`Evicted ${txsToEvict.length} invalid txs after block mined`, { txsToEvict });
+
+    return {
+      reason: this.reason,
+      success: true,
+      txsEvicted: txsToEvict,
+    };
+  }
+
+  private createGasTxValidator(db: MerkleTreeReadOperations): GasTxValidator {
+    return new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, GasFees.empty());
+  }
+
+  updateConfig(_config: TxPoolOptions): void {}
+}

package/src/mem_pools/tx_pool/eviction/invalid_txs_after_mining_rule.ts

@@ -0,0 +1,104 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import type { TxPoolOptions } from '../tx_pool.js';
+import {
+  type EvictionContext,
+  EvictionEvent,
+  type EvictionResult,
+  type EvictionRule,
+  type TxPoolOperations,
+} from './eviction_strategy.js';
+
+/**
+ * Eviction rule that removes invalid transactions after a block is mined.
+ * Only triggers on BLOCK_MINED events.
+ *
+ * Eviction criteria includes:
+ * - Transactions with nullifiers that are already included in the mined block
+ * - Transactions with an expiration timestamp less than or equal to the mined block timestamp
+ */
+export class InvalidTxsAfterMiningRule implements EvictionRule {
+  public readonly name = 'InvalidTxsAfterMining';
+
+  private log = createLogger('p2p:mempool:tx_pool:invalid_txs_after_mining_rule');
+
+  async evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult> {
+    if (context.event !== EvictionEvent.BLOCK_MINED) {
+      return {
+        reason: 'block_mined_invalid_txs',
+        success: true,
+        txsEvicted: [],
+      };
+    }
+
+    if (!context.block || !context.newNullifiers) {
+      this.log.warn('Invalid context for block mined eviction', { context });
+      return {
+        reason: 'block_mined_invalid_txs',
+        success: false,
+        txsEvicted: [],
+        error: new Error('Invalid block mined context'),
+      };
+    }
+
+    try {
+      const { timestamp } = context.block.globalVariables;
+
+      const txsToEvict: TxHash[] = [];
+      const pendingTxs = await txPool.getPendingTxInfos();
+      const minedNullifiers = new Set(context.newNullifiers.map(n => n.toString()));
+
+      for (const { txHash, isEvictable } of pendingTxs) {
+        if (!isEvictable) {
+          continue;
+        }
+
+        const tx = await txPool.getTxByHash(txHash);
+        if (!tx) {
+          continue;
+        }
+
+        // Evict pending txs that share nullifiers with mined txs
+        const txNullifiers = tx.data.getNonEmptyNullifiers();
+        if (txNullifiers.some(nullifier => minedNullifiers.has(nullifier.toString()))) {
+          this.log.verbose(`Evicting tx ${txHash} from pool due to a duplicate nullifier with a mined tx`);
+          txsToEvict.push(txHash);
+          continue;
+        }
+
+        // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
+        const includeByTimestamp = tx.data.includeByTimestamp;
+        if (includeByTimestamp <= timestamp) {
+          this.log.verbose(
+            `Evicting tx ${txHash} from pool due to the tx being expired (includeByTimestamp: ${includeByTimestamp}, mined block timestamp: ${timestamp})`,
+          );
+          txsToEvict.push(txHash);
+          continue;
+        }
+      }
+
+      if (txsToEvict.length > 0) {
+        await txPool.deleteTxs(txsToEvict);
+      }
+
+      this.log.debug(`Evicted ${txsToEvict.length} invalid txs after block mined`);
+
+      return {
+        reason: 'block_mined_invalid_txs',
+        success: true,
+        txsEvicted: txsToEvict,
+      };
+    } catch (err) {
+      this.log.error('Failed to evict invalid transactions after mining', { err });
+      return {
+        reason: 'block_mined_invalid_txs',
+        success: false,
+        txsEvicted: [],
+        error: new Error('Failed to evict invalid txs after mining', { cause: err }),
+      };
+    }
+  }
+
+  updateConfig(_config: TxPoolOptions): void {}
+}

package/src/mem_pools/tx_pool/eviction/invalid_txs_after_reorg_rule.ts

@@ -0,0 +1,91 @@
+import { findIndexInSortedArray, insertIntoSortedArray } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import type { ReadonlyWorldStateAccess } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import type { TxPoolOptions } from '../tx_pool.js';
+import {
+  type EvictionContext,
+  EvictionEvent,
+  type EvictionResult,
+  type EvictionRule,
+  type TxPoolOperations,
+} from './eviction_strategy.js';
+
+/**
+ * Eviction rule that removes invalid transactions after a blockchain reorganization.
+ * Only triggers on CHAIN_PRUNED events.
+ *
+ * Eviction criteria includes:
+ * - Transactions that reference pruned block hashes (invalid by definition)
+ */
+export class InvalidTxsAfterReorgRule implements EvictionRule {
+  public readonly name = 'InvalidTxsAfterReorg';
+
+  private log = createLogger('p2p:mempool:tx_pool:invalid_txs_after_reorg_rule');
+
+  public constructor(private worldState: ReadonlyWorldStateAccess) {}
+
+  async evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult> {
+    if (context.event !== EvictionEvent.CHAIN_PRUNED) {
+      return {
+        reason: 'reorg_invalid_txs',
+        success: true,
+        txsEvicted: [],
+      };
+    }
+
+    try {
+      const candidateTxs = (await txPool.getPendingTxInfos()).filter(({ isEvictable }) => isEvictable);
+
+      // Deduplicate block hashes to reduce redundant DB lookups (many txs may share the same blockHash).
+      const uniqueBlockHashes: Fr[] = [];
+      candidateTxs.forEach(({ blockHash }) => {
+        insertIntoSortedArray(uniqueBlockHashes, blockHash, Fr.cmp, false);
+      });
+
+      const db = this.worldState.getSnapshot(context.blockNumber);
+      const blocksFromDb = await db.findLeafIndices(MerkleTreeId.ARCHIVE, uniqueBlockHashes);
+
+      // Identify txs whose blockHash is not found in the archive (pruned)
+      const txsToEvict: TxHash[] = [];
+      for (const tx of candidateTxs) {
+        const idx = findIndexInSortedArray(uniqueBlockHashes, tx.blockHash, Fr.cmp);
+        const blockPruned = idx === -1 || blocksFromDb[idx] === undefined;
+        if (blockPruned) {
+          txsToEvict.push(tx.txHash);
+        }
+      }
+
+      if (txsToEvict.length > 0) {
+        this.log.verbose(`Evicting ${txsToEvict.length} txs from pool due to referencing pruned blocks`);
+        await txPool.deleteTxs(txsToEvict);
+      }
+
+      const keptCount = candidateTxs.length - txsToEvict.length;
+      if (keptCount > 0) {
+        this.log.verbose(`Kept ${keptCount} txs that did not reference pruned blocks`);
+      }
+
+      this.log.debug(`Evicted ${txsToEvict.length} invalid txs after reorg`);
+
+      return {
+        reason: 'reorg_invalid_txs',
+        success: true,
+        txsEvicted: txsToEvict,
+      };
+    } catch (err) {
+      this.log.error('Failed to evict invalid transactions after reorg', { err });
+      return {
+        reason: 'reorg_invalid_txs',
+        success: false,
+        txsEvicted: [],
+        error: new Error('Failed to evict invalid txs after reorg', { cause: err }),
+      };
+    }
+  }
+
+  updateConfig(_config: TxPoolOptions): void {}
+}

package/src/mem_pools/tx_pool/eviction/low_priority_eviction_rule.ts

@@ -0,0 +1,106 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import type { TxPoolOptions } from '../tx_pool.js';
+import {
+  type EvictionContext,
+  EvictionEvent,
+  type EvictionResult,
+  type EvictionRule,
+  type TxPoolOperations,
+} from './eviction_strategy.js';
+
+export interface LowPriorityEvictionConfig {
+  /** Maximum number of pending transactions before eviction kicks in */
+  maxPoolSize: number;
+}
+
+/**
+ * Eviction rule that removes low-priority transactions when the number of pending transactions exceeds configured limits.
+ * Only triggers on TXS_ADDED events and respects non-evictable transactions.
+ */
+export class LowPriorityEvictionRule implements EvictionRule {
+  public readonly name = 'LowPriorityEviction';
+
+  private log = createLogger('p2p:mempool:tx_pool:low_priority_eviction_rule');
+
+  constructor(private config: LowPriorityEvictionConfig) {}
+
+  public async evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult> {
+    if (context.event !== EvictionEvent.TXS_ADDED) {
+      return {
+        reason: 'low_priority',
+        success: true,
+        txsEvicted: [],
+      };
+    }
+
+    if (this.config.maxPoolSize === 0) {
+      return {
+        reason: 'low_priority',
+        success: true,
+        txsEvicted: [],
+      };
+    }
+
+    try {
+      const currentTxCount = await txPool.getPendingTxCount();
+      const maxCount = this.config.maxPoolSize;
+
+      if (currentTxCount <= maxCount) {
+        this.log.trace(`Not evicting low priority txs. Pending tx count below limit ${currentTxCount} <= ${maxCount}`);
+        return {
+          reason: 'low_priority',
+          success: true,
+          txsEvicted: [],
+        };
+      }
+
+      this.log.verbose(`Evicting low priority txs. Pending tx count above limit: ${currentTxCount} > ${maxCount}`);
+      const numberToEvict = currentTxCount - maxCount;
+      const txsToEvict: TxHash[] = await txPool.getLowestPriorityEvictable(numberToEvict);
+
+      if (txsToEvict.length > 0) {
+        await txPool.deleteTxs(txsToEvict);
+      }
+
+      const numNewTxsEvicted = context.newTxs.filter(newTxHash =>
+        txsToEvict.some(evictedTx => evictedTx.equals(newTxHash)),
+      ).length;
+
+      this.log.verbose(`Evicted ${txsToEvict.length} low priority txs, including ${numNewTxsEvicted} newly added txs`, {
+        txsEvicted: txsToEvict,
+      });
+
+      return {
+        reason: 'low_priority',
+        success: true,
+        txsEvicted: txsToEvict,
+      };
+    } catch (err) {
+      this.log.error('Failed to evict low priority transactions', { err });
+      return {
+        reason: 'low_priority',
+        success: false,
+        txsEvicted: [],
+        error: new Error('Failed to evict low priority txs', { cause: err }),
+      };
+    }
+  }
+
+  /**
+   * Updates the configuration for this eviction rule
+   */
+  updateConfig(config: TxPoolOptions): void {
+    if (config.maxPendingTxCount !== undefined) {
+      this.config.maxPoolSize = config.maxPendingTxCount;
+    }
+  }
+
+  /**
+   * Gets the current configuration
+   */
+  getConfig(): LowPriorityEvictionConfig {
+    return { ...this.config };
+  }
+}

package/src/mem_pools/tx_pool/index.ts

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

package/src/mem_pools/tx_pool/priority.ts

@@ -7,7 +7,14 @@ import type { Tx } from '@aztec/stdlib/tx';
  * We currently use the sum of the priority fees for the tx for this value, represented as hex.
  */
 export function getPendingTxPriority(tx: Tx): string {
+  return Buffer32.fromBigInt(getTxPriorityFee(tx)).toString();
+}
+
+/**
+ * Returns the priority of a tx.
+ */
+export function getTxPriorityFee(tx: Tx): bigint {
   const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
   const totalFees = priorityFees.feePerDaGas + priorityFees.feePerL2Gas;
-  return Buffer32.fromBigInt(totalFees).toString();
+  return totalFees;
 }

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -3,8 +3,7 @@ import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
 export type TxPoolOptions = {
-  maxTxPoolSize?: number;
-  txPoolOverflowFactor?: number;
+  maxPendingTxCount?: number;
   archivedTxLimit?: number;
 };
 
@@ -69,8 +68,9 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    * 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.
+   * @param latestBlock - The block number the chain was pruned to.
    */
-  markMinedAsPending(txHashes: TxHash[]): Promise<void>;
+  markMinedAsPending(txHashes: TxHash[], latestBlock: BlockNumber): Promise<void>;
 
   /**
    * Deletes transactions from the pool. Tx hashes that are not present are ignored.
@@ -127,6 +127,11 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    */
   markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
 
+  /**
+   * Clears collection of non-evictable transactions in the pool
+   */
+  clearNonEvictableTxs(): 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.