@lodestar/utils 1.35.0-dev.98d359db41 → 1.35.0-dev.b42a298a7c

package/src/format.ts

@@ -1,119 +0,0 @@
-import {toRootHex} from "./bytes/index.js";
-import {ETH_TO_WEI} from "./ethConversion.js";
-
-/**
- * Format bytes as `0x1234…1234`
- * 4 bytes can represent 4294967296 values, so the chance of collision is low
- */
-export function prettyBytes(root: Uint8Array | string): string {
-  const str = typeof root === "string" ? root : toRootHex(root);
-  return `${str.slice(0, 6)}…${str.slice(-4)}`;
-}
-
-/**
- * Format bytes as `0x1234…`
- * Paired with block numbers or slots, it can still act as a decent identify-able format
- */
-export function prettyBytesShort(root: Uint8Array | string): string {
-  const str = typeof root === "string" ? root : toRootHex(root);
-  return `${str.slice(0, 6)}…`;
-}
-
-/**
- * Truncate and format bytes as `0x123456789abc`
- * 6 bytes is sufficient to avoid collisions and it allows to easily look up
- * values on explorers like beaconcha.in while improving readability of logs
- */
-export function truncBytes(root: Uint8Array | string): string {
-  const str = typeof root === "string" ? root : toRootHex(root);
-  return str.slice(0, 14);
-}
-
-/**
- * Format a bigint value as a decimal string
- */
-export function formatBigDecimal(numerator: bigint, denominator: bigint, maxDecimalFactor: bigint): string {
-  const full = numerator / denominator;
-  const fraction = ((numerator - full * denominator) * maxDecimalFactor) / denominator;
-
-  // zeros to be added post decimal are number of zeros in maxDecimalFactor - number of digits in fraction
-  const zerosPostDecimal = String(maxDecimalFactor).length - 1 - String(fraction).length;
-  return `${full}.${"0".repeat(zerosPostDecimal)}${fraction}`;
-}
-
-// display upto 5 decimal places
-const MAX_DECIMAL_FACTOR = BigInt("100000");
-
-/**
- * Format wei as ETH, with up to 5 decimals
- */
-export function formatWeiToEth(wei: bigint): string {
-  return formatBigDecimal(wei, ETH_TO_WEI, MAX_DECIMAL_FACTOR);
-}
-
-/**
- * Format wei as ETH, with up to 5 decimals and append ' ETH'
- */
-export function prettyWeiToEth(wei: bigint): string {
-  return `${formatWeiToEth(wei)} ETH`;
-}
-
-/**
- * Format milliseconds to time format HH:MM:SS.ms
- */
-export function prettyMsToTime(timeMs: number): string {
-  const date = new Date(0, 0, 0, 0, 0, 0, timeMs);
-  return `${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}.${date.getMilliseconds()}`;
-}
-
-/**
- * Remove 0x prefix from a string
- */
-export function strip0xPrefix(hex: string): string {
-  return hex.startsWith("0x") ? hex.slice(2) : hex;
-}
-
-export function groupSequentialIndices(indices: number[]): string[] {
-  if (indices.length === 0) {
-    return [];
-  }
-
-  // Get unique values and sort them
-  const uniqueValues = Array.from(new Set(indices)).sort((a, b) => a - b);
-
-  const result: string[] = [];
-  let start = uniqueValues[0];
-  let end = uniqueValues[0];
-
-  for (let i = 1; i < uniqueValues.length; i++) {
-    const current = uniqueValues[i];
-
-    if (current === end + 1) {
-      end = current; // extend the range
-    } else {
-      result.push(start === end ? `${start}` : `${start}-${end}`);
-      start = current;
-      end = current;
-    }
-  }
-
-  // Push the last range
-  result.push(start === end ? `${start}` : `${start}-${end}`);
-
-  return result;
-}
-
-/**
- * Pretty print indices from an array of numbers.
- *
- * example:
- * ```ts
- * const indices = [1, 3, 109, 110, 111, 112, 113, 127];
- * console.log(prettyPrintIndices(indices));
- * // `1,3,110-113,127`
- * ```
- */
-export function prettyPrintIndices(indices: number[]): string {
-  const increments = groupSequentialIndices(indices);
-  return `[${increments.join(", ")}]`;
-}

