@aztec/p2p 0.0.1-commit.e3c1de76 → 0.0.1-commit.e558bd1c

package/src/mem_pools/tx_pool_v2/eviction/fee_payer_balance_pre_add_rule.ts

@@ -0,0 +1,111 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import { type TxMetaData, comparePriority } from '../tx_metadata.js';
+import type { PreAddPoolAccess, PreAddResult, PreAddRule } from './interfaces.js';
+
+/**
+ * Pre-add rule that checks if a fee payer has sufficient balance to cover the incoming transaction.
+ *
+ * When an incoming tx is added:
+ * - Get the fee payer's on-chain balance
+ * - Get all existing pending txs for this fee payer
+ * - Insert incoming tx in priority order
+ * - Walk through in priority order, tracking running balance
+ * - If incoming tx can be covered: accept, mark lower-priority txs for eviction if needed
+ * - If incoming tx cannot be covered: ignore it
+ */
+export class FeePayerBalancePreAddRule implements PreAddRule {
+  public readonly name = 'FeePayerBalancePreAdd';
+
+  private log = createLogger('p2p:tx_pool_v2:fee_payer_balance_pre_add_rule');
+
+  async check(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess): Promise<PreAddResult> {
+    // Get fee payer's on-chain balance
+    const initialBalance = await poolAccess.getFeePayerBalance(incomingMeta.feePayer);
+
+    // Get existing pending txs for this fee payer
+    const existingTxs = poolAccess.getFeePayerPendingTxs(incomingMeta.feePayer);
+
+    // Create combined list with incoming tx
+    const allTxs: Array<{
+      txHash: string;
+      priorityFee: bigint;
+      feeLimit: bigint;
+      claimAmount: bigint;
+      isIncoming: boolean;
+    }> = [
+      ...existingTxs.map(t => ({
+        txHash: t.txHash,
+        priorityFee: t.priorityFee,
+        feeLimit: t.feeLimit,
+        claimAmount: t.claimAmount,
+        isIncoming: false,
+      })),
+      {
+        txHash: incomingMeta.txHash,
+        priorityFee: incomingMeta.priorityFee,
+        feeLimit: incomingMeta.feeLimit,
+        claimAmount: incomingMeta.claimAmount,
+        isIncoming: true,
+      },
+    ];
+
+    // Sort by priority descending (highest first), with hash as tiebreaker
+    allTxs.sort((a, b) => comparePriority(b, a));
+
+    // Walk through in priority order, tracking balance
+    let balance = initialBalance;
+    let incomingTxCovered = false;
+    const txsToEvict: string[] = [];
+
+    for (const txInfo of allTxs) {
+      const available = balance + txInfo.claimAmount;
+
+      if (available >= txInfo.feeLimit) {
+        // This tx can be covered
+        balance = available - txInfo.feeLimit;
+        if (txInfo.isIncoming) {
+          incomingTxCovered = true;
+        }
+      } else {
+        // This tx cannot be covered
+        if (txInfo.isIncoming) {
+          // Incoming tx cannot be covered - ignore it
+          this.log.debug(
+            `Ignoring tx ${incomingMeta.txHash}: fee payer ${incomingMeta.feePayer} has insufficient balance`,
+            { balance: initialBalance, feeLimit: incomingMeta.feeLimit, claimAmount: incomingMeta.claimAmount },
+          );
+          return {
+            shouldIgnore: true,
+            txHashesToEvict: [],
+            reason: `fee payer ${incomingMeta.feePayer} has insufficient balance`,
+          };
+        } else {
+          // Existing tx cannot be covered after adding incoming - mark for eviction
+          txsToEvict.push(txInfo.txHash);
+        }
+      }
+    }
+
+    if (!incomingTxCovered) {
+      // This shouldn't happen if the logic above is correct, but just in case
+      this.log.warn(`Incoming tx ${incomingMeta.txHash} was not covered but also not ignored - this is a bug`);
+      return {
+        shouldIgnore: true,
+        txHashesToEvict: [],
+        reason: 'internal error: tx coverage not determined',
+      };
+    }
+
+    if (txsToEvict.length > 0) {
+      this.log.debug(
+        `Accepting tx ${incomingMeta.txHash}, evicting ${txsToEvict.length} lower-priority txs due to fee payer balance`,
+      );
+    }
+
+    return {
+      shouldIgnore: false,
+      txHashesToEvict: txsToEvict,
+    };
+  }
+}

package/src/mem_pools/tx_pool_v2/eviction/index.ts

