@aztec/p2p 0.76.4 → 0.77.0-testnet-ignition.21

package/src/services/libp2p/libp2p_service.ts

@@ -1,31 +1,26 @@
+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 type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ClientProtocolCircuitVerifier, PeerInfo, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import {
   BlockAttestation,
   BlockProposal,
-  type ClientProtocolCircuitVerifier,
   type Gossipable,
-  type L2BlockSource,
-  MerkleTreeId,
   P2PClientType,
   PeerErrorSeverity,
-  type PeerInfo,
-  type RawGossipMessage,
   TopicTypeMap,
-  Tx,
-  type TxHash,
-  type TxValidationResult,
-  type WorldStateSynchronizer,
   getTopicTypeForClientType,
   metricsTopicStrToLabels,
-} from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
-import { type EpochCacheInterface } from '@aztec/epoch-cache';
-import { 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';
+} from '@aztec/stdlib/p2p';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { Tx, type TxHash, type TxValidationResult } from '@aztec/stdlib/tx';
 import { Attributes, OtelMetricsAdapter, type TelemetryClient, WithTracer, trackSpan } from '@aztec/telemetry-client';
 
-import { type ENR } from '@chainsafe/enr';
+import type { ENR } from '@chainsafe/enr';
 import {
   type GossipSub,
   type GossipSubComponents,
@@ -39,14 +34,14 @@ import { yamux } from '@chainsafe/libp2p-yamux';
 import { bootstrap } from '@libp2p/bootstrap';
 import { identify } from '@libp2p/identify';
 import { type Message, type PeerId, TopicValidatorResult } from '@libp2p/interface';
-import { type ConnectionManager } from '@libp2p/interface-internal';
+import type { ConnectionManager } from '@libp2p/interface-internal';
 import '@libp2p/kad-dht';
 import { mplex } from '@libp2p/mplex';
 import { tcp } from '@libp2p/tcp';
 import { createLibp2p } from 'libp2p';
 
-import { type P2PConfig } from '../../config.js';
-import { type MemPools } from '../../mem_pools/interface.js';
+import type { P2PConfig } from '../../config.js';
+import type { MemPools } from '../../mem_pools/interface.js';
 import { AttestationValidator, BlockProposalValidator } from '../../msg_validators/index.js';
 import {
   DataTxValidator,
@@ -54,9 +49,11 @@ import {
   MetadataTxValidator,
   TxProofValidator,
 } from '../../msg_validators/tx_validator/index.js';
+import { GossipSubEvent } from '../../types/index.js';
 import { type PubSubLibp2p, convertToMultiaddr } from '../../util.js';
 import { AztecDatastore } from '../data_store.js';
 import { SnappyTransform, fastMsgIdFn, getMsgIdFn, msgIdToStrFn } from '../encoding.js';
+import { gossipScoreThresholds } from '../gossipsub/scoring.js';
 import { PeerManager } from '../peer-manager/peer_manager.js';
 import { PeerScoring } from '../peer-manager/peer_scoring.js';
 import { DEFAULT_SUB_PROTOCOL_VALIDATORS, ReqRespSubProtocol, type SubProtocolMap } from '../reqresp/interface.js';
@@ -64,8 +61,6 @@ 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 { GossipSubEvent } from '../types.js';
-import { createLibp2pComponentLogger } from './libp2p_logger.js';
 
 interface MessageValidator {
   validator: {
@@ -211,9 +206,9 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       connectionEncryption: [noise()],
       connectionManager: {
         minConnections: 0,
-        maxConnections: maxPeerCount,
 
         maxParallelDials: 100,
+        dialTimeout: 30_000,
         maxPeerAddrsToDial: 5,
         maxIncomingPendingConnections: 5,
       },
@@ -233,8 +228,6 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
           heartbeatInterval: config.gossipsubInterval,
           mcacheLength: config.gossipsubMcacheLength,
           mcacheGossip: config.gossipsubMcacheGossip,
-          // Increased from default 3s to give time for input lag: configuration and rationale from lodestar
-          gossipsubIWantFollowupMs: 12 * 1000,
           msgIdFn: getMsgIdFn,
           msgIdToStrFn: msgIdToStrFn,
           fastMsgIdFn: fastMsgIdFn,
@@ -242,6 +235,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
           metricsRegister: otelMetricsAdapter,
           metricsTopicStrToLabel: metricsTopicStrToLabels(),
           asyncValidation: true,
+          scoreThresholds: gossipScoreThresholds,
           scoreParams: createPeerScoreParams({
             // IPColocation factor can be disabled for local testing - default to -5
             IPColocationFactorWeight: config.debugDisableColocationPenalty ? 0 : -5.0,
@@ -256,7 +250,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
                 invalidMessageDeliveriesWeight: -20,
                 invalidMessageDeliveriesDecay: 0.5,
               }),
-              [BlockAttestation.p2pTopic]: createTopicScoreParams({
+              [BlockProposal.p2pTopic]: createTopicScoreParams({
                 topicWeight: 1,
                 invalidMessageDeliveriesWeight: -20,
                 invalidMessageDeliveriesDecay: 0.5,
@@ -268,8 +262,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
           connectionManager: components.connectionManager,
         }),
       },
-      // Fix the peer id in libp2p logs so we can see the source of the log
-      logger: createLibp2pComponentLogger(logger.module, { sourcePeerId: peerId }),
+      logger: createLibp2pComponentLogger(logger.module),
     });
 
     return new LibP2PService(
@@ -327,26 +320,6 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       [ReqRespSubProtocol.BLOCK]: blockHandler.bind(this),
     };
 
-    // Add p2p topic validators
-    // As they are stored within a kv pair, there is no need to register them conditionally
-    // based on the client type
-    const topicValidators = {
-      [Tx.p2pTopic]: this.validatePropagatedTxFromMessage.bind(this),
-      [BlockAttestation.p2pTopic]: this.validatePropagatedAttestationFromMessage.bind(this),
-      [BlockProposal.p2pTopic]: this.validatePropagatedBlockFromMessage.bind(this),
-    };
-    // When running bandwidth benchmarks, we use send blobs of data we do not want to validate
-    // NEVER switch this off in production
-    if (!this.config.debugDisableMessageValidation) {
-      for (const [topic, validator] of Object.entries(topicValidators)) {
-        this.node.services.pubsub.topicValidators.set(topic, validator);
-      }
-    } else {
-      this.logger.warn(
-        'MESSAGE VALIDATION DISABLED - IF YOU SEE THIS LOG AND ARE NOT DEBUGGING AND ARE RUNNING IN A PRODUCTION ENVIRONMENT, PLEASE RE-ENABLE MESSAGE VALIDATION',
-      );
-    }
-
     // add GossipSub listener
     this.node.services.pubsub.addEventListener(GossipSubEvent.MESSAGE, this.handleGossipSubEvent.bind(this));
 
@@ -402,12 +375,16 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
   }
 
   private handleGossipSubEvent(e: CustomEvent<GossipsubMessage>) {
-    const { msg } = e.detail;
     this.logger.trace(`Received PUBSUB message.`);
 
-    void this.jobQueue
-      .put(() => this.handleNewGossipMessage(msg))
-      .catch(err => this.logger.error(`Error processing gossip message`, err));
+    const safeJob = async () => {
+      try {
+        await this.handleNewGossipMessage(e.detail.msg, e.detail.msgId, e.detail.propagationSource);
+      } catch (err) {
+        this.logger.error(`Error handling gossipsub message: ${err}`);
+      }
+    };
+    setImmediate(() => void safeJob());
   }
 
   /**
@@ -484,35 +461,81 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
    * @param topic - The message's topic.
    * @param data - The message data
    */
-  private async handleNewGossipMessage(message: RawGossipMessage) {
-    if (message.topic === Tx.p2pTopic) {
-      const tx = Tx.fromBuffer(Buffer.from(message.data));
-      await this.processTxFromPeer(tx);
+  private async handleNewGossipMessage(msg: Message, msgId: string, source: PeerId) {
+    if (msg.topic === Tx.p2pTopic) {
+      await this.handleGossipedTx(msg, msgId, source);
     }
-    if (message.topic === BlockAttestation.p2pTopic && this.clientType === P2PClientType.Full) {
-      const attestation = BlockAttestation.fromBuffer(Buffer.from(message.data));
-      await this.processAttestationFromPeer(attestation);
+    if (msg.topic === BlockAttestation.p2pTopic && this.clientType === P2PClientType.Full) {
+      await this.processAttestationFromPeer(msg, msgId, source);
     }
-    if (message.topic == BlockProposal.p2pTopic) {
-      const block = BlockProposal.fromBuffer(Buffer.from(message.data));
-      await this.processBlockFromPeer(block);
+    if (msg.topic == BlockProposal.p2pTopic) {
+      await this.processBlockFromPeer(msg, msgId, source);
     }
 
     return;
   }
 
+  private async validateReceivedMessage<T>(
+    validationFunc: () => Promise<{ result: boolean; obj: T }>,
+    msgId: string,
+    source: PeerId,
+  ): Promise<{ result: boolean; obj: T | undefined }> {
+    let resultAndObj: { result: boolean; obj: T | undefined } = { result: false, obj: undefined };
+    try {
+      resultAndObj = await validationFunc();
+    } catch (err) {
+      this.logger.error(`Error deserialising and validating message `, err);
+    }
+
+    this.node.services.pubsub.reportMessageValidationResult(
+      msgId,
+      source.toString(),
+      resultAndObj.result && resultAndObj.obj ? TopicValidatorResult.Accept : TopicValidatorResult.Reject,
+    );
+    return resultAndObj;
+  }
+
+  private async handleGossipedTx(msg: Message, msgId: string, source: PeerId) {
+    const validationFunc = async () => {
+      const tx = Tx.fromBuffer(Buffer.from(msg.data));
+      const result = await this.validatePropagatedTx(tx, source);
+      return { result, obj: tx };
+    };
+
+    const { result, obj: tx } = await this.validateReceivedMessage<Tx>(validationFunc, msgId, source);
+    if (!result || !tx) {
+      return;
+    }
+    const txHash = await tx.getTxHash();
+    const txHashString = txHash.toString();
+    this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
+    await this.mempools.txPool.addTxs([tx]);
+  }
+
   /**Process Attestation From Peer
    * When a proposal is received from a peer, we add it to the attestation pool, so it can be accessed by other services.
    *
    * @param attestation - The attestation to process.
    */
-  @trackSpan('Libp2pService.processAttestationFromPeer', async attestation => ({
-    [Attributes.BLOCK_NUMBER]: attestation.payload.header.globalVariables.blockNumber.toNumber(),
-    [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toNumber(),
-    [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
-    [Attributes.P2P_ID]: await attestation.p2pMessageIdentifier().then(i => i.toString()),
-  }))
-  private async processAttestationFromPeer(attestation: BlockAttestation): Promise<void> {
+  private async processAttestationFromPeer(msg: Message, msgId: string, source: PeerId): Promise<void> {
+    const validationFunc = async () => {
+      const attestation = BlockAttestation.fromBuffer(Buffer.from(msg.data));
+      const result = await this.validateAttestation(source, attestation);
+      this.logger.trace(`validatePropagatedAttestation: ${result}`, {
+        [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toString(),
+        [Attributes.P2P_ID]: source.toString(),
+      });
+      return { result, obj: attestation };
+    };
+
+    const { result, obj: attestation } = await this.validateReceivedMessage<BlockAttestation>(
+      validationFunc,
+      msgId,
+      source,
+    );
+    if (!result || !attestation) {
+      return;
+    }
     this.logger.debug(
       `Received attestation for block ${attestation.blockNumber.toNumber()} slot ${attestation.slotNumber.toNumber()} from external peer.`,
       {
@@ -525,20 +548,32 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     await this.mempools.attestationPool!.addAttestations([attestation]);
   }
 
-  /**Process block from peer
-   *
-   * Pass the received block to the validator client
-   *
-   * @param block - The block to process.
-   */
+  private async processBlockFromPeer(msg: Message, msgId: string, source: PeerId): Promise<void> {
+    const validationFunc = async () => {
+      const block = BlockProposal.fromBuffer(Buffer.from(msg.data));
+      const result = await this.validateBlockProposal(source, block);
+      this.logger.trace(`validatePropagatedBlock: ${result}`, {
+        [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString(),
+        [Attributes.P2P_ID]: source.toString(),
+      });
+      return { result, obj: block };
+    };
+
+    const { result, obj: block } = await this.validateReceivedMessage<BlockProposal>(validationFunc, msgId, source);
+    if (!result || !block) {
+      return;
+    }
+    await this.processValidBlockProposal(block);
+  }
+
   // REVIEW: callback pattern https://github.com/AztecProtocol/aztec-packages/issues/7963
-  @trackSpan('Libp2pService.processBlockFromPeer', async block => ({
+  @trackSpan('Libp2pService.processValidBlockProposal', async block => ({
     [Attributes.BLOCK_NUMBER]: block.blockNumber.toNumber(),
     [Attributes.SLOT_NUMBER]: block.slotNumber.toNumber(),
     [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
     [Attributes.P2P_ID]: await block.p2pMessageIdentifier().then(i => i.toString()),
   }))
-  private async processBlockFromPeer(block: BlockProposal): Promise<void> {
+  private async processValidBlockProposal(block: BlockProposal) {
     this.logger.verbose(
       `Received block ${block.blockNumber.toNumber()} for slot ${block.slotNumber.toNumber()} from external peer.`,
       {
@@ -587,16 +622,13 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
   public async propagate<T extends Gossipable>(message: T) {
     const p2pMessageIdentifier = await message.p2pMessageIdentifier();
     this.logger.trace(`Message ${p2pMessageIdentifier} queued`, { p2pMessageIdentifier });
-    void this.jobQueue.put(async () => {
-      await this.sendToPeers(message);
-    });
-  }
-
-  private async processTxFromPeer(tx: Tx): Promise<void> {
-    const txHash = await tx.getTxHash();
-    const txHashString = txHash.toString();
-    this.logger.verbose(`Received tx ${txHashString} from external peer.`);
-    await this.mempools.txPool.addTxs([tx]);
+    void this.jobQueue
+      .put(async () => {
+        await this.sendToPeers(message);
+      })
+      .catch(error => {
+        this.logger.error(`Error propagating message ${p2pMessageIdentifier}`, { error });
+      });
   }
 
   /**
@@ -636,63 +668,6 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     return true;
   }
 
-  /**
-   * Validate a tx from a peer.
-   * @param propagationSource - The peer ID of the peer that sent the tx.
-   * @param msg - The tx message.
-   * @returns True if the tx is valid, false otherwise.
-   */
-  private async validatePropagatedTxFromMessage(
-    propagationSource: PeerId,
-    msg: Message,
-  ): Promise<TopicValidatorResult> {
-    const tx = Tx.fromBuffer(Buffer.from(msg.data));
-    const isValid = await this.validatePropagatedTx(tx, propagationSource);
-    this.logger.trace(`validatePropagatedTx: ${isValid}`, {
-      [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
-      [Attributes.P2P_ID]: propagationSource.toString(),
-    });
-    return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
-  }
-
-  /**
-   * Validate an attestation from a peer.
-   * @param propagationSource - The peer ID of the peer that sent the attestation.
-   * @param msg - The attestation message.
-   * @returns True if the attestation is valid, false otherwise.
-   */
-  private async validatePropagatedAttestationFromMessage(
-    propagationSource: PeerId,
-    msg: Message,
-  ): Promise<TopicValidatorResult> {
-    const attestation = BlockAttestation.fromBuffer(Buffer.from(msg.data));
-    const isValid = await this.validateAttestation(propagationSource, attestation);
-    this.logger.trace(`validatePropagatedAttestation: ${isValid}`, {
-      [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toString(),
-      [Attributes.P2P_ID]: propagationSource.toString(),
-    });
-    return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
-  }
-
-  /**
-   * Validate a block proposal from a peer.
-   * @param propagationSource - The peer ID of the peer that sent the block.
-   * @param msg - The block proposal message.
-   * @returns True if the block proposal is valid, false otherwise.
-   */
-  private async validatePropagatedBlockFromMessage(
-    propagationSource: PeerId,
-    msg: Message,
-  ): Promise<TopicValidatorResult> {
-    const block = BlockProposal.fromBuffer(Buffer.from(msg.data));
-    const isValid = await this.validateBlockProposal(propagationSource, block);
-    this.logger.trace(`validatePropagatedBlock: ${isValid}`, {
-      [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString(),
-      [Attributes.P2P_ID]: propagationSource.toString(),
-    });
-    return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
-  }
-
   @trackSpan('Libp2pService.validatePropagatedTx', async tx => ({
     [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
   }))
@@ -832,8 +807,11 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
    * @param attestation - The attestation to validate.
    * @returns True if the attestation is valid, false otherwise.
    */
-  @trackSpan('Libp2pService.validateAttestation', (_peerId, attestation) => ({
-    [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toString(),
+  @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_ARCHIVE]: attestation.archive.toString(),
+    [Attributes.P2P_ID]: await attestation.p2pMessageIdentifier().then(i => i.toString()),
   }))
   public async validateAttestation(peerId: PeerId, attestation: BlockAttestation): Promise<boolean> {
     const severity = await this.attestationValidator.validate(attestation);

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

@@ -1,19 +1,20 @@
-import { type PeerErrorSeverity, type PeerInfo } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
+import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
+import type { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import { type ENR } from '@chainsafe/enr';
-import { type Connection, type PeerId } from '@libp2p/interface';
-import { type Multiaddr } from '@multiformats/multiaddr';
+import type { ENR } from '@chainsafe/enr';
+import type { Connection, PeerId } from '@libp2p/interface';
+import type { Multiaddr } from '@multiformats/multiaddr';
 import { inspect } from 'util';
 
-import { type P2PConfig } from '../../config.js';
-import { type PubSubLibp2p } from '../../util.js';
+import type { P2PConfig } from '../../config.js';
+import { PeerEvent } from '../../types/index.js';
+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 { type PeerDiscoveryService } from '../service.js';
-import { PeerEvent } from '../types.js';
+import type { ReqResp } from '../reqresp/reqresp.js';
+import type { PeerDiscoveryService } from '../service.js';
 import { PeerManagerMetrics } from './metrics.js';
 import { PeerScoreState, type PeerScoring } from './peer_scoring.js';
 
@@ -189,14 +190,14 @@ export class PeerManager {
   private discover() {
     const connections = this.libP2PNode.getConnections();
 
-    const healthyConnections = this.pruneUnhealthyPeers(connections);
+    const healthyConnections = this.prioritizePeers(this.pruneUnhealthyPeers(this.pruneDuplicatePeers(connections)));
 
     // Calculate how many connections we're looking to make
     const peersToConnect = this.config.maxPeerCount - healthyConnections.length;
 
     const logLevel = this.heartbeatCounter % this.displayPeerCountsPeerHeartbeat === 0 ? 'info' : 'debug';
-    this.logger[logLevel](`Connected to ${connections.length} peers`, {
-      connections: connections.length,
+    this.logger[logLevel](`Connected to ${healthyConnections.length} peers`, {
+      connections: healthyConnections.length,
       maxPeerCount: this.config.maxPeerCount,
       cachedPeers: this.cachedPeers.size,
       ...this.peerScoring.getStats(),
@@ -257,7 +258,7 @@ export class PeerManager {
           void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.BANNED);
           break;
         case PeerScoreState.Disconnect:
-          void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.DISCONNECTED);
+          void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.LOW_SCORE);
           break;
         case PeerScoreState.Healthy:
           connectedHealthyPeers.push(peer);
@@ -267,6 +268,63 @@ export class PeerManager {
     return connectedHealthyPeers;
   }
 
+  /**
+   * If the max peer count is reached, the lowest scoring peers will be pruned to satisfy the max peer count.
+   *
+   * @param connections - The list of connections to prune low scoring peers above the max peer count from.
+   * @returns The pruned list of connections.
+   */
+  private prioritizePeers(connections: Connection[]): Connection[] {
+    if (connections.length > this.config.maxPeerCount) {
+      // Sort the peer scores from lowest to highest
+      const prioritizedConnections = connections.sort((connectionA, connectionB) => {
+        const connectionScoreA = this.peerScoring.getScore(connectionA.remotePeer.toString());
+        const connectionScoreB = this.peerScoring.getScore(connectionB.remotePeer.toString());
+        return connectionScoreB - connectionScoreA;
+      });
+
+      // Disconnect from the lowest scoring connections.
+      for (const conn of prioritizedConnections.slice(this.config.maxPeerCount)) {
+        void this.goodbyeAndDisconnectPeer(conn.remotePeer, GoodByeReason.MAX_PEERS);
+      }
+      return prioritizedConnections.slice(0, this.config.maxPeerCount);
+    } else {
+      return connections;
+    }
+  }
+
+  /**
+   * If multiple connections to the same peer are found, the oldest connection is kept and the duplicates are pruned.
+   *
+   * This is necessary to resolve a race condition where multiple connections to the same peer are established if
+   * they are discovered at the same time.
+   *
+   * @param connections - The list of connections to prune duplicate peers from.
+   * @returns The pruned list of connections.
+   */
+  private pruneDuplicatePeers(connections: Connection[]): Connection[] {
+    const peerConnections = new Map<string, Connection>();
+
+    for (const conn of connections) {
+      const peerId = conn.remotePeer.toString();
+      const existingConnection = peerConnections.get(peerId);
+      if (!existingConnection) {
+        peerConnections.set(peerId, conn);
+      } else {
+        // Keep the oldest connection for each peer
+        this.logger.debug(`Found duplicate connection to peer ${peerId}, keeping oldest connection`);
+        if (conn.timeline.open < existingConnection.timeline.open) {
+          peerConnections.set(peerId, conn);
+          void existingConnection.close();
+        } else {
+          void conn.close();
+        }
+      }
+    }
+
+    return [...peerConnections.values()];
+  }
+
   private async goodbyeAndDisconnectPeer(peer: PeerId, reason: GoodByeReason) {
     this.logger.debug(`Disconnecting peer ${peer.toString()} with reason ${prettyGoodbyeReason(reason)}`);
 

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

@@ -1,10 +1,10 @@
-import { PeerErrorSeverity } from '@aztec/circuit-types';
 import { median } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
-import { type PeerId } from '@libp2p/interface';
+import type { PeerId } from '@libp2p/interface';
 
-import { type P2PConfig } from '../../config.js';
+import type { P2PConfig } from '../../config.js';
 
 const DefaultPeerPenalties = {
   [PeerErrorSeverity.LowToleranceError]: 50,

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

@@ -1,8 +1,8 @@
 import { createLogger } from '@aztec/foundation/log';
 
-import { type PeerId } from '@libp2p/interface';
+import type { PeerId } from '@libp2p/interface';
 
-import { type ConnectionSampler } from './connection_sampler.js';
+import type { ConnectionSampler } from './connection_sampler.js';
 
 /**
  * Manages batches of peers for parallel request processing.

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

@@ -1,7 +1,7 @@
 import { createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 
-import { type Libp2p, type PeerId, type Stream } from '@libp2p/interface';
+import type { Libp2p, PeerId, Stream } from '@libp2p/interface';
 
 const MAX_SAMPLE_ATTEMPTS = 4;
 
@@ -170,7 +170,13 @@ export class ConnectionSampler {
    */
   async close(streamId: string): Promise<void> {
     try {
-      const { stream, peerId } = this.streams.get(streamId)!;
+      const streamAndPeerId = this.streams.get(streamId);
+      if (!streamAndPeerId) {
+        this.logger.warn(`Stream ${streamId} not found`);
+        return;
+      }
+
+      const { stream, peerId } = streamAndPeerId;
 
       const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 1) - 1;
       this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
@@ -184,7 +190,7 @@ export class ConnectionSampler {
 
       await stream?.close();
     } catch (error) {
-      this.logger.warn(`Failed to close connection to peer with stream id ${streamId}`);
+      this.logger.error(`Failed to close connection to peer with stream id ${streamId}`, error);
     } finally {
       this.streams.delete(streamId);
     }

package/src/services/reqresp/interface.ts

@@ -1,9 +1,10 @@
-import { L2Block, Tx, TxHash } from '@aztec/circuit-types';
 import { Fr } from '@aztec/foundation/fields';
+import { L2Block } from '@aztec/stdlib/block';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
 
-import { type PeerId } from '@libp2p/interface';
+import type { PeerId } from '@libp2p/interface';
 
-import { type ReqRespStatus } from './status.js';
+import type { ReqRespStatus } from './status.js';
 
 /*
  * Request Response Sub Protocols

package/src/services/reqresp/metrics.ts

@@ -1,6 +1,6 @@
 // Request response metrics
 import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
-import { type TelemetryClient, type Tracer, type UpDownCounter } from '@aztec/telemetry-client';
+import type { TelemetryClient, Tracer, UpDownCounter } from '@aztec/telemetry-client';
 
 export class ReqRespMetrics {
   public readonly tracer: Tracer;

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

@@ -1,9 +1,9 @@
-import { type L2BlockSource } from '@aztec/circuit-types';
 import { Fr } from '@aztec/foundation/fields';
+import type { L2BlockSource } from '@aztec/stdlib/block';
 
-import { type PeerId } from '@libp2p/interface';
+import type { PeerId } from '@libp2p/interface';
 
-import { type ReqRespSubProtocolHandler } from '../interface.js';
+import type { ReqRespSubProtocolHandler } from '../interface.js';
 
 export function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubProtocolHandler {
   return async (_peerId: PeerId, msg: Buffer) => {