@aztec/p2p 0.0.1-commit.6b90f3f5 → 0.0.1-commit.6bd18f1aa

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 → tx_pool_v2}/eviction/invalid_txs_after_mining_rule.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import { EvictionEvent } from './eviction_strategy.js';
+import { EvictionEvent } from './interfaces.js';
 /**
  * Eviction rule that removes invalid transactions after a block is mined.
  * Only triggers on BLOCK_MINED events.
@@ -9,8 +9,8 @@ import { EvictionEvent } from './eviction_strategy.js';
  * - Transactions with an expiration timestamp less than or equal to the mined block timestamp
  */ export class InvalidTxsAfterMiningRule {
     name = 'InvalidTxsAfterMining';
-    log = createLogger('p2p:mempool:tx_pool:invalid_txs_after_mining_rule');
-    async evict(context, txPool) {
+    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',
@@ -18,49 +18,31 @@ import { EvictionEvent } from './eviction_strategy.js';
                 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 minedNullifiers = new Set(context.newNullifiers);
             const txsToEvict = [];
-            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;
-                }
+            const pendingTxs = pool.getPendingTxs();
+            for (const meta of pendingTxs){
                 // 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);
+                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
-                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);
+                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) {
-                await txPool.deleteTxs(txsToEvict);
+                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`);
+            this.log.debug(`Evicted ${txsToEvict.length} invalid txs after block mined`, {
+                txHashes: txsToEvict
+            });
             return {
                 reason: 'block_mined_invalid_txs',
                 success: true,
@@ -80,5 +62,4 @@ import { EvictionEvent } from './eviction_strategy.js';
             };
         }
     }
-    updateConfig(_config) {}
 }

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 → tx_pool_v2}/eviction/invalid_txs_after_reorg_rule.js

@@ -1,8 +1,7 @@
-import { findIndexInSortedArray, insertIntoSortedArray } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { EvictionEvent } from './eviction_strategy.js';
+import { EvictionEvent } from './interfaces.js';
 /**
  * Eviction rule that removes invalid transactions after a blockchain reorganization.
  * Only triggers on CHAIN_PRUNED events.
@@ -16,9 +15,9 @@ import { EvictionEvent } from './eviction_strategy.js';
     constructor(worldState){
         this.worldState = worldState;
         this.name = 'InvalidTxsAfterReorg';
-        this.log = createLogger('p2p:mempool:tx_pool:invalid_txs_after_reorg_rule');
+        this.log = createLogger('p2p:tx_pool_v2:invalid_txs_after_reorg_rule');
     }
-    async evict(context, txPool) {
+    async evict(context, pool) {
         if (context.event !== EvictionEvent.CHAIN_PRUNED) {
             return {
                 reason: 'reorg_invalid_txs',
@@ -27,34 +26,51 @@ import { EvictionEvent } from './eviction_strategy.js';
             };
         }
         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 = [];
-            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 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);
-            const blocksFromDb = await db.findLeafIndices(MerkleTreeId.ARCHIVE, uniqueBlockHashes);
-            // Identify txs whose blockHash is not found in the archive (pruned)
+            // 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 tx of candidateTxs){
-                const idx = findIndexInSortedArray(uniqueBlockHashes, tx.blockHash, Fr.cmp);
-                const blockPruned = idx === -1 || blocksFromDb[idx] === undefined;
-                if (blockPruned) {
-                    txsToEvict.push(tx.txHash);
+            for (const [blockHashStr, txHashes] of txsByBlockHash){
+                if (prunedBlockHashes.has(blockHashStr)) {
+                    txsToEvict.push(...txHashes);
                 }
             }
             if (txsToEvict.length > 0) {
-                this.log.verbose(`Evicting ${txsToEvict.length} txs from pool due to referencing pruned blocks`);
-                await txPool.deleteTxs(txsToEvict);
+                this.log.info(`Evicting ${txsToEvict.length} txs from pool due to referencing pruned blocks`);
+                await pool.deleteTxs(txsToEvict, this.name);
             }
-            const keptCount = candidateTxs.length - txsToEvict.length;
+            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`);
+            this.log.debug(`Evicted ${txsToEvict.length} invalid txs after reorg`, {
+                txHashes: txsToEvict
+            });
             return {
                 reason: 'reorg_invalid_txs',
                 success: true,
@@ -74,5 +90,4 @@ import { EvictionEvent } from './eviction_strategy.js';
             };
         }
     }
