@aztec/p2p 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

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

@@ -0,0 +1,132 @@
+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, Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { TxPoolOptions } from '../tx_pool.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[], feePayers: AztecAddress[]): Promise<void> {
+    const ctx: EvictionContext = {
+      event: EvictionEvent.TXS_ADDED,
+      newTxs,
+      feePayers,
+    };
+    await this.runEvictionRules(ctx);
+  }
+
+  public async evictAfterNewBlock(
+    block: BlockHeader,
+    newNullifiers: Fr[],
+    minedFeePayers: AztecAddress[],
+  ): Promise<void> {
+    const ctx: EvictionContext = {
+      event: EvictionEvent.BLOCK_MINED,
+      block,
+      newNullifiers,
+      feePayers: minedFeePayers,
+    };
+
+    await this.runEvictionRules(ctx);
+  }
+
+  public async evictAfterChainPrune(blockNumber: BlockNumber): Promise<void> {
+    const ctx: EvictionContext = {
+      event: EvictionEvent.CHAIN_PRUNED,
+      blockNumber,
+    };
+    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> {
+    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,208 @@
+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, 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 = {
+  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[];
+      feePayers: AztecAddress[];
+    }
+  | {
+      event: typeof EvictionEvent.CHAIN_PRUNED;
+      blockNumber: BlockNumber;
+    }
+  | {
+      event: typeof EvictionEvent.BLOCK_MINED;
+      block: BlockHeader;
+      newNullifiers: Fr[];
+      feePayers: 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[]>;
+  getPendingFeePayers(): Promise<AztecAddress[]>;
+  getFeePayerTxInfos(feePayer: AztecAddress): AsyncIterable<FeePayerTxInfo>;
+  /** 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;
+}
+
+/**
+ * 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

@@ -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,93 @@
+import { findIndexInSortedArray, insertIntoSortedArray } from '@aztec/foundation/array';
+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 { 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: WorldStateSynchronizer) {}
+
+  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);
+      });
+
+      // 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);
+
+      // 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 {}
+}