@aztec/p2p 0.0.1-commit.7cf39cb55 → 0.0.1-commit.808bf7f90

package/dest/mem_pools/tx_pool_v2/tx_pool_v2_impl.js

@@ -6,7 +6,8 @@ import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 import { TxArchive } from './archive/index.js';
 import { DeletedPool } from './deleted_pool.js';
-import { EvictionManager, FeePayerBalanceEvictionRule, FeePayerBalancePreAddRule, InvalidTxsAfterMiningRule, InvalidTxsAfterReorgRule, LowPriorityEvictionRule, LowPriorityPreAddRule, NullifierConflictRule } from './eviction/index.js';
+import { EvictionManager, FeePayerBalanceEvictionRule, FeePayerBalancePreAddRule, InvalidTxsAfterMiningRule, InvalidTxsAfterReorgRule, LowPriorityEvictionRule, LowPriorityPreAddRule, NullifierConflictRule, TxPoolRejectionCode } from './eviction/index.js';
+import { TxPoolV2Instrumentation } from './instrumentation.js';
 import { DEFAULT_TX_POOL_V2_CONFIG } from './interfaces.js';
 import { buildTxMetaData, checkNullifierConflict } from './tx_metadata.js';
 import { TxPoolIndices } from './tx_pool_indices.js';
@@ -30,9 +31,11 @@ import { TxPoolIndices } from './tx_pool_indices.js';
     #deletedPool;
     #evictionManager;
     #dateProvider;
+    #instrumentation;
+    #evictedTxHashes = new Set();
     #log;
     #callbacks;
-    constructor(store, archiveStore, deps, callbacks, config = {}, dateProvider, log){
+    constructor(store, archiveStore, deps, callbacks, telemetry, config = {}, dateProvider, log){
         this.#store = store;
         this.#txsDB = store.openMap('txs');
         this.#l2BlockSource = deps.l2BlockSource;
@@ -45,6 +48,7 @@ import { TxPoolIndices } from './tx_pool_indices.js';
         this.#archive = new TxArchive(archiveStore, this.#config.archivedTxLimit, log);
         this.#deletedPool = new DeletedPool(store, this.#txsDB, log);
         this.#dateProvider = dateProvider;
+        this.#instrumentation = new TxPoolV2Instrumentation(telemetry, ()=>this.#indices.getTotalMetadataBytes());
         this.#log = log;
         this.#callbacks = callbacks;
         // Setup eviction manager with rules
@@ -122,8 +126,12 @@ import { TxPoolIndices } from './tx_pool_indices.js';
         const accepted = [];
         const ignored = [];
         const rejected = [];
+        const errors = new Map();
         const acceptedPending = new Set();
         const poolAccess = this.#createPreAddPoolAccess();
+        const preAddContext = opts.feeComparisonOnly !== undefined ? {
+            feeComparisonOnly: opts.feeComparisonOnly
+        } : undefined;
         await this.#store.transactionAsync(async ()=>{
             for (const tx of txs){
                 const txHash = tx.getTxHash();
@@ -150,7 +158,7 @@ import { TxPoolIndices } from './tx_pool_indices.js';
                     accepted.push(txHash);
                 } else {
                     // Regular pending tx - validate and run pre-add rules
-                    const result = await this.#tryAddRegularPendingTx(tx, opts, poolAccess, acceptedPending, ignored);
+                    const result = await this.#tryAddRegularPendingTx(tx, opts, poolAccess, acceptedPending, ignored, errors, preAddContext);
                     if (result.status === 'accepted') {
                         acceptedPending.add(txHashStr);
                     } else if (result.status === 'rejected') {
@@ -160,26 +168,36 @@ import { TxPoolIndices } from './tx_pool_indices.js';
                     }
                 }
             }
+            // Run post-add eviction rules for pending txs (inside transaction for atomicity)
+            if (acceptedPending.size > 0) {
+                const feePayers = Array.from(acceptedPending).map((txHash)=>this.#indices.getMetadata(txHash).feePayer);
+                const uniqueFeePayers = new Set(feePayers);
+                await this.#evictionManager.evictAfterNewTxs(Array.from(acceptedPending), [
+                    ...uniqueFeePayers
+                ]);
+            }
         });
         // Build final accepted list for pending txs (excludes intra-batch evictions)
         for (const txHashStr of acceptedPending){
             accepted.push(TxHash.fromString(txHashStr));
         }
-        // Run post-add eviction rules for pending txs
-        if (acceptedPending.size > 0) {
-            const feePayers = Array.from(acceptedPending).map((txHash)=>this.#indices.getMetadata(txHash).feePayer);
-            const uniqueFeePayers = new Set(feePayers);
-            await this.#evictionManager.evictAfterNewTxs(Array.from(acceptedPending), [
-                ...uniqueFeePayers
-            ]);
+        // Record metrics
+        if (ignored.length > 0) {
+            this.#instrumentation.recordIgnored(ignored.length);
+        }
+        if (rejected.length > 0) {
+            this.#instrumentation.recordRejected(rejected.length);
         }
         return {
             accepted,
             ignored,
-            rejected
+            rejected,
+            ...errors.size > 0 ? {
+                errors
+            } : {}
         };
     }
