@aztec/p2p 0.87.4 → 0.87.6

package/dest/services/tx_collector.js

@@ -0,0 +1,73 @@
+import { compactArray } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+export class TxCollector {
+    p2pClient;
+    log;
+    constructor(p2pClient, log = createLogger('p2p:tx-collector')){
+        this.p2pClient = p2pClient;
+        this.log = log;
+    }
+    async collectForBlockProposal(proposal, peerWhoSentTheProposal) {
+        if (proposal.payload.txHashes.length === 0) {
+            this.log.verbose(`Received block proposal with no transactions, skipping transaction availability check`);
+            return {
+                txs: []
+            };
+        }
+        // Is this a new style proposal?
+        if (proposal.txs && proposal.txs.length > 0 && proposal.txs.length === proposal.payload.txHashes.length) {
+            // Yes, any txs that we already have we should use
+            this.log.info(`Using new style proposal with ${proposal.txs.length} transactions`);
+            // Request from the pool based on the signed hashes in the payload
+            const hashesFromPayload = proposal.payload.txHashes;
+            const txsToUse = await this.p2pClient.getTxsByHashFromPool(hashesFromPayload);
+            const missingTxs = txsToUse.filter((tx)=>tx === undefined).length;
+            if (missingTxs > 0) {
+                this.log.verbose(`Missing ${missingTxs}/${hashesFromPayload.length} transactions in the tx pool, will attempt to take from the proposal`);
+            }
+            let usedFromProposal = 0;
+            // Fill any holes with txs in the proposal, provided their hash matches the hash in the payload
+            for(let i = 0; i < txsToUse.length; i++){
+                if (txsToUse[i] === undefined) {
+                    // We don't have the transaction, take from the proposal, provided the hash is the same
+                    const hashOfTxInProposal = await proposal.txs[i].getTxHash();
+                    if (hashOfTxInProposal.equals(hashesFromPayload[i])) {
+                        // Hash is equal, we can use the tx from the proposal
+                        txsToUse[i] = proposal.txs[i];
+                        usedFromProposal++;
+                    } else {
+                        this.log.warn(`Unable to take tx: ${hashOfTxInProposal.toString()} from the proposal, it does not match payload hash: ${hashesFromPayload[i].toString()}`);
+                    }
+                }
+            }
+            // See if we still have any holes, if there are then we were not successful and will try the old method
+            if (txsToUse.some((tx)=>tx === undefined)) {
+                this.log.warn(`Failed to use transactions from proposal. Falling back to old proposal logic`);
+            } else {
+                this.log.info(`Successfully used ${usedFromProposal}/${hashesFromPayload.length} transactions from the proposal`);
+                await this.p2pClient.validate(txsToUse);
+                return {
+                    txs: txsToUse
+                };
+            }
+        }
+        this.log.info(`Using old style proposal with ${proposal.payload.txHashes.length} transactions`);
+        // Old style proposal, we will perform a request by hash from pool
+        // This will request from network any txs that are missing
+        const txHashes = proposal.payload.txHashes;
+        // This part is just for logging that we are requesting from the network
+        const availability = await this.p2pClient.hasTxsInPool(txHashes);
+        const notAvailable = availability.filter((availability)=>availability === false);
+        if (notAvailable.length) {
+            this.log.verbose(`Missing ${notAvailable.length} transactions in the tx pool, will need to request from the network`);
+        }
+        // This will request from the network any txs that are missing
+        const retrievedTxs = await this.p2pClient.getTxsByHash(txHashes, peerWhoSentTheProposal);
+        const missingTxs = compactArray(retrievedTxs.map((tx, index)=>tx === undefined ? txHashes[index] : undefined));
+        await this.p2pClient.validate(retrievedTxs);
+        return {
+            txs: retrievedTxs,
+            missing: missingTxs
+        };
+    }
+}

package/dest/test-helpers/reqresp-nodes.d.ts

@@ -14,7 +14,7 @@ import type { BootnodeConfig } from '../config.js';
 import type { MemPools } from '../mem_pools/interface.js';
 import { LibP2PService } from '../services/libp2p/libp2p_service.js';
 import type { PeerScoring } from '../services/peer-manager/peer_scoring.js';
