@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

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

@@ -1 +1 @@
-{"version":3,"file":"reqresp.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/reqresp.ts"],"names":[],"mappings":"AAMA,OAAO,EAAc,KAAK,eAAe,EAAiC,MAAM,yBAAyB,CAAC;AAE1G,OAAO,KAAK,EAAsB,MAAM,EAAU,MAAM,mBAAmB,CAAC;AAG5E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AASrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,kBAAkB,EAClB,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EACjC,KAAK,cAAc,EAEpB,MAAM,gBAAgB,CAAC;AASxB;;;;;;;;;;;;;GAaG;AACH,qBAAa,OAAQ,YAAW,gBAAgB;IAkB5C,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,MAAM;IAnBhB,OAAO,CAAC,uBAAuB,CAA8C;IAC7E,OAAO,CAAC,0BAA0B,CAAiD;IACnF,OAAO,CAAC,aAAa,CAA2C;IAGhE,OAAO,CAAC,mBAAmB,CAA6D;IACxF,OAAO,CAAC,qBAAqB,CAAiE;IAE9F,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,WAAW,CAA6B;IAEhD,OAAO,CAAC,eAAe,CAAkB;IAEzC,OAAO,CAAC,OAAO,CAAiB;gBAG9B,MAAM,EAAE,gBAAgB,EAChB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,EACxB,MAAM,yCAA8B,EAC5C,UAAU,GAAE,OAAO,CAAC,4BAA4B,CAAM,EACtD,eAAe,GAAE,eAAsC;IAkBlD,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;IAc5D,IAAI,MAAM,6CAET;IAED;;OAEG;IACG,KAAK,CAAC,mBAAmB,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,4BAA4B;IAiBhH;;OAEG;IACG,IAAI;IAoBV;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,WAAW,CAAC,WAAW,SAAS,kBAAkB,EACtD,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,GAC5D,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC;IAiE7E;;;;;;;;;;;;;;;;;;;;;OAqBG;IAQG,gBAAgB,CAAC,WAAW,SAAS,kBAAkB,EAC3D,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAChE,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,SAAS,SAAQ,EACjB,QAAQ,SAA+C,EACvD,gBAAgB,SAAI,GACnB,OAAO,CAAC,CAAC,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;IAgJjF;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IAKU,iBAAiB,CAC5B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,MAA2B,GACvC,OAAO,CAAC,eAAe,CAAC;IA4C3B;;;;;;;;;OASG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;OAEG;IACH,OAAO,CAAC,eAAe;IAiEvB;;;;;;OAMG;YACW,WAAW;IAoCzB;;;;;;;;;;;;;;;OAeG;YAKW,aAAa;YAsFZ,cAAc;CAI9B"}
+{"version":3,"file":"reqresp.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/reqresp.ts"],"names":[],"mappings":"AAMA,OAAO,EAAc,KAAK,eAAe,EAAiC,MAAM,yBAAyB,CAAC;AAE1G,OAAO,KAAK,EAAsB,MAAM,EAAU,MAAM,mBAAmB,CAAC;AAC5E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAUrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EACjC,KAAK,cAAc,EAEpB,MAAM,gBAAgB,CAAC;AASxB;;;;;;;;;;;;;GAaG;AACH,qBAAa,OAAQ,YAAW,gBAAgB;IAiB5C,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,MAAM;IAlBhB,OAAO,CAAC,0BAA0B,CAAiD;IACnF,OAAO,CAAC,aAAa,CAA2C;IAGhE,OAAO,CAAC,mBAAmB,CAA6D;IACxF,OAAO,CAAC,qBAAqB,CAAiE;IAE9F,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,WAAW,CAA6B;IAEhD,OAAO,CAAC,eAAe,CAAkB;IAEzC,OAAO,CAAC,OAAO,CAAiB;gBAG9B,MAAM,EAAE,gBAAgB,EAChB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,EACxB,MAAM,yCAA8B,EAC5C,UAAU,GAAE,OAAO,CAAC,4BAA4B,CAAM,EACtD,eAAe,GAAE,eAAsC;IAkBlD,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;IAU5D,IAAI,MAAM,6CAET;IAED;;OAEG;IACG,KAAK,CAAC,mBAAmB,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,4BAA4B;IAiB1G,cAAc,CAClB,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,yBAAyB,EAClC,SAAS,GAAE,4BAA4B,CAAC,kBAAkB,CAAgD,GACzG,OAAO,CAAC,IAAI,CAAC;IAYhB;;OAEG;IACG,IAAI;IAoBV;;;;;;;;;;;;;;;;;;;;;OAqBG;IAQG,gBAAgB,CAAC,WAAW,SAAS,kBAAkB,EAC3D,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAChE,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,SAAS,SAAQ,EACjB,QAAQ,SAA+C,EACvD,gBAAgB,SAAI,GACnB,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC;IAgJnE;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IAKU,iBAAiB,CAC5B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,MAA2B,GACvC,OAAO,CAAC,eAAe,CAAC;IAsD3B;;;;;;;;;OASG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;;;;;OAMG;YACW,WAAW;IA6CzB;;;;;;;;;;;;;;;;OAgBG;YAKW,aAAa;IAuD3B;;;;;;;SAOK;YACS,aAAa;IA4B3B;;;;;;;OAOG;YACW,YAAY;IAmC1B,OAAO,CAAC,kBAAkB;IAO1B;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAyB/B,OAAO,CAAC,0BAA0B;CA8DnC"}

