@aztec/p2p 0.0.1-commit.6d63667d → 0.0.1-commit.86469d5

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

@@ -1,147 +0,0 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Logger } from '@aztec/foundation/log';
-import type { BlockHeader } from '@aztec/stdlib/tx';
-
-import type { TxMetaData } from '../tx_metadata.js';
-import {
-  type EvictionConfig,
-  type EvictionContext,
-  EvictionEvent,
-  type EvictionRule,
-  type PoolOperations,
-  type PreAddPoolAccess,
-  type PreAddResult,
-  type PreAddRule,
-} from './interfaces.js';
-
-/**
- * Manages eviction rules for the transaction pool.
- * Coordinates pre-add rules (run during addPendingTxs) and post-event rules (run after events).
- */
-export class EvictionManager {
-  private preAddRules: PreAddRule[] = [];
-  private postEventRules: EvictionRule[] = [];
-
-  constructor(
-    private pool: PoolOperations,
-    private log: Logger,
-  ) {}
-
-  /**
-   * Registers a pre-add rule that runs during transaction addition.
-   */
-  registerPreAddRule(rule: PreAddRule): void {
-    this.preAddRules.push(rule);
-    this.log.debug(`Registered pre-add rule: ${rule.name}`);
-  }
-
-  /**
-   * Registers a post-event eviction rule that runs after events.
-   */
-  registerRule(rule: EvictionRule): void {
-    this.postEventRules.push(rule);
-    this.log.debug(`Registered eviction rule: ${rule.name}`);
-  }
-
-  /**
-   * Runs all pre-add rules for an incoming transaction.
-   * Returns combined result of all rules.
-   */
-  async runPreAddRules(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess): Promise<PreAddResult> {
-    const allTxHashesToEvict: string[] = [];
-
-    for (const rule of this.preAddRules) {
-      try {
-        const result = await rule.check(incomingMeta, poolAccess);
-
-        if (result.shouldIgnore) {
-          return result;
-        }
-
-        // Collect txs to evict from all rules
-        for (const txHash of result.txHashesToEvict) {
-          if (!allTxHashesToEvict.includes(txHash)) {
-            allTxHashesToEvict.push(txHash);
-          }
-        }
-      } catch (err) {
-        this.log.error(`Error running pre-add rule ${rule.name}`, { err, txHash: incomingMeta.txHash });
-        // On error, ignore the transaction to be safe
-        return {
-          shouldIgnore: true,
-          txHashesToEvict: [],
-          reason: `pre-add rule ${rule.name} error: ${err}`,
-        };
-      }
-    }
-
-    return {
-      shouldIgnore: false,
-      txHashesToEvict: allTxHashesToEvict,
-    };
-  }
-
-  /**
-   * Runs post-event eviction after new transactions are added.
-   */
-  async evictAfterNewTxs(newTxHashes: string[], feePayers: string[]): Promise<void> {
-    const context: EvictionContext = {
-      event: EvictionEvent.TXS_ADDED,
-      newTxHashes,
-      feePayers,
-    };
-
-    await this.runPostEventRules(context);
-  }
-
-  /**
-   * Runs post-event eviction after a block is mined.
-   */
-  async evictAfterNewBlock(block: BlockHeader, newNullifiers: string[], feePayers: string[]): Promise<void> {
-    const context: EvictionContext = {
-      event: EvictionEvent.BLOCK_MINED,
-      block,
-      newNullifiers,
-      feePayers,
-    };
-
-    await this.runPostEventRules(context);
-  }
-
-  /**
-   * Runs post-event eviction after a chain prune (reorg).
-   */
-  async evictAfterChainPrune(blockNumber: BlockNumber): Promise<void> {
-    const context: EvictionContext = {
-      event: EvictionEvent.CHAIN_PRUNED,
-      blockNumber,
-    };
-
-    await this.runPostEventRules(context);
-  }
-
-  /**
-   * Updates configuration for all rules.
-   */
-  updateConfig(config: EvictionConfig): void {
-    for (const rule of this.preAddRules) {
-      rule.updateConfig?.(config);
-    }
-    for (const rule of this.postEventRules) {
-      rule.updateConfig?.(config);
-    }
-  }
-
-  private async runPostEventRules(context: EvictionContext): Promise<void> {
-    for (const rule of this.postEventRules) {
-      try {
-        const result = await rule.evict(context, this.pool);
-        if (!result.success) {
-          this.log.warn(`Eviction rule ${rule.name} failed`, { error: result.error });
-        }
-      } catch (err) {
-        this.log.error(`Error running eviction rule ${rule.name}`, { err });
-      }
-    }
-  }
-}

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

