@lodestar/validator 1.35.0-dev.98d359db41 → 1.35.0-dev.a70bac5bd3

package/src/services/blockDuties.ts

@@ -1,215 +0,0 @@
-import {ApiClient, routes} from "@lodestar/api";
-import {ChainConfig} from "@lodestar/config";
-import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {BLSPubkey, Epoch, RootHex, Slot} from "@lodestar/types";
-import {sleep, toPubkeyHex} from "@lodestar/utils";
-import {Metrics} from "../metrics.js";
-import {PubkeyHex} from "../types.js";
-import {IClock, LoggerVc, differenceHex} from "../util/index.js";
-import {ValidatorStore} from "./validatorStore.js";
-
-/** This polls block duties 1s before the next epoch */
-// TODO: change to 6 to do it 2s before the next epoch
-// once we have some improvement on epoch transition time
-// see https://github.com/ChainSafe/lodestar/issues/5792#issuecomment-1647457442
-const BLOCK_DUTIES_LOOKAHEAD_FACTOR = 12;
-/** Only retain `HISTORICAL_DUTIES_EPOCHS` duties prior to the current epoch */
-const HISTORICAL_DUTIES_EPOCHS = 2;
-// Re-declaring to not have to depend on `lodestar-params` just for this 0
-const GENESIS_EPOCH = 0;
-export const GENESIS_SLOT = 0;
-
-type BlockDutyAtEpoch = {dependentRoot: RootHex; data: routes.validator.ProposerDuty[]};
-type NotifyBlockProductionFn = (slot: Slot, proposers: BLSPubkey[]) => void;
-
-export class BlockDutiesService {
-  /** Notify the block service if it should produce a block. */
-  private readonly notifyBlockProductionFn: NotifyBlockProductionFn;
-  /** Maps an epoch to all *local* proposers in this epoch. Notably, this does not contain
-      proposals for any validators which are not registered locally. */
-  private readonly proposers = new Map<Epoch, BlockDutyAtEpoch>();
-
-  constructor(
-    private readonly config: ChainConfig,
-    private readonly logger: LoggerVc,
-    private readonly api: ApiClient,
-    private readonly clock: IClock,
-    private readonly validatorStore: ValidatorStore,
-    private readonly metrics: Metrics | null,
-    notifyBlockProductionFn: NotifyBlockProductionFn
-  ) {
-    this.notifyBlockProductionFn = notifyBlockProductionFn;
-
-    // TODO: Instead of polling every CLOCK_SLOT, poll every CLOCK_EPOCH and track re-org events
-    //       only then re-fetch the block duties. Make sure most clients (including Lodestar)
-    //       properly emit the re-org event
-    clock.runEverySlot(this.runBlockDutiesTask);
-
-    if (metrics) {
-      metrics.proposerDutiesEpochCount.addCollect(() => {
-        metrics.proposerDutiesEpochCount.set(this.proposers.size);
-      });
-    }
-  }
-
-  /**
-   * Returns the pubkeys of the validators which are assigned to propose in the given slot.
-   *
-   * It is possible that multiple validators have an identical proposal slot, however that is
-   * likely the result of heavy forking (lol) or inconsistent beacon node connections.
-   */
-  getblockProposersAtSlot(slot: Slot): BLSPubkey[] {
-    const epoch = computeEpochAtSlot(slot);
-    const publicKeys = new Map<string, BLSPubkey>(); // pseudo-HashSet of Buffers
-
-    const dutyAtEpoch = this.proposers.get(epoch);
-    if (dutyAtEpoch) {
-      for (const proposer of dutyAtEpoch.data) {
-        if (proposer.slot === slot) {
-          publicKeys.set(toPubkeyHex(proposer.pubkey), proposer.pubkey);
-        }
-      }
-    }
-
-    return Array.from(publicKeys.values());
-  }
-
-  removeDutiesForKey(pubkey: PubkeyHex): void {
-    for (const blockDutyAtEpoch of this.proposers.values()) {
-      blockDutyAtEpoch.data = blockDutyAtEpoch.data.filter((proposer) => {
-        return toPubkeyHex(proposer.pubkey) !== pubkey;
-      });
-    }
-  }
-
-  private runBlockDutiesTask = async (slot: Slot, signal: AbortSignal): Promise<void> => {
-    try {
-      if (slot < 0) {
-        // Before genesis, fetch the genesis duties but don't notify block production
-        // Only fetch duties once since there is not possible to re-org. TODO: Review
-        if (!this.proposers.has(GENESIS_EPOCH)) {
-          await this.pollBeaconProposers(GENESIS_EPOCH);
-        }
-      } else {
-        await this.pollBeaconProposersAndNotify(slot, signal);
-      }
-    } catch (e) {
-      this.logger.error("Error on pollBeaconProposers", {}, e as Error);
-    } finally {
-      this.pruneOldDuties(computeEpochAtSlot(slot));
-    }
-  };
-
-  /**
-   * Download the proposer duties for the current epoch and store them in `this.proposers`.
-   * If there are any proposer for this slot, send out a notification to the block proposers.
-   *
-   * ## Note
-   *
-   * This function will potentially send *two* notifications to the `BlockService`; it will send a
-   * notification initially, then it will download the latest duties and send a *second* notification
-   * if those duties have changed. This behaviour simultaneously achieves the following:
-   *
-   * 1. Block production can happen immediately and does not have to wait for the proposer duties to
-   *    download.
-   * 2. We won't miss a block if the duties for the current slot happen to change with this poll.
-   *
-   * This sounds great, but is it safe? Firstly, the additional notification will only contain block
-   * producers that were not included in the first notification. This should be safety enough.
-   * However, we also have the slashing protection as a second line of defense. These two factors
-   * provide an acceptable level of safety.
-   *
-   * It's important to note that since there is a 0-epoch look-ahead (i.e., no look-ahead) for block
-   * proposers then it's very likely that a proposal for the first slot of the epoch will need go
-   * through the slow path every time. I.e., the proposal will only happen after we've been able to
-   * download and process the duties from the BN. This means it is very important to ensure this
-   * function is as fast as possible.
-   *   - Starting from Jul 2023, we poll proposers 1s before the next epoch thanks to PrepareNextSlotScheduler
-   * usually finishes in 3s.
-   */
-  private async pollBeaconProposersAndNotify(currentSlot: Slot, signal: AbortSignal): Promise<void> {
-    const nextEpoch = computeEpochAtSlot(currentSlot) + 1;
-    const isLastSlotEpoch = computeStartSlotAtEpoch(nextEpoch) === currentSlot + 1;
-    if (isLastSlotEpoch) {
-      // no need to await for other steps, just poll proposers for next epoch
-      this.pollBeaconProposersNextEpoch(currentSlot, nextEpoch, signal).catch((e) => {
-        this.logger.error("Error on pollBeaconProposersNextEpoch", {}, e);
-      });
-    }
-
-    // Notify the block proposal service for any proposals that we have in our cache.
-    const initialBlockProposers = this.getblockProposersAtSlot(currentSlot);
-    if (initialBlockProposers.length > 0) {
-      this.notifyBlockProductionFn(currentSlot, initialBlockProposers);
-    }
-
-    // Poll proposers again for the same slot
-    await this.pollBeaconProposers(computeEpochAtSlot(currentSlot));
-
-    // Compute the block proposers for this slot again, now that we've received an update from the BN.
-    //
-    // Then, compute the difference between these two sets to obtain a set of block proposers
-    // which were not included in the initial notification to the `BlockService`.
-    const newBlockProducers = this.getblockProposersAtSlot(currentSlot);
-    const additionalBlockProducers = differenceHex(initialBlockProposers, newBlockProducers);
-
-    // If there are any new proposers for this slot, send a notification so they produce a block.
-    //
-    // See the function-level documentation for more reasoning about this behaviour.
-    if (additionalBlockProducers.length > 0) {
-      this.notifyBlockProductionFn(currentSlot, additionalBlockProducers);
-      this.logger.debug("Detected new block proposer", {currentSlot});
-      this.metrics?.newProposalDutiesDetected.inc();
-    }
-  }
-
-  /**
-   * This is to avoid some delay on the first slot of the epoch when validators have proposal duties.
-   * See https://github.com/ChainSafe/lodestar/issues/5792
-   */
-  private async pollBeaconProposersNextEpoch(currentSlot: Slot, nextEpoch: Epoch, signal: AbortSignal): Promise<void> {
-    const nextSlot = currentSlot + 1;
-    const lookAheadMs = (this.config.SECONDS_PER_SLOT * 1000) / BLOCK_DUTIES_LOOKAHEAD_FACTOR;
-    await sleep(this.clock.msToSlot(nextSlot) - lookAheadMs, signal);
-    this.logger.debug("Polling proposers for next epoch", {nextEpoch, nextSlot});
-    // Poll proposers for the next epoch
-    await this.pollBeaconProposers(nextEpoch);
-  }
-
-  private async pollBeaconProposers(epoch: Epoch): Promise<void> {
-    // Only download duties and push out additional block production events if we have some validators.
-    if (!this.validatorStore.hasSomeValidators()) {
-      return;
-    }
-
-    const res = await this.api.validator.getProposerDuties({epoch});
-    const proposerDuties = res.value();
-    const {dependentRoot} = res.meta();
-    const relevantDuties = proposerDuties.filter((duty) => {
-      const pubkeyHex = toPubkeyHex(duty.pubkey);
-      return this.validatorStore.hasVotingPubkey(pubkeyHex) && this.validatorStore.isDoppelgangerSafe(pubkeyHex);
-    });
-
-    this.logger.debug("Downloaded proposer duties", {epoch, dependentRoot, count: relevantDuties.length});
-
-    const prior = this.proposers.get(epoch);
-    this.proposers.set(epoch, {dependentRoot, data: relevantDuties});
-
-    if (prior && prior.dependentRoot !== dependentRoot) {
-      this.metrics?.proposerDutiesReorg.inc();
-      this.logger.warn("Proposer duties re-org. This may happen from time to time", {
-        priorDependentRoot: prior.dependentRoot,
-        dependentRoot,
-      });
-    }
-  }
-
-  /** Run once per epoch to prune `this.proposers` map */
-  private pruneOldDuties(currentEpoch: Epoch): void {
-    for (const epoch of this.proposers.keys()) {
-      if (epoch + HISTORICAL_DUTIES_EPOCHS < currentEpoch) {
-        this.proposers.delete(epoch);
-      }
-    }
-  }
-}

