@lodestar/reqresp 1.35.0-dev.a70bac5bd3 → 1.35.0-dev.ba92bd8a88

package/package.json

@@ -11,13 +11,15 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.35.0-dev.a70bac5bd3",
+  "version": "1.35.0-dev.ba92bd8a88",
   "type": "module",
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
       "import": "./lib/index.js"
     },
     "./utils": {
+      "bun": "./src/utils/index.ts",
       "import": "./lib/utils/index.js"
     }
   },
@@ -32,11 +34,9 @@
   },
   "types": "./lib/index.d.ts",
   "files": [
-    "lib/**/*.d.ts",
-    "lib/**/*.js",
-    "lib/**/*.js.map",
-    "*.d.ts",
-    "*.js"
+    "src",
+    "lib",
+    "!**/*.tsbuildinfo"
   ],
   "scripts": {
     "clean": "rm -rf lib && rm -f *.tsbuildinfo",
@@ -54,9 +54,9 @@
   "dependencies": {
     "@chainsafe/fast-crc32c": "^4.2.0",
     "@libp2p/interface": "^2.7.0",
-    "@lodestar/config": "1.35.0-dev.a70bac5bd3",
-    "@lodestar/params": "1.35.0-dev.a70bac5bd3",
-    "@lodestar/utils": "1.35.0-dev.a70bac5bd3",
+    "@lodestar/config": "1.35.0-dev.ba92bd8a88",
+    "@lodestar/params": "1.35.0-dev.ba92bd8a88",
+    "@lodestar/utils": "1.35.0-dev.ba92bd8a88",
     "it-all": "^3.0.4",
     "it-pipe": "^3.0.1",
     "snappy": "^7.2.2",
@@ -65,8 +65,8 @@
     "uint8arraylist": "^2.4.7"
   },
   "devDependencies": {
-    "@lodestar/logger": "1.35.0-dev.a70bac5bd3",
-    "@lodestar/types": "1.35.0-dev.a70bac5bd3",
+    "@lodestar/logger": "1.35.0-dev.ba92bd8a88",
+    "@lodestar/types": "1.35.0-dev.ba92bd8a88",
     "libp2p": "2.9.0"
   },
   "peerDependencies": {
@@ -80,5 +80,5 @@
     "reqresp",
     "blockchain"
   ],
-  "gitHead": "ed950d79939c776cb95654954528160b4afa7a2e"
+  "gitHead": "1b20674959d28aa02d63fea5358fd3332de8e88f"
 }

package/src/ReqResp.ts

