@lodestar/reqresp 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/request/index.ts

@@ -1,225 +0,0 @@
-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 {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
-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
-
-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;
-}
-
-type SendRequestModules = {
-  logger: Logger;
-  libp2p: Libp2p;
-  metrics: Metrics | null;
-  peerClient?: string;
-};
-
-/**
- * Sends ReqResp request to a peer. Throws on error. Logs each step of the request lifecycle.
- *
- * 1. Dial peer, establish duplex stream
- * 2. Encoded and write request to peer. Expect the responder to close the stream's write side
- * 3. Read and decode reponse(s) from peer. Will close the read stream if:
- *    - An error result is received in one of the chunks. Reads the error_message and throws.
- *    - The responder closes the stream. If at the end or start of a <response_chunk>, return. Otherwise throws
- *    - Any part of the response_chunk fails validation. Throws a typed error (see `SszSnappyError`)
- *    - The maximum number of requested chunks are read. Does not throw, returns read chunks only.
- */
-export async function* sendRequest(
-  {logger, libp2p, metrics, peerClient}: SendRequestModules,
-  peerId: PeerId,
-  protocols: MixedProtocol[],
-  protocolIDs: string[],
-  requestBody: Uint8Array,
-  signal?: AbortSignal,
-  opts?: SendRequestOpts,
-  requestId = 0
-): AsyncIterable<ResponseIncoming> {
-  if (protocols.length === 0) {
-    throw Error("sendRequest must set > 0 protocols");
-  }
-
-  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);
-  const {method, encoding, version} = protocols[0];
-  const logCtx = {method, version, encoding, client: peerClient, peer: peerIdStrShort, requestId};
-
-  if (signal?.aborted) {
-    throw new ErrorAborted("sendRequest");
-  }
-
-  logger.debug("Req  dialing peer", logCtx);
-
-  try {
-    // From Altair block query methods have V1 and V2. Both protocols should be requested.
-    // On stream negotiation `libp2p.dialProtocol` will pick the available protocol and return
-    // 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());
-        const conn = await libp2p.dialProtocol(peerId, protocolIds, {signal: timeoutAndParentSignal});
-        if (!conn) throw Error("dialProtocol timeout");
-        return conn;
-      },
-      DIAL_TIMEOUT,
-      signal
-    ).catch((e: Error) => {
-      if (e instanceof TimeoutError) {
-        throw new RequestError({code: RequestErrorCode.DIAL_TIMEOUT});
-      }
-      throw new RequestError({code: RequestErrorCode.DIAL_ERROR, error: e});
-    });
-
-    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);
-    if (!protocol) throw Error(`dialProtocol selected unknown protocolId ${protocolId}`);
-
-    // Override with actual version that was negotiated
-    logCtx.version = protocol.version;
-
-    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});
-      }
-    );
-
-    logger.debug("Req  request sent", logCtx);
-
-    // For goodbye method peers may disconnect before completing the response and trigger multiple errors.
-    // Do not expect them to reply and successfully return early
-    if (protocol.ignoreResponse) {
-      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();
-
-    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);
-    };
-
-    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();
-          },
-        })
-      );
-
-      // 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);
-    } 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();
-      metrics?.outgoingClosedStreams?.inc({method});
-      logger.verbose("Req  stream closed", logCtx);
-    }
-  } catch (e) {
-    logger.verbose("Req  error", logCtx, e as Error);
-
-    if (e instanceof ResponseError) {
-      throw new RequestError(responseStatusErrorToRequestError(e));
-    }
-    throw e;
-  }
-}

package/src/response/errors.ts

@@ -1,50 +0,0 @@
-import {LodestarError, LodestarErrorMetaData, LodestarErrorObject} from "@lodestar/utils";
-import {RespStatus, RpcResponseStatusError} from "../interface.js";
-
-type RpcResponseStatusNotSuccess = Exclude<RespStatus, RespStatus.SUCCESS>;
-
-export enum ResponseErrorCode {
-  RESPONSE_STATUS_ERROR = "RESPONSE_STATUS_ERROR",
-}
-
-type RequestErrorType = {
-  code: ResponseErrorCode;
-  status: RpcResponseStatusError;
-  errorMessage: string;
-};
-
-export const RESPONSE_ERROR_CLASS_NAME = "ResponseError";
-
-/**
- * Used internally only to signal a response status error. Since the error should never bubble up to the user,
- * the error code and error message does not matter much.
- */
-export class ResponseError extends LodestarError<RequestErrorType> {
-  status: RpcResponseStatusNotSuccess;
-  errorMessage: string;
-  constructor(status: RpcResponseStatusNotSuccess, errorMessage: string, stack?: string) {
-    const type = {code: ResponseErrorCode.RESPONSE_STATUS_ERROR, status, errorMessage};
-    super(type, `RESPONSE_ERROR_${RespStatus[status]}: ${errorMessage}`, stack);
-    this.status = status;
-    this.errorMessage = errorMessage;
-  }
-
-  getMetadata(): LodestarErrorMetaData {
-    return {
-      status: this.status,
-      errorMessage: this.errorMessage,
-    };
-  }
-
-  static fromObject(obj: LodestarErrorObject): ResponseError {
-    if (obj.className !== RESPONSE_ERROR_CLASS_NAME) {
-      throw new Error(`Expected className to be ResponseError, but got ${obj.className}`);
-    }
-
-    return new ResponseError(
-      obj.type.status as RpcResponseStatusNotSuccess,
-      obj.type.errorMessage as string,
-      obj.stack
-    );
-  }
-}

