@lodestar/reqresp 1.41.0-dev.a35cbde8b3 → 1.41.0-dev.aeab9f930d

package/src/encodingStrategies/sszSnappy/decode.ts

@@ -1,8 +1,9 @@
+import type {Stream} from "@libp2p/interface";
+import type {ByteStream} from "@libp2p/utils";
 import {decode as varintDecode, encodingLength as varintEncodingLength} from "uint8-varint";
 import {Uint8ArrayList} from "uint8arraylist";
 import {TypeSizes} from "../../types.js";
-import {BufferedSource} from "../../utils/index.js";
-import {SnappyFramesUncompress} from "../../utils/snappyIndex.js";
+import {ChunkType, decodeSnappyFrameData, parseSnappyFrameHeader} from "../../utils/snappyIndex.js";
 import {SszSnappyError, SszSnappyErrorCode} from "./errors.js";
 import {maxEncodedLen} from "./utils.js";
 
@@ -15,76 +16,115 @@ export const MAX_VARINT_BYTES = 10;
  * <encoding-dependent-header> | <encoded-payload>
  * ```
  */
-export async function readSszSnappyPayload(bufferedSource: BufferedSource, type: TypeSizes): Promise<Uint8Array> {
-  const sszDataLength = await readSszSnappyHeader(bufferedSource, type);
-
-  return readSszSnappyBody(bufferedSource, sszDataLength);
+export async function readSszSnappyPayload(
+  stream: ByteStream<Stream>,
+  type: TypeSizes,
+  signal?: AbortSignal
+): Promise<Uint8Array> {
+  const sszDataLength = await readSszSnappyHeader(stream, type, signal);
+
+  return readSszSnappyBody(stream, sszDataLength, signal);
 }
 
 /**
  * Reads `<encoding-dependent-header>` for ssz-snappy.
  * encoding-header ::= the length of the raw SSZ bytes, encoded as an unsigned protobuf varint
  */
-export async function readSszSnappyHeader(bufferedSource: BufferedSource, type: TypeSizes): Promise<number> {
-  for await (const buffer of bufferedSource) {
-    // Get next bytes if empty
-    if (buffer.length === 0) {
-      continue;
-    }
+export async function readSszSnappyHeader(
+  stream: ByteStream<Stream>,
+  type: TypeSizes,
+  signal?: AbortSignal
+): Promise<number> {
+  const varintBytes: number[] = [];
 
-    let sszDataLength: number;
-    try {
-      sszDataLength = varintDecode(buffer.subarray());
-    } catch (_e) {
-      throw new SszSnappyError({code: SszSnappyErrorCode.INVALID_VARINT_BYTES_COUNT, bytes: Infinity});
-    }
+  while (true) {
+    const byte = await readExactOrSourceAborted(stream, 1, signal);
 
-    // MUST validate: the unsigned protobuf varint used for the length-prefix MUST not be longer than 10 bytes
-    // encodingLength function only returns 1-8 inclusive
-    const varintBytes = varintEncodingLength(sszDataLength);
-    buffer.consume(varintBytes);
+    const value = byte.get(0);
 
-    // MUST validate: the length-prefix is within the expected size bounds derived from the payload SSZ type.
-    const minSize = type.minSize;
-    const maxSize = type.maxSize;
-    if (sszDataLength < minSize) {
-      throw new SszSnappyError({code: SszSnappyErrorCode.UNDER_SSZ_MIN_SIZE, minSize, sszDataLength});
-    }
-    if (sszDataLength > maxSize) {
-      throw new SszSnappyError({code: SszSnappyErrorCode.OVER_SSZ_MAX_SIZE, maxSize, sszDataLength});
+    varintBytes.push(value);
+    if (varintBytes.length > MAX_VARINT_BYTES) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.INVALID_VARINT_BYTES_COUNT, bytes: varintBytes.length});
     }
 
-    return sszDataLength;
+    // MSB not set => varint terminated
+    if ((value & 0x80) === 0) break;
+  }
+
+  let sszDataLength: number;
+  try {
+    sszDataLength = varintDecode(Uint8Array.from(varintBytes));
+  } catch {
+    throw new SszSnappyError({code: SszSnappyErrorCode.INVALID_VARINT_BYTES_COUNT, bytes: Infinity});
   }
 
-  throw new SszSnappyError({code: SszSnappyErrorCode.SOURCE_ABORTED});
+  // MUST validate: the unsigned protobuf varint used for the length-prefix MUST not be longer than 10 bytes
+  // encodingLength function only returns 1-8 inclusive
+  const varintByteLength = varintEncodingLength(sszDataLength);
+  if (varintByteLength > MAX_VARINT_BYTES) {
+    throw new SszSnappyError({code: SszSnappyErrorCode.INVALID_VARINT_BYTES_COUNT, bytes: varintByteLength});
+  }
+
+  // MUST validate: the length-prefix is within the expected size bounds derived from the payload SSZ type.
+  const minSize = type.minSize;
+  const maxSize = type.maxSize;
+  if (sszDataLength < minSize) {
+    throw new SszSnappyError({code: SszSnappyErrorCode.UNDER_SSZ_MIN_SIZE, minSize, sszDataLength});
+  }
+  if (sszDataLength > maxSize) {
+    throw new SszSnappyError({code: SszSnappyErrorCode.OVER_SSZ_MAX_SIZE, maxSize, sszDataLength});
+  }
+
+  return sszDataLength;
 }
 
 /**
  * Reads `<encoded-payload>` for ssz-snappy and decompress.
  * The returned bytes can be SSZ deseralized
  */
-export async function readSszSnappyBody(bufferedSource: BufferedSource, sszDataLength: number): Promise<Uint8Array> {
-  const decompressor = new SnappyFramesUncompress();
+export async function readSszSnappyBody(
+  stream: ByteStream<Stream>,
+  sszDataLength: number,
+  signal?: AbortSignal
+): Promise<Uint8Array> {
   const uncompressedData = new Uint8ArrayList();
-  let readBytes = 0;
+  let encodedBytesRead = 0;
+  const maxBytes = maxEncodedLen(sszDataLength);
+  let foundIdentifier = false;
+
+  while (uncompressedData.length < sszDataLength) {
+    const header = await readExactOrSourceAborted(stream, 4, signal);
 
-  for await (const buffer of bufferedSource) {
     // SHOULD NOT read more than max_encoded_len(n) bytes after reading the SSZ length-prefix n from the header
-    readBytes += buffer.length;
-    if (readBytes > maxEncodedLen(sszDataLength)) {
-      throw new SszSnappyError({code: SszSnappyErrorCode.TOO_MUCH_BYTES_READ, readBytes, sszDataLength});
+    encodedBytesRead = addEncodedBytesReadOrThrow(encodedBytesRead, header.length, maxBytes, sszDataLength);
+
+    let headerParsed: {type: ChunkType; frameSize: number};
+    try {
+      headerParsed = parseSnappyFrameHeader(header.subarray());
+      if (!foundIdentifier && headerParsed.type !== ChunkType.IDENTIFIER) {
+        throw new Error("malformed input: must begin with an identifier");
+      }
+    } catch (e) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.DECOMPRESSOR_ERROR, decompressorError: e as Error});
     }
 
-    // No bytes left to consume, get next
-    if (buffer.length === 0) {
-      continue;
+    if (headerParsed.frameSize > maxBytes - encodedBytesRead) {
+      throw new SszSnappyError({
+        code: SszSnappyErrorCode.TOO_MUCH_BYTES_READ,
+        readBytes: encodedBytesRead + headerParsed.frameSize,
+        sszDataLength,
+      });
     }
+    const frame = await readExactOrSourceAborted(stream, headerParsed.frameSize, signal);
+
+    encodedBytesRead = addEncodedBytesReadOrThrow(encodedBytesRead, frame.length, maxBytes, sszDataLength);
 
-    // stream contents can be passed through a buffered Snappy reader to decompress frame by frame
     try {
-      const uncompressed = decompressor.uncompress(buffer);
-      buffer.consume(buffer.length);
+      if (headerParsed.type === ChunkType.IDENTIFIER) {
+        foundIdentifier = true;
+      }
+
+      const uncompressed = decodeSnappyFrameData(headerParsed.type, frame.subarray());
       if (uncompressed !== null) {
         uncompressedData.append(uncompressed);
       }
@@ -96,16 +136,34 @@ export async function readSszSnappyBody(bufferedSource: BufferedSource, sszDataL
     if (uncompressedData.length > sszDataLength) {
       throw new SszSnappyError({code: SszSnappyErrorCode.TOO_MANY_BYTES, sszDataLength});
     }
+  }
 
-    // Keep reading chunks until `n` SSZ bytes
-    if (uncompressedData.length < sszDataLength) {
-      continue;
-    }
+  // buffer.length === n
+  return uncompressedData.subarray(0, sszDataLength);
+}
 
-    // buffer.length === n
-    return uncompressedData.subarray(0, sszDataLength);
+function addEncodedBytesReadOrThrow(
+  encodedBytesRead: number,
+  bytesToAdd: number,
+  maxBytes: number,
+  sszDataLength: number
+): number {
+  const nextReadBytes = encodedBytesRead + bytesToAdd;
+  if (nextReadBytes > maxBytes) {
+    throw new SszSnappyError({code: SszSnappyErrorCode.TOO_MUCH_BYTES_READ, readBytes: nextReadBytes, sszDataLength});
   }
+  return nextReadBytes;
+}
 
-  // SHOULD consider invalid: An early EOF before fully reading the declared length-prefix worth of SSZ bytes
-  throw new SszSnappyError({code: SszSnappyErrorCode.SOURCE_ABORTED});
+async function readExactOrSourceAborted(
+  stream: ByteStream<Stream>,
+  bytes: number,
+  signal?: AbortSignal
+): Promise<Uint8ArrayList> {
+  return stream.read({bytes, signal}).catch((e) => {
+    if ((e as Error).name === "UnexpectedEOFError") {
+      throw new SszSnappyError({code: SszSnappyErrorCode.SOURCE_ABORTED});
+    }
+    throw e;
+  });
 }

package/src/encodingStrategies/sszSnappy/encode.ts

@@ -8,12 +8,12 @@ import {encodeSnappy} from "../../utils/snappyIndex.js";
  * <encoding-dependent-header> | <encoded-payload>
  * ```
  */
