@lodestar/reqresp 1.35.0-dev.e9dd48f165 → 1.35.0-dev.f45a2be721

package/src/encodingStrategies/sszSnappy/decode.ts

@@ -0,0 +1,111 @@
+import {decode as varintDecode, encodingLength as varintEncodingLength} from "uint8-varint";
+import {Uint8ArrayList} from "uint8arraylist";
+import {TypeSizes} from "../../types.js";
+import {BufferedSource} from "../../utils/index.js";
+import {SszSnappyError, SszSnappyErrorCode} from "./errors.js";
+import {SnappyFramesUncompress} from "./snappyFrames/uncompress.js";
+import {maxEncodedLen} from "./utils.js";
+
+export const MAX_VARINT_BYTES = 10;
+
+/**
+ * ssz_snappy encoding strategy reader.
+ * Consumes a stream source to read encoded header and payload as defined in the spec:
+ * ```bnf
+ * <encoding-dependent-header> | <encoded-payload>
+ * ```
+ */
+export async function readSszSnappyPayload(bufferedSource: BufferedSource, type: TypeSizes): Promise<Uint8Array> {
+  const sszDataLength = await readSszSnappyHeader(bufferedSource, type);
+
+  return readSszSnappyBody(bufferedSource, sszDataLength);
+}
+
+/**
+ * Reads `<encoding-dependent-header>` for ssz-snappy.
+ * encoding-header ::= the length of the raw SSZ bytes, encoded as an unsigned protobuf varint
+ */
+export async function readSszSnappyHeader(bufferedSource: BufferedSource, type: TypeSizes): Promise<number> {
+  for await (const buffer of bufferedSource) {
+    // Get next bytes if empty
+    if (buffer.length === 0) {
+      continue;
+    }
+
+    let sszDataLength: number;
+    try {
+      sszDataLength = varintDecode(buffer.subarray());
+    } catch (_e) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.INVALID_VARINT_BYTES_COUNT, bytes: Infinity});
+    }
+
+    // MUST validate: the unsigned protobuf varint used for the length-prefix MUST not be longer than 10 bytes
+    // encodingLength function only returns 1-8 inclusive
+    const varintBytes = varintEncodingLength(sszDataLength);
+    buffer.consume(varintBytes);
+
+    // MUST validate: the length-prefix is within the expected size bounds derived from the payload SSZ type.
+    const minSize = type.minSize;
+    const maxSize = type.maxSize;
+    if (sszDataLength < minSize) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.UNDER_SSZ_MIN_SIZE, minSize, sszDataLength});
+    }
+    if (sszDataLength > maxSize) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.OVER_SSZ_MAX_SIZE, maxSize, sszDataLength});
+    }
+
+    return sszDataLength;
+  }
+
+  throw new SszSnappyError({code: SszSnappyErrorCode.SOURCE_ABORTED});
+}
+
+/**
+ * Reads `<encoded-payload>` for ssz-snappy and decompress.
+ * The returned bytes can be SSZ deseralized
+ */
+export async function readSszSnappyBody(bufferedSource: BufferedSource, sszDataLength: number): Promise<Uint8Array> {
+  const decompressor = new SnappyFramesUncompress();
+  const uncompressedData = new Uint8ArrayList();
+  let readBytes = 0;
+
+  for await (const buffer of bufferedSource) {
+    // SHOULD NOT read more than max_encoded_len(n) bytes after reading the SSZ length-prefix n from the header
+    readBytes += buffer.length;
+    if (readBytes > maxEncodedLen(sszDataLength)) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.TOO_MUCH_BYTES_READ, readBytes, sszDataLength});
+    }
+
+    // No bytes left to consume, get next
+    if (buffer.length === 0) {
+      continue;
+    }
+
+    // stream contents can be passed through a buffered Snappy reader to decompress frame by frame
+    try {
+      const uncompressed = decompressor.uncompress(buffer);
+      buffer.consume(buffer.length);
+      if (uncompressed !== null) {
+        uncompressedData.append(uncompressed);
+      }
+    } catch (e) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.DECOMPRESSOR_ERROR, decompressorError: e as Error});
+    }
+
+    // SHOULD consider invalid reading more bytes than `n` SSZ bytes
+    if (uncompressedData.length > sszDataLength) {
+      throw new SszSnappyError({code: SszSnappyErrorCode.TOO_MANY_BYTES, sszDataLength});
+    }
+
+    // Keep reading chunks until `n` SSZ bytes
+    if (uncompressedData.length < sszDataLength) {
+      continue;
+    }
+
+    // buffer.length === n
+    return uncompressedData.subarray(0, sszDataLength);
+  }
+
+  // SHOULD consider invalid: An early EOF before fully reading the declared length-prefix worth of SSZ bytes
+  throw new SszSnappyError({code: SszSnappyErrorCode.SOURCE_ABORTED});
+}

