@aztec/p2p 0.84.0 → 0.85.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "0.84.0",
+  "version": "0.85.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -65,16 +65,16 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.84.0",
-    "@aztec/epoch-cache": "0.84.0",
-    "@aztec/foundation": "0.84.0",
-    "@aztec/kv-store": "0.84.0",
-    "@aztec/noir-contracts.js": "0.84.0",
-    "@aztec/noir-protocol-circuits-types": "0.84.0",
-    "@aztec/protocol-contracts": "0.84.0",
-    "@aztec/simulator": "0.84.0",
-    "@aztec/stdlib": "0.84.0",
-    "@aztec/telemetry-client": "0.84.0",
+    "@aztec/constants": "0.85.0",
+    "@aztec/epoch-cache": "0.85.0",
+    "@aztec/foundation": "0.85.0",
+    "@aztec/kv-store": "0.85.0",
+    "@aztec/noir-contracts.js": "0.85.0",
+    "@aztec/noir-protocol-circuits-types": "0.85.0",
+    "@aztec/protocol-contracts": "0.85.0",
+    "@aztec/simulator": "0.85.0",
+    "@aztec/stdlib": "0.85.0",
+    "@aztec/telemetry-client": "0.85.0",
     "@chainsafe/discv5": "9.0.0",
     "@chainsafe/enr": "3.0.0",
     "@chainsafe/libp2p-gossipsub": "13.0.0",
@@ -103,7 +103,7 @@
     "xxhash-wasm": "^1.1.0"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.84.0",
+    "@aztec/archiver": "0.85.0",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.14.6",

package/src/bootstrap/bootstrap.ts

@@ -38,7 +38,7 @@ export class BootstrapNode implements P2PBootstrapApi {
       throw new Error('You need to provide a P2P IP address.');
     }
 