package/src/services/chainHeaderTracker.ts

@@ -1,89 +0,0 @@
-import {ApiClient, routes} from "@lodestar/api";
-import {GENESIS_SLOT} from "@lodestar/params";
-import {Root, RootHex, Slot} from "@lodestar/types";
-import {Logger, fromHex} from "@lodestar/utils";
-import {ValidatorEvent, ValidatorEventEmitter} from "./emitter.js";
-
-const {EventType} = routes.events;
-
-export type HeadEventData = {
-  slot: Slot;
-  head: RootHex;
-  previousDutyDependentRoot: RootHex;
-  currentDutyDependentRoot: RootHex;
-};
-
-type RunEveryFn = (event: HeadEventData) => Promise<void>;
-
-/**
- * Track the head slot/root using the event stream api "head".
- */
-export class ChainHeaderTracker {
-  private headBlockSlot: Slot = GENESIS_SLOT;
-  private headBlockRoot: Root | null = null;
-  private readonly fns: RunEveryFn[] = [];
-
-  constructor(
-    private readonly logger: Logger,
-    private readonly api: ApiClient,
-    private readonly emitter: ValidatorEventEmitter
-  ) {}
-
-  start(signal: AbortSignal): void {
-    this.logger.verbose("Subscribing to head event");
-    this.api.events
-      .eventstream({
-        topics: [EventType.head],
-        signal,
-        onEvent: this.onHeadUpdate,
-        onError: (e) => {
-          this.logger.error("Failed to receive head event", {}, e);
-        },
-        onClose: () => {
-          this.logger.verbose("Closed stream for head event", {});
-        },
-      })
-      .catch((e) => this.logger.error("Failed to subscribe to head event", {}, e));
-  }
-
-  getCurrentChainHead(slot: Slot): Root | null {
-    if (slot >= this.headBlockSlot) {
-      return this.headBlockRoot;
-    }
-    // We don't know head of an old block
-    return null;
-  }
-
-  runOnNewHead(fn: RunEveryFn): void {
-    this.fns.push(fn);
-  }
-
-  private onHeadUpdate = (event: routes.events.BeaconEvent): void => {
-    if (event.type === EventType.head) {
-      const {message} = event;
-      const {slot, block, previousDutyDependentRoot, currentDutyDependentRoot} = message;
-      this.headBlockSlot = slot;
-      this.headBlockRoot = fromHex(block);
-
-      const headEventData = {
-        slot: this.headBlockSlot,
-        head: block,
-        previousDutyDependentRoot: previousDutyDependentRoot,
-        currentDutyDependentRoot: currentDutyDependentRoot,
-      };
-
-      for (const fn of this.fns) {
-        fn(headEventData).catch((e) => this.logger.error("Error calling head event handler", e));
-      }
-
-      this.emitter.emit(ValidatorEvent.chainHead, headEventData);
-
-      this.logger.verbose("Found new chain head", {
-        slot: slot,
-        head: block,
-        previousDuty: previousDutyDependentRoot,
-        currentDuty: currentDutyDependentRoot,
-      });
-    }
-  };
-}

