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

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";

package/src/utils/snappyUncompress.ts

@@ -2,96 +2,94 @@ import {uncompress} from "snappyjs";
 import {Uint8ArrayList} from "uint8arraylist";
 import {ChunkType, IDENTIFIER, UNCOMPRESSED_CHUNK_SIZE, crc} from "./snappyCommon.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;
+export function parseSnappyFrameHeader(header: Uint8Array): {type: ChunkType; frameSize: number} {
+  if (header.length !== 4) {
+    throw new Error("malformed input: incomplete frame header");
+  }
 
-      const type = getChunkType(this.buffer.get(0));
+  const type = getChunkType(header[0]);
+  const frameSize = header[1] + (header[2] << 8) + (header[3] << 16);
+  return {type, frameSize};
+}
 
-      if (!this.state.foundIdentifier && type !== ChunkType.IDENTIFIER) {
-        throw "malformed input: must begin with an identifier";
+export function decodeSnappyFrameData(type: ChunkType, frame: Uint8Array): Uint8Array | null {
+  switch (type) {
+    case ChunkType.IDENTIFIER: {
+      if (!Buffer.prototype.equals.call(frame, IDENTIFIER)) {
+        throw new Error("malformed input: bad identifier");
+      }
+      return null;
+    }
+    case ChunkType.PADDING:
+    case ChunkType.SKIPPABLE:
+      return null;
+    case ChunkType.COMPRESSED: {
+      if (frame.length < 4) {
+        throw new Error("malformed input: too short");
       }
 
-      const frameSize = getFrameSize(this.buffer, 1);
+      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 new Error("malformed input: bad checksum");
+      }
+      return uncompressed;
+    }
+    case ChunkType.UNCOMPRESSED: {
+      if (frame.length < 4) {
+        throw new Error("malformed input: too short");
+      }
 
-      if (this.buffer.length - 4 < frameSize) {
-        break;
+      const checksum = frame.subarray(0, 4);
+      const uncompressed = frame.subarray(4);
+      if (uncompressed.length > UNCOMPRESSED_CHUNK_SIZE) {
+        throw new Error("malformed input: too large");
+      }
+      if (crc(uncompressed).compare(checksum) !== 0) {
+        throw new Error("malformed input: bad checksum");
       }
+      return uncompressed;
+    }
+  }
+}
 
-      const frame = this.buffer.subarray(4, 4 + frameSize);
-      this.buffer.consume(4 + frameSize);
+export function decodeSnappyFrames(data: Uint8Array): Uint8ArrayList {
+  const out = new Uint8ArrayList();
+  let foundIdentifier = false;
+  let offset = 0;
 
-      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);
+  while (offset < data.length) {
+    const remaining = data.length - offset;
+    if (remaining < 4) {
+      throw new Error("malformed input: incomplete frame header");
+    }
 
-          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);
+    const {type, frameSize} = parseSnappyFrameHeader(data.subarray(offset, offset + 4));
+    if (!foundIdentifier && type !== ChunkType.IDENTIFIER) {
+      throw new Error("malformed input: must begin with an identifier");
+    }
 
-          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;
-        }
-      }
+    offset += 4;
+
+    if (data.length - offset < frameSize) {
+      throw new Error("malformed input: incomplete frame");
     }
-    if (result.length === 0) {
-      return null;
+
+    const frame = data.subarray(offset, offset + frameSize);
+    offset += frameSize;
+
+    if (type === ChunkType.IDENTIFIER) {
+      foundIdentifier = true;
     }
-    return result;
-  }
 
-  reset(): void {
-    this.buffer = new Uint8ArrayList();
-    this.state = {
-      foundIdentifier: false,
-    };
+    const uncompressed = decodeSnappyFrameData(type, frame);
+    if (uncompressed !== null) {
+      out.append(uncompressed);
+    }
   }
