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

package/src/chain/errors/index.ts

@@ -1,10 +0,0 @@
-export * from "./attestationError.js";
-export * from "./attesterSlashingError.js";
-export * from "./blobSidecarError.js";
-export * from "./blockError.js";
-export * from "./blsToExecutionChangeError.js";
-export * from "./dataColumnSidecarError.js";
-export * from "./gossipValidation.js";
-export * from "./proposerSlashingError.js";
-export * from "./syncCommitteeError.js";
-export * from "./voluntaryExitError.js";

package/src/chain/errors/lightClientError.ts

@@ -1,30 +0,0 @@
-import {LodestarError} from "@lodestar/utils";
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum LightClientErrorCode {
-  FINALITY_UPDATE_ALREADY_FORWARDED = "FINALITY_UPDATE_ALREADY_FORWARDED",
-  OPTIMISTIC_UPDATE_ALREADY_FORWARDED = "OPTIMISTIC_UPDATE_ALREADY_FORWARDED",
-  FINALITY_UPDATE_RECEIVED_TOO_EARLY = "FINALITY_UPDATE_RECEIVED_TOO_EARLY",
-  OPTIMISTIC_UPDATE_RECEIVED_TOO_EARLY = "OPTIMISTIC_UPDATE_RECEIVED_TOO_EARLY",
-  FINALITY_UPDATE_NOT_MATCHING_LOCAL = "FINALITY_UPDATE_NOT_MATCHING_LOCAL",
-  OPTIMISTIC_UPDATE_NOT_MATCHING_LOCAL = "OPTIMISTIC_UPDATE_NOT_MATCHING_LOCAL",
-}
-export type LightClientErrorType =
-  | {code: LightClientErrorCode.FINALITY_UPDATE_ALREADY_FORWARDED}
-  | {code: LightClientErrorCode.OPTIMISTIC_UPDATE_ALREADY_FORWARDED}
-  | {code: LightClientErrorCode.FINALITY_UPDATE_RECEIVED_TOO_EARLY}
-  | {code: LightClientErrorCode.OPTIMISTIC_UPDATE_RECEIVED_TOO_EARLY}
-  | {code: LightClientErrorCode.FINALITY_UPDATE_NOT_MATCHING_LOCAL}
-  | {code: LightClientErrorCode.OPTIMISTIC_UPDATE_NOT_MATCHING_LOCAL};
-
-export class LightClientError extends GossipActionError<LightClientErrorType> {}
-
-// Errors for the light client server
-
-export enum LightClientServerErrorCode {
-  RESOURCE_UNAVAILABLE = "RESOURCE_UNAVAILABLE",
-}
-
-export type LightClientServerErrorType = {code: LightClientServerErrorCode.RESOURCE_UNAVAILABLE};
-
-export class LightClientServerError extends LodestarError<LightClientServerErrorType> {}

package/src/chain/errors/proposerSlashingError.ts

@@ -1,11 +0,0 @@
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum ProposerSlashingErrorCode {
-  ALREADY_EXISTS = "PROPOSER_SLASHING_ERROR_ALREADY_EXISTS",
-  INVALID = "PROPOSER_SLASHING_ERROR_INVALID",
-}
-export type ProposerSlashingErrorType =
-  | {code: ProposerSlashingErrorCode.ALREADY_EXISTS}
-  | {code: ProposerSlashingErrorCode.INVALID; error: Error};
-
-export class ProposerSlashingError extends GossipActionError<ProposerSlashingErrorType> {}

package/src/chain/errors/syncCommitteeError.ts