@@ -0,0 +1,23 @@
+export { EvictionManager } from './eviction_manager.js';
+export {
+  type EvictionConfig,
+  type EvictionContext,
+  EvictionEvent,
+  type EvictionResult,
+  type EvictionRule,
+  type PoolOperations,
+  type PreAddPoolAccess,
+  type PreAddResult,
+  type PreAddRule,
+} from './interfaces.js';
+
+// Pre-add rules
+export { NullifierConflictRule } from './nullifier_conflict_rule.js';
+export { FeePayerBalancePreAddRule } from './fee_payer_balance_pre_add_rule.js';
+export { LowPriorityPreAddRule } from './low_priority_pre_add_rule.js';
+
+// Post-event eviction rules
+export { InvalidTxsAfterMiningRule } from './invalid_txs_after_mining_rule.js';
+export { InvalidTxsAfterReorgRule } from './invalid_txs_after_reorg_rule.js';
+export { FeePayerBalanceEvictionRule } from './fee_payer_balance_eviction_rule.js';
+export { LowPriorityEvictionRule } from './low_priority_eviction_rule.js';

package/src/mem_pools/tx_pool_v2/eviction/interfaces.ts

@@ -0,0 +1,164 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+
+import type { TxMetaData } from '../tx_metadata.js';
+
+/**
+ * Events that trigger eviction checks.
+ */
+export const EvictionEvent = {
+  TXS_ADDED: 'txs_added',
+  BLOCK_MINED: 'block_mined',
+  CHAIN_PRUNED: 'chain_pruned',
+} as const;
+
+export type EvictionEventType = (typeof EvictionEvent)[keyof typeof EvictionEvent];
+
+/**
+ * Context passed to eviction rules based on the triggering event.
+ */
+export type EvictionContext =
+  | {
+      event: typeof EvictionEvent.TXS_ADDED;
+      newTxHashes: string[];
+      feePayers: string[];
+    }
+  | {
+      event: typeof EvictionEvent.CHAIN_PRUNED;
+      blockNumber: BlockNumber;
+    }
+  | {
+      event: typeof EvictionEvent.BLOCK_MINED;
+      block: BlockHeader;
+      newNullifiers: string[];
+      feePayers: string[];
+    };
+
+/**
+ * Result of an eviction operation.
+ */
+export interface EvictionResult {
+  readonly txsEvicted: string[];
+  readonly reason: string;
+  readonly success: boolean;
+  readonly error?: Error;
+}
+
+/**
+ * Read-only access to pool state for pre-add checks.
+ */
+export interface PreAddPoolAccess {
+  /** Get metadata for a pending tx by its hash string */
+  getMetadata(txHashStr: string): TxMetaData | undefined;
+
+  /** Get the pending tx hash that uses a specific nullifier (as string) */
+  getTxHashByNullifier(nullifier: string): string | undefined;
+
+  /** Get on-chain balance for a fee payer address */
+  getFeePayerBalance(feePayer: string): Promise<bigint>;
+
+  /** Get metadata for all pending txs from a specific fee payer */
+  getFeePayerPendingTxs(feePayer: string): TxMetaData[];
+
+  /** Get current count of pending transactions */
+  getPendingTxCount(): number;
+
+  /** Get the lowest priority pending tx metadata */
+  getLowestPriorityPendingTx(): TxMetaData | undefined;
+}
+
+/**
+ * Result of a pre-add check for a single transaction.
+ */
+export interface PreAddResult {
+  /** Whether the incoming tx should be ignored (valid but not desired) */
+  readonly shouldIgnore: boolean;
+  /** Tx hashes (as strings) that should be evicted if this tx is added */
+  readonly txHashesToEvict: string[];
+  /** Optional reason for ignoring */
+  readonly reason?: string;
+}
+
+/**
+ * Pre-add rule interface. Rules check incoming txs before they're added to the pool.
+ * All methods work with TxMetaData for efficiency.
+ */
+export interface PreAddRule {
+  readonly name: string;
+
+  /**
+   * Check if incoming tx should be added and which existing txs to evict.
+   * @param incomingMeta - Metadata for the incoming transaction
+   * @param poolAccess - Read-only access to current pool state
+   * @returns Result indicating whether to ignore and what to evict
+   */
+  check(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess): Promise<PreAddResult>;
+
+  /**
+   * Updates the configuration for this rule.
+   */
+  updateConfig?(config: EvictionConfig): void;
+}
+
+/**
+ * Operations that post-event eviction rules can perform on the pool.
+ * All methods work with metadata and strings for efficiency.
+ */
+export interface PoolOperations {
+  /** Get all pending tx metadata */
+  getPendingTxs(): TxMetaData[];
+
+  /** Get unique fee payers from pending transactions */
+  getPendingFeePayers(): string[];
+
+  /** Get metadata for all pending txs from a specific fee payer */
+  getFeePayerPendingTxs(feePayer: string): TxMetaData[];
+
+  /** Get current count of pending transactions */
+  getPendingTxCount(): number;
+
+  /** Get the N lowest priority pending tx hashes */
+  getLowestPriorityPending(limit: number): string[];
+
+  /** Delete transactions by hash */
+  deleteTxs(txHashes: string[]): Promise<void>;
+}
+
+/**
+ * Post-event eviction rule interface. Rules run after events to clean up the pool.
+ */
+export interface EvictionRule {
+  readonly name: string;
+
+  /**
+   * Performs the eviction logic after an event.
+   */
+  evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult>;
+
+  /**
+   * Updates the configuration for this rule.
+   */
+  updateConfig?(config: EvictionConfig): void;
+}
+
+/**
+ * Configuration options for eviction rules.
+ */
+export interface EvictionConfig {
+  /** Maximum number of pending transactions (0 = unlimited) */
+  maxPendingTxCount?: number;
+}
+
+/**
+ * Converts a TxHash to its string representation for use in eviction results.
+ */
+export function txHashToString(txHash: TxHash): string {
+  return txHash.toString();
+}
+
+/**
+ * Converts an array of TxHash to string array.
+ */
+export function txHashesToStrings(txHashes: TxHash[]): string[] {
+  return txHashes.map(h => h.toString());
+}

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