@@ -0,0 +1,289 @@
+import {setMaxListeners} from "node:events";
+import {Connection, PeerId, Stream} from "@libp2p/interface";
+import type {Libp2p} from "libp2p";
+import {Logger, MetricsRegisterExtra} from "@lodestar/utils";
+import {Metrics, getMetrics} from "./metrics.js";
+import {ReqRespRateLimiter} from "./rate_limiter/ReqRespRateLimiter.js";
+import {SelfRateLimiter} from "./rate_limiter/selfRateLimiter.js";
+import {RequestError, RequestErrorCode, SendRequestOpts, sendRequest} from "./request/index.js";
+import {handleRequest} from "./response/index.js";
+import {
+  DialOnlyProtocol,
+  Encoding,
+  MixedProtocol,
+  Protocol,
+  ProtocolDescriptor,
+  ReqRespRateLimiterOpts,
+  ResponseIncoming,
+} from "./types.js";
+import {formatProtocolID} from "./utils/protocolId.js";
+
+type ProtocolID = string;
+
+export const DEFAULT_PROTOCOL_PREFIX = "/eth2/beacon_chain/req";
+
+export interface ReqRespProtocolModules {
+  libp2p: Libp2p;
+  logger: Logger;
+  metricsRegister: MetricsRegisterExtra | null;
+}
+
+export interface ReqRespOpts extends SendRequestOpts, ReqRespRateLimiterOpts {
+  /** Custom prefix for `/ProtocolPrefix/MessageName/SchemaVersion/Encoding` */
+  protocolPrefix?: string;
+  getPeerLogMetadata?: (peerId: string) => string;
+}
+
+/**
+ * Implementation of Ethereum Consensus p2p Req/Resp domain.
+ * For the spec that this code is based on, see:
+ * https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#the-reqresp-domain
+ * https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/p2p-interface.md#the-reqresp-domain
+ */
+export class ReqResp {
+  // protected to be usable by extending class
+  protected readonly libp2p: Libp2p;
+  protected readonly logger: Logger;
+  protected readonly metrics: Metrics | null;
+
+  // rate limit requests coming to this node to not be used by extending class
+  private readonly rateLimiter: ReqRespRateLimiter;
+  // rate limit requests sending to other peers
+  private readonly selfRateLimiter: SelfRateLimiter;
+
+  private controller = new AbortController();
+  /** Tracks request and responses in a sequential counter */
+  private reqCount = 0;
+  private readonly protocolPrefix: string;
+
+  /** `${protocolPrefix}/${method}/${version}/${encoding}` */
+  private readonly registeredProtocols = new Map<ProtocolID, MixedProtocol>();
+  private readonly dialOnlyProtocols = new Map<ProtocolID, boolean>();
+
+  constructor(
+    modules: ReqRespProtocolModules,
+    private readonly opts: ReqRespOpts = {}
+  ) {
+    this.libp2p = modules.libp2p;
+    this.logger = modules.logger;
+    this.metrics = modules.metricsRegister ? getMetrics(modules.metricsRegister) : null;
+    this.protocolPrefix = opts.protocolPrefix ?? DEFAULT_PROTOCOL_PREFIX;
+    this.rateLimiter = new ReqRespRateLimiter(opts);
+    this.selfRateLimiter = new SelfRateLimiter();
+
+    this.metrics?.selfRateLimiterPeerCount.addCollect(() => {
+      this.metrics?.selfRateLimiterPeerCount.set(this.selfRateLimiter.getPeerCount());
+    });
+  }
+
+  /**
+   * Register protocol which will be used only to dial to other peers
+   * The libp2p instance will not handle that protocol
+   *
+   * Made it explicit method to avoid any developer mistake
+   */
+  registerDialOnlyProtocol(protocol: DialOnlyProtocol): void {
+    const protocolID = this.formatProtocolID(protocol);
+
+    this.registeredProtocols.set(protocolID, protocol);
+    this.dialOnlyProtocols.set(protocolID, true);
+  }
+
+  /**
+   * Register protocol as supported and to libp2p.
+   * async because libp2p registrar persists the new protocol list in the peer-store.
+   * Overrides handler and rate limits in case protocol is already registered.
+   * Can be called at any time, no concept of started / stopped
+   */
+  async registerProtocol(protocol: Protocol): Promise<void> {
+    const protocolID = this.formatProtocolID(protocol);
+    const {handler: _handler, inboundRateLimits, ...rest} = protocol;
+
+    this.registerDialOnlyProtocol(rest);
+    this.dialOnlyProtocols.set(protocolID, false);
+
+    if (inboundRateLimits) {
+      this.rateLimiter.setRateLimits(protocolID, inboundRateLimits);
+    }
+
+    return this.libp2p.handle(protocolID, this.getRequestHandler(protocol, protocolID), {force: true});
+  }
+
+  /**
+   * Remove protocol as supported and from libp2p.
+   * async because libp2p registrar persists the new protocol list in the peer-store.
+   * Does NOT throw if the protocolID is unknown.
+   * Can be called at any time, no concept of started / stopped
+   */
+  async unregisterProtocol(protocolID: ProtocolID): Promise<void> {
+    this.registeredProtocols.delete(protocolID);
+
+    return this.libp2p.unhandle(protocolID);
+  }
+
+  /**
+   * Remove all registered protocols from libp2p
+   */
+  async unregisterAllProtocols(): Promise<void> {
+    for (const protocolID of this.registeredProtocols.keys()) {
+      await this.unregisterProtocol(protocolID);
+    }
+  }
+
+  getRegisteredProtocols(): ProtocolID[] {
+    return Array.from(this.registeredProtocols.values()).map((protocol) => this.formatProtocolID(protocol));
+  }
+
+  async start(): Promise<void> {
+    this.controller = new AbortController();
+    this.rateLimiter.start();
+    this.selfRateLimiter.start();
+    // We set infinity to prevent MaxListenersExceededWarning which get logged when listeners > 10
+    // Since it is perfectly fine to have listeners > 10
+    setMaxListeners(Infinity, this.controller.signal);
+  }
+
+  async stop(): Promise<void> {
+    this.rateLimiter.stop();
+    this.selfRateLimiter.stop();
+    this.controller.abort();
+  }
+
+  // Helper to reduce code duplication
+  async *sendRequest(
+    peerId: PeerId,
+    method: string,
+    versions: number[],
+    encoding: Encoding,
+    body: Uint8Array
+  ): AsyncIterable<ResponseIncoming> {
+    const peerIdStr = peerId.toString();
+    const peerClient = this.opts.getPeerLogMetadata?.(peerIdStr);
+    this.metrics?.outgoingRequests.inc({method});
+    const timer = this.metrics?.outgoingRequestRoundtripTime.startTimer({method});
+
+    const protocols: (MixedProtocol | DialOnlyProtocol)[] = [];
+    const protocolIDs: string[] = [];
+    // don't increase this.reqCount until we know request will be sent
+    const requestId = this.reqCount + 1;
+
+    for (const version of versions) {
+      const protocolID = this.formatProtocolID({method, version, encoding});
+      const protocol = this.registeredProtocols.get(protocolID);
+      if (!protocol) {
+        throw Error(`Request to send to protocol ${protocolID} but it has not been declared`);
+      }
+
+      if (!this.selfRateLimiter.allows(peerIdStr, protocolID, requestId)) {
+        // we technically don't send request in this case but would be nice just to track this in the same `outgoingErrorReasons` metric
+        this.metrics?.outgoingErrorReasons.inc({reason: RequestErrorCode.REQUEST_SELF_RATE_LIMITED});
+        throw new RequestError({code: RequestErrorCode.REQUEST_SELF_RATE_LIMITED});
+        // don't call this.onOutgoingRequestError() to penalize peer
+      }
+
+      protocols.push(protocol);
+      protocolIDs.push(protocolID);
+    }
+
+    // requestId is now the same to reqCount
+    this.reqCount++;
+
+    try {
+      yield* sendRequest(
+        {logger: this.logger, libp2p: this.libp2p, metrics: this.metrics, peerClient},
+        peerId,
+        protocols,
+        protocolIDs,
+        body,
+        this.controller.signal,
+        this.opts,
+        requestId
+      );
+    } catch (e) {
+      this.metrics?.outgoingErrors.inc({method});
+
+      if (e instanceof RequestError) {
+        if (e.type.code === RequestErrorCode.DIAL_ERROR || e.type.code === RequestErrorCode.DIAL_TIMEOUT) {
+          this.metrics?.dialErrors.inc();
+        }
+        this.metrics?.outgoingErrorReasons.inc({reason: e.type.code});
+
+        this.onOutgoingRequestError(peerId, method, e);
+      }
+
+      throw e;
+    } finally {
+      for (const protocolID of protocolIDs) {
+        this.selfRateLimiter.requestCompleted(peerIdStr, protocolID, requestId);
+      }
+      timer?.();
+    }
+  }
+
+  private getRequestHandler(protocol: MixedProtocol, protocolID: string) {
+    return async ({connection, stream}: {connection: Connection; stream: Stream}) => {
+      if (this.dialOnlyProtocols.get(protocolID)) {
+        throw new Error(`Received request on dial only protocol '${protocolID}'`);
+      }
+
+      const peerId = connection.remotePeer;
+      const peerClient = this.opts.getPeerLogMetadata?.(peerId.toString());
+      const {method} = protocol;
+
+      this.metrics?.incomingRequests.inc({method});
+      const timer = this.metrics?.incomingRequestHandlerTime.startTimer({method});
+
+      this.onIncomingRequest?.(peerId, protocol);
+
+      try {
+        await handleRequest({
+          logger: this.logger,
+          metrics: this.metrics,
+          stream,
+          peerId,
+          protocol: protocol as Protocol,
+          protocolID,
+          rateLimiter: this.rateLimiter,
+          signal: this.controller.signal,
+          requestId: this.reqCount++,
+          peerClient,
+          requestTimeoutMs: this.opts.requestTimeoutMs,
+        });
+        // TODO: Do success peer scoring here
+      } catch (err) {
+        this.metrics?.incomingErrors.inc({method});
+
+        if (err instanceof RequestError) {
+          this.onIncomingRequestError(protocol as ProtocolDescriptor, err);
+        }
+
+        // TODO: Do error peer scoring here
+        // Must not throw since this is an event handler
+      } finally {
+        timer?.();
+      }
+    };
+  }
+
+  protected onIncomingRequest(_peerId: PeerId, _protocol: ProtocolDescriptor): void {
+    // Override
+  }
+
+  protected onIncomingRequestError(_protocol: ProtocolDescriptor, _error: RequestError): void {
+    // Override
+  }
+
+  protected onOutgoingRequestError(_peerId: PeerId, _method: string, _error: RequestError): void {
+    // Override
+  }
+
+  /**
+   * ```
+   * /ProtocolPrefix/MessageName/SchemaVersion/Encoding
+   * ```
+   * https://github.com/ethereum/consensus-specs/blob/v1.2.0/specs/phase0/p2p-interface.md#protocol-identification
+   */
+  protected formatProtocolID(protocol: Pick<MixedProtocol, "method" | "version" | "encoding">): string {
+    return formatProtocolID(this.protocolPrefix, protocol.method, protocol.version, protocol.encoding);
+  }
+}

