@lodestar/reqresp 1.35.0-dev.83de5b8dea → 1.35.0-dev.8689cc3545

package/src/encoders/responseDecode.ts

@@ -0,0 +1,169 @@
+import {Uint8ArrayList} from "uint8arraylist";
+import {ForkName} from "@lodestar/params";
+import {readEncodedPayload} from "../encodingStrategies/index.js";
+import {RespStatus} from "../interface.js";
+import {ResponseError} from "../response/index.js";
+import {
+  CONTEXT_BYTES_FORK_DIGEST_LENGTH,
+  ContextBytesFactory,
+  ContextBytesType,
+  MixedProtocol,
+  ResponseIncoming,
+} from "../types.js";
+import {BufferedSource, decodeErrorMessage} from "../utils/index.js";
+
+/**
+ * Internal helper type to signal stream ended early
+ */
+enum StreamStatus {
+  Ended = "STREAM_ENDED",
+}
+
+/**
+ * Consumes a stream source to read a `<response>`
+ * ```bnf
+ * response        ::= <response_chunk>*
+ * response_chunk  ::= <result> | <context-bytes> | <encoding-dependent-header> | <encoded-payload>
+ * result          ::= "0" | "1" | "2" | ["128" ... "255"]
+ * ```
+ */
+export 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;
+
+    // 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);
+
+      // 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
+      if (status === StreamStatus.Ended) {
+        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);
+        throw new ResponseError(status, errorMessage);
+      }
+
+      const forkName = await readContextBytes(protocol.contextBytes, bufferedSource);
+      const typeSizes = protocol.responseSizes(forkName);
+      const chunkData = await readEncodedPayload(bufferedSource, protocol.encoding, typeSizes);
+
+      yield {
+        data: chunkData,
+        fork: forkName,
+        protocolVersion: protocol.version,
+      };
+
+      if (!readFirstResponseChunk) {
+        cbs.onFirstResponseChunk();
+        readFirstResponseChunk = true;
+      }
+    }
+  };
+}
+
+/**
+ * Consumes a stream source to read a `<result>`
+ * ```bnf
+ * result  ::= "0" | "1" | "2" | ["128" ... "255"]
+ * ```
+ * `<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;
+}
+
+/**
+ * Consumes a stream source to read an optional `<error_response>?`
+ * ```bnf
+ * error_response  ::= <result> | <error_message>?
+ * 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;
+      break;
+    }
+    length = buffer.length;
+  }
+
+  // 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");
+  }
+}
+
+/**
+ * Consumes a stream source to read a variable length `<context-bytes>` depending on the method.
+ * While `<context-bytes>` has a single type of `ForkDigest`, this function only parses the `ForkName`
+ * of the `ForkDigest` or defaults to `phase0`
+ */
+export async function readContextBytes(
+  contextBytes: ContextBytesFactory,
+  bufferedSource: BufferedSource
+): Promise<ForkName> {
+  switch (contextBytes.type) {
+    case ContextBytesType.Empty:
+      return ForkName.phase0;
+
+    case ContextBytesType.ForkDigest: {
+      const forkDigest = await readContextBytesForkDigest(bufferedSource);
+      return contextBytes.config.forkDigest2ForkBoundary(forkDigest).fork;
+    }
+  }
+}
+
+/**
+ * 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");
+}

package/src/encoders/responseEncode.ts

@@ -0,0 +1,81 @@
+import {writeEncodedPayload} from "../encodingStrategies/index.js";
+import {RespStatus, RpcResponseStatusError} from "../interface.js";
+import {ContextBytesFactory, ContextBytesType, MixedProtocol, Protocol, ResponseOutgoing} from "../types.js";
+import {encodeErrorMessage} from "../utils/index.js";
+
+const SUCCESS_BUFFER = Buffer.from([RespStatus.SUCCESS]);
+
+/**
+ * Yields byte chunks for a `<response>` with a zero response code `<result>`
+ * ```bnf
+ * response        ::= <response_chunk>*
+ * response_chunk  ::= <result> | <context-bytes> | <encoding-dependent-header> | <encoded-payload>
+ * result          ::= "0"
+ * ```
+ * Note: `response` has zero or more chunks (denoted by `<>*`)
+ */
+export function responseEncodeSuccess(
+  protocol: Protocol,
+  cbs: {onChunk: (chunkIndex: number) => void}
+): (source: AsyncIterable<ResponseOutgoing>) => AsyncIterable<Buffer> {
+  return async function* responseEncodeSuccessTransform(source) {
+    let chunkIndex = 0;
+
+    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);
+    }
+  };
+}
+
+/**
+ * Yields byte chunks for a `<response_chunk>` with a non-zero response code `<result>`
+ * denoted as `<error_response>`
+ * ```bnf
+ * error_response  ::= <result> | <error_message>?
+ * result          ::= "1" | "2" | ["128" ... "255"]
+ * ```
+ * 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(
+  protocol: Pick<MixedProtocol, "encoding">,
+  status: RpcResponseStatusError,
+  errorMessage: string
+): AsyncGenerator<Buffer> {
+  // <result>
+  yield Buffer.from([status]);
+
+  // <error_message>? is optional
+  if (errorMessage) {
+    yield* encodeErrorMessage(errorMessage, protocol.encoding);
+  }
+}
+
+/**
+ * Yields byte chunks for a `<context-bytes>`. See `ContextBytesType` for possible types.
+ * This item is mandatory but may be empty.
+ */
+function getContextBytes(contextBytes: ContextBytesFactory, chunk: ResponseOutgoing): Uint8Array | null {
+  switch (contextBytes.type) {
+    // Yield nothing
+    case ContextBytesType.Empty:
+      return null;
+
+    // Yield a fixed-width 4 byte chunk, set to the `ForkDigest`
+    case ContextBytesType.ForkDigest:
+      return contextBytes.config.forkBoundary2ForkDigest(chunk.boundary);
+  }
+}

