@lodestar/beacon-node 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/util/queue/errors.ts

@@ -1,14 +0,0 @@
-import {LodestarError} from "@lodestar/utils";
-
-export enum QueueErrorCode {
-  QUEUE_ABORTED = "QUEUE_ERROR_QUEUE_ABORTED",
-  QUEUE_MAX_LENGTH = "QUEUE_ERROR_QUEUE_MAX_LENGTH",
-}
-
-export type QueueErrorCodeType = {code: QueueErrorCode.QUEUE_ABORTED} | {code: QueueErrorCode.QUEUE_MAX_LENGTH};
-
-export class QueueError extends LodestarError<QueueErrorCodeType> {}
-
-export function isQueueErrorAborted(e: unknown): e is QueueError {
-  return e instanceof QueueError && e.type.code === QueueErrorCode.QUEUE_ABORTED;
-}

package/src/util/queue/fnQueue.ts

@@ -1,16 +0,0 @@
-import {JobItemQueue} from "./itemQueue.js";
-import {JobQueueOpts, QueueMetrics} from "./options.js";
-
-// biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
-type Fn<R> = (...args: any) => Promise<R>;
-
-// biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
-export class JobFnQueue extends JobItemQueue<[Fn<any>], any> {
-  constructor(opts: JobQueueOpts, metrics?: QueueMetrics) {
-    super((fn) => fn(), opts, metrics);
-  }
-
-  push<R, F extends Fn<R> = Fn<R>>(fn: F): Promise<R> {
-    return super.push(fn) as Promise<R>;
-  }
-}

package/src/util/queue/index.ts

@@ -1,4 +0,0 @@
-export {QueueError, QueueErrorCode, isQueueErrorAborted} from "./errors.js";
-export * from "./fnQueue.js";
-export * from "./itemQueue.js";
-export * from "./options.js";

package/src/util/queue/itemQueue.ts

@@ -1,128 +0,0 @@
-import {callInNextEventLoop, nextEventLoop} from "../../util/eventLoop.js";
-import {LinkedList} from "../array.js";
-import {QueueError, QueueErrorCode} from "./errors.js";
-import {JobQueueOpts, QueueMetrics, QueueType, defaultQueueOpts} from "./options.js";
-
-/**
- * JobQueue that stores arguments in the job array instead of closures.
- * Supports a single itemProcessor, for arbitrary functions use the JobFnQueue
- */
-
-// biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
-export class JobItemQueue<Args extends any[], R> {
-  private readonly opts: Required<JobQueueOpts>;
-  /**
-   * We choose to use LinkedList instead of regular array to improve shift() / push() / pop() performance.
-   * See the LinkedList benchmark for more details.
-   * */
-  private readonly jobs: LinkedList<{
-    args: Args;
-    addedTimeMs: number;
-    resolve: (result: R | PromiseLike<R>) => void;
-    reject: (error?: Error) => void;
-  }> = new LinkedList();
-  private readonly metrics?: QueueMetrics;
-  private runningJobs = 0;
-  private lastYield = 0;
-
-  constructor(
-    private readonly itemProcessor: (...args: Args) => Promise<R>,
-    opts: JobQueueOpts,
-    metrics?: QueueMetrics
-  ) {
-    this.opts = {...defaultQueueOpts, ...opts};
-    this.opts.signal.addEventListener("abort", this.abortAllJobs, {once: true});
-
-    if (metrics) {
-      this.metrics = metrics;
-      metrics.length.addCollect(() => {
-        metrics.length.set(this.jobs.length);
-        metrics.concurrency.set(this.runningJobs);
-      });
-    }
-  }
-
-  get jobLen(): number {
-    return this.jobs.length;
-  }
-
-  push(...args: Args): Promise<R> {
-    if (this.opts.signal.aborted) {
-      throw new QueueError({code: QueueErrorCode.QUEUE_ABORTED});
-    }
-
-    if (this.jobs.length + 1 > this.opts.maxLength) {
-      this.metrics?.droppedJobs.inc();
-      if (this.opts.type === QueueType.LIFO) {
-        // In LIFO queues keep the latest job and drop the oldest
-        this.jobs.shift();
-      } else {
-        // In FIFO queues drop the latest job
-        throw new QueueError({code: QueueErrorCode.QUEUE_MAX_LENGTH});
-      }
-    }
-
-    return new Promise<R>((resolve, reject) => {
-      this.jobs.push({args, resolve, reject, addedTimeMs: Date.now()});
-      if (this.jobs.length === 1 && this.opts.noYieldIfOneItem) {
-        void this.runJob();
-      } else if (this.runningJobs < this.opts.maxConcurrency) {
-        callInNextEventLoop(this.runJob);
-      }
-    });
-  }
-
-  getItems(): {args: Args; addedTimeMs: number}[] {
-    return this.jobs.map((job) => ({args: job.args, addedTimeMs: job.addedTimeMs}));
-  }
-
-  dropAllJobs = (): void => {
-    this.jobs.clear();
-  };
-
-  private runJob = async (): Promise<void> => {
-    if (this.opts.signal.aborted || this.runningJobs >= this.opts.maxConcurrency) {
-      return;
-    }
-
-    // Default to FIFO. LIFO -> pop() remove last item, FIFO -> shift() remove first item
-    const job = this.opts.type === QueueType.LIFO ? this.jobs.pop() : this.jobs.shift();
-    if (!job) {
-      return;
-    }
-
-    this.runningJobs++;
-
-    // If the job, metrics or any code below throws: the job will reject never going stale.
-    // Only downside is the job promise may be resolved twice, but that's not an issue
-    try {
-      const timer = this.metrics?.jobTime.startTimer();
-      this.metrics?.jobWaitTime.observe((Date.now() - job.addedTimeMs) / 1000);
-
-      const result = await this.itemProcessor(...job.args);
-      job.resolve(result);
-
-      if (timer) timer();
-
-      // Yield to the macro queue
-      if (Date.now() - this.lastYield > this.opts.yieldEveryMs) {
-        this.lastYield = Date.now();
-        await nextEventLoop();
-      }
-    } catch (e) {
-      job.reject(e as Error);
-    }
-
-    this.runningJobs = Math.max(0, this.runningJobs - 1);
-
-    // Potentially run a new job
-    void this.runJob();
-  };
-
-  private abortAllJobs = (): void => {
-    while (this.jobs.length > 0) {
-      const job = this.jobs.pop();
-      if (job) job.reject(new QueueError({code: QueueErrorCode.QUEUE_ABORTED}));
-    }
-  };
-}

