@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/util/bitArray.ts

@@ -0,0 +1,84 @@
+import {BitArray} from "@chainsafe/ssz";
+
+export enum IntersectResult {
+  Equal,
+  /** All elements in set B are in set A  */
+  Superset,
+  /** All elements in set A are in set B  */
+  Subset,
+  /** Set A and set B do not share any elements */
+  Exclusive,
+  /** Set A and set B intersect but are not superset or subset */
+  Intersect,
+}
+
+/**
+ * For each byte check if a includes b,
+ * | a        | b        | result        |
+ * | -------- | -------- | ------------- |
+ * | 00001111 | 00001111 | A equals B    |
+ * | 00001111 | 00000011 | A superset B  |
+ * | 00000011 | 00001111 | A subset B    |
+ * | 11110000 | 00001111 | A exclude B   |
+ * | 11111100 | 00111111 | A intersect B |
+ *
+ * For all bytes in BitArray:
+ * - equals = MAYBE ONLY equals
+ * - excludes = MUST ONLY equals
+ * - superset = MUST superset MAYBE equal
+ * - subset = MUST subset MAYBE equal
+ * - intersect = any other condition
+ */
+export function intersectUint8Arrays(aUA: Uint8Array, bUA: Uint8Array): IntersectResult {
+  const len = aUA.length;
+
+  let someEquals = false;
+  let someExcludes = false;
+  let someSuperset = false;
+  let someSubset = false;
+
+  for (let i = 0; i < len; i++) {
+    const a = aUA[i];
+    const b = bUA[i];
+
+    if (a === 0 && b === 0) {
+      // zero, skip
+    } else if (a === b) {
+      // A equals B
+      someEquals = true;
+    } else if ((a & b) === 0) {
+      // A excludes B
+      someExcludes = true;
+    } else if ((a & b) === b) {
+      // A superset B
+      if (someSubset) return IntersectResult.Intersect;
+      someSuperset = true;
+    } else if ((a & b) === a) {
+      // A subset B
+      if (someSuperset) return IntersectResult.Intersect;
+      someSubset = true;
+    } else {
+      // A diff B
+      return IntersectResult.Intersect;
+    }
+  }
+
+  // equals = MAYBE ONLY equals
+  if (!someExcludes && !someSuperset && !someSubset) return IntersectResult.Equal;
+  // excludes = MUST ONLY equals
+  if (!someEquals && someExcludes && !someSuperset && !someSubset) return IntersectResult.Exclusive;
+  // superset = MUST superset MAYBE equal
+  if (!someExcludes && someSuperset && !someSubset) return IntersectResult.Superset;
+  // subset = MUST subset MAYBE equal
+  if (!someExcludes && !someSuperset && someSubset) return IntersectResult.Subset;
+  // intersect = any other condition
+  return IntersectResult.Intersect;
+}
+
+/**
+ * Check if first BitArray is equal to or superset of the second
+ */
+export function isSuperSetOrEqual(superSet: BitArray, toCheck: BitArray): boolean {
+  const intersectionResult = intersectUint8Arrays(superSet.uint8Array, toCheck.uint8Array);
+  return intersectionResult === IntersectResult.Superset || intersectionResult === IntersectResult.Equal;
+}

package/src/util/blobs.ts

