@aztec/p2p 0.0.1-commit.3fd054f6 → 0.0.1-commit.431c48d

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

@@ -1,6 +1,6 @@
+import { first } from '@aztec/foundation/iterable';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { ChonkProof } from '@aztec/stdlib/proofs';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 
 /**
@@ -47,8 +47,23 @@ export class TxArchive {
    * Archives transactions, stripping their proofs.
    * Evicts oldest transactions if the limit is exceeded.
    */
-  async archiveTxs(txs: Tx[]): Promise<void> {
-    if (!this.isEnabled() || txs.length === 0) {
+  archiveTxs(txs: Tx[]): Promise<void> {
+    if (!this.isEnabled()) {
+      return Promise.resolve();
+    }
+
+    return this.archiveTxBuffers(
+      txs.map(tx => ({ txHash: tx.getTxHash().toString(), buffer: tx.withoutProof().toBuffer() })),
+    );
+  }
+
+  /**
+   * Archives already-serialized proof-less tx buffers, avoiding any deserialization. This is the
+   * hot path used at finalization time, where the pool already stores txs proof-stripped.
+   * Evicts oldest transactions if the limit is exceeded.
+   */
+  async archiveTxBuffers(entries: { txHash: string; buffer: Buffer }[]): Promise<void> {
+    if (!this.isEnabled() || entries.length === 0) {
       return;
     }
 
@@ -58,7 +73,12 @@ export class TxArchive {
         let headIdx = await this.getHeadIndex();
         let tailIdx = await this.getTailIndex();
 
-        for (const tx of txs) {
+        for (const { txHash, buffer } of entries) {
+          // Skip txs that are already archived
+          if (await this.#txs.hasAsync(txHash)) {
+            continue;
+          }
+
           // Evict oldest entries if at capacity
           while (headIdx - tailIdx >= this.#limit) {
             const txHashToEvict = await this.#indices.getAsync(tailIdx);
@@ -69,15 +89,12 @@ export class TxArchive {
             tailIdx++;
           }
 
-          // Archive the transaction with stripped proof
-          const archivedTx = this.stripProof(tx);
-          const txHash = tx.getTxHash().toString();
-          await this.#txs.set(txHash, archivedTx.toBuffer());
+          await this.#txs.set(txHash, buffer);
           await this.#indices.set(headIdx, txHash);
           headIdx++;
         }
 
-        this.#log.debug(`Archived ${txs.length} txs, total: ${headIdx - tailIdx}`);
+        this.#log.debug(`Archived ${entries.length} txs, total: ${headIdx - tailIdx}`);
       });
     } catch (error) {
       this.#log.error('Error archiving transactions', { error });
@@ -101,20 +118,13 @@ export class TxArchive {
     return head - tail;
   }
 
-  /**
-   * Strips the proof from a transaction for archival.
-   */
-  private stripProof(tx: Tx): Tx {
-    return new Tx(tx.txHash, tx.data, ChonkProof.empty(), tx.contractClassLogFields, tx.publicFunctionCalldata);
-  }
-
   private async getHeadIndex(): Promise<number> {
-    const entry = await this.#indices.entriesAsync({ limit: 1, reverse: true }).next();
-    return (entry.value?.[0] ?? -1) + 1;
+    const entry = await first(this.#indices.entriesAsync({ limit: 1, reverse: true }));
+    return entry === undefined ? 0 : entry[0] + 1;
   }
 
   private async getTailIndex(): Promise<number> {
-    const entry = await this.#indices.entriesAsync({ limit: 1 }).next();
-    return entry.value?.[0] ?? 0;
+    const entry = await first(this.#indices.entriesAsync({ limit: 1 }));
+    return entry === undefined ? 0 : entry[0];
   }
 }

package/src/mem_pools/tx_pool_v2/deleted_pool.ts

@@ -52,8 +52,8 @@ export class DeletedPool {
   /** Persisted map: txHash -> DeletedTxState (serialized) - for prune-based soft deletions */
   #deletedTxsDB: AztecAsyncMap<string, Buffer>;
 
-  /** Reference to the main txs database for hard deletion */
-  #txsDB: AztecAsyncMap<string, Buffer>;
+  /** Hard-deletes a tx's stored data (tx blob and proof) from the pool's stores. */
+  #deleteTxData: (txHash: string) => Promise<void>;
 
   /** In-memory state for transactions from pruned blocks */
   #state: Map<string, DeletedTxState> = new Map();
@@ -69,10 +69,10 @@ export class DeletedPool {
 
   #log: Logger;
 
-  constructor(store: AztecAsyncKVStore, txsDB: AztecAsyncMap<string, Buffer>, log: Logger) {
+  constructor(store: AztecAsyncKVStore, deleteTxData: (txHash: string) => Promise<void>, log: Logger) {
     this.#deletedTxsDB = store.openMap('deleted_txs');
     this.#slotDeletedDB = store.openSet('slot_deleted_txs');
-    this.#txsDB = txsDB;
+    this.#deleteTxData = deleteTxData;
     this.#log = log;
   }
 
@@ -100,7 +100,7 @@ export class DeletedPool {
     // Slot-deleted txs are stale after restart - hard-delete them all
     let slotDeletedCount = 0;
     for await (const txHash of this.#slotDeletedDB.entriesAsync()) {
-      await this.#txsDB.delete(txHash);
+      await this.#deleteTxData(txHash);
       await this.#slotDeletedDB.delete(txHash);
       slotDeletedCount++;
     }
@@ -234,7 +234,7 @@ export class DeletedPool {
     for (const txHash of toHardDelete) {
       this.#state.delete(txHash);
       await this.#deletedTxsDB.delete(txHash);
-      await this.#txsDB.delete(txHash);
+      await this.#deleteTxData(txHash);
     }
 
     this.#log.debug(`Finalized ${toHardDelete.length} txs from pruned blocks at block ${finalizedBlockNumber}`, {
@@ -266,7 +266,7 @@ export class DeletedPool {
     for (const txHash of toHardDelete) {
       this.#slotDeletedTxs.delete(txHash);
       await this.#slotDeletedDB.delete(txHash);
-      await this.#txsDB.delete(txHash);
+      await this.#deleteTxData(txHash);
     }
 
     this.#log.debug(

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

@@ -69,9 +69,7 @@ export class FeePayerBalanceEvictionRule implements EvictionRule {
 
     if (txsToEvict.length > 0) {
       await pool.deleteTxs(txsToEvict, this.name);
-      this.log.debug(`Evicted ${txsToEvict.length} txs due to insufficient fee payer balance`, {
-        txHashes: txsToEvict,
-      });
+      this.log.info(`Evicted ${txsToEvict.length} txs due to insufficient fee payer balance`, { txsToEvict });
     }
 
     return {
@@ -86,7 +84,7 @@ export class FeePayerBalanceEvictionRule implements EvictionRule {
     publicStateSource: DatabasePublicStateSource,
     pool: PoolOperations,
   ): Promise<string[]> {
-    const feePayer = AztecAddress.fromString(feePayerStr);
+    const feePayer = AztecAddress.fromStringUnsafe(feePayerStr);
     const initialBalance = (
       await publicStateSource.storageRead(
         ProtocolContractAddress.FeeJuice,

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

@@ -112,8 +112,9 @@ export class FeePayerBalancePreAddRule implements PreAddRule {
     }
 
     if (txsToEvict.length > 0) {
-      this.log.debug(
-        `Accepting tx ${incomingMeta.txHash}, evicting ${txsToEvict.length} lower-priority txs due to fee payer balance`,
+      this.log.info(
+        `Accepting tx ${incomingMeta.txHash} and evicting ${txsToEvict.length} lower-priority txs due to fee payer balance`,
+        { txsToEvict },
       );
     }
 

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

@@ -21,6 +21,7 @@ export { FeePayerBalancePreAddRule } from './fee_payer_balance_pre_add_rule.js';
 export { LowPriorityPreAddRule } from './low_priority_pre_add_rule.js';
 
 // Post-event eviction rules
+export { InsufficientFeePerGasEvictionRule } from './insufficient_fee_per_gas_eviction_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';

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

@@ -0,0 +1,67 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { BlockMinFeesProvider } from '@aztec/stdlib/gas';
+
+import type { EvictionContext, EvictionResult, EvictionRule, PoolOperations } from './interfaces.js';
+import { EvictionEvent } from './interfaces.js';
+
+/**
+ * Eviction rule that removes transactions whose maxFeesPerGas no longer meets
+ * the projected minimum gas fees after a new block is mined.
+ * Uses the BlockMinFeesProvider (forward-looking) to get the projected minimum fees.
+ * Only triggers on BLOCK_MINED events.
+ */
+export class InsufficientFeePerGasEvictionRule implements EvictionRule {
+  public readonly name = 'InsufficientFeePerGas';
+
+  private log = createLogger('p2p:tx_pool_v2:insufficient_fee_per_gas_eviction_rule');
+
+  constructor(private blockMinFeesProvider: BlockMinFeesProvider) {}
+
+  async evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult> {
+    if (context.event !== EvictionEvent.BLOCK_MINED) {
+      return {
+        reason: 'insufficient_fee_per_gas',
+        success: true,
+        txsEvicted: [],
+      };
+    }
+
+    try {
+      const gasFees = await this.blockMinFeesProvider.getCurrentMinFees();
+      const txsToEvict: string[] = [];
+      const pendingTxs = pool.getPendingTxs();
+
+      for (const meta of pendingTxs) {
+        const maxFeesPerGas = meta.data.constants.txContext.gasSettings.maxFeesPerGas;
+        if (maxFeesPerGas.feePerDaGas < gasFees.feePerDaGas || maxFeesPerGas.feePerL2Gas < gasFees.feePerL2Gas) {
+          this.log.verbose(`Evicting tx ${meta.txHash} from pool due to insufficient fee per gas`, {
+            txMaxFeesPerGas: maxFeesPerGas.toInspect(),
+            blockGasFees: gasFees.toInspect(),
+          });
+          txsToEvict.push(meta.txHash);
+        }
+      }
+
+      if (txsToEvict.length > 0) {
+        this.log.info(`Evicted ${txsToEvict.length} txs with insufficient fee per gas after block mined`, {
+          txsToEvict,
+        });
+        await pool.deleteTxs(txsToEvict, this.name);
+      }
+
+      return {
+        reason: 'insufficient_fee_per_gas',
+        success: true,
+        txsEvicted: txsToEvict,
+      };
+    } catch (err) {
+      this.log.error('Failed to evict transactions with insufficient fee per gas', { err });
+      return {
+        reason: 'insufficient_fee_per_gas',
+        success: false,
+        txsEvicted: [],
+        error: new Error('Failed to evict txs with insufficient fee per gas', { cause: err }),
+      };
+    }
+  }
+}

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

@@ -50,12 +50,10 @@ export class InvalidTxsAfterMiningRule implements EvictionRule {
       }
 
       if (txsToEvict.length > 0) {
-        this.log.info(`Evicted ${txsToEvict.length} invalid txs after block mined`);
+        this.log.info(`Evicted ${txsToEvict.length} invalid txs after block mined`, { txsToEvict });
         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,

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

@@ -1,5 +1,5 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
+import { BlockHash } from '@aztec/stdlib/block';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
@@ -33,14 +33,14 @@ export class InvalidTxsAfterReorgRule implements EvictionRule {
       const pendingTxs = pool.getPendingTxs();
 
       // Deduplicate block hashes to reduce redundant DB lookups
-      const uniqueBlockHashes = new Map<string, Fr>();
+      const uniqueBlockHashes = new Map<string, BlockHash>();
       const txsByBlockHash = new Map<string, string[]>();
 
       for (const meta of pendingTxs) {
         const blockHashStr = meta.anchorBlockHeaderHash;
         if (!txsByBlockHash.has(blockHashStr)) {
           txsByBlockHash.set(blockHashStr, []);
-          uniqueBlockHashes.set(blockHashStr, Fr.fromHexString(blockHashStr));
+          uniqueBlockHashes.set(blockHashStr, BlockHash.fromString(blockHashStr));
         }
         txsByBlockHash.get(blockHashStr)!.push(meta.txHash);
       }
@@ -72,17 +72,15 @@ export class InvalidTxsAfterReorgRule implements EvictionRule {
       }
 
       if (txsToEvict.length > 0) {
-        this.log.info(`Evicting ${txsToEvict.length} txs from pool due to referencing pruned blocks`);
+        this.log.info(`Evicting ${txsToEvict.length} txs from pool referencing pruned blocks`, { txsToEvict });
         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(`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,

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

@@ -56,17 +56,16 @@ export class LowPriorityEvictionRule implements EvictionRule {
         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`);
+          this.log.info(
+            `Evicted ${txsToEvict.length} low priority txs, including ${numNewTxsEvicted} newly added txs`,
+            { txsToEvict },
+          );
         } else {
-          this.log.info(`Evicted ${txsToEvict.length} low priority txs after chain prune`);
+          this.log.info(`Evicted ${txsToEvict.length} low priority txs after chain prune`, { txsToEvict });
         }
         await pool.deleteTxs(txsToEvict, this.name);
       }
 
-      this.log.debug(`Evicted ${txsToEvict.length} low priority txs`, {
-        txHashes: txsToEvict,
-      });
-
       return {
         reason: 'low_priority',
         success: true,

package/src/mem_pools/tx_pool_v2/instrumentation.ts

@@ -1,5 +1,6 @@
 import {
   Attributes,
+  type Histogram,
   type Meter,
   Metrics,
   type ObservableGauge,
@@ -67,3 +68,29 @@ export class TxPoolV2Instrumentation {
     this.#missingPreviouslyEvictedCounter.add(count);
   }
 }
+
+/**
+ * Instrumentation for the tx pool serial queue: how long operations wait behind other queued work,
+ * how long they take to execute once running, and the current queue depth. All pool operations share
+ * a single serial queue, so contention here directly delays gossip tx validation.
+ */
+export class TxPoolQueueInstrumentation {
+  #queueWait: Histogram;
+  #queueExecution: Histogram;
+
+  constructor(telemetry: TelemetryClient, getQueueLength: () => number) {
+    const meter: Meter = telemetry.getMeter('TxPoolQueue');
+    this.#queueWait = meter.createHistogram(Metrics.MEMPOOL_TX_POOL_V2_QUEUE_WAIT);
+    this.#queueExecution = meter.createHistogram(Metrics.MEMPOOL_TX_POOL_V2_QUEUE_EXECUTION);
+    const queueLength = meter.createObservableGauge(Metrics.MEMPOOL_TX_POOL_V2_QUEUE_LENGTH);
+    queueLength.addCallback((result: ObservableResult) => {
+      result.observe(getQueueLength());
+    });
+  }
+
+  record(operation: string, waitMs: number, executionMs: number) {
+    const attributes = { [Attributes.MEMPOOL_OPERATION]: operation };
+    this.#queueWait.record(Math.ceil(waitMs), attributes);
+    this.#queueExecution.record(Math.ceil(executionMs), attributes);
+  }
+}

package/src/mem_pools/tx_pool_v2/interfaces.ts

@@ -1,6 +1,7 @@
 import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { L2Block, L2BlockId, L2BlockSource } from '@aztec/stdlib/block';
+import type { BlockMinFeesProvider } from '@aztec/stdlib/gas';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { BlockHeader, Tx, TxHash, TxValidator } from '@aztec/stdlib/tx';
 
@@ -48,6 +49,11 @@ export type TxPoolV2Config = {
   dropTransactionsProbability: number;
   /** Minimum percentage fee increase required to replace an existing tx via RPC (0 = no bump). */
   priceBumpPercentage: bigint;
+  /**
+   * Number of slots behind the finalized tip to keep finalized txs for before deleting them. 0 deletes
+   * at the finalized tip (default).
+   */
+  keepFinalizedTxsForSlots: number;
 };
 
 /**
@@ -60,6 +66,7 @@ export const DEFAULT_TX_POOL_V2_CONFIG: TxPoolV2Config = {
   evictedTxCacheSize: 10_000,
   dropTransactionsProbability: 0,
   priceBumpPercentage: 10n,
+  keepFinalizedTxsForSlots: 0,
 };
 
 /**
@@ -74,6 +81,8 @@ export type TxPoolV2Dependencies = {
   createTxValidator: () => Promise<TxValidator<TxMetaData>>;
   /** Checks whether a tx's setup-phase calls are on the allow list. Precomputed at receipt time. */
   checkAllowedSetupCalls: (tx: Tx) => Promise<boolean>;
+  /** Provides projected minimum fees for the next block. Used by eviction rules instead of stale block header fees. */
+  blockMinFeesProvider: BlockMinFeesProvider;
 };
 
 /**
@@ -167,6 +176,17 @@ export interface TxPoolV2 extends TypedEventEmitter<TxPoolV2Events> {
    */
   prepareForSlot(slotNumber: SlotNumber): Promise<void>;
 
+  /**
+   * Releases the protections a failed block proposal created and restores the txs to pending.
+   * Only clears protection entries still recorded at exactly the given slot: a tx that another,
+   * still-live proposal raised to a higher slot via {@link protectTxs} keeps its protection, and
+   * mined txs (which carry no protection entry) are left untouched. Restored txs are re-validated
+   * and resolved against nullifier conflicts before re-entering the pending indices.
+   * @param txHashes - Hashes of the proposal's txs to release.
+   * @param slotNumber - The slot the failed proposal targeted; protection is released only for this slot.
+   */
+  unprotectTxs(txHashes: TxHash[], slotNumber: SlotNumber): Promise<void>;
+
   /**
    * Handles pruned blocks during a reorg.
    * Un-mines all transactions mined in blocks beyond the given latest block
@@ -189,11 +209,11 @@ export interface TxPoolV2 extends TypedEventEmitter<TxPoolV2Events> {
    */
   handleFinalizedBlock(block: BlockHeader): Promise<void>;
 
-  /** Gets a transaction by its hash */
-  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+  /** Gets a transaction by its hash. Set `includeProof: false` to skip loading the proof from the DB. */
+  getTxByHash(txHash: TxHash, opts?: { includeProof?: boolean }): Promise<Tx | undefined>;
 
-  /** Gets multiple transactions by their hashes */
-  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  /** Gets multiple transactions by their hashes. Set `includeProof: false` to skip loading proofs from the DB. */
+  getTxsByHash(txHashes: TxHash[], opts?: { includeProof?: boolean }): Promise<(Tx | undefined)[]>;
 
   /** Checks if transactions exist in the pool */
   hasTxs(txHashes: TxHash[]): Promise<boolean[]>;
@@ -210,6 +230,13 @@ export interface TxPoolV2 extends TypedEventEmitter<TxPoolV2Events> {
   /** Gets the count of pending transactions */
   getPendingTxCount(): Promise<number>;
 
+  /**
+   * Returns whether at least `minCount` pending transactions are old enough per minTxPoolAgeMs to be eligible
+   * for block building. Stops scanning once the threshold is reached, so it is cheaper than counting all
+   * eligible txs when only a few are needed.
+   */
+  hasEligiblePendingTxs(minCount: number): Promise<boolean>;
+
   /** Gets mined transaction hashes with their block IDs */
   getMinedTxHashes(): Promise<[TxHash, L2BlockId][]>;
 

package/src/mem_pools/tx_pool_v2/tx_metadata.ts

@@ -1,12 +1,12 @@
+import { minBigint } from '@aztec/foundation/bigint';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { BlockHash, type L2BlockId } from '@aztec/stdlib/block';
-import { Gas } from '@aztec/stdlib/gas';
+import { Gas, GasFees } from '@aztec/stdlib/gas';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
 import { getFeePayerBalanceDelta } from '../../msg_validators/tx_validator/fee_payer_balance.js';
-import { getTxPriorityFee } from '../tx_pool/priority.js';
 import { type PreAddResult, TxPoolRejectionCode } from './eviction/interfaces.js';
 
 /** Validator-compatible data interface, mirroring the subset of PrivateKernelTailCircuitPublicInputs used by validators. */
@@ -23,7 +23,7 @@ export type TxMetaValidationData = {
       };
     };
     txContext: {
-      gasSettings: { gasLimits: Gas };
+      gasSettings: { gasLimits: Gas; maxFeesPerGas: GasFees };
     };
   };
 };
@@ -132,7 +132,10 @@ export async function buildTxMetaData(tx: Tx, allowedSetupCalls: boolean = true)
           globalVariables: { blockNumber: anchorBlockNumber },
         },
         txContext: {
-          gasSettings: { gasLimits: tx.data.constants.txContext.gasSettings.gasLimits },
+          gasSettings: {
+            gasLimits: tx.data.constants.txContext.gasSettings.gasLimits,
+            maxFeesPerGas: tx.data.constants.txContext.gasSettings.maxFeesPerGas,
+          },
         },
       },
     },
@@ -285,17 +288,19 @@ export function checkNullifierConflict(
 }
 
 /** Creates a stub TxMetaValidationData for tests that don't exercise validators. */
-export function stubTxMetaValidationData(overrides: { expirationTimestamp?: bigint } = {}): TxMetaValidationData {
+export function stubTxMetaValidationData(
+  overrides: { expirationTimestamp?: bigint; maxFeesPerGas?: GasFees } = {},
+): TxMetaValidationData {
   return {
     getNonEmptyNullifiers: () => [],
     expirationTimestamp: overrides.expirationTimestamp ?? 0n,
     constants: {
       anchorBlockHeader: {
-        hash: () => Promise.resolve(new BlockHash(Fr.ZERO)),
+        hash: () => Promise.resolve(BlockHash.ZERO),
         globalVariables: { blockNumber: BlockNumber(0) },
       },
       txContext: {
-        gasSettings: { gasLimits: Gas.empty() },
+        gasSettings: { gasLimits: Gas.empty(), maxFeesPerGas: overrides.maxFeesPerGas ?? GasFees.empty() },
       },
     },
   };
@@ -313,6 +318,7 @@ export function stubTxMetaData(
     expirationTimestamp?: bigint;
     anchorBlockHeaderHash?: string;
     allowedSetupCalls?: boolean;
+    maxFeesPerGas?: GasFees;
   } = {},
 ): TxMetaData {
   const txHashBigInt = Fr.fromHexString(txHash).toBigInt();
@@ -332,6 +338,12 @@ export function stubTxMetaData(
     allowedSetupCalls: overrides.allowedSetupCalls ?? true,
     receivedAt: 0,
     estimatedSizeBytes: 0,
-    data: stubTxMetaValidationData({ expirationTimestamp }),
+    data: stubTxMetaValidationData({ expirationTimestamp, maxFeesPerGas: overrides.maxFeesPerGas }),
   };
 }
+
+/** Returns the priority fee for a tx, based on the L2 priority fee capped by the max fee per gas. */
+function getTxPriorityFee(tx: Tx): bigint {
+  const { maxPriorityFeesPerGas: priorityFees, maxFeesPerGas } = tx.getGasSettings();
+  return minBigint(maxFeesPerGas.feePerL2Gas, priorityFees.feePerL2Gas);
+}

package/src/mem_pools/tx_pool_v2/tx_pool_indices.ts

@@ -131,6 +131,9 @@ export class TxPoolIndices {
     meta.minedL2BlockId = blockId;
     // Safe to call unconditionally - removeFromPendingIndices is idempotent
     this.#removeFromPendingIndices(meta);
+    // A mined tx supersedes any protection: drop the stale entry so it can't linger in the map and
+    // be matched by later protection scans.
+    this.#protectedTransactions.delete(meta.txHash);
   }
 
   /** Clears the mined status from a transaction */
@@ -225,6 +228,29 @@ export class TxPoolIndices {
     return this.#pendingByPriority.length;
   }
 
+  /**
+   * Returns whether at least `minCount` pending transactions were received at or before maxReceivedAt,
+   * i.e. are old enough to be eligible for block building. Stops as soon as the threshold is met, so it
+   * does not scan the whole pool when only a handful of eligible txs are needed. The total pending count
+   * is an upper bound on the eligible count, so a pool with fewer than `minCount` pending can never
+   * satisfy the threshold and short-circuits without scanning.
+   */
+  hasEligiblePendingTxs(maxReceivedAt: number, minCount: number): boolean {
+    if (minCount <= 0) {
+      return true;
+    }
+    if (this.#pendingByPriority.length < minCount) {
+      return false;
+    }
+    let count = 0;
+    for (const _ of this.iterateEligiblePendingByPriority('desc', maxReceivedAt)) {
+      if (++count >= minCount) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /** Gets the lowest priority pending transaction hashes (up to limit) */
   getLowestPriorityPending(limit: number): string[] {
     if (limit <= 0) {
@@ -316,6 +342,15 @@ export class TxPoolIndices {
     return result;
   }
 
+  /**
+   * From the given hashes, returns those whose protection is recorded at exactly the given slot.
+   * Used to release the protections a single block proposal created without disturbing entries a
+   * later proposal raised to a higher slot via updateProtection.
+   */
+  findProtectedTxsAtSlot(txHashes: string[], slotNumber: SlotNumber): string[] {
+    return txHashes.filter(txHash => this.#protectedTransactions.get(txHash) === slotNumber);
+  }
+
   /** Filters out transactions that are currently protected */
   filterUnprotected(txs: TxMetaData[]): TxMetaData[] {
     return txs.filter(meta => !this.#protectedTransactions.has(meta.txHash));