@aztec/p2p 0.0.1-commit.d431d1c → 0.0.1-commit.dbf9cec

package/dest/mem_pools/tx_pool_v2/eviction/fee_payer_balance_pre_add_rule.js

@@ -0,0 +1,97 @@
+import { createLogger } from '@aztec/foundation/log';
+import { comparePriority } from '../tx_metadata.js';
+import { TxPoolRejectionCode } 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 {
+    name = 'FeePayerBalancePreAdd';
+    log = createLogger('p2p:tx_pool_v2:fee_payer_balance_pre_add_rule');
+    async check(incomingMeta, poolAccess, _context) {
+        // 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 = [
+            ...existingTxs.map((t)=>({
+                    txHash: t.txHash,
+                    txHashBigInt: t.txHashBigInt,
+                    priorityFee: t.priorityFee,
+                    feeLimit: t.feeLimit,
+                    claimAmount: t.claimAmount,
+                    isIncoming: false
+                })),
+            {
+                txHash: incomingMeta.txHash,
+                txHashBigInt: incomingMeta.txHashBigInt,
+                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 = [];
+        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: {
+                            code: TxPoolRejectionCode.INSUFFICIENT_FEE_PAYER_BALANCE,
+                            message: `Fee payer ${incomingMeta.feePayer} has insufficient balance. Balance at transaction: ${available}, required: ${incomingMeta.feeLimit}`,
+                            currentBalance: initialBalance,
+                            availableBalance: available,
+                            feeLimit: incomingMeta.feeLimit
+                        }
+                    };
+                } 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: []
+            };
+        }
+        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/dest/mem_pools/tx_pool_v2/eviction/index.d.ts

@@ -0,0 +1,10 @@
+export { EvictionManager } from './eviction_manager.js';
+export { type EvictionConfig, type EvictionContext, EvictionEvent, type EvictionResult, type EvictionRule, type PoolOperations, type PreAddContext, type PreAddPoolAccess, type PreAddResult, type PreAddRule, type TaggedEviction, TxPoolRejectionCode, type TxPoolRejectionError, } from './interfaces.js';
+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';
+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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbF92Mi9ldmljdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUNMLEtBQUssY0FBYyxFQUNuQixLQUFLLGVBQWUsRUFDcEIsYUFBYSxFQUNiLEtBQUssY0FBYyxFQUNuQixLQUFLLFlBQVksRUFDakIsS0FBSyxjQUFjLEVBQ25CLEtBQUssYUFBYSxFQUNsQixLQUFLLGdCQUFnQixFQUNyQixLQUFLLFlBQVksRUFDakIsS0FBSyxVQUFVLEVBQ2YsS0FBSyxjQUFjLEVBQ25CLG1CQUFtQixFQUNuQixLQUFLLG9CQUFvQixHQUMxQixNQUFNLGlCQUFpQixDQUFDO0FBR3pCLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3JFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ2hGLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBR3ZFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQy9FLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQzdFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ25GLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDIn0=

package/dest/mem_pools/tx_pool_v2/eviction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,mBAAmB,EACnB,KAAK,oBAAoB,GAC1B,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAGvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC"}

package/dest/mem_pools/tx_pool_v2/eviction/index.js

@@ -0,0 +1,11 @@
+export { EvictionManager } from './eviction_manager.js';
+export { EvictionEvent, TxPoolRejectionCode } 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/dest/mem_pools/tx_pool_v2/eviction/interfaces.d.ts

