@aztec/p2p 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.75.0

package/dest/services/reqresp/reqresp.js

@@ -1,23 +1,17 @@
+import { __esDecorate, __runInitializers } from "tslib";
 // @attribution: lodestar impl for inspiration
-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 { 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 { 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, subProtocolMap, } from './interface.js';
 import { ReqRespMetrics } from './metrics.js';
 import { RequestResponseRateLimiter } from './rate-limiter/rate_limiter.js';
-import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqRespStatus } from './status.js';
 /**
  * The Request Response Service
  *
@@ -31,480 +25,420 @@ 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
- */ 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;
+ */
+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);
             }
-            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;
+            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();
             }
-        };
-        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 [];
+            /**
+             * 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
             }
-            // 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;
+            /**
+             * 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;
                     }
-                    if (!requestBatches.has(peer)) {
-                        requestBatches.set(peer, []);
+                    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;
+                        }
                     }
-                    requestBatches.get(peer).push(requestIndex);
+                };
+                try {
+                    return await executeTimeout(requestFunction, this.overallRequestTimeoutMs, () => new CollectiveReqRespTimeoutError());
+                }
+                catch (e) {
+                    this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
+                    return undefined;
                 }
-                // 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
+            }
+            /**
+             * 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: peerResults
-                                };
+                                return { peer, results: [] };
                             }
-                            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
-                                    });
+                        }));
+                        // Process results
+                        for (const { results } of batchResults) {
+                            for (const { index, response } of results) {
+                                if (response) {
+                                    responses[index] = response;
+                                    pendingRequestIndices.delete(index);
                                 }
                             }
                         }
-                        return {
-                            peer,
-                            results: peerResults
-                        };
-                    } catch (error) {
-                        this.logger.debug(`Failed batch request to peer ${peer.toString()}:`, error);
-                        batchSampler.removePeerAndReplace(peer);
-                        return {
-                            peer,
-                            results: []
-                        };
+                        retryAttempts++;
                     }
-                }));
-                // Process results
-                for (const { results } of batchResults){
-                    for (const { index, response } of results){
-                        if (response) {
-                            responses[index] = response;
-                            pendingRequestIndices.delete(index);
-                        }
+                    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 [];
                 }
-                retryAttempts++;
-            }
-            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) {
+            /**
+             * 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 {
-                    await this.connectionSampler.close(stream.id);
-                } catch (closeError) {
-                    this.logger.error(`Error closing stream: ${closeError instanceof Error ? closeError.message : 'Unknown error'}`);
+                    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'}`);
+                        }
+                    }
                 }
             }
-        }
-    }
-    /**
-   * 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());
+            /**
+             * 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);
                 }
             }
-            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;
+            /**
+             * 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;
             }
-            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
-            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);
+            /**
+             * 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);
             }
-            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);
-                    // Send success code first, then the response
-                    const successChunk = Buffer.from([
-                        ReqRespStatus.SUCCESS
-                    ]);
-                    yield new Uint8Array(successChunk);
-                    yield new Uint8Array(transform.outboundTransformNoTopic(response));
+            /**
+             * 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();
                 }
-            }, stream);
-        } catch (e) {
-            this.logger.warn(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();
-        }
-    }
-    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);
+        },
+        (() => {
+            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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"}