@aztec/p2p 0.86.0 → 0.87.0

package/src/services/libp2p/libp2p_service.ts

@@ -1,10 +1,9 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { Fr } from '@aztec/foundation/fields';
 import { createLibp2pComponentLogger, createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { GasFees } from '@aztec/stdlib/gas';
@@ -14,13 +13,14 @@ import {
   BlockProposal,
   type Gossipable,
   P2PClientType,
+  P2PMessage,
   PeerErrorSeverity,
   TopicType,
   createTopicString,
   getTopicTypeForClientType,
   metricsTopicStrToLabels,
 } from '@aztec/stdlib/p2p';
-import { DatabasePublicStateSource, MerkleTreeId } from '@aztec/stdlib/trees';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { Tx, type TxHash, type TxValidationResult } from '@aztec/stdlib/tx';
 import { compressComponentVersions } from '@aztec/stdlib/versioning';
 import { Attributes, OtelMetricsAdapter, type TelemetryClient, WithTracer, trackSpan } from '@aztec/telemetry-client';
@@ -49,14 +49,8 @@ import type { P2PConfig } from '../../config.js';
 import type { MemPools } from '../../mem_pools/interface.js';
 import { AttestationValidator, BlockProposalValidator } from '../../msg_validators/index.js';
 import { getDefaultAllowedSetupFunctions } from '../../msg_validators/tx_validator/allowed_public_setup.js';
-import {
-  DataTxValidator,
-  DoubleSpendTxValidator,
-  GasTxValidator,
-  MetadataTxValidator,
-  PhasesTxValidator,
-  TxProofValidator,
-} from '../../msg_validators/tx_validator/index.js';
+import { type MessageValidator, createTxMessageValidators } from '../../msg_validators/tx_validator/factory.js';
+import { DoubleSpendTxValidator, TxProofValidator } from '../../msg_validators/tx_validator/index.js';
 import { GossipSubEvent } from '../../types/index.js';
 import { type PubSubLibp2p, convertToMultiaddr } from '../../util.js';
 import { getVersions } from '../../versioning.js';
@@ -71,13 +65,6 @@ import { pingHandler, reqRespBlockHandler, reqRespTxHandler, statusHandler } fro
 import { ReqResp } from '../reqresp/reqresp.js';
 import type { P2PService, PeerDiscoveryService } from '../service.js';
 
-interface MessageValidator {
-  validator: {
-    validateTx(tx: Tx): Promise<TxValidationResult>;
-  };
-  severity: PeerErrorSeverity;
-}
-
 interface ValidationResult {
   name: string;
   isValid: TxValidationResult;
@@ -233,7 +220,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         tcp({
           maxConnections: config.maxPeerCount,
           // socket option: the maximum length of the queue of pending connections
-          // https://nodejs.org/dist/latest-v18.x/docs/api/net.html#serverlisten
+          // https://nodejs.org/dist/latest-v22.x/docs/api/net.html#serverlisten
           // it's not safe if we increase this number
           backlog: 5,
           closeServerOnMaxConnections: {
@@ -270,6 +257,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
           heartbeatInterval: config.gossipsubInterval,
           mcacheLength: config.gossipsubMcacheLength,
           mcacheGossip: config.gossipsubMcacheGossip,
+          seenTTL: config.gossipsubSeenTTL,
           msgIdFn: getMsgIdFn,
           msgIdToStrFn: msgIdToStrFn,
           fastMsgIdFn: fastMsgIdFn,
@@ -489,14 +477,19 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   /**
    * Publishes data to a topic.
    * @param topic - The topic to publish to.
-   * @param data - The data to publish.
+   * @param data - The message to publish.
    * @returns The number of recipients the data was sent to.
    */
-  private async publishToTopic(topic: string, data: Uint8Array) {
+  private async publishToTopic(topic: string, message: Gossipable) {
     if (!this.node.services.pubsub) {
       throw new Error('Pubsub service not available.');
     }
-    const result = await this.node.services.pubsub.publish(topic, data);
+    const p2pMessage = await P2PMessage.fromGossipable(message);
+    this.logger.debug(`Publishing message`, {
+      topic,
+      messageId: p2pMessage.id,
+    });
+    const result = await this.node.services.pubsub.publish(topic, p2pMessage.toMessageData());
 
     return result.recipients.length;
   }
@@ -507,14 +500,22 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @param data - The message data
    */
   protected async handleNewGossipMessage(msg: Message, msgId: string, source: PeerId) {
+    const p2pMessage = P2PMessage.fromMessageData(Buffer.from(msg.data));
+    const currentTime = new Date();
+    const messageLatency = currentTime.getTime() - p2pMessage.publishTime.getTime();
+    this.logger.debug(`Received message`, {
+      topic: msg.topic,
+      messageId: p2pMessage.id,
+      messageLatency,
+    });
     if (msg.topic === this.topicStrings[TopicType.tx]) {
-      await this.handleGossipedTx(msg, msgId, source);
+      await this.handleGossipedTx(p2pMessage.payload, msgId, source);
     }
     if (msg.topic === this.topicStrings[TopicType.block_attestation] && this.clientType === P2PClientType.Full) {
-      await this.processAttestationFromPeer(msg, msgId, source);
+      await this.processAttestationFromPeer(p2pMessage.payload, msgId, source);
     }
     if (msg.topic === this.topicStrings[TopicType.block_proposal]) {
-      await this.processBlockFromPeer(msg, msgId, source);
+      await this.processBlockFromPeer(p2pMessage.payload, msgId, source);
     }
 
     return;
@@ -540,9 +541,9 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return resultAndObj;
   }
 
-  protected async handleGossipedTx(msg: Message, msgId: string, source: PeerId) {
+  protected async handleGossipedTx(payloadData: Buffer, msgId: string, source: PeerId) {
     const validationFunc = async () => {
-      const tx = Tx.fromBuffer(Buffer.from(msg.data));
+      const tx = Tx.fromBuffer(payloadData);
       const result = await this.validatePropagatedTx(tx, source);
       return { result, obj: tx };
     };
@@ -563,12 +564,12 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    *
    * @param attestation - The attestation to process.
    */
-  private async processAttestationFromPeer(msg: Message, msgId: string, source: PeerId): Promise<void> {
+  private async processAttestationFromPeer(payloadData: Buffer, msgId: string, source: PeerId): Promise<void> {
     const validationFunc = async () => {
-      const attestation = BlockAttestation.fromBuffer(Buffer.from(msg.data));
+      const attestation = BlockAttestation.fromBuffer(payloadData);
       const result = await this.validateAttestation(source, attestation);
       this.logger.trace(`validatePropagatedAttestation: ${result}`, {
-        [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toString(),
+        [Attributes.SLOT_NUMBER]: attestation.payload.header.slotNumber.toString(),
         [Attributes.P2P_ID]: source.toString(),
       });
       return { result, obj: attestation };
@@ -594,12 +595,12 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     await this.mempools.attestationPool!.addAttestations([attestation]);
   }
 
-  private async processBlockFromPeer(msg: Message, msgId: string, source: PeerId): Promise<void> {
+  private async processBlockFromPeer(payloadData: Buffer, msgId: string, source: PeerId): Promise<void> {
     const validationFunc = async () => {
-      const block = BlockProposal.fromBuffer(Buffer.from(msg.data));
+      const block = BlockProposal.fromBuffer(payloadData);
       const result = await this.validateBlockProposal(source, block);
       this.logger.trace(`validatePropagatedBlock: ${result}`, {
-        [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString(),
+        [Attributes.SLOT_NUMBER]: block.payload.header.slotNumber.toString(),
         [Attributes.P2P_ID]: source.toString(),
       });
       return { result, obj: block };
@@ -629,6 +630,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         block: block.blockNumber.toNumber(),
       },
     );
+    // Mark the txs in this proposal as non-evictable
+    await this.mempools.txPool.markTxsAsNonEvictable(block.payload.txHashes);
     const attestation = await this.blockReceivedCallback(block);
 
     // TODO: fix up this pattern - the abstraction is not nice
@@ -652,8 +655,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @param attestation - The attestation to broadcast.
    */
   @trackSpan('Libp2pService.broadcastAttestation', async attestation => ({
-    [Attributes.BLOCK_NUMBER]: attestation.payload.header.globalVariables.blockNumber.toNumber(),
-    [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toNumber(),
+    [Attributes.BLOCK_NUMBER]: attestation.blockNumber.toNumber(),
+    [Attributes.SLOT_NUMBER]: attestation.payload.header.slotNumber.toNumber(),
     [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
     [Attributes.P2P_ID]: await attestation.p2pMessageIdentifier().then(i => i.toString()),
   }))
@@ -720,21 +723,25 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   private async validatePropagatedTx(tx: Tx, peerId: PeerId): Promise<boolean> {
     const blockNumber = (await this.archiver.getBlockNumber()) + 1;
     const messageValidators = await this.createMessageValidators(blockNumber);
-    const outcome = await this.runValidations(tx, messageValidators);
 
-    if (outcome.allPassed) {
-      return true;
-    }
-    const { name } = outcome.failure;
-    let { severity } = outcome.failure;
+    for (const validator of messageValidators) {
+      const outcome = await this.runValidations(tx, validator);
 
-    // Double spend validator has a special case handler
-    if (name === 'doubleSpendValidator') {
-      severity = await this.handleDoubleSpendFailure(tx, blockNumber);
-    }
+      if (outcome.allPassed) {
+        continue;
+      }
+      const { name } = outcome.failure;
+      let { severity } = outcome.failure;
+
+      // Double spend validator has a special case handler
+      if (name === 'doubleSpendValidator') {
+        severity = await this.handleDoubleSpendFailure(tx, blockNumber);
+      }
 
-    this.peerManager.penalizePeer(peerId, severity);
-    return false;
+      this.peerManager.penalizePeer(peerId, severity);
+      return false;
+    }
+    return true;
   }
 
   private async getGasFees(blockNumber: number): Promise<GasFees> {
@@ -748,6 +755,22 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return gasFees;
   }
 
+  public async validate(txs: Tx[]): Promise<void> {
+    const blockNumber = (await this.archiver.getBlockNumber()) + 1;
+    const messageValidators = await this.createMessageValidators(blockNumber);
+
+    await Promise.all(
+      txs.map(async tx => {
+        for (const validator of messageValidators) {
+          const outcome = await this.runValidations(tx, validator);
+          if (!outcome.allPassed) {
+            throw new Error('Invalid tx detected', { cause: { outcome } });
+          }
+        }
+      }),
+    );
+  }
+
   /**
    * Create message validators for the given block number.
    *
@@ -757,51 +780,21 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @param blockNumber - The block number to create validators for.
    * @returns The message validators.
    */
-  private async createMessageValidators(blockNumber: number): Promise<Record<string, MessageValidator>> {
-    const merkleTree = this.worldStateSynchronizer.getCommitted();
+  private async createMessageValidators(blockNumber: number): Promise<Record<string, MessageValidator>[]> {
     const gasFees = await this.getGasFees(blockNumber - 1);
     const allowedInSetup = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
 
-    return {
-      dataValidator: {
-        validator: new DataTxValidator(),
-        severity: PeerErrorSeverity.HighToleranceError,
-      },
-      metadataValidator: {
-        validator: new MetadataTxValidator(
-          new Fr(this.config.l1ChainId),
-          new Fr(this.config.rollupVersion),
-          new Fr(blockNumber),
-        ),
-        severity: PeerErrorSeverity.HighToleranceError,
-      },
-      proofValidator: {
-        validator: new TxProofValidator(this.proofVerifier),
-        severity: PeerErrorSeverity.MidToleranceError,
-      },
-      doubleSpendValidator: {
-        validator: new DoubleSpendTxValidator({
-          nullifiersExist: async (nullifiers: Buffer[]) => {
-            const merkleTree = this.worldStateSynchronizer.getCommitted();
-            const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
-            return indices.map(index => index !== undefined);
-          },
-        }),
-        severity: PeerErrorSeverity.HighToleranceError,
-      },
-      gasValidator: {
-        validator: new GasTxValidator(
-          new DatabasePublicStateSource(merkleTree),
-          ProtocolContractAddress.FeeJuice,
-          gasFees,
-        ),
-        severity: PeerErrorSeverity.HighToleranceError,
-      },
-      phasesValidator: {
-        validator: new PhasesTxValidator(this.archiver, allowedInSetup, blockNumber),
-        severity: PeerErrorSeverity.MidToleranceError,
-      },
-    };
+    return createTxMessageValidators(
+      blockNumber,
+      this.worldStateSynchronizer,
+      gasFees,
+      this.config.l1ChainId,
+      this.config.rollupVersion,
+      protocolContractTreeRoot,
+      this.archiver,
+      this.proofVerifier,
+      allowedInSetup,
+    );
   }
 
   /**
@@ -820,24 +813,22 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     });
 
     // A promise that resolves when all validations have been run
-    const allValidations = Promise.all(validationPromises);
-
-    // A promise that resolves when the first validation fails
-    const firstFailure = Promise.race(
-      validationPromises.map(async promise => {
-        const result = await promise;
-        return result.isValid ? new Promise(() => {}) : result;
-      }),
-    );
-
-    // Wait for the first validation to fail or all validations to pass
-    const result = await Promise.race([
-      allValidations.then(() => ({ allPassed: true as const })),
-      firstFailure.then(failure => ({ allPassed: false as const, failure: failure as ValidationResult })),
-    ]);
-
-    // If all validations pass, allPassed will be true, if failed, then the failure will be the first validation to fail
-    return result;
+    const allValidations = await Promise.all(validationPromises);
+    const failed = allValidations.find(x => !x.isValid);
+    if (failed) {
+      return {
+        allPassed: false,
+        failure: {
+          isValid: { result: 'invalid' as const, reason: ['Failed validation'] },
+          name: failed.name,
+          severity: failed.severity,
+        },
+      };
+    } else {
+      return {
+        allPassed: true,
+      };
+    }
   }
 
   /**
@@ -881,8 +872,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @returns True if the attestation is valid, false otherwise.
    */
   @trackSpan('Libp2pService.validateAttestation', async (_, attestation) => ({
-    [Attributes.BLOCK_NUMBER]: attestation.payload.header.globalVariables.blockNumber.toNumber(),
-    [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toNumber(),
+    [Attributes.BLOCK_NUMBER]: attestation.blockNumber.toNumber(),
+    [Attributes.SLOT_NUMBER]: attestation.payload.header.slotNumber.toNumber(),
     [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
     [Attributes.P2P_ID]: await attestation.p2pMessageIdentifier().then(i => i.toString()),
   }))
@@ -903,7 +894,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @returns True if the block proposal is valid, false otherwise.
    */
   @trackSpan('Libp2pService.validateBlockProposal', (_peerId, block) => ({
-    [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString(),
+    [Attributes.SLOT_NUMBER]: block.payload.header.slotNumber.toString(),
   }))
   public async validateBlockProposal(peerId: PeerId, block: BlockProposal): Promise<boolean> {
     const severity = await this.blockProposalValidator.validate(block);
@@ -926,7 +917,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     const identifier = await message.p2pMessageIdentifier().then(i => i.toString());
     this.logger.trace(`Sending message ${identifier}`, { p2pMessageIdentifier: identifier });
 
-    const recipientsNum = await this.publishToTopic(this.topicStrings[parent.p2pTopic], message.toBuffer());
+    const recipientsNum = await this.publishToTopic(this.topicStrings[parent.p2pTopic], message);
     this.logger.debug(`Sent message ${identifier} to ${recipientsNum} peers`, {
       p2pMessageIdentifier: identifier,
       sourcePeer: this.node.peerId.toString(),

package/src/services/peer-manager/metrics.ts

@@ -18,7 +18,10 @@ export class PeerManagerMetrics {
 
   public readonly tracer: Tracer;
 
-  constructor(public readonly telemetryClient: TelemetryClient = getTelemetryClient(), name = 'PeerManager') {
+  constructor(
+    public readonly telemetryClient: TelemetryClient = getTelemetryClient(),
+    name = 'PeerManager',
+  ) {
     this.tracer = telemetryClient.getTracer(name);
 
     const meter = telemetryClient.getMeter(name);

package/src/services/peer-manager/peer_manager.ts

@@ -14,6 +14,7 @@ import type { PubSubLibp2p } from '../../util.js';
 import { ReqRespSubProtocol } from '../reqresp/interface.js';
 import { GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/goodbye.js';
 import type { ReqResp } from '../reqresp/reqresp.js';
+import { ReqRespStatus } from '../reqresp/status.js';
 import type { PeerDiscoveryService } from '../service.js';
 import { PeerManagerMetrics } from './metrics.js';
 import { PeerScoreState, type PeerScoring } from './peer_scoring.js';
@@ -22,6 +23,7 @@ const MAX_DIAL_ATTEMPTS = 3;
 const MAX_CACHED_PEERS = 100;
 const MAX_CACHED_PEER_AGE_MS = 5 * 60 * 1000; // 5 minutes
 const FAILED_PEER_BAN_TIME_MS = 5 * 60 * 1000; // 5 minutes timeout after failing MAX_DIAL_ATTEMPTS
+const GOODBYE_DIAL_TIMEOUT_MS = 1000;
 
 type CachedPeer = {
   peerId: PeerId;
@@ -455,7 +457,22 @@ export class PeerManager {
     this.metrics.recordGoodbyeSent(reason);
 
     try {
-      await this.reqresp.sendRequestToPeer(peer, ReqRespSubProtocol.GOODBYE, Buffer.from([reason]));
+      const resp = await this.reqresp.sendRequestToPeer(
+        peer,
+        ReqRespSubProtocol.GOODBYE,
+        Buffer.from([reason]),
+        GOODBYE_DIAL_TIMEOUT_MS,
+      );
+
+      if (resp.status === ReqRespStatus.FAILURE) {
+        this.logger.debug(`Failed to send goodbye to peer ${peer.toString()}`);
+      } else if (resp.status === ReqRespStatus.SUCCESS) {
+        this.logger.verbose(`Sent goodbye to peer ${peer.toString()}`);
+      } else {
+        this.logger.debug(
+          `Unexpected status sending goodbye to peer ${peer.toString()}: ${ReqRespStatus[resp.status]}`,
+        );
+      }
     } catch (error) {
       this.logger.debug(`Failed to send goodbye to peer ${peer.toString()}: ${error}`);
     } finally {

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

@@ -22,7 +22,11 @@ export class BatchConnectionSampler {
   private readonly batch: PeerId[] = [];
   private readonly requestsPerPeer: number;
 
-  constructor(private readonly connectionSampler: ConnectionSampler, batchSize: number, maxPeers: number) {
+  constructor(
+    private readonly connectionSampler: ConnectionSampler,
+    batchSize: number,
+    maxPeers: number,
+  ) {
     if (maxPeers <= 0) {
       throw new Error('Max peers cannot be 0');
     }

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

@@ -26,7 +26,7 @@ export class RandomSampler {
 export class ConnectionSampler {
   private readonly logger = createLogger('p2p:reqresp:connection-sampler');
   private cleanupInterval: NodeJS.Timeout;
-  private abortController: AbortController = new AbortController();
+  private dialAttempts: AbortController[] = [];
 
   private readonly activeConnectionsCount: Map<PeerId, number> = new Map();
   private readonly streams: Map<string, StreamAndPeerId> = new Map();
@@ -51,7 +51,10 @@ export class ConnectionSampler {
     this.logger.info('Stopping connection sampler');
     clearInterval(this.cleanupInterval);
 
-    this.abortController.abort();
+    for (const attempt of this.dialAttempts) {
+      attempt.abort();
+    }
+    this.dialAttempts = [];
     await this.dialQueue.end();
 
     // Close all active streams
@@ -184,24 +187,44 @@ export class ConnectionSampler {
    * @param protocol - The protocol
    * @returns The stream
    */
-  async dialProtocol(peerId: PeerId, protocol: string): Promise<Stream> {
+  async dialProtocol(peerId: PeerId, protocol: string, timeout?: number): Promise<Stream> {
     // Dialling at the same time can cause race conditions where two different streams
     // end up with the same id, hence a serial queue
-    const stream = await this.dialQueue.put(() =>
-      this.libp2p.dialProtocol(peerId, protocol, { signal: this.abortController.signal }),
-    );
-
-    this.streams.set(stream.id, { stream, peerId });
-    const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 0) + 1;
-    this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
-
-    this.logger.trace('Dialed protocol', {
-      streamId: stream.id,
-      protocol,
-      peerId: peerId.toString(),
-      activeConnectionsCount: updatedActiveConnectionsCount,
-    });
-    return stream;
+    this.logger.debug(`Dial queue length: ${this.dialQueue.length()}`);
+
+    const abortController = new AbortController();
+    this.dialAttempts.push(abortController);
+    let timeoutHandle: NodeJS.Timeout | undefined;
+    if (timeout) {
+      timeoutHandle = setTimeout(() => abortController.abort(), timeout);
+    }
+
+    try {
+      const stream = await this.dialQueue.put(() =>
+        this.libp2p.dialProtocol(peerId, protocol, { signal: abortController.signal }),
+      );
+
+      this.streams.set(stream.id, { stream, peerId });
+      const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 0) + 1;
+      this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
+
+      this.logger.trace('Dialed protocol', {
+        streamId: stream.id,
+        protocol,
+        peerId: peerId.toString(),
+        activeConnectionsCount: updatedActiveConnectionsCount,
+      });
+      return stream;
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+
+      const idx = this.dialAttempts.indexOf(abortController);
+      if (idx > -1) {
+        this.dialAttempts.splice(idx, 1);
+      }
+    }
   }
 
   /**
@@ -213,7 +236,7 @@ export class ConnectionSampler {
     try {
       const streamAndPeerId = this.streams.get(streamId);
       if (!streamAndPeerId) {
-        this.logger.warn(`Stream ${streamId} not found`);
+        this.logger.debug(`Stream ${streamId} not found`);
         return;
       }
 

package/src/services/reqresp/metrics.ts

@@ -11,7 +11,10 @@ export class ReqRespMetrics {
   private readonly failedOutboundRequests: UpDownCounter;
   private readonly failedInboundRequests: UpDownCounter;
 
-  constructor(readonly telemetryClient: TelemetryClient, name = 'ReqResp') {
+  constructor(
+    readonly telemetryClient: TelemetryClient,
+    name = 'ReqResp',
+  ) {
     this.tracer = telemetryClient.getTracer(name);
 
     const meter = telemetryClient.getMeter(name);

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

@@ -34,7 +34,7 @@ export function decodeGoodbyeReason(buffer: Buffer): GoodByeReason {
       throw new Error('Invalid goodbye reason buffer length');
     }
     return buffer[0] as GoodByeReason;
-  } catch (error) {
+  } catch {
     return GoodByeReason.UNKNOWN;
   }
 }

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

@@ -180,7 +180,10 @@ export class RequestResponseRateLimiter {
 
   private cleanupInterval: NodeJS.Timeout | undefined = undefined;
 
-  constructor(private peerScoring: PeerScoring, rateLimits: ReqRespSubProtocolRateLimits = DEFAULT_RATE_LIMITS) {
+  constructor(
+    private peerScoring: PeerScoring,
+    rateLimits: ReqRespSubProtocolRateLimits = DEFAULT_RATE_LIMITS,
+  ) {
     this.subProtocolRateLimiters = new Map();
 
     for (const [subProtocol, protocolLimits] of Object.entries(rateLimits)) {

package/src/services/reqresp/reqresp.ts

@@ -262,7 +262,7 @@ export class ReqResp {
     subProtocol: SubProtocol,
     requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
     timeoutMs = 10000,
-    maxPeers = Math.min(10, requests.length),
+    maxPeers = Math.max(10, Math.ceil(requests.length / 3)),
     maxRetryAttempts = 3,
   ): Promise<(InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[]> {
     const responseValidator = this.subProtocolValidators[subProtocol];
@@ -292,7 +292,8 @@ export class ReqResp {
       let retryAttempts = 0;
       while (pendingRequestIndices.size > 0 && batchSampler.activePeerCount > 0 && retryAttempts < maxRetryAttempts) {
         // Process requests in parallel for each available peer
-        const requestBatches = new Map<PeerId, number[]>();
+        type BatchEntry = { peerId: PeerId; indices: number[] };
+        const requestBatches = new Map<string, BatchEntry>();
 
         // Group requests by peer
         for (const requestIndex of pendingRequestIndices) {
@@ -300,11 +301,11 @@ export class ReqResp {
           if (!peer) {
             break;
           }
-
-          if (!requestBatches.has(peer)) {
-            requestBatches.set(peer, []);
+          const peerAsString = peer.toString();
+          if (!requestBatches.has(peerAsString)) {
+            requestBatches.set(peerAsString, { peerId: peer, indices: [] });
           }
-          requestBatches.get(peer)!.push(requestIndex);
+          requestBatches.get(peerAsString)!.indices.push(requestIndex);
         }
 
         // Make parallel requests for each peer's batch
@@ -316,7 +317,7 @@ export class ReqResp {
         // while simultaneously Peer Id 1 will send requests 4, 5, 6, 7 in serial
 
         const batchResults = await Promise.all(
-          Array.from(requestBatches.entries()).map(async ([peer, indices]) => {
+          Array.from(requestBatches.entries()).map(async ([peerAsString, { peerId: peer, indices }]) => {
             try {
               // Requests all going to the same peer are sent synchronously
               const peerResults: { index: number; response: InstanceType<SubProtocolMap[SubProtocol]['response']> }[] =
@@ -327,9 +328,7 @@ export class ReqResp {
                 // Check the status of the response buffer
                 if (response.status !== ReqRespStatus.SUCCESS) {
                   this.logger.debug(
-                    `Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(
-                      response.status,
-                    )}`,
+                    `Request to peer ${peerAsString} failed with status ${prettyPrintReqRespStatus(response.status)}`,
                   );
 
                   // If we hit a rate limit or some failure, we remove the peer and return the results,
@@ -350,7 +349,7 @@ export class ReqResp {
 
               return { peer, results: peerResults };
             } catch (error) {
-              this.logger.debug(`Failed batch request to peer ${peer.toString()}:`, error);
+              this.logger.debug(`Failed batch request to peer ${peerAsString}:`, error);
               batchSampler.removePeerAndReplace(peer);
               return { peer, results: [] };
             }
@@ -421,12 +420,13 @@ export class ReqResp {
     peerId: PeerId,
     subProtocol: ReqRespSubProtocol,
     payload: Buffer,
+    dialTimeout?: number,
   ): Promise<ReqRespResponse> {
     let stream: Stream | undefined;
     try {
       this.metrics.recordRequestSent(subProtocol);
 
-      stream = await this.connectionSampler.dialProtocol(peerId, subProtocol);
+      stream = await this.connectionSampler.dialProtocol(peerId, subProtocol, dialTimeout);
 
       // Open the stream with a timeout
       const result = await executeTimeout<ReqRespResponse>(