package/src/encodingStrategies/sszSnappy/encode.ts

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

package/src/encodingStrategies/sszSnappy/errors.ts

@@ -0,0 +1,31 @@
+import {LodestarError} from "@lodestar/utils";
+
+export enum SszSnappyErrorCode {
+  /** Invalid number of bytes for protobuf varint */
+  INVALID_VARINT_BYTES_COUNT = "SSZ_SNAPPY_ERROR_INVALID_VARINT_BYTES_COUNT",
+  /** Parsed sszDataLength is under the SSZ type min size */
+  UNDER_SSZ_MIN_SIZE = "SSZ_SNAPPY_ERROR_UNDER_SSZ_MIN_SIZE",
+  /** Parsed sszDataLength is over the SSZ type max size */
+  OVER_SSZ_MAX_SIZE = "SSZ_SNAPPY_ERROR_OVER_SSZ_MAX_SIZE",
+  TOO_MUCH_BYTES_READ = "SSZ_SNAPPY_ERROR_TOO_MUCH_BYTES_READ",
+  DECOMPRESSOR_ERROR = "SSZ_SNAPPY_ERROR_DECOMPRESSOR_ERROR",
+  DESERIALIZE_ERROR = "SSZ_SNAPPY_ERROR_DESERIALIZE_ERROR",
+  SERIALIZE_ERROR = "SSZ_SNAPPY_ERROR_SERIALIZE_ERROR",
+  /** Received more bytes than specified sszDataLength */
+  TOO_MANY_BYTES = "SSZ_SNAPPY_ERROR_TOO_MANY_BYTES",
+  /** Source aborted before reading sszDataLength bytes */
+  SOURCE_ABORTED = "SSZ_SNAPPY_ERROR_SOURCE_ABORTED",
+}
+
+type SszSnappyErrorType =
+  | {code: SszSnappyErrorCode.INVALID_VARINT_BYTES_COUNT; bytes: number}
+  | {code: SszSnappyErrorCode.UNDER_SSZ_MIN_SIZE; minSize: number; sszDataLength: number}
+  | {code: SszSnappyErrorCode.OVER_SSZ_MAX_SIZE; maxSize: number; sszDataLength: number}
+  | {code: SszSnappyErrorCode.TOO_MUCH_BYTES_READ; readBytes: number; sszDataLength: number}
+  | {code: SszSnappyErrorCode.DECOMPRESSOR_ERROR; decompressorError: Error}
+  | {code: SszSnappyErrorCode.DESERIALIZE_ERROR; deserializeError: Error}
+  | {code: SszSnappyErrorCode.SERIALIZE_ERROR; serializeError: Error}
+  | {code: SszSnappyErrorCode.TOO_MANY_BYTES; sszDataLength: number}
+  | {code: SszSnappyErrorCode.SOURCE_ABORTED};
+
+export class SszSnappyError extends LodestarError<SszSnappyErrorType> {}

package/src/encodingStrategies/sszSnappy/index.ts

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

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

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

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

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

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

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

package/src/encodingStrategies/sszSnappy/utils.ts

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

package/src/index.ts

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

package/src/interface.ts

@@ -0,0 +1,26 @@
+//  Request/Response constants
+export enum RespStatus {
+  /**
+   * A normal response follows, with contents matching the expected message schema and encoding specified in the request
+   */
+  SUCCESS = 0,
+  /**
+   * The contents of the request are semantically invalid, or the payload is malformed,
+   * or could not be understood. The response payload adheres to the ErrorMessage schema
+   */
+  INVALID_REQUEST = 1,
+  /**
+   * The responder encountered an error while processing the request. The response payload adheres to the ErrorMessage schema
+   */
+  SERVER_ERROR = 2,
+  /**
+   * The responder does not have requested resource.  The response payload adheres to the ErrorMessage schema (described below). Note: This response code is only valid as a response to BlocksByRange
+   */
+  RESOURCE_UNAVAILABLE = 3,
+  /**
+   * Our node does not have bandwidth to serve requests due to either per-peer quota or total quota.
+   */
+  RATE_LIMITED = 139,
+}
+
+export type RpcResponseStatusError = Exclude<RespStatus, RespStatus.SUCCESS>;