package/src/response/index.ts

@@ -1,147 +0,0 @@
-import {PeerId, Stream} from "@libp2p/interface";
-import {pipe} from "it-pipe";
-import {Uint8ArrayList} from "uint8arraylist";
-import {Logger, TimeoutError, withTimeout} from "@lodestar/utils";
-import {requestDecode} from "../encoders/requestDecode.js";
-import {responseEncodeError, responseEncodeSuccess} from "../encoders/responseEncode.js";
-import {RespStatus} from "../interface.js";
-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 {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
-export const DEFAULT_REQUEST_TIMEOUT = 5 * 1000; // 5 sec
-
-export interface HandleRequestOpts {
-  logger: Logger;
-  metrics: Metrics | null;
-  stream: Stream;
-  peerId: PeerId;
-  protocol: Protocol;
-  protocolID: string;
-  rateLimiter: ReqRespRateLimiter;
-  signal?: AbortSignal;
-  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 */
-  requestTimeoutMs?: number;
-}
-
-/**
- * Handles a ReqResp request from a peer. Throws on error. Logs each step of the response lifecycle.
- *
- * 1. A duplex `stream` with the peer is already available
- * 2. Read and decode request from peer
- * 3. Delegate to `performRequestHandler()` to perform the request job and expect
- *    to yield zero or more `<response_chunks>`
- * 4a. Encode and write `<response_chunks>` to peer
- * 4b. On error, encode and write an error `<response_chunk>` and stop
- */
-export async function handleRequest({
-  logger,
-  metrics,
-  stream,
-  peerId,
-  protocol,
-  protocolID,
-  rateLimiter,
-  signal,
-  requestId = 0,
-  peerClient = "unknown",
-  requestTimeoutMs,
-}: HandleRequestOpts): Promise<void> {
-  const REQUEST_TIMEOUT = requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT;
-
-  const logCtx = {
-    method: protocol.method,
-    version: protocol.version,
-    client: peerClient,
-    peer: prettyPrintPeerId(peerId),
-    requestId,
-  };
-  metrics?.incomingOpenedStreams.inc({method: protocol.method});
-
-  let responseError: Error | null = null;
-  await pipe(
-    // 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
-    // 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 as AsyncIterable<Uint8ArrayList>, 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
-          }
-          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});
-        }
-
-        const requestChunk: ReqRespRequest = {
-          data: requestBody,
-          version: protocol.version,
-        };
-
-        yield* pipe(
-          // TODO: Debug the reason for type conversion here
-          protocol.handler(requestChunk, peerId),
-          // 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,
-  // 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
-  // investigate a potential race condition there
-
-  if (responseError !== null) {
-    logger.verbose("Resp error", logCtx, responseError);
-    throw responseError;
-  }
-  // NOTE: Only log once per request to verbose, intermediate steps to debug
-  logger.verbose("Resp done", logCtx);
-}

package/src/types.ts

