@aztec/p2p 0.71.0 → 0.72.1

package/dest/services/reqresp/reqresp.js

@@ -1,12 +1,17 @@
+import { __esDecorate, __runInitializers } from "tslib";
 // @attribution: lodestar impl for inspiration
 import { PeerErrorSeverity } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
 import { executeTimeout } from '@aztec/foundation/timer';
+import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { pipe } from 'it-pipe';
 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, subProtocolMap, } from './interface.js';
-import { RequestResponseRateLimiter } from './rate_limiter/rate_limiter.js';
+import { ReqRespMetrics } from './metrics.js';
+import { RequestResponseRateLimiter } from './rate-limiter/rate_limiter.js';
 /**
  * The Request Response Service
  *
@@ -21,259 +26,419 @@ import { RequestResponseRateLimiter } from './rate_limiter/rate_limiter.js';
  *
  * see: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#the-reqresp-domain
  */
-export class ReqResp {
-    constructor(config, libp2p, peerManager) {
-        this.libp2p = libp2p;
-        this.peerManager = peerManager;
-        // 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(peerManager);
-        this.snappyTransform = new SnappyTransform();
-    }
-    /**
-     * 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, this.streamHandler.bind(this, subProtocol));
-        }
-        this.rateLimiter.start();
-    }
-    /**
-     * Stop the reqresp service
-     */
-    async stop() {
-        // Unregister all handlers
-        for (const protocol of Object.keys(this.subProtocolHandlers)) {
-            await this.libp2p.unhandle(protocol);
-        }
-        // Close all active connections
-        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:
-     * - Iterates over all active peers.
-     * - Opens a stream with each 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 requestFunction = async () => {
-            const responseValidator = this.subProtocolValidators[subProtocol];
-            const requestBuffer = request.toBuffer();
-            // Get active peers
-            const peers = this.libp2p.getPeers();
-            // Attempt to ask all of our peers
-            for (const peer of peers) {
-                const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
-                // 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.length > 0) {
-                    const object = subProtocolMap[subProtocol].response.fromBuffer(response);
-                    // The response validator handles peer punishment within
-                    const isValid = await responseValidator(request, object, peer);
-                    if (!isValid) {
-                        throw new InvalidResponseError();
+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);
+            }
+            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, this.streamHandler.bind(this, subProtocol));
+                }
+                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;
                     }
-                    return object;
+                    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 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.length > 0) {
+                            const object = subProtocolMap[subProtocol].response.fromBuffer(response);
+                            // The response validator handles peer punishment within
+                            const isValid = await responseValidator(request, object, peer);
+                            if (!isValid) {
+                                throw new InvalidResponseError();
+                            }
+                            return object;
+                        }
+                    }
+                };
+                try {
+                    return await executeTimeout(requestFunction, this.overallRequestTimeoutMs, () => new CollectiveReqRespTimeoutError());
+                }
+                catch (e) {
+                    this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
+                    return undefined;
                 }
             }
-            return undefined;
-        };
-        try {
-            return await executeTimeout(requestFunction, this.overallRequestTimeoutMs, () => new CollectiveReqRespTimeoutError());
-        }
-        catch (e) {
-            this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
-            return undefined;
-        }
-    }
-    /**
-     * 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 {
-            stream = await this.libp2p.dialProtocol(peerId, subProtocol);
-            this.logger.trace(`Stream opened with ${peerId.toString()} for ${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.handleResponseError(e, peerId, subProtocol);
-        }
-        finally {
-            if (stream) {
+            /**
+             * 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]);
+                                    if (response && response.length > 0) {
+                                        const object = subProtocolMap[subProtocol].response.fromBuffer(response);
+                                        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);
+                                batchSampler.removePeerAndReplace(peer);
+                                return { peer, results: [] };
+                            }
+                        }));
+                        // Process results
+                        for (const { results } of batchResults) {
+                            for (const { index, response } of results) {
+                                if (response) {
+                                    responses[index] = response;
+                                    pendingRequestIndices.delete(index);
+                                }
+                            }
+                        }
+                        retryAttempts++;
+                    }
+                    if (retryAttempts >= maxRetryAttempts) {
+                        this.logger.debug(`Max retry attempts ${maxRetryAttempts} reached for batch request`);
+                    }
+                    return responses;
+                };
                 try {
-                    await stream.close();
-                    this.logger.trace(`Stream closed with ${peerId.toString()} for ${subProtocol}`);
+                    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);
                 }
-                catch (closeError) {
-                    this.logger.error(`Error closing stream: ${closeError instanceof Error ? closeError.message : 'Unknown error'}`);
+                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'}`);
+                        }
+                    }
+                }
+            }
+            /**
+             * 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.peerManager.penalizePeer(peerId, severity);
-        }
-    }
-    /**
-     * Categorize the error and log it.
-     */
-    categorizeError(e, peerId, subProtocol) {
-        // Non pubishable errors
-        // 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
-     */
-    async readMessage(source) {
-        const chunks = [];
-        for await (const chunk of source) {
-            chunks.push(chunk.subarray());
-        }
-        const messageData = Buffer.concat(chunks);
-        return this.snappyTransform.inboundTransformNoTopic(messageData);
-    }
-    /**
-     * 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 }) {
-        // 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}`);
-            // TODO(#8483): handle changing peer scoring for failed rate limit, maybe differentiate between global and peer limits here when punishing
-            await stream.close();
-            return;
-        }
-        const handler = this.subProtocolHandlers[protocol];
-        const transform = this.snappyTransform;
-        try {
-            await pipe(stream, async function* (source) {
-                for await (const chunkList of source) {
-                    const msg = Buffer.from(chunkList.subarray());
-                    const response = await handler(msg);
-                    yield new Uint8Array(transform.outboundTransformNoTopic(response));
+            /**
+             * Categorize the error and log it.
+             */
+            categorizeError(e, peerId, subProtocol) {
+                // Non pubishable errors
+                // 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;
                 }
-            }, stream);
-        }
-        catch (e) {
-            this.logger.warn(e);
-        }
-        finally {
-            await stream.close();
-        }
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reqresp.js","sourceRoot":"","sources":["../../../src/services/reqresp/reqresp.ts"],"names":[],"mappings":"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"}
+                // 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
+             */
+            async readMessage(source) {
+                const chunks = [];
+                for await (const chunk of source) {
+                    chunks.push(chunk.subarray());
+                }
+                const messageData = Buffer.concat(chunks);
+                return this.snappyTransform.inboundTransformNoTopic(messageData);
+            }
+            /**
+             * 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);
+                // 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}`);
+                    // TODO(#8483): handle changing peer scoring for failed rate limit, maybe differentiate between global and peer limits here when punishing
+                    await stream.close();
+                    return;
+                }
+                const handler = this.subProtocolHandlers[protocol];
+                const transform = this.snappyTransform;
+                try {
+                    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);
+                            yield new Uint8Array(transform.outboundTransformNoTopic(response));
+                        }
+                    }, stream);
+                }
+                catch (e) {
+                    this.logger.warn(e);
+                    this.metrics.recordResponseError(protocol);
+                }
+                finally {
+                    await stream.close();
+                }
+            }
+        },
+        (() => {
+            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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"}