@@ -0,0 +1,210 @@
+import {digest as sha256Digest} from "@chainsafe/as-sha256";
+import {Tree} from "@chainsafe/persistent-merkle-tree";
+import {ChainForkConfig} from "@lodestar/config";
+import {
+  BYTES_PER_CELL,
+  BYTES_PER_FIELD_ELEMENT,
+  CELLS_PER_EXT_BLOB,
+  FIELD_ELEMENTS_PER_BLOB,
+  ForkAll,
+  ForkName,
+  KZG_COMMITMENT_GINDEX0,
+  NUMBER_OF_COLUMNS,
+  VERSIONED_HASH_VERSION_KZG,
+} from "@lodestar/params";
+import {signedBlockToSignedHeader} from "@lodestar/state-transition";
+import {BeaconBlockBody, SSZTypesFor, SignedBeaconBlock, deneb, fulu, ssz} from "@lodestar/types";
+import {kzg} from "./kzg.js";
+
+type VersionHash = Uint8Array;
+
+export function kzgCommitmentToVersionedHash(kzgCommitment: deneb.KZGCommitment): VersionHash {
+  const hash = sha256Digest(kzgCommitment);
+  // Equivalent to `VERSIONED_HASH_VERSION_KZG + hash(kzg_commitment)[1:]`
+  hash[0] = VERSIONED_HASH_VERSION_KZG;
+  return hash;
+}
+
+export function computePreFuluKzgCommitmentsInclusionProof(
+  fork: ForkName,
+  body: BeaconBlockBody,
+  index: number
+): deneb.KzgCommitmentInclusionProof {
+  const bodyView = (ssz[fork].BeaconBlockBody as SSZTypesFor<ForkAll, "BeaconBlockBody">).toView(body);
+  const commitmentGindex = KZG_COMMITMENT_GINDEX0 + index;
+  return new Tree(bodyView.node).getSingleProof(BigInt(commitmentGindex));
+}
+
+/**
+ * SPEC FUNCTION get_blob_sidecars
+ * https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/deneb/validator.md#sidecar
+ */
+export function getBlobSidecars(
+  config: ChainForkConfig,
+  signedBlock: SignedBeaconBlock,
+  blobs: deneb.Blobs,
+  proofs: deneb.KZGProofs
+): deneb.BlobSidecars {
+  const blobKzgCommitments = (signedBlock as deneb.SignedBeaconBlock).message.body.blobKzgCommitments;
+  if (blobKzgCommitments === undefined) {
+    throw Error("Invalid block with missing blobKzgCommitments for computeBlobSidecars");
+  }
+
+  const signedBlockHeader = signedBlockToSignedHeader(config, signedBlock);
+  const fork = config.getForkName(signedBlockHeader.message.slot);
+
+  return blobKzgCommitments.map((kzgCommitment, index) => {
+    const blob = blobs[index];
+    const kzgProof = proofs[index];
+    const kzgCommitmentInclusionProof = computePreFuluKzgCommitmentsInclusionProof(
+      fork,
+      signedBlock.message.body,
+      index
+    );
+
+    return {index, blob, kzgCommitment, kzgProof, signedBlockHeader, kzgCommitmentInclusionProof};
+  });
+}
+
+/**
+ * If the node obtains 50%+ of all the columns, it SHOULD reconstruct the full data matrix via the recover_matrix helper
+ * See https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/fulu/das-core.md#recover_matrix
+ */
+export async function dataColumnMatrixRecovery(
+  partialSidecars: Map<number, fulu.DataColumnSidecar>
+): Promise<fulu.DataColumnSidecars | null> {
+  const columnCount = partialSidecars.size;
+  if (columnCount < NUMBER_OF_COLUMNS / 2) {
+    // We don't have enough columns to recover
+    return null;
+  }
+
+  if (columnCount === NUMBER_OF_COLUMNS) {
+    // full columns, no need to recover
+    return Array.from(partialSidecars.values());
+  }
+
+  // Sort data columns by index in ascending order before passing for kzg operations
+  const partialSidecarsSorted = Array.from(partialSidecars.values()).sort((a, b) => a.index - b.index);
+
+  const firstDataColumn = partialSidecarsSorted[0];
+  if (firstDataColumn == null) {
+    // should not happen because we check the size of the cache before this
+    throw new Error("No data column found in cache to recover from");
+  }
+  const blobCount = firstDataColumn.kzgCommitments.length;
+
+  const fullColumns: Array<Uint8Array[]> = Array.from(
+    {length: NUMBER_OF_COLUMNS},
+    () => new Array<Uint8Array>(blobCount)
+  );
+  const blobProofs: Array<Uint8Array[]> = Array.from({length: blobCount});
+  // https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/fulu/das-core.md#recover_matrix
+  const cellsAndProofs = await Promise.all(
+    blobProofs.map((_, blobIndex) => {
+      const cellIndices: number[] = [];
+      const cells: Uint8Array[] = [];
+      for (const dataColumn of partialSidecarsSorted) {
+        cellIndices.push(dataColumn.index);
+        cells.push(dataColumn.column[blobIndex]);
+      }
+      // recovered cells and proofs are of the same row/blob, their length should be NUMBER_OF_COLUMNS
+      return kzg.asyncRecoverCellsAndKzgProofs(cellIndices, cells);
+    })
+  );
+
+  for (let blobIndex = 0; blobIndex < blobCount; blobIndex++) {
+    const recoveredCells = cellsAndProofs[blobIndex].cells;
+    blobProofs[blobIndex] = cellsAndProofs[blobIndex].proofs;
+    for (let columnIndex = 0; columnIndex < NUMBER_OF_COLUMNS; columnIndex++) {
+      fullColumns[columnIndex][blobIndex] = recoveredCells[columnIndex];
+    }
+  }
+
+  const result: fulu.DataColumnSidecars = new Array(NUMBER_OF_COLUMNS);
+
+  for (let columnIndex = 0; columnIndex < NUMBER_OF_COLUMNS; columnIndex++) {
+    let sidecar = partialSidecars.get(columnIndex);
+    if (sidecar) {
+      // We already have this column
+      result[columnIndex] = sidecar;
+      continue;
+    }
+
+    sidecar = {
+      index: columnIndex,
+      column: fullColumns[columnIndex],
+      kzgCommitments: firstDataColumn.kzgCommitments,
+      kzgProofs: Array.from({length: blobCount}, (_, rowIndex) => blobProofs[rowIndex][columnIndex]),
+      signedBlockHeader: firstDataColumn.signedBlockHeader,
+      kzgCommitmentsInclusionProof: firstDataColumn.kzgCommitmentsInclusionProof,
+    };
+    result[columnIndex] = sidecar;
+  }
+
+  return result;
+}
+
+/**
+ * Reconstruct blobs from a set of data columns, at least 50%+ of all the columns
+ * must be provided to allow to reconstruct the full data matrix
+ */
+export async function reconstructBlobs(sidecars: fulu.DataColumnSidecars): Promise<deneb.Blobs> {
+  if (sidecars.length < NUMBER_OF_COLUMNS / 2) {
+    throw Error(
+      `Expected at least ${NUMBER_OF_COLUMNS / 2} data columns to reconstruct blobs, received ${sidecars.length}`
+    );
+  }
+
+  let fullSidecars: fulu.DataColumnSidecars;
+
+  if (sidecars.length === NUMBER_OF_COLUMNS) {
+    // Full columns, no need to recover
+    fullSidecars = sidecars;
+  } else {
+    const sidecarsByIndex = new Map<number, fulu.DataColumnSidecar>(sidecars.map((sc) => [sc.index, sc]));
+    const recoveredSidecars = await dataColumnMatrixRecovery(sidecarsByIndex);
+    if (recoveredSidecars === null) {
+      // Should not happen because we check the column count above
+      throw Error("Failed to reconstruct the full data matrix");
+    }
+    fullSidecars = recoveredSidecars;
+  }
+
+  const blobCount = fullSidecars[0].column.length;
+  const blobs: deneb.Blobs = new Array(blobCount);
+
+  const ordered = fullSidecars.slice().sort((a, b) => a.index - b.index);
+  for (let row = 0; row < blobCount; row++) {
+    // 128 cells that make up one "extended blob" row
+    const cells = ordered.map((col) => col.column[row]);
+    blobs[row] = cellsToBlob(cells);
+  }
+
+  return blobs;
+}
+
+/**
+ * Concatenate the systematic half (columns 0‑63) of a row of cells into
+ * the original 131072 byte blob. The parity half (64‑127) is ignored as
+ * it is only needed for erasure‑coding recovery when columns are missing.
+ */
+function cellsToBlob(cells: fulu.Cell[]): deneb.Blob {
+  if (cells.length !== CELLS_PER_EXT_BLOB) {
+    throw Error(`Expected ${CELLS_PER_EXT_BLOB} cells to reconstruct blob, received ${cells.length}`);
+  }
+
+  const blob = new Uint8Array(BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB);
+
+  // Only the first 64 cells hold the original bytes
+  for (let i = 0; i < CELLS_PER_EXT_BLOB / 2; i++) {
+    const cell = cells[i];
+    if (cell.length !== BYTES_PER_CELL) {
+      throw Error(`Cell ${i} has incorrect byte size ${cell.length} != ${BYTES_PER_CELL}`);
+    }
+
+    blob.set(cell, i * BYTES_PER_CELL);
+  }
+
+  return blob;
+}

