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

package/src/request/index.ts

@@ -1,31 +1,46 @@
+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});
+}
+
 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 +79,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 +97,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 +115,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 +126,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 +153,52 @@ 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();
+    // RESP_TIMEOUT: Maximum time for complete response transfer
+    const respSignal = signal
+      ? AbortSignal.any([signal, AbortSignal.timeout(RESP_TIMEOUT)])
+      : AbortSignal.timeout(RESP_TIMEOUT);
 
-    let timeoutRESP: NodeJS.Timeout | null = null;
-
-    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);
+          }
+        }
+      }
       metrics?.outgoingClosedStreams?.inc({method});
       logger.verbose("Req  stream closed", logCtx);
     }

package/src/response/index.ts

@@ -1,5 +1,4 @@
 import {PeerId, Stream} from "@libp2p/interface";
-import {pipe} from "it-pipe";
 import {Logger, TimeoutError, withTimeout} from "@lodestar/utils";
 import {requestDecode} from "../encoders/requestDecode.js";
 import {responseEncodeError, responseEncodeSuccess} from "../encoders/responseEncode.js";
@@ -8,12 +7,12 @@ import {Metrics} from "../metrics.js";
 import {ReqRespRateLimiter} from "../rate_limiter/ReqRespRateLimiter.js";
 import {RequestError, RequestErrorCode} from "../request/errors.js";
 import {Protocol, ReqRespRequest} from "../types.js";
-import {prettyPrintPeerId} from "../utils/index.js";
+import {prettyPrintPeerId, sendChunks} from "../utils/index.js";
 import {ResponseError} from "./errors.js";
 
 export {ResponseError};
 