-    /** Validates and adds a regular pending tx. Returns status. */ async #tryAddRegularPendingTx(tx, opts, poolAccess, acceptedPending, ignored) {
+    /** Validates and adds a regular pending tx. Returns status. */ async #tryAddRegularPendingTx(tx, opts, poolAccess, acceptedPending, ignored, errors, preAddContext) {
         const txHash = tx.getTxHash();
         const txHashStr = txHash.toString();
         // Build metadata and validate using metadata
@@ -190,26 +208,51 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             };
         }
         // Run pre-add rules
-        const preAddResult = await this.#evictionManager.runPreAddRules(meta, poolAccess);
+        const preAddResult = await this.#evictionManager.runPreAddRules(meta, poolAccess, preAddContext);
         if (preAddResult.shouldIgnore) {
-            this.#log.debug(`Ignoring tx ${txHashStr}: ${preAddResult.reason}`);
+            this.#log.debug(`Ignoring tx ${txHashStr}: ${preAddResult.reason?.message ?? 'unknown reason'}`);
+            if (preAddResult.reason && preAddResult.reason.code !== TxPoolRejectionCode.INTERNAL_ERROR) {
+                errors.set(txHashStr, preAddResult.reason);
+            }
             return {
                 status: 'ignored'
             };
         }
-        // Evict conflicts
-        for (const evictHashStr of preAddResult.txHashesToEvict){
-            await this.#deleteTx(evictHashStr);
-            this.#log.debug(`Evicted tx ${evictHashStr} due to higher-fee tx ${txHashStr}`, {
-                evictedTxHash: evictHashStr,
-                replacementTxHash: txHashStr
-            });
-            if (acceptedPending.has(evictHashStr)) {
-                // Evicted tx was from this batch - mark as ignored in result
-                acceptedPending.delete(evictHashStr);
-                ignored.push(TxHash.fromString(evictHashStr));
+        // Evict conflicts, grouped by rule name for metrics
+        if (preAddResult.evictions && preAddResult.evictions.length > 0) {
+            const byReason = new Map();
+            for (const { txHash: evictHash, reason } of preAddResult.evictions){
+                const group = byReason.get(reason);
+                if (group) {
+                    group.push(evictHash);
+                } else {
+                    byReason.set(reason, [
+                        evictHash
+                    ]);
+                }
+            }
+            for (const [reason, hashes] of byReason){
+                await this.#evictTxs(hashes, reason);
+            }
+            for (const evictHashStr of preAddResult.txHashesToEvict){
+                this.#log.debug(`Evicted tx ${evictHashStr} due to higher-fee tx ${txHashStr}`, {
+                    evictedTxHash: evictHashStr,
+                    replacementTxHash: txHashStr
+                });
+                if (acceptedPending.has(evictHashStr)) {
+                    // Evicted tx was from this batch - mark as ignored in result
+                    acceptedPending.delete(evictHashStr);
+                    ignored.push(TxHash.fromString(evictHashStr));
+                }
             }
         }
+        // Randomly drop the transaction for testing purposes (report as accepted so it propagates)
+        if (this.#config.dropTransactionsProbability > 0 && Math.random() < this.#config.dropTransactionsProbability) {
+            this.#log.debug(`Dropping tx ${txHashStr} (simulated drop for testing)`);
+            return {
+                status: 'accepted'
+            };
+        }
         // Add the transaction
         await this.#addTx(tx, 'pending', opts);
         return {
@@ -264,20 +307,53 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             }
         });
     }