@@ -1,36 +0,0 @@
-import {RootHex, Slot, ValidatorIndex} from "@lodestar/types";
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum SyncCommitteeErrorCode {
-  NOT_CURRENT_SLOT = "SYNC_COMMITTEE_ERROR_NOT_CURRENT_SLOT",
-  UNKNOWN_BEACON_BLOCK_ROOT = "SYNC_COMMITTEE_ERROR_UNKNOWN_BEACON_BLOCK_ROOT",
-  SYNC_COMMITTEE_MESSAGE_KNOWN = "SYNC_COMMITTEE_ERROR_SYNC_COMMITTEE_MESSAGE_KNOWN",
-  SYNC_COMMITTEE_AGGREGATOR_ALREADY_KNOWN = "SYNC_COMMITTEE_ERROR_SYNC_COMMITTEE_AGGREGATOR_ALREADY_KNOWN",
-  SYNC_COMMITTEE_PARTICIPANTS_ALREADY_KNOWN = "SYNC_COMMITTEE_ERROR_SYNC_COMMITTEE_PARTICIPANTS_ALREADY_KNOWN",
-  VALIDATOR_NOT_IN_SYNC_COMMITTEE = "SYNC_COMMITTEE_ERROR_VALIDATOR_NOT_IN_SYNC_COMMITTEE",
-  INVALID_SIGNATURE = "SYNC_COMMITTEE_INVALID_SIGNATURE",
-  INVALID_SUBCOMMITTEE_INDEX = "SYNC_COMMITTEE_INVALID_SUBCOMMITTEE_INDEX",
-  NO_PARTICIPANT = "SYNC_COMMITTEE_NO_PARTICIPANT",
-  INVALID_AGGREGATOR = "SYNC_COMMITTEE_ERROR_INVALID_AGGREGATOR",
-  AGGREGATOR_PUBKEY_UNKNOWN = "SYNC_COMMITTEE_ERROR_AGGREGATOR_PUBKEY_UNKNOWN",
-}
-export type SyncCommitteeErrorType =
-  | {code: SyncCommitteeErrorCode.NOT_CURRENT_SLOT; slot: Slot; currentSlot: Slot}
-  | {code: SyncCommitteeErrorCode.UNKNOWN_BEACON_BLOCK_ROOT; beaconBlockRoot: Uint8Array}
-  | {
-      code: SyncCommitteeErrorCode.SYNC_COMMITTEE_MESSAGE_KNOWN;
-      validatorIndex: ValidatorIndex;
-      slot: Slot;
-      prevRoot: RootHex;
-      newRoot: RootHex;
-    }
-  | {code: SyncCommitteeErrorCode.SYNC_COMMITTEE_AGGREGATOR_ALREADY_KNOWN}
-  | {code: SyncCommitteeErrorCode.SYNC_COMMITTEE_PARTICIPANTS_ALREADY_KNOWN}
-  | {code: SyncCommitteeErrorCode.VALIDATOR_NOT_IN_SYNC_COMMITTEE; validatorIndex: ValidatorIndex}
-  | {code: SyncCommitteeErrorCode.INVALID_SIGNATURE}
-  | {code: SyncCommitteeErrorCode.INVALID_SUBCOMMITTEE_INDEX; subcommitteeIndex: number}
-  | {code: SyncCommitteeErrorCode.NO_PARTICIPANT}
-  | {code: SyncCommitteeErrorCode.INVALID_AGGREGATOR; aggregatorIndex: ValidatorIndex}
-  | {code: SyncCommitteeErrorCode.AGGREGATOR_PUBKEY_UNKNOWN; aggregatorIndex: ValidatorIndex};
-
-export class SyncCommitteeError extends GossipActionError<SyncCommitteeErrorType> {}

package/src/chain/errors/voluntaryExitError.ts

@@ -1,13 +0,0 @@
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum VoluntaryExitErrorCode {
-  ALREADY_EXISTS = "VOLUNTARY_EXIT_ERROR_ALREADY_EXISTS",
-  INVALID = "VOLUNTARY_EXIT_ERROR_INVALID",
-  INVALID_SIGNATURE = "VOLUNTARY_EXIT_ERROR_INVALID_SIGNATURE",
-}
-export type VoluntaryExitErrorType =
-  | {code: VoluntaryExitErrorCode.ALREADY_EXISTS}
-  | {code: VoluntaryExitErrorCode.INVALID}
-  | {code: VoluntaryExitErrorCode.INVALID_SIGNATURE};
-
-export class VoluntaryExitError extends GossipActionError<VoluntaryExitErrorType> {}