@@ -0,0 +1,74 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import type { EvictionContext, EvictionResult, EvictionRule, PoolOperations } from './interfaces.js';
+import { EvictionEvent } from './interfaces.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:tx_pool_v2:invalid_txs_after_mining_rule');
+
+  async evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult> {
+    if (context.event !== EvictionEvent.BLOCK_MINED) {
+      return {
+        reason: 'block_mined_invalid_txs',
+        success: true,
+        txsEvicted: [],
+      };
+    }
+
+    try {
+      const { timestamp } = context.block.globalVariables;
+      const minedNullifiers = new Set(context.newNullifiers);
+
+      const txsToEvict: string[] = [];
+      const pendingTxs = pool.getPendingTxs();
+
+      for (const meta of pendingTxs) {
+        // Evict pending txs that share nullifiers with mined txs
+        if (meta.nullifiers.some(nullifier => minedNullifiers.has(nullifier))) {
+          this.log.verbose(`Evicting tx ${meta.txHash} from pool due to a duplicate nullifier with a mined tx`);
+          txsToEvict.push(meta.txHash);
+          continue;
+        }
+
+        // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
+        if (meta.includeByTimestamp <= timestamp) {
+          this.log.verbose(
+            `Evicting tx ${meta.txHash} from pool due to the tx being expired (includeByTimestamp: ${meta.includeByTimestamp}, mined block timestamp: ${timestamp})`,
+          );
+          txsToEvict.push(meta.txHash);
+          continue;
+        }
+      }
+
+      if (txsToEvict.length > 0) {
+        await pool.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 }),
+      };
+    }
+  }
+}

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

@@ -0,0 +1,101 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+
+import type { EvictionContext, EvictionResult, EvictionRule, PoolOperations } from './interfaces.js';
+import { EvictionEvent } from './interfaces.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:tx_pool_v2:invalid_txs_after_reorg_rule');
+
+  constructor(private worldState: WorldStateSynchronizer) {}
+
+  async evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult> {
+    if (context.event !== EvictionEvent.CHAIN_PRUNED) {
+      return {
+        reason: 'reorg_invalid_txs',
+        success: true,
+        txsEvicted: [],
+      };
+    }
+
+    try {
+      const pendingTxs = pool.getPendingTxs();
+
+      // Deduplicate block hashes to reduce redundant DB lookups
+      const uniqueBlockHashes = new Map<string, Fr>();
+      const txsByBlockHash = new Map<string, string[]>();
+
+      for (const meta of pendingTxs) {
+        const blockHashStr = meta.anchorBlockHeaderHash;
+        if (!txsByBlockHash.has(blockHashStr)) {
+          txsByBlockHash.set(blockHashStr, []);
+          uniqueBlockHashes.set(blockHashStr, Fr.fromHexString(blockHashStr));
+        }
+        txsByBlockHash.get(blockHashStr)!.push(meta.txHash);
+      }
+
+      // Ensure world state is synced to this block before accessing the snapshot
+      await this.worldState.syncImmediate(context.blockNumber);
+      const db = this.worldState.getSnapshot(context.blockNumber);
+
+      // Check which blocks exist in the archive
+      const blockHashArray = Array.from(uniqueBlockHashes.values());
+      const blocksFromDb = await db.findLeafIndices(MerkleTreeId.ARCHIVE, blockHashArray);
+
+      // Build set of pruned block hashes
+      const prunedBlockHashes = new Set<string>();
+      let i = 0;
+      for (const [blockHashStr] of uniqueBlockHashes) {
+        if (blocksFromDb[i] === undefined) {
+          prunedBlockHashes.add(blockHashStr);
+        }
+        i++;
+      }
+
+      // Identify txs whose anchor block was pruned
+      const txsToEvict: string[] = [];
+      for (const [blockHashStr, txHashes] of txsByBlockHash) {
+        if (prunedBlockHashes.has(blockHashStr)) {
+          txsToEvict.push(...txHashes);
+        }
+      }
+
+      if (txsToEvict.length > 0) {
+        this.log.verbose(`Evicting ${txsToEvict.length} txs from pool due to referencing pruned blocks`);
+        await pool.deleteTxs(txsToEvict);
+      }
+
+      const keptCount = pendingTxs.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 }),
+      };
+    }
+  }
+}

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