package/src/util/queue/options.ts

@@ -1,37 +0,0 @@
-import {Gauge, GaugeExtra, Histogram} from "@lodestar/utils";
-
-export enum QueueType {
-  FIFO = "FIFO",
-  LIFO = "LIFO",
-}
-
-export type JobQueueOpts = {
-  maxLength: number;
-  /** Defaults to 1 */
-  maxConcurrency?: number;
-  /** Yield to the macro queue every at least every N milliseconds */
-  yieldEveryMs?: number;
-  signal: AbortSignal;
-  /** Defaults to FIFO */
-  type?: QueueType;
-  /**By default yield per push()*/
-  noYieldIfOneItem?: boolean;
-};
-
-export type QueueMetrics = {
-  length: GaugeExtra;
-  droppedJobs: Gauge;
-  /** Compute async utilization rate with `rate(metrics_name[1m])` */
-  jobTime: Histogram;
-  jobWaitTime: Histogram;
-  concurrency: Gauge;
-};
-
-export const defaultQueueOpts: Required<
-  Pick<JobQueueOpts, "maxConcurrency" | "yieldEveryMs" | "type" | "noYieldIfOneItem">
-> = {
-  maxConcurrency: 1,
-  yieldEveryMs: 50,
-  type: QueueType.FIFO,
-  noYieldIfOneItem: false,
-};

package/src/util/serializedCache.ts

@@ -1,20 +0,0 @@
-/**
- * A cache to store the serialized version of an object
- *
- * This is a thin wrapper around WeakMap
- */
-export class SerializedCache {
-  map: WeakMap<object, Uint8Array> = new WeakMap();
-
-  get(obj: object): Uint8Array | undefined {
-    return this.map.get(obj);
-  }
-
-  set(obj: object, serialized: Uint8Array): void {
-    this.map.set(obj, serialized);
-  }
-
-  clear(): void {
-    this.map = new WeakMap();
-  }
-}

package/src/util/set.ts

@@ -1,62 +0,0 @@
-import {LinkedList} from "./array.js";
-
-/**
- * An implementation of Set that support first() and last() method.
- */
-export class OrderedSet<T> {
-  private set: Set<T>;
-  private array: LinkedList<T>;
-
-  constructor() {
-    this.set = new Set<T>();
-    this.array = new LinkedList<T>();
-  }
-
-  add(item: T): void {
-    if (!this.set.has(item)) {
-      this.set.add(item);
-      this.array.push(item);
-    }
-  }
-
-  delete(item: T, searchFromHead: boolean): void {
-    if (this.set.has(item)) {
-      this.set.delete(item);
-      if (searchFromHead) {
-        this.array.deleteFirst(item);
-      } else {
-        this.array.deleteLast(item);
-      }
-    }
-  }
-
-  first(): T | null {
-    if (this.array.length === 0) {
-      return null;
-    }
-    return this.array.first();
-  }
-
-  last(): T | null {
-    if (this.array.length === 0) {
-      return null;
-    }
-    return this.array.last();
-  }
-
-  toArray(): T[] {
-    return this.array.toArray();
-  }
-
-  values(): IterableIterator<T> {
-    return this.array;
-  }
-
-  has(item: T): boolean {
-    return this.set.has(item);
-  }
-
-  get size(): number {
-    return this.set.size;
-  }
-}

package/src/util/shuffle.ts

@@ -1,21 +0,0 @@
-/**
- * Randomize an array of items without mutation.
- * Note: Uses Math.random() as entropy source, use for non-critical stuff
- */
-export function shuffle<T>(arr: T[]): T[] {
-  const _arr: T[] = [...arr];
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [_arr[i], _arr[j]] = [_arr[j], _arr[i]];
-  }
-  return _arr;
-}
-
-/**
- * Return one random item from array
- */
-export function shuffleOne<T>(arr: T[]): T | undefined {
-  if (arr.length === 0) return undefined;
-
-  return arr[Math.floor(Math.random() * arr.length)];
-}

package/src/util/sortBy.ts

@@ -1,19 +0,0 @@
-/**
- * Sort by multiple prioritized conditions
- * - Sort is stable
- * - Sort does not mutate the original array
- * - Sorts by number in ascending order: [-1,0,1,2]
- * @param condition Must return an number, used to sort compare each item
- * - conditions[0] has priority over conditions[1]
- */
-export function sortBy<T>(arr: T[], ...conditions: ((item: T) => number)[]): T[] {
-  return [...arr].sort((a, b) => {
-    for (const condition of conditions) {
-      const ca = condition(a);
-      const cb = condition(b);
-      if (ca > cb) return 1;
-      if (ca < cb) return -1;
-    }
-    return 0;
-  });
-}