@aztec/p2p 0.67.1 → 0.68.1

package/src/{service → services/peer-scoring}/peer_scoring.ts

@@ -1,31 +1,24 @@
+import { PeerErrorSeverity } from '@aztec/circuit-types';
 import { median } from '@aztec/foundation/collection';
 
-import { type P2PConfig } from '../config.js';
-
-export enum PeerErrorSeverity {
-  /**
-   * Not malicious action, but it must not be tolerated
-   * ~2 occurrences will get the peer banned
-   */
-  LowToleranceError = 'LowToleranceError',
-  /**
-   * Negative action that can be tolerated only sometimes
-   * ~10 occurrences will get the peer banned
-   */
-  MidToleranceError = 'MidToleranceError',
-  /**
-   * Some error that can be tolerated multiple times
-   * ~50 occurrences will get the peer banned
-   */
-  HighToleranceError = 'HighToleranceError',
-}
+import { type P2PConfig } from '../../config.js';
 
 const DefaultPeerPenalties = {
-  [PeerErrorSeverity.LowToleranceError]: 2,
+  [PeerErrorSeverity.LowToleranceError]: 50,
   [PeerErrorSeverity.MidToleranceError]: 10,
-  [PeerErrorSeverity.HighToleranceError]: 50,
+  [PeerErrorSeverity.HighToleranceError]: 2,
 };
 
+export enum PeerScoreState {
+  Banned,
+  Disconnect,
+  Healthy,
+}
+
+// TODO: move into config / constants
+const MIN_SCORE_BEFORE_BAN = -100;
+const MIN_SCORE_BEFORE_DISCONNECT = -50;
+
 export class PeerScoring {
   private scores: Map<string, number> = new Map();
   private lastUpdateTime: Map<string, number> = new Map();
@@ -37,11 +30,11 @@ export class PeerScoring {
     const orderedValues = config.peerPenaltyValues?.sort((a, b) => a - b);
     this.peerPenalties = {
       [PeerErrorSeverity.HighToleranceError]:
-        orderedValues?.[0] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError],
+        orderedValues?.[0] ?? DefaultPeerPenalties[PeerErrorSeverity.HighToleranceError],
       [PeerErrorSeverity.MidToleranceError]:
         orderedValues?.[1] ?? DefaultPeerPenalties[PeerErrorSeverity.MidToleranceError],
       [PeerErrorSeverity.LowToleranceError]:
-        orderedValues?.[2] ?? DefaultPeerPenalties[PeerErrorSeverity.HighToleranceError],
+        orderedValues?.[2] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError],
     };
   }
 
@@ -82,6 +75,17 @@ export class PeerScoring {
     return this.scores.get(peerId) || 0;
   }
 
+  getScoreState(peerId: string) {
+    // TODO: permanently store banned peers???
+    const score = this.getScore(peerId);
+    if (score < MIN_SCORE_BEFORE_BAN) {
+      return PeerScoreState.Banned;
+    } else if (score < MIN_SCORE_BEFORE_DISCONNECT) {
+      return PeerScoreState.Disconnect;
+    }
+    return PeerScoreState.Healthy;
+  }
+
   getStats(): { medianScore: number } {
     return { medianScore: median(Array.from(this.scores.values())) ?? 0 };
   }

package/src/services/peer_manager.ts

