@aztec/p2p 0.85.0 → 0.86.0

package/src/services/libp2p/libp2p_service.ts

@@ -15,12 +15,14 @@ import {
   type Gossipable,
   P2PClientType,
   PeerErrorSeverity,
-  TopicTypeMap,
+  TopicType,
+  createTopicString,
   getTopicTypeForClientType,
   metricsTopicStrToLabels,
 } from '@aztec/stdlib/p2p';
 import { DatabasePublicStateSource, 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';
 
 import type { ENR } from '@chainsafe/enr';
@@ -57,6 +59,7 @@ import {
 } 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';
 import { AztecDatastore } from '../data_store.js';
 import { SnappyTransform, fastMsgIdFn, getMsgIdFn, msgIdToStrFn } from '../encoding.js';
 import { gossipScoreThresholds } from '../gossipsub/scoring.js';
@@ -95,6 +98,9 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   private attestationValidator: AttestationValidator;
   private blockProposalValidator: BlockProposalValidator;
 
+  private protocolVersion = '';
+  private topicStrings: Record<TopicType, string> = {} as Record<TopicType, string>;
+
   // Request and response sub service
   public reqresp: ReqResp;
 
@@ -127,6 +133,17 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   ) {
     super(telemetry, 'LibP2PService');
 
+    const versions = getVersions(config);
+    this.protocolVersion = compressComponentVersions(versions);
+    logger.info(`Started libp2p service with protocol version ${this.protocolVersion}`);
+
+    this.topicStrings[TopicType.tx] = createTopicString(TopicType.tx, this.protocolVersion);
+    this.topicStrings[TopicType.block_proposal] = createTopicString(TopicType.block_proposal, this.protocolVersion);
+    this.topicStrings[TopicType.block_attestation] = createTopicString(
+      TopicType.block_attestation,
+      this.protocolVersion,
+    );
+
     const peerScoring = new PeerScoring(config);
     this.reqresp = new ReqResp(config, node, peerScoring);
 
@@ -198,6 +215,13 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       peerDiscovery.push(bootstrap({ list: bootstrapNodes }));
     }
 