@@ -0,0 +1,174 @@
+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 declare const EvictionEvent: {
+    readonly TXS_ADDED: "txs_added";
+    readonly BLOCK_MINED: "block_mined";
+    readonly CHAIN_PRUNED: "chain_pruned";
+};
+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;
+}
+/** A single eviction tagged with the rule that caused it. */
+export interface TaggedEviction {
+    readonly txHash: string;
+    readonly reason: string;
+}
+/**
+ * Machine-readable rejection codes for pre-add rule rejections.
+ */
+export declare const TxPoolRejectionCode: {
+    readonly LOW_PRIORITY_FEE: "LOW_PRIORITY_FEE";
+    readonly INSUFFICIENT_FEE_PAYER_BALANCE: "INSUFFICIENT_FEE_PAYER_BALANCE";
+    readonly NULLIFIER_CONFLICT: "NULLIFIER_CONFLICT";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+};
+export type TxPoolRejectionCode = (typeof TxPoolRejectionCode)[keyof typeof TxPoolRejectionCode];
+/** Structured rejection reason returned by pre-add rules. */
+export type TxPoolRejectionError = {
+    code: typeof TxPoolRejectionCode.LOW_PRIORITY_FEE;
+    message: string;
+    minimumPriorityFee: bigint;
+    txPriorityFee: bigint;
+} | {
+    code: typeof TxPoolRejectionCode.INSUFFICIENT_FEE_PAYER_BALANCE;
+    message: string;
+    currentBalance: bigint;
+    availableBalance: bigint;
+    feeLimit: bigint;
+} | {
+    code: typeof TxPoolRejectionCode.NULLIFIER_CONFLICT;
+    message: string;
+    conflictingTxHash: string;
+} | {
+    code: typeof TxPoolRejectionCode.INTERNAL_ERROR;
+    message: string;
+};
+/**
+ * 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[];
+    /** Evictions tagged with the rule name that produced them. Populated by EvictionManager. */
+    readonly evictions?: TaggedEviction[];
+    /** Optional reason for ignoring */
+    readonly reason?: TxPoolRejectionError;
+}
+/** Context passed to pre-add rules from addPendingTxs. */
+export interface PreAddContext {
+    /** If true, compare priority fee only (no tx hash tiebreaker). Used for RPC submissions. */
+    feeComparisonOnly?: boolean;
+}
+/**
+ * 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
+     * @param context - Optional context from addPendingTxs caller
+     * @returns Result indicating whether to ignore and what to evict
+     */
+    check(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess, context?: PreAddContext): 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, with an optional reason for metrics */
+    deleteTxs(txHashes: string[], reason?: 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 declare function txHashToString(txHash: TxHash): string;
+/**
+ * Converts an array of TxHash to string array.
+ */
+export declare function txHashesToStrings(txHashes: TxHash[]): string[];
+//# sourceMappingURL=data:application/json;base64,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

package/dest/mem_pools/tx_pool_v2/eviction/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/interfaces.ts"],"names":[],"mappings":"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"}

package/dest/mem_pools/tx_pool_v2/eviction/interfaces.js

@@ -0,0 +1,25 @@
+/**
+ * Events that trigger eviction checks.
+ */ export const EvictionEvent = {
+    TXS_ADDED: 'txs_added',
+    BLOCK_MINED: 'block_mined',
+    CHAIN_PRUNED: 'chain_pruned'
+};
+/**
+ * Machine-readable rejection codes for pre-add rule rejections.
+ */ export const TxPoolRejectionCode = {
+    LOW_PRIORITY_FEE: 'LOW_PRIORITY_FEE',
+    INSUFFICIENT_FEE_PAYER_BALANCE: 'INSUFFICIENT_FEE_PAYER_BALANCE',
+    NULLIFIER_CONFLICT: 'NULLIFIER_CONFLICT',
+    INTERNAL_ERROR: 'INTERNAL_ERROR'
+};
+/**
+ * Converts a TxHash to its string representation for use in eviction results.
+ */ export function txHashToString(txHash) {
+    return txHash.toString();
+}
+/**
+ * Converts an array of TxHash to string array.
+ */ export function txHashesToStrings(txHashes) {
+    return txHashes.map((h)=>h.toString());
+}

package/dest/mem_pools/tx_pool_v2/eviction/invalid_txs_after_mining_rule.d.ts

@@ -0,0 +1,15 @@
+import type { EvictionContext, EvictionResult, EvictionRule, PoolOperations } 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 declare class InvalidTxsAfterMiningRule implements EvictionRule {
+    readonly name = "InvalidTxsAfterMining";
+    private log;
+    evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW52YWxpZF90eHNfYWZ0ZXJfbWluaW5nX3J1bGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbF92Mi9ldmljdGlvbi9pbnZhbGlkX3R4c19hZnRlcl9taW5pbmdfcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUdyRzs7Ozs7OztHQU9HO0FBQ0gscUJBQWEseUJBQTBCLFlBQVcsWUFBWTtJQUM1RCxTQUFnQixJQUFJLDJCQUEyQjtJQUUvQyxPQUFPLENBQUMsR0FBRyxDQUFnRTtJQUVyRSxLQUFLLENBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUUsY0FBYyxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FzRG5GO0NBQ0YifQ==

package/dest/mem_pools/tx_pool_v2/eviction/invalid_txs_after_mining_rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid_txs_after_mining_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/invalid_txs_after_mining_rule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGrG;;;;;;;GAOG;AACH,qBAAa,yBAA0B,YAAW,YAAY;IAC5D,SAAgB,IAAI,2BAA2B;IAE/C,OAAO,CAAC,GAAG,CAAgE;IAErE,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAsDnF;CACF"}

package/dest/mem_pools/tx_pool_v2/eviction/invalid_txs_after_mining_rule.js

@@ -0,0 +1,65 @@
+import { createLogger } from '@aztec/foundation/log';
+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 {
+    name = 'InvalidTxsAfterMining';
+    log = createLogger('p2p:tx_pool_v2:invalid_txs_after_mining_rule');
+    async evict(context, pool) {
+        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 = [];
+            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))) {
+                    txsToEvict.push(meta.txHash);
+                    continue;
+                }
+                // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
+                if (meta.expirationTimestamp <= timestamp) {
+                    this.log.verbose(`Evicting tx ${meta.txHash} from pool due to the tx being expired (expirationTimestamp: ${meta.expirationTimestamp}, mined block timestamp: ${timestamp})`);
+                    txsToEvict.push(meta.txHash);
+                    continue;
+                }
+            }
+            if (txsToEvict.length > 0) {
+                this.log.info(`Evicted ${txsToEvict.length} invalid txs after block mined`);
+                await pool.deleteTxs(txsToEvict, this.name);
+            }
+            this.log.debug(`Evicted ${txsToEvict.length} invalid txs after block mined`, {
+                txHashes: txsToEvict
+            });
+            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/dest/mem_pools/tx_pool_v2/eviction/invalid_txs_after_reorg_rule.d.ts

