@aztec/p2p 0.86.0-starknet.1 → 0.87.0

package/src/services/discv5/discV5_service.ts

@@ -10,9 +10,9 @@ import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
 import EventEmitter from 'events';
 
 import type { P2PConfig } from '../../config.js';
+import { createNodeENR } from '../../enr/generate-enr.js';
 import { AZTEC_ENR_KEY, Discv5Event, PeerEvent } from '../../types/index.js';
 import { convertToMultiaddr } from '../../util.js';
-import { setAztecEnrKey } from '../../versioning.js';
 import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
 
 const delayBeforeStart = 2000; // 2sec
@@ -22,7 +22,7 @@ const delayBeforeStart = 2000; // 2sec
  */
 export class DiscV5Service extends EventEmitter implements PeerDiscoveryService {
   /** The Discv5 instance */
-  private discv5: Discv5 & Discv5EventEmitter;
+  private discv5: Discv5EventEmitter;
 
   /** This instance's ENR */
   private enr: SignableENR;
@@ -47,6 +47,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   constructor(
     private peerId: PeerId,
     private config: P2PConfig,
+    private readonly packageVersion: string,
     telemetry: TelemetryClient = getTelemetryClient(),
     private logger = createLogger('p2p:discv5_service'),
     configOverrides: Partial<IDiscv5CreateOptions> = {},
@@ -57,10 +58,6 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     this.bootstrapNodeEnrs = bootstrapNodes.map(x => ENR.decodeTxt(x));
     const privatePeerEnrs = new Set(privatePeers);
     this.trustedPeerEnrs = trustedPeers.filter(x => !privatePeerEnrs.has(x)).map(x => ENR.decodeTxt(x));
-    // create ENR from PeerId
-    this.enr = SignableENR.createFromPeerId(peerId);
-    // Add aztec identification to ENR
-    this.versions = setAztecEnrKey(this.enr, config);
 
     // If no overridden broadcast port is provided, use the p2p port as the broadcast port
     if (!p2pBroadcastPort) {
@@ -72,19 +69,24 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       ip4: multiaddr(convertToMultiaddr(config.listenAddress, p2pPort, 'udp')),
     };
 
+    let multiAddrUdp, multiAddrTcp;
     if (p2pIp) {
-      const multiAddrTcp = multiaddr(
+      multiAddrTcp = multiaddr(
         `${convertToMultiaddr(p2pIp!, config.p2pBroadcastPort!, 'tcp')}/p2p/${peerId.toString()}`,
       );
-      const multiAddrUdp = multiaddr(
+      multiAddrUdp = multiaddr(
         `${convertToMultiaddr(p2pIp!, config.p2pBroadcastPort!, 'udp')}/p2p/${peerId.toString()}`,
       );
-
-      // set location multiaddr in ENR record
-      this.enr.setLocationMultiaddr(multiAddrUdp);
-      this.enr.setLocationMultiaddr(multiAddrTcp);
     }
 
+    ({ enr: this.enr, versions: this.versions } = createNodeENR(
+      peerId,
+      multiAddrUdp,
+      multiAddrTcp,
+      config,
+      this.packageVersion,
+    ));
+
     const metricsRegistry = new OtelMetricsAdapter(telemetry);
     this.discv5 = Discv5.create({
       enr: this.enr,

package/src/services/dummy_service.ts

@@ -1,6 +1,6 @@
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
 import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
-import { TxHash } from '@aztec/stdlib/tx';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
@@ -38,7 +38,9 @@ export class DummyP2PService implements P2PService {
    * Called to have the given message propagated through the P2P network.
    * @param _ - The message to be propagated.
    */
-  public propagate<T extends Gossipable>(_: T) {}
+  public propagate<T extends Gossipable>(_: T) {
+    return Promise.resolve();
+  }
 
   /**
    * Called upon receipt of settled transactions.
@@ -84,6 +86,10 @@ export class DummyP2PService implements P2PService {
   public getEnr(): undefined {
     return undefined;
   }
+
+  validate(_txs: Tx[]): Promise<void> {
+    return Promise.resolve();
+  }
 }
 
 /**

package/src/services/libp2p/libp2p_service.ts

@@ -1,11 +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 { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { ProtocolContractAddress, protocolContractTreeRoot } 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';
@@ -15,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';
@@ -50,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';
@@ -72,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;
@@ -234,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: {
@@ -271,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,
@@ -490,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;
   }
@@ -508,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;
@@ -541,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 };
     };
@@ -564,9 +564,9 @@ 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.slotNumber.toString(),
@@ -595,9 +595,9 @@ 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.slotNumber.toString(),
@@ -630,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
@@ -721,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> {
@@ -749,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.
    *
@@ -758,53 +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({
-          l1ChainId: new Fr(this.config.l1ChainId),
-          rollupVersion: new Fr(this.config.rollupVersion),
-          blockNumber: new Fr(blockNumber),
-          protocolContractTreeRoot,
-          vkTreeRoot: getVKTreeRoot(),
-        }),
-        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,
+    );
   }
 
   /**
@@ -823,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,
+      };
+    }
   }
 
   /**
@@ -929,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

@@ -420,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>(