@lodestar/beacon-node 1.35.0-dev.39be8f0882 → 1.35.0-dev.3d8b04e1a0

package/src/util/bitArray.ts

@@ -1,84 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,212 +0,0 @@
-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 `SECONDS_PER_SLOT` seconds.
-   */
-  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 `SECONDS_PER_SLOT * SLOTS_PER_EPOCH` seconds.
-   */
-  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
- * - `SECONDS_PER_SLOT` - # of seconds 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 - (this.genesisTime + slot * this.config.SECONDS_PER_SLOT);
-  }
-
-  msFromSlot(slot: Slot, toMs = Date.now()): number {
-    return toMs - (this.genesisTime * 1000 + slot * this.config.SLOT_DURATION_MS);
-  }
-
-  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 > SECONDS_PER_SLOT
-    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.SECONDS_PER_SLOT * 1000;
-    const diffInMilliSeconds = Date.now() - this.genesisTime * 1000;
-    return milliSecondsPerSlot - (diffInMilliSeconds % milliSecondsPerSlot);
-  }
-}