@aztec/p2p 0.0.1-commit.fcb71a6 → 0.0.1-commit.ff7989d6c

package/src/mem_pools/attestation_pool/index.ts

@@ -1,2 +1,9 @@
-export * from './attestation_pool.js';
-export * from './memory_attestation_pool.js';
+export {
+  AttestationPool,
+  type AttestationPoolApi,
+  type TryAddResult,
+  createTestAttestationPool,
+  MAX_CHECKPOINT_PROPOSALS_PER_SLOT,
+  MAX_BLOCK_PROPOSALS_PER_POSITION,
+  MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER,
+} from './attestation_pool.js';

package/src/mem_pools/attestation_pool/mocks.ts

@@ -1,12 +1,13 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import {
-  BlockAttestation,
+  CheckpointAttestation,
   ConsensusPayload,
   SignatureDomainSeparator,
   getHashedSignaturePayloadEthSignedMessage,
 } from '@aztec/stdlib/p2p';
-import { makeL2BlockHeader } from '@aztec/stdlib/testing';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 
 import { type LocalAccount, generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 
@@ -20,26 +21,32 @@ export const generateAccount = (): LocalAccount => {
   return privateKeyToAccount(privateKey);
 };
 
-/** Mock Attestation
+/** Mock Checkpoint Attestation
  *
- * @param signer A viem signer to create a signature
+ * @param signer A Secp256k1Signer to create a signature
  * @param slot The slot number the attestation is for
- * @returns A Block Attestation
+ * @param archive The archive root (defaults to random)
+ * @param header The checkpoint header (defaults to random with given slot)
+ * @returns A Checkpoint Attestation
  */
-export const mockAttestation = (
+export const mockCheckpointAttestation = (
   signer: Secp256k1Signer,
   slot: number = 0,
   archive: Fr = Fr.random(),
-): BlockAttestation => {
-  // Use arbitrary numbers for all other than slot
-  const header = makeL2BlockHeader(1, 2, slot);
-  const payload = new ConsensusPayload(header.toCheckpointHeader(), archive);
+  header?: CheckpointHeader,
+  feeAssetPriceModifier: bigint = 0n,
+): CheckpointAttestation => {
+  header = header ?? CheckpointHeader.random({ slotNumber: SlotNumber(slot) });
+  const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier);
 
-  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(
+    payload,
+    SignatureDomainSeparator.checkpointAttestation,
+  );
   const attestationSignature = signer.sign(attestationHash);
 
-  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.checkpointProposal);
   const proposerSignature = signer.sign(proposalHash);
 
-  return new BlockAttestation(payload, attestationSignature, proposerSignature);
+  return new CheckpointAttestation(payload, attestationSignature, proposerSignature);
 };

package/src/mem_pools/index.ts

@@ -1,3 +1,6 @@
-export { type AttestationPool } from './attestation_pool/attestation_pool.js';
+export { AttestationPool, type AttestationPoolApi } from './attestation_pool/attestation_pool.js';
 export { type MemPools } from './interface.js';
+// Old TxPool exports - kept temporarily for external consumers
 export { type TxPool } from './tx_pool/tx_pool.js';
+// New TxPoolV2 exports
+export { type TxPoolV2, type TxPoolV2Config, type TxPoolV2Events, type AddTxsResult } from './tx_pool_v2/index.js';

package/src/mem_pools/instrumentation.ts