package/src/util/bufferPool.ts

@@ -0,0 +1,95 @@
+import {Metrics} from "../metrics/metrics.js";
+
+/**
+ * If consumer wants more memory than available, we grow the buffer by this ratio.
+ */
+const GROW_RATIO = 1.1;
+
+export enum AllocSource {
+  PERSISTENT_CHECKPOINTS_CACHE_VALIDATORS = "persistent_checkpoints_cache_validators",
+  PERSISTENT_CHECKPOINTS_CACHE_STATE = "persistent_checkpoints_cache_state",
+  ARCHIVE_STATE = "archive_state",
+}
+
+/**
+ * A simple implementation to manage a single buffer.
+ * This is initially used for state serialization at every epoch and for state reload.
+ * We can enhance and use this for other purposes in the future.
+ */
+export class BufferPool {
+  private buffer: Uint8Array;
+  private inUse = false;
+  private currentKey: number;
+  private readonly metrics: Metrics["bufferPool"] | null = null;
+
+  constructor(size: number, metrics: Metrics | null = null) {
+    this.buffer = new Uint8Array(Math.floor(size * GROW_RATIO));
+    this.currentKey = 0;
+    if (metrics) {
+      this.metrics = metrics.bufferPool;
+      metrics.bufferPool.length.addCollect(() => {
+        metrics.bufferPool.length.set(this.buffer.length);
+      });
+    }
+  }
+
+  get length(): number {
+    return this.buffer.length;
+  }
+
+  /**
+   * Returns a buffer of the given size with all 0.
+   * If the buffer is already in use, return null.
+   * Grow the buffer if the requested size is larger than the current buffer.
+   */
+  alloc(size: number, source: AllocSource): BufferWithKey | null {
+    return this.doAlloc(size, source, false);
+  }
+
+  /**
+   * Same to alloc() but the buffer is not zeroed.
+   */
+  allocUnsafe(size: number, source: AllocSource): BufferWithKey | null {
+    return this.doAlloc(size, source, true);
+  }
+
+  private doAlloc(size: number, source: AllocSource, isUnsafe = false): BufferWithKey | null {
+    if (this.inUse) {
+      this.metrics?.misses.inc({source});
+      return null;
+    }
+    this.inUse = true;
+    this.metrics?.hits.inc({source});
+    this.currentKey += 1;
+    if (size > this.buffer.length) {
+      this.metrics?.grows.inc();
+      this.buffer = new Uint8Array(Math.floor(size * GROW_RATIO));
+    }
+    const bytes = this.buffer.subarray(0, size);
+    if (!isUnsafe) {
+      bytes.fill(0);
+    }
+    return new BufferWithKey(bytes, this.currentKey, this);
+  }
+
+  /**
+   * Marks the buffer as free.
+   */
+  free(key: number): void {
+    if (key === this.currentKey) {
+      this.inUse = false;
+    }
+  }
+}
+
+export class BufferWithKey implements Disposable {
+  constructor(
+    readonly buffer: Uint8Array,
+    private readonly key: number,
+    private readonly pool: BufferPool
+  ) {}
+
+  [Symbol.dispose](): void {
+    this.pool.free(this.key);
+  }
+}