package/src/metrics.ts

@@ -0,0 +1,95 @@
+import {MetricsRegisterExtra} from "@lodestar/utils";
+import {RequestErrorCode} from "./request/errors.js";
+
+export type Metrics = ReturnType<typeof getMetrics>;
+
+/**
+ * A collection of metrics used throughout the Gossipsub behaviour.
+ */
+export function getMetrics(register: MetricsRegisterExtra) {
+  // Using function style instead of class to prevent having to re-declare all MetricsPrometheus types.
+
+  return {
+    outgoingRequests: register.gauge<{method: string}>({
+      name: "beacon_reqresp_outgoing_requests_total",
+      help: "Counts total requests done per method",
+      labelNames: ["method"],
+    }),
+    outgoingOpenedStreams: register.counter<{method: string}>({
+      name: "beacon_reqresp_outgoing_opened_streams_total",
+      help: "Counts total opened streams per method",
+      labelNames: ["method"],
+    }),
+    outgoingClosedStreams: register.counter<{method: string}>({
+      name: "beacon_reqresp_outgoing_closed_streams_total",
+      help: "Counts total closed streams per method",
+      labelNames: ["method"],
+    }),
+    outgoingRequestRoundtripTime: register.histogram<{method: string}>({
+      name: "beacon_reqresp_outgoing_request_roundtrip_time_seconds",
+      help: "Histogram of outgoing requests round-trip time",
+      labelNames: ["method"],
+      // Spec sets RESP_TIMEOUT = 10 sec
+      buckets: [0.1, 0.2, 0.5, 1, 5, 10, 15, 60],
+    }),
+    outgoingErrors: register.gauge<{method: string}>({
+      name: "beacon_reqresp_outgoing_requests_error_total",
+      help: "Counts total failed requests done per method",
+      labelNames: ["method"],
+    }),
+    outgoingErrorReasons: register.gauge<{reason: RequestErrorCode}>({
+      name: "beacon_reqresp_outgoing_requests_error_reason_total",
+      help: "Count total outgoing request errors by reason",
+      labelNames: ["reason"],
+    }),
+    incomingRequests: register.gauge<{method: string}>({
+      name: "beacon_reqresp_incoming_requests_total",
+      help: "Counts total responses handled per method",
+      labelNames: ["method"],
+    }),
+    incomingOpenedStreams: register.counter<{method: string}>({
+      name: "beacon_reqresp_incoming_opened_streams_total",
+      help: "Counts total incoming opened streams per method",
+      labelNames: ["method"],
+    }),
+    incomingClosedStreams: register.counter<{method: string}>({
+      name: "beacon_reqresp_incoming_closed_streams_total",
+      help: "Counts total incoming closed streams per method",
+      labelNames: ["method"],
+    }),
+    incomingRequestHandlerTime: register.histogram<{method: string}>({
+      name: "beacon_reqresp_incoming_request_handler_time_seconds",
+      help: "Histogram of incoming requests internal handling time",
+      labelNames: ["method"],
+      // Spec sets RESP_TIMEOUT = 10 sec
+      buckets: [0.1, 0.2, 0.5, 1, 5, 10],
+    }),
+    incomingErrors: register.gauge<{method: string}>({
+      name: "beacon_reqresp_incoming_requests_error_total",
+      help: "Counts total failed responses handled per method",
+      labelNames: ["method"],
+    }),
+    outgoingResponseTTFB: register.histogram<{method: string}>({
+      name: "beacon_reqresp_outgoing_response_ttfb_seconds",
+      help: "Time to first byte (TTFB) for outgoing responses",
+      labelNames: ["method"],
+      // Spec sets TTFB_TIMEOUT = 5 sec
+      buckets: [0.1, 1, 5],
+    }),
+    incomingResponseTTFB: register.histogram<{method: string}>({
+      name: "beacon_reqresp_incoming_response_ttfb_seconds",
+      help: "Time to first byte (TTFB) for incoming responses",
+      labelNames: ["method"],
+      // Spec sets TTFB_TIMEOUT = 5 sec
+      buckets: [0.1, 1, 5],
+    }),
+    dialErrors: register.gauge({
+      name: "beacon_reqresp_dial_errors_total",
+      help: "Count total dial errors",
+    }),
+    selfRateLimiterPeerCount: register.gauge({
+      name: "beacon_reqresp_self_rate_limiter_peer_count",
+      help: "Count of peers tracked by the self rate limiter",
+    }),
+  };
+}