@@ -7,11 +7,12 @@ import {
   LmdbMetrics,
   type LmdbStatsCallback,
   type Meter,
+  type MetricDefinition,
   Metrics,
-  type MetricsType,
   type ObservableGauge,
   type TelemetryClient,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 export enum PoolName {
@@ -20,10 +21,10 @@ export enum PoolName {
 }
 
 type MetricsLabels = {
-  objectInMempool: MetricsType;
-  objectSize: MetricsType;
-  itemsAdded: MetricsType;
-  itemMinedDelay: MetricsType;
+  objectInMempool: MetricDefinition;
+  objectSize: MetricDefinition;
+  itemsAdded: MetricDefinition;
+  itemMinedDelay: MetricDefinition;
 };
 
 /**
@@ -85,14 +86,9 @@ export class PoolInstrumentation<PoolObject extends Gossipable> {
 
     const metricsLabels = getMetricsLabels(name);
 
-    this.objectsInMempool = this.meter.createObservableGauge(metricsLabels.objectInMempool, {
-      description: 'The current number of transactions in the mempool',
-    });
+    this.objectsInMempool = this.meter.createObservableGauge(metricsLabels.objectInMempool);
 
-    this.objectSize = this.meter.createHistogram(metricsLabels.objectSize, {
-      unit: 'By',
-      description: 'The size of transactions in the mempool',
-    });
+    this.objectSize = this.meter.createHistogram(metricsLabels.objectSize);
 
     this.dbMetrics = new LmdbMetrics(
       this.meter,
@@ -102,13 +98,9 @@ export class PoolInstrumentation<PoolObject extends Gossipable> {
       dbStats,
     );
 
-    this.addObjectCounter = this.meter.createUpDownCounter(metricsLabels.itemsAdded, {
-      description: 'The number of transactions added to the mempool',
-    });
+    this.addObjectCounter = createUpDownCounterWithDefault(this.meter, metricsLabels.itemsAdded);
 
-    this.minedDelay = this.meter.createHistogram(metricsLabels.itemMinedDelay, {
-      description: 'Delay between transaction added and evicted from the mempool',
-    });
+    this.minedDelay = this.meter.createHistogram(metricsLabels.itemMinedDelay);
 
     this.meter.addBatchObservableCallback(this.observeStats, [this.objectsInMempool]);
   }

package/src/mem_pools/interface.ts

@@ -1,10 +1,10 @@
-import type { AttestationPool } from './attestation_pool/attestation_pool.js';
-import type { TxPool } from './tx_pool/tx_pool.js';
+import type { AttestationPoolApi } from './attestation_pool/attestation_pool.js';
+import type { TxPoolV2 } from './tx_pool_v2/interfaces.js';
 
 /**
  * A interface the combines all mempools
  */
 export type MemPools = {
-  txPool: TxPool;
-  attestationPool: AttestationPool;
+  txPool: TxPoolV2;
+  attestationPool: AttestationPoolApi;
 };

package/src/mem_pools/tx_pool/README.md

@@ -24,7 +24,7 @@ The lifecycle of transactions in the pool is summarised in the following table:
 
 **Note on why Soft Delete:**
 Mined transactions are soft-deleted rather than permanently removed to support:
-1. Reorg handling — If a chain reorganization occurs, soft-deleted transactions are still available in the mempool 
+1. Reorg handling — If a chain reorganization occurs, soft-deleted transactions are still available in the mempool
 2. Slash condition detection — The epoch prune watcher needs access to transactions from pruned epochs to correctly identify data withholding slash conditions. Without soft-delete, transactions invalidated by reorgs (e.g., built on removed blocks) would be lost, causing false positives for data withholding violations.
 
 Mined transactions are permanently deleted via `cleanupDeletedMinedTxs()` once their original block is finalized on L1, ensuring theyremain available during the uncertainty window.
@@ -34,7 +34,7 @@ Alternatively, mined transactions can be permanently deleted immediately by pass
 
 | Method | Description |
 |--------|-------------|
-| `addTxs(txs, opts?)` | Adds transactions to the pool. Duplicates are ignored. Returns count of newly added txs. |
+| `addTxs(txs, opts?)` | Adds transactions to the pool. Duplicates and nullifier conflicts are handled. Returns count of newly added txs. |
 | `deleteTxs(txHashes, opts?)` | Removes transactions from the pool. Supports soft-delete for mined txs. |
 | `markAsMined(txHashes, blockHeader)` | Marks transactions as included in a block. |
 | `markMinedAsPending(txHashes, blockNumber)` | Reverts mined transactions to pending (used during reorgs). |
@@ -91,6 +91,7 @@ The pool maintains several KV maps and indexes:
 | `#txHashToHistoricalBlockHeaderHash` | Anchor block reference for each tx |
 | `#historicalHeaderToTxHash` | Index from historical block → tx hashes |
 | `#feePayerToTxHash` | Index from fee payer address → tx hashes |
+| `#pendingNullifierToTxHash` | Index from nullifier → tx hash |
 | `#archivedTxs` | Archived transactions for historical lookup |
 
 #### In-Memory Caches
@@ -117,15 +118,17 @@ The priority is stored as a hex string derived from a 32-byte buffer representat
 When `addTxs()` is called:
 
 1. Check for duplicates (skip if tx already exists)
-2. Store the serialized tx in `#txs`
-3. Index the tx by its anchor block hash
-4. If not already mined, add to pending indexes:
+2. Check for nullifier conflicts (see Nullifier Deduplication below)
+3. Store the serialized tx in `#txs`
+4. Index the tx by its anchor block hash
+5. If not already mined, add to pending indexes:
    - Priority-to-hash index (for ordering)
    - Historical header index (for reorg handling)
    - Fee payer index (for balance validation)
-5. Record metrics
-6. Trigger eviction rules for `TXS_ADDED` event
-7. Emit `txs-added` event
+   - Nullifier-to-tx-hash index (for conflict detection)
+6. Record metrics
+7. Trigger eviction rules for `TXS_ADDED` event
+8. Emit `txs-added` event
 
 ### 2. Marking as Mined
 
@@ -152,6 +155,16 @@ The `deleteTxs()` method handles two cases:
 
 Soft-deleted mined transactions are retained for potential future reference and can be permanently cleaned up later via `cleanupDeletedMinedTxs()`.
 
+### Nullifier Deduplication
+
+The pool prevents nullifier spam attacks by ensuring only one pending transaction can reference each unique nullifier. When an incoming transaction shares nullifiers with existing pending transactions:
+
+- **Higher fee wins**: If the incoming tx has a higher priority fee than ALL conflicting txs, those conflicting txs are replaced
+- **Existing tx wins on tie**: If any conflicting tx has an equal or higher fee, the incoming tx is rejected
+- **Partial overlap counts**: Even a single shared nullifier triggers conflict resolution
+
+This is enforced at entry time via the `#pendingNullifierToTxHash` index, which maps each nullifier to the tx hash that references it. The index is maintained atomically with tx additions and removals.
+
 ## Eviction System
 
 The eviction system automatically removes invalid or low-priority transactions based on configurable rules. See the [`eviction/`](eviction/) subdirectory for implementation details.
@@ -189,7 +202,7 @@ The [`EvictionManager`](eviction/eviction_manager.ts) coordinates eviction by:
 |-------|---------|---------|
 | `TXS_ADDED` | New transactions added | Enforce pool size limits |
 | `BLOCK_MINED` | Block finalized | Remove invalidated transactions |
-| `CHAIN_PRUNED` | Chain reorganization | Remove txs referencing pruned blocks |
+| `CHAIN_PRUNED` | Chain reorganization | Remove txs referencing pruned blocks and re-evaluate fee payer balances |
 
 ### Eviction Rules
 
@@ -200,7 +213,7 @@ The [`EvictionManager`](eviction/eviction_manager.ts) coordinates eviction by:
 Evicts transactions that become invalid after a block is mined:
 
 - Duplicate nullifiers: Txs with nullifiers already included in the mined block
-- Expired transactions: Txs with `includeByTimestamp` ≤ mined block timestamp
+- Expired transactions: Txs with `expirationTimestamp` ≤ mined block timestamp
 
 #### 2. `InvalidTxsAfterReorgRule`
 
@@ -211,13 +224,15 @@ Evicts transactions that reference blocks no longer in the canonical chain:
 - Checks each pending tx's anchor block hash against the archive tree
 - Removes txs whose anchor blocks are not found (pruned)
 
-#### 3. `InsufficientFeePayerBalanceRule`
+#### 3. `FeePayerBalanceEvictionRule`
 
-**Triggers on:** `BLOCK_MINED`, `CHAIN_PRUNED`
+**Triggers on:** `TXS_ADDED`, `BLOCK_MINED`, `CHAIN_PRUNED`
 
-Evicts transactions whose fee payer no longer has sufficient balance:
+Evicts low-priority transactions when a fee payer's pending fee limits exceed their Fee Juice balance:
 
-- Uses `GasTxValidator` to check fee payer balances against current world state
+- Evaluates transactions in priority order so higher-priority claims can fund lower-priority spends
+- Accounts for self-funding claims made during setup
+- Removes evictable txs that do not fit within the running balance
 
 #### 4. `LowPriorityEvictionRule`
 

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -5,8 +5,8 @@ import { toArray } from '@aztec/foundation/iterable';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { MerkleTreeReadOperations, ReadonlyWorldStateAccess } from '@aztec/stdlib/interfaces/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { MerkleTreeReadOperations, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { ChonkProof } from '@aztec/stdlib/proofs';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
 import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
@@ -18,11 +18,18 @@ import EventEmitter from 'node:events';
 import { ArchiveCache } from '../../msg_validators/tx_validator/archive_cache.js';
 import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import { EvictionManager } from './eviction/eviction_manager.js';
-import type { PendingTxInfo, TxBlockReference, TxPoolOperations } from './eviction/eviction_strategy.js';
-import { InsufficientFeePayerBalanceRule } from './eviction/insufficient_fee_payer_balance_rule.js';
+import {
+  FeePayerTxInfo,
+  type PendingTxInfo,
+  type PreAddPoolAccess,
+  type TxBlockReference,
+  type TxPoolOperations,
+} from './eviction/eviction_strategy.js';
+import { FeePayerBalanceEvictionRule } from './eviction/fee_payer_balance_eviction_rule.js';
 import { InvalidTxsAfterMiningRule } from './eviction/invalid_txs_after_mining_rule.js';
 import { InvalidTxsAfterReorgRule } from './eviction/invalid_txs_after_reorg_rule.js';
 import { LowPriorityEvictionRule } from './eviction/low_priority_eviction_rule.js';
+import { NullifierConflictPreAddRule } from './eviction/nullifier_conflict_pre_add_rule.js';
 import { getPendingTxPriority } from './priority.js';
 import type { TxPool, TxPoolEvents, TxPoolOptions } from './tx_pool.js';
 
@@ -55,7 +62,10 @@ export class AztecKVTxPool
 
   #historicalHeaderToTxHash: AztecAsyncMultiMap<string, string>;
 
-  #feePayerToTxHash: AztecAsyncMultiMap<string, string>;
+  #feePayerToBalanceEntry: AztecAsyncMultiMap<string, Buffer>;
+
+  /** Index from nullifier to pending tx hash */
+  #pendingNullifierToTxHash: AztecAsyncMap<string, string>;
 
   /** In-memory set of txs that should not be evicted from the pool. */
   #nonEvictableTxs: Set<string>;
@@ -89,7 +99,7 @@ export class AztecKVTxPool
   constructor(
     store: AztecAsyncKVStore,
     archive: AztecAsyncKVStore,
-    worldState: ReadonlyWorldStateAccess,
+    worldState: WorldStateSynchronizer,
     telemetry: TelemetryClient = getTelemetryClient(),
     config: TxPoolOptions = {},
     log = createLogger('p2p:tx_pool'),
@@ -101,13 +111,14 @@ export class AztecKVTxPool
     this.#evictionManager = new EvictionManager(this);
     this.#evictionManager.registerRule(new InvalidTxsAfterMiningRule());
     this.#evictionManager.registerRule(new InvalidTxsAfterReorgRule(worldState));
-    this.#evictionManager.registerRule(new InsufficientFeePayerBalanceRule(worldState));
+    this.#evictionManager.registerRule(new FeePayerBalanceEvictionRule(worldState));
     this.#evictionManager.registerRule(
       new LowPriorityEvictionRule({
         //NOTE: 0 effectively disables low priority eviction
         maxPoolSize: config.maxPendingTxCount ?? 0,
       }),
     );
+    this.#evictionManager.registerPreAddRule(new NullifierConflictPreAddRule());
 
     this.updateConfig(config);
 
@@ -119,7 +130,8 @@ export class AztecKVTxPool
 
     this.#pendingTxHashToHistoricalBlockHeaderHash = store.openMap('txHistoricalBlock');
     this.#historicalHeaderToTxHash = store.openMultiMap('historicalHeaderToPendingTxHash');
-    this.#feePayerToTxHash = store.openMultiMap('feePayerToPendingTxHash');
+    this.#feePayerToBalanceEntry = store.openMultiMap('feePayerToBalanceEntry');
+    this.#pendingNullifierToTxHash = store.openMap('pendingNullifierToTxHash');
 
     this.#nonEvictableTxs = new Set<string>();
 
@@ -171,7 +183,7 @@ export class AztecKVTxPool
           const key = hash.toString();
           await this.#minedTxHashToBlock.set(key, blockHeader.globalVariables.blockNumber);
 
-          const tx = await this.getPendingTxByHash(hash);
+          const tx = await this.getTxByHash(hash);
           if (tx) {
             const nullifiers = tx.data.getNonEmptyNullifiers();
 
@@ -216,8 +228,16 @@ export class AztecKVTxPool
           const key = hash.toString();
           await this.#minedTxHashToBlock.delete(key);
 
+          // Clear soft-delete metadata if this tx was previously soft-deleted,
+          // so cleanupDeletedMinedTxs won't later hard-delete it while it's pending
+          const deletedBlock = await this.#deletedMinedTxHashes.getAsync(key);
+          if (deletedBlock !== undefined) {
+            await this.#deletedMinedTxHashes.delete(key);
+            await this.#blockToDeletedMinedTxHash.deleteValue(deletedBlock, key);
+          }
+
           // Rehydrate the tx in the in-memory pending txs mapping
-          const tx = await this.getPendingTxByHash(hash);
+          const tx = await this.getTxByHash(hash);
           if (tx) {
             await this.addPendingTxIndicesInDbTx(tx, key);
           }
@@ -271,6 +291,8 @@ export class AztecKVTxPool
 
   /**
    * Adds a list of transactions to the pool. Duplicates are ignored.
+   * Handles nullifier deduplication: if an incoming tx has a nullifier conflict with
+   * existing pending txs, it will either replace them (if higher fee) or be rejected.
    * @param txs - An array of txs to be added to the pool.
    * @returns count of added transactions
    */
@@ -280,43 +302,69 @@ export class AztecKVTxPool
     }
 
     const addedTxs: Tx[] = [];
+    const uniqueFeePayers: AztecAddress[] = [];
+    const replacedTxHashes: TxHash[] = [];
     const hashesAndStats = txs.map(tx => ({ txHash: tx.getTxHash(), txStats: tx.getStats() }));
     try {
       await this.#store.transactionAsync(async () => {
-        await Promise.all(
-          txs.map(async (tx, i) => {
-            const { txHash, txStats } = hashesAndStats[i];
-            const key = txHash.toString();
-            if (await this.#txs.hasAsync(key)) {
-              this.#log.debug(`Tx ${txHash.toString()} already exists in the pool`);
-              return;
+        for (let i = 0; i < txs.length; i++) {
+          const tx = txs[i];
+          const { txHash, txStats } = hashesAndStats[i];
+          const key = txHash.toString();
+          if (await this.#txs.hasAsync(key)) {
+            this.#log.debug(`Tx ${key} already exists in the pool`);
+            continue;
+          }
+
+          const poolAccess = this.getPreAddPoolAccess();
+          const { shouldReject, txHashesToEvict } = await this.#evictionManager.runPreAddRules(tx, poolAccess);
+          if (shouldReject) {
+            continue;
+          }
+
+          for (const txHashToEvict of txHashesToEvict) {
+            const txToDelete = await this.getTxByHash(txHashToEvict);
+            if (txToDelete) {
+              const evictedKey = txHashToEvict.toString();
+              await this.deletePendingTxInDbTx(txToDelete, evictedKey);
+              replacedTxHashes.push(txHashToEvict);
+              this.#log.verbose(`Evicted tx ${evictedKey} due to higher-fee tx ${key}`);
             }
+          }
 
-            this.#log.verbose(`Adding tx ${txHash.toString()} to pool`, {
-              eventName: 'tx-added-to-pool',
-              ...txStats,
-            } satisfies TxAddedToPoolStats);
+          this.#log.verbose(`Adding tx ${key} to pool`, {
+            eventName: 'tx-added-to-pool',
+            ...txStats,
+          } satisfies TxAddedToPoolStats);
 
-            await this.#txs.set(key, tx.toBuffer());
-            addedTxs.push(tx as Tx);
-            await this.#pendingTxHashToHistoricalBlockHeaderHash.set(
-              key,
-              (await tx.data.constants.anchorBlockHeader.hash()).toString(),
-            );
+          await this.#txs.set(key, tx.toBuffer());
+          addedTxs.push(tx);
+          insertIntoSortedArray(uniqueFeePayers, tx.data.feePayer, (a, b) => a.toField().cmp(b.toField()), false);
 
-            if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
-              await this.addPendingTxIndicesInDbTx(tx, key);
-              this.#metrics.recordSize(tx);
-            }
-          }),
-        );
+          await this.#pendingTxHashToHistoricalBlockHeaderHash.set(
+            key,
+            (await tx.data.constants.anchorBlockHeader.hash()).toString(),
+          );
+
+          if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
+            await this.addPendingTxIndicesInDbTx(tx, key);
+            this.#metrics.recordSize(tx);
+          }
+        }
       });
 
