@aztec/p2p 0.87.5 → 0.87.7

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';

package/src/services/libp2p/instrumentation.ts

@@ -0,0 +1,39 @@
+import type { Timer } from '@aztec/foundation/timer';
+import type { TopicType } from '@aztec/stdlib/p2p';
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+export class P2PInstrumentation {
+  private messageValidationDuration: Histogram;
+  private messagePrevalidationCount: UpDownCounter;
+
+  constructor(client: TelemetryClient, name: string) {
+    const meter = client.getMeter(name);
+
+    this.messageValidationDuration = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_VALIDATION_DURATION, {
+      unit: 'ms',
+      description: 'How long validating a gossiped message takes',
+      valueType: ValueType.INT,
+    });
+
+    this.messagePrevalidationCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_MESSAGE_PREVALIDATION_COUNT, {
+      description: 'How many message pass/fail prevalidation',
+      valueType: ValueType.INT,
+    });
+  }
+
+  public recordMessageValidation(topicName: TopicType, timerOrMs: Timer | number) {
+    const ms = typeof timerOrMs === 'number' ? timerOrMs : timerOrMs.ms();
+    this.messageValidationDuration.record(Math.ceil(ms), { [Attributes.TOPIC_NAME]: topicName });
+  }
+
+  public incMessagePrevalidationStatus(passed: boolean, topicName: TopicType | undefined) {
+    this.messagePrevalidationCount.add(1, { [Attributes.TOPIC_NAME]: topicName, [Attributes.OK]: passed });
+  }
+}

package/src/services/libp2p/libp2p_service.ts