package/src/encodingStrategies/index.ts

@@ -0,0 +1,46 @@
+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
+// Supported encoding strategies:
+// - ssz_snappy
+
+/**
+ * Consumes a stream source to read encoded header and payload as defined in the spec:
+ * ```
+ * <encoding-dependent-header> | <encoded-payload>
+ * ```
+ */
+export async function readEncodedPayload(
+  bufferedSource: BufferedSource,
+  encoding: Encoding,
+  type: TypeSizes
+): Promise<Uint8Array> {
+  switch (encoding) {
+    case Encoding.SSZ_SNAPPY:
+      return readSszSnappyPayload(bufferedSource, type);
+
+    default:
+      throw Error("Unsupported encoding");
+  }
+}
+
+/**
+ * Yields byte chunks for encoded header and payload as defined in the spec:
+ * ```
+ * <encoding-dependent-header> | <encoded-payload>
+ * ```
+ */
+export async function* writeEncodedPayload(chunkData: Uint8Array, encoding: Encoding): AsyncGenerator<Buffer> {
+  switch (encoding) {
+    case Encoding.SSZ_SNAPPY:
+      yield* writeSszSnappyPayload(chunkData);
+      break;
+
+    default:
+      throw Error("Unsupported encoding");
+  }
+}

package/src/encodingStrategies/sszSnappy/decode.ts