-    protectTxs(txHashes, block) {
+    async protectTxs(txHashes, block) {
         const slotNumber = block.globalVariables.slotNumber;
         const missing = [];
-        for (const txHash of txHashes){
-            const txHashStr = txHash.toString();
-            if (this.#indices.has(txHashStr)) {
-                // Update protection for existing tx
-                this.#indices.updateProtection(txHashStr, slotNumber);
-            } else {
-                // Pre-record protection for tx we don't have yet
-                this.#indices.setProtection(txHashStr, slotNumber);
-                missing.push(txHash);
+        let softDeletedHits = 0;
+        let missingPreviouslyEvicted = 0;
+        await this.#store.transactionAsync(async ()=>{
+            for (const txHash of txHashes){
+                const txHashStr = txHash.toString();
+                if (this.#indices.has(txHashStr)) {
+                    // Update protection for existing tx
+                    this.#indices.updateProtection(txHashStr, slotNumber);
+                } else if (this.#deletedPool.isSoftDeleted(txHashStr)) {
+                    // Resurrect soft-deleted tx as protected
+                    const buffer = await this.#txsDB.getAsync(txHashStr);
+                    if (buffer) {
+                        const tx = Tx.fromBuffer(buffer);
+                        await this.#addTx(tx, {
+                            protected: slotNumber
+                        });
+                        softDeletedHits++;
+                    } else {
+                        // Data missing despite soft-delete flag — treat as truly missing
+                        this.#indices.setProtection(txHashStr, slotNumber);
+                        missing.push(txHash);
+                    }
+                } else {
+                    // Truly missing — pre-record protection for tx we don't have yet
+                    this.#indices.setProtection(txHashStr, slotNumber);
+                    missing.push(txHash);
+                    if (this.#evictedTxHashes.has(txHashStr)) {
+                        missingPreviouslyEvicted++;
+                    }
+                }
             }
+        });
+        // Record metrics
+        if (softDeletedHits > 0) {
+            this.#instrumentation.recordSoftDeletedHits(softDeletedHits);
         }
+        if (missing.length > 0) {
+            this.#log.debug(`protectTxs missing tx hashes: ${missing.map((h)=>h.toString()).join(', ')}`);
+            this.#instrumentation.recordMissingOnProtect(missing.length);
+        }
+        if (missingPreviouslyEvicted > 0) {
+            this.#instrumentation.recordMissingPreviouslyEvicted(missingPreviouslyEvicted);
+        }
+        this.#log.info(`Protected ${txHashes.length} txs, missing: ${missing.length}, soft-deleted hits: ${softDeletedHits}`);
         return missing;
     }
     async addMinedTxs(txs, block, opts) {
@@ -316,47 +392,50 @@ import { TxPoolIndices } from './tx_pool_indices.js';
                 found.push(meta);
             }
         }
-        // Step 4: Mark txs as mined (only those we have in the pool)
-        for (const meta of found){
-            this.#indices.markAsMined(meta, blockId);
-            await this.#deletedPool.clearIfMinedHigher(meta.txHash, blockId.number);
-        }
-        // Step 5: Run eviction rules (remove pending txs with conflicting nullifiers/expired timestamps)
-        await this.#evictionManager.evictAfterNewBlock(block.header, nullifiers, feePayers);
+        await this.#store.transactionAsync(async ()=>{
+            // Step 4: Mark txs as mined (only those we have in the pool)
+            for (const meta of found){
+                this.#indices.markAsMined(meta, blockId);
+                await this.#deletedPool.clearIfMinedHigher(meta.txHash, blockId.number);
+            }
+            // Step 5: Run post-event eviction rules (inside transaction for atomicity)
+            await this.#evictionManager.evictAfterNewBlock(block.header, nullifiers, feePayers);
+        });
         this.#log.info(`Marked ${found.length} txs as mined in block ${blockId.number}`);
     }
     async prepareForSlot(slotNumber) {
-        // Step 0: Clean up slot-deleted txs from previous slots
-        await this.#deletedPool.cleanupSlotDeleted(slotNumber);
-        // Step 1: Find expired protected txs
-        const expiredProtected = this.#indices.findExpiredProtectedTxs(slotNumber);
-        // Step 2: Clear protection for all expired entries (including those without metadata)
-        this.#indices.clearProtection(expiredProtected);
-        // Step 3: Filter to only txs that have metadata and are not mined
-        const txsToRestore = this.#indices.filterRestorable(expiredProtected);
-        if (txsToRestore.length === 0) {
-            return;
-        }
-        this.#log.info(`Preparing for slot ${slotNumber}: unprotecting ${txsToRestore.length} txs`);
-        // Step 4: Validate for pending pool
-        const { valid, invalid } = await this.#revalidateMetadata(txsToRestore, 'during prepareForSlot');
-        // Step 5: Resolve nullifier conflicts and add winners to pending indices
-        const { added, toEvict } = this.#applyNullifierConflictResolution(valid);
-        // Step 6: Delete invalid and evicted txs
-        await this.#deleteTxsBatch([
-            ...invalid,
-            ...toEvict
-        ]);
-        // Step 7: Run eviction rules (enforce pool size limit)
-        if (added.length > 0) {
-            const feePayers = added.map((meta)=>meta.feePayer);
-            const uniqueFeePayers = new Set(feePayers);
-            await this.#evictionManager.evictAfterNewTxs(added.map((m)=>m.txHash), [
-                ...uniqueFeePayers
-            ]);
-        }
+        await this.#store.transactionAsync(async ()=>{
+            // Step 0: Clean up slot-deleted txs from previous slots
+            await this.#deletedPool.cleanupSlotDeleted(slotNumber);
+            // Step 1: Find expired protected txs
+            const expiredProtected = this.#indices.findExpiredProtectedTxs(slotNumber);
+            // Step 2: Clear protection for all expired entries (including those without metadata)
+            this.#indices.clearProtection(expiredProtected);
+            // Step 3: Filter to only txs that have metadata and are not mined
+            const txsToRestore = this.#indices.filterRestorable(expiredProtected);
+            if (txsToRestore.length === 0) {
+                this.#log.debug(`Preparing for slot ${slotNumber}, no txs to unprotect`);
+                return;
+            }
+            this.#log.info(`Preparing for slot ${slotNumber}: unprotecting ${txsToRestore.length} txs`);
+            // Step 4: Validate for pending pool
+            const { valid, invalid } = await this.#revalidateMetadata(txsToRestore, 'during prepareForSlot');
+            // Step 5: Resolve nullifier conflicts and add winners to pending indices
+            const { added, toEvict } = this.#applyNullifierConflictResolution(valid);
+            // Step 6: Delete invalid txs and evict conflict losers
+            await this.#deleteTxsBatch(invalid);
+            await this.#evictTxs(toEvict, 'NullifierConflict');
+            // Step 7: Run eviction rules (enforce pool size limit)
+            if (added.length > 0) {
+                const feePayers = added.map((meta)=>meta.feePayer);
+                const uniqueFeePayers = new Set(feePayers);
+                await this.#evictionManager.evictAfterNewTxs(added.map((m)=>m.txHash), [
+                    ...uniqueFeePayers
+                ]);
+            }
+        });
     }