package/src/chain/forkChoice/index.ts

@@ -1,112 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {
-  ExecutionStatus,
-  ForkChoice,
-  ForkChoiceStore,
-  JustifiedBalancesGetter,
-  ProtoArray,
-  ForkChoiceOpts as RawForkChoiceOpts,
-} from "@lodestar/fork-choice";
-import {
-  CachedBeaconStateAllForks,
-  DataAvailabilityStatus,
-  computeAnchorCheckpoint,
-  getEffectiveBalanceIncrementsZeroInactive,
-  isExecutionStateType,
-  isMergeTransitionComplete,
-} from "@lodestar/state-transition";
-import {Slot} from "@lodestar/types";
-import {Logger, toRootHex} from "@lodestar/utils";
-import {GENESIS_SLOT} from "../../constants/index.js";
-import {Metrics} from "../../metrics/index.js";
-import {ChainEvent, ChainEventEmitter} from "../emitter.js";
-
-export type ForkChoiceOpts = RawForkChoiceOpts & {
-  // for testing only
-  forkchoiceConstructor?: typeof ForkChoice;
-};
-
-export enum ForkchoiceCaller {
-  prepareNextSlot = "prepare_next_slot",
-  importBlock = "import_block",
-}
-
-/**
- * Fork Choice extended with a ChainEventEmitter
- */
-export function initializeForkChoice(
-  config: ChainForkConfig,
-  emitter: ChainEventEmitter,
-  currentSlot: Slot,
-  state: CachedBeaconStateAllForks,
-  opts: ForkChoiceOpts,
-  justifiedBalancesGetter: JustifiedBalancesGetter,
-  metrics: Metrics | null,
-  logger?: Logger
-): ForkChoice {
-  const {blockHeader, checkpoint} = computeAnchorCheckpoint(config, state);
-  const finalizedCheckpoint = {...checkpoint};
-  const justifiedCheckpoint = {
-    ...checkpoint,
-    // If not genesis epoch, justified checkpoint epoch must be set to finalized checkpoint epoch + 1
-    // So that we don't allow the chain to initially justify with a block that isn't also finalizing the anchor state.
-    // If that happens, we will create an invalid head state,
-    // with the head not matching the fork choice justified and finalized epochs.
-    epoch: checkpoint.epoch === 0 ? checkpoint.epoch : checkpoint.epoch + 1,
-  };
-
-  const justifiedBalances = getEffectiveBalanceIncrementsZeroInactive(state);
-
-  // forkchoiceConstructor is only used for some test cases
-  // production code use ForkChoice constructor directly
-  const forkchoiceConstructor = opts.forkchoiceConstructor ?? ForkChoice;
-
-  return new forkchoiceConstructor(
-    config,
-
-    new ForkChoiceStore(
-      currentSlot,
-      justifiedCheckpoint,
-      finalizedCheckpoint,
-      justifiedBalances,
-      justifiedBalancesGetter,
-      {
-        onJustified: (cp) => emitter.emit(ChainEvent.forkChoiceJustified, cp),
-        onFinalized: (cp) => emitter.emit(ChainEvent.forkChoiceFinalized, cp),
-      }
-    ),
-
-    ProtoArray.initialize(
-      {
-        slot: blockHeader.slot,
-        parentRoot: toRootHex(blockHeader.parentRoot),
-        stateRoot: toRootHex(blockHeader.stateRoot),
-        blockRoot: toRootHex(checkpoint.root),
-        timeliness: true, // Optimisitcally assume is timely
-
-        justifiedEpoch: justifiedCheckpoint.epoch,
-        justifiedRoot: toRootHex(justifiedCheckpoint.root),
-        finalizedEpoch: finalizedCheckpoint.epoch,
-        finalizedRoot: toRootHex(finalizedCheckpoint.root),
-        unrealizedJustifiedEpoch: justifiedCheckpoint.epoch,
-        unrealizedJustifiedRoot: toRootHex(justifiedCheckpoint.root),
-        unrealizedFinalizedEpoch: finalizedCheckpoint.epoch,
-        unrealizedFinalizedRoot: toRootHex(finalizedCheckpoint.root),
-
-        ...(isExecutionStateType(state) && isMergeTransitionComplete(state)
-          ? {
-              executionPayloadBlockHash: toRootHex(state.latestExecutionPayloadHeader.blockHash),
-              executionPayloadNumber: state.latestExecutionPayloadHeader.blockNumber,
-              executionStatus: blockHeader.slot === GENESIS_SLOT ? ExecutionStatus.Valid : ExecutionStatus.Syncing,
-            }
-          : {executionPayloadBlockHash: null, executionStatus: ExecutionStatus.PreMerge}),
-
-        dataAvailabilityStatus: DataAvailabilityStatus.PreData,
-      },
-      currentSlot
-    ),
-    metrics,
-    opts,
-    logger
-  );
-}