package/src/index.ts

@@ -1,28 +0,0 @@
-export * from "./assert.js";
-export * from "./base64.js";
-export * from "./bytes/index.js";
-export * from "./bytes.js";
-export * from "./command.js";
-export * from "./diff.js";
-export * from "./err.js";
-export * from "./errors.js";
-export * from "./ethConversion.js";
-export * from "./fetch.js";
-export * from "./format.js";
-export * from "./iterator.js";
-export * from "./logger.js";
-export * from "./map.js";
-export * from "./math.js";
-export * from "./metrics.js";
-export * from "./notNullish.js";
-export * from "./objects.js";
-export * from "./promise.js";
-export {type RetryOptions, retry} from "./retry.js";
-export * from "./sleep.js";
-export * from "./sort.js";
-export * from "./timeout.js";
-export {type RecursivePartial, type RequiredSelective, bnToNum} from "./types.js";
-export * from "./url.js";
-export * from "./verifyMerkleBranch.js";
-export * from "./waitFor.js";
-export * from "./yaml/index.js";

package/src/iterator.ts

@@ -1,10 +0,0 @@
-// ES2024 onward we have Array.fromAsync which does exactly this
-// This function is here as wrapper to be deleted later when we upgrade
-// minimum nodejs requirement to > 22
-export async function fromAsync<T>(iter: AsyncIterable<T>): Promise<T[]> {
-  const arr: T[] = [];
-  for await (const v of iter) {
-    arr.push(v);
-  }
-  return arr;
-}

package/src/logger.ts

@@ -1,20 +0,0 @@
-/**
- * Interface of a generic Lodestar logger. For implementations, see `@lodestar/logger`
- */
-export type Logger = Record<Exclude<LogLevel, LogLevel.trace>, LogHandler>;
-
-export enum LogLevel {
-  error = "error",
-  warn = "warn",
-  info = "info",
-  verbose = "verbose",
-  debug = "debug",
-  trace = "trace",
-}
-
-export const LogLevels = Object.values(LogLevel);
-
-export type LogHandler = (message: string, context?: LogData, error?: Error) => void;
-
-export type LogDataBasic = string | number | bigint | boolean | null | undefined;
-export type LogData = LogDataBasic | Record<string, LogDataBasic> | LogDataBasic[] | Record<string, LogDataBasic>[];

package/src/map.ts

