@aztec/p2p 0.0.1-commit.fcb71a6 → 0.0.1-commit.ff7989d6c

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

@@ -1,23 +1,37 @@
+import { findIndexInSortedArray, insertIntoSortedArray } from '@aztec/foundation/array';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 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 { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { TxPoolOptions } from '../tx_pool.js';
-import { type EvictionContext, EvictionEvent, type EvictionRule, type TxPoolOperations } from './eviction_strategy.js';
+import {
+  type EvictionContext,
+  EvictionEvent,
+  type EvictionRule,
+  type PreAddEvictionResult,
+  type PreAddEvictionRule,
+  type PreAddPoolAccess,
+  type TxPoolOperations,
+} from './eviction_strategy.js';
 
 export class EvictionManager {
   private rules: EvictionRule[] = [];
 
+  /** Pre-add eviction rules (run inside addTxs transaction) */
+  private preAddRules: PreAddEvictionRule[] = [];
+
   constructor(
     private txPool: TxPoolOperations,
     private log = createLogger('p2p:mempool:tx_pool:eviction_manager'),
   ) {}
 
-  public async evictAfterNewTxs(newTxs: TxHash[]): Promise<void> {
+  public async evictAfterNewTxs(newTxs: TxHash[], feePayers: AztecAddress[]): Promise<void> {
     const ctx: EvictionContext = {
       event: EvictionEvent.TXS_ADDED,
       newTxs,
+      feePayers,
     };
     await this.runEvictionRules(ctx);
   }
@@ -31,13 +45,13 @@ export class EvictionManager {
       event: EvictionEvent.BLOCK_MINED,
       block,
       newNullifiers,
-      minedFeePayers,
+      feePayers: minedFeePayers,
     };
 
     await this.runEvictionRules(ctx);
   }
 
-  public async evictAfterChainPrune(blockNumber: number): Promise<void> {
+  public async evictAfterChainPrune(blockNumber: BlockNumber): Promise<void> {
     const ctx: EvictionContext = {
       event: EvictionEvent.CHAIN_PRUNED,
       blockNumber,
@@ -45,14 +59,61 @@ export class EvictionManager {
     await this.runEvictionRules(ctx);
   }
 
+  /**
+   * Runs pre-add eviction rules to determine if an incoming tx should be added
+   * and which existing txs should be evicted.
+   * Called from inside the addTxs database transaction for atomicity.
+   *
+   * @param tx - The incoming transaction
+   * @param poolAccess - Read-only access to pool state
+   * @returns Combined result from all pre-add rules
+   */
+  public async runPreAddRules(tx: Tx, poolAccess: PreAddPoolAccess): Promise<PreAddEvictionResult> {
+    const allTxHashesToEvict: TxHash[] = [];
+    const cmpTxHash = (a: TxHash, b: TxHash) => Fr.cmp(a.hash, b.hash);
+
+    for (const rule of this.preAddRules) {
+      try {
+        const result = await rule.check(tx, poolAccess);
+
+        if (result.shouldReject) {
+          return { shouldReject: true, txHashesToEvict: [], reason: result.reason };
+        }
+
+        for (const txHashToEvict of result.txHashesToEvict) {
+          // Only add if not already present (dedup)
+          if (findIndexInSortedArray(allTxHashesToEvict, txHashToEvict, cmpTxHash) === -1) {
+            insertIntoSortedArray(allTxHashesToEvict, txHashToEvict, cmpTxHash);
+          }
+        }
+      } catch (err) {
+        this.log.warn(`Pre-add eviction rule ${rule.name} unexpected error: ${String(err)}`, {
+          err,
+          preAddRule: rule.name,
+        });
+        // On error, reject the tx to be safe
+        return { shouldReject: true, txHashesToEvict: [], reason: `rule error: ${String(err)}` };
+      }
+    }
+
+    return { shouldReject: false, txHashesToEvict: allTxHashesToEvict };
+  }
+
   public registerRule(rule: EvictionRule) {
     this.rules.push(rule);
   }
 
+  public registerPreAddRule(rule: PreAddEvictionRule) {
+    this.preAddRules.push(rule);
+  }
+
   public updateConfig(config: TxPoolOptions): void {
     for (const rule of this.rules) {
       rule.updateConfig(config);
     }
+    for (const rule of this.preAddRules) {
+      rule.updateConfig?.(config);
+    }
   }
 
   private async runEvictionRules(ctx: EvictionContext): Promise<void> {

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

@@ -1,7 +1,12 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+import { type BlockHeader, type Tx, TxHash } from '@aztec/stdlib/tx';
 
+import { getFeePayerBalanceDelta } from '../../../msg_validators/tx_validator/fee_payer_balance.js';
+import { getTxPriorityFee } from '../priority.js';
 import type { TxPoolOptions } from '../tx_pool.js';
 
 export const EvictionEvent = {
@@ -16,16 +21,17 @@ export type EvictionContext =
   | {
       event: typeof EvictionEvent.TXS_ADDED;
       newTxs: TxHash[];
+      feePayers: AztecAddress[];
     }
   | {
       event: typeof EvictionEvent.CHAIN_PRUNED;
-      blockNumber: number;
+      blockNumber: BlockNumber;
     }
   | {
       event: typeof EvictionEvent.BLOCK_MINED;
       block: BlockHeader;
       newNullifiers: Fr[];
-      minedFeePayers: AztecAddress[];
+      feePayers: AztecAddress[];
     };
 
 /**
@@ -63,7 +69,8 @@ export interface TxPoolOperations {
   getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
   getPendingTxInfos(): Promise<PendingTxInfo[]>;
   getPendingTxsReferencingBlocks(blockHashes: Fr[]): Promise<TxBlockReference[]>;
-  getPendingTxsWithFeePayer(feePayer: AztecAddress[]): Promise<PendingTxInfo[]>;
+  getPendingFeePayers(): Promise<AztecAddress[]>;
+  getFeePayerTxInfos(feePayer: AztecAddress): AsyncIterable<FeePayerTxInfo>;
   /** Cheap count of current pending transactions. */
   getPendingTxCount(): Promise<number>;
   /**
@@ -91,3 +98,111 @@ export interface EvictionRule {
    */
   updateConfig(config: TxPoolOptions): void;
 }
+
+/**
+ * Balance-related information about a transaction for a fee payer.
+ */
+export class FeePayerTxInfo {
+  txHash: TxHash;
+  priority: bigint;
+  feeLimit: bigint;
+  claimAmount: bigint;
+  isEvictable: boolean;
+
+  constructor(fields: {
+    txHash: TxHash;
+    priority: bigint;
+    feeLimit: bigint;
+    claimAmount: bigint;
+    isEvictable: boolean;
+  }) {
+    this.txHash = fields.txHash;
+    this.priority = fields.priority;
+    this.feeLimit = fields.feeLimit;
+    this.claimAmount = fields.claimAmount;
+    this.isEvictable = fields.isEvictable;
+  }
+
+  static async encode(tx: Tx, txHash: string | TxHash): Promise<Buffer> {
+    const { feeLimit, claimAmount } = await getFeePayerBalanceDelta(tx, ProtocolContractAddress.FeeJuice);
+    const priority = Buffer32.fromBigInt(getTxPriorityFee(tx)).toBuffer();
+    const hashBuffer = (typeof txHash === 'string' ? TxHash.fromString(txHash) : txHash).toBuffer();
+    const feeLimitBuffer = Buffer32.fromBigInt(feeLimit).toBuffer();
+    const claimAmountBuffer = Buffer32.fromBigInt(claimAmount).toBuffer();
+    return Buffer.concat([priority, hashBuffer, feeLimitBuffer, claimAmountBuffer]);
+  }
+
+  static decode(value: Buffer, isEvictable = true): FeePayerTxInfo {
+    const priority = Buffer32.fromBuffer(value.subarray(0, Buffer32.SIZE)).toBigInt();
+    const hashOffset = Buffer32.SIZE;
+    const feeLimitOffset = hashOffset + TxHash.SIZE;
+    const claimOffset = feeLimitOffset + Buffer32.SIZE;
+
+    return new FeePayerTxInfo({
+      txHash: TxHash.fromBuffer(value.subarray(hashOffset, feeLimitOffset)),
+      priority,
+      feeLimit: Buffer32.fromBuffer(value.subarray(feeLimitOffset, claimOffset)).toBigInt(),
+      claimAmount: Buffer32.fromBuffer(value.subarray(claimOffset, claimOffset + Buffer32.SIZE)).toBigInt(),
+      isEvictable,
+    });
+  }
+}
+
+/**
+ * Read-only access to pool state for pre-add eviction checks.
+ * Passed to pre-add rules during the addTxs transaction.
+ */
+export interface PreAddPoolAccess {
+  /**
+   * Get the pending tx hash that uses a specific nullifier, if any.
+   * Returns undefined if no pending tx uses this nullifier.
+   */
+  getTxHashByNullifier(nullifier: Fr): Promise<TxHash | undefined>;
+
+  /**
+   * Get a pending transaction by its hash.
+   */
+  getPendingTxByHash(hash: TxHash): Promise<Tx | undefined>;
+
+  /**
+   * Get the priority string for a transaction (for fee comparison).
+   */
+  getTxPriority(tx: Tx): string;
+}
+
+/**
+ * Result of a pre-add eviction check for a single transaction.
+ */
+export interface PreAddEvictionResult {
+  /** Whether the incoming tx should be rejected */
+  readonly shouldReject: boolean;
+  /** Sorted array of existing tx hashes that should be evicted if this tx is added */
+  readonly txHashesToEvict: TxHash[];
+  /** Optional reason for rejection */
+  readonly reason?: string;
+}
+
+/**
+ * Strategy interface for pre-add eviction rules.
+ * These run inside the addTxs transaction before a tx is added,
+ * deciding whether to evict existing txs or reject the incoming tx.
+ */
+export interface PreAddEvictionRule {
+  readonly name: string;
+
+  /**
+   * Check if incoming tx should be added and which existing txs to evict.
+   * Called inside the addTxs database transaction for atomicity.
+   *
+   * @param tx - The incoming transaction to check
+   * @param poolAccess - Read-only access to current pool state
+   * @returns Result indicating whether to reject and what to evict
+   */
+  check(tx: Tx, poolAccess: PreAddPoolAccess): Promise<PreAddEvictionResult>;
+
+  /**
+   * Updates the configuration for this rule.
+   * Rules should ignore config options that don't apply to them.
+   */
+  updateConfig?(config: TxPoolOptions): void;
+}

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

@@ -0,0 +1,162 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { DatabasePublicStateSource, type MerkleTreeReadOperations } 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 FeePayerTxInfo,
+  type TxPoolOperations,
+} from './eviction_strategy.js';
+
+export class FeePayerBalanceEvictionRule implements EvictionRule {
+  public readonly name = 'FeePayerBalanceEviction';
+  public readonly reason = 'fee_payer_balance';
+
+  private log = createLogger('p2p:mempool:tx_pool:fee_payer_balance_eviction_rule');
+
+  constructor(private worldState: WorldStateSynchronizer) {}
+
+  async evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult> {
+    try {
+      if (context.event === EvictionEvent.TXS_ADDED) {
+        return await this.evictForFeePayers(context.feePayers, this.worldState.getCommitted(), txPool);
+      }
+
+      if (context.event === EvictionEvent.BLOCK_MINED) {
+        const blockNumber = context.block.getBlockNumber();
+        // Ensure world state is synced to this block before accessing the snapshot.
+        // This handles the race where a block is added to the archiver
+        // but the world state hasn't synced it yet.
+        await this.worldState.syncImmediate(blockNumber);
+        return await this.evictForFeePayers(context.feePayers, this.worldState.getSnapshot(blockNumber), txPool);
+      }
+
+      // 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.
+      //
+      // NOTE: this will happen only in case of that lower-priority-fee tx entered in e.g. block 2, and we have higher-priority-fee tx in block 3
+      // (simply because that was the timing of these txs). But, in case of higher-priority-fee txs being in block 2, the tx3 won't be evicted
+      // -----
+      // Proposed fix: evict only if node is synched
+      if (context.event === EvictionEvent.CHAIN_PRUNED) {
+        // Ensure world state is synced to this block before accessing the snapshot.
+        await this.worldState.syncImmediate(context.blockNumber);
+        const feePayers = await txPool.getPendingFeePayers();
+        return await this.evictForFeePayers(feePayers, this.worldState.getSnapshot(context.blockNumber), txPool);
+      }
+
+      return {
+        reason: this.reason,
+        success: true,
+        txsEvicted: [],
+      };
+    } catch (err) {
+      this.log.error('Failed to evict txs due to fee payer balance', { err });
+      return {
+        reason: this.reason,
+        success: false,
+        txsEvicted: [],
+        error: new Error('Failed to evict txs due to fee payer balance', { cause: err }),
+      };
+    }
+  }
+
+  updateConfig(_config: TxPoolOptions): void {}
+
+  private async evictForFeePayers(
+    feePayers: Array<AztecAddress>, // assumed to be unique
+    db: MerkleTreeReadOperations,
+    txPool: TxPoolOperations,
+  ): Promise<EvictionResult> {
+    const publicStateSource = this.createPublicStateSource(db);
+
+    const txsToEvict = (
+      await Promise.all(feePayers.map(feePayer => this.getEvictionsForFeePayer(feePayer, publicStateSource, txPool)))
+    ).flat();
+
+    if (txsToEvict.length > 0) {
+      await txPool.deleteTxs(txsToEvict);
+    }
+
+    return {
+      reason: this.reason,
+      success: true,
+      txsEvicted: txsToEvict,
+    };
+  }
+
+  private async getEvictionsForFeePayer(
+    feePayer: AztecAddress,
+    publicStateSource: DatabasePublicStateSource,
+    txPool: TxPoolOperations,
+  ): Promise<TxHash[]> {
+    const initialBalance = (
+      await publicStateSource.storageRead(
+        ProtocolContractAddress.FeeJuice,
+        //TODO: cache this LRU-style
+        await computeFeePayerBalanceStorageSlot(feePayer),
+      )
+    ).toBigInt();
+
+    const txs: FeePayerTxInfo[] = [];
+    for await (const entry of txPool.getFeePayerTxInfos(feePayer)) {
+      txs.push(entry);
+    }
+
+    if (txs.length === 0) {
+      return [];
+    }
+
+    const txsToEvict: TxHash[] = [];
+    let balance = initialBalance;
+    let hasNonEvictableOverBalance = false;
+
+    // Evaluate balance in priority order so later claims cannot fund earlier spends.
+    // This sorts so that higher priority txs come first.
+    txs.sort((a, b) => {
+      if (a.priority === b.priority) {
+        return a.txHash.toBigInt() >= b.txHash.toBigInt() ? -1 : 1;
+      }
+
+      return a.priority > b.priority ? -1 : 1;
+    });
+
+    for (const tx of txs) {
+      const available = balance + tx.claimAmount;
+      if (available >= tx.feeLimit) {
+        balance = available - tx.feeLimit;
+        continue;
+      }
+
+      if (tx.isEvictable) {
+        txsToEvict.push(tx.txHash);
+      } else {
+        hasNonEvictableOverBalance = true;
+      }
+    }
+
+    if (hasNonEvictableOverBalance) {
+      this.log.verbose('Fee payer balance cannot be satisfied due to non-evictable txs', {
+        feePayer: feePayer.toString(),
+        balance: initialBalance,
+      });
+    }
+
+    return txsToEvict;
+  }
+
+  private createPublicStateSource(db: MerkleTreeReadOperations): DatabasePublicStateSource {
+    return new DatabasePublicStateSource(db);
+  }
+}

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

@@ -68,10 +68,10 @@ export class InvalidTxsAfterMiningRule implements EvictionRule {
         }
 
         // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
-        const includeByTimestamp = tx.data.includeByTimestamp;
-        if (includeByTimestamp <= timestamp) {
+        const expirationTimestamp = tx.data.expirationTimestamp;
+        if (expirationTimestamp <= timestamp) {
           this.log.verbose(
-            `Evicting tx ${txHash} from pool due to the tx being expired (includeByTimestamp: ${includeByTimestamp}, mined block timestamp: ${timestamp})`,
+            `Evicting tx ${txHash} from pool due to the tx being expired (expirationTimestamp: ${expirationTimestamp}, mined block timestamp: ${timestamp})`,
           );
           txsToEvict.push(txHash);
           continue;

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

@@ -1,7 +1,7 @@
 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 type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { TxHash } from '@aztec/stdlib/tx';
 
@@ -26,7 +26,7 @@ export class InvalidTxsAfterReorgRule implements EvictionRule {
 
   private log = createLogger('p2p:mempool:tx_pool:invalid_txs_after_reorg_rule');
 
-  public constructor(private worldState: ReadonlyWorldStateAccess) {}
+  public constructor(private worldState: WorldStateSynchronizer) {}
 
   async evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult> {
     if (context.event !== EvictionEvent.CHAIN_PRUNED) {
@@ -46,6 +46,8 @@ export class InvalidTxsAfterReorgRule implements EvictionRule {
         insertIntoSortedArray(uniqueBlockHashes, blockHash, Fr.cmp, false);
       });
 
+      // 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);
       const blocksFromDb = await db.findLeafIndices(MerkleTreeId.ARCHIVE, uniqueBlockHashes);
 

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

@@ -0,0 +1,75 @@
+import { findIndexInSortedArray, insertIntoSortedArray } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PreAddEvictionResult, PreAddEvictionRule, PreAddPoolAccess } from './eviction_strategy.js';
+
+const cmpTxHash = (a: TxHash, b: TxHash) => Fr.cmp(a.hash, b.hash);
+
+/**
+ * Pre-add eviction 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 fee, evict all conflicting txs
+ * - If any conflicting tx has equal or higher priority fee, reject the incoming tx
+ *
+ * This prevents nullifier spam attacks where an attacker floods the mempool with
+ * transactions spending the same nullifiers.
+ */
+export class NullifierConflictPreAddRule implements PreAddEvictionRule {
+  public readonly name = 'NullifierConflictPreAdd';
+
+  private log = createLogger('p2p:mempool:tx_pool:nullifier_conflict_pre_add_rule');
+
+  /**
+   * Check if the incoming transaction conflicts with existing transactions via nullifiers.
+   *
+   * @param tx - The incoming transaction
+   * @param poolAccess - Read-only access to pool state
+   * @returns Result with rejection status and txs to evict
+   */
+  async check(tx: Tx, poolAccess: PreAddPoolAccess): Promise<PreAddEvictionResult> {
+    const txHash = tx.getTxHash();
+    const nullifiers = tx.data.getNonEmptyNullifiers();
+    const txHashesToEvict: TxHash[] = [];
+    const incomingPriority = poolAccess.getTxPriority(tx);
+
+    for (const nullifier of nullifiers) {
+      const conflictingHash = await poolAccess.getTxHashByNullifier(nullifier);
+
+      if (
+        !conflictingHash ||
+        conflictingHash.equals(txHash) ||
+        findIndexInSortedArray(txHashesToEvict, conflictingHash, cmpTxHash) !== -1
+      ) {
+        continue;
+      }
+
+      // Get the conflicting tx's priority
+      const conflictingTx = await poolAccess.getPendingTxByHash(conflictingHash);
+      if (!conflictingTx) {
+        continue;
+      }
+
+      const conflictingPriority = poolAccess.getTxPriority(conflictingTx);
+
+      // If incoming tx has strictly higher priority, mark for eviction
+      // Otherwise, reject incoming tx (ties go to existing tx)
+      if (incomingPriority > conflictingPriority) {
+        insertIntoSortedArray(txHashesToEvict, conflictingHash, cmpTxHash);
+      } else {
+        this.log.debug(
+          `Rejecting tx ${txHash.toString()}: nullifier conflict with ${conflictingHash.toString()} which has higher or equal fee`,
+        );
+        return {
+          shouldReject: true,
+          txHashesToEvict: [],
+          reason: `nullifier conflict with ${conflictingHash.toString()}`,
+        };
+      }
+    }
+
+    return { shouldReject: false, txHashesToEvict };
+  }
+}