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

package/dest/services/reqresp/reqresp.js

@@ -1,17 +1,22 @@
-import { __esDecorate, __runInitializers } from "tslib";
 // @attribution: lodestar impl for inspiration
-import { PeerErrorSeverity } from '@aztec/circuit-types';
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
 import { createLogger } from '@aztec/foundation/log';
 import { executeTimeout } from '@aztec/foundation/timer';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { pipe } from 'it-pipe';
-import { CollectiveReqRespTimeoutError, IndividualReqRespTimeoutError, InvalidResponseError, } from '../../errors/reqresp.error.js';
+import { CollectiveReqRespTimeoutError, IndividualReqRespTimeoutError, InvalidResponseError } from '../../errors/reqresp.error.js';
 import { SnappyTransform } from '../encoding.js';
 import { BatchConnectionSampler } from './connection-sampler/batch_connection_sampler.js';
 import { ConnectionSampler } from './connection-sampler/connection_sampler.js';
-import { DEFAULT_SUB_PROTOCOL_HANDLERS, DEFAULT_SUB_PROTOCOL_VALIDATORS, ReqRespSubProtocol, subProtocolMap, } from './interface.js';
+import { DEFAULT_SUB_PROTOCOL_HANDLERS, DEFAULT_SUB_PROTOCOL_VALIDATORS, ReqRespSubProtocol, subProtocolMap } from './interface.js';
 import { ReqRespMetrics } from './metrics.js';