package/src/chain/genesis/genesis.ts

@@ -1,190 +0,0 @@
-import {Tree, toGindex} from "@chainsafe/persistent-merkle-tree";
-import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
-import {GENESIS_EPOCH, GENESIS_SLOT} from "@lodestar/params";
-import {
-  BeaconStateAllForks,
-  CachedBeaconStateAllForks,
-  applyDeposits,
-  applyEth1BlockHash,
-  applyTimestamp,
-  createCachedBeaconState,
-  createEmptyEpochCacheImmutableData,
-  getActiveValidatorIndices,
-  getGenesisBeaconState,
-  getTemporaryBlockHeader,
-} from "@lodestar/state-transition";
-import {phase0, ssz} from "@lodestar/types";
-import {Logger} from "@lodestar/utils";
-import {DepositTree} from "../../db/repositories/depositDataRoot.js";
-import {IEth1Provider} from "../../eth1/index.js";
-import {IEth1StreamParams} from "../../eth1/interface.js";
-import {getDepositsAndBlockStreamForGenesis, getDepositsStream} from "../../eth1/stream.js";
-import {GenesisResult, IGenesisBuilder} from "./interface.js";
-
-export type GenesisBuilderKwargs = {
-  config: ChainForkConfig;
-  eth1Provider: IEth1Provider;
-  logger: Logger;
-
-  /** Use to restore pending progress */
-  pendingStatus?: {
-    state: BeaconStateAllForks;
-    depositTree: DepositTree;
-    lastProcessedBlockNumber: number;
-  };
-
-  signal?: AbortSignal;
-  maxBlocksPerPoll?: number;
-};
-
-export class GenesisBuilder implements IGenesisBuilder {
-  // Expose state to persist on error
-  readonly state: CachedBeaconStateAllForks;
-  readonly depositTree: DepositTree;
-  /** Is null if no block has been processed yet */
-  lastProcessedBlockNumber: number | null = null;
-
-  private readonly config: BeaconConfig;
-  private readonly eth1Provider: IEth1Provider;
-  private readonly logger: Logger;
-  private readonly signal?: AbortSignal;
-  private readonly eth1Params: IEth1StreamParams;
-  private readonly depositCache = new Set<number>();
-  private readonly fromBlock: number;
-  private readonly logEvery = 30 * 1000;
-  private lastLog = 0;
-  /** Current count of active validators in the state */
-  private activatedValidatorCount: number;
-
-  constructor({config, eth1Provider, logger, signal, pendingStatus, maxBlocksPerPoll}: GenesisBuilderKwargs) {
-    // at genesis builder, there is no genesis validator so we don't have a real BeaconConfig
-    // but we need BeaconConfig to temporarily create CachedBeaconState, the cast here is safe since we don't use any getDomain here
-    // the use of state as CachedBeaconState is just for convenient, GenesisResult returns TreeView anyway
-    this.eth1Provider = eth1Provider;
-    this.logger = logger;
-    this.signal = signal;
-    this.eth1Params = {
-      ...config,
-      maxBlocksPerPoll: maxBlocksPerPoll ?? 10000,
-    };
-
-    let stateView: BeaconStateAllForks;
-
-    if (pendingStatus) {
-      this.logger.info("Restoring pending genesis state", {block: pendingStatus.lastProcessedBlockNumber});
-      stateView = pendingStatus.state;
-      this.depositTree = pendingStatus.depositTree;
-      this.fromBlock = Math.max(pendingStatus.lastProcessedBlockNumber + 1, this.eth1Provider.deployBlock);
-    } else {
-      stateView = getGenesisBeaconState(
-        config,
-        ssz.phase0.Eth1Data.defaultValue(),
-        getTemporaryBlockHeader(config, config.getForkTypes(GENESIS_SLOT).BeaconBlock.defaultValue())
-      );
-      this.depositTree = ssz.phase0.DepositDataRootList.defaultViewDU();
-      this.fromBlock = this.eth1Provider.deployBlock;
-    }
-
-    // TODO - PENDING: Ensure EpochCacheImmutableData is created only once
-    this.state = createCachedBeaconState(stateView, createEmptyEpochCacheImmutableData(config, stateView));
-    this.config = this.state.config;
-    this.activatedValidatorCount = getActiveValidatorIndices(stateView, GENESIS_EPOCH).length;
-  }
-
-  /**
-   * Get eth1 deposit events and blocks and apply to this.state until we found genesis.
-   */
-  async waitForGenesis(): Promise<GenesisResult> {
-    await this.eth1Provider.validateContract();
-
-    // Load data from data from this.db.depositData, this.db.depositDataRoot
-    // And start from a more recent fromBlock
-    const blockNumberValidatorGenesis = await this.waitForGenesisValidators();
-
-    const depositsAndBlocksStream = getDepositsAndBlockStreamForGenesis(
-      blockNumberValidatorGenesis,
-      this.eth1Provider,
-      this.eth1Params,
-      this.signal
-    );
-
-    for await (const [depositEvents, block] of depositsAndBlocksStream) {
-      this.applyDeposits(depositEvents);
-      applyTimestamp(this.config, this.state, block.timestamp);
-      applyEth1BlockHash(this.state, block.blockHash);
-      this.lastProcessedBlockNumber = block.blockNumber;
-
-      if (
-        this.state.genesisTime >= this.config.MIN_GENESIS_TIME &&
-        this.activatedValidatorCount >= this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
-      ) {
-        this.logger.info("Found genesis state", {blockNumber: block.blockNumber});
-        return {
-          state: this.state,
-          depositTree: this.depositTree,
-          block,
-        };
-      }
-
-      this.throttledLog(`Waiting for min genesis time ${block.timestamp} / ${this.config.MIN_GENESIS_TIME}`);
-    }
-
-    throw Error("depositsStream stopped without a valid genesis state");
-  }
-
-  /**
-   * First phase of waiting for genesis.
-   * Stream deposits events in batches as big as possible without querying block data
-   * @returns Block number at which there are enough active validators is state for genesis
-   */
-  private async waitForGenesisValidators(): Promise<number> {
-    const depositsStream = getDepositsStream(this.fromBlock, this.eth1Provider, this.eth1Params, this.signal);
-
-    for await (const {depositEvents, blockNumber} of depositsStream) {
-      this.applyDeposits(depositEvents);
-      this.lastProcessedBlockNumber = blockNumber;
-
-      if (this.activatedValidatorCount >= this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT) {
-        this.logger.info("Found enough genesis validators", {blockNumber});
-        return blockNumber;
-      }
-
-      this.throttledLog(
-        `Found ${this.state.validators.length} / ${this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT} validators to genesis`
-      );
-    }
-
-    throw Error("depositsStream stopped without a valid genesis state");
-  }
-
-  private applyDeposits(depositEvents: phase0.DepositEvent[]): void {
-    const newDeposits = depositEvents
-      .filter((depositEvent) => !this.depositCache.has(depositEvent.index))
-      .map((depositEvent) => {
-        this.depositCache.add(depositEvent.index);
-        this.depositTree.push(ssz.phase0.DepositData.hashTreeRoot(depositEvent.depositData));
-        const gindex = toGindex(this.depositTree.type.depth, BigInt(depositEvent.index));
-
-        // Apply changes from the push above
-        this.depositTree.commit();
-        const depositTreeNode = this.depositTree.node;
-        return {
-          proof: new Tree(depositTreeNode).getSingleProof(gindex),
-          data: depositEvent.depositData,
-        };
-      });
-
-    const {activatedValidatorCount} = applyDeposits(this.config, this.state, newDeposits, this.depositTree);
-    this.activatedValidatorCount += activatedValidatorCount;
-
-    // TODO: If necessary persist deposits here to this.db.depositData, this.db.depositDataRoot
-  }
-
-  /** Throttle genesis generation status log to prevent spamming */
-  private throttledLog(message: string): void {
-    if (Date.now() - this.lastLog > this.logEvery) {
-      this.lastLog = Date.now();
-      this.logger.info(message);
-    }
-  }
-}