-    async handlePrunedBlocks(latestBlock) {
+    async handlePrunedBlocks(latestBlock, options) {
         // Step 1: Find transactions mined after the prune point
         const txsToUnmine = this.#indices.findTxsMinedAfter(latestBlock.number);
         if (txsToUnmine.length === 0) {
@@ -364,40 +443,48 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             return;
         }
         this.#log.info(`Handling prune to block ${latestBlock.number}: un-mining ${txsToUnmine.length} txs`);
-        // Step 2: Mark ALL un-mined txs with their original mined block number
-        // This ensures they get soft-deleted if removed later, and only hard-deleted
-        // when their original mined block is finalized
-        await this.#deletedPool.markFromPrunedBlock(txsToUnmine.map((m)=>({
-                txHash: m.txHash,
-                minedAtBlock: BlockNumber(m.minedL2BlockId.number)
-            })));
-        // Step 3: Unmine - clear mined status from metadata
-        for (const meta of txsToUnmine){
-            this.#indices.markAsUnmined(meta);
-        }
-        // Step 4: Filter out protected txs (they'll be handled by prepareForSlot)
-        const unprotectedTxs = this.#indices.filterUnprotected(txsToUnmine);
-        // Step 4: Validate for pending pool
-        const { valid, invalid } = await this.#revalidateMetadata(unprotectedTxs, 'during handlePrunedBlocks');
-        // Step 6: Resolve nullifier conflicts and add winners to pending indices
-        const { toEvict } = this.#applyNullifierConflictResolution(valid);
-        // Step 7: Delete invalid and evicted txs
-        await this.#deleteTxsBatch([
-            ...invalid,
-            ...toEvict
-        ]);
-        this.#log.info(`Handled prune to block ${latestBlock.number}: ${valid.length} txs restored to pending, ${invalid.length} invalid, ${toEvict.length} evicted due to nullifier conflicts`, {
-            txHashesRestored: valid.map((m)=>m.txHash),
-            txHashesInvalid: invalid,
-            txHashesEvicted: toEvict
+        await this.#store.transactionAsync(async ()=>{
+            // Step 2: Mark ALL un-mined txs with their original mined block number
+            // This ensures they get soft-deleted if removed later, and only hard-deleted
+            // when their original mined block is finalized
+            await this.#deletedPool.markFromPrunedBlock(txsToUnmine.map((m)=>({
+                    txHash: m.txHash,
+                    minedAtBlock: BlockNumber(m.minedL2BlockId.number)
+                })));
+            // Step 3: Unmine - clear mined status from metadata
+            for (const meta of txsToUnmine){
+                this.#indices.markAsUnmined(meta);
+            }
+            // If deleteAllTxs is set (epoch prune), delete all un-mined txs and return early
+            if (options?.deleteAllTxs) {
+                const allTxHashes = txsToUnmine.map((m)=>m.txHash);
+                await this.#deleteTxsBatch(allTxHashes);
+                this.#log.info(`Handled prune to block ${latestBlock.number} with deleteAllTxs: deleted ${allTxHashes.length} txs`);
+                return;
+            }
+            // Step 4: Filter out protected txs (they'll be handled by prepareForSlot)
+            const unprotectedTxs = this.#indices.filterUnprotected(txsToUnmine);
+            // Step 5: Validate for pending pool
+            const { valid, invalid } = await this.#revalidateMetadata(unprotectedTxs, 'during handlePrunedBlocks');
+            // Step 6: Resolve nullifier conflicts and add winners to pending indices
+            const { toEvict } = this.#applyNullifierConflictResolution(valid);
+            // Step 7: Delete invalid txs and evict conflict losers
+            await this.#deleteTxsBatch(invalid);
+            await this.#evictTxs(toEvict, 'NullifierConflict');
+            this.#log.info(`Handled prune to block ${latestBlock.number}: ${valid.length} txs restored to pending, ${invalid.length} invalid, ${toEvict.length} evicted due to nullifier conflicts`, {
+                txHashesRestored: valid.map((m)=>m.txHash),
+                txHashesInvalid: invalid,
+                txHashesEvicted: toEvict
+            });
+            // Step 8: Run eviction rules for ALL pending txs (not just restored ones)
+            // This handles cases like existing pending txs with invalid fee payer balances
+            await this.#evictionManager.evictAfterChainPrune(latestBlock.number);
         });
