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

package/src/chain/errors/index.ts

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,221 @@
+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);
+}