package/src/encoders/requestDecode.ts

@@ -0,0 +1,29 @@
+import type {Sink} from "it-stream-types";
+import {Uint8ArrayList} from "uint8arraylist";
+import {readEncodedPayload} from "../encodingStrategies/index.js";
+import {MixedProtocol} from "../types.js";
+import {BufferedSource} from "../utils/index.js";
+
+const EMPTY_DATA = new Uint8Array();
+
+/**
+ * Consumes a stream source to read a `<request>`
+ * ```bnf
+ * request  ::= <encoding-dependent-header> | <encoded-payload>
+ * ```
+ */
+export function requestDecode(
+  protocol: MixedProtocol
+): Sink<AsyncIterable<Uint8Array | Uint8ArrayList>, Promise<Uint8Array>> {
+  return async function requestDecodeSink(source) {
+    const type = protocol.requestSizes;
+    if (type === null) {
+      // method has no body
+      return EMPTY_DATA;
+    }
+
+    // Request has a single payload, so return immediately
+    const bufferedSource = new BufferedSource(source as AsyncGenerator<Uint8ArrayList>);
+    return readEncodedPayload(bufferedSource, protocol.encoding, type);
+  };
+}

package/src/encoders/requestEncode.ts

@@ -0,0 +1,18 @@
+import {writeEncodedPayload} from "../encodingStrategies/index.js";
+import {MixedProtocol} from "../types.js";
+
+/**
+ * Yields byte chunks for a `<request>`
+ * ```bnf
+ * request  ::= <encoding-dependent-header> | <encoded-payload>
+ * ```
+ * Requests may contain no payload (e.g. /eth2/beacon_chain/req/metadata/1/)
+ * if so, it would yield no byte chunks
+ */
+export async function* requestEncode(protocol: MixedProtocol, requestBody: Uint8Array): AsyncGenerator<Buffer> {
+  const type = protocol.requestSizes;
+
+  if (type && requestBody !== null) {
+    yield* writeEncodedPayload(requestBody, protocol.encoding);
+  }
+}

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");
+  }
+}