@@ -0,0 +1,422 @@
+import { type PeerErrorSeverity, type PeerInfo } from '@aztec/circuit-types';
+import { createLogger } from '@aztec/foundation/log';
+import { type TelemetryClient, WithTracer, trackSpan } from '@aztec/telemetry-client';
+
+import { type ENR } from '@chainsafe/enr';
+import { type Connection, type PeerId } from '@libp2p/interface';
+import { type Multiaddr } from '@multiformats/multiaddr';
+import { inspect } from 'util';
+
+import { type P2PConfig } from '../config.js';
+import { type PubSubLibp2p } from '../util.js';
+import { PeerScoreState, PeerScoring } from './peer-scoring/peer_scoring.js';
+import { type PeerDiscoveryService } from './service.js';
+import { PeerEvent } from './types.js';
+
+const MAX_DIAL_ATTEMPTS = 3;
+const MAX_CACHED_PEERS = 100;
+const MAX_CACHED_PEER_AGE_MS = 5 * 60 * 1000; // 5 minutes
+const FAILED_PEER_BAN_TIME_MS = 5 * 60 * 1000; // 5 minutes timeout after failing MAX_DIAL_ATTEMPTS
+
+type CachedPeer = {
+  peerId: PeerId;
+  enr: ENR;
+  multiaddrTcp: Multiaddr;
+  dialAttempts: number;
+  addedUnixMs: number;
+};
+
+type TimedOutPeer = {
+  peerId: string;
+  timeoutUntilMs: number;
+};
+
+export class PeerManager extends WithTracer {
+  private cachedPeers: Map<string, CachedPeer> = new Map();
+  private peerScoring: PeerScoring;
+  private heartbeatCounter: number = 0;
+  private displayPeerCountsPeerHeartbeat: number = 0;
+  private timedOutPeers: Map<string, TimedOutPeer> = new Map();
+
+  constructor(
+    private libP2PNode: PubSubLibp2p,
+    private peerDiscoveryService: PeerDiscoveryService,
+    private config: P2PConfig,
+    telemetryClient: TelemetryClient,
+    private logger = createLogger('p2p:peer-manager'),
+  ) {
+    super(telemetryClient, 'PeerManager');
+
+    this.peerScoring = new PeerScoring(config);
+    // Handle new established connections
+    this.libP2PNode.addEventListener(PeerEvent.CONNECTED, this.handleConnectedPeerEvent.bind(this));
+    // Handle lost connections
+    this.libP2PNode.addEventListener(PeerEvent.DISCONNECTED, this.handleDisconnectedPeerEvent.bind(this));
+
+    // Handle Discovered peers
+    this.peerDiscoveryService.on(PeerEvent.DISCOVERED, this.handleDiscoveredPeer.bind(this));
+
+    // Display peer counts every 60 seconds
+    this.displayPeerCountsPeerHeartbeat = Math.floor(60_000 / this.config.peerCheckIntervalMS);
+  }
+
+  @trackSpan('PeerManager.heartbeat')
+  public heartbeat() {
+    this.heartbeatCounter++;
+    this.peerScoring.decayAllScores();
+
+    this.cleanupExpiredTimeouts();
+
+    this.discover();
+  }
+
+  /**
+   * Cleans up expired timeouts.
+   *
+   * When peers fail to dial after a number of retries, they are temporarily timed out.
+   * This function removes any peers that have been in the timed out state for too long.
+   * To give them a chance to reconnect.
+   */
+  private cleanupExpiredTimeouts() {
+    // Clean up expired timeouts
+    const now = Date.now();
+    for (const [peerId, timedOutPeer] of this.timedOutPeers.entries()) {
+      if (now >= timedOutPeer.timeoutUntilMs) {
+        this.timedOutPeers.delete(peerId);
+      }
+    }
+  }
+
+  /**
+   * Simply logs the type of connected peer.
+   * @param e - The connected peer event.
+   */
+  private handleConnectedPeerEvent(e: CustomEvent<PeerId>) {
+    const peerId = e.detail;
+    if (this.peerDiscoveryService.isBootstrapPeer(peerId)) {
+      this.logger.verbose(`Connected to bootstrap peer ${peerId.toString()}`);
+    } else {
+      this.logger.verbose(`Connected to transaction peer ${peerId.toString()}`);
+    }
+  }
+
+  /**
+   * Simply logs the type of disconnected peer.
+   * @param e - The disconnected peer event.
+   */
+  private handleDisconnectedPeerEvent(e: CustomEvent<PeerId>) {
+    const peerId = e.detail;
+    if (this.peerDiscoveryService.isBootstrapPeer(peerId)) {
+      this.logger.verbose(`Disconnected from bootstrap peer ${peerId.toString()}`);
+    } else {
+      this.logger.verbose(`Disconnected from transaction peer ${peerId.toString()}`);
+    }
+  }
+
+  public penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity) {
+    const id = peerId.toString();
+    const penaltyValue = this.peerScoring.peerPenalties[penalty];
+    const newScore = this.peerScoring.updateScore(id, -penaltyValue);
+    this.logger.verbose(`Penalizing peer ${id} with ${penalty} (new score is ${newScore})`);
+  }
+
+  public getPeerScore(peerId: string): number {
+    return this.peerScoring.getScore(peerId);
+  }
+
+  public getPeers(includePending = false): PeerInfo[] {
+    const connected = this.libP2PNode
+      .getPeers()
+      .map(peer => ({ id: peer.toString(), score: this.getPeerScore(peer.toString()), status: 'connected' as const }));
+
+    if (!includePending) {
+      return connected;
+    }
+
+    const dialQueue = this.libP2PNode
+      .getDialQueue()
+      .filter(peer => !!peer.peerId)
+      .map(peer => ({
+        id: peer.peerId!.toString(),
+        status: 'dialing' as const,
+        dialStatus: peer.status,
+        addresses: peer.multiaddrs.map(m => m.toString()),
+      }));
+
+    const cachedPeers = Array.from(this.cachedPeers.values())
+      .filter(peer => !dialQueue.some(dialPeer => dialPeer.id && peer.peerId.toString() === dialPeer.id.toString()))
+      .filter(peer => !connected.some(connPeer => connPeer.id.toString() === peer.peerId.toString()))
+      .map(peer => ({
+        status: 'cached' as const,
+        id: peer.peerId.toString(),
+        addresses: [peer.multiaddrTcp.toString()],
+        dialAttempts: peer.dialAttempts,
+        enr: peer.enr.encodeTxt(),
+      }));
+
+    return [...connected, ...dialQueue, ...cachedPeers];
+  }
+
+  /**
+   * Discovers peers.
+   */
+  private discover() {
+    const connections = this.libP2PNode.getConnections();
+
+    const healthyConnections = this.pruneUnhealthyPeers(connections);
+
+    // Calculate how many connections we're looking to make
+    const peersToConnect = this.config.maxPeerCount - healthyConnections.length;
+
+    const logLevel = this.heartbeatCounter % this.displayPeerCountsPeerHeartbeat === 0 ? 'info' : 'debug';
+    this.logger[logLevel](`Connected to ${connections.length} peers`, {
+      connections: connections.length,
+      maxPeerCount: this.config.maxPeerCount,
+      cachedPeers: this.cachedPeers.size,
+      ...this.peerScoring.getStats(),
+    });
+
+    // Exit if no peers to connect
+    if (peersToConnect <= 0) {
+      return;
+    }
+
+    const cachedPeersToDial: CachedPeer[] = [];
+
+    const pendingDials = new Set(
+      this.libP2PNode
+        .getDialQueue()
+        .map(pendingDial => pendingDial.peerId?.toString())
+        .filter(Boolean) as string[],
+    );
+
+    for (const [id, peerData] of this.cachedPeers.entries()) {
+      // if already dialling or connected to, remove from cache
+      if (
+        pendingDials.has(id) ||
+        healthyConnections.some(conn => conn.remotePeer.equals(peerData.peerId)) ||
+        // if peer has been in cache for the max cache age, remove from cache
+        Date.now() - peerData.addedUnixMs > MAX_CACHED_PEER_AGE_MS
+      ) {
+        this.cachedPeers.delete(id);
+      } else {
+        // cachedPeersToDial.set(id, enr);
+        cachedPeersToDial.push(peerData);
+      }
+    }
+
+    // reverse to dial older entries first
+    cachedPeersToDial.reverse();
+
+    for (const peer of cachedPeersToDial) {
+      // We remove from the cache before, as dialling will add it back if it fails
+      this.cachedPeers.delete(peer.peerId.toString());
+      void this.dialPeer(peer);
+    }
+
+    // if we need more peers, start randomNodesQuery
+    if (peersToConnect > 0) {
+      this.logger.trace(`Running random nodes query to connect to ${peersToConnect} peers`);
+      void this.peerDiscoveryService.runRandomNodesQuery();
+    }
+  }
+
+  private pruneUnhealthyPeers(connections: Connection[]): Connection[] {
+    const connectedHealthyPeers: Connection[] = [];
+
+    for (const peer of connections) {
+      const score = this.peerScoring.getScoreState(peer.remotePeer.toString());
+      switch (score) {
+        // TODO: add goodbye and give reasons
+        case PeerScoreState.Banned:
+        case PeerScoreState.Disconnect:
+          void this.disconnectPeer(peer.remotePeer);
+          break;
+        case PeerScoreState.Healthy:
+          connectedHealthyPeers.push(peer);
+      }
+    }
+
+    return connectedHealthyPeers;
+  }
+
+  // TODO: send a goodbye with a reason to the peer
+  private async disconnectPeer(peer: PeerId) {
+    this.logger.debug(`Disconnecting peer ${peer.toString()}`);
+    await this.libP2PNode.hangUp(peer);
+  }
+
+  /**
+   *  Handles a discovered peer.
+   * @param enr - The discovered peer's ENR.
+   */
+  private async handleDiscoveredPeer(enr: ENR) {
+    // Check that the peer has not already been banned
+    const peerId = await enr.peerId();
+    const peerIdString = peerId.toString();
+
+    // Check if peer is temporarily timed out
+    const timedOutPeer = this.timedOutPeers.get(peerIdString);
+    if (timedOutPeer) {
+      if (Date.now() < timedOutPeer.timeoutUntilMs) {
+        this.logger.trace(`Skipping timed out peer ${peerId}`);
+        return;
+      }
+      // Timeout period expired, remove from timed out peers
+      this.timedOutPeers.delete(peerIdString);
+    }
+
+    if (this.peerScoring.getScoreState(peerIdString) != PeerScoreState.Healthy) {
+      return;
+    }
+
+    const [multiaddrTcp] = await Promise.all([enr.getFullMultiaddr('tcp')]);
+
+    this.logger.trace(`Handling discovered peer ${peerId} at ${multiaddrTcp?.toString() ?? 'undefined address'}`);
+
+    // stop if no tcp addr in multiaddr
+    if (!multiaddrTcp) {
+      this.logger.debug(`No TCP address in discovered node's multiaddr ${enr.encodeTxt()}`);
+      return;
+    }
+    // check if peer is already connected
+    const connections = this.libP2PNode.getConnections();
+    if (connections.some(conn => conn.remotePeer.equals(peerId))) {
+      this.logger.trace(`Already connected to peer ${peerId}`);
+      return;
+    }
+
+    // check if peer is already in cache
+    if (this.cachedPeers.has(peerIdString)) {
+      this.logger.trace(`Peer already in cache ${peerIdString}`);
+      return;
+    }
+
+    // create cached peer object
+    const cachedPeer: CachedPeer = {
+      peerId,
+      enr,
+      multiaddrTcp,
+      dialAttempts: 0,
+      addedUnixMs: Date.now(),
+    };
+
+    // Determine if we should dial immediately or not
+    if (this.shouldDialPeer()) {
+      void this.dialPeer(cachedPeer);
+    } else {
+      this.logger.trace(`Caching peer ${peerIdString}`);
+      this.cachedPeers.set(peerIdString, cachedPeer);
+      // Prune set of cached peers
+      this.pruneCachedPeers();
+    }
+  }
+
+  private async dialPeer(peer: CachedPeer) {
+    const id = peer.peerId.toString();
+
+    // Add to the address book before dialing
+    await this.libP2PNode.peerStore.merge(peer.peerId, { multiaddrs: [peer.multiaddrTcp] });
+
+    this.logger.trace(`Dialing peer ${id}`);
+    try {
+      await this.libP2PNode.dial(peer.multiaddrTcp);
+    } catch (error) {
+      peer.dialAttempts++;
+      if (peer.dialAttempts < MAX_DIAL_ATTEMPTS) {
+        this.logger.trace(`Failed to dial peer ${id} (attempt ${peer.dialAttempts})`, { error: inspect(error) });
+        this.cachedPeers.set(id, peer);
+      } else {
+        formatLibp2pDialError(error as Error);
+        this.logger.debug(`Failed to dial peer ${id} (dropping)`, { error: inspect(error) });
+        this.cachedPeers.delete(id);
+        // Add to timed out peers
+        this.timedOutPeers.set(id, {
+          peerId: id,
+          timeoutUntilMs: Date.now() + FAILED_PEER_BAN_TIME_MS,
+        });
+      }
+    }
+  }
+
+  private shouldDialPeer(): boolean {
+    const connections = this.libP2PNode.getConnections().length;
+    if (connections >= this.config.maxPeerCount) {
+      this.logger.trace(
+        `Not dialing peer due to max peer count of ${this.config.maxPeerCount} reached (${connections} current connections)`,
+      );
+      return false;
+    }
+    return true;
+  }
+
+  private pruneCachedPeers() {
+    let peersToDelete = this.cachedPeers.size - MAX_CACHED_PEERS;
+    if (peersToDelete <= 0) {
+      return;
+    }
+
+    // Remove the oldest peers
+    for (const key of this.cachedPeers.keys()) {
+      this.cachedPeers.delete(key);
+      this.logger.trace(`Pruning peer ${key} from cache`);
+      peersToDelete--;
+      if (peersToDelete <= 0) {
+        break;
+      }
+    }
+  }
+
+  /**
+   * Stops the peer manager.
+   * Removing all event listeners.
+   */
+  public stop() {
+    this.libP2PNode.removeEventListener(PeerEvent.CONNECTED, this.handleConnectedPeerEvent);
+    this.libP2PNode.removeEventListener(PeerEvent.DISCONNECTED, this.handleDisconnectedPeerEvent);
+    this.peerDiscoveryService.off(PeerEvent.DISCOVERED, this.handleDiscoveredPeer);
+  }
+}
+
+/**
+ * copied from github.com/ChainSafe/lodestar
+ * libp2p errors with extremely noisy errors here, which are deeply nested taking 30-50 lines.
+ * Some known errors:
+ * ```
+ * Error: The operation was aborted
+ * Error: stream ended before 1 bytes became available
+ * Error: Error occurred during XX handshake: Error occurred while verifying signed payload: Peer ID doesn't match libp2p public key
+ * ```
+ *
+ * Also the error's message is not properly formatted, where the error message is indented and includes the full stack
+ * ```
+ * {
+ *  emessage: '\n' +
+ *    '    Error: stream ended before 1 bytes became available\n' +
+ *    '        at /home/lion/Code/eth2.0/lodestar/node_modules/it-reader/index.js:37:9\n' +
+ *    '        at runMicrotasks (<anonymous>)\n' +
+ *    '        at decoder (/home/lion/Code/eth2.0/lodestar/node_modules/it-length-prefixed/src/decode.js:113:22)\n' +
+ *    '        at first (/home/lion/Code/eth2.0/lodestar/node_modules/it-first/index.js:11:20)\n' +
+ *    '        at Object.exports.read (/home/lion/Code/eth2.0/lodestar/node_modules/multistream-select/src/multistream.js:31:15)\n' +
+ *    '        at module.exports (/home/lion/Code/eth2.0/lodestar/node_modules/multistream-select/src/select.js:21:19)\n' +
+ *    '        at Upgrader._encryptOutbound (/home/lion/Code/eth2.0/lodestar/node_modules/libp2p/src/upgrader.js:397:36)\n' +
+ *    '        at Upgrader.upgradeOutbound (/home/lion/Code/eth2.0/lodestar/node_modules/libp2p/src/upgrader.js:176:11)\n' +
+ *    '        at ClassIsWrapper.dial (/home/lion/Code/eth2.0/lodestar/node_modules/libp2p-tcp/src/index.js:49:18)'
+ * }
+ * ```
+ *
+ * Tracking issue https://github.com/libp2p/js-libp2p/issues/996
+ */
+function formatLibp2pDialError(e: Error): void {
+  const errorMessage = e.message.trim();
+  const newlineIndex = errorMessage.indexOf('\n');
+  e.message = newlineIndex !== -1 ? errorMessage.slice(0, newlineIndex) : errorMessage;
+
+  if (
+    e.message.includes('The operation was aborted') ||
+    e.message.includes('stream ended before 1 bytes became available') ||
+    e.message.includes('The operation was aborted')
+  ) {
+    e.stack = undefined;
+  }
+}