package/dest/services/reqresp/reqresp.js

@@ -11,14 +11,13 @@ 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 { abortableDuplex, abortableSink } from 'abortable-iterator';
-import { pipe } from 'it-pipe';
+import { pipeline } from 'node:stream/promises';
 import { CollectiveReqRespTimeoutError, IndividualReqRespTimeoutError, InvalidResponseError } from '../../errors/reqresp.error.js';
 import { SnappyTransform } from '../encoding.js';
-import { DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS, DEFAULT_OVERALL_REQUEST_TIMEOUT_MS, DEFAULT_REQRESP_DIAL_TIMEOUT_MS } from './config.js';
+import { DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS, DEFAULT_REQRESP_DIAL_TIMEOUT_MS } from './config.js';
 import { BatchConnectionSampler } from './connection-sampler/batch_connection_sampler.js';
 import { ConnectionSampler, RandomSampler } 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, responseFromBuffer } from './interface.js';
 import { ReqRespMetrics } from './metrics.js';
 import { RateLimitStatus, RequestResponseRateLimiter, prettyPrintRateLimitStatus } from './rate-limiter/rate_limiter.js';
 import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqRespStatus } from './status.js';
@@ -39,7 +38,6 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
     libp2p;
     peerScoring;
     logger;
-    overallRequestTimeoutMs;
     individualRequestTimeoutMs;
     dialTimeoutMs;
     // Warning, if the `start` function is not called as the parent class constructor, then the default sub protocol handlers will be used ( not good )
@@ -53,7 +51,6 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
         this.libp2p = libp2p;
         this.peerScoring = peerScoring;
         this.logger = logger;
-        this.overallRequestTimeoutMs = DEFAULT_OVERALL_REQUEST_TIMEOUT_MS;
         this.individualRequestTimeoutMs = DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS;
         this.dialTimeoutMs = DEFAULT_REQRESP_DIAL_TIMEOUT_MS;
         this.subProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
@@ -66,9 +63,6 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
         this.metrics = new ReqRespMetrics(telemetryClient);
     }
     updateConfig(config) {
-        if (typeof config.overallRequestTimeoutMs === 'number') {
-            this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
-        }
         if (typeof config.individualRequestTimeoutMs === 'number') {
             this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
         }
@@ -90,6 +84,11 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
         }
         this.rateLimiter.start();
     }