@@ -0,0 +1,86 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import type { EvictionConfig, EvictionContext, EvictionResult, EvictionRule, PoolOperations } from './interfaces.js';
+import { EvictionEvent } from './interfaces.js';
+
+/**
+ * Eviction rule that removes low-priority transactions when the pool exceeds configured limits.
+ * Only triggers on TXS_ADDED events.
+ */
+export class LowPriorityEvictionRule implements EvictionRule {
+  public readonly name = 'LowPriorityEviction';
+
+  private log = createLogger('p2p:tx_pool_v2:low_priority_eviction_rule');
+  private maxPoolSize: number;
+
+  constructor(config: { maxPoolSize: number }) {
+    this.maxPoolSize = config.maxPoolSize;
+  }
+
+  async evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult> {
+    if (context.event !== EvictionEvent.TXS_ADDED) {
+      return {
+        reason: 'low_priority',
+        success: true,
+        txsEvicted: [],
+      };
+    }
+
+    if (this.maxPoolSize === 0) {
+      return {
+        reason: 'low_priority',
+        success: true,
+        txsEvicted: [],
+      };
+    }
+
+    try {
+      const currentTxCount = pool.getPendingTxCount();
+
+      if (currentTxCount <= this.maxPoolSize) {
+        this.log.trace(
+          `Not evicting low priority txs. Pending tx count below limit ${currentTxCount} <= ${this.maxPoolSize}`,
+        );
+        return {
+          reason: 'low_priority',
+          success: true,
+          txsEvicted: [],
+        };
+      }
+
+      this.log.verbose(
+        `Evicting low priority txs. Pending tx count above limit: ${currentTxCount} > ${this.maxPoolSize}`,
+      );
+      const numberToEvict = currentTxCount - this.maxPoolSize;
+      const txsToEvict = pool.getLowestPriorityPending(numberToEvict);
+
+      if (txsToEvict.length > 0) {
+        await pool.deleteTxs(txsToEvict);
+      }
+
+      const numNewTxsEvicted = context.newTxHashes.filter(newTxHash => txsToEvict.includes(newTxHash)).length;
+
+      this.log.verbose(`Evicted ${txsToEvict.length} low priority txs, including ${numNewTxsEvicted} newly added txs`);
+
+      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 }),
+      };
+    }
+  }
+
+  updateConfig(config: EvictionConfig): void {
+    if (config.maxPendingTxCount !== undefined) {
+      this.maxPoolSize = config.maxPendingTxCount;
+    }
+  }
+}

package/src/mem_pools/tx_pool_v2/eviction/low_priority_pre_add_rule.ts