@@ -1,108 +0,0 @@
-export class MapDef<K, V> extends Map<K, V> {
-  constructor(private readonly getDefault: () => V) {
-    super();
-  }
-
-  getOrDefault(key: K): V {
-    let value = super.get(key);
-    if (value === undefined) {
-      value = this.getDefault();
-      this.set(key, value);
-    }
-    return value;
-  }
-}
-
-/**
- * Extends MapDef but ensures that there always a max of `maxKeys` keys
- */
-export class MapDefMax<K, V> {
-  private readonly map = new Map<K, V>();
-
-  constructor(
-    private readonly getDefault: () => V,
-    private readonly maxKeys: number
-  ) {}
-
-  getOrDefault(key: K): V {
-    let value = this.map.get(key);
-    if (value === undefined) {
-      value = this.getDefault();
-      this.map.set(key, value);
-      pruneSetToMax(this.map, this.maxKeys);
-    }
-    return value;
-  }
-
-  get(key: K): V | undefined {
-    return this.map.get(key);
-  }
-}
-
-/**
- * 2 dimensions Es6 Map
- */
-export class Map2d<K1, K2, V> {
-  readonly map = new Map<K1, Map<K2, V>>();
-
-  get(k1: K1, k2: K2): V | undefined {
-    return this.map.get(k1)?.get(k2);
-  }
-
-  set(k1: K1, k2: K2, v: V): void {
-    let map2 = this.map.get(k1);
-    if (!map2) {
-      map2 = new Map<K2, V>();
-      this.map.set(k1, map2);
-    }
-    map2.set(k2, v);
-  }
-}
-
-/**
- * 2 dimensions Es6 Map + regular array
- */
-export class Map2dArr<K1, V> {
-  readonly map = new Map<K1, V[]>();
-
-  get(k1: K1, idx: number): V | undefined {
-    return this.map.get(k1)?.[idx];
-  }
-
-  set(k1: K1, idx: number, v: V): void {
-    let arr = this.map.get(k1);
-    if (!arr) {
-      arr = [];
-      this.map.set(k1, arr);
-    }
-    arr[idx] = v;
-  }
-}
-
-/**
- * Prune an arbitrary set removing the first keys to have a set.size === maxItems.
- * Returns the count of deleted items.
- *
- * Keys can be sorted by `compareFn` to get more control over which items to prune first
- */
-export function pruneSetToMax<T>(
-  set: Set<T> | Map<T, unknown>,
-  maxItems: number,
-  compareFn?: (a: T, b: T) => number
-): number {
-  let itemsToDelete = set.size - maxItems;
-  const deletedItems = Math.max(0, itemsToDelete);
-
-  if (itemsToDelete > 0) {
-    const keys = compareFn ? Array.from(set.keys()).sort(compareFn) : set.keys();
-    for (const key of keys) {
-      set.delete(key);
-      itemsToDelete--;
-      if (itemsToDelete <= 0) {
-        break;
-      }
-    }
-  }
-
-  return deletedItems;
-}

package/src/math.ts

@@ -1,55 +0,0 @@
-/**
- * Return the min number between two big numbers.
- */
-export function bigIntMin(a: bigint, b: bigint): bigint {
-  return a < b ? a : b;
-}
-
-/**
- * Return the max number between two big numbers.
- */
-export function bigIntMax(a: bigint, b: bigint): bigint {
-  return a > b ? a : b;
-}
-
-export function intDiv(dividend: number, divisor: number): number {
-  return Math.floor(dividend / divisor);
-}
-
-/**
- * Calculate the largest integer k such that k**2 <= n.
- */
-export function intSqrt(n: number): number {
-  let x = n;
-  let y = intDiv(x + 1, 2);
-  while (y < x) {
-    x = y;
-    y = intDiv(x + intDiv(n, x), 2);
-  }
-  return x;
-}
-
-export function bigIntSqrt(n: bigint): bigint {
-  let x = n;
-  let y = (x + BigInt(1)) / BigInt(2);
-  while (y < x) {
-    x = y;
-    y = (x + n / x) / BigInt(2);
-  }
-  return x;
-}
-
-/**
- * Regenerates a random integer between min (included) and max (excluded).
- */
-export function randBetween(min: number, max: number): number {
-  return Math.floor(Math.random() * (max - min)) + min;
-}
-
-/**
- * Wraps randBetween and returns a bigNumber.
- * @returns {bigint}
- */
-export function randBetweenBigInt(min: number, max: number): bigint {
-  return BigInt(randBetween(min, max));
-}

package/src/metrics.ts