-    updateConfig(_config) {}
 }

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;
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import { type TxMetaData } from '../tx_metadata.js';
+import { type EvictionConfig, type PreAddContext, type PreAddPoolAccess, type PreAddResult, type PreAddRule } from './interfaces.js';
+/**
+ * Pre-add rule that checks if the pool is at capacity and handles low-priority eviction.
+ *
+ * When the pool is at capacity:
+ * - If incoming tx has higher priority than the lowest priority tx, evict the lowest and accept incoming
+ * - If incoming tx has equal or lower priority than the lowest, ignore incoming (it would be evicted anyway)
+ */
+export declare class LowPriorityPreAddRule implements PreAddRule {
+    readonly name = "LowPriorityPreAdd";
+    private log;
+    private maxPoolSize;
+    constructor(config: {
+        maxPoolSize: number;
+    });
+    check(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess, context?: PreAddContext): Promise<PreAddResult>;
+    updateConfig(config: EvictionConfig): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG93X3ByaW9yaXR5X3ByZV9hZGRfcnVsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sX3YyL2V2aWN0aW9uL2xvd19wcmlvcml0eV9wcmVfYWRkX3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLEtBQUssVUFBVSxFQUEyQyxNQUFNLG1CQUFtQixDQUFDO0FBQzdGLE9BQU8sRUFDTCxLQUFLLGNBQWMsRUFDbkIsS0FBSyxhQUFhLEVBQ2xCLEtBQUssZ0JBQWdCLEVBQ3JCLEtBQUssWUFBWSxFQUNqQixLQUFLLFVBQVUsRUFFaEIsTUFBTSxpQkFBaUIsQ0FBQztBQUV6Qjs7Ozs7O0dBTUc7QUFDSCxxQkFBYSxxQkFBc0IsWUFBVyxVQUFVO0lBQ3RELFNBQWdCLElBQUksdUJBQXVCO0lBRTNDLE9BQU8sQ0FBQyxHQUFHLENBQTREO0lBQ3ZFLE9BQU8sQ0FBQyxXQUFXLENBQVM7SUFFNUIsWUFBWSxNQUFNLEVBQUU7UUFBRSxXQUFXLEVBQUUsTUFBTSxDQUFBO0tBQUUsRUFFMUM7SUFFRCxLQUFLLENBQUMsWUFBWSxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDLEVBQUUsYUFBYSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0E4RDVHO0lBRUQsWUFBWSxDQUFDLE1BQU0sRUFBRSxjQUFjLEdBQUcsSUFBSSxDQUl6QztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"low_priority_pre_add_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/low_priority_pre_add_rule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAA2C,MAAM,mBAAmB,CAAC;AAC7F,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AACH,qBAAa,qBAAsB,YAAW,UAAU;IACtD,SAAgB,IAAI,uBAAuB;IAE3C,OAAO,CAAC,GAAG,CAA4D;IACvE,OAAO,CAAC,WAAW,CAAS;IAE5B,YAAY,MAAM,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,EAE1C;IAED,KAAK,CAAC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CA8D5G;IAED,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAIzC;CACF"}

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

