@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.24de95ac

package/dest/services/reqresp/config.d.ts

@@ -1,16 +1,18 @@
 import { type ConfigMapping } from '@aztec/foundation/config';
-export declare const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 2000;
-export declare const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 4000;
+export declare const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 10000;
+export declare const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 10000;
+export declare const DEFAULT_REQRESP_DIAL_TIMEOUT_MS = 5000;
+export declare const DEFAULT_OPTIMISTIC_NEGOTIATION = false;
 export declare const DEFAULT_P2P_REQRESP_CONFIG: P2PReqRespConfig;
 export interface P2PReqRespConfig {
-    /**
-     * The overall timeout for a request response operation.
-     */
+    /** The overall timeout for a request response operation. */
     overallRequestTimeoutMs: number;
-    /**
-     * The timeout for an individual request response peer interaction.
-     */
+    /** The timeout for an individual request response peer interaction. */
     individualRequestTimeoutMs: number;
+    /** Whether to use optimistic protocol negotiation when dialing to another peer (opposite of `negotiateFully`). */
+    p2pOptimisticNegotiation: boolean;
+    /** How long to wait for the dial protocol to establish a connection */
+    dialTimeoutMs: number;
 }
 export declare const p2pReqRespConfigMappings: Record<keyof P2PReqRespConfig, ConfigMapping>;
 //# sourceMappingURL=config.d.ts.map

package/dest/services/reqresp/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAsB,MAAM,0BAA0B,CAAC;AAElF,eAAO,MAAM,qCAAqC,OAAO,CAAC;AAC1D,eAAO,MAAM,kCAAkC,OAAO,CAAC;AAGvD,eAAO,MAAM,0BAA0B,EAAE,gBAGxC,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAEhC;;OAEG;IACH,0BAA0B,EAAE,MAAM,CAAC;CACpC;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,gBAAgB,EAAE,aAAa,CAWlF,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAA2C,MAAM,0BAA0B,CAAC;AAEvG,eAAO,MAAM,qCAAqC,QAAS,CAAC;AAC5D,eAAO,MAAM,kCAAkC,QAAS,CAAC;AACzD,eAAO,MAAM,+BAA+B,OAAQ,CAAC;AACrD,eAAO,MAAM,8BAA8B,QAAQ,CAAC;AAGpD,eAAO,MAAM,0BAA0B,EAAE,gBAKxC,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,uBAAuB,EAAE,MAAM,CAAC;IAEhC,uEAAuE;IACvE,0BAA0B,EAAE,MAAM,CAAC;IAEnC,kHAAkH;IAClH,wBAAwB,EAAE,OAAO,CAAC;IAElC,uEAAuE;IACvE,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,gBAAgB,EAAE,aAAa,CAsBlF,CAAC"}

package/dest/services/reqresp/config.js