@@ -1,158 +0,0 @@
-import {PeerId} from "@libp2p/interface";
-import {BeaconConfig, ForkBoundary} from "@lodestar/config";
-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
- */
-export enum Encoding {
-  SSZ_SNAPPY = "ssz_snappy",
-}
-
-export const CONTEXT_BYTES_FORK_DIGEST_LENGTH = 4;
-
-/**
- * Wrapper for the request/response payload
- */
-export type ResponseIncoming = {
-  data: Uint8Array;
-  fork: ForkName;
-  protocolVersion: number;
-};
-
-export type ResponseOutgoing = {
-  data: Uint8Array;
-  /**
-   * Reason why outgoing needs fork boundary but incoming only needs fork is because we can deserialize incoming data
-   * with only fork info, but for outgoing we also need to compute fork digest, which requires fork boundary.
-   */
-  boundary: ForkBoundary;
-};
-
-/**
- * Rate limiter options for the requests
- */
-export interface ReqRespRateLimiterOpts {
-  rateLimitMultiplier?: number;
-  onRateLimit?: (peer: PeerId, method: string) => void;
-}
-
-/**
- * Inbound rate limiter quota for the protocol
- */
-export interface InboundRateLimitQuota {
-  /**
-   * Will be tracked for the protocol per peer
-   */
-  byPeer?: RateLimiterQuota;
-  /**
-   * Will be tracked regardless of the peer
-   */
-  total?: RateLimiterQuota;
-  /**
-   * Some requests may be counted multiple e.g. getBlocksByRange
-   * for such implement this method else `1` will be used default
-   */
-  getRequestCount?: (req: Uint8Array) => number;
-}
-
-export type ReqRespRequest = {
-  data: Uint8Array;
-  version: number;
-};
-
-/**
- * Request handler
- */
-export type ProtocolHandler = (req: ReqRespRequest, peerId: PeerId) => AsyncIterable<ResponseOutgoing>;
-
-/**
- * ReqResp Protocol Deceleration
- */
-export interface ProtocolAttributes {
-  readonly protocolPrefix: string;
-  /** Protocol name identifier `beacon_blocks_by_range` or `status` */
-  readonly method: string;
-  /** Version counter: `1`, `2` etc */
-  readonly version: number;
-  readonly encoding: Encoding;
-}
-
-export interface ProtocolDescriptor extends Omit<ProtocolAttributes, "protocolPrefix"> {
-  contextBytes: ContextBytesFactory;
-  ignoreResponse?: boolean;
-}
-
-// `protocolPrefix` is added runtime so not part of definition
-/**
- * ReqResp Protocol definition for full duplex protocols
- */
-export interface Protocol extends ProtocolDescriptor {
-  handler: ProtocolHandler;
-  inboundRateLimits?: InboundRateLimitQuota;
-  requestSizes: TypeSizes | null;
-  responseSizes: (fork: ForkName) => TypeSizes;
-}
-
-/**
- * ReqResp Protocol definition for dial only protocols
- */
-export interface DialOnlyProtocol extends Omit<Protocol, "handler" | "inboundRateLimits" | "renderRequestBody"> {
-  handler?: never;
-  inboundRateLimits?: never;
-  renderRequestBody?: never;
-}
-
-/**
- * ReqResp Protocol definition for full duplex and dial only protocols
- */
-export type MixedProtocol = DialOnlyProtocol | Protocol;
-
-/**
- * ReqResp protocol definition descriptor for full duplex and dial only protocols
- * If handler is not provided, the protocol will be dial only
- * If handler is provided, the protocol will be full duplex
- */
-export type MixedProtocolGenerators = <H extends ProtocolHandler | undefined = undefined>(
-  // "inboundRateLimiter" is available only on handler context not on generator
-  modules: {config: BeaconConfig},
-  handler?: H
-) => H extends undefined ? DialOnlyProtocol : Protocol;
-
-/**
- * ReqResp protocol definition descriptor for full duplex protocols
- */
-export type ProtocolGenerator = (modules: {config: BeaconConfig}, handler: ProtocolHandler) => Protocol;
-
-export type HandlerTypeFromMessage<T> = T extends ProtocolGenerator ? ProtocolHandler : never;
-
-export type ContextBytesFactory =
-  | {type: ContextBytesType.Empty}
-  | {type: ContextBytesType.ForkDigest; config: BeaconConfig};
-
-export type ContextBytes = {type: ContextBytesType.Empty} | {type: ContextBytesType.ForkDigest; fork: ForkName};
-
-export enum ContextBytesType {
-  /** 0 bytes chunk, can be ignored */
-  Empty,
-  /** A fixed-width 4 byte <context-bytes>, set to the ForkDigest matching the chunk: compute_fork_digest(fork_version, genesis_validators_root) */
-  ForkDigest,
-}
-
-export enum LightClientServerErrorCode {
-  RESOURCE_UNAVAILABLE = "RESOURCE_UNAVAILABLE",
-}
-
-export type LightClientServerErrorType = {code: LightClientServerErrorCode.RESOURCE_UNAVAILABLE};
-
-export class LightClientServerError extends LodestarError<LightClientServerErrorType> {}
-
-export type TypeSizes = {
-  maxSize: number;
-  minSize: number;
-};

package/src/utils/abortableSource.ts

@@ -1,80 +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<T>(
-  sourceArg: AsyncIterable<T>,
-  signals: {
-    signal: AbortSignal;
-    getError: () => Error;
-  }[]
-): AsyncIterable<T> {
-  const source = sourceArg as AsyncGenerator<T>;
-
-  async function* abortable(): AsyncIterable<T> {
-    // Handler that will hold a reference to the `abort()` promise,
-    // necessary for the signal abort listeners to reject the iterable promise
-    let nextAbortHandler: ((error: Error) => void) | null = null;
-
-    // For each signal register an abortHandler(), and prepare clean-up with `onDoneCbs`
-    const onDoneCbs: (() => void)[] = [];
-    for (const {signal, getError} of signals) {
-      const abortHandler = (): void => {
-        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<never>((_, 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();
-}