@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.5476d83

package/dest/services/reqresp/reqresp.js

@@ -5,16 +5,19 @@ function _ts_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 { compactArray } from '@aztec/foundation/collection';
+import { AbortError, TimeoutError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { executeTimeout } from '@aztec/foundation/timer';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { pipe } from 'it-pipe';
+import { 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_REQRESP_DIAL_TIMEOUT_MS } from './config.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 { ConnectionSampler, RandomSampler } from './connection-sampler/connection_sampler.js';
+import { 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';
@@ -35,43 +38,58 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
     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 )
+    dialTimeoutMs;
     subProtocolHandlers;
     subProtocolValidators;
     connectionSampler;
     rateLimiter;
     snappyTransform;
     metrics;
-    constructor(config, libp2p, peerScoring, telemetryClient = getTelemetryClient()){
+    constructor(config, libp2p, peerScoring, logger = createLogger('p2p:reqresp'), rateLimits = {}, 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);
+        this.logger = logger;
+        this.individualRequestTimeoutMs = DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS;
+        this.dialTimeoutMs = DEFAULT_REQRESP_DIAL_TIMEOUT_MS;
+        this.subProtocolHandlers = {};
+        this.subProtocolValidators = {};
+        this.updateConfig(config);
+        this.rateLimiter = new RequestResponseRateLimiter(peerScoring, rateLimits);
         // Connection sampler is used to sample our connected peers
-        this.connectionSampler = new ConnectionSampler(libp2p);
+        this.connectionSampler = new ConnectionSampler(libp2p, new RandomSampler(), createLogger(`${logger.module}:connection-sampler`), config);
         this.snappyTransform = new SnappyTransform();
         this.metrics = new ReqRespMetrics(telemetryClient);
     }
+    updateConfig(config) {
+        if (typeof config.individualRequestTimeoutMs === 'number') {
+            this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
+        }
+        if (typeof config.dialTimeoutMs === 'number') {
+            this.dialTimeoutMs = config.dialTimeoutMs;
+        }
+    }
     get tracer() {
         return this.metrics.tracer;
     }
     /**
    * Start the reqresp service
    */ async start(subProtocolHandlers, subProtocolValidators) {
-        this.subProtocolHandlers = subProtocolHandlers;
-        this.subProtocolValidators = subProtocolValidators;
+        Object.assign(this.subProtocolHandlers, subProtocolHandlers);
+        Object.assign(this.subProtocolValidators, subProtocolValidators);
         // Register all protocol handlers
-        for (const subProtocol of Object.keys(this.subProtocolHandlers)){
+        for (const subProtocol of Object.keys(subProtocolHandlers)){
+            this.logger.debug(`Registering handler for sub protocol ${subProtocol}`);
             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();
     }
+    async addSubProtocol(subProtocol, handler, validator = DEFAULT_SUB_PROTOCOL_VALIDATORS[subProtocol]) {
+        this.subProtocolHandlers[subProtocol] = handler;
+        this.subProtocolValidators[subProtocol] = validator;
+        this.logger.debug(`Registering handler for sub protocol ${subProtocol}`);
+        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() {
@@ -90,81 +108,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 ()=>{
-            // 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++){
-                // 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;
-                }
-            }
-        };
-        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
@@ -185,17 +128,19 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
    * @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];
+   */ async sendBatchRequest(subProtocol, requests, pinnedPeer, timeoutMs = 10000, maxPeers = Math.max(10, Math.ceil(requests.length / 3)), maxRetryAttempts = 3) {
+        const responseValidator = this.subProtocolValidators[subProtocol] ?? DEFAULT_SUB_PROTOCOL_VALIDATORS[subProtocol];
         const responses = new Array(requests.length);
         const requestBuffers = requests.map((req)=>req.toBuffer());
-        const requestFunction = async ()=>{
+        const requestFunction = async (signal)=>{
             // 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');
+            const batchSampler = new BatchConnectionSampler(this.connectionSampler, requests.length, maxPeers, compactArray([
+                pinnedPeer
+            ]), createLogger(`${this.logger.module}:batch-connection-sampler`));
+            if (batchSampler.activePeerCount === 0 && !pinnedPeer) {
+                this.logger.warn('No active peers to send requests to');
                 return [];
             }
             // This is where it gets fun
@@ -206,7 +151,9 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
             // 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
+                if (signal.aborted) {
+                    throw new AbortError('Batch request aborted');
+                }
                 const requestBatches = new Map();
                 // Group requests by peer
                 for (const requestIndex of pendingRequestIndices){
@@ -214,10 +161,23 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
                     if (!peer) {
                         break;
                     }
-                    if (!requestBatches.has(peer)) {
-                        requestBatches.set(peer, []);
+                    const peerAsString = peer.toString();
+                    if (!requestBatches.has(peerAsString)) {
+                        requestBatches.set(peerAsString, {
+                            peerId: peer,
+                            indices: []
+                        });
                     }
-                    requestBatches.get(peer).push(requestIndex);
+                    requestBatches.get(peerAsString).indices.push(requestIndex);
+                }
+                // If there is a pinned peer, we will always send every request to that peer
+                // We use the default limits for the subprotocol to avoid hitting the rate limiter
+                if (pinnedPeer) {
+                    const limit = this.rateLimiter.getRateLimits(subProtocol).peerLimit.quotaCount;
+                    requestBatches.set(pinnedPeer.toString(), {
+                        peerId: pinnedPeer,
+                        indices: Array.from(pendingRequestIndices.values()).slice(0, limit)
+                    });
                 }
                 // Make parallel requests for each peer's batch
                 // A batch entry will look something like this:
@@ -225,15 +185,16 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
                 // 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])=>{
+                const batchResults = await Promise.all(Array.from(requestBatches.entries()).map(async ([peerAsString, { peerId: peer, indices }])=>{
                     try {
                         // Requests all going to the same peer are sent synchronously
                         const peerResults = [];
                         for (const index of indices){
+                            this.logger.trace(`Sending request ${index} to peer ${peerAsString}`);
                             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 (response.status !== ReqRespStatus.SUCCESS) {
+                                this.logger.debug(`Request to peer ${peerAsString} failed with status ${prettyPrintReqRespStatus(response.status)}`);
                                 // If we hit a rate limit or some failure, we remove the peer and return the results,
                                 // they will be split among remaining peers and the new sampled peer
                                 batchSampler.removePeerAndReplace(peer);
@@ -243,7 +204,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({
@@ -258,7 +219,7 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
                             results: peerResults
                         };
                     } catch (error) {
-                        this.logger.debug(`Failed batch request to peer ${peer.toString()}:`, error);
+                        this.logger.debug(`Failed batch request to peer ${peerAsString}:`, error);
                         batchSampler.removePeerAndReplace(peer);
                         return {
                             peer,
@@ -299,6 +260,7 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
    * @param peerId - The peer to send the request to
    * @param subProtocol - The protocol to use to request
    * @param payload - The payload to send
+   * @param dialTimeout - If establishing a stream takes longer than this an error will be thrown
    * @returns If the request is successful, the response is returned, otherwise undefined
    *
    * @description
@@ -312,24 +274,46 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
    *
    * 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) {
+   */ async sendRequestToPeer(peerId, subProtocol, payload, dialTimeout = this.dialTimeoutMs) {
         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;
+            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}`);
+            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
+            };
         } 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 {
-                    await this.connectionSampler.close(stream.id);
+                    this.logger.trace(`Closing stream ${stream.id} for request to peer ${peerId.toString()} on sub protocol ${subProtocol}`);
+                    await this.connectionSampler.close(stream);
                 } catch (closeError) {
                     this.logger.error(`Error closing stream: ${closeError instanceof Error ? closeError.message : 'Unknown error'}`);
                 }
@@ -346,75 +330,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) {
-        // 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;
+        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);
+            const message = this.snappyTransform.inboundTransformData(messageData);
             return {
-                status: statusBuffer ?? ReqRespStatus.UNKNOWN,
+                status: status ?? ReqRespStatus.UNKNOWN,
                 data: message
             };
         } catch (e) {
@@ -424,8 +374,7 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
                 status = e.status;
             }
             return {
-                status,
-                data: Buffer.from([])
+                status
             };
         }
     }
@@ -433,7 +382,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
@@ -444,56 +394,197 @@ 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) {
-                this.logger.warn(`Rate limit exceeded ${prettyPrintRateLimitStatus(rateLimitStatus)} for ${protocol} from ${connection.remotePeer}`);
+            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) {
-                        // Don't respond
-                        await stream.close();
-                        return;
-                    }
-                    // Send success code first, then the response
-                    const successChunk = Buffer.from([
-                        ReqRespStatus.SUCCESS
-                    ]);
-                    yield new Uint8Array(successChunk);
-                    yield new Uint8Array(transform.outboundTransformNoTopic(response));
-                }
-            }, stream);
-        } catch (e) {
-            this.logger.warn('Reqresp Response error: ', e);
+            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;
+            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,
+                    errorStatus: err.status,
+                    cause: err.cause ?? 'Cause unknown'
+                });
+            } 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
+                });
+                stream.abort(err);
             }
-            const sendErrorChunk = this.sendErrorChunk(errorStatus);
-            // Return and yield the response chunk
-            await pipe(stream, async function*(_source) {
-                yield* sendErrorChunk;
-            }, stream);
         } 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];
+        if (!handler) {
+            throw new Error(`No handler defined for reqresp subprotocol ${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.outboundTransformData(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([