+    const versions = getVersions(config);
+    const protocolVersion = compressComponentVersions(versions);
+
+    const txTopic = createTopicString(TopicType.tx, protocolVersion);
+    const blockProposalTopic = createTopicString(TopicType.block_proposal, protocolVersion);
+    const blockAttestationTopic = createTopicString(TopicType.block_attestation, protocolVersion);
+
     const node = await createLibp2p({
       start: false,
       peerId,
@@ -251,24 +275,24 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
           fastMsgIdFn: fastMsgIdFn,
           dataTransform: new SnappyTransform(),
           metricsRegister: otelMetricsAdapter,
-          metricsTopicStrToLabel: metricsTopicStrToLabels(),
+          metricsTopicStrToLabel: metricsTopicStrToLabels(protocolVersion),
           asyncValidation: true,
           scoreThresholds: gossipScoreThresholds,
           scoreParams: createPeerScoreParams({
             // IPColocation factor can be disabled for local testing - default to -5
             IPColocationFactorWeight: config.debugDisableColocationPenalty ? 0 : -5.0,
             topics: {
-              [Tx.p2pTopic]: createTopicScoreParams({
+              [txTopic]: createTopicScoreParams({
                 topicWeight: 1,
                 invalidMessageDeliveriesWeight: -20,
                 invalidMessageDeliveriesDecay: 0.5,
               }),
-              [BlockAttestation.p2pTopic]: createTopicScoreParams({
+              [blockAttestationTopic]: createTopicScoreParams({
                 topicWeight: 1,
                 invalidMessageDeliveriesWeight: -20,
                 invalidMessageDeliveriesDecay: 0.5,
               }),
-              [BlockProposal.p2pTopic]: createTopicScoreParams({
+              [blockProposalTopic]: createTopicScoreParams({
                 topicWeight: 1,
                 invalidMessageDeliveriesWeight: -20,
                 invalidMessageDeliveriesDecay: 0.5,
@@ -318,13 +342,13 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     // Start job queue, peer discovery service and libp2p node
     this.jobQueue.start();
 
-    await this.peerManager.initializeTrustedPeers();
+    await this.peerManager.initializePeers();
     await this.peerDiscoveryService.start();
     await this.node.start();
 
     // Subscribe to standard GossipSub topics by default
     for (const topic of getTopicTypeForClientType(this.clientType)) {
-      this.subscribeToTopic(TopicTypeMap[topic].p2pTopic);
+      this.subscribeToTopic(this.topicStrings[topic]);
     }
 
     // Create request response protocol handlers
@@ -434,7 +458,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(
     protocol: SubProtocol,
     requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
-  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[] | undefined> {
+  ): Promise<(InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[]> {
     return this.reqresp.sendBatchRequest(protocol, requests);
   }
 
@@ -483,13 +507,13 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @param data - The message data
    */
   protected async handleNewGossipMessage(msg: Message, msgId: string, source: PeerId) {
-    if (msg.topic === Tx.p2pTopic) {
+    if (msg.topic === this.topicStrings[TopicType.tx]) {
       await this.handleGossipedTx(msg, msgId, source);
     }
-    if (msg.topic === BlockAttestation.p2pTopic && this.clientType === P2PClientType.Full) {
+    if (msg.topic === this.topicStrings[TopicType.block_attestation] && this.clientType === P2PClientType.Full) {
       await this.processAttestationFromPeer(msg, msgId, source);
     }
-    if (msg.topic == BlockProposal.p2pTopic) {
+    if (msg.topic === this.topicStrings[TopicType.block_proposal]) {
       await this.processBlockFromPeer(msg, msgId, source);
     }
 
@@ -884,6 +908,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   public async validateBlockProposal(peerId: PeerId, block: BlockProposal): Promise<boolean> {
     const severity = await this.blockProposalValidator.validate(block);
     if (severity) {
+      this.logger.debug(`Penalizing peer ${peerId} for block proposal validation failure`);
       this.peerManager.penalizePeer(peerId, severity);
       return false;
     }
@@ -901,7 +926,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(parent.p2pTopic, message.toBuffer());
+    const recipientsNum = await this.publishToTopic(this.topicStrings[parent.p2pTopic], message.toBuffer());
     this.logger.debug(`Sent message ${identifier} to ${recipientsNum} peers`, {
       p2pMessageIdentifier: identifier,
       sourcePeer: this.node.peerId.toString(),

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

@@ -41,8 +41,10 @@ export class PeerManager {
   private heartbeatCounter: number = 0;
   private displayPeerCountsPeerHeartbeat: number = 0;
   private timedOutPeers: Map<string, TimedOutPeer> = new Map();
-  private trustedPeers: Set<PeerId> = new Set();
+  private trustedPeers: Set<string> = new Set();
   private trustedPeersInitialized: boolean = false;
+  private privatePeers: Set<string> = new Set();
+  private privatePeersInitialized: boolean = false;
 
   private metrics: PeerManagerMetrics;
   private handlers: {
@@ -87,14 +89,34 @@ export class PeerManager {
    *
    * This function is called when the peer manager is initialized.
    */
-  async initializeTrustedPeers() {
-    const trustedPeersEnrs: ENR[] = this.config.trustedPeers.map(enr => ENR.decodeTxt(enr));
-    await Promise.all(trustedPeersEnrs.map(enr => enr.peerId()))
-      .then(peerIds => peerIds.forEach(peerId => this.trustedPeers.add(peerId)))
-      .finally(() => {
-        this.trustedPeersInitialized = true;
-      })
-      .catch(e => this.logger.error('Error initializing trusted peers', e));
+  async initializePeers() {
+    if (this.config.trustedPeers) {
+      const trustedPeersEnrs: ENR[] = this.config.trustedPeers.map(enr => ENR.decodeTxt(enr));
+      await Promise.all(trustedPeersEnrs.map(enr => enr.peerId()))
+        .then(peerIds => peerIds.forEach(peerId => this.trustedPeers.add(peerId.toString())))
+        .finally(() => {
+          this.trustedPeersInitialized = true;
+        })
+        .catch(e => this.logger.error('Error initializing trusted peers', e));
+    }
+
+    if (this.config.privatePeers) {
+      const privatePeersEnrs: ENR[] = this.config.privatePeers.map(enr => ENR.decodeTxt(enr));
+      await Promise.all(privatePeersEnrs.map(enr => enr.peerId()))
+        .then(peerIds =>
+          peerIds.forEach(peerId => {
+            this.trustedPeers.add(peerId.toString());
+            this.privatePeers.add(peerId.toString());
+          }),
+        )
+        .finally(() => {
+          if (!this.config.trustedPeers) {
+            this.trustedPeersInitialized = true;
+          }
+          this.privatePeersInitialized = true;
+        })
+        .catch(e => this.logger.error('Error initializing private peers', e));
+    }
   }
 
   get tracer() {
@@ -165,7 +187,7 @@ export class PeerManager {
       this.logger.warn('Trusted peers not initialized, returning false');
       return false;
     }
-    return this.trustedPeers.has(peerId);
+    return this.trustedPeers.has(peerId.toString());
   }
 
   /**
@@ -173,9 +195,47 @@ export class PeerManager {
    * @param peerId - The peer ID to add to trusted peers.
    */
   public addTrustedPeer(peerId: PeerId): void {
-    this.trustedPeers.add(peerId);
+    const peerIdStr = peerId.toString();
+
+    this.trustedPeers.add(peerIdStr);
+    this.trustedPeersInitialized = true;
+    this.logger.verbose(`Added trusted peer ${peerIdStr}`);
+  }
+
+  /**
+   * Adds a peer to the private peers set.
+   * @param peerId - The peer ID to add to private peers.
+   */
+  public addPrivatePeer(peerId: PeerId): void {
+    const peerIdStr = peerId.toString();
+
+    this.trustedPeers.add(peerIdStr);
+    this.privatePeers.add(peerIdStr);
     this.trustedPeersInitialized = true;
-    this.logger.verbose(`Added trusted peer ${peerId.toString()}`);
+    this.privatePeersInitialized = true;
+    this.logger.verbose(`Added private peer ${peerIdStr}`);
+  }
+
+  /**
+   * Checks if a peer is private.
+   * @param peerId - The peer ID.
+   * @returns True if the peer is private, false otherwise.
+   */
+  private isPrivatePeer(peerId: PeerId): boolean {
+    if (!this.privatePeersInitialized) {
+      this.logger.warn('Private peers not initialized, returning false');
+      return false;
+    }
+    return this.privatePeers.has(peerId.toString());
+  }
+
+  /**
+   * Checks if a peer is protected (either trusted or private).
+   * @param peerId - The peer ID.
+   * @returns True if the peer is protected, false otherwise.
+   */
+  private isProtectedPeer(peerId: PeerId): boolean {
+    return this.isTrustedPeer(peerId) || this.isPrivatePeer(peerId);
   }
 
   /**
@@ -241,15 +301,16 @@ export class PeerManager {
     const connections = this.libP2PNode.getConnections();
 
     const healthyConnections = this.prioritizePeers(
-      this.onlyNotTrustedPeers(this.pruneUnhealthyPeers(this.pruneDuplicatePeers(connections))),
+      this.pruneUnhealthyPeers(this.getNonProtectedPeers(this.pruneDuplicatePeers(connections))),
     );
 
     // Calculate how many connections we're looking to make
     const peersToConnect = this.config.maxPeerCount - healthyConnections.length - this.trustedPeers.size;
 
     const logLevel = this.heartbeatCounter % this.displayPeerCountsPeerHeartbeat === 0 ? 'info' : 'debug';
-    this.logger[logLevel](`Connected to ${healthyConnections.length} peers`, {
-      connections: healthyConnections.length,
+    this.logger[logLevel](`Connected to ${healthyConnections.length + this.trustedPeers.size} peers`, {
+      discoveredConnections: healthyConnections.length,
+      protectedConnections: this.trustedPeers.size,
       maxPeerCount: this.config.maxPeerCount,
       cachedPeers: this.cachedPeers.size,
       ...this.peerScoring.getStats(),
@@ -302,18 +363,14 @@ export class PeerManager {
     }
   }
 
-  private onlyNotTrustedPeers(connections: Connection[]): Connection[] {
-    return connections.filter(conn => !this.isTrustedPeer(conn.remotePeer));
+  private getNonProtectedPeers(connections: Connection[]): Connection[] {
+    return connections.filter(conn => !this.isProtectedPeer(conn.remotePeer));
   }
 
   private pruneUnhealthyPeers(connections: Connection[]): Connection[] {
     const connectedHealthyPeers: Connection[] = [];
 
     for (const peer of connections) {
-      if (this.isTrustedPeer(peer.remotePeer)) {
-        this.logger.debug(`Not pruning trusted peer ${peer.remotePeer.toString()}`);
-        continue;
-      }
       const score = this.peerScoring.getScoreState(peer.remotePeer.toString());
       switch (score) {
         case PeerScoreState.Banned:
@@ -526,7 +583,7 @@ export class PeerManager {
 
     // Remove the oldest peers
     for (const [key, value] of this.cachedPeers.entries()) {
-      if (this.isTrustedPeer(value.peerId)) {
+      if (this.isProtectedPeer(value.peerId)) {
         this.logger.debug(`Not pruning trusted peer ${key}`);
         continue;
       }

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

@@ -70,11 +70,11 @@ export class BatchConnectionSampler {
 
     if (newPeer) {
       this.batch[index] = newPeer;
-      this.logger.trace(`Replaced peer ${peerId} with ${newPeer}`, { peerId, newPeer });
+      this.logger.trace('Replaced peer', { peerId, newPeer });
     } else {
       // If we couldn't get a replacement, remove the peer and compact the array
       this.batch.splice(index, 1);
-      this.logger.trace(`Removed peer ${peerId}`, { peerId });
+      this.logger.trace('Removed peer', { peerId });
     }
   }
 

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

@@ -17,7 +17,7 @@ export class RandomSampler {
 }
 
 /**
- * A class that samples peers from the libp2p node and returns a peer that we don't already have a connection open to.
+ * A class that samples peers from the libp2p node and returns a peer that we don't already have a reqresp connection open to.
  * If we already have a connection open, we try to sample a different peer.
  * We do this MAX_SAMPLE_ATTEMPTS times, if we still don't find a peer we just go for it.
  *
@@ -69,32 +69,65 @@ export class ConnectionSampler {
   getPeer(excluding?: Map<string, boolean>): PeerId | undefined {
     // In libp2p getPeers performs a shallow copy, so this array can be sliced from safetly
     const peers = this.libp2p.getPeers();
+    const { peer } = this.getPeerFromList(peers, excluding);
+    return peer;
+  }
 
+  /**
+   * Samples a peer from a list of peers, excluding those that have active (reqresp) connections or are in the exclusion list
+   *
+   * @param peers - The list of peers to sample from
+   * @param excluding - The peers to exclude from the sampling
+   * @returns - A peer from the list, or undefined if no peers are available,
+   *          - a boolean indicating if the peer has active connections, and
+   *          - all sampled peers - to enable optional resampling
+   *
+   * @dev The provided list peers, should be mutated by this function. This allows batch sampling
+   *      to be performed without making extra copies of the list.
+   */
+  getPeerFromList(
+    peers: PeerId[],
+    excluding?: Map<string, boolean>,
+  ): {
+    peer: PeerId | undefined;
+    sampledPeers: PeerId[];
+  } {
     if (peers.length === 0) {
-      return undefined;
+      return { peer: undefined, sampledPeers: [] };
     }
 
-    let randomIndex = this.sampler.random(peers.length);
-    let attempts = 0;
-
-    // Keep sampling while:
-    // - we haven't exceeded max attempts AND
-    // - either the peer has active connections OR is in the exclusion list
-    while (
-      attempts < MAX_SAMPLE_ATTEMPTS &&
-      ((this.activeConnectionsCount.get(peers[randomIndex]) ?? 0) > 0 ||
-        (excluding?.get(peers[randomIndex]?.toString()) ?? false))
-    ) {
+    const sampledPeers: PeerId[] = [];
+    // Try to find a peer that has no active connections and is not in the exclusion list
+    for (let attempts = 0; attempts < MAX_SAMPLE_ATTEMPTS && peers.length > 0; attempts++) {
+      const randomIndex = this.sampler.random(peers.length);
+      const peer = peers[randomIndex];
+      const hasActiveConnections = (this.activeConnectionsCount.get(peer) ?? 0) > 0;
+      const isExcluded = excluding?.get(peer.toString()) ?? false;
+
+      // Remove this peer from consideration
       peers.splice(randomIndex, 1);
-      randomIndex = this.sampler.random(peers.length);
-      attempts++;
+
+      // If peer is suitable (no active connections and not excluded), return it
+      if (!hasActiveConnections && !isExcluded) {
+        this.logger.trace('Sampled peer', {
+          attempts,
+          peer,
+        });
+        return { peer, sampledPeers };
+      }
+
+      // Keep track of peers that have active reqresp channels, batch sampling will use these to resample
+      sampledPeers.push(peer);
     }
 
-    this.logger.trace(`Sampled peer in ${attempts} attempts`, {
-      attempts,
-      peer: peers[randomIndex]?.toString(),
+    // If we've exhausted our attempts or peers list is empty, return the last peer if available
+    const lastPeer = peers.length > 0 ? peers[this.sampler.random(peers.length)] : undefined;
+
+    this.logger.trace('Sampled peer', {
+      attempts: MAX_SAMPLE_ATTEMPTS,
+      peer: lastPeer?.toString(),
     });
-    return peers[randomIndex];
+    return { peer: lastPeer, sampledPeers };
   }
 
   /**
@@ -105,34 +138,41 @@ export class ConnectionSampler {
    */
   samplePeersBatch(numberToSample: number): PeerId[] {
     const peers = this.libp2p.getPeers();
-    const sampledPeers: PeerId[] = [];
-    const peersWithConnections: PeerId[] = []; // Hold onto peers with active connections incase we need to sample more
+    this.logger.debug('Sampling peers batch', { numberToSample, peers });
 
-    for (const peer of peers) {
-      const activeConnections = this.activeConnectionsCount.get(peer) ?? 0;
-      if (activeConnections === 0) {
-        if (sampledPeers.push(peer) === numberToSample) {
-          return sampledPeers;
-        }
-      } else {
-        peersWithConnections.push(peer);
+    // Only sample as many peers as we have available
+    numberToSample = Math.min(numberToSample, peers.length);
+
+    const batch: PeerId[] = [];
+    const withActiveConnections: Set<PeerId> = new Set();
+    for (let i = 0; i < numberToSample; i++) {
+      const { peer, sampledPeers } = this.getPeerFromList(peers, undefined);
+      if (peer) {
+        batch.push(peer);
+      }
+      if (sampledPeers.length > 0) {
+        sampledPeers.forEach(peer => withActiveConnections.add(peer));
       }
     }
+    const lengthWithoutConnections = batch.length;
 
     // If we still need more peers, sample from those with connections
-    while (sampledPeers.length < numberToSample && peersWithConnections.length > 0) {
-      const randomIndex = this.sampler.random(peersWithConnections.length);
-      const [peer] = peersWithConnections.splice(randomIndex, 1);
-      sampledPeers.push(peer);
+    while (batch.length < numberToSample && withActiveConnections.size > 0) {
+      const randomIndex = this.sampler.random(withActiveConnections.size);
+
+      const peer = Array.from(withActiveConnections)[randomIndex];
+      withActiveConnections.delete(peer);
+      batch.push(peer);
     }
 
-    this.logger.trace(`Batch sampled ${sampledPeers.length} unique peers`, {
-      peers: sampledPeers,
-      withoutConnections: sampledPeers.length - peersWithConnections.length,
-      withConnections: peersWithConnections.length,
+    this.logger.trace('Batch sampled peers', {
+      length: batch.length,
+      peers: batch,
+      withoutConnections: lengthWithoutConnections,
+      withConnections: numberToSample - lengthWithoutConnections,
     });
 
-    return sampledPeers;
+    return batch;
   }
 
   // Set of passthrough functions to keep track of active connections
@@ -155,8 +195,9 @@ export class ConnectionSampler {
     const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 0) + 1;
     this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
 
-    this.logger.trace(`Dialed protocol ${protocol} with peer ${peerId.toString()}`, {
+    this.logger.trace('Dialed protocol', {
       streamId: stream.id,
+      protocol,
       peerId: peerId.toString(),
       activeConnectionsCount: updatedActiveConnectionsCount,
     });
@@ -181,7 +222,7 @@ export class ConnectionSampler {
       const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 1) - 1;
       this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
 
-      this.logger.trace(`Closing connection to peer ${peerId.toString()}`, {
+      this.logger.trace('Closing connection', {
         streamId,
         peerId: peerId.toString(),
         protocol: stream.protocol,
@@ -207,7 +248,7 @@ export class ConnectionSampler {
         // Check if we have lost track of accounting
         if (this.activeConnectionsCount.get(peerId) === 0) {
           await this.close(streamId);
-          this.logger.debug(`Cleaned up stale connection ${streamId} to peer ${peerId.toString()}`);
+          this.logger.debug('Cleaned up stale connection', { streamId, peerId: peerId.toString() });
         }
       } catch (error) {
         this.logger.error(`Error cleaning up stale connection ${streamId}`, { error });

package/src/services/reqresp/reqresp.ts

@@ -196,7 +196,7 @@ export class ReqResp {
         this.logger.trace(`Sending request to peer: ${peer.toString()}`);
         const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
 
-        if (response && response.status !== ReqRespStatus.SUCCESS) {
+        if (response.status !== ReqRespStatus.SUCCESS) {
           this.logger.debug(
             `Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(response.status)}`,
           );
@@ -264,9 +264,9 @@ export class ReqResp {
     timeoutMs = 10000,
     maxPeers = Math.min(10, requests.length),
     maxRetryAttempts = 3,
-  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]> {
+  ): Promise<(InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[]> {
     const responseValidator = this.subProtocolValidators[subProtocol];
-    const responses: InstanceType<SubProtocolMap[SubProtocol]['response']>[] = new Array(requests.length);
+    const responses: (InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[] = new Array(requests.length);
     const requestBuffers = requests.map(req => req.toBuffer());
 
     const requestFunction = async () => {
@@ -325,7 +325,7 @@ export class ReqResp {
                 const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
 
                 // Check the status of the response buffer
-                if (response && response.status !== ReqRespStatus.SUCCESS) {
+                if (response.status !== ReqRespStatus.SUCCESS) {
                   this.logger.debug(
                     `Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(
                       response.status,
@@ -378,7 +378,7 @@ export class ReqResp {
     };
 
     try {
-      return await executeTimeout<InstanceType<SubProtocolMap[SubProtocol]['response']>[]>(
+      return await executeTimeout<(InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[]>(
         requestFunction,
         timeoutMs,
         () => new CollectiveReqRespTimeoutError(),
@@ -421,7 +421,7 @@ export class ReqResp {
     peerId: PeerId,
     subProtocol: ReqRespSubProtocol,
     payload: Buffer,
-  ): Promise<ReqRespResponse | undefined> {
+  ): Promise<ReqRespResponse> {
     let stream: Stream | undefined;
     try {
       this.metrics.recordRequestSent(subProtocol);
@@ -439,6 +439,12 @@ export class ReqResp {
     } catch (e: any) {
       this.metrics.recordRequestError(subProtocol);
       this.handleResponseError(e, peerId, subProtocol);
+
+      // If there is an exception, we return an unknown response
+      return {
+        status: ReqRespStatus.FAILURE,
+        data: Buffer.from([]),
+      };
     } finally {
       // Only close the stream if we created it
       if (stream) {

package/src/services/reqresp/status.ts

@@ -5,6 +5,7 @@ export enum ReqRespStatus {
   SUCCESS = 0,
   RATE_LIMIT_EXCEEDED = 1,
   BADLY_FORMED_REQUEST = 2,
+  FAILURE = 126,
   UNKNOWN = 127,
 }
 
@@ -53,6 +54,8 @@ export function prettyPrintReqRespStatus(status: ReqRespStatus) {
       return 'RATE_LIMIT_EXCEEDED';
     case ReqRespStatus.BADLY_FORMED_REQUEST:
       return 'BADLY_FORMED_REQUEST';
+    case ReqRespStatus.FAILURE:
+      return 'FAILURE';
     case ReqRespStatus.UNKNOWN:
       return 'UNKNOWN';
   }

package/src/services/service.ts

@@ -56,7 +56,7 @@ export interface P2PService {
   sendBatchRequest<Protocol extends ReqRespSubProtocol>(
     protocol: Protocol,
     requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[] | undefined>;
+  ): Promise<(InstanceType<SubProtocolMap[Protocol]['response']> | undefined)[]>;
 
   // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
   registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void;
@@ -81,10 +81,10 @@ export interface PeerDiscoveryService extends EventEmitter {
   stop(): Promise<void>;
 
   /**
-   * Gets all peers.
-   * @returns An array of peer ENRs.
+   * Gets all KadValues.
+   * @returns An array of ENRs.
    */
-  getAllPeers(): ENR[];
+  getKadValues(): ENR[];
 
   /**
    * Runs findRandomNode query.

package/src/test-helpers/make-test-p2p-clients.ts

@@ -1,6 +1,7 @@
 import { MockL2BlockSource } from '@aztec/archiver/test';
 import type { EpochCache } from '@aztec/epoch-cache';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
@@ -57,6 +58,7 @@ export async function makeTestP2PClient(
     p2pEnabled: true,
     peerIdPrivateKey,
     p2pIp: `127.0.0.1`,
+    listenAddress: `127.0.0.1`,
     p2pPort: port,
     bootstrapNodes: peers,
     peerCheckIntervalMS: 1000,
@@ -101,7 +103,16 @@ export async function makeTestP2PClients(numberOfPeers: number, testConfig: Make
   const clients: P2PClient[] = [];
   const peerIdPrivateKeys = generatePeerIdPrivateKeys(numberOfPeers);
 
-  const ports = await getPorts(numberOfPeers);
+  let ports = [];
+  while (true) {
+    try {
+      ports = await getPorts(numberOfPeers);
+      break;
+    } catch (err) {
+      await sleep(1000);
+    }
+  }
+
   const peerEnrs = await makeEnrs(peerIdPrivateKeys, ports, testConfig.p2pBaseConfig);
 
   for (let i = 0; i < numberOfPeers; i++) {
@@ -113,5 +124,12 @@ export async function makeTestP2PClients(numberOfPeers: number, testConfig: Make
   }
 
   await Promise.all(clients.map(client => client.isReady()));
-  return clients;
+  return clients.map((client, index) => {
+    return {
+      client,
+      peerPrivateKey: peerIdPrivateKeys[index],
+      port: ports[index],
+      enr: peerEnrs[index],
+    };
+  });
 }