-        // Step 8: Run eviction rules for ALL pending txs (not just restored ones)
-        // This handles cases like existing pending txs with invalid fee payer balances
-        await this.#evictionManager.evictAfterChainPrune(latestBlock.number);
     }
     async handleFailedExecution(txHashes) {
-        // Delete failed txs
-        await this.#deleteTxsBatch(txHashes.map((h)=>h.toString()));
+        await this.#store.transactionAsync(async ()=>{
+            await this.#deleteTxsBatch(txHashes.map((h)=>h.toString()));
+        });
         this.#log.info(`Deleted ${txHashes.length} failed txs`, {
             txHashes: txHashes.map((h)=>h.toString())
         });
@@ -406,24 +493,26 @@ import { TxPoolIndices } from './tx_pool_indices.js';
         const blockNumber = block.globalVariables.blockNumber;
         // Step 1: Find mined txs at or before finalized block
         const minedTxsToFinalize = this.#indices.findTxsMinedAtOrBefore(blockNumber);
-        // Step 2: Collect mined txs for archiving (before deletion)
-        const txsToArchive = [];
-        if (this.#archive.isEnabled()) {
-            for (const txHashStr of minedTxsToFinalize){
-                const buffer = await this.#txsDB.getAsync(txHashStr);
-                if (buffer) {
-                    txsToArchive.push(Tx.fromBuffer(buffer));
+        await this.#store.transactionAsync(async ()=>{
+            // Step 2: Collect mined txs for archiving (before deletion)
+            const txsToArchive = [];
+            if (this.#archive.isEnabled()) {
+                for (const txHashStr of minedTxsToFinalize){
+                    const buffer = await this.#txsDB.getAsync(txHashStr);
+                    if (buffer) {
+                        txsToArchive.push(Tx.fromBuffer(buffer));
+                    }
                 }
             }
-        }
-        // Step 3: Delete mined txs from active pool
-        await this.#deleteTxsBatch(minedTxsToFinalize);
-        // Step 4: Finalize soft-deleted txs
-        await this.#deletedPool.finalizeBlock(blockNumber);
-        // Step 5: Archive mined txs
-        if (txsToArchive.length > 0) {
-            await this.#archive.archiveTxs(txsToArchive);
-        }
+            // Step 3: Delete mined txs from active pool
+            await this.#deleteTxsBatch(minedTxsToFinalize);
+            // Step 4: Finalize soft-deleted txs
+            await this.#deletedPool.finalizeBlock(blockNumber);
+            // Step 5: Archive mined txs
+            if (txsToArchive.length > 0) {
+                await this.#archive.archiveTxs(txsToArchive);
+            }
+        });
         if (minedTxsToFinalize.length > 0) {
             this.#log.info(`Finalized ${minedTxsToFinalize.length} mined txs from blocks up to ${blockNumber}`, {
                 txHashes: minedTxsToFinalize
@@ -528,7 +617,10 @@ import { TxPoolIndices } from './tx_pool_indices.js';
     }
     // === Metrics ===
     countTxs() {
-        return this.#indices.countTxs();
+        return {
+            ...this.#indices.countTxs(),
+            softDeleted: this.#deletedPool.getSoftDeletedCount()
+        };
     }
     // ============================================================================
     // PRIVATE HELPERS - Transaction Management
@@ -554,9 +646,11 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             this.#indices.addMined(meta);
         }
         const stateStr = typeof state === 'string' ? state : Object.keys(state)[0];
-        this.#log.verbose(`Added ${stateStr} tx ${txHashStr}`, {
+        this.#log.debug(`Added tx ${txHashStr} as ${stateStr}`, {
             eventName: 'tx-added-to-pool',
-            state: stateStr
+            txHash: txHashStr,
+            state: stateStr,
+            source: opts.source
         });
         return meta;
     }
@@ -579,6 +673,28 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             await this.#deleteTx(txHashStr);
         }
     }