-// 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_REQUEST_TIMEOUT = 5 * 1000; // 5 sec
 
 export interface HandleRequestOpts {
@@ -28,7 +27,7 @@ export interface HandleRequestOpts {
   requestId?: number;
   /** Peer client type for logging and metrics: 'prysm' | 'lighthouse' */
   peerClient?: string;
-  /** Non-spec timeout from sending request until write stream closed by responder */
+  /** Timeout for reading the incoming request payload */
   requestTimeoutMs?: number;
 }
 
@@ -67,71 +66,66 @@ export async function handleRequest({
   metrics?.incomingOpenedStreams.inc({method: protocol.method});
 
   let responseError: Error | null = null;
-  await pipe(
+  let streamSendError: Error | null = null;
+
+  try {
     // Yields success chunks and error chunks in the same generator
-    // This syntax allows to recycle stream.sink to send success and error chunks without returning
+    // This syntax allows to recycle stream to send success and error chunks without returning
     // in case request whose body is a List fails at chunk_i > 0, without breaking out of the for..await..of
-    (async function* requestHandlerSource() {
-      try {
-        // TODO: Does the TTFB timer start on opening stream or after receiving request
-        const timerTTFB = metrics?.outgoingResponseTTFB.startTimer({method: protocol.method});
-
-        const requestBody = await withTimeout(
-          () => pipe(stream.source, requestDecode(protocol)),
-          REQUEST_TIMEOUT,
-          signal
-        ).catch((e: unknown) => {
-          if (e instanceof TimeoutError) {
-            throw e; // Let outter catch (_e) {} re-type the error as SERVER_ERROR
+    await sendChunks(
+      stream,
+      (async function* requestHandlerSource() {
+        try {
+          const requestBody = await withTimeout(
+            (timeoutAndParentSignal) => requestDecode(protocol, stream, timeoutAndParentSignal),
+            REQUEST_TIMEOUT,
+            signal
+          ).catch((e: unknown) => {
+            if (e instanceof TimeoutError) {
+              throw e; // Let outer catch re-type the error as SERVER_ERROR
+            }
+            throw new ResponseError(RespStatus.INVALID_REQUEST, (e as Error).message);
+          });
+
+          logger.debug("Req  received", logCtx);
+
+          // Max count by request for byRange and byRoot
+          const requestCount = protocol?.inboundRateLimits?.getRequestCount?.(requestBody) ?? 1;
+
+          if (!rateLimiter.allows(peerId, protocolID, requestCount)) {
+            throw new RequestError({code: RequestErrorCode.REQUEST_RATE_LIMITED});
           }
-          throw new ResponseError(RespStatus.INVALID_REQUEST, (e as Error).message);
-        });
 
-        logger.debug("Req  received", logCtx);
+          const requestChunk: ReqRespRequest = {
+            data: requestBody,
+            version: protocol.version,
+          };
 
-        // Max count by request for byRange and byRoot
-        const requestCount = protocol?.inboundRateLimits?.getRequestCount?.(requestBody) ?? 1;
+          yield* responseEncodeSuccess(protocol, protocol.handler(requestChunk, peerId, peerClient));
+        } catch (e) {
+          const status = e instanceof ResponseError ? e.status : RespStatus.SERVER_ERROR;
+          yield* responseEncodeError(protocol, status, (e as Error).message);
 
-        if (!rateLimiter.allows(peerId, protocolID, requestCount)) {
-          throw new RequestError({code: RequestErrorCode.REQUEST_RATE_LIMITED});
+          responseError = e as Error;
         }
+      })(),
+      signal
+    );
+  } catch (e) {
+    streamSendError = e as Error;
+    throw e;
+  } finally {
+    if (streamSendError) {
+      stream.abort(streamSendError);
+    } else {
+      await stream.close().catch((e) => {
+        stream.abort(e as Error);
+      });
+    }
+    metrics?.incomingClosedStreams.inc({method: protocol.method});
+  }
 
-        const requestChunk: ReqRespRequest = {
-          data: requestBody,
-          version: protocol.version,
-        };
-
-        yield* pipe(
-          // TODO: Debug the reason for type conversion here
-          protocol.handler(requestChunk, peerId, peerClient),
-          // NOTE: Do not log the resp chunk contents, logs get extremely cluttered
-          // Note: Not logging on each chunk since after 1 year it hasn't add any value when debugging
-          // onChunk(() => logger.debug("Resp sending chunk", logCtx)),
-          responseEncodeSuccess(protocol, {
-            onChunk(chunkIndex) {
-              if (chunkIndex === 0) timerTTFB?.();
-            },
-          })
-        );
-      } catch (e) {
-        const status = e instanceof ResponseError ? e.status : RespStatus.SERVER_ERROR;
-        yield* responseEncodeError(protocol, status, (e as Error).message);
-
-        // Should not throw an error here or libp2p-mplex throws with 'AbortError: stream reset'
-        // throw e;
-        responseError = e as Error;
-      }
-    })(),
-    stream.sink
-  );
-
-  // If streak.sink throws, libp2p-mplex will close stream.source
-  // If `requestDecode()` throws the stream.source must be closed manually
-  // To ensure the stream.source it-pushable instance is always closed, stream.close() is called always
-  await stream.close();
-  metrics?.incomingClosedStreams.inc({method: protocol.method});
-
-  // TODO: It may happen that stream.sink returns before returning stream.source first,
+  // TODO: It may happen that the response write completes before the request is fully read,
   // so you never see "Resp received request" in the logs and the response ends without
   // sending any chunk, triggering EMPTY_RESPONSE error on the requesting side
   // It has only happened when doing a request too fast upon immediate connection on inbound peer

package/src/types.ts

@@ -4,11 +4,9 @@ import {ForkName} from "@lodestar/params";
 import {LodestarError} from "@lodestar/utils";
 import {RateLimiterQuota} from "./rate_limiter/rateLimiterGRCA.js";
 
-export const protocolPrefix = "/eth2/beacon_chain/req";
-
 /**
  * Available request/response encoding strategies:
- * 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
  */
 export enum Encoding {
   SSZ_SNAPPY = "ssz_snappy",

package/src/utils/collectMaxResponse.ts

@@ -6,12 +6,11 @@
  * Collects a bounded list of responses up to `maxResponses`
  */
 export async function collectMaxResponse<T>(source: AsyncIterable<T>, maxResponses: number): Promise<T[]> {
-  // else: zero or more responses
   const responses: T[] = [];
   for await (const response of source) {
     responses.push(response);
 
-    if (maxResponses !== undefined && responses.length >= maxResponses) {
+    if (responses.length >= maxResponses) {
       break;
     }
   }

package/src/utils/errorMessage.ts

@@ -1,8 +1,7 @@
 import {decode as varintDecode, encodingLength as varintEncodingLength} from "uint8-varint";
-import {Uint8ArrayList} from "uint8arraylist";
 import {writeSszSnappyPayload} from "../encodingStrategies/sszSnappy/encode.js";
 import {Encoding} from "../types.js";
-import {SnappyFramesUncompress} from "./snappyIndex.js";
+import {decodeSnappyFrames} from "./snappyIndex.js";
 
 // ErrorMessage schema:
 //
@@ -13,18 +12,21 @@ import {SnappyFramesUncompress} from "./snappyIndex.js";
 // By convention, the error_message is a sequence of bytes that MAY be interpreted as a
 // UTF-8 string (for debugging purposes). Clients MUST treat as valid any byte sequences
 //
-// Spec v1.1.10 https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#responding-side
+// https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/phase0/p2p-interface.md#responding-side
 
 /**
  * Encodes a UTF-8 string to 256 bytes max
  */
-export async function* encodeErrorMessage(errorMessage: string, encoding: Encoding): AsyncGenerator<Buffer> {
+export function* encodeErrorMessage(errorMessage: string, encoding: Encoding): Generator<Buffer> {
   const encoder = new TextEncoder();
   const bytes = encoder.encode(errorMessage).slice(0, 256);
 
   switch (encoding) {
     case Encoding.SSZ_SNAPPY:
       yield* writeSszSnappyPayload(bytes);
+      break;
+    default:
+      throw Error("Unsupported encoding");
   }
 }
 
@@ -32,9 +34,9 @@ export async function* encodeErrorMessage(errorMessage: string, encoding: Encodi
  * Encodes a UTF-8 error message string into a single buffer (max 256 bytes before encoding).
  * Unlike `encodeErrorMessage`, this collects all encoded chunks into one buffer.
  */
-export async function encodeErrorMessageToBuffer(errorMessage: string, encoding: Encoding): Promise<Buffer> {
+export function encodeErrorMessageToBuffer(errorMessage: string, encoding: Encoding): Buffer {
   const chunks: Buffer[] = [];
-  for await (const chunk of encodeErrorMessage(errorMessage, encoding)) {
+  for (const chunk of encodeErrorMessage(errorMessage, encoding)) {
     chunks.push(chunk);
   }
   return Buffer.concat(chunks);
@@ -43,21 +45,20 @@ export async function encodeErrorMessageToBuffer(errorMessage: string, encoding:
 /**
  * Decodes error message from network bytes and removes non printable, non ascii characters.
  */
-export async function decodeErrorMessage(encodedErrorMessage: Uint8Array): Promise<string> {
-  const encoder = new TextDecoder();
+export function decodeErrorMessage(encodedErrorMessage: Uint8Array): string {
+  const decoder = new TextDecoder();
   let sszDataLength: number;
   try {
     sszDataLength = varintDecode(encodedErrorMessage);
-    const decompressor = new SnappyFramesUncompress();
     const varintBytes = varintEncodingLength(sszDataLength);
-    const errorMessage = decompressor.uncompress(new Uint8ArrayList(encodedErrorMessage.subarray(varintBytes)));
-    if (errorMessage == null || errorMessage.length !== sszDataLength) {
+    const errorMessage = decodeSnappyFrames(encodedErrorMessage.subarray(varintBytes));
+    if (errorMessage.length !== sszDataLength) {
       throw new Error("Malformed input: data length mismatch");
     }
     // remove non ascii characters from string
-    return encoder.decode(errorMessage.subarray(0)).replace(/[^\x20-\x7F]/g, "");
+    return decoder.decode(errorMessage.subarray(0)).replace(/[^\x20-\x7F]/g, "");
   } catch (_e) {
     // remove non ascii characters from string
-    return encoder.decode(encodedErrorMessage.slice(0, 256)).replace(/[^\x20-\x7F]/g, "");
+    return decoder.decode(encodedErrorMessage.slice(0, 256)).replace(/[^\x20-\x7F]/g, "");
   }
 }

package/src/utils/index.ts

@@ -1,9 +1,7 @@
-export * from "./abortableSource.js";
-export * from "./bufferedSource.js";
 export * from "./collectExactOne.js";
 export * from "./collectMaxResponse.js";
 export * from "./errorMessage.js";
-export * from "./onChunk.js";
 export * from "./peerId.js";
 export * from "./protocolId.js";
 export * from "./snappyIndex.js";
+export * from "./stream.js";

package/src/utils/protocolId.ts

@@ -1,14 +1,14 @@
 import {Encoding, ProtocolAttributes} from "../types.js";
 
 /**
- * https://github.com/ethereum/consensus-specs/blob/v1.2.0/specs/phase0/p2p-interface.md#protocol-identification
+ * https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/phase0/p2p-interface.md#protocol-identification
  */
 export function formatProtocolID(protocolPrefix: string, method: string, version: number, encoding: Encoding): string {
   return `${protocolPrefix}/${method}/${version}/${encoding}`;
 }
 
 /**
- * https://github.com/ethereum/consensus-specs/blob/v1.2.0/specs/phase0/p2p-interface.md#protocol-identification
+ * https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/phase0/p2p-interface.md#protocol-identification
  */
 export function parseProtocolID(protocolId: string): ProtocolAttributes {
   const result = protocolId.split("/");

package/src/utils/snappyCompress.ts

@@ -3,7 +3,7 @@ import {compressSync} from "snappy";
 import {ChunkType, IDENTIFIER_FRAME, UNCOMPRESSED_CHUNK_SIZE, crc} from "./snappyCommon.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> {
+export function* encodeSnappy(bytes: Buffer): Generator<Buffer> {
   yield IDENTIFIER_FRAME;
 
   for (let i = 0; i < bytes.length; i += UNCOMPRESSED_CHUNK_SIZE) {

package/src/utils/snappyIndex.ts

@@ -1,3 +1,3 @@
 export * from "./snappyCommon.js";
 export {encodeSnappy} from "./snappyCompress.js";
-export {SnappyFramesUncompress} from "./snappyUncompress.js";
+export * from "./snappyUncompress.js";