@lodestar/reqresp 1.41.0-dev.aeb5a213ee → 1.41.0-dev.bb273175f2

package/src/encoders/responseDecode.ts

@@ -1,4 +1,6 @@
-import {Uint8ArrayList} from "uint8arraylist";
+import type {Stream} from "@libp2p/interface";
+import type {ByteStream} from "@libp2p/utils";
+import {byteStream} from "@libp2p/utils";
 import {ForkName} from "@lodestar/params";
 import {readEncodedPayload} from "../encodingStrategies/index.js";
 import {RespStatus} from "../interface.js";
@@ -10,7 +12,7 @@ import {
   MixedProtocol,
   ResponseIncoming,
 } from "../types.js";
-import {BufferedSource, decodeErrorMessage} from "../utils/index.js";
+import {decodeErrorMessage, drainByteStream} from "../utils/index.js";
 
 /**
  * Internal helper type to signal stream ended early
@@ -27,22 +29,17 @@ enum StreamStatus {
  * result          ::= "0" | "1" | "2" | ["128" ... "255"]
  * ```
  */
-export function responseDecode(
+export async function* responseDecode(
   protocol: MixedProtocol,
-  cbs: {
-    onFirstHeader: () => void;
-    onFirstResponseChunk: () => void;
-  }
-): (source: AsyncIterable<Uint8Array | Uint8ArrayList>) => AsyncIterable<ResponseIncoming> {
-  return async function* responseDecodeSink(source) {
-    const bufferedSource = new BufferedSource(source as AsyncGenerator<Uint8ArrayList>);
-
-    let readFirstHeader = false;
-    let readFirstResponseChunk = false;
+  stream: Stream,
+  opts: {signal?: AbortSignal; getError?: () => Error} = {}
+): AsyncIterable<ResponseIncoming> {
+  const bytes = byteStream(stream);
+  let responseReadDone = false;
 
-    // Consumers of `responseDecode()` may limit the number of <response_chunk> and break out of the while loop
-    while (!bufferedSource.isDone) {
-      const status = await readResultHeader(bufferedSource);
+  try {
+    while (true) {
+      const status = await readResultHeader(bytes, opts.signal);
 
       // Stream is only allowed to end at the start of a <response_chunk> block
       // The happens when source ends before readResultHeader() can fetch 1 byte
@@ -50,34 +47,41 @@ export function responseDecode(
         break;
       }
 
-      if (!readFirstHeader) {
-        cbs.onFirstHeader();
-        readFirstHeader = true;
-      }
-
       // For multiple chunks, only the last chunk is allowed to have a non-zero error
       // code (i.e. The chunk stream is terminated once an error occurs
       if (status !== RespStatus.SUCCESS) {
-        const errorMessage = await readErrorMessage(bufferedSource);
+        const errorMessage = await readErrorMessage(bytes, opts.signal);
         throw new ResponseError(status, errorMessage);
       }
 
-      const forkName = await readContextBytes(protocol.contextBytes, bufferedSource);
+      const forkName = await readContextBytes(protocol.contextBytes, bytes, opts.signal);
       const typeSizes = protocol.responseSizes(forkName);
-      const chunkData = await readEncodedPayload(bufferedSource, protocol.encoding, typeSizes);
+      const chunkData = await readEncodedPayload(bytes, protocol.encoding, typeSizes, opts.signal);
 
       yield {
         data: chunkData,
         fork: forkName,
         protocolVersion: protocol.version,
       };
-
-      if (!readFirstResponseChunk) {
-        cbs.onFirstResponseChunk();
-        readFirstResponseChunk = true;
+    }
+    responseReadDone = true;
+  } catch (e) {
+    if (opts.signal?.aborted && opts.getError) {
+      throw opts.getError();
+    }
+    throw e;
+  } finally {
+    try {
+      if (!responseReadDone) {
+        // Do not push partial bytes back into the stream on decode failure/abort.
+        // This stream is consumed by req/resp only once.
+        drainByteStream(bytes);
       }
+      bytes.unwrap();
+    } catch {
+      // Ignore unwrap errors - stream may already be closed
     }
-  };
+  }
 }
 
 /**
@@ -87,18 +91,17 @@ export function responseDecode(
  * ```
  * `<response_chunk>` starts with a single-byte response code which determines the contents of the response_chunk
  */
-export async function readResultHeader(bufferedSource: BufferedSource): Promise<RespStatus | StreamStatus> {
-  for await (const buffer of bufferedSource) {
-    const status = buffer.get(0);
-    buffer.consume(1);
-
-    // If first chunk had zero bytes status === null, get next
-    if (status !== null) {
-      return status;
-    }
-  }
-
-  return StreamStatus.Ended;
+export async function readResultHeader(
+  bytes: ByteStream<Stream>,
+  signal?: AbortSignal
+): Promise<RespStatus | StreamStatus> {
+  const chunk = await bytes.read({bytes: 1, signal}).catch((e) => {
+    if ((e as Error).name === "UnexpectedEOFError") return null;
+    throw e;
+  });
+  if (chunk === null) return StreamStatus.Ended;
+
+  return chunk.get(0);
 }
 
 /**
@@ -108,28 +111,29 @@ export async function readResultHeader(bufferedSource: BufferedSource): Promise<
  * result          ::= "1" | "2" | ["128" ... "255"]
  * ```
  */
-export async function readErrorMessage(bufferedSource: BufferedSource): Promise<string> {
-  // Read at least 256 or wait for the stream to end
-  let length: number | undefined;
-  for await (const buffer of bufferedSource) {
-    // Wait for next chunk with bytes or for the stream to end
-    // Note: The entire <error_message> is expected to be in the same chunk
-    if (buffer.length >= 256) {
-      length = 256;
+export async function readErrorMessage(bytes: ByteStream<Stream>, signal?: AbortSignal): Promise<string> {
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+
+  while (total < 256) {
+    const chunk = await bytes.read({signal}).catch((e) => {
+      if ((e as Error).name === "UnexpectedEOFError") return null;
+      throw e;
+    });
+    if (chunk === null) {
+      // If EOF is reached while satisfying a larger read, libp2p v3 may still have
+      // buffered bytes available. Drain them so error_message matches pre-v3 behavior.
+      const remaining = drainByteStream(bytes);
+      if (remaining) {
+        chunks.push(remaining);
+      }
       break;
     }
-    length = buffer.length;
+    chunks.push(chunk.subarray());
+    total += chunk.byteLength;
   }
 
-  // biome-ignore lint/complexity/useLiteralKeys: It is a private attribute
-  const bytes = bufferedSource["buffer"].slice(0, length);
-
-  try {
-    return decodeErrorMessage(bytes);
-  } catch (_e) {
-    // Error message is optional and may not be included in the response stream
-    return Buffer.prototype.toString.call(bytes, "hex");
-  }
+  return decodeErrorMessage(Buffer.concat(chunks).subarray(0, 256));
 }
 
 /**
@@ -139,14 +143,15 @@ export async function readErrorMessage(bufferedSource: BufferedSource): Promise<
  */
 export async function readContextBytes(
   contextBytes: ContextBytesFactory,
-  bufferedSource: BufferedSource
+  bytes: ByteStream<Stream>,
+  signal?: AbortSignal
 ): Promise<ForkName> {
   switch (contextBytes.type) {
     case ContextBytesType.Empty:
       return ForkName.phase0;
 
     case ContextBytesType.ForkDigest: {
-      const forkDigest = await readContextBytesForkDigest(bufferedSource);
+      const forkDigest = await readContextBytesForkDigest(bytes, signal);
       return contextBytes.config.forkDigest2ForkBoundary(forkDigest).fork;
     }
   }
@@ -155,15 +160,6 @@ export async function readContextBytes(
 /**
  * Consumes a stream source to read `<context-bytes>`, where it's a fixed-width 4 byte
  */
-export async function readContextBytesForkDigest(bufferedSource: BufferedSource): Promise<Uint8Array> {
-  for await (const buffer of bufferedSource) {
-    if (buffer.length >= CONTEXT_BYTES_FORK_DIGEST_LENGTH) {
-      const bytes = buffer.slice(0, CONTEXT_BYTES_FORK_DIGEST_LENGTH);
-      buffer.consume(CONTEXT_BYTES_FORK_DIGEST_LENGTH);
-      return bytes;
-    }
-  }
-
-  // TODO: Use typed error
-  throw Error("Source ended while reading context bytes");
+export async function readContextBytesForkDigest(bytes: ByteStream<Stream>, signal?: AbortSignal): Promise<Uint8Array> {
+  return (await bytes.read({bytes: CONTEXT_BYTES_FORK_DIGEST_LENGTH, signal})).subarray();
 }

package/src/encoders/responseEncode.ts

@@ -14,30 +14,23 @@ const SUCCESS_BUFFER = Buffer.from([RespStatus.SUCCESS]);
  * ```
  * Note: `response` has zero or more chunks (denoted by `<>*`)
  */
-export function responseEncodeSuccess(
+export async function* responseEncodeSuccess(
   protocol: Protocol,
-  cbs: {onChunk: (chunkIndex: number) => void}
-): (source: AsyncIterable<ResponseOutgoing>) => AsyncIterable<Buffer> {
-  return async function* responseEncodeSuccessTransform(source) {
-    let chunkIndex = 0;
+  source: AsyncIterable<ResponseOutgoing>
+): AsyncIterable<Uint8Array> {
+  for await (const chunk of source) {
+    // <result>
+    yield SUCCESS_BUFFER;
 
-    for await (const chunk of source) {
-      // Postfix increment, return 0 as first chunk
-      cbs.onChunk(chunkIndex++);
-
-      // <result>
-      yield SUCCESS_BUFFER;
-
-      // <context-bytes> - from altair
-      const contextBytes = getContextBytes(protocol.contextBytes, chunk);
-      if (contextBytes) {
-        yield contextBytes as Buffer;
-      }
-
-      // <encoding-dependent-header> | <encoded-payload>
-      yield* writeEncodedPayload(chunk.data, protocol.encoding);
+    // <context-bytes> - from altair
+    const contextBytes = getContextBytes(protocol.contextBytes, chunk);
+    if (contextBytes) {
+      yield contextBytes;
     }
-  };
+
+    // <encoding-dependent-header> | <encoded-payload>
+    yield* writeEncodedPayload(chunk.data, protocol.encoding);
+  }
 }
 
 /**
@@ -50,20 +43,15 @@ export function responseEncodeSuccess(
  * Only the last `<response_chunk>` is allowed to have a non-zero error code, so this
  * fn yields exactly one `<error_response>` and afterwards the stream must be terminated
  */
-export async function* responseEncodeError(
+export function* responseEncodeError(
   protocol: Pick<MixedProtocol, "encoding">,
   status: RpcResponseStatusError,
   errorMessage: string
-): AsyncGenerator<Buffer> {
-  if (!errorMessage) {
-    yield Buffer.from([status]);
-    return;
-  }
-
+): Generator<Buffer> {
   // Combine <result> and <error_message> into a single chunk for atomic delivery.
   // Yielding them separately causes a race condition where the stream closes after the
   // status byte but before the error message arrives on the reader side.
-  const errorMessageBuffer = await encodeErrorMessageToBuffer(errorMessage, protocol.encoding);
+  const errorMessageBuffer = encodeErrorMessageToBuffer(errorMessage, protocol.encoding);
   yield Buffer.concat([Buffer.from([status]), errorMessageBuffer]);
 }
 

package/src/encodingStrategies/index.ts

@@ -1,10 +1,11 @@
+import type {Stream} from "@libp2p/interface";
+import type {ByteStream} from "@libp2p/utils";
 import {Encoding, TypeSizes} from "../types.js";
-import {BufferedSource} from "../utils/index.js";
 import {readSszSnappyPayload} from "./sszSnappy/decode.js";
 import {writeSszSnappyPayload} from "./sszSnappy/encode.js";
 
 // For more info about Ethereum Consensus request/response encoding strategies, see:
-// https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#encoding-strategies
+// https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/phase0/p2p-interface.md#encoding-strategies
 // Supported encoding strategies:
 // - ssz_snappy
 
@@ -15,13 +16,14 @@ import {writeSszSnappyPayload} from "./sszSnappy/encode.js";
  * ```
  */
 export async function readEncodedPayload(
-  bufferedSource: BufferedSource,
+  stream: ByteStream<Stream>,
   encoding: Encoding,
-  type: TypeSizes
+  type: TypeSizes,
+  signal?: AbortSignal
 ): Promise<Uint8Array> {
   switch (encoding) {
     case Encoding.SSZ_SNAPPY:
-      return readSszSnappyPayload(bufferedSource, type);
+      return readSszSnappyPayload(stream, type, signal);
 
     default:
       throw Error("Unsupported encoding");
@@ -34,7 +36,7 @@ export async function readEncodedPayload(
  * <encoding-dependent-header> | <encoded-payload>
  * ```
  */
-export async function* writeEncodedPayload(chunkData: Uint8Array, encoding: Encoding): AsyncGenerator<Buffer> {
+export function* writeEncodedPayload(chunkData: Uint8Array, encoding: Encoding): Generator<Buffer> {
   switch (encoding) {
     case Encoding.SSZ_SNAPPY:
       yield* writeSszSnappyPayload(chunkData);

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}