+    /** Evicts transactions: records eviction metric with reason, caches hashes, then deletes. */ async #evictTxs(txHashes, reason) {
+        if (txHashes.length === 0) {
+            return;
+        }
+        this.#instrumentation.recordEvictions(txHashes.length, reason);
+        for (const txHashStr of txHashes){
+            this.#log.debug(`Evicting tx ${txHashStr}`, {
+                txHash: txHashStr,
+                reason
+            });
+            this.#addToEvictedCache(txHashStr);
+        }
+        await this.#deleteTxsBatch(txHashes);
+    }
+    /** Adds a tx hash to the bounded evicted cache, evicting the oldest entry if at capacity. */ #addToEvictedCache(txHashStr) {
+        if (this.#evictedTxHashes.size >= this.#config.evictedTxCacheSize) {
+            // FIFO eviction: remove the first (oldest) entry
+            const oldest = this.#evictedTxHashes.values().next().value;
+            this.#evictedTxHashes.delete(oldest);
+        }
+        this.#evictedTxHashes.add(txHashStr);
+    }
     // ============================================================================
     // PRIVATE HELPERS - Validation & Conflict Resolution
     // ============================================================================
@@ -717,7 +833,7 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             if (preAddResult.shouldIgnore) {
                 // Transaction rejected - mark for deletion from DB
                 rejected.push(meta.txHash);
-                this.#log.debug(`Rejected tx ${meta.txHash} during rebuild: ${preAddResult.reason}`);
+                this.#log.debug(`Rejected tx ${meta.txHash} during rebuild: ${preAddResult.reason?.message ?? 'unknown reason'}`);
                 continue;
             }
             // Evict any conflicting txs identified by pre-add rules
@@ -753,7 +869,7 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             getFeePayerPendingTxs: (feePayer)=>this.#indices.getFeePayerPendingTxs(feePayer),
             getPendingTxCount: ()=>this.#indices.getPendingTxCount(),
             getLowestPriorityPending: (limit)=>this.#indices.getLowestPriorityPending(limit),
-            deleteTxs: (txHashes)=>this.#deleteTxsBatch(txHashes)
+            deleteTxs: (txHashes, reason)=>this.#evictTxs(txHashes, reason ?? 'unknown')
         };
     }
     #createPreAddPoolAccess() {

package/dest/msg_validators/tx_validator/gas_validator.d.ts

@@ -9,4 +9,4 @@ export declare class GasTxValidator implements TxValidator<Tx> {
     validateTx(tx: Tx): Promise<TxValidationResult>;
     validateTxFee(tx: Tx): Promise<TxValidationResult>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2FzX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci9nYXNfdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUV2RixPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQU8sT0FBTyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDakQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUM3RCxPQUFPLEVBS0wsS0FBSyxFQUFFLEVBQ1AsS0FBSyxrQkFBa0IsRUFDdkIsS0FBSyxXQUFXLEVBQ2pCLE1BQU0sa0JBQWtCLENBQUM7QUFJMUIscUJBQWEsY0FBZSxZQUFXLFdBQVcsQ0FBQyxFQUFFLENBQUM7O0lBTXBELFlBQ0UsZ0JBQWdCLEVBQUUsaUJBQWlCLEVBQ25DLGVBQWUsRUFBRSxZQUFZLEVBQzdCLE9BQU8sRUFBRSxPQUFPLEVBQ2hCLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFNMUI7SUFFSyxVQUFVLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FTcEQ7SUFtRFksYUFBYSxDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBeUI5RDtDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2FzX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci9nYXNfdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUV2RixPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQU8sT0FBTyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDakQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUM3RCxPQUFPLEVBS0wsS0FBSyxFQUFFLEVBQ1AsS0FBSyxrQkFBa0IsRUFDdkIsS0FBSyxXQUFXLEVBQ2pCLE1BQU0sa0JBQWtCLENBQUM7QUFJMUIscUJBQWEsY0FBZSxZQUFXLFdBQVcsQ0FBQyxFQUFFLENBQUM7O0lBTXBELFlBQ0UsZ0JBQWdCLEVBQUUsaUJBQWlCLEVBQ25DLGVBQWUsRUFBRSxZQUFZLEVBQzdCLE9BQU8sRUFBRSxPQUFPLEVBQ2hCLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFNMUI7SUFFSyxVQUFVLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FTcEQ7SUFzRFksYUFBYSxDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBeUI5RDtDQUNGIn0=

package/dest/msg_validators/tx_validator/gas_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gas_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/gas_validator.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAO,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAKL,KAAK,EAAE,EACP,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAI1B,qBAAa,cAAe,YAAW,WAAW,CAAC,EAAE,CAAC;;IAMpD,YACE,gBAAgB,EAAE,iBAAiB,EACnC,eAAe,EAAE,YAAY,EAC7B,OAAO,EAAE,OAAO,EAChB,QAAQ,CAAC,EAAE,cAAc,EAM1B;IAEK,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CASpD;IAmDY,aAAa,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAyB9D;CACF"}
+{"version":3,"file":"gas_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/gas_validator.ts"],"names":[],"mappings":"AAMA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAO,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAKL,KAAK,EAAE,EACP,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAI1B,qBAAa,cAAe,YAAW,WAAW,CAAC,EAAE,CAAC;;IAMpD,YACE,gBAAgB,EAAE,iBAAiB,EACnC,eAAe,EAAE,YAAY,EAC7B,OAAO,EAAE,OAAO,EAChB,QAAQ,CAAC,EAAE,cAAc,EAM1B;IAEK,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CASpD;IAsDY,aAAa,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAyB9D;CACF"}