package/src/rate_limiter/ReqRespRateLimiter.ts

@@ -0,0 +1,107 @@
+import {PeerId} from "@libp2p/interface";
+import {InboundRateLimitQuota, ReqRespRateLimiterOpts} from "../types.js";
+import {RateLimiterGRCA} from "./rateLimiterGRCA.js";
+
+/** Sometimes a peer request comes AFTER libp2p disconnect event, check for such peers every 10 minutes */
+const CHECK_DISCONNECTED_PEERS_INTERVAL_MS = 10 * 60 * 1000;
+
+/** Peers don't request us for 5 mins are considered disconnected */
+const DISCONNECTED_TIMEOUT_MS = 5 * 60 * 1000;
+
+type ProtocolID = string;
+
+export class ReqRespRateLimiter {
+  private readonly rateLimitersPerPeer = new Map<ProtocolID, RateLimiterGRCA<string>>();
+  private readonly rateLimitersTotal = new Map<ProtocolID, RateLimiterGRCA<null>>();
+  /** Interval to check lastSeenMessagesByPeer */
+  private cleanupInterval: NodeJS.Timeout | undefined = undefined;
+  private rateLimitMultiplier: number;
+  /** Periodically check this to remove tracker of disconnected peers */
+  private lastSeenRequestsByPeer: Map<string, number>;
+
+  constructor(private readonly opts?: ReqRespRateLimiterOpts) {
+    this.rateLimitMultiplier = opts?.rateLimitMultiplier ?? 1;
+    this.lastSeenRequestsByPeer = new Map();
+  }
+
+  get enabled(): boolean {
+    return this.rateLimitMultiplier > 0;
+  }
+
+  setRateLimits(protocolID: ProtocolID, rateLimits: InboundRateLimitQuota): void {
+    if (!this.enabled) {
+      return;
+    }
+
+    if (rateLimits.byPeer) {
+      this.rateLimitersPerPeer.set(
+        protocolID,
+        RateLimiterGRCA.fromQuota<string>({
+          quotaTimeMs: rateLimits.byPeer.quotaTimeMs,
+          quota: rateLimits.byPeer.quota * this.rateLimitMultiplier,
+        })
+      );
+    }
+
+    if (rateLimits.total) {
+      this.rateLimitersTotal.set(
+        protocolID,
+        RateLimiterGRCA.fromQuota<null>({
+          quotaTimeMs: rateLimits.total.quotaTimeMs,
+          quota: rateLimits.total.quota * this.rateLimitMultiplier,
+        })
+      );
+    }
+  }
+
+  allows(peerId: PeerId, protocolID: string, requestCount: number): boolean {
+    if (!this.enabled) {
+      return true;
+    }
+
+    const peerIdStr = peerId.toString();
+    this.lastSeenRequestsByPeer.set(peerIdStr, Date.now());
+
+    const byPeer = this.rateLimitersPerPeer.get(protocolID);
+    const total = this.rateLimitersTotal.get(protocolID);
+
+    if ((byPeer && !byPeer.allows(peerIdStr, requestCount)) || (total && !total.allows(null, requestCount))) {
+      this.opts?.onRateLimit?.(peerId, protocolID);
+      return false;
+    }
+
+    return true;
+  }
+
+  prune(peerId: PeerId): void {
+    const peerIdStr = peerId.toString();
+    this.pruneByPeerIdStr(peerIdStr);
+  }
+
+  start(): void {
+    this.cleanupInterval = setInterval(this.checkDisconnectedPeers.bind(this), CHECK_DISCONNECTED_PEERS_INTERVAL_MS);
+  }
+
+  stop(): void {
+    if (this.cleanupInterval !== undefined) {
+      clearInterval(this.cleanupInterval);
+    }
+  }
+
+  private pruneByPeerIdStr(peerIdStr: string): void {
+    // Check for every method and version to cleanup
+    for (const method of this.rateLimitersPerPeer.values()) {
+      method.pruneByKey(peerIdStr);
+    }
+    this.lastSeenRequestsByPeer.delete(peerIdStr);
+  }
+
+  private checkDisconnectedPeers(): void {
+    const now = Date.now();
+    for (const [peerIdStr, lastSeenTime] of this.lastSeenRequestsByPeer.entries()) {
+      if (now - lastSeenTime >= DISCONNECTED_TIMEOUT_MS) {
+        this.pruneByPeerIdStr(peerIdStr);
+      }
+    }
+  }
+}