package/src/util/bytes.ts

@@ -0,0 +1,11 @@
+import {Root} from "@lodestar/types";
+
+export function byteArrayEquals(a: Uint8Array | Root, b: Uint8Array | Root): boolean {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}

package/src/util/chunkify.ts

@@ -0,0 +1,27 @@
+/**
+ * Split an inclusive range into a sequence of contiguous inclusive ranges
+ * ```
+ * [[a,b], [c,d] ... Sn] = chunkifyInclusiveRange([a,z], n)
+ * // where
+ * [a,z] = [a,b] U [c,d] U ... U Sn
+ * ```
+ * @param from range start inclusive
+ * @param to range end inclusive
+ * @param chunks Maximum number of chunks, if range is big enough
+ */
+export function chunkifyInclusiveRange(from: number, to: number, chunkCount: number): number[][] {
+  // Enforce chunkCount >= 1
+  if (chunkCount < 1) chunkCount = 1;
+
+  const totalItems = to - from + 1;
+  const itemsPerChunk = Math.ceil(totalItems / chunkCount);
+
+  const chunks: number[][] = [];
+  for (let i = 0; i < chunkCount; i++) {
+    const _from = from + i * itemsPerChunk;
+    const _to = Math.min(from + (i + 1) * itemsPerChunk - 1, to);
+    chunks.push([_from, _to]);
+    if (_to >= to) break;
+  }
+  return chunks;
+}

package/src/util/clock.ts