+    async addSubProtocol(subProtocol, handler, validator = DEFAULT_SUB_PROTOCOL_VALIDATORS[subProtocol]) {
+        this.subProtocolHandlers[subProtocol] = handler;
+        this.subProtocolValidators[subProtocol] = validator;
+        await this.libp2p.handle(subProtocol, (data)=>void this.streamHandler(subProtocol, data).catch((err)=>this.logger.error(`Error on libp2p subprotocol ${subProtocol} handler`, err)));
+    }
     /**
    * Stop the reqresp service
    */ async stop() {
@@ -108,84 +107,6 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
     // 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 (signal)=>{
-            // 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;
-            }
-            const attemptedPeers = new Map();
-            for(let i = 0; i < numberOfPeers; i++){
-                if (signal.aborted) {
-                    throw new AbortError('Request has been aborted');
-                }
-                // 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.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;
-                }
-            }
-        };
-        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
@@ -282,7 +203,7 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
                                 };
                             }
                             if (response && response.data.length > 0) {
-                                const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
+                                const object = responseFromBuffer(subProtocol, response.data);
                                 const isValid = await responseValidator(requests[index], object, peer);
                                 if (isValid) {
                                     peerResults.push({
@@ -359,22 +280,35 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
             this.logger.trace(`Sending request to peer ${peerId.toString()} on sub protocol ${subProtocol}`);
             stream = await this.connectionSampler.dialProtocol(peerId, subProtocol, dialTimeout);
             this.logger.trace(`Opened stream ${stream.id} for sending request to peer ${peerId.toString()} on sub protocol ${subProtocol}`);
-            // Open the stream with a timeout
-            const result = await executeTimeout((signal)=>pipe([
-                    payload
-                ], abortableDuplex(stream, signal), abortableSink(this.readMessage.bind(this), signal)), this.individualRequestTimeoutMs, ()=>new IndividualReqRespTimeoutError());
-            return result;
+            const timeoutErr = new IndividualReqRespTimeoutError();
+            const [_, resp] = await executeTimeout((signal)=>Promise.all([
+                    pipeline([
+                        payload
+                    ], stream.sink, {
+                        signal
+                    }),
+                    pipeline(stream.source, this.readMessage.bind(this), {
+                        signal
+                    })
+                ]), this.individualRequestTimeoutMs, ()=>timeoutErr);
+            return resp;
         } catch (e) {
+            // On error we immediately abort the stream, this is preferred way,
+            // because it signals to the sender that error happened, whereas
+            // closing the stream only closes our side and is much slower
+            if (stream) {
+                stream.abort(e);
+            }
             this.metrics.recordRequestError(subProtocol);
             this.handleResponseError(e, peerId, subProtocol);
             // If there is an exception, we return an unknown response
             this.logger.debug(`Error sending request to peer ${peerId.toString()} on sub protocol ${subProtocol}: ${e}`);
             return {
-                status: ReqRespStatus.FAILURE,
-                data: Buffer.from([])
+                status: ReqRespStatus.FAILURE
             };
         } finally{
             // Only close the stream if we created it
+            // Note even if we aborted the stream, calling close on it is ok, it's just a no-op
             if (stream) {
                 try {
                     this.logger.trace(`Closing stream ${stream.id} for request to peer ${peerId.toString()} on sub protocol ${subProtocol}`);
@@ -395,88 +329,41 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
    * @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);
+        const severity = this.categorizeResponseError(e, peerId, subProtocol);
         if (severity) {
             this.peerScoring.penalizePeer(peerId, severity);
         }
     }
     /**
-   * Categorize the error and log it.
-   */ categorizeError(e, peerId, subProtocol) {
-        const logTags = {
-            peerId: peerId.toString(),
-            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', logTags);
-            return undefined;
-        }
-        // We do not punish a collective timeout, as the node triggers this interupt, independent of the peer's behaviour
-        if (e instanceof CollectiveReqRespTimeoutError || e instanceof InvalidResponseError) {
-            this.logger.debug(`Non-punishable error in ${subProtocol}: ${e.message}`, logTags);
-            return undefined;
-        }
-        // Do not punish if we are stopping the service
-        if (e && (e instanceof AbortError || e.code === 'ABORT_ERR')) {
-            this.logger.debug(`Request aborted: ${e.message}`, logTags);
-            return undefined;
-        }
-        // Do not punish if we are the ones closing the connection
-        if (e?.code === 'ERR_CONNECTION_BEING_CLOSED' || e?.code === 'ERR_CONNECTION_CLOSED' || e?.code === 'ERR_TRANSIENT_CONNECTION' || e?.message?.includes('Muxer already closed')) {
-            this.logger.debug(`Connection closed to peer from our side: ${peerId.toString()} (${e?.message ?? 'missing error message'})`, 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;
-        }
-        if (e?.code === 'ERR_UNEXPECTED_EOF') {
-            this.logger.debug(`Connection unexpected EOF: ${peerId.toString()}`, logTags);
-            return PeerErrorSeverity.HighToleranceError;
-        }
-        // Timeout errors are punished with high tolerance, they can be due to a geographically far away or overloaded peer
-        if (e instanceof IndividualReqRespTimeoutError || e instanceof TimeoutError) {
-            this.logger.debug(`Timeout error in ${subProtocol}: ${e.message}`, logTags);
-            return PeerErrorSeverity.HighToleranceError;
-        }
-        // Catch all error
-        this.logger.debug(`Unexpected error sending request to peer`, {
-            err: 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;
+        let status;
         const chunks = [];
         try {
             for await (const chunk of source){
-                if (statusBuffer === undefined) {
-                    const firstChunkBuffer = chunk.subarray();
-                    statusBuffer = parseStatusChunk(firstChunkBuffer);
-                } else {
+                const statusParsed = status !== undefined;
+                if (statusParsed) {
                     chunks.push(chunk.subarray());
+                    continue;
+                }
+                const firstChunkBuffer = chunk.subarray();
+                status = parseStatusChunk(firstChunkBuffer);
+                // In case status is not SUCCESS, we do not expect any data in the response
+                // we can return early
+                if (status !== ReqRespStatus.SUCCESS) {
+                    return {
+                        status
+                    };
                 }
             }
             const messageData = Buffer.concat(chunks);
             const message = this.snappyTransform.inboundTransformNoTopic(messageData);
             return {
-                status: statusBuffer ?? ReqRespStatus.UNKNOWN,
+                status: status ?? ReqRespStatus.UNKNOWN,
                 data: message
             };
         } catch (e) {
@@ -486,8 +373,7 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
                 status = e.status;
             }
             return {
-                status,
-                data: Buffer.from([])
+                status
             };
         }
     }
@@ -495,7 +381,8 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
    * Stream Handler
    * Reads the incoming stream, determines the protocol, then triggers the appropriate handler
    *
-   * @param param0 - The incoming stream data
+   * @param protocol - The sub protocol to handle
+   * @param incomingStream - The incoming stream data containing the stream and connection
    *
    * @description
    * An individual stream handler will be bound to each sub protocol, and handles returning data back
@@ -506,81 +393,194 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
    *
    * 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);
+   */ async streamHandler(protocol, incomingStream) {
+        const { stream, connection } = incomingStream;
         try {
-            // Store a reference to from this for the async generator
+            this.metrics.recordRequestReceived(protocol);
             const rateLimitStatus = this.rateLimiter.allow(protocol, connection.remotePeer);
-            if (rateLimitStatus != RateLimitStatus.Allowed) {
+            if (rateLimitStatus !== RateLimitStatus.Allowed) {
                 this.logger.verbose(`Rate limit exceeded ${prettyPrintRateLimitStatus(rateLimitStatus)} 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) {
-                        // NOTE: The stream was already closed by Goodbye handler
-                        // peerManager.goodbyeReceived(peerId, reason); will call libp2p.hangUp closing all active streams and connections
-                        // Don't respond
-                        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) {
-            let level = 'warn';
-            if (e && (e instanceof ReqRespStatusError && e.status === ReqRespStatus.RATE_LIMIT_EXCEEDED || e instanceof Error && [
-                'stream reset',
-                'Cannot push value onto an ended pushable'
-            ].some((msg)=>e.message.includes(msg)))) {
-                level = 'debug';
-            }
-            this.logger[level](`Reqresp response error: ${String(e)}`, e);
+            await this.processStream(protocol, incomingStream);
+        } catch (err) {
             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 canWriteToStream = stream.status === 'open' && (stream.writeStatus === 'writing' || stream.writeStatus === 'ready');
-            if (!canWriteToStream) {
-                this.logger.debug('Stream already closed, not sending error response', {
+            this.handleRequestError(err, connection.remotePeer, protocol);
+            if (err instanceof ReqRespStatusError) {
+                const errorSent = await this.trySendError(stream, connection.remotePeer, protocol, err.status);
+                const logMessage = errorSent ? 'Protocol error sent successfully.' : 'Stream already closed or poisoned, not sending error response.';
+                const isRateLimit = err.status === ReqRespStatus.RATE_LIMIT_EXCEEDED;
+                const level = isRateLimit ? 'debug' : 'warn';
+                this.logger[level](logMessage + ` Status: ${ReqRespStatus[err.status]}`, {
                     protocol,
-                    err: e,
-                    errorStatus
+                    err,
+                    errorStatus: err.status,
+                    cause: err.cause ?? 'Cause unknown'
                 });
-                return;
-            }
-            // Return and yield the response chunk
-            try {
-                const sendErrorChunk = this.sendErrorChunk(errorStatus);
-                await pipe(stream, async function*(_source) {
-                    yield* sendErrorChunk;
-                }, stream);
-            } catch (e) {
-                this.logger.warn('Error while sending error response', {
+            } else {
+                // In erroneous case we abort the stream, this will signal the peer that something went wrong
+                // and that this stream should be dropped
+                const isMessageToNotWarn = err instanceof Error && [
+                    'stream reset',
+                    'Cannot push value onto an ended pushable'
+                ].some((msg)=>err.message.includes(msg));
+                const level = isMessageToNotWarn ? 'debug' : 'warn';
+                this.logger[level]('Unknown stream error while handling the stream, aborting', {
                     protocol,
-                    err: e,
-                    errorStatus
+                    err
                 });
+                stream.abort(err);
             }
         } finally{
+            //NOTE: This is idempotent action, so it's ok to call it even if stream was aborted
             await stream.close();
         }
     }
-    async *sendErrorChunk(error) {
-        const errorChunk = Buffer.from([
-            error
-        ]);
-        yield new Uint8Array(errorChunk);
+    /**
+   * Reads incoming data from the stream, processes it according to the sub protocol,
+   * and puts response back into the stream.
+   *
+   * @param protocol - The sub protocol to use for processing the stream
+   * @param incomingStream - The incoming stream data containing the stream and connection
+   *
+   * */ async processStream(protocol, { stream, connection }) {
+        const handler = this.subProtocolHandlers[protocol];
+        const snappy = this.snappyTransform;
+        const SUCCESS = Uint8Array.of(ReqRespStatus.SUCCESS);
+        await pipeline(stream.source, async function*(source) {
+            for await (const chunk of source){
+                const response = await handler(connection.remotePeer, chunk.subarray());
+                if (protocol === ReqRespSubProtocol.GOODBYE) {
+                    // NOTE: The stream was already closed by Goodbye handler
+                    // peerManager.goodbyeReceived(peerId, reason); will call libp2p.hangUp closing all active streams and connections
+                    // Don't try to respond
+                    return;
+                }
+                stream.metadata.written = true; // Mark the stream as written to;
+                yield SUCCESS;
+                yield snappy.outboundTransformNoTopic(response);
+            }
+        }, stream.sink);
+    }
+    /**
+   * Try to send error status to the peer. We say try, because the stream,
+   * might already be closed
+   * @param stream - The stream opened between us and the peer
+   * @param status - The error status to send back to the peer
+   * @returns true if error was sent successfully, otherwise false
+   *
+   */ async trySendError(stream, peerId, protocol, status) {
+        const canWriteToStream = // 'writing' is a bit weird naming, but it actually means that the stream is ready to write
+        // 'ready' means that stream ready to be opened for writing
+        stream.status === 'open' && (stream.writeStatus === 'writing' || stream.writeStatus === 'ready');
+        // Stream was already written to, we consider it poisoned, in a sense,
+        // that even if we write an error response, it will not be interpreted correctly by the peer
+        const streamPoisoned = stream.metadata.written === true;
+        const shouldWriteToStream = canWriteToStream && !streamPoisoned;
+        if (!shouldWriteToStream) {
+            return false;
+        }
+        try {
+            await pipeline(function*() {
+                yield Uint8Array.of(status);
+            }, stream.sink);
+            return true;
+        } catch (e) {
+            this.logger.warn('Error while sending error response', e);
+            stream.abort(e);
+            this.handleRequestError(e, peerId, protocol);
+            return false;
+        }
+    }
+    handleRequestError(e, peerId, subProtocol) {
+        const severity = this.categorizeRequestError(e, peerId, subProtocol);
+        if (severity) {
+            this.peerScoring.penalizePeer(peerId, severity);
+        }
+    }
+    /**
+   * Categorize the request error and log it.
+   *
+   * @returns Severity of the error, or undefined if the error is not punishable.
+   */ categorizeRequestError(e, peerId, subProtocol) {
+        const logTags = {
+            peerId: peerId.toString(),
+            subProtocol
+        };
+        //Punishable error - peer should never send badly formed request
+        if (e instanceof ReqRespStatusError && e.status === ReqRespStatus.BADLY_FORMED_REQUEST) {
+            this.logger.debug(`Punishable error in ${subProtocol}: ${e.cause}`, logTags);
+            return PeerErrorSeverity.LowToleranceError;
+        }
+        //TODO: (mralj): think if we should penalize peer here based on connection errors
+        return undefined;
+    }
+    /**
+   * Categorize the response error and log it.
+   *
+   * @returns Severity of the error, or undefined if the error is not punishable.
+   */ categorizeResponseError(e, peerId, subProtocol) {
+        const logTags = {
+            peerId: peerId.toString(),
+            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', logTags);
+            return undefined;
+        }
+        // We do not punish a collective timeout, as the node triggers this interupt, independent of the peer's behaviour
+        if (e instanceof CollectiveReqRespTimeoutError || e instanceof InvalidResponseError) {
+            this.logger.debug(`Non-punishable error in ${subProtocol}: ${e.message}`, logTags);
+            return undefined;
+        }
+        return this.categorizeConnectionErrors(e, peerId, subProtocol);
+    }
+    /*
+   * Errors specific to connection  handling
+   * These can happen  both when sending request and response*/ categorizeConnectionErrors(e, peerId, subProtocol) {
+        const logTags = {
+            peerId: peerId.toString(),
+            subProtocol
+        };
+        // Do not punish if we are stopping the service
+        if (e instanceof AbortError || e?.code == 'ABORT_ERR') {
+            this.logger.debug(`Request aborted: ${e.message}`, logTags);
+            return undefined;
+        }
+        // Do not punish if we are the ones closing the connection
+        if (e?.code === 'ERR_CONNECTION_BEING_CLOSED' || e?.code === 'ERR_CONNECTION_CLOSED' || e?.code === 'ERR_TRANSIENT_CONNECTION' || e?.message?.includes('Muxer already closed') || e?.message?.includes('muxer closed') || e?.message?.includes('ended pushable')) {
+            this.logger.debug(`Connection closed to peer from our side: ${peerId.toString()} (${e?.message ?? 'missing error message'})`, 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;
+        }
+        if (e?.code === 'ERR_UNEXPECTED_EOF') {
+            this.logger.debug(`Connection unexpected EOF: ${peerId.toString()}`, logTags);
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        if (e?.code === 'ERR_UNSUPPORTED_PROTOCOL') {
+            this.logger.debug(`Sub protocol not supported by peer: ${peerId.toString()}`, logTags);
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        // Timeout errors are punished with high tolerance, they can be due to a geographically far away or overloaded peer
+        if (e instanceof IndividualReqRespTimeoutError || e instanceof TimeoutError) {
+            this.logger.debug(`Timeout error in ${subProtocol}: ${e.message}`, logTags);
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        // Catch all error
+        this.logger.error(`Unexpected error in ReqResp protocol`, e, logTags);
+        return PeerErrorSeverity.HighToleranceError;
     }
 }
 _ts_decorate([

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

@@ -5,15 +5,20 @@ export declare enum ReqRespStatus {
     SUCCESS = 0,
     RATE_LIMIT_EXCEEDED = 1,
     BADLY_FORMED_REQUEST = 2,
+    INTERNAL_ERROR = 3,
+    NOT_FOUND = 4,
     FAILURE = 126,
     UNKNOWN = 127
 }
+export type UnsuccessfulReqRespStatus = Exclude<ReqRespStatus, ReqRespStatus.SUCCESS>;
 export declare class ReqRespStatusError extends Error {
     /**
      * The status code
      */
-    status: ReqRespStatus;
-    constructor(status: ReqRespStatus);
+    readonly status: UnsuccessfulReqRespStatus;
+    constructor(status: UnsuccessfulReqRespStatus, cause?: {
+        cause?: Error;
+    });
 }
 /**
  * Parse the status chunk
@@ -28,5 +33,5 @@ export declare function parseStatusChunk(chunk: Uint8Array): ReqRespStatus;
  * @param status
  * @returns
  */
-export declare function prettyPrintReqRespStatus(status: ReqRespStatus): "SUCCESS" | "RATE_LIMIT_EXCEEDED" | "BADLY_FORMED_REQUEST" | "FAILURE" | "UNKNOWN";
+export declare function prettyPrintReqRespStatus(status: ReqRespStatus): "SUCCESS" | "RATE_LIMIT_EXCEEDED" | "BADLY_FORMED_REQUEST" | "FAILURE" | "INTERNAL_ERROR" | "UNKNOWN" | undefined;
 //# sourceMappingURL=status.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/status.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,aAAa;IACvB,OAAO,IAAI;IACX,mBAAmB,IAAI;IACvB,oBAAoB,IAAI;IACxB,OAAO,MAAM;IACb,OAAO,MAAM;CACd;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;OAEG;IACH,MAAM,EAAE,aAAa,CAAC;gBAEV,MAAM,EAAE,aAAa;CAIlC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAWjE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,sFAa7D"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/status.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,aAAa;IACvB,OAAO,IAAI;IACX,mBAAmB,IAAI;IACvB,oBAAoB,IAAI;IACxB,cAAc,IAAI;IAClB,SAAS,IAAI;IACb,OAAO,MAAM;IACb,OAAO,MAAM;CACd;AAED,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAAC,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;AAEtF,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;gBAE/B,MAAM,EAAE,yBAAyB,EAAE,KAAK,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE;CAIzE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAWjE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,qHAe7D"}

package/dest/services/reqresp/status.js

@@ -4,6 +4,8 @@
     ReqRespStatus[ReqRespStatus["SUCCESS"] = 0] = "SUCCESS";
     ReqRespStatus[ReqRespStatus["RATE_LIMIT_EXCEEDED"] = 1] = "RATE_LIMIT_EXCEEDED";
     ReqRespStatus[ReqRespStatus["BADLY_FORMED_REQUEST"] = 2] = "BADLY_FORMED_REQUEST";
+    ReqRespStatus[ReqRespStatus["INTERNAL_ERROR"] = 3] = "INTERNAL_ERROR";
+    ReqRespStatus[ReqRespStatus["NOT_FOUND"] = 4] = "NOT_FOUND";
     ReqRespStatus[ReqRespStatus["FAILURE"] = 126] = "FAILURE";
     ReqRespStatus[ReqRespStatus["UNKNOWN"] = 127] = "UNKNOWN";
     return ReqRespStatus;
@@ -12,8 +14,8 @@ export class ReqRespStatusError extends Error {
     /**
    * The status code
    */ status;
-    constructor(status){
-        super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`);
+    constructor(status, cause){
+        super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`, cause);
         this.status = status;
     }
 }
@@ -48,6 +50,8 @@ export class ReqRespStatusError extends Error {
             return 'BADLY_FORMED_REQUEST';
         case 126:
             return 'FAILURE';
+        case 3:
+            return 'INTERNAL_ERROR';
         case 127:
             return 'UNKNOWN';
     }