package/src/services/doppelgangerService.ts

@@ -1,286 +0,0 @@
-import {ApiClient, routes} from "@lodestar/api";
-import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {Epoch, ValidatorIndex} from "@lodestar/types";
-import {Logger, fromHex, sleep, truncBytes} from "@lodestar/utils";
-import {Metrics} from "../metrics.js";
-import {ISlashingProtection} from "../slashingProtection/index.js";
-import {ProcessShutdownCallback, PubkeyHex} from "../types.js";
-import {IClock} from "../util/index.js";
-import {IndicesService} from "./indices.js";
-
-// The number of epochs that must be checked before we assume that there are
-// no other duplicate validators on the network
-const DEFAULT_REMAINING_DETECTION_EPOCHS = 1;
-const REMAINING_EPOCHS_IF_DOPPELGANGER = Infinity;
-const REMAINING_EPOCHS_IF_SKIPPED = 0;
-
-/** Liveness responses for a given epoch */
-type EpochLivenessData = {
-  epoch: Epoch;
-  responses: routes.validator.LivenessResponseData[];
-};
-
-export type DoppelgangerState = {
-  nextEpochToCheck: Epoch;
-  remainingEpochs: Epoch;
-};
-
-export enum DoppelgangerStatus {
-  /** This pubkey is known to the doppelganger service and has been verified safe */
-  VerifiedSafe = "VerifiedSafe",
-  /** This pubkey is known to the doppelganger service but has not been verified safe */
-  Unverified = "Unverified",
-  /** This pubkey is unknown to the doppelganger service */
-  Unknown = "Unknown",
-  /** This pubkey has been detected to be active on the network */
-  DoppelgangerDetected = "DoppelgangerDetected",
-}
-
-export class DoppelgangerService {
-  private readonly doppelgangerStateByPubkey = new Map<PubkeyHex, DoppelgangerState>();
-
-  constructor(
-    private readonly logger: Logger,
-    private readonly clock: IClock,
-    private readonly api: ApiClient,
-    private readonly indicesService: IndicesService,
-    private readonly slashingProtection: ISlashingProtection,
-    private readonly processShutdownCallback: ProcessShutdownCallback,
-    private readonly metrics: Metrics | null
-  ) {
-    this.clock.runEveryEpoch(this.pollLiveness);
-
-    if (metrics) {
-      metrics.doppelganger.statusCount.addCollect(() => this.onScrapeMetrics(metrics));
-    }
-
-    this.logger.info("Doppelganger protection enabled", {detectionEpochs: DEFAULT_REMAINING_DETECTION_EPOCHS});
-  }
-
-  async registerValidator(pubkeyHex: PubkeyHex): Promise<void> {
-    const {currentEpoch} = this.clock;
-    // Disable doppelganger protection when the validator was initialized before genesis.
-    // There's no activity before genesis, so doppelganger is pointless.
-    let remainingEpochs = currentEpoch <= 0 ? REMAINING_EPOCHS_IF_SKIPPED : DEFAULT_REMAINING_DETECTION_EPOCHS;
-    const nextEpochToCheck = currentEpoch + 1;
-
-    // Log here to alert that validation won't be active until remainingEpochs == 0
-    if (remainingEpochs > 0) {
-      const previousEpoch = currentEpoch - 1;
-      const attestedInPreviousEpoch = await this.slashingProtection.hasAttestedInEpoch(
-        fromHex(pubkeyHex),
-        previousEpoch
-      );
-
-      if (attestedInPreviousEpoch) {
-        // It is safe to skip doppelganger detection
-        // https://github.com/ChainSafe/lodestar/issues/5856
-        remainingEpochs = REMAINING_EPOCHS_IF_SKIPPED;
-        this.logger.info("Doppelganger detection skipped for validator because restart was detected", {
-          pubkey: truncBytes(pubkeyHex),
-          previousEpoch,
-        });
-      } else {
-        this.logger.info("Registered validator for doppelganger detection", {
-          pubkey: truncBytes(pubkeyHex),
-          remainingEpochs,
-          nextEpochToCheck,
-        });
-      }
-    } else {
-      this.logger.info("Doppelganger detection skipped for validator initialized before genesis", {
-        pubkey: truncBytes(pubkeyHex),
-        currentEpoch,
-      });
-    }
-
-    this.doppelgangerStateByPubkey.set(pubkeyHex, {
-      nextEpochToCheck,
-      remainingEpochs,
-    });
-  }
-
-  unregisterValidator(pubkeyHex: PubkeyHex): void {
-    this.doppelgangerStateByPubkey.delete(pubkeyHex);
-  }
-
-  getStatus(pubKeyHex: PubkeyHex): DoppelgangerStatus {
-    return getStatus(this.doppelgangerStateByPubkey.get(pubKeyHex));
-  }
-
-  isDoppelgangerSafe(pubKeyHex: PubkeyHex): boolean {
-    return getStatus(this.doppelgangerStateByPubkey.get(pubKeyHex)) === DoppelgangerStatus.VerifiedSafe;
-  }
-
-  private pollLiveness = async (currentEpoch: Epoch, signal: AbortSignal): Promise<void> => {
-    if (currentEpoch < 0) {
-      return;
-    }
-
-    const endSlotOfCurrentEpoch = computeStartSlotAtEpoch(currentEpoch + 1) - 1;
-    // Run the doppelganger protection check 75% through the last slot of this epoch. This
-    // *should* mean that the BN has seen the blocks and attestations for the epoch
-    await sleep(this.clock.msToSlot(endSlotOfCurrentEpoch + 3 / 4), signal);
-
-    // Collect indices that still need doppelganger checks
-    const pubkeysToCheckWithoutIndex: PubkeyHex[] = [];
-    // Collect as Map for detectDoppelganger() which needs to map back index -> pubkey
-    const indicesToCheckMap = new Map<ValidatorIndex, PubkeyHex>();
-
-    for (const [pubkeyHex, state] of this.doppelgangerStateByPubkey.entries()) {
-      if (state.remainingEpochs > 0 && state.nextEpochToCheck <= currentEpoch) {
-        const index = this.indicesService.pubkey2index.get(pubkeyHex);
-        if (index !== undefined) {
-          indicesToCheckMap.set(index, pubkeyHex);
-        } else {
-          pubkeysToCheckWithoutIndex.push(pubkeyHex);
-        }
-      }
-    }
-
-    // Attempt to collect missing indexes
-    const newIndices = await this.indicesService.pollValidatorIndices(pubkeysToCheckWithoutIndex);
-    for (const index of newIndices) {
-      const pubkey = this.indicesService.index2pubkey.get(index);
-      if (pubkey) {
-        indicesToCheckMap.set(index, pubkey);
-      }
-    }
-
-    if (indicesToCheckMap.size === 0) {
-      return;
-    }
-
-    this.logger.info("Doppelganger liveness check", {currentEpoch, indicesCount: indicesToCheckMap.size});
-
-    // in the current epoch also request for liveness check for past epoch in case a validator index was live
-    // in the remaining 25% of the last slot of the previous epoch
-    const indicesToCheck = Array.from(indicesToCheckMap.keys());
-    const [previous, current] = await Promise.all([
-      this.getLiveness(currentEpoch - 1, indicesToCheck),
-      this.getLiveness(currentEpoch, indicesToCheck),
-    ]);
-
-    this.detectDoppelganger(currentEpoch, previous, current, indicesToCheckMap);
-  };
-
-  private async getLiveness(epoch: Epoch, indicesToCheck: ValidatorIndex[]): Promise<EpochLivenessData> {
-    if (epoch < 0) {
-      return {epoch, responses: []};
-    }
-
-    const res = await this.api.validator.getLiveness({epoch, indices: indicesToCheck});
-    if (!res.ok) {
-      this.logger.error(`Error getting liveness data for epoch ${epoch}`, {}, res.error() as Error);
-      return {epoch, responses: []};
-    }
-    return {epoch, responses: res.value()};
-  }
-
-  private detectDoppelganger(
-    currentEpoch: Epoch,
-    previousEpochLiveness: EpochLivenessData,
-    currentEpochLiveness: EpochLivenessData,
-    indicesToCheckMap: Map<ValidatorIndex, PubkeyHex>
-  ): void {
-    const previousEpoch = currentEpoch - 1;
-    const violators: ValidatorIndex[] = [];
-
-    // Perform a loop through the current and previous epoch responses and detect any violators.
-    //
-    // A following loop will update the states of each validator, depending on whether or not
-    // any violators were detected here.
-
-    for (const {epoch, responses} of [previousEpochLiveness, currentEpochLiveness]) {
-      for (const response of responses) {
-        if (!response.isLive) {
-          continue;
-        }
-
-        const state = this.doppelgangerStateByPubkey.get(indicesToCheckMap.get(response.index) ?? "");
-        if (!state) {
-          this.logger.error(`Inconsistent livenessResponseData unknown index ${response.index}`);
-          continue;
-        }
-
-        if (state.nextEpochToCheck <= epoch) {
-          // Doppelganger detected
-          violators.push(response.index);
-        }
-      }
-    }
-
-    if (violators.length > 0) {
-      // If a single doppelganger is detected, enable doppelganger checks on all validators forever
-      for (const state of this.doppelgangerStateByPubkey.values()) {
-        state.remainingEpochs = REMAINING_EPOCHS_IF_DOPPELGANGER;
-      }
-
-      this.logger.error(
-        `Doppelganger(s) detected
-        A doppelganger occurs when two different validator clients run the same public key.
-        This validator client detected another instance of a local validator on the network
-        and is shutting down to prevent potential slashable offenses. Ensure that you are not
-        running a duplicate or overlapping validator client`,
-        violators
-      );
-
-      // Request process to shutdown
-      this.processShutdownCallback(Error("Doppelganger(s) detected"));
-    }
-
-    // If not there are no validators
-    else {
-      // Iterate through all the previous epoch responses, updating `self.doppelganger_states`.
-      //
-      // Do not bother iterating through the current epoch responses since they've already been
-      // checked for violators and they don't result in updating the state.
-      for (const response of previousEpochLiveness.responses) {
-        const state = this.doppelgangerStateByPubkey.get(indicesToCheckMap.get(response.index) ?? "");
-        if (!state) {
-          this.logger.error(`Inconsistent livenessResponseData unknown index ${response.index}`);
-          continue;
-        }
-
-        if (!response.isLive && state.nextEpochToCheck <= previousEpoch) {
-          state.remainingEpochs--;
-          state.nextEpochToCheck = currentEpoch;
-          this.metrics?.doppelganger.epochsChecked.inc(1);
-
-          const {remainingEpochs, nextEpochToCheck} = state;
-          if (remainingEpochs <= 0) {
-            this.logger.info("Doppelganger detection complete", {index: response.index, epoch: currentEpoch});
-          } else {
-            this.logger.info("Found no doppelganger", {index: response.index, remainingEpochs, nextEpochToCheck});
-          }
-        }
-      }
-    }
-  }
-
-  private onScrapeMetrics(metrics: Metrics): void {
-    const countByStatus = new Map<DoppelgangerStatus, number>();
-    for (const state of this.doppelgangerStateByPubkey.values()) {
-      const status = getStatus(state);
-      countByStatus.set(status, (countByStatus.get(status) ?? 0) + 1);
-    }
-
-    // Loop over DoppelgangerStatus not countByStatus to zero status without counts
-    for (const status of Object.values(DoppelgangerStatus)) {
-      metrics.doppelganger.statusCount.set({status}, countByStatus.get(status) ?? 0);
-    }
-  }
-}
-
-function getStatus(state: DoppelgangerState | undefined): DoppelgangerStatus {
-  if (!state) {
-    return DoppelgangerStatus.Unknown;
-  }
-  if (state.remainingEpochs <= 0) {
-    return DoppelgangerStatus.VerifiedSafe;
-  }
-  if (state.remainingEpochs === REMAINING_EPOCHS_IF_DOPPELGANGER) {
-    return DoppelgangerStatus.DoppelgangerDetected;
-  }
-  return DoppelgangerStatus.Unverified;
-}