-import { type ReqRespSubProtocolHandlers, type ReqRespSubProtocolValidators } from '../services/reqresp/interface.js';
+import { type ReqRespSubProtocolHandlers, type ReqRespSubProtocolRateLimits, type ReqRespSubProtocolValidators } from '../services/reqresp/interface.js';
 import { ReqResp } from '../services/reqresp/reqresp.js';
 /**
  * Creates a libp2p node, pre configured.
@@ -43,10 +43,10 @@ export declare const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators;
  * @param numberOfNodes - the number of nodes to create
  * @returns An array of the created nodes
  */
-export declare const createNodes: (peerScoring: PeerScoring, numberOfNodes: number) => Promise<ReqRespNode[]>;
+export declare const createNodes: (peerScoring: PeerScoring, numberOfNodes: number, rateLimits?: Partial<ReqRespSubProtocolRateLimits>) => Promise<ReqRespNode[]>;
 export declare const startNodes: (nodes: ReqRespNode[], subProtocolHandlers?: ReqRespSubProtocolHandlers, subProtocolValidators?: ReqRespSubProtocolValidators) => Promise<void>;
 export declare const stopNodes: (nodes: ReqRespNode[]) => Promise<void>;
-export declare const createReqResp: (peerScoring: PeerScoring) => Promise<ReqRespNode>;
+export declare const createReqResp: (peerScoring: PeerScoring, rateLimits?: Partial<ReqRespSubProtocolRateLimits>) => Promise<ReqRespNode>;
 export declare const connectToPeers: (nodes: ReqRespNode[]) => Promise<void>;
 export declare class AlwaysTrueCircuitVerifier implements ClientProtocolCircuitVerifier {
     verifyProof(_tx: Tx): Promise<boolean>;

package/dest/test-helpers/reqresp-nodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reqresp-nodes.d.ts","sourceRoot":"","sources":["../../src/test-helpers/reqresp-nodes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reqresp-nodes.d.ts","sourceRoot":"","sources":["../../src/test-helpers/reqresp-nodes.ts"],"names":[],"mappings":"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"}

package/dest/test-helpers/reqresp-nodes.js

@@ -112,8 +112,8 @@ export const MOCK_SUB_PROTOCOL_VALIDATORS = {
 /**
  * @param numberOfNodes - the number of nodes to create
  * @returns An array of the created nodes
- */ export const createNodes = (peerScoring, numberOfNodes)=>{
-    return timesParallel(numberOfNodes, ()=>createReqResp(peerScoring));
+ */ export const createNodes = (peerScoring, numberOfNodes, rateLimits = {})=>{
+    return timesParallel(numberOfNodes, ()=>createReqResp(peerScoring, rateLimits));
 };
 export const startNodes = async (nodes, subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS, subProtocolValidators = MOCK_SUB_PROTOCOL_VALIDATORS)=>{
     for (const node of nodes){
@@ -128,13 +128,13 @@ export const stopNodes = async (nodes)=>{
     await Promise.all(stopPromises);
 };
 // Create a req resp node, exposing the underlying p2p node
-export const createReqResp = async (peerScoring)=>{
+export const createReqResp = async (peerScoring, rateLimits = {})=>{
     const p2p = await createLibp2pNode();
     const config = {
         overallRequestTimeoutMs: 4000,
         individualRequestTimeoutMs: 2000
     };
-    const req = new ReqResp(config, p2p, peerScoring);
+    const req = new ReqResp(config, p2p, peerScoring, rateLimits);
     return {
         p2p,
         req

package/dest/testbench/p2p_client_testbench_worker.js

@@ -33,7 +33,7 @@ function mockTxPool() {
         getTxStatus: ()=>Promise.resolve(TxStatus.PENDING),
         getTxsByHash: ()=>Promise.resolve([]),
         hasTxs: ()=>Promise.resolve([]),
-        setMaxTxPoolSize: ()=>Promise.resolve(),
+        updateConfig: ()=>{},
         markTxsAsNonEvictable: ()=>Promise.resolve()
     };
 }

package/package.json

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

package/src/client/interface.ts

@@ -1,11 +1,13 @@
 import type { L2BlockId } from '@aztec/stdlib/block';
 import type { P2PApi } from '@aztec/stdlib/interfaces/server';
-import { BlockAttestation, type BlockProposal, type P2PClientType } from '@aztec/stdlib/p2p';
+import type { BlockProposal, P2PClientType } from '@aztec/stdlib/p2p';
 import type { Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { ENR } from '@chainsafe/enr';
+import type { PeerId } from '@libp2p/interface';
 
 import type { P2PConfig } from '../config.js';
+import type { P2PBlockReceivedCallback } from '../services/service.js';
 
 /**
  * Enum defining the possible states of the p2p client.
@@ -50,14 +52,15 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApi<T> & {
    */
   // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
   // ^ This pattern is not my favorite (md)
-  registerBlockProposalHandler(handler: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void;
+  registerBlockProposalHandler(callback: P2PBlockReceivedCallback): void;
 
   /**
    * Request a list of transactions from another peer by their tx hashes.
    * @param txHashes - Hashes of the txs to query.
+   * @param pinnedPeerId - An optional peer id that will be used to request the tx from (in addition to other random peers).
    * @returns A list of transactions or undefined if the transactions are not found.
    */
-  requestTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  requestTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId): Promise<(Tx | undefined)[]>;
 
   /**
    * Request a transaction from another peer by its tx hash.
@@ -115,9 +118,10 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApi<T> & {
   /**
    * Returns transactions in the transaction pool by hash, requesting from the network if not found.
    * @param txHashes  - Hashes of tx to return.
+   * @param pinnedPeerId - An optional peer id that will be used to request the tx from (in addition to other random peers).
    * @returns An array of tx or undefined.
    */
-  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  getTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId | undefined): Promise<(Tx | undefined)[]>;
 
   /**
    * Returns an archived transaction from the transaction pool by its hash.

package/src/client/p2p_client.ts

@@ -24,6 +24,7 @@ import {
 } from '@aztec/telemetry-client';
 
 import type { ENR } from '@chainsafe/enr';
+import type { PeerId } from '@libp2p/interface';
 
 import { type P2PConfig, getP2PDefaultConfig } from '../config.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
@@ -31,6 +32,7 @@ import type { MemPools } from '../mem_pools/interface.js';
 import type { TxPool } from '../mem_pools/tx_pool/index.js';
 import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
 import type { P2PService } from '../services/service.js';
+import { TxCollector } from '../services/tx_collector.js';
 import { type P2P, P2PClientState, type P2PSyncState } from './interface.js';
 
 /**
@@ -87,6 +89,15 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     this.txPool = mempools.txPool;
     this.attestationPool = mempools.attestationPool!;
 
+    // Default to collecting all txs when we see a valid proposal
+    // This can be overridden by the validator client to attest, and it will call collectForBlockProposal on its own
+    const txCollector = new TxCollector(this, this.log);
+    this.registerBlockProposalHandler(async (block, sender) => {
+      this.log.debug(`Received block proposal from ${sender.toString()}`);
+      await txCollector.collectForBlockProposal(block, sender);
+      return undefined;
+    });
+
     // REFACTOR: Try replacing these with an L2TipsStore
     this.synchedBlockHashes = store.openMap('p2p_pool_block_hashes');
     this.synchedLatestBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
@@ -111,11 +122,9 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     return this.synchedBlockHashes.getAsync(number);
   }
 
-  public async updateP2PConfig(config: Partial<P2PConfig>): Promise<void> {
-    if (typeof config.maxTxPoolSize === 'number' && this.config.maxTxPoolSize !== config.maxTxPoolSize) {
-      await this.txPool.setMaxTxPoolSize(config.maxTxPoolSize);
-      this.config.maxTxPoolSize = config.maxTxPoolSize;
-    }
+  public updateP2PConfig(config: Partial<P2PConfig>): Promise<void> {
+    this.txPool.updateConfig(config);
+    return Promise.resolve();
   }
 
   public async getL2Tips(): Promise<L2Tips> {
@@ -328,7 +337,9 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
 
   // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
   // ^ This pattern is not my favorite (md)
-  public registerBlockProposalHandler(handler: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void {
+  public registerBlockProposalHandler(
+    handler: (block: BlockProposal, sender: any) => Promise<BlockAttestation | undefined>,
+  ): void {
     this.p2pService.registerBlockReceivedCallback(handler);
   }
 
@@ -357,7 +368,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
   /**
    * Uses the batched Request Response protocol to request a set of transactions from the network.
    */
-  public async requestTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+  public async requestTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId | undefined): Promise<(Tx | undefined)[]> {
     const timeoutMs = 8000; // Longer timeout for now
     const maxPeers = Math.min(Math.ceil(txHashes.length / 3), 10);
     const maxRetryAttempts = 10; // Keep retrying within the timeout
@@ -365,6 +376,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     const txs = await this.p2pService.sendBatchRequest(
       ReqRespSubProtocol.TX,
       txHashes,
+      pinnedPeerId,
       timeoutMs,
       maxPeers,
       maxRetryAttempts,
@@ -462,7 +474,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
    * @param txHashes - Hashes of the transactions to look for.
    * @returns The txs found, or undefined if not found in the order requested.
    */
-  async getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+  async getTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId | undefined): Promise<(Tx | undefined)[]> {
     const txs = await Promise.all(txHashes.map(txHash => this.txPool.getTxByHash(txHash)));
     const missingTxHashes = txs
       .map((tx, index) => [tx, index] as const)
@@ -473,7 +485,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
       return txs as Tx[];
     }
 
-    const missingTxs = await this.requestTxsByHash(missingTxHashes);
+    const missingTxs = await this.requestTxsByHash(missingTxHashes, pinnedPeerId);
     const fetchedMissingTxs = missingTxs.filter((tx): tx is Tx => !!tx);
 
     // TODO: optimize
@@ -678,7 +690,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
           `Requesting ${missingTxHashes.length} missing txs from peers for ${unprovenBlocks.length} unproven mined blocks`,
           { missingTxHashes, unprovenBlockNumbers: unprovenBlocks.map(block => block.number) },
         );
-        await this.requestTxsByHash(missingTxHashes);
+        await this.requestTxsByHash(missingTxHashes, undefined);
       }
     } catch (err) {
       this.log.error(`Error requesting missing txs from unproven blocks`, err, {

package/src/config.ts

@@ -1,6 +1,7 @@
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
+  floatConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
@@ -196,6 +197,16 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
    * The maximum cumulative tx size (in bytes) of pending txs before evicting lower priority txs.
    */
   maxTxPoolSize: number;
+
+  /**
+   * If the pool is full, it will still accept a few more txs until it reached maxTxPoolOverspillFactor * maxTxPoolSize. Then it will evict
+   */
+  txPoolOverflowFactor: number;
+
+  /**
+   * The node's seen message ID cache size
+   */
+  seenMessageCacheSize: number;
 }
 
 export const DEFAULT_P2P_PORT = 40400;
@@ -308,7 +319,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   gossipsubFloodPublish: {
     env: 'P2P_GOSSIPSUB_FLOOD_PUBLISH',
     description: 'Whether to flood publish messages. - For testing purposes only',
-    ...booleanConfigHelper(true),
+    ...booleanConfigHelper(false),
   },
   gossipsubMcacheLength: {
     env: 'P2P_GOSSIPSUB_MCACHE_LENGTH',
@@ -393,6 +404,16 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The maximum cumulative tx size of pending txs (in bytes) before evicting lower priority txs.',
     ...numberConfigHelper(100_000_000), // 100MB
   },
+  txPoolOverflowFactor: {
+    env: 'P2P_TX_POOL_OVERFLOW_FACTOR',
+    description: 'How much the tx pool can overflow before it starts evicting txs. Must be greater than 1',
+    ...floatConfigHelper(1.1), // 10% overflow
+  },
+  seenMessageCacheSize: {
+    env: 'P2P_SEEN_MSG_CACHE_SIZE',
+    description: 'The number of messages to keep in the seen message cache',
+    ...numberConfigHelper(100_000), // 100K
+  },
   ...p2pReqRespConfigMappings,
   ...chainConfigMappings,
 };

package/src/index.ts

@@ -1,3 +1,5 @@
+export type { PeerId } from '@libp2p/interface';
+
 export * from './bootstrap/bootstrap.js';
 export * from './client/index.js';
 export * from './enr/index.js';

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -11,11 +11,13 @@ import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
+import assert from 'assert';
+
 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';
+import type { TxPool, TxPoolOptions } from './tx_pool.js';
 
 /**
  * KV implementation of the Transaction Pool.
@@ -27,7 +29,10 @@ export class AztecKVTxPool implements TxPool {
   #txs: AztecAsyncMap<string, Buffer>;
 
   /** The maximum cumulative tx size that the pending txs in the pool take up. */
-  #maxTxPoolSize: number | undefined;
+  #maxTxPoolSize: number = 0;
+
+  /** The tx evicion logic will kick after pool size is greater than maxTxPoolSize * txPoolOverflowFactor */
+  txPoolOverflowFactor: number = 1;
 
   /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */
   #minedTxHashToBlock: AztecAsyncMap<string, number>;
@@ -63,7 +68,7 @@ export class AztecKVTxPool implements TxPool {
   #archivedTxIndices: AztecAsyncMap<number, string>;
 
   /** Number of txs to archive. */
-  #archivedTxLimit: number;
+  #archivedTxLimit: number = 0;
 
   /** The world state synchronizer used in the node. */
   #worldStateSynchronizer: WorldStateSynchronizer;
@@ -85,12 +90,12 @@ export class AztecKVTxPool implements TxPool {
     archive: AztecAsyncKVStore,
     worldStateSynchronizer: WorldStateSynchronizer,
     telemetry: TelemetryClient = getTelemetryClient(),
-    config: {
-      maxTxPoolSize?: number;
-      archivedTxLimit?: number;
-    } = {},
+    config: TxPoolOptions = {},
     log = createLogger('p2p:tx_pool'),
   ) {
+    this.#log = log;
+    this.updateConfig(config);
+
     this.#txs = store.openMap('txs');
     this.#minedTxHashToBlock = store.openMap('txHashToBlockMined');
     this.#pendingTxPriorityToHash = store.openMultiMap('pendingTxFeeToHash');
@@ -98,18 +103,16 @@ export class AztecKVTxPool implements TxPool {
     this.#pendingTxHashToHeaderHash = store.openMap('pendingTxHashToHeaderHash');
     this.#pendingTxSize = store.openSingleton('pendingTxSize');
     this.#pendingTxCount = store.openSingleton('pendingTxCount');
-    this.#maxTxPoolSize = config.maxTxPoolSize;
+
     this.#pendingTxs = new Map<string, Tx>();
     this.#nonEvictableTxs = new Set<string>();
 
     this.#archivedTxs = archive.openMap('archivedTxs');
     this.#archivedTxIndices = archive.openMap('archivedTxIndices');
-    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());
   }
 
@@ -386,9 +389,28 @@ export class AztecKVTxPool implements TxPool {
     return vals.map(x => TxHash.fromString(x));
   }
 
-  public setMaxTxPoolSize(maxSizeBytes: number | undefined): Promise<void> {
-    this.#maxTxPoolSize = maxSizeBytes;
-    return Promise.resolve();
+  public updateConfig({ maxTxPoolSize, txPoolOverflowFactor, archivedTxLimit }: TxPoolOptions): void {
+    if (typeof maxTxPoolSize === 'number') {
+      assert(maxTxPoolSize >= 0, 'maxTxPoolSize must be greater or equal to 0');
+      this.#maxTxPoolSize = maxTxPoolSize;
+
+      if (maxTxPoolSize === 0) {
+        this.#log.info(`Disabling maximum tx mempool size. Tx eviction stopped`);
+      } else {
+        this.#log.info(`Setting maximum tx mempool size`, { maxTxPoolSize });
+      }
+    }
+
+    if (typeof txPoolOverflowFactor === 'number') {
+      assert(txPoolOverflowFactor >= 1, 'txPoolOveflowFactor must be greater or equal to 1');
+      this.txPoolOverflowFactor = txPoolOverflowFactor;
+      this.#log.info(`Allowing tx pool size to grow above limit`, { maxTxPoolSize, txPoolOverflowFactor });
+    }
+
+    if (typeof archivedTxLimit === 'number') {
+      assert(archivedTxLimit >= 0, 'archivedTxLimit must be greater or equal to 0');
+      this.#archivedTxLimit = archivedTxLimit;
+    }
   }
 
   public markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void> {
@@ -483,7 +505,7 @@ export class AztecKVTxPool implements TxPool {
   private async evictLowPriorityTxs(
     newTxHashes: TxHash[],
   ): Promise<{ numLowPriorityTxsEvicted: number; numNewTxsEvicted: number }> {
-    if (this.#maxTxPoolSize === undefined) {
+    if (this.#maxTxPoolSize === undefined || this.#maxTxPoolSize === 0) {
       return { numLowPriorityTxsEvicted: 0, numNewTxsEvicted: 0 };
     }
 
@@ -491,17 +513,22 @@ export class AztecKVTxPool implements TxPool {
     const txsToEvict: TxHash[] = [];
 
     let pendingTxsSize = (await this.#pendingTxSize.getAsync()) ?? 0;
-    if (pendingTxsSize > this.#maxTxPoolSize) {
+    if (pendingTxsSize > this.#maxTxPoolSize * this.txPoolOverflowFactor) {
       for await (const txHash of this.#pendingTxPriorityToHash.valuesAsync()) {
         if (this.#nonEvictableTxs.has(txHash.toString())) {
           continue;
         }
-        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();
+
+        this.#log.verbose(`Evicting tx ${txHash} from pool due to low priority to satisfy max tx size limit`, {
+          txHash,
+          txSize,
+        });
+
+        txsToEvict.push(TxHash.fromString(txHash));
+
         if (txSize) {
           pendingTxsSize -= txSize;
           if (pendingTxsSize <= this.#maxTxPoolSize) {

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -5,7 +5,7 @@ import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-clien
 
 import { PoolInstrumentation, PoolName } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
-import type { TxPool } from './tx_pool.js';
+import type { TxPool, TxPoolOptions } from './tx_pool.js';
 
 /**
  * In-memory implementation of the Transaction Pool.
@@ -190,9 +190,7 @@ export class InMemoryTxPool implements TxPool {
     return Promise.resolve(Array.from(this.txs.keys()).map(x => TxHash.fromBigInt(x)));
   }
 
-  setMaxTxPoolSize(_maxSizeBytes: number | undefined): Promise<void> {
-    return Promise.resolve();
-  }
+  updateConfig(_config: TxPoolOptions): void {}
 
   markTxsAsNonEvictable(_: TxHash[]): Promise<void> {
     return Promise.resolve();

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,5 +1,11 @@
 import type { Tx, TxHash } from '@aztec/stdlib/tx';
 
+export type TxPoolOptions = {
+  maxTxPoolSize?: number;
+  txPoolOverflowFactor?: number;
+  archivedTxLimit?: number;
+};
+
 /**
  * Interface of a transaction pool. The pool includes tx requests and is kept up-to-date by a P2P client.
  */
@@ -95,7 +101,7 @@ export interface TxPool {
    * Configure the maximum size of the tx pool
    * @param maxSizeBytes - The maximum size in bytes of the mempool. Set to undefined to disable it
    */
-  setMaxTxPoolSize(maxSizeBytes: number | undefined): Promise<void>;
+  updateConfig(config: TxPoolOptions): void;
 
   /** Returns whether the pool is empty. */
   isEmpty(): Promise<boolean>;

package/src/msg_validators/msg_seen_validator/msg_seen_validator.ts

@@ -0,0 +1,36 @@
+// Implements a queue of message IDs
+export class MessageSeenValidator {
+  private queue: Array<string>;
+  private writePointer = 0;
+  private seenMessages: Set<string> = new Set();
+
+  constructor(private queueLength: number) {
+    if (this.queueLength <= 0) {
+      throw new Error('Queue length must be greater than 0');
+    }
+    this.queue = new Array<string>(this.queueLength);
+  }
+
+  // Adds a message if not seen before. Returns true if added, false if already seen.
+  public addMessage(msgId: string): boolean {
+    // Check if the message is already in the cache
+    if (this.seenMessages.has(msgId)) {
+      return false;
+    }
+    // If we are at the cache limit, remove the oldest msg ID
+    if (this.seenMessages.size >= this.queueLength) {
+      const msgToRemove = this.queue[this.writePointer];
+      this.seenMessages.delete(msgToRemove);
+    }
+
+    // Insert the message into the cache and the queue
+    this.seenMessages.add(msgId);
+    this.queue[this.writePointer] = msgId;
+    this.writePointer = this.writePointer === this.queueLength - 1 ? 0 : this.writePointer + 1;
+    return true;
+  }
+
+  public size() {
+    return this.seenMessages.size;
+  }
+}

package/src/services/dummy_service.ts

@@ -51,7 +51,9 @@ export class DummyP2PService implements P2PService {
   /**
    * Register a callback into the validator client for when a block proposal is received
    */
-  public registerBlockReceivedCallback(_: (block: BlockProposal) => Promise<BlockAttestation>) {}
+  public registerBlockReceivedCallback(
+    _callback: (block: BlockProposal, sender: PeerId) => Promise<BlockAttestation>,
+  ) {}
 
   /**
    * Sends a request to a peer.

package/src/services/index.ts

@@ -1,2 +1,3 @@
 export * from './service.js';
 export * from './libp2p/libp2p_service.js';
+export * from './tx_collector.js';