@@ -1,73 +0,0 @@
-import {NonEmptyArray} from "./types.js";
-
-export type NoLabels = Record<string, never>;
-export type LabelsGeneric = Record<string, string | number>;
-export type LabelKeys<Labels extends LabelsGeneric> = Extract<keyof Labels, string>;
-export type CollectFn<Labels extends LabelsGeneric> = (metric: Gauge<Labels>) => void;
-
-export interface Gauge<Labels extends LabelsGeneric = NoLabels> {
-  inc: NoLabels extends Labels ? (value?: number) => void : (labels: Labels, value?: number) => void;
-  dec: NoLabels extends Labels ? (value?: number) => void : (labels: Labels, value?: number) => void;
-  set: NoLabels extends Labels ? (value: number) => void : (labels: Labels, value: number) => void;
-
-  collect?(): void;
-}
-
-export interface GaugeExtra<Labels extends LabelsGeneric = NoLabels> extends Omit<Gauge<Labels>, "collect"> {
-  addCollect(collectFn: CollectFn<Labels>): void;
-}
-
-export interface Histogram<Labels extends LabelsGeneric = NoLabels> {
-  startTimer(): NoLabels extends Labels ? () => number : (labels: Labels) => number;
-  startTimer<L extends Partial<Labels>>(
-    labels?: NoLabels extends Labels ? never : L
-  ): keyof Omit<Labels, keyof L> extends never ? () => number : (labels: Omit<Labels, keyof L>) => number;
-
-  observe: NoLabels extends Labels ? (value: number) => void : (labels: Labels, value: number) => void;
-
-  reset(): void;
-}
-
-export interface AvgMinMax<Labels extends LabelsGeneric = NoLabels> {
-  addGetValuesFn(getValuesFn: () => number[]): void;
-
-  set: NoLabels extends Labels ? (values: number[]) => void : (labels: Labels, values: number[]) => void;
-}
-
-export interface Counter<Labels extends LabelsGeneric = NoLabels> {
-  inc: NoLabels extends Labels ? (value?: number) => void : (labels: Labels, value?: number) => void;
-}
-
-export type GaugeConfig<Labels extends LabelsGeneric> = {
-  name: string;
-  help: string;
-} & (NoLabels extends Labels ? {labelNames?: never} : {labelNames: NonEmptyArray<LabelKeys<Labels>>});
-
-export type HistogramConfig<Labels extends LabelsGeneric> = GaugeConfig<Labels> & {
-  buckets: number[];
-};
-
-export type AvgMinMaxConfig<Labels extends LabelsGeneric> = GaugeConfig<Labels>;
-
-export type CounterConfig<Labels extends LabelsGeneric> = GaugeConfig<Labels>;
-
-export type StaticConfig<Labels extends LabelsGeneric> = {
-  name: GaugeConfig<Labels>["name"];
-  help: GaugeConfig<Labels>["help"];
-  value: Record<LabelKeys<Labels>, string>;
-};
-
-export interface MetricsRegister {
-  gauge<Labels extends LabelsGeneric = NoLabels>(config: GaugeConfig<Labels>): Gauge<Labels>;
-  histogram<Labels extends LabelsGeneric = NoLabels>(config: HistogramConfig<Labels>): Histogram<Labels>;
-  counter<Labels extends LabelsGeneric = NoLabels>(config: CounterConfig<Labels>): Counter<Labels>;
-}
-
-export interface MetricsRegisterExtra extends MetricsRegister {
-  gauge<Labels extends LabelsGeneric = NoLabels>(config: GaugeConfig<Labels>): GaugeExtra<Labels>;
-}
-
-export interface MetricsRegisterCustom extends MetricsRegisterExtra {
-  avgMinMax<Labels extends LabelsGeneric = NoLabels>(config: AvgMinMaxConfig<Labels>): AvgMinMax<Labels>;
-  static<Labels extends LabelsGeneric = NoLabels>(config: StaticConfig<Labels>): void;
-}

package/src/notNullish.ts

@@ -1,11 +0,0 @@
-/**
- * Type-safe helper to filter out nullist values from an array
- * ```js
- * const array: (string | null)[] = ['foo', null];
- * const filteredArray: string[] = array.filter(notEmpty);
- * ```
- * @param value
- */
-export function notNullish<TValue>(value: TValue | null | undefined): value is TValue {
-  return value !== null && value !== undefined;
-}

package/src/objects.ts