@@ -1,118 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { DatabasePublicStateSource, type MerkleTreeReadOperations } from '@aztec/stdlib/trees';
-
-import { type TxMetaData, comparePriority } from '../tx_metadata.js';
-import type { EvictionContext, EvictionResult, EvictionRule, PoolOperations } from './interfaces.js';
-import { EvictionEvent } from './interfaces.js';
-
-/**
- * Eviction rule that removes transactions when fee payers have insufficient balance.
- * Triggers on TXS_ADDED, BLOCK_MINED, and CHAIN_PRUNED events.
- */
-export class FeePayerBalanceEvictionRule implements EvictionRule {
-  public readonly name = 'FeePayerBalanceEviction';
-  public readonly reason = 'fee_payer_balance';
-
-  private log = createLogger('p2p:tx_pool_v2:fee_payer_balance_eviction_rule');
-
-  constructor(private worldState: WorldStateSynchronizer) {}
-
-  async evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult> {
-    try {
-      if (context.event === EvictionEvent.TXS_ADDED) {
-        return await this.evictForFeePayers(context.feePayers, this.worldState.getCommitted(), pool);
-      }
-
-      if (context.event === EvictionEvent.BLOCK_MINED) {
-        const blockNumber = context.block.getBlockNumber();
-        await this.worldState.syncImmediate(blockNumber);
-        return await this.evictForFeePayers(context.feePayers, this.worldState.getSnapshot(blockNumber), pool);
-      }
-
-      if (context.event === EvictionEvent.CHAIN_PRUNED) {
-        await this.worldState.syncImmediate(context.blockNumber);
-        const feePayers = pool.getPendingFeePayers();
-        return await this.evictForFeePayers(feePayers, this.worldState.getSnapshot(context.blockNumber), pool);
-      }
-
-      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 }),
-      };
-    }
-  }
-
-  private async evictForFeePayers(
-    feePayers: string[],
-    db: MerkleTreeReadOperations,
-    pool: PoolOperations,
-  ): Promise<EvictionResult> {
-    const publicStateSource = new DatabasePublicStateSource(db);
-
-    const txsToEvict = (
-      await Promise.all(feePayers.map(feePayer => this.getEvictionsForFeePayer(feePayer, publicStateSource, pool)))
-    ).flat();
-
-    if (txsToEvict.length > 0) {
-      await pool.deleteTxs(txsToEvict);
-    }
-
-    return {
-      reason: this.reason,
-      success: true,
-      txsEvicted: txsToEvict,
-    };
-  }
-
-  private async getEvictionsForFeePayer(
-    feePayerStr: string,
-    publicStateSource: DatabasePublicStateSource,
-    pool: PoolOperations,
-  ): Promise<string[]> {
-    const feePayer = AztecAddress.fromString(feePayerStr);
-    const initialBalance = (
-      await publicStateSource.storageRead(
-        ProtocolContractAddress.FeeJuice,
-        await computeFeePayerBalanceStorageSlot(feePayer),
-      )
-    ).toBigInt();
-
-    const txs: TxMetaData[] = pool.getFeePayerPendingTxs(feePayerStr);
-
-    if (txs.length === 0) {
-      return [];
-    }
-
-    const txsToEvict: string[] = [];
-    let balance = initialBalance;
-
-    // Sort by priority descending (highest first), with hash as tiebreaker
-    txs.sort((a, b) => comparePriority(b, a));
-
-    for (const tx of txs) {
-      const available = balance + tx.claimAmount;
-      if (available >= tx.feeLimit) {
-        balance = available - tx.feeLimit;
-        continue;
-      }
-
-      // This tx cannot be covered - mark for eviction
-      txsToEvict.push(tx.txHash);
-    }
-
-    return txsToEvict;
-  }
-}

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

@@ -1,111 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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 }),
-      };
-    }
-  }
-}