package/src/chain/genesis/interface.ts

@@ -1,14 +0,0 @@
-import {CompositeViewDU, VectorCompositeType} from "@chainsafe/ssz";
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {ssz} from "@lodestar/types";
-import {Eth1Block} from "../../eth1/interface.js";
-
-export type GenesisResult = {
-  state: CachedBeaconStateAllForks;
-  depositTree: CompositeViewDU<VectorCompositeType<typeof ssz.Root>>;
-  block: Eth1Block;
-};
-
-export interface IGenesisBuilder {
-  waitForGenesis: () => Promise<GenesisResult>;
-}

package/src/chain/index.ts

@@ -1,6 +0,0 @@
-export * from "./chain.js";
-export * from "./emitter.js";
-export * from "./forkChoice/index.js";
-export * from "./initState.js";
-export * from "./interface.js";
-export * from "./stateCache/index.js";

package/src/chain/initState.ts

@@ -1,221 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {ZERO_HASH} from "@lodestar/params";
-import {
-  BeaconStateAllForks,
-  CachedBeaconStateAllForks,
-  computeEpochAtSlot,
-  computeStartSlotAtEpoch,
-} from "@lodestar/state-transition";
-import {SignedBeaconBlock, ssz} from "@lodestar/types";
-import {Logger, toHex, toRootHex} from "@lodestar/utils";
-import {GENESIS_SLOT} from "../constants/index.js";
-import {IBeaconDb} from "../db/index.js";
-import {Eth1Provider} from "../eth1/index.js";
-import {Eth1Options} from "../eth1/options.js";
-import {Metrics} from "../metrics/index.js";
-import {GenesisBuilder} from "./genesis/genesis.js";
-import {GenesisResult} from "./genesis/interface.js";
-
-export async function persistGenesisResult(
-  db: IBeaconDb,
-  genesisResult: GenesisResult,
-  genesisBlock: SignedBeaconBlock
-): Promise<void> {
-  await Promise.all([
-    db.stateArchive.add(genesisResult.state),
-    db.blockArchive.add(genesisBlock),
-    db.depositDataRoot.putList(genesisResult.depositTree.getAllReadonlyValues()),
-    db.eth1Data.put(genesisResult.block.timestamp, {
-      ...genesisResult.block,
-      depositCount: genesisResult.depositTree.length,
-      depositRoot: genesisResult.depositTree.hashTreeRoot(),
-    }),
-  ]);
-}
-
-export async function persistAnchorState(
-  config: ChainForkConfig,
-  db: IBeaconDb,
-  anchorState: BeaconStateAllForks,
-  anchorStateBytes: Uint8Array
-): Promise<void> {
-  if (anchorState.slot === GENESIS_SLOT) {
-    const genesisBlock = createGenesisBlock(config, anchorState);
-    const blockRoot = config.getForkTypes(GENESIS_SLOT).BeaconBlock.hashTreeRoot(genesisBlock.message);
-
-    const latestBlockHeader = ssz.phase0.BeaconBlockHeader.clone(anchorState.latestBlockHeader);
-
-    if (ssz.Root.equals(latestBlockHeader.stateRoot, ZERO_HASH)) {
-      latestBlockHeader.stateRoot = anchorState.hashTreeRoot();
-    }
-
-    const latestBlockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(latestBlockHeader);
-
-    if (Buffer.compare(blockRoot, latestBlockRoot) !== 0) {
-      throw Error(
-        `Genesis block root ${toRootHex(blockRoot)} does not match genesis state latest block root ${toRootHex(latestBlockRoot)}`
-      );
-    }
-
-    await Promise.all([
-      db.blockArchive.add(genesisBlock),
-      db.block.add(genesisBlock),
-      db.stateArchive.putBinary(anchorState.slot, anchorStateBytes),
-    ]);
-  } else {
-    await db.stateArchive.putBinary(anchorState.slot, anchorStateBytes);
-  }
-}
-
-export function createGenesisBlock(config: ChainForkConfig, genesisState: BeaconStateAllForks): SignedBeaconBlock {
-  const types = config.getForkTypes(GENESIS_SLOT);
-  const genesisBlock = types.SignedBeaconBlock.defaultValue();
-  const stateRoot = genesisState.hashTreeRoot();
-  genesisBlock.message.stateRoot = stateRoot;
-  return genesisBlock;
-}
-
-/**
- * Initialize and persist a genesis state and related data
- */
-export async function initStateFromEth1({
-  config,
-  db,
-  logger,
-  opts,
-  signal,
-}: {
-  config: ChainForkConfig;
-  db: IBeaconDb;
-  logger: Logger;
-  opts: Eth1Options;
-  signal: AbortSignal;
-}): Promise<CachedBeaconStateAllForks> {
-  logger.info("Listening to eth1 for genesis state");
-
-  const statePreGenesis = await db.preGenesisState.get();
-  const depositTree = await db.depositDataRoot.getDepositRootTree();
-  const lastProcessedBlockNumber = await db.preGenesisStateLastProcessedBlock.get();
-
-  const builder = new GenesisBuilder({
-    config,
-    eth1Provider: new Eth1Provider(config, {...opts, logger}, signal),
-    logger,
-    signal,
-    pendingStatus:
-      statePreGenesis && depositTree !== undefined && lastProcessedBlockNumber != null
-        ? {state: statePreGenesis, depositTree, lastProcessedBlockNumber}
-        : undefined,
-  });
-
-  try {
-    const genesisResult = await builder.waitForGenesis();
-
-    // Note: .hashTreeRoot() automatically commits()
-    const genesisBlock = createGenesisBlock(config, genesisResult.state);
-    const types = config.getForkTypes(GENESIS_SLOT);
-    const stateRoot = genesisResult.state.hashTreeRoot();
-    const blockRoot = types.BeaconBlock.hashTreeRoot(genesisBlock.message);
-
-    logger.info("Initializing genesis state", {
-      stateRoot: toRootHex(stateRoot),
-      blockRoot: toRootHex(blockRoot),
-      validatorCount: genesisResult.state.validators.length,
-    });
-
-    await persistGenesisResult(db, genesisResult, genesisBlock);
-
-    logger.verbose("Clearing pending genesis state if any");
-    await db.preGenesisState.delete();
-    await db.preGenesisStateLastProcessedBlock.delete();
-
-    return genesisResult.state;
-  } catch (e) {
-    if (builder.lastProcessedBlockNumber != null) {
-      logger.info("Persisting genesis state", {block: builder.lastProcessedBlockNumber});
-
-      // Commit changed before serializing
-      builder.state.commit();
-
-      await db.preGenesisState.put(builder.state);
-      await db.depositDataRoot.putList(builder.depositTree.getAllReadonlyValues());
-      await db.preGenesisStateLastProcessedBlock.put(builder.lastProcessedBlockNumber);
-    }
-    throw e;
-  }
-}
-
-/**
- * Restore the latest beacon state from db
- */
-export async function initStateFromDb(
-  _config: ChainForkConfig,
-  db: IBeaconDb,
-  logger: Logger
-): Promise<BeaconStateAllForks> {
-  const state = await db.stateArchive.lastValue();
-  if (!state) {
-    throw new Error("No state exists in database");
-  }
-
-  logger.info("Initializing beacon state from db", {
-    slot: state.slot,
-    epoch: computeEpochAtSlot(state.slot),
-    stateRoot: toRootHex(state.hashTreeRoot()),
-  });
-
-  return state;
-}
-
-/**
- * Initialize and persist an anchor state (either weak subjectivity or genesis)
- */
-export async function checkAndPersistAnchorState(
-  config: ChainForkConfig,
-  db: IBeaconDb,
-  logger: Logger,
-  anchorState: BeaconStateAllForks,
-  anchorStateBytes: Uint8Array,
-  {
-    isWithinWeakSubjectivityPeriod,
-    isCheckpointState,
-  }: {isWithinWeakSubjectivityPeriod: boolean; isCheckpointState: boolean}
-): Promise<void> {
-  const expectedFork = config.getForkInfo(computeStartSlotAtEpoch(anchorState.fork.epoch));
-  const expectedForkVersion = toHex(expectedFork.version);
-  const stateFork = toHex(anchorState.fork.currentVersion);
-  if (stateFork !== expectedForkVersion) {
-    throw Error(
-      `State current fork version ${stateFork} not equal to current config ${expectedForkVersion}. Maybe caused by importing a state from a different network`
-    );
-  }
-
-  const stateInfo = isCheckpointState ? "checkpoint" : "db";
-  if (isWithinWeakSubjectivityPeriod) {
-    logger.info(`Initializing beacon from a valid ${stateInfo} state`, {
-      slot: anchorState.slot,
-      epoch: computeEpochAtSlot(anchorState.slot),
-      stateRoot: toRootHex(anchorState.hashTreeRoot()),
-      isWithinWeakSubjectivityPeriod,
-    });
-  } else {
-    logger.warn(`Initializing from a stale ${stateInfo} state vulnerable to long range attacks`, {
-      slot: anchorState.slot,
-      epoch: computeEpochAtSlot(anchorState.slot),
-      stateRoot: toRootHex(anchorState.hashTreeRoot()),
-      isWithinWeakSubjectivityPeriod,
-    });
-    logger.warn("Checkpoint sync recommended, please use --help to see checkpoint sync options");
-  }
-
-  if (isCheckpointState || anchorState.slot === GENESIS_SLOT) {
-    await persistAnchorState(config, db, anchorState, anchorStateBytes);
-  }
-}
-
-export function initBeaconMetrics(metrics: Metrics, state: BeaconStateAllForks): void {
-  metrics.headSlot.set(state.slot);
-  metrics.previousJustifiedEpoch.set(state.previousJustifiedCheckpoint.epoch);
-  metrics.currentJustifiedEpoch.set(state.currentJustifiedCheckpoint.epoch);
-  metrics.finalizedEpoch.set(state.finalizedCheckpoint.epoch);
-}