package/dest/msg_validators/tx_validator/gas_validator.js

@@ -1,4 +1,4 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS, FIXED_DA_GAS, FIXED_L2_GAS } from '@aztec/constants';
+import { MAX_PROCESSABLE_L2_GAS, PRIVATE_TX_L2_GAS_OVERHEAD, PUBLIC_TX_L2_GAS_OVERHEAD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import { Gas } from '@aztec/stdlib/gas';
@@ -52,7 +52,7 @@ export class GasTxValidator {
    * Check whether the tx's gas limit is above the minimum amount.
    */ #validateGasLimit(tx) {
         const gasLimits = tx.data.constants.txContext.gasSettings.gasLimits;
-        const minGasLimits = new Gas(FIXED_DA_GAS, FIXED_L2_GAS);
+        const minGasLimits = new Gas(TX_DA_GAS_OVERHEAD, tx.data.forPublic ? PUBLIC_TX_L2_GAS_OVERHEAD : PRIVATE_TX_L2_GAS_OVERHEAD);
         if (minGasLimits.gtAny(gasLimits)) {
             this.#log.verbose(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
                 gasLimits,
@@ -65,7 +65,7 @@ export class GasTxValidator {
                 ]
             };
         }
-        if (gasLimits.l2Gas > AVM_MAX_PROCESSABLE_L2_GAS) {
+        if (gasLimits.l2Gas > MAX_PROCESSABLE_L2_GAS) {
             this.#log.verbose(`Rejecting transaction due to the gas limit(s) being higher than the maximum processable gas`, {
                 gasLimits,
                 minGasLimits

package/dest/msg_validators/tx_validator/timestamp_validator.d.ts

@@ -8,7 +8,7 @@ export interface HasTimestampData {
         toString(): string;
     };
     data: {
-        includeByTimestamp: bigint;
+        expirationTimestamp: bigint;
         constants: {
             anchorBlockHeader: {
                 globalVariables: {
@@ -27,4 +27,4 @@ export declare class TimestampTxValidator<T extends HasTimestampData> implements
     }, bindings?: LoggerBindings);
     validateTx(tx: T): Promise<TxValidationResult>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXN0YW1wX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci90aW1lc3RhbXBfdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RixPQUFPLEVBQXlDLEtBQUssa0JBQWtCLEVBQUUsS0FBSyxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNwSCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVsRCxxREFBcUQ7QUFDckQsTUFBTSxXQUFXLGdCQUFnQjtJQUMvQixNQUFNLEVBQUU7UUFBRSxRQUFRLElBQUksTUFBTSxDQUFBO0tBQUUsQ0FBQztJQUMvQixJQUFJLEVBQUU7UUFDSixrQkFBa0IsRUFBRSxNQUFNLENBQUM7UUFDM0IsU0FBUyxFQUFFO1lBQ1QsaUJBQWlCLEVBQUU7Z0JBQ2pCLGVBQWUsRUFBRTtvQkFDZixXQUFXLEVBQUUsV0FBVyxDQUFDO2lCQUMxQixDQUFDO2FBQ0gsQ0FBQztTQUNILENBQUM7S0FDSCxDQUFDO0NBQ0g7QUFFRCxxQkFBYSxvQkFBb0IsQ0FBQyxDQUFDLFNBQVMsZ0JBQWdCLENBQUUsWUFBVyxXQUFXLENBQUMsQ0FBQyxDQUFDOztJQUluRixPQUFPLENBQUMsTUFBTTtJQURoQixZQUNVLE1BQU0sRUFBRTtRQUdkLFNBQVMsRUFBRSxNQUFNLENBQUM7UUFFbEIsV0FBVyxFQUFFLFdBQVcsQ0FBQztLQUMxQixFQUNELFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHMUI7SUFFRCxVQUFVLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FtQjdDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXN0YW1wX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci90aW1lc3RhbXBfdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RixPQUFPLEVBQXlDLEtBQUssa0JBQWtCLEVBQUUsS0FBSyxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNwSCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVsRCxxREFBcUQ7QUFDckQsTUFBTSxXQUFXLGdCQUFnQjtJQUMvQixNQUFNLEVBQUU7UUFBRSxRQUFRLElBQUksTUFBTSxDQUFBO0tBQUUsQ0FBQztJQUMvQixJQUFJLEVBQUU7UUFDSixtQkFBbUIsRUFBRSxNQUFNLENBQUM7UUFDNUIsU0FBUyxFQUFFO1lBQ1QsaUJBQWlCLEVBQUU7Z0JBQ2pCLGVBQWUsRUFBRTtvQkFDZixXQUFXLEVBQUUsV0FBVyxDQUFDO2lCQUMxQixDQUFDO2FBQ0gsQ0FBQztTQUNILENBQUM7S0FDSCxDQUFDO0NBQ0g7QUFFRCxxQkFBYSxvQkFBb0IsQ0FBQyxDQUFDLFNBQVMsZ0JBQWdCLENBQUUsWUFBVyxXQUFXLENBQUMsQ0FBQyxDQUFDOztJQUluRixPQUFPLENBQUMsTUFBTTtJQURoQixZQUNVLE1BQU0sRUFBRTtRQUdkLFNBQVMsRUFBRSxNQUFNLENBQUM7UUFFbEIsV0FBVyxFQUFFLFdBQVcsQ0FBQztLQUMxQixFQUNELFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHMUI7SUFFRCxVQUFVLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FtQjdDO0NBQ0YifQ==

package/dest/msg_validators/tx_validator/timestamp_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timestamp_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/timestamp_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAyC,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE;QAAE,QAAQ,IAAI,MAAM,CAAA;KAAE,CAAC;IAC/B,IAAI,EAAE;QACJ,kBAAkB,EAAE,MAAM,CAAC;QAC3B,SAAS,EAAE;YACT,iBAAiB,EAAE;gBACjB,eAAe,EAAE;oBACf,WAAW,EAAE,WAAW,CAAC;iBAC1B,CAAC;aACH,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,qBAAa,oBAAoB,CAAC,CAAC,SAAS,gBAAgB,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAInF,OAAO,CAAC,MAAM;IADhB,YACU,MAAM,EAAE;QAGd,SAAS,EAAE,MAAM,CAAC;QAElB,WAAW,EAAE,WAAW,CAAC;KAC1B,EACD,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAmB7C;CACF"}
+{"version":3,"file":"timestamp_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/timestamp_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAyC,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE;QAAE,QAAQ,IAAI,MAAM,CAAA;KAAE,CAAC;IAC/B,IAAI,EAAE;QACJ,mBAAmB,EAAE,MAAM,CAAC;QAC5B,SAAS,EAAE;YACT,iBAAiB,EAAE;gBACjB,eAAe,EAAE;oBACf,WAAW,EAAE,WAAW,CAAC;iBAC1B,CAAC;aACH,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,qBAAa,oBAAoB,CAAC,CAAC,SAAS,gBAAgB,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAInF,OAAO,CAAC,MAAM;IADhB,YACU,MAAM,EAAE;QAGd,SAAS,EAAE,MAAM,CAAC;QAElB,WAAW,EAAE,WAAW,CAAC;KAC1B,EACD,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAmB7C;CACF"}

package/dest/msg_validators/tx_validator/timestamp_validator.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import { TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP } from '@aztec/stdlib/tx';
+import { TX_ERROR_INVALID_EXPIRATION_TIMESTAMP } from '@aztec/stdlib/tx';
 export class TimestampTxValidator {
     values;
     #log;
@@ -8,19 +8,19 @@ export class TimestampTxValidator {
         this.#log = createLogger('p2p:tx_validator:timestamp', bindings);
     }
     validateTx(tx) {
-        const includeByTimestamp = tx.data.includeByTimestamp;
-        // If building block 1, we skip the expiration check. For details on why see the `validate_include_by_timestamp`
+        const expirationTimestamp = tx.data.expirationTimestamp;
+        // If building block 1, we skip the expiration check. For details on why see the `validate_expiration_timestamp`
         // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
         const buildingBlock1 = this.values.blockNumber === 1;
-        if (!buildingBlock1 && includeByTimestamp < this.values.timestamp) {
+        if (!buildingBlock1 && expirationTimestamp < this.values.timestamp) {
             if (tx.data.constants.anchorBlockHeader.globalVariables.blockNumber === 0) {
                 this.#log.warn(`A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`);
             }
-            this.#log.verbose(`Rejecting tx ${tx.txHash} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${this.values.timestamp}.`);
+            this.#log.verbose(`Rejecting tx ${tx.txHash} for low expiration timestamp. Tx expiration timestamp: ${expirationTimestamp}, timestamp: ${this.values.timestamp}.`);
             return Promise.resolve({
                 result: 'invalid',
                 reason: [
-                    TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP
+                    TX_ERROR_INVALID_EXPIRATION_TIMESTAMP
                 ]
             });
         } else {