@@ -1,102 +0,0 @@
-import Case from "case";
-
-export type KeyCase =
-  | "snake"
-  | "constant"
-  | "camel"
-  | "param"
-  | "header"
-  | "pascal" //Same as squish
-  | "dot"
-  | "notransform";
-
-export function toExpectedCase(
-  value: string,
-  expectedCase: KeyCase = "camel",
-  customCasingMap?: Record<string, string>
-): string {
-  if (expectedCase === "notransform") return value;
-  if (customCasingMap?.[value]) return customCasingMap[value];
-  switch (expectedCase) {
-    case "param":
-      return Case.kebab(value);
-    case "dot":
-      return Case.lower(value, ".", true);
-    default:
-      return Case[expectedCase](value);
-  }
-}
-
-function isObjectObject(val: unknown): val is object {
-  return val != null && typeof val === "object" && Array.isArray(val) === false;
-}
-
-export function isPlainObject(o: unknown): o is object {
-  if (isObjectObject(o) === false) return false;
-
-  // If has modified constructor
-  const ctor = (o as Record<string, unknown>).constructor;
-  if (typeof ctor !== "function") return false;
-
-  // If has modified prototype
-  const prot = ctor.prototype;
-  if (isObjectObject(prot) === false) return false;
-
-  // If constructor does not have an Object-specific method
-  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
-    return false;
-  }
-
-  // Most likely a plain Object
-  return true;
-}
-
-export function isEmptyObject(value: unknown): boolean {
-  return isObjectObject(value) && Object.keys(value).length === 0;
-}
-
-/**
- * Creates an object with the same keys as object and values generated by running each own enumerable
- * string keyed property of object thru iteratee.
- *
- * Inspired on lodash.mapValues, see https://lodash.com/docs/4.17.15#mapValues
- */
-// biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
-export function mapValues<T extends {[K: string]: any}, R>(
-  obj: T,
-  iteratee: (value: T[keyof T], key: keyof T) => R
-): {[K in keyof T]: R} {
-  const output = {} as {[K in keyof T]: R};
-  for (const [key, value] of Object.entries(obj)) {
-    output[key as keyof T] = iteratee(value, key);
-  }
-  return output;
-}
-
-export function objectToExpectedCase<T extends Record<string, unknown> | Record<string, unknown>[] | unknown[]>(
-  obj: T,
-  expectedCase: "snake" | "constant" | "camel" | "param" | "header" | "pascal" | "dot" | "notransform" = "camel"
-): T {
-  if (Array.isArray(obj)) {
-    const newArr: unknown[] = [];
-    for (let i = 0; i < obj.length; i++) {
-      newArr[i] = objectToExpectedCase(obj[i] as T, expectedCase);
-    }
-    return newArr as unknown as T;
-  }
-
-  if (Object(obj) === obj) {
-    const newObj: Record<string, unknown> = {};
-    for (const name of Object.getOwnPropertyNames(obj)) {
-      const newName = toExpectedCase(name, expectedCase);
-      if (newName !== name && Object.prototype.hasOwnProperty.call(obj, newName)) {
-        throw new Error(`object already has a ${newName} property`);
-      }
-
-      newObj[newName] = objectToExpectedCase(obj[name] as Record<string, unknown>, expectedCase);
-    }
-    return newObj as T;
-  }
-
-  return obj;
-}

package/src/promise.ts