-    const peerIdPrivateKey = await getPeerIdPrivateKey(config, this.store);
+    const peerIdPrivateKey = await getPeerIdPrivateKey(config, this.store, this.logger);
 
     const { enr: ourEnr, peerId } = await createBootnodeENRandPeerId(
       peerIdPrivateKey,

package/src/client/factory.ts

@@ -43,7 +43,12 @@ export const createP2PClient = async <T extends P2PClientType>(
   const archive = await createStore('p2p-archive', 1, config, createLogger('p2p-archive:lmdb-v2'));
 
   const mempools: MemPools<T> = {
-    txPool: deps.txPool ?? new AztecKVTxPool(store, archive, telemetry, config.archivedTxLimit),
+    txPool:
+      deps.txPool ??
+      new AztecKVTxPool(store, archive, worldStateSynchronizer, telemetry, {
+        maxTxPoolSize: config.maxTxPoolSize,
+        archivedTxLimit: config.archivedTxLimit,
+      }),
     attestationPool:
       clientType === P2PClientType.Full
         ? ((deps.attestationPool ?? new InMemoryAttestationPool(telemetry)) as T extends P2PClientType.Full
@@ -59,7 +64,7 @@ export const createP2PClient = async <T extends P2PClientType>(
     config = await configureP2PClientAddresses(_config);
 
     // Create peer discovery service
-    const peerIdPrivateKey = await getPeerIdPrivateKey(config, store);
+    const peerIdPrivateKey = await getPeerIdPrivateKey(config, store, logger);
     const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey);
     const discoveryService = new DiscV5Service(
       peerId,

package/src/client/p2p_client.ts

@@ -372,6 +372,11 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     this.log.info('P2P client stopped.');
   }
 
+  /** Triggers a sync to the archiver. Used for testing. */
+  public async sync() {
+    await this.blockStream.sync();
+  }
+
   @trackSpan('p2pClient.broadcastProposal', async proposal => ({
     [Attributes.BLOCK_NUMBER]: proposal.blockNumber.toNumber(),
     [Attributes.SLOT_NUMBER]: proposal.slotNumber.toNumber(),
@@ -738,7 +743,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     this.log.info(
       `Detected chain prune. Removing invalid txs count=${
         txsToDelete.length
-      } newLatestBlock=${latestBlock} previousLatestBlock=${this.getSyncedLatestBlockNum()}`,
+      } newLatestBlock=${latestBlock} previousLatestBlock=${await this.getSyncedLatestBlockNum()}`,
     );
 
     // delete invalid txs (both pending and mined)

package/src/config.ts

@@ -68,6 +68,11 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
    */
   peerIdPrivateKey?: string;
 
+  /**
+   * An optional path to store generated peer id private keys. If blank, will default to storing any generated keys in the data directory.
+   */
+  peerIdPrivateKeyPath?: string;
+
   /**
    * A list of bootstrap peers to connect to.
    */
@@ -160,7 +165,9 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
    */
   peerPenaltyValues: number[];
 
-  /** Limit of transactions to archive in the tx pool. Once the archived tx limit is reached, the oldest archived txs will be purged. */
+  /**
+   *  Limit of transactions to archive in the tx pool. Once the archived tx limit is reached, the oldest archived txs will be purged.
+   */
   archivedTxLimit: number;
 
   /**
@@ -175,6 +182,11 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
 
   /** Which calls are allowed in the public setup phase of a tx. */
   txPublicSetupAllowList: AllowedElement[];
+
+  /**
+   * The maximum cumulative tx size (in bytes) of pending txs before evicting lower priority txs.
+   */
+  maxTxPoolSize: number;
 }
 
 export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
@@ -221,10 +233,16 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     env: 'PEER_ID_PRIVATE_KEY',
     description: 'An optional peer id private key. If blank, will generate a random key.',
   },
+  peerIdPrivateKeyPath: {
+    env: 'PEER_ID_PRIVATE_KEY_PATH',
+    description:
+      'An optional path to store generated peer id private keys. If blank, will default to storing any generated keys in the root of the data directory.',
+  },
   bootstrapNodes: {
     env: 'BOOTSTRAP_NODES',
     parseEnv: (val: string) => val.split(','),
     description: 'A list of bootstrap peer ENRs to connect to. Separated by commas.',
+    defaultValue: [],
   },
   bootstrapNodeEnrVersionCheck: {
     env: 'P2P_BOOTSTRAP_NODE_ENR_VERSION_CHECK',
@@ -354,6 +372,11 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     printDefault: () =>
       'AuthRegistry, FeeJuice.increase_public_balance, Token.increase_public_balance, FPC.prepare_fee',
   },
+  maxTxPoolSize: {
+    env: 'P2P_MAX_TX_POOL_SIZE',
+    description: 'The maximum cumulative tx size of pending txs (in bytes) before evicting lower priority txs.',
+    ...numberConfigHelper(100_000_000), // 100MB
+  },
   ...p2pReqRespConfigMappings,
   ...chainConfigMappings,
 };
@@ -375,7 +398,7 @@ export function getP2PDefaultConfig(): P2PConfig {
  */
 export type BootnodeConfig = Pick<
   P2PConfig,
-  'p2pIp' | 'p2pPort' | 'peerIdPrivateKey' | 'bootstrapNodes' | 'listenAddress'
+  'p2pIp' | 'p2pPort' | 'peerIdPrivateKey' | 'peerIdPrivateKeyPath' | 'bootstrapNodes' | 'listenAddress'
 > &
   Required<Pick<P2PConfig, 'p2pIp' | 'p2pPort'>> &
   Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'> &
@@ -386,6 +409,7 @@ const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
   'p2pPort',
   'listenAddress',
   'peerIdPrivateKey',
+  'peerIdPrivateKeyPath',
   'dataDirectory',
   'dataStoreMapSizeKB',
   'bootstrapNodes',

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -1,11 +1,18 @@
+import { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap, AztecAsyncSingleton } from '@aztec/kv-store';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { GasFees } from '@aztec/stdlib/gas';
+import type { MerkleTreeReadOperations, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { ClientIvcProof } from '@aztec/stdlib/proofs';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
+import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
+import { ArchiveCache } from '../../msg_validators/tx_validator/archive_cache.js';
+import { GasTxValidator } from '../../msg_validators/tx_validator/gas_validator.js';
 import { PoolInstrumentation, PoolName } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
 import type { TxPool } from './tx_pool.js';
@@ -19,12 +26,27 @@ export class AztecKVTxPool implements TxPool {
   /** Our tx pool, stored as a Map, with K: tx hash and V: the transaction. */
   #txs: AztecAsyncMap<string, Buffer>;
 
+  /** The maximum cumulative tx size that the pending txs in the pool take up. */
+  #maxTxPoolSize: number | undefined;
+
   /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */
   #minedTxHashToBlock: AztecAsyncMap<string, number>;
 
   /** Index from tx priority (stored as hex) to its tx hash, filtered by pending txs. */
   #pendingTxPriorityToHash: AztecAsyncMultiMap<string, string>;
 
+  /** Index from tx hash to its tx size (in bytes), filtered by pending txs. */
+  #pendingTxHashToSize: AztecAsyncMap<string, number>;
+
+  /** Index from tx hash to its header hash, filtered by pending txs. */
+  #pendingTxHashToHeaderHash: AztecAsyncMap<string, string>;
+
+  /** The cumulative tx size in bytes that the pending txs in the pool take up. */
+  #pendingTxSize: AztecAsyncSingleton<number>;
+
+  /** In-memory mapping of pending tx hashes to the hydrated pending tx in the pool. */
+  #pendingTxs: Map<string, Tx>;
+
   /** KV store for archived txs. */
   #archive: AztecAsyncKVStore;
 
@@ -37,6 +59,9 @@ export class AztecKVTxPool implements TxPool {
   /** Number of txs to archive. */
   #archivedTxLimit: number;
 
+  /** The world state synchronizer used in the node. */
+  #worldStateSynchronizer: WorldStateSynchronizer;
+
   #log: Logger;
 
   #metrics: PoolInstrumentation<Tx>;
@@ -52,20 +77,30 @@ export class AztecKVTxPool implements TxPool {
   constructor(
     store: AztecAsyncKVStore,
     archive: AztecAsyncKVStore,
+    worldStateSynchronizer: WorldStateSynchronizer,
     telemetry: TelemetryClient = getTelemetryClient(),
-    archivedTxLimit: number = 0,
+    config: {
+      maxTxPoolSize?: number;
+      archivedTxLimit?: number;
+    } = {},
     log = createLogger('p2p:tx_pool'),
   ) {
     this.#txs = store.openMap('txs');
     this.#minedTxHashToBlock = store.openMap('txHashToBlockMined');
     this.#pendingTxPriorityToHash = store.openMultiMap('pendingTxFeeToHash');
+    this.#pendingTxHashToSize = store.openMap('pendingTxHashToSize');
+    this.#pendingTxHashToHeaderHash = store.openMap('pendingTxHashToHeaderHash');
+    this.#pendingTxSize = store.openSingleton('pendingTxSize');
+    this.#maxTxPoolSize = config.maxTxPoolSize;
+    this.#pendingTxs = new Map<string, Tx>();
 
     this.#archivedTxs = archive.openMap('archivedTxs');
     this.#archivedTxIndices = archive.openMap('archivedTxIndices');
-    this.#archivedTxLimit = archivedTxLimit;
+    this.#archivedTxLimit = config.archivedTxLimit ?? 0;
 
     this.#store = store;
     this.#archive = archive;
+    this.#worldStateSynchronizer = worldStateSynchronizer;
     this.#log = log;
     this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, () => store.estimateSize());
   }
@@ -76,20 +111,35 @@ export class AztecKVTxPool implements TxPool {
     }
 
     let deletedPending = 0;
+    const minedNullifiers = new Set<string>();
+    const minedFeePayers = new Set<string>();
     return this.#store.transactionAsync(async () => {
+      let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       for (const hash of txHashes) {
         const key = hash.toString();
         await this.#minedTxHashToBlock.set(key, blockNumber);
 
-        const tx = await this.getTxByHash(hash);
+        const tx = await this.getPendingTxByHash(hash);
         if (tx) {
+          const nullifiers = tx.data.getNonEmptyNullifiers();
+          nullifiers.forEach(nullifier => minedNullifiers.add(nullifier.toString()));
+          minedFeePayers.add(tx.data.feePayer.toString());
+
           deletedPending++;
-          const fee = getPendingTxPriority(tx);
-          await this.#pendingTxPriorityToHash.deleteValue(fee, key);
+          pendingTxSize -= tx.getSize();
+          await this.removePendingTxIndices(tx, key);
         }
       }
       this.#metrics.recordAddedObjects(txHashes.length, 'mined');
-      this.#metrics.recordRemovedObjects(deletedPending, 'pending');
+      await this.#pendingTxSize.set(pendingTxSize);
+
+      const numTxsEvicted = await this.evictInvalidTxsAfterMining(
+        txHashes,
+        blockNumber,
+        minedNullifiers,
+        minedFeePayers,
+      );
+      this.#metrics.recordRemovedObjects(deletedPending + numTxsEvicted, 'pending');
     });
   }
 
@@ -99,21 +149,35 @@ export class AztecKVTxPool implements TxPool {
     }
 
     let markedAsPending = 0;
-    return this.#store.transactionAsync(async () => {
-      for (const hash of txHashes) {
-        const key = hash.toString();
-        await this.#minedTxHashToBlock.delete(key);
+    return this.#store
+      .transactionAsync(async () => {
+        let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
+        for (const hash of txHashes) {
+          const key = hash.toString();
+          await this.#minedTxHashToBlock.delete(key);
 
-        const tx = await this.getTxByHash(hash);
-        if (tx) {
-          await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
-          markedAsPending++;
+          // Rehydrate the tx in the in-memory pending txs mapping
+          const tx = await this.getPendingTxByHash(hash);
+          if (tx) {
+            await this.addPendingTxIndices(tx, key);
+            pendingTxSize += tx.getSize();
+            markedAsPending++;
+          }
         }
-      }
 
-      this.#metrics.recordAddedObjects(markedAsPending, 'pending');
-      this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
-    });
+        await this.#pendingTxSize.set(pendingTxSize);
+      })
+      .then(async () => {
+        const numInvalidTxsEvicted = await this.evictInvalidTxsAfterReorg(txHashes);
+        const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(txHashes);
+
+        this.#metrics.recordAddedObjects(markedAsPending - numNewTxsEvicted, 'pending');
+        this.#metrics.recordRemovedObjects(
+          numInvalidTxsEvicted + numLowPriorityTxsEvicted - numNewTxsEvicted,
+          'pending',
+        );
+        this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
+      });
   }
 
   public async getPendingTxHashes(): Promise<TxHash[]> {
@@ -180,6 +244,7 @@ export class AztecKVTxPool implements TxPool {
     );
     await this.#store.transactionAsync(async () => {
       let pendingCount = 0;
+      let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       await Promise.all(
         txs.map(async (tx, i) => {
           const { txHash, txStats } = hashesAndStats[i];
@@ -193,14 +258,21 @@ export class AztecKVTxPool implements TxPool {
 
           if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
             pendingCount++;
-            // REFACTOR: Use an lmdb conditional write to avoid race conditions with this write tx
-            await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
+            pendingTxSize += tx.getSize();
+            await this.addPendingTxIndices(tx, key);
             this.#metrics.recordSize(tx);
           }
         }),
       );
 
-      this.#metrics.recordAddedObjects(pendingCount, 'pending');
+      await this.#pendingTxSize.set(pendingTxSize);
+
+      const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(
+        hashesAndStats.map(({ txHash }) => txHash),
+      );
+
+      this.#metrics.recordAddedObjects(pendingCount - numNewTxsEvicted, 'pending');
+      this.#metrics.recordRemovedObjects(numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
     });
   }
 
@@ -209,28 +281,28 @@ export class AztecKVTxPool implements TxPool {
    * @param txHashes - An array of tx hashes to be removed from the tx pool.
    * @returns Empty promise.
    */
-  public deleteTxs(txHashes: TxHash[]): Promise<void> {
+  public deleteTxs(txHashes: TxHash[], eviction = false): Promise<void> {
     let pendingDeleted = 0;
     let minedDeleted = 0;
 
     const deletedTxs: Tx[] = [];
     const poolDbTx = this.#store.transactionAsync(async () => {
+      let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       for (const hash of txHashes) {
         const key = hash.toString();
         const tx = await this.getTxByHash(hash);
 
         if (tx) {
-          const fee = getPendingTxPriority(tx);
-          await this.#pendingTxPriorityToHash.deleteValue(fee, key);
-
           const isMined = await this.#minedTxHashToBlock.hasAsync(key);
           if (isMined) {
             minedDeleted++;
           } else {
             pendingDeleted++;
+            pendingTxSize -= tx.getSize();
+            await this.removePendingTxIndices(tx, key);
           }
 
-          if (this.#archivedTxLimit) {
+          if (!eviction && this.#archivedTxLimit) {
             deletedTxs.push(tx);
           }
 
@@ -239,6 +311,7 @@ export class AztecKVTxPool implements TxPool {
         }
       }
 
+      await this.#pendingTxSize.set(pendingTxSize);
       this.#metrics.recordRemovedObjects(pendingDeleted, 'pending');
       this.#metrics.recordRemovedObjects(minedDeleted, 'mined');
     });
@@ -268,6 +341,50 @@ export class AztecKVTxPool implements TxPool {
     return vals.map(x => TxHash.fromString(x));
   }
 
+  /**
+   * Creates a GasTxValidator instance.
+   * @param db - DB for the validator to use
+   * @returns A GasTxValidator instance
+   */
+  protected createGasTxValidator(db: MerkleTreeReadOperations): GasTxValidator {
+    return new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, GasFees.empty());
+  }
+
+  /**
+   * Creates an ArchiveCache instance.
+   * @param db - DB for the cache to use
+   * @returns An ArchiveCache instance
+   */
+  protected createArchiveCache(db: MerkleTreeReadOperations): ArchiveCache {
+    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> {
+    let key;
+    if (typeof txHash === 'string') {
+      key = txHash;
+      txHash = TxHash.fromString(txHash);
+    } else {
+      key = txHash.toString();
+    }
+
+    if (this.#pendingTxs.has(key)) {
+      return this.#pendingTxs.get(key);
+    }
+    const tx = await this.getTxByHash(txHash);
+    if (tx) {
+      this.#pendingTxs.set(key, tx);
+      return tx;
+    }
+    return undefined;
+  }
+
   /**
    * Archives a list of txs for future reference. The number of archived txs is limited by the specified archivedTxLimit.
    * @param txs - The list of transactions to archive.
@@ -300,4 +417,172 @@ export class AztecKVTxPool implements TxPool {
       }
     });
   }
+
+  /**
+   * Evicts pending txs with the lowest priority fees from the pool to accomodate the max tx count and cumulative max tx size
+   * after new txs are added.
+   *
+   * @param newTxHashes - The tx hashes of the new txs added to the pool.
+   * @returns The total number of txs evicted from the pool and the number of new txs that were evicted.
+   */
+  private async evictLowPriorityTxs(
+    newTxHashes: TxHash[],
+  ): Promise<{ numLowPriorityTxsEvicted: number; numNewTxsEvicted: number }> {
+    if (this.#maxTxPoolSize === undefined) {
+      return { numLowPriorityTxsEvicted: 0, numNewTxsEvicted: 0 };
+    }
+
+    let numNewTxsEvicted = 0;
+    const txsToEvict: TxHash[] = [];
+
+    let pendingTxsSize = (await this.#pendingTxSize.getAsync()) ?? 0;
+    if (pendingTxsSize > this.#maxTxPoolSize) {
+      for await (const txHash of this.#pendingTxPriorityToHash.valuesAsync()) {
+        this.#log.verbose(`Evicting tx ${txHash} from pool due to low priority to satisfy max tx size limit`);
+        txsToEvict.push(TxHash.fromString(txHash));
+
+        const txSize =
+          (await this.#pendingTxHashToSize.getAsync(txHash.toString())) ??
+          (await this.getPendingTxByHash(txHash))?.getSize();
+        if (txSize) {
+          pendingTxsSize -= txSize;
+          if (pendingTxsSize <= this.#maxTxPoolSize) {
+            break;
+          }
+        }
+      }
+      numNewTxsEvicted += newTxHashes.filter(txHash => txsToEvict.includes(txHash)).length;
+    }
+
+    if (txsToEvict.length > 0) {
+      await this.deleteTxs(txsToEvict, true);
+    }
+    return {
+      numLowPriorityTxsEvicted: txsToEvict.length,
+      numNewTxsEvicted,
+    };
+  }
+
+  /**
+   * Evicts invalid pending txs from the pool after a txs from a block are mined.
+   * Eviction criteria includes:
+   *   - txs with nullifiers that are already included in the mined block
+   *   - txs with an insufficient fee payer balance
+   *   - txs with a max block number lower than the mined block
+   *
+   * @param minedTxHashes - The tx hashes of the txs mined in the block.
+   * @param blockNumber - The block number of the mined block.
+   * @returns The total number of txs evicted from the pool.
+   */
+  private async evictInvalidTxsAfterMining(
+    minedTxHashes: TxHash[],
+    blockNumber: number,
+    minedNullifiers: Set<string>,
+    minedFeePayers: Set<string>,
+  ): Promise<number> {
+    if (minedTxHashes.length === 0) {
+      return 0;
+    }
+
+    // Wait for world state to be synced to at least the mined block number
+    await this.#worldStateSynchronizer.syncImmediate(blockNumber);
+
+    const db = this.#worldStateSynchronizer.getCommitted();
+    const gasTxValidator = this.createGasTxValidator(db);
+
+    const txsToEvict: TxHash[] = [];
+    for await (const txHash of this.#pendingTxPriorityToHash.valuesAsync()) {
+      const tx = await this.getPendingTxByHash(txHash);
+      if (!tx) {
+        continue;
+      }
+
+      // Evict pending txs that share nullifiers with mined txs
+      const txNullifiers = tx.data.getNonEmptyNullifiers();
+      if (txNullifiers.some(nullifier => minedNullifiers.has(nullifier.toString()))) {
+        this.#log.verbose(`Evicting tx ${txHash} from pool due to a duplicate nullifier with a mined tx`);
+        txsToEvict.push(TxHash.fromString(txHash));
+        continue;
+      }
+
+      // Evict pending txs with an insufficient fee payer balance
+      if (
+        minedFeePayers.has(tx.data.feePayer.toString()) &&
+        (await gasTxValidator.validateTxFee(tx)).result === 'invalid'
+      ) {
+        this.#log.verbose(`Evicting tx ${txHash} from pool due to an insufficient fee payer balance`);
+        txsToEvict.push(TxHash.fromString(txHash));
+        continue;
+      }
+
+      // Evict pending txs with a max block number less than or equal to the mined block
+      const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+      if (maxBlockNumber.isSome && maxBlockNumber.value.toNumber() <= blockNumber) {
+        this.#log.verbose(`Evicting tx ${txHash} from pool due to an invalid max block number`);
+        txsToEvict.push(TxHash.fromString(txHash));
+        continue;
+      }
+    }
+
+    if (txsToEvict.length > 0) {
+      await this.deleteTxs(txsToEvict, true);
+    }
+    return txsToEvict.length;
+  }
+
+  /**
+   * Evicts pending txs that no longer have valid archive roots or fee payer balances from the pool after a reorg.
+   *
+   * @param txHashes - The tx hashes of the txs that were moved from mined to pending.
+   * @returns The total number of txs evicted from the pool.
+   */
+  private async evictInvalidTxsAfterReorg(txHashes: TxHash[]): Promise<number> {
+    if (txHashes.length === 0) {
+      return 0;
+    }
+
+    await this.#worldStateSynchronizer.syncImmediate();
+    const db = this.#worldStateSynchronizer.getCommitted();
+    const archiveCache = this.createArchiveCache(db);
+    const gasTxValidator = this.createGasTxValidator(db);
+
+    const txsToEvict: TxHash[] = [];
+
+    for await (const [txHash, headerHash] of this.#pendingTxHashToHeaderHash.entriesAsync()) {
+      const tx = await this.getPendingTxByHash(txHash);
+      if (!tx) {
+        continue;
+      }
+
+      const [index] = await archiveCache.getArchiveIndices([Fr.fromString(headerHash)]);
+      if (index === undefined) {
+        this.#log.verbose(`Evicting tx ${txHash} from pool due to an invalid archive root`);
+        txsToEvict.push(TxHash.fromString(txHash));
+        continue;
+      }
+
+      if ((await gasTxValidator.validateTxFee(tx)).result === 'invalid') {
+        this.#log.verbose(`Evicting tx ${txHash} from pool due to an insufficient fee payer balance`);
+        txsToEvict.push(TxHash.fromString(txHash));
+      }
+    }
+
+    if (txsToEvict.length > 0) {
+      await this.deleteTxs(txsToEvict, true);
+    }
+    return txsToEvict.length;
+  }
+
+  private async addPendingTxIndices(tx: Tx, txHash: string): Promise<void> {
+    await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), txHash);
+    await this.#pendingTxHashToSize.set(txHash, tx.getSize());
+    await this.#pendingTxHashToHeaderHash.set(txHash, (await tx.data.constants.historicalHeader.hash()).toString());
+  }
+
+  private async removePendingTxIndices(tx: Tx, txHash: string): Promise<void> {
+    await this.#pendingTxPriorityToHash.deleteValue(getPendingTxPriority(tx), txHash);
+    await this.#pendingTxHashToSize.delete(txHash);
+    await this.#pendingTxHashToHeaderHash.delete(txHash);
+    this.#pendingTxs.delete(txHash);
+  }
 }

package/src/msg_validators/tx_validator/archive_cache.ts

@@ -0,0 +1,28 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { ArchiveSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+
+/**
+ * Implements an archive source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export class ArchiveCache implements ArchiveSource {
+  archives: Map<string, bigint>;
+
+  constructor(private db: MerkleTreeReadOperations) {
+    this.archives = new Map<string, bigint>();
+  }
+
+  public async getArchiveIndices(archives: Fr[]): Promise<(bigint | undefined)[]> {
+    const toCheckDb = archives.filter(n => !this.archives.has(n.toString()));
+    const dbHits = await this.db.findLeafIndices(MerkleTreeId.ARCHIVE, toCheckDb);
+    dbHits.forEach((x, index) => {
+      if (x !== undefined) {
+        this.archives.set(toCheckDb[index].toString(), x);
+      }
+    });
+
+    return archives.map(n => this.archives.get(n.toString()));
+  }
+}