@@ -0,0 +1,111 @@
+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 {SszSnappyError, SszSnappyErrorCode} from "./errors.js";
+import {SnappyFramesUncompress} from "./snappyFrames/uncompress.js";
+import {maxEncodedLen} from "./utils.js";
+
+export const MAX_VARINT_BYTES = 10;
+
+/**
+ * ssz_snappy encoding strategy reader.
+ * Consumes a stream source to read encoded header and payload as defined in the spec:
+ * ```bnf
+ * <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);
+}
+
+/**
+ * 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;
+    }
+
+    let sszDataLength: number;
+    try {
+      sszDataLength = varintDecode(buffer.subarray());
+    } catch (_e) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.INVALID_VARINT_BYTES_COUNT, bytes: Infinity});
+    }
+
+    // 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);
+
+    // 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;
+  }
+
+  throw new SszSnappyError({code: SszSnappyErrorCode.SOURCE_ABORTED});
+}
+
+/**
+ * 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();
+  const uncompressedData = new Uint8ArrayList();
+  let readBytes = 0;
+
+  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});
+    }
+
+    // No bytes left to consume, get next
+    if (buffer.length === 0) {
+      continue;
+    }
+
+    // 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 (uncompressed !== null) {
+        uncompressedData.append(uncompressed);
+      }
+    } catch (e) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.DECOMPRESSOR_ERROR, decompressorError: e as Error});
+    }
+
+    // SHOULD consider invalid reading more bytes than `n` SSZ bytes
+    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);
+  }
+
+  // SHOULD consider invalid: An early EOF before fully reading the declared length-prefix worth of SSZ bytes
+  throw new SszSnappyError({code: SszSnappyErrorCode.SOURCE_ABORTED});
+}

package/src/encodingStrategies/sszSnappy/encode.ts

@@ -0,0 +1,24 @@
+import {encode as varintEncode} from "uint8-varint";
+import {encodeSnappy} from "./snappyFrames/compress.js";
+
+/**
+ * ssz_snappy encoding strategy writer.
+ * Yields byte chunks for encoded header and payload as defined in the spec:
+ * ```
+ * <encoding-dependent-header> | <encoded-payload>
+ * ```
+ */
+export const writeSszSnappyPayload = encodeSszSnappy as (bytes: Uint8Array) => AsyncGenerator<Buffer>;
+
+/**
+ * Buffered Snappy writer
+ */
+export async function* encodeSszSnappy(bytes: Buffer): AsyncGenerator<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);
+
+  // By first computing and writing the SSZ byte length, the SSZ encoder can then directly
+  // write the chunk contents to the stream. Snappy writer compresses frame by frame
+  yield* encodeSnappy(bytes);
+}

package/src/encodingStrategies/sszSnappy/errors.ts

@@ -0,0 +1,31 @@
+import {LodestarError} from "@lodestar/utils";
+
+export enum SszSnappyErrorCode {
+  /** Invalid number of bytes for protobuf varint */
+  INVALID_VARINT_BYTES_COUNT = "SSZ_SNAPPY_ERROR_INVALID_VARINT_BYTES_COUNT",
+  /** Parsed sszDataLength is under the SSZ type min size */
+  UNDER_SSZ_MIN_SIZE = "SSZ_SNAPPY_ERROR_UNDER_SSZ_MIN_SIZE",
+  /** Parsed sszDataLength is over the SSZ type max size */
+  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 */
+  SOURCE_ABORTED = "SSZ_SNAPPY_ERROR_SOURCE_ABORTED",
+}
+
+type SszSnappyErrorType =
+  | {code: SszSnappyErrorCode.INVALID_VARINT_BYTES_COUNT; bytes: number}
+  | {code: SszSnappyErrorCode.UNDER_SSZ_MIN_SIZE; minSize: number; sszDataLength: number}
+  | {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};
+
+export class SszSnappyError extends LodestarError<SszSnappyErrorType> {}

package/src/encodingStrategies/sszSnappy/index.ts

@@ -0,0 +1,3 @@
+export * from "./decode.js";
+export * from "./encode.js";
+export * from "./errors.js";

package/src/encodingStrategies/sszSnappy/snappyFrames/common.ts