-}
-
-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);
+  return out;
 }
 
 function getChunkType(value: number): ChunkType {

package/src/utils/stream.ts

@@ -0,0 +1,34 @@
+import type {Stream} from "@libp2p/interface";
+import {ByteStream} from "@libp2p/utils";
+import {Uint8ArrayList} from "uint8arraylist";
+import {ErrorAborted} from "@lodestar/utils";
+
+export async function sendChunks(
+  stream: Stream,
+  source: Iterable<Uint8Array | Uint8ArrayList> | AsyncIterable<Uint8Array | Uint8ArrayList>,
+  signal?: AbortSignal
+): Promise<void> {
+  for await (const chunk of source) {
+    if (signal?.aborted) {
+      throw new ErrorAborted("sendChunks");
+    }
+
+    if (!stream.send(chunk)) {
+      await stream.onDrain({signal});
+    }
+  }
+}
+
+export function drainByteStream(bytes: ByteStream<Stream>): Uint8Array | undefined {
+  const readBuffer = (
+    bytes as unknown as {
+      readBuffer?: {byteLength: number; subarray: () => Uint8Array; consume: (bytes: number) => void};
+    }
+  ).readBuffer;
+  if (readBuffer && readBuffer.byteLength > 0) {
+    const drained = readBuffer.subarray();
+    readBuffer.consume(readBuffer.byteLength);
+    return drained;
+  }
+  return undefined;
+}

package/lib/utils/abortableSource.d.ts

@@ -1,12 +0,0 @@
-/**
- * Wraps an AsyncIterable and rejects early if any signal aborts.
- * Throws the error returned by `getError()` of each signal options.
- *
- * Simplified fork of `"abortable-iterator"`.
- * Read function's source for reasoning of the fork.
- */
-export declare function abortableSource<T>(sourceArg: AsyncIterable<T>, signals: {
-    signal: AbortSignal;
-    getError: () => Error;
-}[]): AsyncIterable<T>;
-//# sourceMappingURL=abortableSource.d.ts.map

package/lib/utils/abortableSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"abortableSource.d.ts","sourceRoot":"","sources":["../../src/utils/abortableSource.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE;IACP,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,KAAK,CAAC;CACvB,EAAE,GACF,aAAa,CAAC,CAAC,CAAC,CAkElB"}

package/lib/utils/abortableSource.js

@@ -1,69 +0,0 @@
-/**
- * Wraps an AsyncIterable and rejects early if any signal aborts.
- * Throws the error returned by `getError()` of each signal options.
- *
- * Simplified fork of `"abortable-iterator"`.
- * Read function's source for reasoning of the fork.
- */
-export function abortableSource(sourceArg, signals) {
-    const source = sourceArg;
-    async function* abortable() {
-        // Handler that will hold a reference to the `abort()` promise,
-        // necessary for the signal abort listeners to reject the iterable promise
-        let nextAbortHandler = null;
-        // For each signal register an abortHandler(), and prepare clean-up with `onDoneCbs`
-        const onDoneCbs = [];
-        for (const { signal, getError } of signals) {
-            const abortHandler = () => {
-                if (nextAbortHandler)
-                    nextAbortHandler(getError());
-            };
-            signal.addEventListener("abort", abortHandler);
-            onDoneCbs.push(() => {
-                signal.removeEventListener("abort", abortHandler);
-            });
-        }
-        try {
-            while (true) {
-                // Abort early if any signal is aborted
-                for (const { signal, getError } of signals) {
-                    if (signal.aborted) {
-                        throw getError();
-                    }
-                }
-                // Race the iterator and the abort signals
-                const result = await Promise.race([
-                    new Promise((_, reject) => {
-                        nextAbortHandler = (error) => reject(error);
-                    }),
-                    source.next(),
-                ]);
-                // source.next() resolved first
-                nextAbortHandler = null;
-                if (result.done) {
-                    return;
-                }
-                yield result.value;
-            }
-        }
-        catch (err) {
-            // End the iterator if it is a generator
-            if (typeof source.return === "function") {
-                // This source.return() function may never resolve depending on the source AsyncGenerator implementation.
-                // This is the main reason to fork "abortable-iterator", which caused our node to get stuck during Sync.
-                // We choose to call .return() but not await it. In general, source.return should never throw. If it does,
-                // it a problem of the source implementor, and thus logged as an unhandled rejection. If that happens,
-                // the source implementor should fix the upstream code.
-                void source.return(null);
-            }
-            throw err;
-        }
-        finally {
-            for (const cb of onDoneCbs) {
-                cb();
-            }
-        }
-    }
-    return abortable();
-}
-//# sourceMappingURL=abortableSource.js.map

package/lib/utils/abortableSource.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abortableSource.js","sourceRoot":"","sources":["../../src/utils/abortableSource.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,SAA2B,EAC3B,OAGG;IAEH,MAAM,MAAM,GAAG,SAA8B,CAAC;IAE9C,KAAK,SAAS,CAAC,CAAC,SAAS;QACvB,+DAA+D;QAC/D,0EAA0E;QAC1E,IAAI,gBAAgB,GAAoC,IAAI,CAAC;QAE7D,oFAAoF;QACpF,MAAM,SAAS,GAAmB,EAAE,CAAC;QACrC,KAAK,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,IAAI,OAAO,EAAE,CAAC;YACzC,MAAM,YAAY,GAAG,GAAS,EAAE;gBAC9B,IAAI,gBAAgB;oBAAE,gBAAgB,CAAC,QAAQ,EAAE,CAAC,CAAC;YACrD,CAAC,CAAC;YACF,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;YAC/C,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE;gBAClB,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;YACpD,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC;YACH,OAAO,IAAI,EAAE,CAAC;gBACZ,uCAAuC;gBACvC,KAAK,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,IAAI,OAAO,EAAE,CAAC;oBACzC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;wBACnB,MAAM,QAAQ,EAAE,CAAC;oBACnB,CAAC;gBACH,CAAC;gBAED,0CAA0C;gBAC1C,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC;oBAChC,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;wBAC/B,gBAAgB,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAC9C,CAAC,CAAC;oBACF,MAAM,CAAC,IAAI,EAAE;iBACd,CAAC,CAAC;gBAEH,+BAA+B;gBAC/B,gBAAgB,GAAG,IAAI,CAAC;gBAExB,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;oBAChB,OAAO;gBACT,CAAC;gBAED,MAAM,MAAM,CAAC,KAAK,CAAC;YACrB,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,wCAAwC;YACxC,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;gBACxC,yGAAyG;gBACzG,wGAAwG;gBACxG,0GAA0G;gBAC1G,sGAAsG;gBACtG,uDAAuD;gBACvD,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3B,CAAC;YAED,MAAM,GAAG,CAAC;QACZ,CAAC;gBAAS,CAAC;YACT,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;gBAC3B,EAAE,EAAE,CAAC;YACP,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,SAAS,EAAE,CAAC;AACrB,CAAC"}

package/lib/utils/bufferedSource.d.ts

@@ -1,16 +0,0 @@
-import { Uint8ArrayList } from "uint8arraylist";
-/**
- * Wraps a buffer chunk stream source with another async iterable
- * so it can be reused in multiple for..of statements.
- *
- * Uses a BufferList internally to make sure all chunks are consumed
- * when switching consumers
- */
-export declare class BufferedSource {
-    isDone: boolean;
-    private buffer;
-    private source;
-    constructor(source: AsyncGenerator<Uint8ArrayList | Uint8Array>);
-    [Symbol.asyncIterator](): AsyncIterator<Uint8ArrayList>;
-}
-//# sourceMappingURL=bufferedSource.d.ts.map

package/lib/utils/bufferedSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bufferedSource.d.ts","sourceRoot":"","sources":["../../src/utils/bufferedSource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,gBAAgB,CAAC;AAE9C;;;;;;GAMG;AACH,qBAAa,cAAc;IACzB,MAAM,UAAS;IACf,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,MAAM,CAA8C;gBAEhD,MAAM,EAAE,cAAc,CAAC,cAAc,GAAG,UAAU,CAAC;IAK/D,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,cAAc,CAAC;CA0BxD"}