@@ -1,163 +0,0 @@
-import {ErrorAborted, TimeoutError} from "./errors.js";
-import {sleep} from "./sleep.js";
-import {ArrayToTuple, NonEmptyArray} from "./types.js";
-
-/**
- * While promise t is not finished, call function `fn` per `interval`
- */
-export async function callFnWhenAwait<T>(
-  p: Promise<T>,
-  fn: () => void,
-  interval: number,
-  signal?: AbortSignal
-): Promise<T> {
-  let done = false;
-  const logFn = async (): Promise<void> => {
-    while (!done) {
-      await sleep(interval, signal);
-      if (!done) fn();
-    }
-  };
-
-  const t = await Promise.race([p, logFn()]).finally(() => {
-    done = true;
-  });
-
-  return t as T;
-}
-
-/**
- * Create a deferred promise
- */
-export function defer<T>() {
-  let resolve!: (v: T) => void;
-  let reject!: (e: unknown) => void;
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return {promise, resolve, reject};
-}
-
-export type PromiseResult<T> = {
-  promise: Promise<T>;
-} & (
-  | {
-      status: "pending";
-    }
-  | {
-      status: "fulfilled";
-      value: T;
-      durationMs: number;
-    }
-  | {
-      status: "rejected";
-      reason: Error;
-      durationMs: number;
-    }
-);
-export type PromiseFulfilledResult<T> = PromiseResult<T> & {status: "fulfilled"};
-export type PromiseRejectedResult<T> = PromiseResult<T> & {status: "rejected"};
-
-/**
- * Wrap a promise to an object to track the status and value of the promise
- */
-export function wrapPromise<T>(promise: PromiseLike<T>): PromiseResult<T> {
-  const startedAt = Date.now();
-
-  const result = {
-    promise: promise.then(
-      (value) => {
-        result.status = "fulfilled";
-        (result as PromiseFulfilledResult<T>).value = value;
-        (result as PromiseFulfilledResult<T>).durationMs = Date.now() - startedAt;
-        return value;
-      },
-      (reason: unknown) => {
-        result.status = "rejected";
-        (result as PromiseRejectedResult<T>).reason = reason as Error;
-        (result as PromiseRejectedResult<T>).durationMs = Date.now() - startedAt;
-        throw reason;
-      }
-    ),
-    status: "pending",
-  } as PromiseResult<T>;
-
-  return result;
-}
-
-type ReturnPromiseWithTuple<Tuple extends NonEmptyArray<PromiseLike<unknown>>> = {
-  [Index in keyof ArrayToTuple<Tuple>]: PromiseResult<Awaited<Tuple[Index]>>;
-};
-
-/**
- * Two phased approach for resolving promises:
- * - first wait `resolveTimeoutMs` or until all promises settle
- * - then wait `raceTimeoutMs - resolveTimeoutMs` or until at least a single promise resolves
- *
- * Returns a list of promise results, see `PromiseResult`
- */
-export async function resolveOrRacePromises<T extends NonEmptyArray<PromiseLike<unknown>>>(
-  promises: T,
-  {
-    resolveTimeoutMs,
-    raceTimeoutMs,
-    signal,
-  }: {
-    resolveTimeoutMs: number;
-    raceTimeoutMs: number;
-    signal?: AbortSignal;
-  }
-): Promise<ReturnPromiseWithTuple<T>> | never {
-  if (raceTimeoutMs <= resolveTimeoutMs) {
-    throw new Error("Race time must be greater than resolve time");
-  }
-  const resolveTimeoutError = new TimeoutError(
-    `Given promises can't be resolved within resolveTimeoutMs=${resolveTimeoutMs}`
-  );
-  const raceTimeoutError = new TimeoutError(
-    `Not a any single promise be resolved in given raceTimeoutMs=${raceTimeoutMs}`
-  );
-
-  const promiseResults = promises.map((p) => wrapPromise(p)) as ReturnPromiseWithTuple<T>;
-  // We intentionally want an array of promises here
-  promises = (promiseResults as PromiseResult<T>[]).map((p) => p.promise) as unknown as T;
-
-  try {
-    await Promise.race([
-      Promise.allSettled(promises),
-      sleep(resolveTimeoutMs, signal).then(() => {
-        throw resolveTimeoutError;
-      }),
-    ]);
-
-    return promiseResults;
-  } catch (err) {
-    if (err instanceof ErrorAborted) {
-      return promiseResults;
-    }
-    if (err !== resolveTimeoutError) {
-      throw err;
-    }
-  }
-
-  try {
-    await Promise.race([
-      Promise.any(promises),
-      sleep(raceTimeoutMs - resolveTimeoutMs, signal).then(() => {
-        throw raceTimeoutError;
-      }),
-    ]);
-
-    return promiseResults;
-  } catch (err) {
-    if (err instanceof ErrorAborted) {
-      return promiseResults;
-    }
-    if (err !== raceTimeoutError && !(err instanceof AggregateError)) {
-      throw err;
-    }
-  }
-
-  return promiseResults;
-}