-export const writeSszSnappyPayload = encodeSszSnappy as (bytes: Uint8Array) => AsyncGenerator<Buffer>;
+export const writeSszSnappyPayload = encodeSszSnappy as (bytes: Uint8Array) => Generator<Buffer>;
 
 /**
  * Buffered Snappy writer
  */
-export async function* encodeSszSnappy(bytes: Buffer): AsyncGenerator<Buffer> {
+export function* encodeSszSnappy(bytes: Buffer): Generator<Buffer> {
   // MUST encode the length of the raw SSZ bytes, encoded as an unsigned protobuf varint
   const varint = varintEncode(bytes.length);
   yield Buffer.from(varint.buffer, varint.byteOffset, varint.byteLength);

package/src/encodingStrategies/sszSnappy/errors.ts

@@ -9,8 +9,6 @@ export enum SszSnappyErrorCode {
   OVER_SSZ_MAX_SIZE = "SSZ_SNAPPY_ERROR_OVER_SSZ_MAX_SIZE",
   TOO_MUCH_BYTES_READ = "SSZ_SNAPPY_ERROR_TOO_MUCH_BYTES_READ",
   DECOMPRESSOR_ERROR = "SSZ_SNAPPY_ERROR_DECOMPRESSOR_ERROR",
-  DESERIALIZE_ERROR = "SSZ_SNAPPY_ERROR_DESERIALIZE_ERROR",
-  SERIALIZE_ERROR = "SSZ_SNAPPY_ERROR_SERIALIZE_ERROR",
   /** Received more bytes than specified sszDataLength */
   TOO_MANY_BYTES = "SSZ_SNAPPY_ERROR_TOO_MANY_BYTES",
   /** Source aborted before reading sszDataLength bytes */
@@ -23,8 +21,6 @@ type SszSnappyErrorType =
   | {code: SszSnappyErrorCode.OVER_SSZ_MAX_SIZE; maxSize: number; sszDataLength: number}
   | {code: SszSnappyErrorCode.TOO_MUCH_BYTES_READ; readBytes: number; sszDataLength: number}
   | {code: SszSnappyErrorCode.DECOMPRESSOR_ERROR; decompressorError: Error}
-  | {code: SszSnappyErrorCode.DESERIALIZE_ERROR; deserializeError: Error}
-  | {code: SszSnappyErrorCode.SERIALIZE_ERROR; serializeError: Error}
   | {code: SszSnappyErrorCode.TOO_MANY_BYTES; sszDataLength: number}
   | {code: SszSnappyErrorCode.SOURCE_ABORTED};
 

package/src/encodingStrategies/sszSnappy/index.ts

@@ -1,4 +1,3 @@
-export {SnappyFramesUncompress, encodeSnappy} from "../../utils/snappyIndex.js";
 export * from "./decode.js";
 export * from "./encode.js";
 export * from "./errors.js";

package/src/metrics.ts

@@ -4,7 +4,7 @@ import {RequestErrorCode} from "./request/errors.js";
 export type Metrics = ReturnType<typeof getMetrics>;
 
 /**
- * A collection of metrics used throughout the Gossipsub behaviour.
+ * A collection of metrics used throughout the Req/Resp domain.
  */
 export function getMetrics(register: MetricsRegisterExtra) {
   // Using function style instead of class to prevent having to re-declare all MetricsPrometheus types.
@@ -29,7 +29,6 @@ export function getMetrics(register: MetricsRegisterExtra) {
       name: "beacon_reqresp_outgoing_request_roundtrip_time_seconds",
       help: "Histogram of outgoing requests round-trip time",
       labelNames: ["method"],
-      // Spec sets RESP_TIMEOUT = 10 sec
       buckets: [0.1, 0.2, 0.5, 1, 5, 10, 15, 60],
     }),
     outgoingErrors: register.gauge<{method: string}>({
@@ -61,7 +60,6 @@ export function getMetrics(register: MetricsRegisterExtra) {
       name: "beacon_reqresp_incoming_request_handler_time_seconds",
       help: "Histogram of incoming requests internal handling time",
       labelNames: ["method"],
-      // Spec sets RESP_TIMEOUT = 10 sec
       buckets: [0.1, 0.2, 0.5, 1, 5, 10],
     }),
     incomingErrors: register.gauge<{method: string}>({
@@ -69,20 +67,6 @@ export function getMetrics(register: MetricsRegisterExtra) {
       help: "Counts total failed responses handled per method",
       labelNames: ["method"],
     }),
-    outgoingResponseTTFB: register.histogram<{method: string}>({
-      name: "beacon_reqresp_outgoing_response_ttfb_seconds",
-      help: "Time to first byte (TTFB) for outgoing responses",
-      labelNames: ["method"],
-      // Spec sets TTFB_TIMEOUT = 5 sec
-      buckets: [0.1, 1, 5],
-    }),
-    incomingResponseTTFB: register.histogram<{method: string}>({
-      name: "beacon_reqresp_incoming_response_ttfb_seconds",
-      help: "Time to first byte (TTFB) for incoming responses",
-      labelNames: ["method"],
-      // Spec sets TTFB_TIMEOUT = 5 sec
-      buckets: [0.1, 1, 5],
-    }),
     dialErrors: register.gauge({
       name: "beacon_reqresp_dial_errors_total",
       help: "Count total dial errors",

package/src/request/errors.ts

@@ -21,13 +21,9 @@ export enum RequestErrorCode {
   REQUEST_TIMEOUT = "REQUEST_ERROR_REQUEST_TIMEOUT",
   /** Error when sending request to responder */
   REQUEST_ERROR = "REQUEST_ERROR_REQUEST_ERROR",
-  /** Reponder did not deliver a full reponse before max maxTotalResponseTimeout() */
-  RESPONSE_TIMEOUT = "REQUEST_ERROR_RESPONSE_TIMEOUT",
   /** A single-response method returned 0 chunks */
   EMPTY_RESPONSE = "REQUEST_ERROR_EMPTY_RESPONSE",
-  /** Time to first byte timeout */
-  TTFB_TIMEOUT = "REQUEST_ERROR_TTFB_TIMEOUT",
-  /** Timeout between `<response_chunk>` exceed */
+  /** Response transfer timeout exceeded */
   RESP_TIMEOUT = "REQUEST_ERROR_RESP_TIMEOUT",
   /** Request rate limited */
   REQUEST_RATE_LIMITED = "REQUEST_ERROR_RATE_LIMITED",
@@ -50,7 +46,6 @@ type RequestErrorType =
   | {code: RequestErrorCode.REQUEST_TIMEOUT}
   | {code: RequestErrorCode.REQUEST_ERROR; error: Error}
   | {code: RequestErrorCode.EMPTY_RESPONSE}
-  | {code: RequestErrorCode.TTFB_TIMEOUT}
   | {code: RequestErrorCode.RESP_TIMEOUT}
   | {code: RequestErrorCode.REQUEST_RATE_LIMITED}
   | {code: RequestErrorCode.REQUEST_SELF_RATE_LIMITED}

package/src/request/index.ts

@@ -1,31 +1,82 @@
+import type {Stream} from "@libp2p/interface";
 import {PeerId} from "@libp2p/interface";
-import {pipe} from "it-pipe";
 import type {Libp2p} from "libp2p";
-import {Uint8ArrayList} from "uint8arraylist";
 import {ErrorAborted, Logger, TimeoutError, withTimeout} from "@lodestar/utils";
 import {requestEncode} from "../encoders/requestEncode.js";
 import {responseDecode} from "../encoders/responseDecode.js";
 import {Metrics} from "../metrics.js";
 import {ResponseError} from "../response/index.js";
 import {MixedProtocol, ResponseIncoming} from "../types.js";
-import {abortableSource, prettyPrintPeerId} from "../utils/index.js";
+import {prettyPrintPeerId, sendChunks} from "../utils/index.js";
 import {RequestError, RequestErrorCode, responseStatusErrorToRequestError} from "./errors.js";
 
 export {RequestError, RequestErrorCode};
 
-// Default spec values from https://github.com/ethereum/consensus-specs/blob/v1.2.0/specs/phase0/p2p-interface.md#configuration
+// https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/phase0/p2p-interface.md#the-reqresp-domain
 export const DEFAULT_DIAL_TIMEOUT = 5 * 1000; // 5 sec
 export const DEFAULT_REQUEST_TIMEOUT = 5 * 1000; // 5 sec
-export const DEFAULT_TTFB_TIMEOUT = 5 * 1000; // 5 sec
 export const DEFAULT_RESP_TIMEOUT = 10 * 1000; // 10 sec
 
+function getStreamNotFullyConsumedError(): Error {
+  return new Error("ReqResp stream was not fully consumed");
+}
+
+function scheduleStreamAbortIfNotClosed(stream: Stream, timeoutMs: number): void {
+  const onClose = (): void => {
+    clearTimeout(timeout);
+  };
+
+  const timeout = setTimeout(() => {
+    stream.removeEventListener("close", onClose);
+    if (stream.status === "open" && stream.remoteWriteStatus === "writable") {
+      stream.abort(getStreamNotFullyConsumedError());
+    }
+  }, timeoutMs);
+
+  stream.addEventListener("close", onClose, {once: true});
+}
+
+type ClearableSignal = AbortSignal & {clear: () => void};
+
+function createRespSignal(signal: AbortSignal | undefined, timeoutMs: number): ClearableSignal {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  const signals = signal ? [signal, timeoutSignal] : [timeoutSignal];
+  const controller = new AbortController();
+
+  const clear = (): void => {
+    for (const entry of signals) {
+      entry.removeEventListener("abort", onAbort);
+    }
+  };
+
+  const onAbort = (): void => {
+    if (controller.signal.aborted) {
+      return;
+    }
+    const reason = signals.find((entry) => entry.aborted)?.reason;
+    controller.abort(reason);
+    clear();
+  };
+
+  for (const entry of signals) {
+    if (entry.aborted) {
+      onAbort();
+      break;
+    }
+    entry.addEventListener("abort", onAbort);
+  }
+
+  const respSignal = controller.signal as ClearableSignal;
+  respSignal.clear = clear;
+
+  return respSignal;
+}
+
 export interface SendRequestOpts {
   /** The maximum time for complete response transfer. */
   respTimeoutMs?: number;
   /** Non-spec timeout from sending request until write stream closed by responder */
   requestTimeoutMs?: number;
-  /** The maximum time to wait for first byte of request response (time-to-first-byte). */
-  ttfbTimeoutMs?: number;
   /** Non-spec timeout from dialing protocol until stream opened */
   dialTimeoutMs?: number;
 }
@@ -64,7 +115,6 @@ export async function* sendRequest(
 
   const DIAL_TIMEOUT = opts?.dialTimeoutMs ?? DEFAULT_DIAL_TIMEOUT;
   const REQUEST_TIMEOUT = opts?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT;
-  const TTFB_TIMEOUT = opts?.ttfbTimeoutMs ?? DEFAULT_TTFB_TIMEOUT;
   const RESP_TIMEOUT = opts?.respTimeoutMs ?? DEFAULT_RESP_TIMEOUT;
 
   const peerIdStrShort = prettyPrintPeerId(peerId);
@@ -83,17 +133,6 @@ export async function* sendRequest(
     // the picked protocol in `connection.protocol`
     const protocolsMap = new Map<string, MixedProtocol>(protocols.map((protocol, i) => [protocolIDs[i], protocol]));
 
-    // As of October 2020 we can't rely on libp2p.dialProtocol timeout to work so
-    // this function wraps the dialProtocol promise with an extra timeout
-    //
-    // > The issue might be: you add the peer's addresses to the AddressBook,
-    //   which will result in autoDial to kick in and dial your peer. In parallel,
-    //   you do a manual dial and it will wait for the previous one without using
-    //   the abort signal:
-    //
-    // https://github.com/ChainSafe/lodestar/issues/1597#issuecomment-703394386
-
-    // DIAL_TIMEOUT: Non-spec timeout from dialing protocol until stream opened
     const stream = await withTimeout(
       async (timeoutAndParentSignal) => {
         const protocolIds = Array.from(protocolsMap.keys());
@@ -112,9 +151,6 @@ export async function* sendRequest(
 
     metrics?.outgoingOpenedStreams?.inc({method});
 
-    // TODO: Does the TTFB timer start on opening stream or after receiving request
-    const timerTTFB = metrics?.outgoingResponseTTFB.startTimer({method});
-
     // Parse protocol selected by the responder
     const protocolId = stream.protocol ?? "unknown";
     const protocol = protocolsMap.get(protocolId);
@@ -126,21 +162,24 @@ export async function* sendRequest(
     logger.debug("Req  sending request", logCtx);
 
     // Spec: The requester MUST close the write side of the stream once it finishes writing the request message
-    // Impl: stream.sink is closed automatically by js-libp2p-mplex when piped source is exhausted
 
     // REQUEST_TIMEOUT: Non-spec timeout from sending request until write stream closed by responder
-    // Note: libp2p.stop() will close all connections, so not necessary to abort this pipe on parent stop
-    await withTimeout(() => pipe(requestEncode(protocol, requestBody), stream.sink), REQUEST_TIMEOUT, signal).catch(
-      (e) => {
-        // Must close the stream read side (stream.source) manually AND the write side
-        stream.abort(e);
-
-        if (e instanceof TimeoutError) {
-          throw new RequestError({code: RequestErrorCode.REQUEST_TIMEOUT});
-        }
-        throw new RequestError({code: RequestErrorCode.REQUEST_ERROR, error: e as Error});
+    // Note: libp2p.stop() will close all connections, so not necessary to abort this send on parent stop
+    await withTimeout(
+      async (timeoutAndParentSignal) => {
+        await sendChunks(stream, requestEncode(protocol, requestBody), timeoutAndParentSignal);
+        await stream.close({signal: timeoutAndParentSignal});
+      },
+      REQUEST_TIMEOUT,
+      signal
+    ).catch((e) => {
+      stream.abort(e as Error);
+
+      if (e instanceof TimeoutError) {
+        throw new RequestError({code: RequestErrorCode.REQUEST_TIMEOUT});
       }
-    );
+      throw new RequestError({code: RequestErrorCode.REQUEST_ERROR, error: e as Error});
+    });
 
     logger.debug("Req  request sent", logCtx);
 
@@ -150,67 +189,51 @@ export async function* sendRequest(
       return;
     }
 
-    // - TTFB_TIMEOUT: The requester MUST wait a maximum of TTFB_TIMEOUT for the first response byte to arrive
-    // - RESP_TIMEOUT: Requester allows a further RESP_TIMEOUT for each subsequent response_chunk
-    // - Max total timeout: This timeout is not required by the spec. It may not be necessary, but it's kept as
-    //   safe-guard to close. streams in case of bugs on other timeout mechanisms.
-    const ttfbTimeoutController = new AbortController();
-    const respTimeoutController = new AbortController();
-
-    let timeoutRESP: NodeJS.Timeout | null = null;
+    // RESP_TIMEOUT: Maximum time for complete response transfer
+    const respSignal = createRespSignal(signal, RESP_TIMEOUT);
 
-    const timeoutTTFB = setTimeout(() => {
-      // If we abort on first byte delay, don't need to abort for response delay
-      if (timeoutRESP) clearTimeout(timeoutRESP);
-      ttfbTimeoutController.abort();
-    }, TTFB_TIMEOUT);
-
-    const restartRespTimeout = (): void => {
-      if (timeoutRESP) clearTimeout(timeoutRESP);
-      timeoutRESP = setTimeout(() => respTimeoutController.abort(), RESP_TIMEOUT);
-    };
+    let responseError: Error | null = null;
+    let responseFullyConsumed = false;
 
     try {
-      // Note: libp2p.stop() will close all connections, so not necessary to abort this pipe on parent stop
-      yield* pipe(
-        abortableSource(stream.source as AsyncIterable<Uint8ArrayList>, [
-          {
-            signal: ttfbTimeoutController.signal,
-            getError: () => new RequestError({code: RequestErrorCode.TTFB_TIMEOUT}),
-          },
-          {
-            signal: respTimeoutController.signal,
-            getError: () => new RequestError({code: RequestErrorCode.RESP_TIMEOUT}),
-          },
-        ]),
-
-        // Transforms `Buffer` chunks to yield `ResponseBody` chunks
-        responseDecode(protocol, {
-          onFirstHeader() {
-            // On first byte, cancel the single use TTFB_TIMEOUT, and start RESP_TIMEOUT
-            clearTimeout(timeoutTTFB);
-            timerTTFB?.();
-            restartRespTimeout();
-          },
-          onFirstResponseChunk() {
-            // On <response_chunk>, cancel this chunk's RESP_TIMEOUT and start next's
-            restartRespTimeout();
-          },
-        })
-      );
+      yield* responseDecode(protocol, stream, {
+        signal: respSignal,
+        getError: () =>
+          signal?.aborted ? new ErrorAborted("sendRequest") : new RequestError({code: RequestErrorCode.RESP_TIMEOUT}),
+      });
+      responseFullyConsumed = true;
 
       // NOTE: Only log once per request to verbose, intermediate steps to debug
       // NOTE: Do not log the response, logs get extremely cluttered
       // NOTE: add double space after "Req  " to align log with the "Resp " log
       logger.verbose("Req  done", logCtx);
+    } catch (e) {
+      responseError = e as Error;
+      throw e;
     } finally {
-      clearTimeout(timeoutTTFB);
-      if (timeoutRESP !== null) clearTimeout(timeoutRESP);
-
-      // Necessary to call `stream.close()` since collectResponses() may break out of the source before exhausting it
-      // `stream.close()` libp2p-mplex will .end() the source (it-pushable instance)
-      // If collectResponses() exhausts the source, it-pushable.end() can be safely called multiple times
-      await stream.close();
+      // On decode/timeout failures abort immediately so mplex can reclaim stream state.
+      // On normal early consumer exit, close gracefully to avoid stream-id desync with peers.
+      if (responseError !== null || signal?.aborted) {
+        stream.abort(responseError ?? new ErrorAborted("sendRequest"));
+      } else {
+        await stream.close().catch((e) => {
+          stream.abort(e as Error);
+        });
+
+        if (!responseFullyConsumed) {
+          // Stop buffering unread inbound data after caller exits early.
+          // mplex does not support propagating closeRead to the remote, so still
+          // abort later if the remote never closes write.
+          await stream.closeRead().catch(() => {
+            // Ignore closeRead errors - close/abort path below will reclaim stream.
+          });
+
+          if (stream.remoteWriteStatus === "writable") {
+            scheduleStreamAbortIfNotClosed(stream, RESP_TIMEOUT);
+          }
+        }
+      }
+      respSignal.clear();
       metrics?.outgoingClosedStreams?.inc({method});
       logger.verbose("Req  stream closed", logCtx);
     }