@@ -0,0 +1,75 @@
+import { createLogger } from '@aztec/foundation/log';
+import { comparePriority, getMinimumPriceBumpFee } from '../tx_metadata.js';
+import { TxPoolRejectionCode } from './interfaces.js';
+/**
+ * Pre-add rule that checks if the pool is at capacity and handles low-priority eviction.
+ *
+ * When the pool is at capacity:
+ * - If incoming tx has higher priority than the lowest priority tx, evict the lowest and accept incoming
+ * - If incoming tx has equal or lower priority than the lowest, ignore incoming (it would be evicted anyway)
+ */ export class LowPriorityPreAddRule {
+    name = 'LowPriorityPreAdd';
+    log = createLogger('p2p:tx_pool_v2:low_priority_pre_add_rule');
+    maxPoolSize;
+    constructor(config){
+        this.maxPoolSize = config.maxPoolSize;
+    }
+    check(incomingMeta, poolAccess, context) {
+        // Skip if max pool size is disabled (0 = unlimited)
+        if (this.maxPoolSize === 0) {
+            return Promise.resolve({
+                shouldIgnore: false,
+                txHashesToEvict: []
+            });
+        }
+        const currentCount = poolAccess.getPendingTxCount();
+        // If pool is not at capacity, accept the tx
+        if (currentCount < this.maxPoolSize) {
+            return Promise.resolve({
+                shouldIgnore: false,
+                txHashesToEvict: []
+            });
+        }
+        // Pool is at capacity - need to compare priorities
+        const lowestPriorityMeta = poolAccess.getLowestPriorityPendingTx();
+        if (!lowestPriorityMeta) {
+            // No pending txs (shouldn't happen if count > 0, but handle gracefully)
+            return Promise.resolve({
+                shouldIgnore: false,
+                txHashesToEvict: []
+            });
+        }
+        // Compare incoming tx against lowest priority tx.
+        // feeOnly mode (RPC): use strict fee comparison only — avoids churn from hash ordering.
+        // When price bump is also set, require the bumped fee threshold.
+        // Default (gossip): use full comparePriority (fee + tx hash tiebreaker) for determinism.
+        const isHigherPriority = context?.feeComparisonOnly ? context.priceBumpPercentage !== undefined ? incomingMeta.priorityFee >= getMinimumPriceBumpFee(lowestPriorityMeta.priorityFee, context.priceBumpPercentage) : incomingMeta.priorityFee > lowestPriorityMeta.priorityFee : comparePriority(incomingMeta, lowestPriorityMeta) > 0;
+        if (isHigherPriority) {
+            this.log.debug(`Pool at capacity (${currentCount}/${this.maxPoolSize}), evicting ${lowestPriorityMeta.txHash} ` + `(priority ${lowestPriorityMeta.priorityFee}) for ${incomingMeta.txHash} (priority ${incomingMeta.priorityFee})`);
+            return Promise.resolve({
+                shouldIgnore: false,
+                txHashesToEvict: [
+                    lowestPriorityMeta.txHash
+                ]
+            });
+        }
+        // Incoming tx has equal or lower priority - ignore it (it would be evicted anyway)
+        const minimumFee = context?.feeComparisonOnly && context.priceBumpPercentage !== undefined ? getMinimumPriceBumpFee(lowestPriorityMeta.priorityFee, context.priceBumpPercentage) : lowestPriorityMeta.priorityFee + 1n;
+        this.log.debug(`Pool at capacity (${currentCount}/${this.maxPoolSize}), ignoring ${incomingMeta.txHash} ` + `(priority ${incomingMeta.priorityFee}) - lower than existing minimum (priority ${lowestPriorityMeta.priorityFee})`);
+        return Promise.resolve({
+            shouldIgnore: true,
+            txHashesToEvict: [],
+            reason: {
+                code: TxPoolRejectionCode.LOW_PRIORITY_FEE,
+                message: `Tx does not meet minimum priority fee. Required: ${minimumFee}, got: ${incomingMeta.priorityFee}`,
+                minimumPriorityFee: minimumFee,
+                txPriorityFee: incomingMeta.priorityFee
+            }
+        });
+    }
+    updateConfig(config) {
+        if (config.maxPendingTxCount !== undefined) {
+            this.maxPoolSize = config.maxPendingTxCount;
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { type TxMetaData } from '../tx_metadata.js';
+import type { PreAddContext, PreAddPoolAccess, PreAddResult, PreAddRule } from './interfaces.js';
+/**
+ * Pre-add rule that checks for nullifier conflicts between incoming and existing transactions.
+ *
+ * When an incoming tx shares nullifiers with existing pending txs:
+ * - If the incoming tx has strictly higher priority, evict all conflicting txs
+ * - If any conflicting tx has equal or higher priority, ignore the incoming tx
+ */
+export declare class NullifierConflictRule implements PreAddRule {
+    readonly name = "NullifierConflict";
+    private log;
+    check(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess, context?: PreAddContext): Promise<PreAddResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbGlmaWVyX2NvbmZsaWN0X3J1bGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbF92Mi9ldmljdGlvbi9udWxsaWZpZXJfY29uZmxpY3RfcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsS0FBSyxVQUFVLEVBQTBCLE1BQU0sbUJBQW1CLENBQUM7QUFDNUUsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLGdCQUFnQixFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUVqRzs7Ozs7O0dBTUc7QUFDSCxxQkFBYSxxQkFBc0IsWUFBVyxVQUFVO0lBQ3RELFNBQWdCLElBQUksdUJBQXVCO0lBRTNDLE9BQU8sQ0FBQyxHQUFHLENBQTBEO0lBRXJFLEtBQUssQ0FBQyxZQUFZLEVBQUUsVUFBVSxFQUFFLFVBQVUsRUFBRSxnQkFBZ0IsRUFBRSxPQUFPLENBQUMsRUFBRSxhQUFhLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQWE1RztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"nullifier_conflict_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/nullifier_conflict_rule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAA0B,MAAM,mBAAmB,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEjG;;;;;;GAMG;AACH,qBAAa,qBAAsB,YAAW,UAAU;IACtD,SAAgB,IAAI,uBAAuB;IAE3C,OAAO,CAAC,GAAG,CAA0D;IAErE,KAAK,CAAC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAa5G;CACF"}

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

@@ -0,0 +1,19 @@
+import { createLogger } from '@aztec/foundation/log';
+import { checkNullifierConflict } from '../tx_metadata.js';
+/**
+ * Pre-add rule that checks for nullifier conflicts between incoming and existing transactions.
+ *
+ * When an incoming tx shares nullifiers with existing pending txs:
+ * - If the incoming tx has strictly higher priority, evict all conflicting txs
+ * - If any conflicting tx has equal or higher priority, ignore the incoming tx
+ */ export class NullifierConflictRule {
+    name = 'NullifierConflict';
+    log = createLogger('p2p:tx_pool_v2:nullifier_conflict_rule');
+    check(incomingMeta, poolAccess, context) {
+        const result = checkNullifierConflict(incomingMeta, (nullifier)=>poolAccess.getTxHashByNullifier(nullifier), (txHash)=>poolAccess.getMetadata(txHash), context?.priceBumpPercentage);
+        if (result.shouldIgnore) {
+            this.log.debug(`Ignoring tx ${incomingMeta.txHash}: ${result.reason?.message}`);
+        }
+        return Promise.resolve(result);
+    }
+}

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

@@ -0,0 +1,6 @@
+export { AztecKVTxPoolV2 } from './tx_pool_v2.js';
+export { type TxPoolV2, type TxPoolV2Config, type TxPoolV2Events, type AddTxsResult, type PoolReadAccess, DEFAULT_TX_POOL_V2_CONFIG, } from './interfaces.js';
+export { type TxMetaData, type TxState, buildTxMetaData, comparePriority, stubTxMetaData } from './tx_metadata.js';
+export { TxArchive } from './archive/index.js';
+export { DeletedPool } from './deleted_pool.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbF92Mi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDbEQsT0FBTyxFQUNMLEtBQUssUUFBUSxFQUNiLEtBQUssY0FBYyxFQUNuQixLQUFLLGNBQWMsRUFDbkIsS0FBSyxZQUFZLEVBQ2pCLEtBQUssY0FBYyxFQUNuQix5QkFBeUIsR0FDMUIsTUFBTSxpQkFBaUIsQ0FBQztBQUN6QixPQUFPLEVBQUUsS0FBSyxVQUFVLEVBQUUsS0FBSyxPQUFPLEVBQUUsZUFBZSxFQUFFLGVBQWUsRUFBRSxjQUFjLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNuSCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDL0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFtQixDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool_v2/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACnH,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/dest/mem_pools/tx_pool_v2/index.js

@@ -0,0 +1,5 @@
+export { AztecKVTxPoolV2 } from './tx_pool_v2.js';
+export { DEFAULT_TX_POOL_V2_CONFIG } from './interfaces.js';
+export { buildTxMetaData, comparePriority, stubTxMetaData } from './tx_metadata.js';
+export { TxArchive } from './archive/index.js';
+export { DeletedPool } from './deleted_pool.js';

package/dest/mem_pools/tx_pool_v2/instrumentation.d.ts

@@ -0,0 +1,15 @@
+import { type TelemetryClient } from '@aztec/telemetry-client';
+/** Callback that returns the current estimated metadata memory in bytes. */
+export type MetadataMemoryCallback = () => number;
+/** Instrumentation for TxPoolV2Impl internal operations. */
+export declare class TxPoolV2Instrumentation {
+    #private;
+    constructor(telemetry: TelemetryClient, metadataMemoryCallback: MetadataMemoryCallback);
+    recordEvictions(count: number, reason: string): void;
+    recordIgnored(count: number): void;
+    recordRejected(count: number): void;
+    recordSoftDeletedHits(count: number): void;
+    recordMissingOnProtect(count: number): void;
+    recordMissingPreviouslyEvicted(count: number): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1bWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL3R4X3Bvb2xfdjIvaW5zdHJ1bWVudGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFNTCxLQUFLLGVBQWUsRUFHckIsTUFBTSx5QkFBeUIsQ0FBQztBQUVqQyw0RUFBNEU7QUFDNUUsTUFBTSxNQUFNLHNCQUFzQixHQUFHLE1BQU0sTUFBTSxDQUFDO0FBRWxELDREQUE0RDtBQUM1RCxxQkFBYSx1QkFBdUI7O0lBU2xDLFlBQVksU0FBUyxFQUFFLGVBQWUsRUFBRSxzQkFBc0IsRUFBRSxzQkFBc0IsRUFtQnJGO0lBRUQsZUFBZSxDQUFDLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLE1BQU0sUUFFNUM7SUFFRCxhQUFhLENBQUMsS0FBSyxFQUFFLE1BQU0sUUFFMUI7SUFFRCxjQUFjLENBQUMsS0FBSyxFQUFFLE1BQU0sUUFFM0I7SUFFRCxxQkFBcUIsQ0FBQyxLQUFLLEVBQUUsTUFBTSxRQUVsQztJQUVELHNCQUFzQixDQUFDLEtBQUssRUFBRSxNQUFNLFFBRW5DO0lBRUQsOEJBQThCLENBQUMsS0FBSyxFQUFFLE1BQU0sUUFFM0M7Q0FDRiJ9

package/dest/mem_pools/tx_pool_v2/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool_v2/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,4EAA4E;AAC5E,MAAM,MAAM,sBAAsB,GAAG,MAAM,MAAM,CAAC;AAElD,4DAA4D;AAC5D,qBAAa,uBAAuB;;IASlC,YAAY,SAAS,EAAE,eAAe,EAAE,sBAAsB,EAAE,sBAAsB,EAmBrF;IAED,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAE5C;IAED,aAAa,CAAC,KAAK,EAAE,MAAM,QAE1B;IAED,cAAc,CAAC,KAAK,EAAE,MAAM,QAE3B;IAED,qBAAqB,CAAC,KAAK,EAAE,MAAM,QAElC;IAED,sBAAsB,CAAC,KAAK,EAAE,MAAM,QAEnC;IAED,8BAA8B,CAAC,KAAK,EAAE,MAAM,QAE3C;CACF"}

package/dest/mem_pools/tx_pool_v2/instrumentation.js

@@ -0,0 +1,43 @@
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
+/** Instrumentation for TxPoolV2Impl internal operations. */ export class TxPoolV2Instrumentation {
+    #evictedCounter;
+    #ignoredCounter;
+    #rejectedCounter;
+    #softDeletedHitsCounter;
+    #missingOnProtectCounter;
+    #missingPreviouslyEvictedCounter;
+    #metadataMemoryGauge;
+    constructor(telemetry, metadataMemoryCallback){
+        const meter = telemetry.getMeter('TxPoolV2Impl');
+        this.#evictedCounter = createUpDownCounterWithDefault(meter, Metrics.MEMPOOL_TX_POOL_V2_EVICTED_COUNT);
+        this.#ignoredCounter = createUpDownCounterWithDefault(meter, Metrics.MEMPOOL_TX_POOL_V2_IGNORED_COUNT);
+        this.#rejectedCounter = createUpDownCounterWithDefault(meter, Metrics.MEMPOOL_TX_POOL_V2_REJECTED_COUNT);
+        this.#softDeletedHitsCounter = createUpDownCounterWithDefault(meter, Metrics.MEMPOOL_TX_POOL_V2_SOFT_DELETED_HITS);
+        this.#missingOnProtectCounter = createUpDownCounterWithDefault(meter, Metrics.MEMPOOL_TX_POOL_V2_MISSING_ON_PROTECT);
+        this.#missingPreviouslyEvictedCounter = createUpDownCounterWithDefault(meter, Metrics.MEMPOOL_TX_POOL_V2_MISSING_PREVIOUSLY_EVICTED);
+        this.#metadataMemoryGauge = meter.createObservableGauge(Metrics.MEMPOOL_TX_POOL_V2_METADATA_MEMORY);
+        this.#metadataMemoryGauge.addCallback((result)=>{
+            result.observe(metadataMemoryCallback());
+        });
+    }
+    recordEvictions(count, reason) {
+        this.#evictedCounter.add(count, {
+            [Attributes.TX_POOL_EVICTION_REASON]: reason
+        });
+    }
+    recordIgnored(count) {
+        this.#ignoredCounter.add(count);
+    }
+    recordRejected(count) {
+        this.#rejectedCounter.add(count);
+    }
+    recordSoftDeletedHits(count) {
+        this.#softDeletedHitsCounter.add(count);
+    }
+    recordMissingOnProtect(count) {
+        this.#missingOnProtectCounter.add(count);
+    }
+    recordMissingPreviouslyEvicted(count) {
+        this.#missingPreviouslyEvictedCounter.add(count);
+    }
+}