package/src/{service → services}/reqresp/rate_limiter/rate_limiter.ts

@@ -3,10 +3,11 @@
  * Rationale is that if it was good enough for them, then it should be good enough for us.
  * https://github.com/ChainSafe/lodestar
  */
+import { PeerErrorSeverity } from '@aztec/circuit-types';
+
 import { type PeerId } from '@libp2p/interface';
 
 import { type PeerManager } from '../../peer_manager.js';
-import { PeerErrorSeverity } from '../../peer_scoring.js';
 import { type ReqRespSubProtocol, type ReqRespSubProtocolRateLimits } from '../interface.js';
 import { DEFAULT_RATE_LIMITS } from './rate_limits.js';
 

package/src/{service → services}/reqresp/reqresp.ts

@@ -1,16 +1,20 @@
 // @attribution: lodestar impl for inspiration
+import { PeerErrorSeverity } from '@aztec/circuit-types';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { executeTimeoutWithCustomError } from '@aztec/foundation/timer';
+import { executeTimeout } from '@aztec/foundation/timer';
 
 import { type IncomingStreamData, type PeerId, type Stream } from '@libp2p/interface';
 import { pipe } from 'it-pipe';
 import { type Libp2p } from 'libp2p';
-import { compressSync, uncompressSync } from 'snappy';
 import { type Uint8ArrayList } from 'uint8arraylist';
 