@@ -0,0 +1,17 @@
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { EvictionContext, EvictionResult, EvictionRule, PoolOperations } 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 declare class InvalidTxsAfterReorgRule implements EvictionRule {
+    private worldState;
+    readonly name = "InvalidTxsAfterReorg";
+    private log;
+    constructor(worldState: WorldStateSynchronizer);
+    evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW52YWxpZF90eHNfYWZ0ZXJfcmVvcmdfcnVsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sX3YyL2V2aWN0aW9uL2ludmFsaWRfdHhzX2FmdGVyX3Jlb3JnX3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUc5RSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUdyRzs7Ozs7O0dBTUc7QUFDSCxxQkFBYSx3QkFBeUIsWUFBVyxZQUFZO0lBSy9DLE9BQU8sQ0FBQyxVQUFVO0lBSjlCLFNBQWdCLElBQUksMEJBQTBCO0lBRTlDLE9BQU8sQ0FBQyxHQUFHLENBQStEO0lBRTFFLFlBQW9CLFVBQVUsRUFBRSxzQkFBc0IsRUFBSTtJQUVwRCxLQUFLLENBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUUsY0FBYyxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0E2RW5GO0NBQ0YifQ==

package/dest/mem_pools/tx_pool_v2/eviction/invalid_txs_after_reorg_rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid_txs_after_reorg_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/invalid_txs_after_reorg_rule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAG9E,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGrG;;;;;;GAMG;AACH,qBAAa,wBAAyB,YAAW,YAAY;IAK/C,OAAO,CAAC,UAAU;IAJ9B,SAAgB,IAAI,0BAA0B;IAE9C,OAAO,CAAC,GAAG,CAA+D;IAE1E,YAAoB,UAAU,EAAE,sBAAsB,EAAI;IAEpD,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CA6EnF;CACF"}

package/dest/mem_pools/tx_pool_v2/eviction/invalid_txs_after_reorg_rule.js

@@ -0,0 +1,93 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+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 {
+    worldState;
+    name;
+    log;
+    constructor(worldState){
+        this.worldState = worldState;
+        this.name = 'InvalidTxsAfterReorg';
+        this.log = createLogger('p2p:tx_pool_v2:invalid_txs_after_reorg_rule');
+    }
+    async evict(context, pool) {
+        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();
+            const txsByBlockHash = new Map();
+            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);
+            }
+            // Sync without a block number to ensure the world state processes the prune event.
+            await this.worldState.syncImmediate();
+            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();
+            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 = [];
+            for (const [blockHashStr, txHashes] of txsByBlockHash){
+                if (prunedBlockHashes.has(blockHashStr)) {
+                    txsToEvict.push(...txHashes);
+                }
+            }
+            if (txsToEvict.length > 0) {
+                this.log.info(`Evicting ${txsToEvict.length} txs from pool due to referencing pruned blocks`);
+                await pool.deleteTxs(txsToEvict, this.name);
+            }
+            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`, {
+                txHashes: txsToEvict
+            });
+            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/dest/mem_pools/tx_pool_v2/eviction/low_priority_eviction_rule.d.ts

@@ -0,0 +1,16 @@
+import type { EvictionConfig, EvictionContext, EvictionResult, EvictionRule, PoolOperations } from './interfaces.js';
+/**
+ * Eviction rule that removes low-priority transactions when the pool exceeds configured limits.
+ * Triggers on TXS_ADDED and CHAIN_PRUNED events.
+ */
+export declare class LowPriorityEvictionRule implements EvictionRule {
+    readonly name = "LowPriorityEviction";
+    private log;
+    private maxPoolSize;
+    constructor(config: {
+        maxPoolSize: number;
+    });
+    evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult>;
+    updateConfig(config: EvictionConfig): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG93X3ByaW9yaXR5X2V2aWN0aW9uX3J1bGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbF92Mi9ldmljdGlvbi9sb3dfcHJpb3JpdHlfZXZpY3Rpb25fcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsZUFBZSxFQUFFLGNBQWMsRUFBRSxZQUFZLEVBQUUsY0FBYyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFHckg7OztHQUdHO0FBQ0gscUJBQWEsdUJBQXdCLFlBQVcsWUFBWTtJQUMxRCxTQUFnQixJQUFJLHlCQUF5QjtJQUU3QyxPQUFPLENBQUMsR0FBRyxDQUE2RDtJQUN4RSxPQUFPLENBQUMsV0FBVyxDQUFTO0lBRTVCLFlBQVksTUFBTSxFQUFFO1FBQUUsV0FBVyxFQUFFLE1BQU0sQ0FBQTtLQUFFLEVBRTFDO0lBRUssS0FBSyxDQUFDLE9BQU8sRUFBRSxlQUFlLEVBQUUsSUFBSSxFQUFFLGNBQWMsR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLENBZ0VuRjtJQUVELFlBQVksQ0FBQyxNQUFNLEVBQUUsY0FBYyxHQUFHLElBQUksQ0FJekM7Q0FDRiJ9

package/dest/mem_pools/tx_pool_v2/eviction/low_priority_eviction_rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"low_priority_eviction_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/low_priority_eviction_rule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGrH;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,YAAY;IAC1D,SAAgB,IAAI,yBAAyB;IAE7C,OAAO,CAAC,GAAG,CAA6D;IACxE,OAAO,CAAC,WAAW,CAAS;IAE5B,YAAY,MAAM,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,EAE1C;IAEK,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAgEnF;IAED,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAIzC;CACF"}

package/dest/mem_pools/tx_pool_v2/eviction/low_priority_eviction_rule.js

@@ -0,0 +1,78 @@
+import { createLogger } from '@aztec/foundation/log';
+import { EvictionEvent } from './interfaces.js';
+/**
+ * Eviction rule that removes low-priority transactions when the pool exceeds configured limits.
+ * Triggers on TXS_ADDED and CHAIN_PRUNED events.
+ */ export class LowPriorityEvictionRule {
+    name = 'LowPriorityEviction';
+    log = createLogger('p2p:tx_pool_v2:low_priority_eviction_rule');
+    maxPoolSize;
+    constructor(config){
+        this.maxPoolSize = config.maxPoolSize;
+    }
+    async evict(context, pool) {
+        if (context.event !== EvictionEvent.TXS_ADDED && context.event !== EvictionEvent.CHAIN_PRUNED) {
+            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.info(`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) {
+                if (context.event === EvictionEvent.TXS_ADDED) {
+                    const toEvictSet = new Set(txsToEvict);
+                    const numNewTxsEvicted = context.newTxHashes.filter((newTxHash)=>toEvictSet.has(newTxHash)).length;
+                    this.log.info(`Evicted ${txsToEvict.length} low priority txs, including ${numNewTxsEvicted} newly added txs`);
+                } else {
+                    this.log.info(`Evicted ${txsToEvict.length} low priority txs after chain prune`);
+                }
+                await pool.deleteTxs(txsToEvict, this.name);
+            }
+            this.log.debug(`Evicted ${txsToEvict.length} low priority txs`, {
+                txHashes: txsToEvict
+            });
+            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) {
+        if (config.maxPendingTxCount !== undefined) {
+            this.maxPoolSize = config.maxPendingTxCount;
+        }
+    }
+}