@@ -0,0 +1,36 @@
+import crc32c from "@chainsafe/fast-crc32c";
+
+export enum ChunkType {
+  IDENTIFIER = 0xff,
+  COMPRESSED = 0x00,
+  UNCOMPRESSED = 0x01,
+  PADDING = 0xfe,
+  SKIPPABLE = 0x80,
+}
+
+export const IDENTIFIER = Buffer.from([0x73, 0x4e, 0x61, 0x50, 0x70, 0x59]);
+export const IDENTIFIER_FRAME = Buffer.from([0xff, 0x06, 0x00, 0x00, 0x73, 0x4e, 0x61, 0x50, 0x70, 0x59]);
+
+/**
+ * As per the snappy framing format for streams, the size of any uncompressed chunk can be
+ * no longer than 65536 bytes.
+ *
+ * From: https://github.com/google/snappy/blob/main/framing_format.txt#L90:L92
+ */
+export const UNCOMPRESSED_CHUNK_SIZE = 65536;
+
+export function crc(value: Uint8Array): Buffer {
+  const x = crc32c.calculate(value);
+  const result = Buffer.allocUnsafe?.(4) ?? Buffer.alloc(4);
+
+  // As defined in section 3 of https://github.com/google/snappy/blob/master/framing_format.txt
+  // And other implementations for reference:
+  // Go: https://github.com/golang/snappy/blob/2e65f85255dbc3072edf28d6b5b8efc472979f5a/snappy.go#L97
+  // Python: https://github.com/andrix/python-snappy/blob/602e9c10d743f71bef0bac5e4c4dffa17340d7b3/snappy/snappy.py#L70
+  // Mask the right hand to (32 - 17) = 15 bits -> 0x7fff, to keep correct 32 bit values.
+  // Shift the left hand with >>> for correct 32 bit intermediate result.
+  // Then final >>> 0 for 32 bits output
+  result.writeUInt32LE((((x >>> 15) | ((x & 0x7fff) << 17)) + 0xa282ead8) >>> 0, 0);
+
+  return result;
+}

package/src/encodingStrategies/sszSnappy/snappyFrames/compress.ts

@@ -0,0 +1,25 @@
+import snappy from "snappy";
+import {ChunkType, IDENTIFIER_FRAME, UNCOMPRESSED_CHUNK_SIZE, crc} from "./common.js";
+
+// The logic in this file is largely copied (in simplified form) from https://github.com/ChainSafe/node-snappy-stream/
+
+export async function* encodeSnappy(bytes: Buffer): AsyncGenerator<Buffer> {
+  yield IDENTIFIER_FRAME;
+
+  for (let i = 0; i < bytes.length; i += UNCOMPRESSED_CHUNK_SIZE) {
+    const chunk = bytes.subarray(i, i + UNCOMPRESSED_CHUNK_SIZE);
+    const compressed = snappy.compressSync(chunk);
+    if (compressed.length < chunk.length) {
+      const size = compressed.length + 4;
+      yield Buffer.concat([Buffer.from([ChunkType.COMPRESSED, size, size >> 8, size >> 16]), crc(chunk), compressed]);
+    } else {
+      const size = chunk.length + 4;
+      yield Buffer.concat([
+        //
+        Buffer.from([ChunkType.UNCOMPRESSED, size, size >> 8, size >> 16]),
+        crc(chunk),
+        chunk,
+      ]);
+    }
+  }
+}

package/src/encodingStrategies/sszSnappy/snappyFrames/uncompress.ts