@@ -1,10 +1,14 @@
-import { numberConfigHelper } from '@aztec/foundation/config';
-export const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 2000;
-export const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 4000;
+import { booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
+export const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 10_000;
+export const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 10_000; // Not currently used
+export const DEFAULT_REQRESP_DIAL_TIMEOUT_MS = 5_000;
+export const DEFAULT_OPTIMISTIC_NEGOTIATION = false;
 // For use in tests.
 export const DEFAULT_P2P_REQRESP_CONFIG = {
     overallRequestTimeoutMs: DEFAULT_OVERALL_REQUEST_TIMEOUT_MS,
-    individualRequestTimeoutMs: DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS
+    individualRequestTimeoutMs: DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS,
+    dialTimeoutMs: DEFAULT_REQRESP_DIAL_TIMEOUT_MS,
+    p2pOptimisticNegotiation: DEFAULT_OPTIMISTIC_NEGOTIATION
 };
 export const p2pReqRespConfigMappings = {
     overallRequestTimeoutMs: {
@@ -16,5 +20,15 @@ export const p2pReqRespConfigMappings = {
         env: 'P2P_REQRESP_INDIVIDUAL_REQUEST_TIMEOUT_MS',
         description: 'The timeout for an individual request response peer interaction.',
         ...numberConfigHelper(DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS)
+    },
+    dialTimeoutMs: {
+        env: 'P2P_REQRESP_DIAL_TIMEOUT_MS',
+        description: 'How long to wait for the dial protocol to establish a connection',
+        ...numberConfigHelper(DEFAULT_REQRESP_DIAL_TIMEOUT_MS)
+    },
+    p2pOptimisticNegotiation: {
+        env: 'P2P_REQRESP_OPTIMISTIC_NEGOTIATION',
+        description: 'Whether to use optimistic protocol negotiation when dialing to another peer (opposite of `negotiateFully`).',
+        ...booleanConfigHelper(DEFAULT_OPTIMISTIC_NEGOTIATION)
     }
 };

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.d.ts

@@ -18,7 +18,7 @@ export declare class BatchConnectionSampler {
     private readonly logger;
     private readonly batch;
     private readonly requestsPerPeer;
-    constructor(connectionSampler: ConnectionSampler, batchSize: number, maxPeers: number);
+    constructor(connectionSampler: ConnectionSampler, batchSize: number, maxPeers: number, exclude?: PeerId[], logger?: import("@aztec/foundation/log").Logger);
     /**
      * Gets the peer responsible for handling a specific request index
      *

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch_connection_sampler.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/connection-sampler/batch_connection_sampler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAsB;IAKrB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAJ9C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwD;IAC/E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAEZ,iBAAiB,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAetG;;;;;OAKG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAUpD;;;;;OAKG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAmB1C;;OAEG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;CACF"}
+{"version":3,"file":"batch_connection_sampler.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/connection-sampler/batch_connection_sampler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAsB;IAK/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAIlC,OAAO,CAAC,QAAQ,CAAC,MAAM;IARzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAGtB,iBAAiB,EAAE,iBAAiB,EACrD,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAAE,EACD,MAAM,yCAAuD;IAiBhF;;;;;OAKG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAUpD;;;;;OAKG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAmB1C;;OAEG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;CACF"}

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.js

@@ -16,9 +16,9 @@ import { createLogger } from '@aztec/foundation/log';
     logger;
     batch;
     requestsPerPeer;
-    constructor(connectionSampler, batchSize, maxPeers){
+    constructor(connectionSampler, batchSize, maxPeers, exclude, logger = createLogger('p2p:reqresp:batch-connection-sampler')){
         this.connectionSampler = connectionSampler;
-        this.logger = createLogger('p2p:reqresp:batch-connection-sampler');
+        this.logger = logger;
         this.batch = [];
         if (maxPeers <= 0) {
             throw new Error('Max peers cannot be 0');
@@ -29,7 +29,11 @@ import { createLogger } from '@aztec/foundation/log';
         // Calculate how many requests each peer should handle, cannot be 0
         this.requestsPerPeer = Math.max(1, Math.floor(batchSize / maxPeers));
         // Sample initial peers
-        this.batch = this.connectionSampler.samplePeersBatch(maxPeers);
+        const excluding = exclude && new Map(exclude.map((peerId)=>[
+                peerId.toString(),
+                true
+            ]));
+        this.batch = this.connectionSampler.samplePeersBatch(maxPeers, excluding);
     }
     /**
    * Gets the peer responsible for handling a specific request index
@@ -60,17 +64,17 @@ import { createLogger } from '@aztec/foundation/log';
                 true
             ]
         ]);
-        const newPeer = this.connectionSampler.getPeer(excluding);
+        const newPeer = this.connectionSampler.getPeer(excluding); // Q: Shouldn't we accumulate all excluded peers? Otherwise the sampler could return us a previously excluded peer?
         if (newPeer) {
             this.batch[index] = newPeer;
-            this.logger.trace(`Replaced peer ${peerId} with ${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}`, {
+            this.logger.trace('Removed peer', {
                 peerId
             });
         }

package/dest/services/reqresp/connection-sampler/connection_sampler.d.ts

@@ -3,7 +3,7 @@ export declare class RandomSampler {
     random(max: number): number;
 }
 /**
- * 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.
  *
@@ -11,16 +11,17 @@ export declare class RandomSampler {
  */
 export declare class ConnectionSampler {
     private readonly libp2p;
-    private readonly cleanupIntervalMs;
     private readonly sampler;
     private readonly logger;
+    private readonly opts;
     private cleanupInterval;
-    private abortController;
-    private readonly activeConnectionsCount;
-    private readonly streams;
-    private dialQueue;
-    constructor(libp2p: Libp2p, cleanupIntervalMs?: number, // Default to 1 minute
-    sampler?: RandomSampler);
+    protected readonly activeConnectionsCount: Map<string, number>;
+    protected readonly streams: Set<Stream>;
+    private abortOnStop;
+    constructor(libp2p: Libp2p, sampler: RandomSampler, logger?: import("@aztec/foundation/log").Logger, opts?: {
+        cleanupIntervalMs?: number;
+        p2pOptimisticNegotiation?: boolean;
+    });
     /**
      * Stops the cleanup job and closes all active connections
      */
@@ -32,27 +33,43 @@ export declare class ConnectionSampler {
      * @returns
      */
     getPeer(excluding?: Map<string, boolean>): PeerId | undefined;
+    /**
+     * 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[];
+    };
     /**
      * Samples a batch of unique peers from the libp2p node, prioritizing peers without active connections
      *
      * @param numberToSample - The number of peers to sample
+     * @param excluding - The peers to exclude from the sampling
      * @returns Array of unique sampled peers, prioritizing those without active connections
      */
-    samplePeersBatch(numberToSample: number): PeerId[];
+    samplePeersBatch(numberToSample: number, excluding?: Map<string, boolean>): PeerId[];
     /**
      * Dials a protocol and returns the stream
      *
      * @param peerId - The peer id
      * @param protocol - The protocol
+     * @param timeout - Abort connection if it takes too long
      * @returns The stream
      */
-    dialProtocol(peerId: PeerId, protocol: string): Promise<Stream>;
+    dialProtocol(peerId: PeerId, protocol: string, timeout?: number): Promise<Stream>;
     /**
      * Closes a stream and updates the active connections count
-     *
-     * @param streamId - The stream id
      */
-    close(streamId: string): Promise<void>;
+    close(stream: Stream): Promise<void>;
     /**
      * Cleans up stale connections that we have lost accounting for
      */

package/dest/services/reqresp/connection-sampler/connection_sampler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection_sampler.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/connection-sampler/connection_sampler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAShE,qBAAa,aAAa;IACxB,MAAM,CAAC,GAAG,EAAE,MAAM;CAGnB;AAED;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAY1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAb1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkD;IACzE,OAAO,CAAC,eAAe,CAAiB;IACxC,OAAO,CAAC,eAAe,CAA0C;IAEjE,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAkC;IACzE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;IAGnE,OAAO,CAAC,SAAS,CAAkC;gBAGhC,MAAM,EAAE,MAAM,EACd,iBAAiB,GAAE,MAAc,EAAE,sBAAsB;IACzD,OAAO,GAAE,aAAmC;IAO/D;;OAEG;IACG,IAAI;IAaV;;;;;OAKG;IACH,OAAO,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS;IA+B7D;;;;;OAKG;IACH,gBAAgB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE;IAkClD;;;;;;OAMG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAmBrE;;;;OAIG;IACG,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4B5C;;OAEG;YACW,uBAAuB;CAetC"}
+{"version":3,"file":"connection_sampler.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/connection-sampler/connection_sampler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAIhE,qBAAa,aAAa;IACxB,MAAM,CAAC,GAAG,EAAE,MAAM;CAGnB;AAED;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAY1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAdvB,OAAO,CAAC,eAAe,CAAiB;IAGxC,SAAS,CAAC,QAAQ,CAAC,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAa;IAG3E,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAEpD,OAAO,CAAC,WAAW,CAA0C;gBAG1C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,EACtB,MAAM,yCAAiD,EACvD,IAAI,GAAE;QAAE,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAAC,wBAAwB,CAAC,EAAE,OAAO,CAAA;KAAO;IAQhG;;OAEG;IACG,IAAI;IAWV;;;;;OAKG;IACH,OAAO,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS;IAO7D;;;;;;;;;;;OAWG;IACH,eAAe,CACb,KAAK,EAAE,MAAM,EAAE,EACf,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B;QACD,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;QACzB,YAAY,EAAE,MAAM,EAAE,CAAC;KACxB;IAuCD;;;;;;OAMG;IACH,gBAAgB,CAAC,cAAc,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE;IA0CpF;;;;;;;OAOG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAuBvF;;OAEG;IACG,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmC1C;;OAEG;YACW,uBAAuB;CAqBtC"}

package/dest/services/reqresp/connection-sampler/connection_sampler.js

@@ -1,5 +1,5 @@
+import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
-import { SerialQueue } from '@aztec/foundation/queue';
 const MAX_SAMPLE_ATTEMPTS = 4;
 export class RandomSampler {
     random(max) {
@@ -7,43 +7,40 @@ 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.
  *
  * @dev Close must always be called on connections, else memory leak
  */ export class ConnectionSampler {
     libp2p;
-    cleanupIntervalMs;
     sampler;
     logger;
+    opts;
     cleanupInterval;
-    abortController;
+    // Map from stringified peer id to number of active connections
     activeConnectionsCount;
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
     streams;
-    // Serial queue to ensure that we only dial one peer at a time
-    dialQueue;
-    constructor(libp2p, cleanupIntervalMs = 60000, sampler = new RandomSampler()){
+    abortOnStop;
+    constructor(libp2p, sampler, logger = createLogger('p2p:reqresp:connection-sampler'), opts = {}){
         this.libp2p = libp2p;
-        this.cleanupIntervalMs = cleanupIntervalMs;
         this.sampler = sampler;
-        this.logger = createLogger('p2p:reqresp:connection-sampler');
-        this.abortController = new AbortController();
+        this.logger = logger;
+        this.opts = opts;
         this.activeConnectionsCount = new Map();
-        this.streams = new Map();
-        this.dialQueue = new SerialQueue();
-        this.cleanupInterval = setInterval(()=>void this.cleanupStaleConnections(), this.cleanupIntervalMs);
-        this.dialQueue.start();
+        this.streams = new Set();
+        this.abortOnStop = new AbortController();
+        this.cleanupInterval = setInterval(()=>void this.cleanupStaleConnections(), this.opts.cleanupIntervalMs ?? 60_000);
     }
     /**
    * Stops the cleanup job and closes all active connections
    */ async stop() {
         this.logger.info('Stopping connection sampler');
+        this.abortOnStop.abort(new AbortError('Connection sampler stopped'));
         clearInterval(this.cleanupInterval);
-        this.abortController.abort();
-        await this.dialQueue.end();
         // Close all active streams
-        const closePromises = Array.from(this.streams.keys()).map((streamId)=>this.close(streamId));
+        const closePromises = Array.from(this.streams.values()).map((stream)=>this.close(stream));
         await Promise.all(closePromises);
         this.logger.info('Connection sampler stopped');
     }
@@ -55,56 +52,102 @@ export class RandomSampler {
    */ getPeer(excluding) {
         // 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, excluding) {
         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 = [];
+        // 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.toString()) ?? 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
+        };
     }
     /**
    * Samples a batch of unique peers from the libp2p node, prioritizing peers without active connections
    *
    * @param numberToSample - The number of peers to sample
+   * @param excluding - The peers to exclude from the sampling
    * @returns Array of unique sampled peers, prioritizing those without active connections
-   */ samplePeersBatch(numberToSample) {
+   */ samplePeersBatch(numberToSample, excluding) {
         const peers = this.libp2p.getPeers();
-        const sampledPeers = [];
-        const peersWithConnections = []; // Hold onto peers with active connections incase we need to sample more
-        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);
+        this.logger.debug('Sampling peers batch', {
+            numberToSample,
+            peers
+        });
+        // Only sample as many peers as we have available
+        numberToSample = Math.min(numberToSample, peers.length);
+        const batch = [];
+        // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+        const withActiveConnections = new Set();
+        for(let i = 0; i < numberToSample; i++){
+            const { peer, sampledPeers } = this.getPeerFromList(peers, excluding);
+            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
     /**
@@ -112,51 +155,60 @@ export class RandomSampler {
    *
    * @param peerId - The peer id
    * @param protocol - The protocol
+   * @param timeout - Abort connection if it takes too long
    * @returns The stream
-   */ async dialProtocol(peerId, protocol) {
-        // 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
+   */ async dialProtocol(peerId, protocol, timeout) {
+        const stream = await this.libp2p.dialProtocol(peerId, protocol, {
+            signal: AbortSignal.any(timeout ? [
+                this.abortOnStop.signal,
+                AbortSignal.timeout(timeout)
+            ] : [
+                this.abortOnStop.signal
+            ]),
+            negotiateFully: !this.opts.p2pOptimisticNegotiation
         });
-        const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 0) + 1;
-        this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
-        this.logger.trace(`Dialed protocol ${protocol} with peer ${peerId.toString()}`, {
+        stream.metadata.peerId = peerId;
+        this.streams.add(stream);
+        const peerIdString = peerId.toString();
+        const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerIdString) ?? 0) + 1;
+        this.activeConnectionsCount.set(peerIdString, updatedActiveConnectionsCount);
+        this.logger.trace('Dialed protocol', {
             streamId: stream.id,
-            peerId: peerId.toString(),
+            protocol,
+            peerId: peerIdString,
             activeConnectionsCount: updatedActiveConnectionsCount
         });
         return stream;
     }
     /**
    * Closes a stream and updates the active connections count
-   *
-   * @param streamId - The stream id
-   */ async close(streamId) {
+   */ async close(stream) {
+        let peerId = undefined;
         try {
-            const streamAndPeerId = this.streams.get(streamId);
-            if (!streamAndPeerId) {
-                this.logger.warn(`Stream ${streamId} not found`);
-                return;
+            peerId = stream.metadata.peerId;
+            let updatedActiveConnectionsCount = undefined;
+            if (!peerId) {
+                this.logger.warn(`Stream ${stream.id} does not have a peerId set`);
+            } else {
+                updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId.toString()) ?? 1) - 1;
+                this.activeConnectionsCount.set(peerId.toString(), updatedActiveConnectionsCount);
             }
-            const { stream, peerId } = streamAndPeerId;
-            const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 1) - 1;
-            this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
-            this.logger.trace(`Closing connection to peer ${peerId.toString()}`, {
-                streamId,
-                peerId: peerId.toString(),
+            this.logger.trace('Closing connection', {
+                streamId: stream.id,
+                peerId: peerId?.toString(),
                 protocol: stream.protocol,
                 activeConnectionsCount: updatedActiveConnectionsCount
             });
-            await stream?.close();
+            if (!this.streams.has(stream)) {
+                this.logger.debug(`Stream ${stream.id} is not in the active streams set`);
+            }
+            await stream.close();
         } catch (error) {
-            this.logger.error(`Failed to close connection to peer with stream id ${streamId}`, error);
+            this.logger.error(`Failed to close connection to peer ${peerId ?? 'unknown'} with stream id ${stream.id}`, error);
+            // graceful close failed, abort the stream
+            stream.abort(new AbortError('Failed to close stream gracefully'));
         } finally{
-            this.streams.delete(streamId);
+            this.streams.delete(stream);
         }
     }
     /**
@@ -164,15 +216,21 @@ export class RandomSampler {
    */ async cleanupStaleConnections() {
         // Look for streams without anything in the activeConnectionsCount
         // If we find anything, close the stream
-        for (const [streamId, { peerId }] of this.streams.entries()){
+        for (const stream of this.streams.values()){
             try {
                 // 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()}`);
+                const peerId = stream.metadata.peerId;
+                if (!peerId) {
+                    this.logger.warn(`Stream ${stream.id} does not have a peerId set`);
+                } else if (this.activeConnectionsCount.get(peerId.toString()) === 0) {
+                    await this.close(stream);
+                    this.logger.debug('Cleaned up stale connection', {
+                        streamId: stream.id,
+                        peerId: peerId.toString()
+                    });
                 }
             } catch (error) {
-                this.logger.error(`Error cleaning up stale connection ${streamId}`, {
+                this.logger.error(`Error cleaning up stale connection to peer ${stream.metadata.peerId?.toString() ?? 'unknown'} stream ${stream.id}`, {
                     error
                 });
             }

package/dest/services/reqresp/index.d.ts

@@ -1,6 +1,7 @@
-export {};
 /**
  * Request Response protocol allows nodes to ask their peers for data
  * that they missed via the traditional gossip protocol.
  */
+export * from './protocols/index.js';
+export * from './interface.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/services/reqresp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/index.ts"],"names":[],"mappings":";AAAA;;;GAGG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC"}

package/dest/services/reqresp/index.js

@@ -1,4 +1,5 @@
 /**
  * Request Response protocol allows nodes to ask their peers for data
  * that they missed via the traditional gossip protocol.
- */ 
+ */ export * from './protocols/index.js';
+export * from './interface.js';