@@ -0,0 +1,72 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import type { TxMetaData } from '../tx_metadata.js';
+import type { EvictionConfig, PreAddPoolAccess, PreAddResult, PreAddRule } from './interfaces.js';
+
+/**
+ * Pre-add rule that checks if the pool is at capacity and handles low-priority eviction.
+ *
+ * When the pool is at capacity:
+ * - If incoming tx has higher priority than the lowest priority tx, evict the lowest and accept incoming
+ * - If incoming tx has equal or lower priority than the lowest, ignore incoming (it would be evicted anyway)
+ */
+export class LowPriorityPreAddRule implements PreAddRule {
+  public readonly name = 'LowPriorityPreAdd';
+
+  private log = createLogger('p2p:tx_pool_v2:low_priority_pre_add_rule');
+  private maxPoolSize: number;
+
+  constructor(config: { maxPoolSize: number }) {
+    this.maxPoolSize = config.maxPoolSize;
+  }
+
+  check(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess): Promise<PreAddResult> {
+    // Skip if max pool size is disabled (0 = unlimited)
+    if (this.maxPoolSize === 0) {
+      return Promise.resolve({ shouldIgnore: false, txHashesToEvict: [] });
+    }
+
+    const currentCount = poolAccess.getPendingTxCount();
+
+    // If pool is not at capacity, accept the tx
+    if (currentCount < this.maxPoolSize) {
+      return Promise.resolve({ shouldIgnore: false, txHashesToEvict: [] });
+    }
+
+    // Pool is at capacity - need to compare priorities
+    const lowestPriorityMeta = poolAccess.getLowestPriorityPendingTx();
+    if (!lowestPriorityMeta) {
+      // No pending txs (shouldn't happen if count > 0, but handle gracefully)
+      return Promise.resolve({ shouldIgnore: false, txHashesToEvict: [] });
+    }
+
+    // If incoming tx has strictly higher priority, evict the lowest priority tx
+    if (incomingMeta.priorityFee > lowestPriorityMeta.priorityFee) {
+      this.log.debug(
+        `Pool at capacity (${currentCount}/${this.maxPoolSize}), evicting ${lowestPriorityMeta.txHash} ` +
+          `(priority ${lowestPriorityMeta.priorityFee}) for ${incomingMeta.txHash} (priority ${incomingMeta.priorityFee})`,
+      );
+      return Promise.resolve({
+        shouldIgnore: false,
+        txHashesToEvict: [lowestPriorityMeta.txHash],
+      });
+    }
+
+    // Incoming tx has equal or lower priority - ignore it (it would be evicted anyway)
+    this.log.debug(
+      `Pool at capacity (${currentCount}/${this.maxPoolSize}), ignoring ${incomingMeta.txHash} ` +
+        `(priority ${incomingMeta.priorityFee}) - lower than existing minimum (priority ${lowestPriorityMeta.priorityFee})`,
+    );
+    return Promise.resolve({
+      shouldIgnore: true,
+      txHashesToEvict: [],
+      reason: `pool at capacity and tx has lower priority than existing transactions`,
+    });
+  }
+
+  updateConfig(config: EvictionConfig): void {
+    if (config.maxPendingTxCount !== undefined) {
+      this.maxPoolSize = config.maxPendingTxCount;
+    }
+  }
+}

package/src/mem_pools/tx_pool_v2/eviction/nullifier_conflict_rule.ts

@@ -0,0 +1,31 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import { type TxMetaData, checkNullifierConflict } from '../tx_metadata.js';
+import type { PreAddPoolAccess, PreAddResult, PreAddRule } from './interfaces.js';
+
+/**
+ * Pre-add rule that checks for nullifier conflicts between incoming and existing transactions.
+ *
+ * When an incoming tx shares nullifiers with existing pending txs:
+ * - If the incoming tx has strictly higher priority, evict all conflicting txs
+ * - If any conflicting tx has equal or higher priority, ignore the incoming tx
+ */
+export class NullifierConflictRule implements PreAddRule {
+  public readonly name = 'NullifierConflict';
+
+  private log = createLogger('p2p:tx_pool_v2:nullifier_conflict_rule');
+
+  check(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess): Promise<PreAddResult> {
+    const result = checkNullifierConflict(
+      incomingMeta,
+      nullifier => poolAccess.getTxHashByNullifier(nullifier),
+      txHash => poolAccess.getMetadata(txHash),
+    );
+
+    if (result.shouldIgnore) {
+      this.log.debug(`Ignoring tx ${incomingMeta.txHash}: ${result.reason}`);
+    }
+
+    return Promise.resolve(result);
+  }
+}

package/src/mem_pools/tx_pool_v2/index.ts

@@ -0,0 +1,11 @@
+export { AztecKVTxPoolV2 } from './tx_pool_v2.js';
+export {
+  type TxPoolV2,
+  type TxPoolV2Config,
+  type TxPoolV2Events,
+  type AddTxsResult,
+  type PoolReadAccess,
+  DEFAULT_TX_POOL_V2_CONFIG,
+} from './interfaces.js';
+export { type TxMetaData, type TxState, buildTxMetaData, comparePriority } from './tx_metadata.js';
+export { TxArchive } from './archive/index.js';