-import { CollectiveReqRespTimeoutError, IndiviualReqRespTimeoutError } from '../../errors/reqresp.error.js';
+import {
+  CollectiveReqRespTimeoutError,
+  IndividualReqRespTimeoutError,
+  InvalidResponseError,
+} from '../../errors/reqresp.error.js';
+import { SnappyTransform } from '../encoding.js';
 import { type PeerManager } from '../peer_manager.js';
-import { PeerErrorSeverity } from '../peer_scoring.js';
 import { type P2PReqRespConfig } from './config.js';
 import {
   DEFAULT_SUB_PROTOCOL_HANDLERS,
@@ -49,6 +53,8 @@ export class ReqResp {
 
   private rateLimiter: RequestResponseRateLimiter;
 
+  private snappyTransform: SnappyTransform;
+
   constructor(config: P2PReqRespConfig, protected readonly libp2p: Libp2p, private peerManager: PeerManager) {
     this.logger = createLogger('p2p:reqresp');
 
@@ -56,6 +62,7 @@ export class ReqResp {
     this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
 
     this.rateLimiter = new RequestResponseRateLimiter(peerManager);
+    this.snappyTransform = new SnappyTransform();
   }
 
   /**
@@ -143,8 +150,7 @@ export class ReqResp {
           // The response validator handles peer punishment within
           const isValid = await responseValidator(request, object, peer);
           if (!isValid) {
-            this.logger.error(`Invalid response for ${subProtocol} from ${peer.toString()}`);
-            return undefined;
+            throw new InvalidResponseError();
           }
           return object;
         }
@@ -153,13 +159,13 @@ export class ReqResp {
     };
 
     try {
-      return await executeTimeoutWithCustomError<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined>(
+      return await executeTimeout<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined>(
         requestFunction,
         this.overallRequestTimeoutMs,
         () => new CollectiveReqRespTimeoutError(),
       );
     } catch (e: any) {
-      this.logger.error(`${e.message} | subProtocol: ${subProtocol}`);
+      this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
       return undefined;
     }
   }
@@ -199,19 +205,15 @@ export class ReqResp {
       this.logger.trace(`Stream opened with ${peerId.toString()} for ${subProtocol}`);
 
       // Open the stream with a timeout
-      const result = await executeTimeoutWithCustomError<Buffer>(
-        (): Promise<Buffer> => pipe([payload], stream!, this.readMessage),
+      const result = await executeTimeout<Buffer>(
+        (): Promise<Buffer> => pipe([payload], stream!, this.readMessage.bind(this)),
         this.individualRequestTimeoutMs,
-        () => new IndiviualReqRespTimeoutError(),
+        () => new IndividualReqRespTimeoutError(),
       );
 
-      await stream.close();
-      this.logger.trace(`Stream closed with ${peerId.toString()} for ${subProtocol}`);
-
       return result;
     } catch (e: any) {
-      this.logger.error(`Error sending request to peer`, e, { peerId: peerId.toString(), subProtocol });
-      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
+      this.handleResponseError(e, peerId, subProtocol);
     } finally {
       if (stream) {
         try {
@@ -224,7 +226,70 @@ export class ReqResp {
         }
       }
     }
-    return undefined;
+  }
+
+  /**
+   * Handle a response error
+   *
+   * ReqResp errors are punished differently depending on the severity of the offense
+   *
+   * @param e - The error
+   * @param peerId - The peer id
+   * @param subProtocol - The sub protocol
+   * @returns If the error is non pubishable, then undefined is returned, otherwise the peer is penalized
+   */
+  private handleResponseError(e: any, peerId: PeerId, subProtocol: ReqRespSubProtocol): void {
+    const severity = this.categorizeError(e, peerId, subProtocol);
+    if (severity) {
+      this.peerManager.penalizePeer(peerId, severity);
+    }
+  }
+
+  /**
+   * Categorize the error and log it.
+   */
+  private categorizeError(e: any, peerId: PeerId, subProtocol: ReqRespSubProtocol): PeerErrorSeverity | undefined {
+    // Non pubishable errors
+    // We do not punish a collective timeout, as the node triggers this interupt, independent of the peer's behaviour
+    const logTags = {
+      peerId: peerId.toString(),
+      subProtocol,
+    };
+    if (e instanceof CollectiveReqRespTimeoutError || e instanceof InvalidResponseError) {
+      this.logger.debug(
+        `Non-punishable error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`,
+        logTags,
+      );
+      return undefined;
+    }
+
+    // Pubishable errors
+    // Connection reset errors in the networking stack are punished with high severity
+    // it just signals an unreliable peer
+    // We assume that the requesting node has a functioning networking stack.
+    if (e?.code === 'ECONNRESET' || e?.code === 'EPIPE') {
+      this.logger.debug(`Connection reset: ${peerId.toString()}`, logTags);
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    if (e?.code === 'ECONNREFUSED') {
+      this.logger.debug(`Connection refused: ${peerId.toString()}`, logTags);
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    // Timeout errors are punished with high tolerance, they can be due to a geogrpahically far away peer or an
+    // overloaded peer
+    if (e instanceof IndividualReqRespTimeoutError) {
+      this.logger.debug(
+        `Timeout error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`,
+        logTags,
+      );
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    // Catch all error
+    this.logger.error(`Unexpected error sending request to peer`, e, logTags);
+    return PeerErrorSeverity.HighToleranceError;
   }
 
   /**
@@ -235,8 +300,8 @@ export class ReqResp {
     for await (const chunk of source) {
       chunks.push(chunk.subarray());
     }
-    const messageData = chunks.concat();
-    return uncompressSync(Buffer.concat(messageData), { asBuffer: true }) as Buffer;
+    const messageData = Buffer.concat(chunks);
+    return this.snappyTransform.inboundTransformNoTopic(messageData);
   }
 
   /**
@@ -266,6 +331,7 @@ export class ReqResp {
     }
 
     const handler = this.subProtocolHandlers[protocol];
+    const transform = this.snappyTransform;
 
     try {
       await pipe(
@@ -274,7 +340,7 @@ export class ReqResp {
           for await (const chunkList of source) {
             const msg = Buffer.from(chunkList.subarray());
             const response = await handler(msg);
-            yield new Uint8Array(compressSync(response));
+            yield new Uint8Array(transform.outboundTransformNoTopic(response));
           }
         },
         stream,