-import { RequestResponseRateLimiter } from './rate-limiter/rate_limiter.js';
+import { RateLimitStatus, RequestResponseRateLimiter, prettyPrintRateLimitStatus } from './rate-limiter/rate_limiter.js';
 import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqRespStatus } from './status.js';
 /**
  * The Request Response Service
@@ -26,488 +31,486 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
  *       so they get decompressed in readMessage
  *
  * see: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#the-reqresp-domain
- */
-let ReqResp = (() => {
-    var _a;
-    let _instanceExtraInitializers = [];
-    let _sendBatchRequest_decorators;
-    let _sendRequestToPeer_decorators;
-    let _streamHandler_decorators;
-    return _a = class ReqResp {
-            constructor(config, libp2p, peerScoring, telemetryClient = getTelemetryClient()) {
-                this.libp2p = (__runInitializers(this, _instanceExtraInitializers), libp2p);
-                this.peerScoring = peerScoring;
-                // Warning, if the `start` function is not called as the parent class constructor, then the default sub protocol handlers will be used ( not good )
-                this.subProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
-                this.subProtocolValidators = DEFAULT_SUB_PROTOCOL_VALIDATORS;
-                this.logger = createLogger('p2p:reqresp');
-                this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
-                this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
-                this.rateLimiter = new RequestResponseRateLimiter(peerScoring);
-                // Connection sampler is used to sample our connected peers
-                this.connectionSampler = new ConnectionSampler(libp2p);
-                this.snappyTransform = new SnappyTransform();
-                this.metrics = new ReqRespMetrics(telemetryClient);
+ */ export class ReqResp {
+    libp2p;
+    peerScoring;
+    logger;
+    overallRequestTimeoutMs;
+    individualRequestTimeoutMs;
+    // Warning, if the `start` function is not called as the parent class constructor, then the default sub protocol handlers will be used ( not good )
+    subProtocolHandlers;
+    subProtocolValidators;
+    connectionSampler;
+    rateLimiter;
+    snappyTransform;
+    metrics;
+    constructor(config, libp2p, peerScoring, telemetryClient = getTelemetryClient()){
+        this.libp2p = libp2p;
+        this.peerScoring = peerScoring;
+        this.subProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
+        this.subProtocolValidators = DEFAULT_SUB_PROTOCOL_VALIDATORS;
+        this.logger = createLogger('p2p:reqresp');
+        this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
+        this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
+        this.rateLimiter = new RequestResponseRateLimiter(peerScoring);
+        // Connection sampler is used to sample our connected peers
+        this.connectionSampler = new ConnectionSampler(libp2p);
+        this.snappyTransform = new SnappyTransform();
+        this.metrics = new ReqRespMetrics(telemetryClient);
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    /**
+   * Start the reqresp service
+   */ async start(subProtocolHandlers, subProtocolValidators) {
+        this.subProtocolHandlers = subProtocolHandlers;
+        this.subProtocolValidators = subProtocolValidators;
+        // Register all protocol handlers
+        for (const subProtocol of Object.keys(this.subProtocolHandlers)){
+            await this.libp2p.handle(subProtocol, (data)=>void this.streamHandler(subProtocol, data).catch((err)=>this.logger.error(`Error on libp2p subprotocol ${subProtocol} handler`, err)));
+        }
+        this.rateLimiter.start();
+    }
+    /**
+   * Stop the reqresp service
+   */ async stop() {
+        // Unregister handlers in parallel
+        const unregisterPromises = Object.keys(this.subProtocolHandlers).map((protocol)=>this.libp2p.unhandle(protocol));
+        await Promise.all(unregisterPromises);
+        // Close connection sampler
+        await this.connectionSampler.stop();
+        this.logger.debug('ReqResp: Connection sampler stopped');
+        // Close streams in parallel
+        const closeStreamPromises = this.libp2p.getConnections().map((connection)=>connection.close());
+        await Promise.all(closeStreamPromises);
+        this.logger.debug('ReqResp: All active streams closed');
+        this.rateLimiter.stop();
+        this.logger.debug('ReqResp: Rate limiter stopped');
+    // NOTE: We assume libp2p instance is managed by the caller
+    }
+    /**
+   * Send a request to peers, returns the first response
+   *
+   * @param subProtocol - The protocol being requested
+   * @param request - The request to send
+   * @returns - The response from the peer, otherwise undefined
+   *
+   * @description
+   * This method attempts to send a request to all active peers using the specified sub-protocol.
+   * It opens a stream with each peer, sends the request, and awaits a response.
+   * If a valid response is received, it returns the response; otherwise, it continues to the next peer.
+   * If no response is received from any peer, it returns undefined.
+   *
+   * The method performs the following steps:
+   * - Sample a peer to send the request to.
+   * - Opens a stream with the peer using the specified sub-protocol.
+   *
+   * When a response is received, it is validated using the given sub protocols response validator.
+   * To see the interface for the response validator - see `interface.ts`
+   *
+   * Failing a response validation requests in a severe peer penalty, and will
+   * prompt the node to continue to search to the next peer.
+   * For example, a transaction request validator will check that the payload returned does in fact
+   * match the txHash that was requested. A peer that fails this check an only be an extremely naughty peer.
+   *
+   * This entire operation is wrapped in an overall timeout, that is independent of the
+   * peer it is requesting data from.
+   *
+   */ async sendRequest(subProtocol, request) {
+        const responseValidator = this.subProtocolValidators[subProtocol];
+        const requestBuffer = request.toBuffer();
+        const requestFunction = async ()=>{
+            // Attempt to ask all of our peers, but sampled in a random order
+            // This function is wrapped in a timeout, so we will exit the loop if we have not received a response
+            const numberOfPeers = this.libp2p.getPeers().length;
+            if (numberOfPeers === 0) {
+                this.logger.debug('No active peers to send requests to');
+                return undefined;
             }
-            get tracer() {
-                return this.metrics.tracer;
-            }
-            /**
-             * Start the reqresp service
-             */
-            async start(subProtocolHandlers, subProtocolValidators) {
-                this.subProtocolHandlers = subProtocolHandlers;
-                this.subProtocolValidators = subProtocolValidators;
-                // Register all protocol handlers
-                for (const subProtocol of Object.keys(this.subProtocolHandlers)) {
-                    await this.libp2p.handle(subProtocol, (data) => void this.streamHandler(subProtocol, data).catch(err => this.logger.error(`Error on libp2p subprotocol ${subProtocol} handler`, err)));
+            const attemptedPeers = new Map();
+            for(let i = 0; i < numberOfPeers; i++){
+                // Sample a peer to make a request to
+                const peer = this.connectionSampler.getPeer(attemptedPeers);
+                this.logger.trace(`Attempting to send request to peer: ${peer?.toString()}`);
+                if (!peer) {
+                    this.logger.debug('No peers available to send requests to');
+                    return undefined;
+                }
+                attemptedPeers.set(peer.toString(), true);
+                this.logger.trace(`Sending request to peer: ${peer.toString()}`);
+                const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
+                if (response && response.status !== ReqRespStatus.SUCCESS) {
+                    this.logger.debug(`Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(response.status)}`);
+                    continue;
+                }
+                // If we get a response, return it, otherwise we iterate onto the next peer
+                // We do not consider it a success if we have an empty buffer
+                if (response && response.data.length > 0) {
+                    const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
+                    // The response validator handles peer punishment within
+                    const isValid = await responseValidator(request, object, peer);
+                    if (!isValid) {
+                        throw new InvalidResponseError();
+                    }
+                    return object;
                 }
-                this.rateLimiter.start();
             }
-            /**
-             * Stop the reqresp service
-             */
-            async stop() {
-                // Unregister handlers in parallel
-                const unregisterPromises = Object.keys(this.subProtocolHandlers).map(protocol => this.libp2p.unhandle(protocol));
-                await Promise.all(unregisterPromises);
-                // Close connection sampler
-                await this.connectionSampler.stop();
-                this.logger.debug('ReqResp: Connection sampler stopped');
-                // Close streams in parallel
-                const closeStreamPromises = this.libp2p.getConnections().map(connection => connection.close());
-                await Promise.all(closeStreamPromises);
-                this.logger.debug('ReqResp: All active streams closed');
-                this.rateLimiter.stop();
-                this.logger.debug('ReqResp: Rate limiter stopped');
-                // NOTE: We assume libp2p instance is managed by the caller
+        };
+        try {
+            return await executeTimeout(requestFunction, this.overallRequestTimeoutMs, ()=>new CollectiveReqRespTimeoutError());
+        } catch (e) {
+            this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
+            return undefined;
+        }
+    }
+    /**
+   * Request multiple messages over the same sub protocol, balancing the requests across peers.
+   *
+   * @devnote
+   * - The function prioritizes sending requests to free peers using a batch sampling strategy.
+   * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
+   * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
+   * - Responses are validated using a custom validator for the sub-protocol.*
+   *
+   * Requests are sent in parallel to each peer, but multiple requests are sent to the same peer in series
+   * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
+   * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
+   * - Responses are validated using a custom validator for the sub-protocol.*
+   *
+   * @param subProtocol
+   * @param requests
+   * @param timeoutMs
+   * @param maxPeers
+   * @returns
+   *
+   * @throws {CollectiveReqRespTimeoutError} - If the request batch exceeds the specified timeout (`timeoutMs`).
+   */ async sendBatchRequest(subProtocol, requests, timeoutMs = 10000, maxPeers = Math.min(10, requests.length), maxRetryAttempts = 3) {
+        const responseValidator = this.subProtocolValidators[subProtocol];
+        const responses = new Array(requests.length);
+        const requestBuffers = requests.map((req)=>req.toBuffer());
+        const requestFunction = async ()=>{
+            // Track which requests still need to be processed
+            const pendingRequestIndices = new Set(requestBuffers.map((_, i)=>i));
+            // Create batch sampler with the total number of requests and max peers
+            const batchSampler = new BatchConnectionSampler(this.connectionSampler, requests.length, maxPeers);
+            if (batchSampler.activePeerCount === 0) {
+                this.logger.debug('No active peers to send requests to');
+                return [];
             }
-            /**
-             * Send a request to peers, returns the first response
-             *
-             * @param subProtocol - The protocol being requested
-             * @param request - The request to send
-             * @returns - The response from the peer, otherwise undefined
-             *
-             * @description
-             * This method attempts to send a request to all active peers using the specified sub-protocol.
-             * It opens a stream with each peer, sends the request, and awaits a response.
-             * If a valid response is received, it returns the response; otherwise, it continues to the next peer.
-             * If no response is received from any peer, it returns undefined.
-             *
-             * The method performs the following steps:
-             * - Sample a peer to send the request to.
-             * - Opens a stream with the peer using the specified sub-protocol.
-             *
-             * When a response is received, it is validated using the given sub protocols response validator.
-             * To see the interface for the response validator - see `interface.ts`
-             *
-             * Failing a response validation requests in a severe peer penalty, and will
-             * prompt the node to continue to search to the next peer.
-             * For example, a transaction request validator will check that the payload returned does in fact
-             * match the txHash that was requested. A peer that fails this check an only be an extremely naughty peer.
-             *
-             * This entire operation is wrapped in an overall timeout, that is independent of the
-             * peer it is requesting data from.
-             *
-             */
-            async sendRequest(subProtocol, request) {
-                const responseValidator = this.subProtocolValidators[subProtocol];
-                const requestBuffer = request.toBuffer();
-                const requestFunction = async () => {
-                    // Attempt to ask all of our peers, but sampled in a random order
-                    // This function is wrapped in a timeout, so we will exit the loop if we have not received a response
-                    const numberOfPeers = this.libp2p.getPeers().length;
-                    if (numberOfPeers === 0) {
-                        this.logger.debug('No active peers to send requests to');
-                        return undefined;
+            // This is where it gets fun
+            // The outer loop is the retry loop, we will continue to retry until we process all indices we have
+            // not received a response for, or we have reached the max retry attempts
+            // The inner loop is the batch loop, we will process all requests for each peer in parallel
+            // We will then process the results of the requests, and resample any peers that failed to respond
+            // We will continue to retry until we have processed all indices, or we have reached the max retry attempts
+            let retryAttempts = 0;
+            while(pendingRequestIndices.size > 0 && batchSampler.activePeerCount > 0 && retryAttempts < maxRetryAttempts){
+                // Process requests in parallel for each available peer
+                const requestBatches = new Map();
+                // Group requests by peer
+                for (const requestIndex of pendingRequestIndices){
+                    const peer = batchSampler.getPeerForRequest(requestIndex);
+                    if (!peer) {
+                        break;
                     }
-                    const attemptedPeers = new Map();
-                    for (let i = 0; i < numberOfPeers; i++) {
-                        // Sample a peer to make a request to
-                        const peer = this.connectionSampler.getPeer(attemptedPeers);
-                        this.logger.trace(`Attempting to send request to peer: ${peer?.toString()}`);
-                        if (!peer) {
-                            this.logger.debug('No peers available to send requests to');
-                            return undefined;
-                        }
-                        attemptedPeers.set(peer.toString(), true);
-                        this.logger.trace(`Sending request to peer: ${peer.toString()}`);
-                        const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
-                        if (response && response.status !== ReqRespStatus.SUCCESS) {
-                            this.logger.debug(`Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(response.status)}`);
-                            continue;
-                        }
-                        // If we get a response, return it, otherwise we iterate onto the next peer
-                        // We do not consider it a success if we have an empty buffer
-                        if (response && response.data.length > 0) {
-                            const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
-                            // The response validator handles peer punishment within
-                            const isValid = await responseValidator(request, object, peer);
-                            if (!isValid) {
-                                throw new InvalidResponseError();
-                            }
-                            return object;
-                        }
+                    if (!requestBatches.has(peer)) {
+                        requestBatches.set(peer, []);
                     }
-                };
-                try {
-                    return await executeTimeout(requestFunction, this.overallRequestTimeoutMs, () => new CollectiveReqRespTimeoutError());
+                    requestBatches.get(peer).push(requestIndex);
                 }
-                catch (e) {
-                    this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
-                    return undefined;
-                }
-            }
-            /**
-             * Request multiple messages over the same sub protocol, balancing the requests across peers.
-             *
-             * @devnote
-             * - The function prioritizes sending requests to free peers using a batch sampling strategy.
-             * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
-             * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
-             * - Responses are validated using a custom validator for the sub-protocol.*
-             *
-             * Requests are sent in parallel to each peer, but multiple requests are sent to the same peer in series
-             * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
-             * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
-             * - Responses are validated using a custom validator for the sub-protocol.*
-             *
-             * @param subProtocol
-             * @param requests
-             * @param timeoutMs
-             * @param maxPeers
-             * @returns
-             *
-             * @throws {CollectiveReqRespTimeoutError} - If the request batch exceeds the specified timeout (`timeoutMs`).
-             */
-            async sendBatchRequest(subProtocol, requests, timeoutMs = 10000, maxPeers = Math.min(10, requests.length), maxRetryAttempts = 3) {
-                const responseValidator = this.subProtocolValidators[subProtocol];
-                const responses = new Array(requests.length);
-                const requestBuffers = requests.map(req => req.toBuffer());
-                const requestFunction = async () => {
-                    // Track which requests still need to be processed
-                    const pendingRequestIndices = new Set(requestBuffers.map((_, i) => i));
-                    // Create batch sampler with the total number of requests and max peers
-                    const batchSampler = new BatchConnectionSampler(this.connectionSampler, requests.length, maxPeers);
-                    if (batchSampler.activePeerCount === 0) {
-                        this.logger.debug('No active peers to send requests to');
-                        return [];
-                    }
-                    // This is where it gets fun
-                    // The outer loop is the retry loop, we will continue to retry until we process all indices we have
-                    // not received a response for, or we have reached the max retry attempts
-                    // The inner loop is the batch loop, we will process all requests for each peer in parallel
-                    // We will then process the results of the requests, and resample any peers that failed to respond
-                    // We will continue to retry until we have processed all indices, or we have reached the max retry attempts
-                    let retryAttempts = 0;
-                    while (pendingRequestIndices.size > 0 && batchSampler.activePeerCount > 0 && retryAttempts < maxRetryAttempts) {
-                        // Process requests in parallel for each available peer
-                        const requestBatches = new Map();
-                        // Group requests by peer
-                        for (const requestIndex of pendingRequestIndices) {
-                            const peer = batchSampler.getPeerForRequest(requestIndex);
-                            if (!peer) {
-                                break;
-                            }
-                            if (!requestBatches.has(peer)) {
-                                requestBatches.set(peer, []);
-                            }
-                            requestBatches.get(peer).push(requestIndex);
-                        }
-                        // Make parallel requests for each peer's batch
-                        // A batch entry will look something like this:
-                        // PeerId0: [0, 1, 2, 3]
-                        // PeerId1: [4, 5, 6, 7]
-                        // Peer Id 0 will send requests 0, 1, 2, 3 in serial
-                        // while simultaneously Peer Id 1 will send requests 4, 5, 6, 7 in serial
-                        const batchResults = await Promise.all(Array.from(requestBatches.entries()).map(async ([peer, indices]) => {
-                            try {
-                                // Requests all going to the same peer are sent synchronously
-                                const peerResults = [];
-                                for (const index of indices) {
-                                    const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
-                                    // Check the status of the response buffer
-                                    if (response && response.status !== ReqRespStatus.SUCCESS) {
-                                        this.logger.debug(`Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(response.status)}`);
-                                        // If we hit a rate limit or some failure, we remove the peer and return the results,
-                                        // they will be split among remaining peers and the new sampled peer
-                                        batchSampler.removePeerAndReplace(peer);
-                                        return { peer, results: peerResults };
-                                    }
-                                    if (response && response.data.length > 0) {
-                                        const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
-                                        const isValid = await responseValidator(requests[index], object, peer);
-                                        if (isValid) {
-                                            peerResults.push({ index, response: object });
-                                        }
-                                    }
-                                }
-                                return { peer, results: peerResults };
-                            }
-                            catch (error) {
-                                this.logger.debug(`Failed batch request to peer ${peer.toString()}:`, error);
+                // Make parallel requests for each peer's batch
+                // A batch entry will look something like this:
+                // PeerId0: [0, 1, 2, 3]
+                // PeerId1: [4, 5, 6, 7]
+                // Peer Id 0 will send requests 0, 1, 2, 3 in serial
+                // while simultaneously Peer Id 1 will send requests 4, 5, 6, 7 in serial
+                const batchResults = await Promise.all(Array.from(requestBatches.entries()).map(async ([peer, indices])=>{
+                    try {
+                        // Requests all going to the same peer are sent synchronously
+                        const peerResults = [];
+                        for (const index of indices){
+                            const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
+                            // Check the status of the response buffer
+                            if (response && response.status !== ReqRespStatus.SUCCESS) {
+                                this.logger.debug(`Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(response.status)}`);
+                                // If we hit a rate limit or some failure, we remove the peer and return the results,
+                                // they will be split among remaining peers and the new sampled peer
                                 batchSampler.removePeerAndReplace(peer);
-                                return { peer, results: [] };
+                                return {
+                                    peer,
+                                    results: peerResults
+                                };
                             }
-                        }));
-                        // Process results
-                        for (const { results } of batchResults) {
-                            for (const { index, response } of results) {
-                                if (response) {
-                                    responses[index] = response;
-                                    pendingRequestIndices.delete(index);
+                            if (response && response.data.length > 0) {
+                                const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
+                                const isValid = await responseValidator(requests[index], object, peer);
+                                if (isValid) {
+                                    peerResults.push({
+                                        index,
+                                        response: object
+                                    });
                                 }
                             }
                         }
-                        retryAttempts++;
+                        return {
+                            peer,
+                            results: peerResults
+                        };
+                    } catch (error) {
+                        this.logger.debug(`Failed batch request to peer ${peer.toString()}:`, error);
+                        batchSampler.removePeerAndReplace(peer);
+                        return {
+                            peer,
+                            results: []
+                        };
                     }
-                    if (retryAttempts >= maxRetryAttempts) {
-                        this.logger.debug(`Max retry attempts ${maxRetryAttempts} reached for batch request`);
+                }));
+                // Process results
+                for (const { results } of batchResults){
+                    for (const { index, response } of results){
+                        if (response) {
+                            responses[index] = response;
+                            pendingRequestIndices.delete(index);
+                        }
                     }
-                    return responses;
-                };
-                try {
-                    return await executeTimeout(requestFunction, timeoutMs, () => new CollectiveReqRespTimeoutError());
-                }
-                catch (e) {
-                    this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
-                    return [];
                 }
+                retryAttempts++;
             }
-            /**
-             * Sends a request to a specific peer
-             *
-             * We first dial a particular protocol for the peer, this ensures that the peer knows
-             * what to respond with
-             *
-             *
-             * @param peerId - The peer to send the request to
-             * @param subProtocol - The protocol to use to request
-             * @param payload - The payload to send
-             * @returns If the request is successful, the response is returned, otherwise undefined
-             *
-             * @description
-             * This method attempts to open a stream with the specified peer, send the payload,
-             * and await a response.
-             * If an error occurs, it penalizes the peer and returns undefined.
-             *
-             * The method performs the following steps:
-             * - Opens a stream with the peer using the specified sub-protocol.
-             * - Sends the payload and awaits a response with a timeout.
-             *
-             * If the stream is not closed by the dialled peer, and a timeout occurs, then
-             * the stream is closed on the requester's end and sender (us) updates its peer score
-             */
-            async sendRequestToPeer(peerId, subProtocol, payload) {
-                let stream;
+            if (retryAttempts >= maxRetryAttempts) {
+                this.logger.debug(`Max retry attempts ${maxRetryAttempts} reached for batch request`);
+            }
+            return responses;
+        };
+        try {
+            return await executeTimeout(requestFunction, timeoutMs, ()=>new CollectiveReqRespTimeoutError());
+        } catch (e) {
+            this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
+            return [];
+        }
+    }
+    /**
+   * Sends a request to a specific peer
+   *
+   * We first dial a particular protocol for the peer, this ensures that the peer knows
+   * what to respond with
+   *
+   *
+   * @param peerId - The peer to send the request to
+   * @param subProtocol - The protocol to use to request
+   * @param payload - The payload to send
+   * @returns If the request is successful, the response is returned, otherwise undefined
+   *
+   * @description
+   * This method attempts to open a stream with the specified peer, send the payload,
+   * and await a response.
+   * If an error occurs, it penalizes the peer and returns undefined.
+   *
+   * The method performs the following steps:
+   * - Opens a stream with the peer using the specified sub-protocol.
+   * - Sends the payload and awaits a response with a timeout.
+   *
+   * If the stream is not closed by the dialled peer, and a timeout occurs, then
+   * the stream is closed on the requester's end and sender (us) updates its peer score
+   */ async sendRequestToPeer(peerId, subProtocol, payload) {
+        let stream;
+        try {
+            this.metrics.recordRequestSent(subProtocol);
+            stream = await this.connectionSampler.dialProtocol(peerId, subProtocol);
+            // Open the stream with a timeout
+            const result = await executeTimeout(()=>pipe([
+                    payload
+                ], stream, this.readMessage.bind(this)), this.individualRequestTimeoutMs, ()=>new IndividualReqRespTimeoutError());
+            return result;
+        } catch (e) {
+            this.metrics.recordRequestError(subProtocol);
+            this.handleResponseError(e, peerId, subProtocol);
+        } finally{
+            // Only close the stream if we created it
+            if (stream) {
                 try {
-                    this.metrics.recordRequestSent(subProtocol);
-                    stream = await this.connectionSampler.dialProtocol(peerId, subProtocol);
-                    // Open the stream with a timeout
-                    const result = await executeTimeout(() => pipe([payload], stream, this.readMessage.bind(this)), this.individualRequestTimeoutMs, () => new IndividualReqRespTimeoutError());
-                    return result;
-                }
-                catch (e) {
-                    this.metrics.recordRequestError(subProtocol);
-                    this.handleResponseError(e, peerId, subProtocol);
-                }
-                finally {
-                    // Only close the stream if we created it
-                    if (stream) {
-                        try {
-                            await this.connectionSampler.close(stream.id);
-                        }
-                        catch (closeError) {
-                            this.logger.error(`Error closing stream: ${closeError instanceof Error ? closeError.message : 'Unknown error'}`);
-                        }
-                    }
+                    await this.connectionSampler.close(stream.id);
+                } catch (closeError) {
+                    this.logger.error(`Error closing stream: ${closeError instanceof Error ? closeError.message : 'Unknown error'}`);
                 }
             }
-            /**
-             * Handle a response error
-             *
-             * ReqResp errors are punished differently depending on the severity of the offense
-             *
-             * @param e - The error
-             * @param peerId - The peer id
-             * @param subProtocol - The sub protocol
-             * @returns If the error is non pubishable, then undefined is returned, otherwise the peer is penalized
-             */
-            handleResponseError(e, peerId, subProtocol) {
-                const severity = this.categorizeError(e, peerId, subProtocol);
-                if (severity) {
-                    this.peerScoring.penalizePeer(peerId, severity);
+        }
+    }
+    /**
+   * Handle a response error
+   *
+   * ReqResp errors are punished differently depending on the severity of the offense
+   *
+   * @param e - The error
+   * @param peerId - The peer id
+   * @param subProtocol - The sub protocol
+   * @returns If the error is non pubishable, then undefined is returned, otherwise the peer is penalized
+   */ handleResponseError(e, peerId, subProtocol) {
+        const severity = this.categorizeError(e, peerId, subProtocol);
+        if (severity) {
+            this.peerScoring.penalizePeer(peerId, severity);
+        }
+    }
+    /**
+   * Categorize the error and log it.
+   */ categorizeError(e, peerId, subProtocol) {
+        // Non punishable errors - we do not expect a response for goodbye messages
+        if (subProtocol === ReqRespSubProtocol.GOODBYE) {
+            this.logger.debug('Error encountered on goodbye sub protocol, no penalty', {
+                peerId: peerId.toString(),
+                subProtocol
+            });
+            return undefined;
+        }
+        // We do not punish a collective timeout, as the node triggers this interupt, independent of the peer's behaviour
+        const logTags = {
+            peerId: peerId.toString(),
+            subProtocol
+        };
+        if (e instanceof CollectiveReqRespTimeoutError || e instanceof InvalidResponseError) {
+            this.logger.debug(`Non-punishable error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`, logTags);
+            return undefined;
+        }
+        // Pubishable errors
+        // Connection reset errors in the networking stack are punished with high severity
+        // it just signals an unreliable peer
+        // We assume that the requesting node has a functioning networking stack.
+        if (e?.code === 'ECONNRESET' || e?.code === 'EPIPE') {
+            this.logger.debug(`Connection reset: ${peerId.toString()}`, logTags);
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        if (e?.code === 'ECONNREFUSED') {
+            this.logger.debug(`Connection refused: ${peerId.toString()}`, logTags);
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        // Timeout errors are punished with high tolerance, they can be due to a geogrpahically far away peer or an
+        // overloaded peer
+        if (e instanceof IndividualReqRespTimeoutError) {
+            this.logger.debug(`Timeout error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`, logTags);
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        // Catch all error
+        this.logger.error(`Unexpected error sending request to peer`, e, logTags);
+        return PeerErrorSeverity.HighToleranceError;
+    }
+    /**
+   * Read a message returned from a stream into a single buffer
+   *
+   * The message is split into two components
+   * - The first chunk should contain a control byte, indicating the status of the response see `ReqRespStatus`
+   * - The second chunk should contain the response data
+   */ async readMessage(source) {
+        let statusBuffer;
+        const chunks = [];
+        try {
+            for await (const chunk of source){
+                if (statusBuffer === undefined) {
+                    const firstChunkBuffer = chunk.subarray();
+                    statusBuffer = parseStatusChunk(firstChunkBuffer);
+                } else {
+                    chunks.push(chunk.subarray());
                 }
             }
-            /**
-             * Categorize the error and log it.
-             */
-            categorizeError(e, peerId, subProtocol) {
-                // Non punishable errors - we do not expect a response for goodbye messages
-                if (subProtocol === ReqRespSubProtocol.GOODBYE) {
-                    this.logger.debug('Error encountered on goodbye sub protocol, no penalty', {
-                        peerId: peerId.toString(),
-                        subProtocol,
-                    });
-                    return undefined;
-                }
-                // We do not punish a collective timeout, as the node triggers this interupt, independent of the peer's behaviour
-                const logTags = {
-                    peerId: peerId.toString(),
-                    subProtocol,
-                };
-                if (e instanceof CollectiveReqRespTimeoutError || e instanceof InvalidResponseError) {
-                    this.logger.debug(`Non-punishable error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`, logTags);
-                    return undefined;
-                }
-                // Pubishable errors
-                // Connection reset errors in the networking stack are punished with high severity
-                // it just signals an unreliable peer
-                // We assume that the requesting node has a functioning networking stack.
-                if (e?.code === 'ECONNRESET' || e?.code === 'EPIPE') {
-                    this.logger.debug(`Connection reset: ${peerId.toString()}`, logTags);
-                    return PeerErrorSeverity.HighToleranceError;
-                }
-                if (e?.code === 'ECONNREFUSED') {
-                    this.logger.debug(`Connection refused: ${peerId.toString()}`, logTags);
-                    return PeerErrorSeverity.HighToleranceError;
-                }
-                // Timeout errors are punished with high tolerance, they can be due to a geogrpahically far away peer or an
-                // overloaded peer
-                if (e instanceof IndividualReqRespTimeoutError) {
-                    this.logger.debug(`Timeout error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`, logTags);
-                    return PeerErrorSeverity.HighToleranceError;
-                }
-                // Catch all error
-                this.logger.error(`Unexpected error sending request to peer`, e, logTags);
-                return PeerErrorSeverity.HighToleranceError;
+            const messageData = Buffer.concat(chunks);
+            const message = this.snappyTransform.inboundTransformNoTopic(messageData);
+            return {
+                status: statusBuffer ?? ReqRespStatus.UNKNOWN,
+                data: message
+            };
+        } catch (e) {
+            this.logger.debug(`Reading message failed: ${e.message}`);
+            let status = ReqRespStatus.UNKNOWN;
+            if (e instanceof ReqRespStatusError) {
+                status = e.status;
             }
-            /**
-             * Read a message returned from a stream into a single buffer
-             *
-             * The message is split into two components
-             * - The first chunk should contain a control byte, indicating the status of the response see `ReqRespStatus`
-             * - The second chunk should contain the response data
-             */
-            async readMessage(source) {
-                let statusBuffer;
-                const chunks = [];
-                try {
-                    for await (const chunk of source) {
-                        if (statusBuffer === undefined) {
-                            const firstChunkBuffer = chunk.subarray();
-                            statusBuffer = parseStatusChunk(firstChunkBuffer);
-                        }
-                        else {
-                            chunks.push(chunk.subarray());
-                        }
-                    }
-                    const messageData = Buffer.concat(chunks);
-                    const message = this.snappyTransform.inboundTransformNoTopic(messageData);
-                    return {
-                        status: statusBuffer ?? ReqRespStatus.UNKNOWN,
-                        data: message,
-                    };
-                }
-                catch (e) {
-                    this.logger.debug(`Reading message failed: ${e.message}`);
-                    let status = ReqRespStatus.UNKNOWN;
-                    if (e instanceof ReqRespStatusError) {
-                        status = e.status;
-                    }
-                    return {
-                        status,
-                        data: Buffer.from([]),
-                    };
-                }
+            return {
+                status,
+                data: Buffer.from([])
+            };
+        }
+    }
+    /**
+   * Stream Handler
+   * Reads the incoming stream, determines the protocol, then triggers the appropriate handler
+   *
+   * @param param0 - The incoming stream data
+   *
+   * @description
+   * An individual stream handler will be bound to each sub protocol, and handles returning data back
+   * to the requesting peer.
+   *
+   * The sub protocol handler interface is defined within `interface.ts` and will be assigned to the
+   * req resp service on start up.
+   *
+   * We check rate limits for each peer, note the peer will be penalised within the rate limiter implementation
+   * if they exceed their peer specific limits.
+   */ async streamHandler(protocol, { stream, connection }) {
+        this.metrics.recordRequestReceived(protocol);
+        try {
+            // Store a reference to from this for the async generator
+            const rateLimitStatus = this.rateLimiter.allow(protocol, connection.remotePeer);
+            if (rateLimitStatus != RateLimitStatus.Allowed) {
+                this.logger.warn(`Rate limit exceeded ${prettyPrintRateLimitStatus(rateLimitStatus)} for ${protocol} from ${connection.remotePeer}`);
+                throw new ReqRespStatusError(ReqRespStatus.RATE_LIMIT_EXCEEDED);
             }
-            /**
-             * Stream Handler
-             * Reads the incoming stream, determines the protocol, then triggers the appropriate handler
-             *
-             * @param param0 - The incoming stream data
-             *
-             * @description
-             * An individual stream handler will be bound to each sub protocol, and handles returning data back
-             * to the requesting peer.
-             *
-             * The sub protocol handler interface is defined within `interface.ts` and will be assigned to the
-             * req resp service on start up.
-             *
-             * We check rate limits for each peer, note the peer will be penalised within the rate limiter implementation
-             * if they exceed their peer specific limits.
-             */
-            async streamHandler(protocol, { stream, connection }) {
-                this.metrics.recordRequestReceived(protocol);
-                try {
-                    // Store a reference to from this for the async generator
-                    if (!this.rateLimiter.allow(protocol, connection.remotePeer)) {
-                        this.logger.warn(`Rate limit exceeded for ${protocol} from ${connection.remotePeer}`);
-                        throw new ReqRespStatusError(ReqRespStatus.RATE_LIMIT_EXCEEDED);
+            const handler = this.subProtocolHandlers[protocol];
+            const transform = this.snappyTransform;
+            await pipe(stream, async function*(source) {
+                for await (const chunkList of source){
+                    const msg = Buffer.from(chunkList.subarray());
+                    const response = await handler(connection.remotePeer, msg);
+                    if (protocol === ReqRespSubProtocol.GOODBYE) {
+                        // Don't respond
+                        await stream.close();
+                        return;
                     }
-                    const handler = this.subProtocolHandlers[protocol];
-                    const transform = this.snappyTransform;
-                    this.logger.info(`Stream handler for ${protocol}`);
-                    await pipe(stream, async function* (source) {
-                        for await (const chunkList of source) {
-                            const msg = Buffer.from(chunkList.subarray());
-                            const response = await handler(connection.remotePeer, msg);
-                            if (protocol === ReqRespSubProtocol.GOODBYE) {
-                                // Don't respond
-                                await stream.close();
-                                return;
-                            }
-                            // Send success code first, then the response
-                            const successChunk = Buffer.from([ReqRespStatus.SUCCESS]);
-                            yield new Uint8Array(successChunk);
-                            yield new Uint8Array(transform.outboundTransformNoTopic(response));
-                        }
-                    }, stream);
-                }
-                catch (e) {
-                    this.logger.warn('Reqresp Response error: ', e);
-                    this.metrics.recordResponseError(protocol);
-                    // If we receive a known error, we use the error status in the response chunk, otherwise we categorize as unknown
-                    let errorStatus = ReqRespStatus.UNKNOWN;
-                    if (e instanceof ReqRespStatusError) {
-                        errorStatus = e.status;
-                    }
-                    const sendErrorChunk = this.sendErrorChunk(errorStatus);
-                    // Return and yield the response chunk
-                    await pipe(stream, async function* (_source) {
-                        yield* sendErrorChunk;
-                    }, stream);
-                }
-                finally {
-                    await stream.close();
+                    // Send success code first, then the response
+                    const successChunk = Buffer.from([
+                        ReqRespStatus.SUCCESS
+                    ]);
+                    yield new Uint8Array(successChunk);
+                    yield new Uint8Array(transform.outboundTransformNoTopic(response));
                 }
+            }, stream);
+        } catch (e) {
+            this.logger.warn('Reqresp Response error: ', e);
+            this.metrics.recordResponseError(protocol);
+            // If we receive a known error, we use the error status in the response chunk, otherwise we categorize as unknown
+            let errorStatus = ReqRespStatus.UNKNOWN;
+            if (e instanceof ReqRespStatusError) {
+                errorStatus = e.status;
             }
-            async *sendErrorChunk(error) {
-                const errorChunk = Buffer.from([error]);
-                yield new Uint8Array(errorChunk);
-            }
-        },
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _sendBatchRequest_decorators = [trackSpan('ReqResp.sendBatchRequest', (subProtocol, requests) => ({
-                    [Attributes.P2P_REQ_RESP_PROTOCOL]: subProtocol,
-                    [Attributes.P2P_REQ_RESP_BATCH_REQUESTS_COUNT]: requests.length,
-                }))];
-            _sendRequestToPeer_decorators = [trackSpan('ReqResp.sendRequestToPeer', (peerId, subProtocol, _) => ({
-                    [Attributes.P2P_ID]: peerId.toString(),
-                    [Attributes.P2P_REQ_RESP_PROTOCOL]: subProtocol,
-                }))];
-            _streamHandler_decorators = [trackSpan('ReqResp.streamHandler', (protocol, { connection }) => ({
-                    [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol,
-                    [Attributes.P2P_ID]: connection.remotePeer.toString(),
-                }))];
-            __esDecorate(_a, null, _sendBatchRequest_decorators, { kind: "method", name: "sendBatchRequest", static: false, private: false, access: { has: obj => "sendBatchRequest" in obj, get: obj => obj.sendBatchRequest }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _sendRequestToPeer_decorators, { kind: "method", name: "sendRequestToPeer", static: false, private: false, access: { has: obj => "sendRequestToPeer" in obj, get: obj => obj.sendRequestToPeer }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _streamHandler_decorators, { kind: "method", name: "streamHandler", static: false, private: false, access: { has: obj => "streamHandler" in obj, get: obj => obj.streamHandler }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
-})();
-export { ReqResp };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reqresp.js","sourceRoot":"","sources":["../../../src/services/reqresp/reqresp.ts"],"names":[],"mappings":"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"}
+            const sendErrorChunk = this.sendErrorChunk(errorStatus);
+            // Return and yield the response chunk
+            await pipe(stream, async function*(_source) {
+                yield* sendErrorChunk;
+            }, stream);
+        } finally{
+            await stream.close();
+        }
+    }
+    async *sendErrorChunk(error) {
+        const errorChunk = Buffer.from([
+            error
+        ]);
+        yield new Uint8Array(errorChunk);
+    }
+}
+_ts_decorate([
+    trackSpan('ReqResp.sendBatchRequest', (subProtocol, requests)=>({
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: subProtocol,
+            [Attributes.P2P_REQ_RESP_BATCH_REQUESTS_COUNT]: requests.length
+        }))
+], ReqResp.prototype, "sendBatchRequest", null);
+_ts_decorate([
+    trackSpan('ReqResp.sendRequestToPeer', (peerId, subProtocol, _)=>({
+            [Attributes.P2P_ID]: peerId.toString(),
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: subProtocol
+        }))
+], ReqResp.prototype, "sendRequestToPeer", null);
+_ts_decorate([
+    trackSpan('ReqResp.streamHandler', (protocol, { connection })=>({
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol,
+            [Attributes.P2P_ID]: connection.remotePeer.toString()
+        }))
+], ReqResp.prototype, "streamHandler", null);