-      await this.#evictionManager.evictAfterNewTxs(addedTxs.map(({ txHash }) => txHash));
+      await this.#evictionManager.evictAfterNewTxs(
+        addedTxs.map(({ txHash }) => txHash),
+        uniqueFeePayers,
+      );
     } catch (err) {
       this.#log.warn('Unexpected error when adding txs', { err });
     }
 
+    if (replacedTxHashes.length > 0) {
+      this.#metrics.transactionsRemoved(replacedTxHashes.map(hash => hash.toBigInt()));
+    }
+
     if (addedTxs.length > 0) {
       this.#metrics.transactionsAdded(addedTxs);
       this.emit('txs-added', { ...opts, txs: addedTxs });
@@ -348,7 +396,7 @@ export class AztecKVTxPool
         const minedBlockNumber = await this.#minedTxHashToBlock.getAsync(key);
         const txIsPending = minedBlockNumber === undefined;
         if (txIsPending) {
-          await this.deletePendingTx(tx, key);
+          await this.deletePendingTxInDbTx(tx, key);
         } else {
           await this.deleteMinedTx(key, minedBlockNumber!, opts?.permanently ?? false);
           const shouldArchiveTx = this.#archivedTxLimit && !opts?.permanently;
@@ -378,10 +426,11 @@ export class AztecKVTxPool
     await this.#blockToDeletedMinedTxHash.set(minedBlockNumber, txHash);
   }
 
-  private async deletePendingTx(tx: Tx, txHash: `0x${string}`) {
+  // Assumes being called within a DB transaction
+  private async deletePendingTxInDbTx(tx: Tx, txHash: `0x${string}`) {
     // We always permanently delete pending transactions
     this.#log.trace(`Deleting pending tx ${txHash} from pool`);
-    await this.removePendingTxIndices(tx, txHash);
+    await this.removePendingTxIndicesInDbTx(tx, txHash);
     await this.#txs.delete(txHash);
     await this.#pendingTxHashToHistoricalBlockHeaderHash.delete(txHash);
   }
@@ -414,7 +463,7 @@ export class AztecKVTxPool
     let historicalBlockHash = await this.#pendingTxHashToHistoricalBlockHeaderHash.getAsync(txHash.toString());
     // Not all tx might have this index created.
     if (!historicalBlockHash) {
-      const tx = await this.getPendingTxByHash(txHash);
+      const tx = await this.getTxByHash(txHash);
       if (!tx) {
         this.#log.warn(`PendingTxInfo:tx ${txHash} not found`);
         return undefined;
@@ -447,15 +496,21 @@ export class AztecKVTxPool
     return result;
   }
 
-  public async getPendingTxsWithFeePayer(feePayers: AztecAddress[]): Promise<PendingTxInfo[]> {
-    const result: PendingTxInfo[] = [];
-    for (const feePayer of feePayers) {
-      const chunk = await toArray(this.#feePayerToTxHash.getValuesAsync(feePayer.toString()));
-      const infos = await Promise.all(chunk.map(txHash => this.getPendingTxInfo(TxHash.fromString(txHash))));
-      result.push(...infos.filter((info): info is PendingTxInfo => info !== undefined));
+  public async getPendingFeePayers(): Promise<AztecAddress[]> {
+    const feePayers: AztecAddress[] = [];
+    for await (const feePayer of this.#feePayerToBalanceEntry.keysAsync()) {
+      const address = AztecAddress.fromString(feePayer);
+      insertIntoSortedArray(feePayers, address, (a, b) => a.toField().cmp(b.toField()), false);
     }
+    return feePayers;
+  }
 
-    return result;
+  public async *getFeePayerTxInfos(feePayer: AztecAddress): AsyncIterable<FeePayerTxInfo> {
+    for await (const value of this.#feePayerToBalanceEntry.getValuesAsync(feePayer.toString())) {
+      const info = FeePayerTxInfo.decode(value);
+      info.isEvictable = !this.#nonEvictableTxs.has(info.txHash.toString());
+      yield info;
+    }
   }
 
   public async getMinedTxHashes(): Promise<[TxHash, BlockNumber][]> {
@@ -565,24 +620,6 @@ export class AztecKVTxPool
     return new ArchiveCache(db);
   }
 
-  /**
-   * Checks if a cached transaction exists in the in-memory pending tx pool and returns it.
-   * Otherwise, it checks the tx pool, updates the pending tx pool, and returns the tx.
-   * @param txHash - The generated tx hash.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */
-  private async getPendingTxByHash(txHash: TxHash | string): Promise<Tx | undefined> {
-    if (typeof txHash === 'string') {
-      txHash = TxHash.fromString(txHash);
-    }
-
-    const tx = await this.getTxByHash(txHash);
-    if (tx) {
-      return tx;
-    }
-    return undefined;
-  }
-
   /**
    * Archives a list of txs for future reference. The number of archived txs is limited by the specified archivedTxLimit.
    * Note: Pending txs should not be archived, only finalized txs
@@ -640,13 +677,13 @@ export class AztecKVTxPool
   private async addPendingTxIndicesInDbTx(tx: Tx, txHash: string): Promise<void> {
     await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), txHash);
     await this.#historicalHeaderToTxHash.set((await tx.data.constants.anchorBlockHeader.hash()).toString(), txHash);
-    await this.#feePayerToTxHash.set(tx.data.feePayer.toString(), txHash);
-  }
+    await this.#feePayerToBalanceEntry.set(tx.data.feePayer.toString(), await FeePayerTxInfo.encode(tx, txHash));
 
-  private async addPendingTxIndices(tx: Tx, txHash: string): Promise<void> {
-    return await this.#store.transactionAsync(async () => {
-      await this.addPendingTxIndicesInDbTx(tx, txHash);
-    });
+    // Add nullifier entries for conflict detection
+    const nullifiers = tx.data.getNonEmptyNullifiers();
+    for (const nullifier of nullifiers) {
+      await this.#pendingNullifierToTxHash.set(nullifier.toString(), txHash);
+    }
   }
 
   // Assumes being called within a DB transaction
@@ -656,13 +693,16 @@ export class AztecKVTxPool
       (await tx.data.constants.anchorBlockHeader.hash()).toString(),
       txHash,
     );
-    await this.#feePayerToTxHash.deleteValue(tx.data.feePayer.toString(), txHash);
-  }
+    await this.#feePayerToBalanceEntry.deleteValue(
+      tx.data.feePayer.toString(),
+      await FeePayerTxInfo.encode(tx, txHash),
+    );
 
-  private async removePendingTxIndices(tx: Tx, txHash: string): Promise<void> {
-    return await this.#store.transactionAsync(async () => {
-      await this.removePendingTxIndicesInDbTx(tx, txHash);
-    });
+    // Remove nullifier entries
+    const nullifiers = tx.data.getNonEmptyNullifiers();
+    for (const nullifier of nullifiers) {
+      await this.#pendingNullifierToTxHash.delete(nullifier.toString());
+    }
   }
 
   /**
@@ -688,4 +728,19 @@ export class AztecKVTxPool
 
     return txsToEvict;
   }
+
+  /**
+   * Creates a PreAddPoolAccess object for use by pre-add eviction rules.
+   * Provides read-only access to pool state during addTxs transaction.
+   */
+  private getPreAddPoolAccess(): PreAddPoolAccess {
+    return {
+      getTxHashByNullifier: async nullifier => {
+        const hashStr = await this.#pendingNullifierToTxHash.getAsync(nullifier.toString());
+        return hashStr ? TxHash.fromString(hashStr) : undefined;
+      },
+      getPendingTxByHash: this.getTxByHash.bind(this),
+      getTxPriority: getPendingTxPriority,
+    };
+  }
 }