package/src/services/emitter.ts

@@ -1,43 +0,0 @@
-import {EventEmitter} from "node:events";
-import {StrictEventEmitter} from "strict-event-emitter-types";
-import {Slot} from "@lodestar/types";
-import {HeadEventData} from "./chainHeaderTracker.js";
-
-export enum ValidatorEvent {
-  /**
-   * This event signals that the node chain has a new head.
-   */
-  chainHead = "chainHead",
-}
-
-export type ValidatorEvents = {
-  [ValidatorEvent.chainHead]: (head: HeadEventData) => void;
-};
-
-/**
- * Emit important validator events.
- */
-export class ValidatorEventEmitter extends (EventEmitter as {
-  new (): StrictEventEmitter<EventEmitter, ValidatorEvents>;
-}) {
-  /**
-   * Wait for the first block to come with slot >= provided slot.
-   */
-  async waitForBlockSlot(slot: Slot): Promise<void> {
-    let headListener: (head: HeadEventData) => void;
-
-    const onDone = (): void => {
-      this.off(ValidatorEvent.chainHead, headListener);
-    };
-
-    return new Promise((resolve) => {
-      headListener = (head: HeadEventData): void => {
-        if (head.slot >= slot) {
-          onDone();
-          resolve();
-        }
-      };
-      this.on(ValidatorEvent.chainHead, headListener);
-    });
-  }
-}