@@ -0,0 +1,114 @@
+import {uncompress} from "snappyjs";
+import {Uint8ArrayList} from "uint8arraylist";
+import {ChunkType, IDENTIFIER, UNCOMPRESSED_CHUNK_SIZE, crc} from "./common.js";
+
+export class SnappyFramesUncompress {
+  private buffer = new Uint8ArrayList();
+
+  private state: UncompressState = {
+    foundIdentifier: false,
+  };
+
+  /**
+   * Accepts chunk of data containing some part of snappy frames stream
+   * @param chunk
+   * @return Buffer if there is one or more whole frames, null if it's partial
+   */
+  uncompress(chunk: Uint8ArrayList): Uint8ArrayList | null {
+    this.buffer.append(chunk);
+    const result = new Uint8ArrayList();
+    while (this.buffer.length > 0) {
+      if (this.buffer.length < 4) break;
+
+      const type = getChunkType(this.buffer.get(0));
+
+      if (!this.state.foundIdentifier && type !== ChunkType.IDENTIFIER) {
+        throw "malformed input: must begin with an identifier";
+      }
+
+      const frameSize = getFrameSize(this.buffer, 1);
+
+      if (this.buffer.length - 4 < frameSize) {
+        break;
+      }
+
+      const frame = this.buffer.subarray(4, 4 + frameSize);
+      this.buffer.consume(4 + frameSize);
+
+      switch (type) {
+        case ChunkType.IDENTIFIER: {
+          if (!Buffer.prototype.equals.call(frame, IDENTIFIER)) {
+            throw "malformed input: bad identifier";
+          }
+          this.state.foundIdentifier = true;
+          continue;
+        }
+        case ChunkType.PADDING:
+        case ChunkType.SKIPPABLE:
+          continue;
+        case ChunkType.COMPRESSED: {
+          const checksum = frame.subarray(0, 4);
+          const data = frame.subarray(4);
+
+          const uncompressed = uncompress(data, UNCOMPRESSED_CHUNK_SIZE);
+          if (crc(uncompressed).compare(checksum) !== 0) {
+            throw "malformed input: bad checksum";
+          }
+          result.append(uncompressed);
+          break;
+        }
+        case ChunkType.UNCOMPRESSED: {
+          const checksum = frame.subarray(0, 4);
+          const uncompressed = frame.subarray(4);
+
+          if (uncompressed.length > UNCOMPRESSED_CHUNK_SIZE) {
+            throw "malformed input: too large";
+          }
+          if (crc(uncompressed).compare(checksum) !== 0) {
+            throw "malformed input: bad checksum";
+          }
+          result.append(uncompressed);
+          break;
+        }
+      }
+    }
+    if (result.length === 0) {
+      return null;
+    }
+    return result;
+  }
+
+  reset(): void {
+    this.buffer = new Uint8ArrayList();
+    this.state = {
+      foundIdentifier: false,
+    };
+  }
+}
+
+type UncompressState = {
+  foundIdentifier: boolean;
+};
+
+function getFrameSize(buffer: Uint8ArrayList, offset: number): number {
+  return buffer.get(offset) + (buffer.get(offset + 1) << 8) + (buffer.get(offset + 2) << 16);
+}
+
+function getChunkType(value: number): ChunkType {
+  switch (value) {
+    case ChunkType.IDENTIFIER:
+      return ChunkType.IDENTIFIER;
+    case ChunkType.COMPRESSED:
+      return ChunkType.COMPRESSED;
+    case ChunkType.UNCOMPRESSED:
+      return ChunkType.UNCOMPRESSED;
+    case ChunkType.PADDING:
+      return ChunkType.PADDING;
+    default:
+      // https://github.com/google/snappy/blob/main/framing_format.txt#L129
+      if (value >= 0x80 && value <= 0xfd) {
+        return ChunkType.SKIPPABLE;
+      }
+      throw new Error("Unsupported snappy chunk type");
+  }
+}

package/src/encodingStrategies/sszSnappy/utils.ts

@@ -0,0 +1,7 @@
+/**
+ * Computes the worst-case compression result by SSZ-Snappy
+ */
+export function maxEncodedLen(sszLength: number): number {
+  // worst-case compression result by Snappy
+  return 32 + sszLength + sszLength / 6;
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./interface.js";
+export type {Metrics} from "./metrics.js";
+export {getMetrics} from "./metrics.js";
+export type {ReqRespOpts} from "./ReqResp.js";
+export {ReqResp} from "./ReqResp.js";
+export * from "./request/errors.js";
+export * from "./response/errors.js";
+export * from "./types.js";
+export {Encoding as ReqRespEncoding} from "./types.js"; // Expose enums renamed
+export {collectExactOne, collectMaxResponse, formatProtocolID, parseProtocolID} from "./utils/index.js";