@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/src/services/reqresp/reqresp.ts

@@ -7,9 +7,8 @@ import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import type { IncomingStreamData, PeerId, Stream } from '@libp2p/interface';
-import { abortableDuplex, abortableSink } from 'abortable-iterator';
-import { pipe } from 'it-pipe';
 import type { Libp2p } from 'libp2p';
+import { pipeline } from 'node:stream/promises';
 import type { Uint8ArrayList } from 'uint8arraylist';
 
 import {
@@ -21,7 +20,6 @@ import { SnappyTransform } from '../encoding.js';
 import type { PeerScoring } from '../peer-manager/peer_scoring.js';
 import {
   DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS,
-  DEFAULT_OVERALL_REQUEST_TIMEOUT_MS,
   DEFAULT_REQRESP_DIAL_TIMEOUT_MS,
   type P2PReqRespConfig,
 } from './config.js';
@@ -33,11 +31,12 @@ import {
   type ReqRespInterface,
   type ReqRespResponse,
   ReqRespSubProtocol,
+  type ReqRespSubProtocolHandler,
   type ReqRespSubProtocolHandlers,
   type ReqRespSubProtocolRateLimits,
   type ReqRespSubProtocolValidators,
   type SubProtocolMap,
-  subProtocolMap,
+  responseFromBuffer,
 } from './interface.js';
 import { ReqRespMetrics } from './metrics.js';
 import {
@@ -62,7 +61,6 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
  * see: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#the-reqresp-domain
  */
 export class ReqResp implements ReqRespInterface {
-  private overallRequestTimeoutMs: number = DEFAULT_OVERALL_REQUEST_TIMEOUT_MS;
   private individualRequestTimeoutMs: number = DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS;
   private dialTimeoutMs: number = DEFAULT_REQRESP_DIAL_TIMEOUT_MS;
 
@@ -102,10 +100,6 @@ export class ReqResp implements ReqRespInterface {
   }
 
   public updateConfig(config: Partial<P2PReqRespConfig>): void {
-    if (typeof config.overallRequestTimeoutMs === 'number') {
-      this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
-    }
-
     if (typeof config.individualRequestTimeoutMs === 'number') {
       this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
     }
@@ -139,6 +133,22 @@ export class ReqResp implements ReqRespInterface {
     this.rateLimiter.start();
   }
 
+  async addSubProtocol(
+    subProtocol: ReqRespSubProtocol,
+    handler: ReqRespSubProtocolHandler,
+    validator: ReqRespSubProtocolValidators[ReqRespSubProtocol] = DEFAULT_SUB_PROTOCOL_VALIDATORS[subProtocol],
+  ): Promise<void> {
+    this.subProtocolHandlers[subProtocol] = handler;
+    this.subProtocolValidators[subProtocol] = validator;
+    await this.libp2p.handle(
+      subProtocol,
+      (data: IncomingStreamData) =>
+        void this.streamHandler(subProtocol as ReqRespSubProtocol, data).catch(err =>
+          this.logger.error(`Error on libp2p subprotocol ${subProtocol} handler`, err),
+        ),
+    );
+  }
+
   /**
    * Stop the reqresp service
    */
@@ -162,103 +172,6 @@ export class ReqResp implements ReqRespInterface {
     // 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 extends ReqRespSubProtocol>(
-    subProtocol: SubProtocol,
-    request: InstanceType<SubProtocolMap[SubProtocol]['request']>,
-  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined> {
-    const responseValidator = this.subProtocolValidators[subProtocol];
-    const requestBuffer = request.toBuffer();
-
-    const requestFunction = async (signal: AbortSignal) => {
-      // 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: Map<string, boolean> = 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<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined>(
-        requestFunction,
-        this.overallRequestTimeoutMs,
-        () => new CollectiveReqRespTimeoutError(),
-      );
-    } catch (e: any) {
-      this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
-      return undefined;
-    }
-  }
-
   /**
    * Request multiple messages over the same sub protocol, balancing the requests across peers.
    *
@@ -295,9 +208,9 @@ export class ReqResp implements ReqRespInterface {
     timeoutMs = 10000,
     maxPeers = Math.max(10, Math.ceil(requests.length / 3)),
     maxRetryAttempts = 3,
-  ): Promise<(InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[]> {
+  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]> {
     const responseValidator = this.subProtocolValidators[subProtocol];
-    const responses: (InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[] = new Array(requests.length);
+    const responses: InstanceType<SubProtocolMap[SubProtocol]['response']>[] = new Array(requests.length);
     const requestBuffers = requests.map(req => req.toBuffer());
 
     const requestFunction = async (signal: AbortSignal) => {
@@ -389,7 +302,7 @@ export class ReqResp implements ReqRespInterface {
                 }
 
                 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) {
@@ -428,7 +341,7 @@ export class ReqResp implements ReqRespInterface {
     };
 
     try {
-      return await executeTimeout<(InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[]>(
+      return await executeTimeout<InstanceType<SubProtocolMap[SubProtocol]['response']>[]>(
         requestFunction,
         timeoutMs,
         () => new CollectiveReqRespTimeoutError(),
@@ -484,24 +397,34 @@ export class ReqResp implements ReqRespInterface {
         `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<ReqRespResponse>(
-        (signal): Promise<ReqRespResponse> =>
-          pipe([payload], abortableDuplex(stream!, signal), abortableSink(this.readMessage.bind(this), signal)),
+      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,
-        () => new IndividualReqRespTimeoutError(),
+        () => timeoutErr,
       );
-
-      return result;
+      return resp;
     } catch (e: any) {
+      // 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([]) };
+      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 {
           this.logger.trace(
@@ -528,80 +451,12 @@ export class ReqResp implements ReqRespInterface {
    * @returns If the error is non pubishable, then undefined is returned, otherwise the peer is penalized
    */
   private handleResponseError(e: any, peerId: PeerId, subProtocol: ReqRespSubProtocol): void {
-    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.
-   */
-  private categorizeError(e: any, peerId: PeerId, subProtocol: ReqRespSubProtocol): PeerErrorSeverity | undefined {
-    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
    *
@@ -610,16 +465,26 @@ export class ReqResp implements ReqRespInterface {
    * - The second chunk should contain the response data
    */
   private async readMessage(source: AsyncIterable<Uint8ArrayList>): Promise<ReqRespResponse> {
-    let statusBuffer: ReqRespStatus | undefined;
+    let status: ReqRespStatus | undefined;
     const chunks: Uint8Array[] = [];
 
     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,
+          };
         }
       }
 
@@ -627,7 +492,7 @@ export class ReqResp implements ReqRespInterface {
       const message: Buffer = this.snappyTransform.inboundTransformNoTopic(messageData);
 
       return {
-        status: statusBuffer ?? ReqRespStatus.UNKNOWN,
+        status: status ?? ReqRespStatus.UNKNOWN,
         data: message,
       };
     } catch (e: any) {
@@ -640,7 +505,6 @@ export class ReqResp implements ReqRespInterface {
 
       return {
         status,
-        data: Buffer.from([]),
       };
     }
   }
@@ -649,7 +513,8 @@ export class ReqResp implements ReqRespInterface {
    * 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
@@ -665,13 +530,12 @@ export class ReqResp implements ReqRespInterface {
     [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol,
     [Attributes.P2P_ID]: connection.remotePeer.toString(),
   }))
-  private async streamHandler(protocol: ReqRespSubProtocol, { stream, connection }: IncomingStreamData) {
-    this.metrics.recordRequestReceived(protocol);
-
+  private async streamHandler(protocol: ReqRespSubProtocol, incomingStream: IncomingStreamData) {
+    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
@@ -681,78 +545,244 @@ export class ReqResp implements ReqRespInterface {
         throw new ReqRespStatusError(ReqRespStatus.RATE_LIMIT_EXCEEDED);
       }
 
-      const handler = this.subProtocolHandlers[protocol];
-      const transform = this.snappyTransform;
-
-      await pipe(
-        stream,
-        async function* (source: any) {
-          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);
+      await this.processStream(protocol, incomingStream);
+    } catch (err: any) {
+      this.metrics.recordResponseError(protocol);
+      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);
+      }
+    } finally {
+      //NOTE: This is idempotent action, so it's ok to call it even if stream was aborted
+      await stream.close();
+    }
+  }
 
-            yield new Uint8Array(transform.outboundTransformNoTopic(response));
+  /**
+   * 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
+   *
+   * */
+  private async processStream(protocol: ReqRespSubProtocol, { stream, connection }: IncomingStreamData): Promise<void> {
+    const handler = this.subProtocolHandlers[protocol]!;
+    const snappy = this.snappyTransform;
+    const SUCCESS = Uint8Array.of(ReqRespStatus.SUCCESS);
+
+    await pipeline(
+      stream.source,
+      async function* (source: any) {
+        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,
-      );
+
+          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
+   *
+   */
+  private async trySendError(
+    stream: Stream,
+    peerId: PeerId,
+    protocol: ReqRespSubProtocol,
+    status: ReqRespStatus,
+  ): Promise<boolean> {
+    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: any) {
-      let level: 'warn' | 'debug' = '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);
-      this.metrics.recordResponseError(protocol);
+      this.logger.warn('Error while sending error response', e);
+      stream.abort(e);
 
-      // 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(e, peerId, protocol);
+      return false;
+    }
+  }
 
-      const canWriteToStream =
-        stream.status === 'open' && (stream.writeStatus === 'writing' || stream.writeStatus === 'ready');
-      if (!canWriteToStream) {
-        this.logger.debug('Stream already closed, not sending error response', { protocol, err: e, errorStatus });
-        return;
-      }
+  private handleRequestError(e: any, peerId: PeerId, subProtocol: ReqRespSubProtocol): void {
+    const severity = this.categorizeRequestError(e, peerId, subProtocol);
+    if (severity) {
+      this.peerScoring.penalizePeer(peerId, severity);
+    }
+  }
 
-      // Return and yield the response chunk
-      try {
-        const sendErrorChunk = this.sendErrorChunk(errorStatus);
-        await pipe(
-          stream,
-          async function* (_source: any) {
-            yield* sendErrorChunk;
-          },
-          stream,
-        );
-      } catch (e: any) {
-        this.logger.warn('Error while sending error response', { protocol, err: e, errorStatus });
-      }
-    } finally {
-      await stream.close();
+  /**
+   * Categorize the request error and log it.
+   *
+   * @returns Severity of the error, or undefined if the error is not punishable.
+   */
+  private categorizeRequestError(
+    e: any,
+    peerId: PeerId,
+    subProtocol: ReqRespSubProtocol,
+  ): PeerErrorSeverity | undefined {
+    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;
   }
 
-  private async *sendErrorChunk(error: ReqRespStatus): AsyncIterable<Uint8Array> {
-    const errorChunk = Buffer.from([error]);
-    yield new Uint8Array(errorChunk);
+  /**
+   * Categorize the response error and log it.
+   *
+   * @returns Severity of the error, or undefined if the error is not punishable.
+   */
+  private categorizeResponseError(
+    e: any,
+    peerId: PeerId,
+    subProtocol: ReqRespSubProtocol,
+  ): PeerErrorSeverity | undefined {
+    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*/
+  private categorizeConnectionErrors(
+    e: any,
+    peerId: PeerId,
+    subProtocol: ReqRespSubProtocol,
+  ): PeerErrorSeverity | undefined {
+    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;
   }
 }