@aztec/p2p 0.0.1-commit.7d4e6cd → 0.0.1-commit.87a0206

package/src/mem_pools/tx_pool_v2/archive/tx_archive.ts

@@ -0,0 +1,120 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * Manages archived transactions with FIFO eviction.
+ * Archived transactions have their proofs stripped to save space.
+ */
+export class TxArchive {
+  #store: AztecAsyncKVStore;
+  #txs: AztecAsyncMap<string, Buffer>;
+  #indices: AztecAsyncMap<number, string>;
+  #limit: number;
+  #log: Logger;
+
+  constructor(store: AztecAsyncKVStore, limit: number, log?: Logger) {
+    this.#store = store;
+    this.#txs = store.openMap('archivedTxs');
+    this.#indices = store.openMap('archivedTxIndices');
+    this.#limit = limit;
+    this.#log = log ?? createLogger('p2p:tx_pool_v2:archive');
+  }
+
+  /**
+   * Updates the maximum number of archived transactions.
+   */
+  updateLimit(limit: number): void {
+    this.#limit = limit;
+  }
+
+  /**
+   * Gets the current archive limit.
+   */
+  getLimit(): number {
+    return this.#limit;
+  }
+
+  /**
+   * Checks if archiving is enabled.
+   */
+  isEnabled(): boolean {
+    return this.#limit > 0;
+  }
+
+  /**
+   * Archives transactions, stripping their proofs.
+   * Evicts oldest transactions if the limit is exceeded.
+   */
+  async archiveTxs(txs: Tx[]): Promise<void> {
+    if (!this.isEnabled() || txs.length === 0) {
+      return;
+    }
+
+    try {
+      await this.#store.transactionAsync(async () => {
+        // Get current head and tail indices
+        let headIdx = await this.getHeadIndex();
+        let tailIdx = await this.getTailIndex();
+
+        for (const tx of txs) {
+          // Evict oldest entries if at capacity
+          while (headIdx - tailIdx >= this.#limit) {
+            const txHashToEvict = await this.#indices.getAsync(tailIdx);
+            if (txHashToEvict) {
+              await this.#txs.delete(txHashToEvict);
+              await this.#indices.delete(tailIdx);
+            }
+            tailIdx++;
+          }
+
+          // Archive the transaction with stripped proof
+          const archivedTx = this.stripProof(tx);
+          const txHash = tx.getTxHash().toString();
+          await this.#txs.set(txHash, archivedTx.toBuffer());
+          await this.#indices.set(headIdx, txHash);
+          headIdx++;
+        }
+
+        this.#log.debug(`Archived ${txs.length} txs, total: ${headIdx - tailIdx}`);
+      });
+    } catch (error) {
+      this.#log.error('Error archiving transactions', { error });
+    }
+  }
+
+  /**
+   * Retrieves an archived transaction by its hash.
+   */
+  async getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
+    const buffer = await this.#txs.getAsync(txHash.toString());
+    return buffer ? Tx.fromBuffer(buffer) : undefined;
+  }
+
+  /**
+   * Gets the current count of archived transactions.
+   */
+  async getCount(): Promise<number> {
+    const head = await this.getHeadIndex();
+    const tail = await this.getTailIndex();
+    return head - tail;
+  }
+
+  /**
+   * Strips the proof from a transaction for archival.
+   */
+  private stripProof(tx: Tx): Tx {
+    return new Tx(tx.txHash, tx.data, ChonkProof.empty(), tx.contractClassLogFields, tx.publicFunctionCalldata);
+  }
+
+  private async getHeadIndex(): Promise<number> {
+    const entry = await this.#indices.entriesAsync({ limit: 1, reverse: true }).next();
+    return (entry.value?.[0] ?? -1) + 1;
+  }
+
+  private async getTailIndex(): Promise<number> {
+    const entry = await this.#indices.entriesAsync({ limit: 1 }).next();
+    return entry.value?.[0] ?? 0;
+  }
+}

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

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

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

@@ -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());
+}