@@ -0,0 +1,212 @@
+import EventEmitter from "node:events";
+import type {StrictEventEmitter} from "strict-event-emitter-types";
+import {ChainForkConfig} from "@lodestar/config";
+import {computeEpochAtSlot, computeTimeAtSlot, getCurrentSlot} from "@lodestar/state-transition";
+import type {Epoch, Slot} from "@lodestar/types";
+import {ErrorAborted} from "@lodestar/utils";
+import {MAXIMUM_GOSSIP_CLOCK_DISPARITY} from "../constants/constants.js";
+
+export enum ClockEvent {
+  /**
+   * This event signals the start of a new slot, and that subsequent calls to `clock.currentSlot` will equal `slot`.
+   * This event is guaranteed to be emitted every `SLOT_DURATION_MS` milliseconds.
+   */
+  slot = "clock:slot",
+  /**
+   * This event signals the start of a new epoch, and that subsequent calls to `clock.currentEpoch` will return `epoch`.
+   * This event is guaranteed to be emitted every `SLOT_DURATION_MS * SLOTS_PER_EPOCH` milliseconds.
+   */
+  epoch = "clock:epoch",
+}
+
+export type ClockEvents = {
+  [ClockEvent.slot]: (slot: Slot) => void;
+  [ClockEvent.epoch]: (epoch: Epoch) => void;
+};
+
+/**
+ * Tracks the current chain time, measured in `Slot`s and `Epoch`s
+ *
+ * The time is dependent on:
+ * - `state.genesisTime` - the genesis time
+ * - `SLOT_DURATION_MS` - # of milliseconds per slot
+ * - `SLOTS_PER_EPOCH` - # of slots per epoch
+ */
+export type IClock = StrictEventEmitter<EventEmitter, ClockEvents> & {
+  readonly genesisTime: Slot;
+  readonly currentSlot: Slot;
+  /**
+   * If it's too close to next slot, maxCurrentSlot = currentSlot + 1
+   */
+  readonly currentSlotWithGossipDisparity: Slot;
+  readonly currentEpoch: Epoch;
+  /** Returns the slot if the internal clock were advanced by `toleranceSec`. */
+  slotWithFutureTolerance(toleranceSec: number): Slot;
+  /** Returns the slot if the internal clock were reversed by `toleranceSec`. */
+  slotWithPastTolerance(toleranceSec: number): Slot;
+  /**
+   * Check if a slot is current slot given MAXIMUM_GOSSIP_CLOCK_DISPARITY.
+   */
+  isCurrentSlotGivenGossipDisparity(slot: Slot): boolean;
+  /**
+   * Returns a promise that waits until at least `slot` is reached
+   * Resolves when the current slot >= `slot`
+   * Rejects if the clock is aborted
+   */
+  waitForSlot(slot: Slot): Promise<void>;
+  /**
+   * Return second from a slot to either toSec or now.
+   */
+  secFromSlot(slot: Slot, toSec?: number): number;
+  /**
+   * Return milliseconds from a slot to either toMs or now.
+   */
+  msFromSlot(slot: Slot, toMs?: number): number;
+};
+
+/**
+ * A local clock, the clock time is assumed to be trusted
+ */
+export class Clock extends EventEmitter implements IClock {
+  readonly genesisTime: number;
+  private readonly config: ChainForkConfig;
+  private timeoutId: number | NodeJS.Timeout;
+  private readonly signal: AbortSignal;
+  private _currentSlot: number;
+
+  constructor({config, genesisTime, signal}: {config: ChainForkConfig; genesisTime: number; signal: AbortSignal}) {
+    super();
+
+    this.config = config;
+    this.genesisTime = genesisTime;
+    this.timeoutId = setTimeout(this.onNextSlot, this.msUntilNextSlot());
+    this.signal = signal;
+    this._currentSlot = getCurrentSlot(this.config, this.genesisTime);
+    this.signal.addEventListener("abort", () => clearTimeout(this.timeoutId), {once: true});
+  }
+
+  get currentSlot(): Slot {
+    const slot = getCurrentSlot(this.config, this.genesisTime);
+    if (slot > this._currentSlot) {
+      clearTimeout(this.timeoutId);
+      this.onNextSlot(slot);
+    }
+    return slot;
+  }
+
+  /**
+   * If it's too close to next slot given MAXIMUM_GOSSIP_CLOCK_DISPARITY, return currentSlot + 1.
+   * Otherwise return currentSlot
+   */
+  get currentSlotWithGossipDisparity(): Slot {
+    const currentSlot = this.currentSlot;
+    const nextSlotTime = computeTimeAtSlot(this.config, currentSlot + 1, this.genesisTime) * 1000;
+    return nextSlotTime - Date.now() < MAXIMUM_GOSSIP_CLOCK_DISPARITY ? currentSlot + 1 : currentSlot;
+  }
+
+  get currentEpoch(): Epoch {
+    return computeEpochAtSlot(this.currentSlot);
+  }
+
+  /** Returns the slot if the internal clock were advanced by `toleranceSec`. */
+  slotWithFutureTolerance(toleranceSec: number): Slot {
+    // this is the same to getting slot at now + toleranceSec
+    return getCurrentSlot(this.config, this.genesisTime - toleranceSec);
+  }
+
+  /** Returns the slot if the internal clock were reversed by `toleranceSec`. */
+  slotWithPastTolerance(toleranceSec: number): Slot {
+    // this is the same to getting slot at now - toleranceSec
+    return getCurrentSlot(this.config, this.genesisTime + toleranceSec);
+  }
+
+  /**
+   * Check if a slot is current slot given MAXIMUM_GOSSIP_CLOCK_DISPARITY.
+   */
+  isCurrentSlotGivenGossipDisparity(slot: Slot): boolean {
+    const currentSlot = this.currentSlot;
+    if (currentSlot === slot) {
+      return true;
+    }
+    const nextSlotTime = computeTimeAtSlot(this.config, currentSlot + 1, this.genesisTime) * 1000;
+    // we're too close to next slot, accept next slot
+    if (nextSlotTime - Date.now() < MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
+      return slot === currentSlot + 1;
+    }
+    const currentSlotTime = computeTimeAtSlot(this.config, currentSlot, this.genesisTime) * 1000;
+    // we've just passed the current slot, accept previous slot
+    if (Date.now() - currentSlotTime < MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
+      return slot === currentSlot - 1;
+    }
+    return false;
+  }
+
+  async waitForSlot(slot: Slot): Promise<void> {
+    if (this.signal.aborted) {
+      throw new ErrorAborted();
+    }
+
+    if (this.currentSlot >= slot) {
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      const onSlot = (clockSlot: Slot): void => {
+        if (clockSlot >= slot) {
+          onDone();
+        }
+      };
+
+      const onDone = (): void => {
+        this.off(ClockEvent.slot, onSlot);
+        this.signal.removeEventListener("abort", onAbort);
+        resolve();
+      };
+
+      const onAbort = (): void => {
+        this.off(ClockEvent.slot, onSlot);
+        reject(new ErrorAborted());
+      };
+
+      this.on(ClockEvent.slot, onSlot);
+      this.signal.addEventListener("abort", onAbort, {once: true});
+    });
+  }
+
+  secFromSlot(slot: Slot, toSec = Date.now() / 1000): number {
+    return toSec - computeTimeAtSlot(this.config, slot, this.genesisTime);
+  }
+
+  msFromSlot(slot: Slot, toMs = Date.now()): number {
+    return toMs - computeTimeAtSlot(this.config, slot, this.genesisTime) * 1000;
+  }
+
+  private onNextSlot = (slot?: Slot): void => {
+    const clockSlot = slot ?? getCurrentSlot(this.config, this.genesisTime);
+    // process multiple clock slots in the case the main thread has been saturated for > SLOT_DURATION_MS
+    while (this._currentSlot < clockSlot && !this.signal.aborted) {
+      const previousSlot = this._currentSlot;
+      this._currentSlot++;
+
+      this.emit(ClockEvent.slot, this._currentSlot);
+
+      const previousEpoch = computeEpochAtSlot(previousSlot);
+      const currentEpoch = computeEpochAtSlot(this._currentSlot);
+
+      if (previousEpoch < currentEpoch) {
+        this.emit(ClockEvent.epoch, currentEpoch);
+      }
+    }
+
+    if (!this.signal.aborted) {
+      //recursively invoke onNextSlot
+      this.timeoutId = setTimeout(this.onNextSlot, this.msUntilNextSlot());
+    }
+  };
+
+  private msUntilNextSlot(): number {
+    const milliSecondsPerSlot = this.config.SLOT_DURATION_MS;
+    const diffInMilliSeconds = Date.now() - this.genesisTime * 1000;
+    return milliSecondsPerSlot - (diffInMilliSeconds % milliSecondsPerSlot);
+  }
+}