@@ -2,6 +2,7 @@ import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { createLibp2pComponentLogger, createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import { Timer } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import type { L2BlockSource } from '@aztec/stdlib/block';
@@ -48,6 +49,7 @@ import { createLibp2p } from 'libp2p';
 import type { P2PConfig } from '../../config.js';
 import type { MemPools } from '../../mem_pools/interface.js';
 import { AttestationValidator, BlockProposalValidator } from '../../msg_validators/index.js';
+import { MessageSeenValidator } from '../../msg_validators/msg_seen_validator/msg_seen_validator.js';
 import { getDefaultAllowedSetupFunctions } from '../../msg_validators/tx_validator/allowed_public_setup.js';
 import { type MessageValidator, createTxMessageValidators } from '../../msg_validators/tx_validator/factory.js';
 import { DoubleSpendTxValidator, TxProofValidator } from '../../msg_validators/tx_validator/index.js';
@@ -63,7 +65,8 @@ import { DEFAULT_SUB_PROTOCOL_VALIDATORS, ReqRespSubProtocol, type SubProtocolMa
 import { reqGoodbyeHandler } from '../reqresp/protocols/goodbye.js';
 import { pingHandler, reqRespBlockHandler, reqRespTxHandler, statusHandler } from '../reqresp/protocols/index.js';
 import { ReqResp } from '../reqresp/reqresp.js';
-import type { P2PService, PeerDiscoveryService } from '../service.js';
+import type { P2PBlockReceivedCallback, P2PService, PeerDiscoveryService } from '../service.js';
+import { P2PInstrumentation } from './instrumentation.js';
 
 interface ValidationResult {
   name: string;
@@ -80,6 +83,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   private jobQueue: SerialQueue = new SerialQueue();
   private peerManager: PeerManager;
   private discoveryRunningPromise?: RunningPromise;
+  private msgIdSeenValidators: Record<TopicType, MessageSeenValidator> = {} as Record<TopicType, MessageSeenValidator>;
 
   // Message validators
   private attestationValidator: AttestationValidator;
@@ -101,10 +105,12 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @param block - The block received from the peer.
    * @returns The attestation for the block, if any.
    */
-  private blockReceivedCallback: (block: BlockProposal) => Promise<BlockAttestation | undefined>;
+  private blockReceivedCallback: P2PBlockReceivedCallback;
 
   private gossipSubEventHandler: (e: CustomEvent<GossipsubMessage>) => void;
 
+  private instrumentation: P2PInstrumentation;
+
   constructor(
     private clientType: T,
     private config: P2PConfig,
@@ -120,6 +126,12 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   ) {
     super(telemetry, 'LibP2PService');
 
+    this.instrumentation = new P2PInstrumentation(telemetry, 'LibP2PService');
+
+    this.msgIdSeenValidators[TopicType.tx] = new MessageSeenValidator(config.seenMessageCacheSize);
+    this.msgIdSeenValidators[TopicType.block_proposal] = new MessageSeenValidator(config.seenMessageCacheSize);
+    this.msgIdSeenValidators[TopicType.block_attestation] = new MessageSeenValidator(config.seenMessageCacheSize);
+
     const versions = getVersions(config);
     this.protocolVersion = compressComponentVersions(versions);
     logger.info(`Started libp2p service with protocol version ${this.protocolVersion}`);
@@ -446,8 +458,9 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(
     protocol: SubProtocol,
     requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
+    pinnedPeerId: PeerId | undefined,
   ): Promise<(InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[]> {
-    return this.reqresp.sendBatchRequest(protocol, requests);
+    return this.reqresp.sendBatchRequest(protocol, requests, pinnedPeerId);
   }
 
   /**
@@ -458,9 +471,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return this.peerDiscoveryService.getEnr();
   }
 
-  public registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>) {
+  public registerBlockReceivedCallback(callback: P2PBlockReceivedCallback) {
     this.blockReceivedCallback = callback;
-    this.logger.verbose('Block received callback registered');
   }
 
   /**
@@ -494,6 +506,37 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return result.recipients.length;
   }
 
+  protected preValidateReceivedMessage(msg: Message, msgId: string, source: PeerId) {
+    let topicType: TopicType | undefined;
+
+    switch (msg.topic) {
+      case this.topicStrings[TopicType.tx]:
+        topicType = TopicType.tx;
+        break;
+      case this.topicStrings[TopicType.block_attestation]:
+        topicType = TopicType.block_attestation;
+        break;
+      case this.topicStrings[TopicType.block_proposal]:
+        topicType = TopicType.block_proposal;
+        break;
+      default:
+        this.logger.error(`Received message on unknown topic: ${msg.topic}`);
+        break;
+    }
+
+    const validator = topicType ? this.msgIdSeenValidators[topicType] : undefined;
+
+    if (!validator || !validator.addMessage(msgId)) {
+      this.instrumentation.incMessagePrevalidationStatus(false, topicType);
+      this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Ignore);
+      return false;
+    }
+
+    this.instrumentation.incMessagePrevalidationStatus(true, topicType);
+
+    return true;
+  }
+
   /**
    * Handles a new gossip message that was received by the client.
    * @param topic - The message's topic.
@@ -508,6 +551,11 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       messageId: p2pMessage.id,
       messageLatency,
     });
+
+    if (!this.preValidateReceivedMessage(msg, msgId, source)) {
+      return;
+    }
+
     if (msg.topic === this.topicStrings[TopicType.tx]) {
       await this.handleGossipedTx(p2pMessage.payload, msgId, source);
     }
@@ -525,14 +573,20 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     validationFunc: () => Promise<{ result: boolean; obj: T }>,
     msgId: string,
     source: PeerId,
+    topicType: TopicType,
   ): Promise<{ result: boolean; obj: T | undefined }> {
     let resultAndObj: { result: boolean; obj: T | undefined } = { result: false, obj: undefined };
+    const timer = new Timer();
     try {
       resultAndObj = await validationFunc();
     } catch (err) {
       this.logger.error(`Error deserialising and validating message `, err);
     }
 
+    if (resultAndObj.result) {
+      this.instrumentation.recordMessageValidation(topicType, timer);
+    }
+
     this.node.services.pubsub.reportMessageValidationResult(
       msgId,
       source.toString(),
@@ -548,7 +602,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       return { result, obj: tx };
     };
 
-    const { result, obj: tx } = await this.validateReceivedMessage<Tx>(validationFunc, msgId, source);
+    const { result, obj: tx } = await this.validateReceivedMessage<Tx>(validationFunc, msgId, source, TopicType.tx);
     if (!result || !tx) {
       return;
     }
@@ -579,6 +633,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       validationFunc,
       msgId,
       source,
+      TopicType.block_attestation,
     );
     if (!result || !attestation) {
       return;
@@ -606,11 +661,16 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       return { result, obj: block };
     };
 
-    const { result, obj: block } = await this.validateReceivedMessage<BlockProposal>(validationFunc, msgId, source);
+    const { result, obj: block } = await this.validateReceivedMessage<BlockProposal>(
+      validationFunc,
+      msgId,
+      source,
+      TopicType.block_proposal,
+    );
     if (!result || !block) {
       return;
     }
-    await this.processValidBlockProposal(block);
+    await this.processValidBlockProposal(block, source);
   }
 
   // REVIEW: callback pattern https://github.com/AztecProtocol/aztec-packages/issues/7963
@@ -620,9 +680,12 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
     [Attributes.P2P_ID]: await block.p2pMessageIdentifier().then(i => i.toString()),
   }))
-  private async processValidBlockProposal(block: BlockProposal) {
+  private async processValidBlockProposal(block: BlockProposal, sender: PeerId) {
+    const slot = block.slotNumber.toBigInt();
+    const previousSlot = slot - 1n;
+    const epoch = slot / 32n;
     this.logger.verbose(
-      `Received block ${block.blockNumber.toNumber()} for slot ${block.slotNumber.toNumber()} from external peer.`,
+      `Received block ${block.blockNumber.toNumber()} for slot ${slot}, epoch ${epoch} from external peer.`,
       {
         p2pMessageIdentifier: await block.p2pMessageIdentifier(),
         slot: block.slotNumber.toNumber(),
@@ -630,9 +693,14 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         block: block.blockNumber.toNumber(),
       },
     );
+    const attestationsForPreviousSlot = await this.mempools.attestationPool?.getAttestationsForSlot(previousSlot);
+    if (attestationsForPreviousSlot !== undefined) {
+      this.logger.verbose(`Received ${attestationsForPreviousSlot.length} attestations for slot ${previousSlot}`);
+    }
+
     // Mark the txs in this proposal as non-evictable
     await this.mempools.txPool.markTxsAsNonEvictable(block.payload.txHashes);
-    const attestation = await this.blockReceivedCallback(block);
+    const attestation = await this.blockReceivedCallback(block, sender);
 
     // TODO: fix up this pattern - the abstraction is not nice
     // The attestation can be undefined if no handler is registered / the validator deems the block invalid

package/src/services/reqresp/connection-sampler/batch_connection_sampler.ts

@@ -26,6 +26,7 @@ export class BatchConnectionSampler {
     private readonly connectionSampler: ConnectionSampler,
     batchSize: number,
     maxPeers: number,
+    exclude?: PeerId[],
   ) {
     if (maxPeers <= 0) {
       throw new Error('Max peers cannot be 0');
@@ -38,7 +39,8 @@ export class BatchConnectionSampler {
     this.requestsPerPeer = Math.max(1, Math.floor(batchSize / maxPeers));
 
     // Sample initial peers
-    this.batch = this.connectionSampler.samplePeersBatch(maxPeers);
+    const excluding = exclude && new Map(exclude.map(peerId => [peerId.toString(), true] as const));
+    this.batch = this.connectionSampler.samplePeersBatch(maxPeers, excluding);
   }
 
   /**
@@ -70,7 +72,7 @@ export class BatchConnectionSampler {
     }
 
     const excluding = new Map([[peerId.toString(), true]]);
-    const newPeer = this.connectionSampler.getPeer(excluding);
+    const newPeer = this.connectionSampler.getPeer(excluding); // Q: Shouldn't we accumulate all excluded peers? Otherwise the sampler could return us a previously excluded peer?
 
     if (newPeer) {
       this.batch[index] = newPeer;

package/src/services/reqresp/connection-sampler/connection_sampler.ts

@@ -137,9 +137,10 @@ export class ConnectionSampler {
    * Samples a batch of unique peers from the libp2p node, prioritizing peers without active connections
    *
    * @param numberToSample - The number of peers to sample
+   * @param excluding - The peers to exclude from the sampling
    * @returns Array of unique sampled peers, prioritizing those without active connections
    */
-  samplePeersBatch(numberToSample: number): PeerId[] {
+  samplePeersBatch(numberToSample: number, excluding?: Map<string, boolean>): PeerId[] {
     const peers = this.libp2p.getPeers();
     this.logger.debug('Sampling peers batch', { numberToSample, peers });
 
@@ -149,7 +150,7 @@ export class ConnectionSampler {
     const batch: PeerId[] = [];
     const withActiveConnections: Set<PeerId> = new Set();
     for (let i = 0; i < numberToSample; i++) {
-      const { peer, sampledPeers } = this.getPeerFromList(peers, undefined);
+      const { peer, sampledPeers } = this.getPeerFromList(peers, excluding);
       if (peer) {
         batch.push(peer);
       }
@@ -252,7 +253,11 @@ export class ConnectionSampler {
         activeConnectionsCount: updatedActiveConnectionsCount,
       });
 
-      await stream?.close();
+      //NOTE: All other status codes indicate closed stream.
+      //Either graceful close (closed/closing) or forced close (aborted/reset)
+      if (stream.status === 'open') {
+        await stream?.close();
+      }
     } catch (error) {
       this.logger.error(`Failed to close connection to peer with stream id ${streamId}`, error);
     } finally {

package/src/services/reqresp/protocols/goodbye.ts

@@ -95,7 +95,9 @@ export function reqGoodbyeHandler(peerManager: PeerManager): ReqRespSubProtocolH
 
     peerManager.goodbyeReceived(peerId, reason);
 
-    // Return a buffer of length 1 as an acknowledgement: this is allowed to fail
+    // NOTE: In the current implementation this won't be sent to peer,
+    // as the connection to peer has been already closed by peerManager.goodbyeReceived
+    // We have this just to satisfy interface
     return Promise.resolve(Buffer.from([0x0]));
   };
 }

package/src/services/reqresp/rate-limiter/rate_limiter.ts

@@ -8,7 +8,7 @@ import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import type { PeerId } from '@libp2p/interface';
 
 import type { PeerScoring } from '../../peer-manager/peer_scoring.js';
-import type { ReqRespSubProtocol, ReqRespSubProtocolRateLimits } from '../interface.js';
+import type { ProtocolRateLimitQuota, ReqRespSubProtocol, ReqRespSubProtocolRateLimits } from '../interface.js';
 import { DEFAULT_RATE_LIMITS } from './rate_limits.js';
 
 // Check for disconnected peers every 10 minutes
@@ -177,16 +177,18 @@ export class SubProtocolRateLimiter {
  */
 export class RequestResponseRateLimiter {
   private subProtocolRateLimiters: Map<ReqRespSubProtocol, SubProtocolRateLimiter>;
+  private rateLimits: ReqRespSubProtocolRateLimits;
 
   private cleanupInterval: NodeJS.Timeout | undefined = undefined;
 
   constructor(
     private peerScoring: PeerScoring,
-    rateLimits: ReqRespSubProtocolRateLimits = DEFAULT_RATE_LIMITS,
+    rateLimits: Partial<ReqRespSubProtocolRateLimits> = {},
   ) {
     this.subProtocolRateLimiters = new Map();
 
-    for (const [subProtocol, protocolLimits] of Object.entries(rateLimits)) {
+    this.rateLimits = { ...DEFAULT_RATE_LIMITS, ...rateLimits };
+    for (const [subProtocol, protocolLimits] of Object.entries(this.rateLimits)) {
       this.subProtocolRateLimiters.set(
         subProtocol as ReqRespSubProtocol,
         new SubProtocolRateLimiter(
@@ -228,4 +230,8 @@ export class RequestResponseRateLimiter {
   stop() {
     clearInterval(this.cleanupInterval);
   }
+
+  getRateLimits(protocol: ReqRespSubProtocol): ProtocolRateLimitQuota {
+    return this.rateLimits[protocol];
+  }
 }

package/src/services/reqresp/rate-limiter/rate_limits.ts

@@ -29,7 +29,7 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
     },
     globalLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 20,
+      quotaCount: 200,
     },
   },
   [ReqRespSubProtocol.BLOCK]: {