@chainsafe/lodestar 1.50.0-dev.ebecebb9ba → 1.50.0-dev.f0a5c36612

package/src/cmds/beacon/handler.ts

@@ -4,11 +4,10 @@ import {SignableENR} from "@chainsafe/enr";
 import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {hasher} from "@chainsafe/persistent-merkle-tree";
 import {BeaconDb, BeaconNode} from "@lodestar/beacon-node";
-import {ChainForkConfig, createBeaconConfig} from "@lodestar/config";
+import {ChainForkConfig} from "@lodestar/config";
 import {LevelDbController} from "@lodestar/db/controller/level";
 import {LoggerNode, getNodeLogger} from "@lodestar/logger/node";
-import {ACTIVE_PRESET, MAX_PENDING_DEPOSITS_PER_EPOCH, PresetName, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {createBeaconStateView} from "@lodestar/state-transition";
+import {ACTIVE_PRESET, PresetName} from "@lodestar/params";
 import {ErrorAborted, bytesToInt, formatBytes} from "@lodestar/utils";
 import {ProcessShutdownCallback} from "@lodestar/validator";
 import {BeaconNodeOptions, getBeaconConfigFromArgs} from "../../config/index.js";
@@ -28,6 +27,7 @@ import {initBeaconState} from "./initBeaconState.js";
 import {initPrivateKeyAndEnr} from "./initPeerIdAndEnr.js";
 import {BeaconArgs} from "./options.js";
 import {getBeaconPaths} from "./paths.js";
+import {savePubkeysFile} from "./pubkeysFile.js";
 
 const DEFAULT_RETENTION_SSZ_OBJECTS_HOURS = 15 * 24;
 const HOURS_TO_MS = 3600 * 1000;
@@ -77,20 +77,10 @@ export async function beaconHandler(args: BeaconArgs & GlobalArgs): Promise<void
   try {
     const {
       anchorState,
-      stateBytes: anchorStateBytes,
+      config: beaconConfig,
       isFinalized,
-    } = await initBeaconState(args, beaconPaths.dataDir, config, db, logger);
-    const beaconConfig = createBeaconConfig(config, anchorState.genesisValidatorsRoot);
-    // Reserve 3 months of worst-case registry growth (MAX_PENDING_DEPOSITS_PER_EPOCH per epoch),
-    // over a year at organic rates, to avoid routine cache reallocations. Cache growth is protected
-    // by its native lock; if this headroom is exceeded, it grows by the same fixed step.
-    const headroomEpochs = (90 * 24 * 60 * 60) / (config.SECONDS_PER_SLOT * SLOTS_PER_EPOCH);
-    const pubkeyCacheHeadroom = MAX_PENDING_DEPOSITS_PER_EPOCH * Math.ceil(headroomEpochs);
-    pubkeyCache.ensureCapacity(anchorState.validators.length + pubkeyCacheHeadroom);
-    pubkeyCache.syncPubkeys(anchorState.validators.getAllReadonlyValues());
-    const anchorStateView = args["chain.nativeStateView"]
-      ? createBeaconStateView({useNative: true, stateBytes: anchorStateBytes})
-      : createBeaconStateView({useNative: false, anchorState, config: beaconConfig, pubkeyCache});
+      earliestAvailableSlot,
+    } = await initBeaconState(args, beaconPaths.dataDir, beaconPaths.pubkeysFile, config, db, logger);
 
     const node = await BeaconNode.init({
       opts: options,
@@ -103,8 +93,9 @@ export async function beaconHandler(args: BeaconArgs & GlobalArgs): Promise<void
       dataDir: beaconPaths.dataDir,
       dataColumnDir: beaconPaths.dataColumnDir,
       peerStoreDir: beaconPaths.peerStoreDir,
-      anchorState: anchorStateView,
+      anchorState,
       isAnchorStateFinalized: isFinalized,
+      earliestAvailableSlot,
     });
 
     // dev debug option to have access to the BN instance
@@ -151,21 +142,21 @@ export async function beaconHandler(args: BeaconArgs & GlobalArgs): Promise<void
     abortController.signal.addEventListener(
       "abort",
       async () => {
+        let exitCode = 0;
         try {
           await node.close();
           logger.debug("Beacon node closed");
-          // Explicitly exit until active handles issue is resolved
-          // See https://github.com/ChainSafe/lodestar/issues/5642
-          process.exit(0);
         } catch (e) {
           // If we start from unfinalized state, we don't have checkpoint state so there is this error
           // "No state in cache for finalized checkpoint state epoch"
           logger.warn("Error closing beacon node", {}, e as Error);
           // Make sure db is always closed gracefully
           await db.close();
-          // Must explicitly exit process due to potential active handles
-          process.exit(1);
+          exitCode = 1;
         }
+        savePubkeysFile(pubkeyCache, beaconPaths.pubkeysFile, logger);
+        // Explicitly exit process due to potential active handles
+        process.exit(exitCode);
       },
       {once: true}
     );
@@ -241,6 +232,12 @@ export async function beaconHandlerInit(args: BeaconArgs & GlobalArgs) {
   // Render final options
   const options = beaconNodeOptions.getWithDefaults();
 
+  if (options.chain.nativeStateTransition && config.GLOAS_FORK_EPOCH !== Infinity) {
+    throw Error(
+      `--chain.nativeStateTransition does not support Gloas, which is scheduled at epoch ${config.GLOAS_FORK_EPOCH}`
+    );
+  }
+
   return {config, options, beaconPaths, network, version, commit, privateKey, logger};
 }
 

package/src/cmds/beacon/initBeaconState.ts

@@ -1,416 +1,165 @@
+import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
+import {IBeaconDb} from "@lodestar/beacon-node";
+import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
+import {MAX_PENDING_DEPOSITS_PER_EPOCH, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
-  DbCPStateDatastore,
-  FileCPStateDatastore,
-  IBeaconDb,
-  checkAndPersistAnchorState,
-  getStateTypeFromBytes,
-} from "@lodestar/beacon-node";
-import {BeaconConfig, ChainForkConfig, createBeaconConfig} from "@lodestar/config";
-import {
-  BeaconStateAllForks,
-  computeAnchorCheckpoint,
-  computeEpochAtSlot,
-  ensureWithinWeakSubjectivityPeriod,
-  isWithinWeakSubjectivityPeriod,
-  loadState,
-  loadStateAndValidators,
+  IBeaconStateView,
+  computeWeakSubjectivitySummaryFromStateBytes,
+  createBeaconStateView,
+  getValidatorCountFromStateBytes,
+  isWithinWeakSubjectivityPeriodFromSummary,
+  readBeaconStateBytesMetadata,
 } from "@lodestar/state-transition";
-import {ssz} from "@lodestar/types";
-import {Checkpoint} from "@lodestar/types/phase0";
-import {Logger, formatBytes, toRootHex} from "@lodestar/utils";
-import {
-  fetchWeakSubjectivityState,
-  getCheckpointFromArg,
-  getCheckpointFromState,
-  getGenesisFileUrl,
-  getGenesisStateRoot,
-} from "../../networks/index.js";
-import {GlobalArgs, defaultNetwork} from "../../options/globalOptions.js";
-import {downloadOrLoadFile, wrapFnError} from "../../util/index.js";
+import {Slot} from "@lodestar/types";
+import {Logger, formatBytes} from "@lodestar/utils";
+import {GlobalArgs} from "../../options/globalOptions.js";
 import {BeaconArgs} from "./options.js";
-
-type StateWithBytes = {state: BeaconStateAllForks; stateBytes: Uint8Array};
-
-async function initAndVerifyWeakSubjectivityState(
-  config: BeaconConfig,
-  db: IBeaconDb,
-  logger: Logger,
-  dbStateBytes: StateWithBytes,
-  wsStateBytes: StateWithBytes,
-  isWsStateFinalized: boolean,
-  wsCheckpoint: Checkpoint,
-  opts: {forceCheckpointSync?: boolean; ignoreWeakSubjectivityCheck?: boolean} = {}
-): Promise<{anchorState: BeaconStateAllForks; stateBytes: Uint8Array}> {
-  const dbState = dbStateBytes.state;
-  const wsState = wsStateBytes.state;
-  // Check if the store's state and wsState are compatible
-  if (
-    dbState.genesisTime !== wsState.genesisTime ||
-    !ssz.Root.equals(dbState.genesisValidatorsRoot, wsState.genesisValidatorsRoot)
-  ) {
-    throw new Error(
-      "Db state and checkpoint state are not compatible, either clear the db or verify your checkpoint source"
-    );
-  }
-
-  // Pick the state which is ahead as an anchor to initialize the beacon chain
-  let anchorState = wsStateBytes;
-  let anchorCheckpoint = wsCheckpoint;
-  let isCheckpointState = true;
-  if (dbState.slot > wsState.slot && !opts.forceCheckpointSync) {
-    anchorState = dbStateBytes;
-    anchorCheckpoint = getCheckpointFromState(dbState);
-    isCheckpointState = false;
-    logger.verbose(
-      "Db state is ahead of the provided checkpoint state, using the db state to initialize the beacon chain"
-    );
-  }
-
-  // Throw error unless user explicitly asked not to, in testnets can happen that wss period is too small
-  // that even some epochs of non finalization can cause finalized checkpoint to be out of valid range
-  const wssCheck = wrapFnError(() => ensureWithinWeakSubjectivityPeriod(config, anchorState.state, anchorCheckpoint));
-  const isWithinWeakSubjectivityPeriod = wssCheck.err === null;
-  if (!isWithinWeakSubjectivityPeriod && !opts.ignoreWeakSubjectivityCheck) {
-    throw wssCheck.err;
-  }
-
-  if (isWsStateFinalized) {
-    await checkAndPersistAnchorState(config, db, logger, anchorState.state, anchorState.stateBytes, {
-      isWithinWeakSubjectivityPeriod,
-      isCheckpointState,
-    });
-  }
-
-  return {anchorState: anchorState.state, stateBytes: anchorState.stateBytes};
-}
+import {loadPubkeysFile} from "./pubkeysFile.js";
+import {StateInitializationError, StateInitializationErrorCode} from "./stateInitialization/errors.js";
+import {prepareGenesisInitialization} from "./stateInitialization/genesisState.js";
+import {
+  prepareArchivedStateInitialization,
+  prepareCheckpointSourceInitialization,
+} from "./stateInitialization/prepareStateInitialization.js";
+import {
+  ArchivedStateBytes,
+  StateInitialization,
+  StateInitializationOptions,
+  StatePreparationContext,
+} from "./stateInitialization/types.js";
+
+type InitBeaconStateResult = {
+  anchorState: IBeaconStateView;
+  config: BeaconConfig;
+  isFinalized: boolean;
+  earliestAvailableSlot: Slot;
+};
 
 /**
- * Initialize a beacon state, picking the strategy based on the `IBeaconArgs`
- *
- * State is initialized in one of three ways:
- * 1. restore from weak subjectivity state (possibly downloaded from a remote beacon node)
- * 2. restore from db
- * 3. restore from genesis state (possibly downloaded via URL)
- *
- * The returned anchorState could be finalized or not.
- * - if we load from checkpointState, checkpointSyncUrl, genesisStateFile or archived db, it is finalized
- * - it's not finalized if we load from unsafeCheckpointState or lastPersistedCheckpointState
+ * Select serialized anchor bytes before constructing the state used for validation, persistence, and return.
+ * Populates the global `pubkeyCache` with the anchor state's validators, reusing `pubkeysFile` if it matches.
  */
 export async function initBeaconState(
   args: BeaconArgs & GlobalArgs,
   dataDir: string,
+  pubkeysFile: string,
   chainForkConfig: ChainForkConfig,
   db: IBeaconDb,
   logger: Logger
-): Promise<{
-  anchorState: BeaconStateAllForks;
-  stateBytes: Uint8Array;
-  isFinalized: boolean;
-}> {
-  if (args.forceCheckpointSync && !(args.checkpointState || args.checkpointSyncUrl || args.unsafeCheckpointState)) {
-    throw new Error("Forced checkpoint sync without specifying a checkpointState or checkpointSyncUrl");
-  }
-  // fetch the latest state stored in the db which will be used in all cases, if it exists, either
-  //   i)  used directly as the anchor state
-  //   ii) used to load and verify a weak subjectivity state,
-  const lastDbSlot = await db.stateArchive.lastKey();
-  let stateBytes = lastDbSlot !== null ? await db.stateArchive.getBinary(lastDbSlot) : null;
-  // Convert to `Uint8Array` to avoid unexpected behavior such as `Buffer.prototype.slice` not copying memory
-  stateBytes = stateBytes ? new Uint8Array(stateBytes.buffer, stateBytes.byteOffset, stateBytes.byteLength) : null;
-  let lastDbState: BeaconStateAllForks | null = null;
-  let lastDbValidatorsBytes: Uint8Array | null = null;
-  let lastDbStateWithBytes: StateWithBytes | null = null;
-  if (stateBytes) {
-    logger.verbose("Found the last archived state", {slot: lastDbSlot, size: formatBytes(stateBytes.length)});
-    const {state, validatorsBytes} = loadStateAndValidators(chainForkConfig, stateBytes);
-    lastDbState = state;
-    lastDbValidatorsBytes = validatorsBytes;
-    lastDbStateWithBytes = {state, stateBytes: stateBytes};
-  }
-
-  if (lastDbState) {
-    // state from archive db is finalized
-    const isFinalized = true;
-    const config = createBeaconConfig(chainForkConfig, lastDbState.genesisValidatorsRoot);
-    const wssCheck = isWithinWeakSubjectivityPeriod(config, lastDbState, getCheckpointFromState(lastDbState));
-
-    // Explicitly force syncing from checkpoint state
-    if (args.forceCheckpointSync) {
-      // Forcing to sync from checkpoint is only recommended if node is taking too long to sync from last db state.
-      // It is important to remind the user to remove this flag again unless it is absolutely necessary.
-      if (wssCheck) {
-        logger.warn(
-          `Forced syncing from checkpoint even though db state at slot ${lastDbState.slot} is within weak subjectivity period`
-        );
-        logger.warn("Please consider removing --forceCheckpointSync flag unless absolutely necessary");
-      }
-    } else {
-      // All cases when we want to directly use lastDbState as the anchor state:
-      //  - if no checkpoint sync args provided, or
-      //  - the lastDbState is within weak subjectivity period:
-      if (
-        (!args.checkpointState &&
-          !args.checkpointSyncUrl &&
-          !args.unsafeCheckpointState &&
-          !args.lastPersistedCheckpointState) ||
-        wssCheck
-      ) {
-        if (stateBytes === null) {
-          // this never happens
-          throw Error(`There is no stateBytes for the lastDbState at slot ${lastDbState.slot}`);
-        }
-        await checkAndPersistAnchorState(config, db, logger, lastDbState, stateBytes, {
-          isWithinWeakSubjectivityPeriod: wssCheck,
-          isCheckpointState: false,
-        });
-        logger.info("Initialized state from db", {
-          slot: lastDbState.slot,
-          epoch: computeEpochAtSlot(lastDbState.slot),
-          stateRoot: toRootHex(lastDbState.hashTreeRoot()),
-          isFinalized,
-        });
-        return {anchorState: lastDbState, stateBytes, isFinalized};
-      }
-    }
-  }
-
-  // See if we can sync state using checkpoint sync args or else start from genesis
-  if (args.checkpointState) {
-    // state is trusted to be finalized
-    const isFinalized = true;
-    logger.info("Loading checkpoint state", {checkpointState: args.checkpointState});
-    const stateBytes = await downloadOrLoadFile(args.checkpointState);
-    logger.info("Loaded checkpoint state", {
-      size: formatBytes(stateBytes.length),
-    });
-
-    const stateAndCp = await readWSState(
-      lastDbStateWithBytes,
-      lastDbValidatorsBytes,
-      {
-        stateBytes,
-        isFinalized,
-        wssCheckpoint: args.wssCheckpoint,
-        forceCheckpointSync: args.forceCheckpointSync,
-        ignoreWeakSubjectivityCheck: args.ignoreWeakSubjectivityCheck,
-      },
-      chainForkConfig,
-      db,
-      logger
-    );
-
-    const {checkpoint} = computeAnchorCheckpoint(chainForkConfig, stateAndCp.anchorState);
-
-    logger.info("Initialized checkpoint state", {
-      slot: stateAndCp.anchorState.slot,
-      epoch: checkpoint.epoch,
-      checkpointRoot: toRootHex(checkpoint.root),
-      isFinalized,
-    });
-
-    return {...stateAndCp, isFinalized};
-  }
-
-  if (args.checkpointSyncUrl) {
-    // state is trusted to be finalized
-    const isFinalized = true;
-    const stateAndCp = await fetchWSStateFromBeaconApi(
-      lastDbStateWithBytes,
-      lastDbValidatorsBytes,
-      {
-        checkpointSyncUrl: args.checkpointSyncUrl,
-        wssCheckpoint: args.wssCheckpoint,
-        forceCheckpointSync: args.forceCheckpointSync,
-        ignoreWeakSubjectivityCheck: args.ignoreWeakSubjectivityCheck,
-      },
-      chainForkConfig,
-      db,
-      logger
+): Promise<InitBeaconStateResult> {
+  const options: StateInitializationOptions = args;
+  const nativeStateTransition = options["chain.nativeStateTransition"] ?? false;
+  if (
+    options.forceCheckpointSync &&
+    !(options.checkpointState || options.checkpointSyncUrl || options.unsafeCheckpointState)
+  ) {
+    throw new StateInitializationError(
+      {code: StateInitializationErrorCode.INVALID_CHECKPOINT_SOURCE},
+      "Forced checkpoint sync without specifying a checkpointState, checkpointSyncUrl or unsafeCheckpointState"
     );
-
-    const {checkpoint} = computeAnchorCheckpoint(chainForkConfig, stateAndCp.anchorState);
-
-    logger.info("Initialized checkpoint state", {
-      slot: stateAndCp.anchorState.slot,
-      epoch: checkpoint.epoch,
-      checkpointRoot: toRootHex(checkpoint.root),
-      isFinalized,
-    });
-
-    return {...stateAndCp, isFinalized};
   }
-
-  if (args.unsafeCheckpointState || args.lastPersistedCheckpointState) {
-    // state is supposed to be not yet finalized
-    const isFinalized = false;
-    let stateBytes: Uint8Array | null = null;
-    // prioritize lastPersistedCheckpointState over unsafeCheckpointState, unless forceCheckpointSync is set
-    if (args.lastPersistedCheckpointState && !args.forceCheckpointSync) {
-      // find the last persisted checkpoint state to load
-      const cpDataStore = args["chain.nHistoricalStatesFileDataStore"]
-        ? new FileCPStateDatastore(dataDir)
-        : new DbCPStateDatastore(db);
-      logger.verbose(`Finding last persisted checkpoint state from ${cpDataStore.constructor.name}`);
-      stateBytes = await cpDataStore.readLatestSafe();
-      if (stateBytes === null) {
-        logger.warn("Last persisted checkpoint state not found");
-      } else {
-        logger.info("Found last persisted checkpoint state", {size: formatBytes(stateBytes.length)});
-      }
-    }
-
-    if (stateBytes === null && args.unsafeCheckpointState) {
-      logger.info("Loading checkpoint state", {unsafeCheckpointState: args.unsafeCheckpointState});
-      stateBytes = await downloadOrLoadFile(args.unsafeCheckpointState);
-      logger.info("Loaded checkpoint state", {
-        size: formatBytes(stateBytes.length),
+  const context: StatePreparationContext = {chainForkConfig, db, dataDir, logger};
+  const archived = await readLatestArchivedStateBytes(context);
+  if (archived !== null) {
+    if (options.forceCheckpointSync && archived.isWithinWeakSubjectivityPeriod) {
+      logger.warn("Forced syncing from checkpoint even though db state is within weak subjectivity period", {
+        slot: archived.metadata.slot,
       });
+      logger.warn("Please consider removing --forceCheckpointSync flag unless absolutely necessary");
     }
-
-    if (stateBytes !== null) {
-      logger.warn(
-        "Initializing from unfinalized checkpoint state is unsafe and may cause the node to follow a minority chain"
-      );
-      const stateAndCp = await readWSState(
-        lastDbStateWithBytes,
-        lastDbValidatorsBytes,
-        {
-          stateBytes,
-          isFinalized,
-          wssCheckpoint: args.wssCheckpoint,
-          forceCheckpointSync: args.forceCheckpointSync,
-          ignoreWeakSubjectivityCheck: args.ignoreWeakSubjectivityCheck,
-        },
-        chainForkConfig,
-        db,
+    const hasCheckpointSource = Boolean(
+      options.checkpointState ||
+        options.checkpointSyncUrl ||
+        options.unsafeCheckpointState ||
+        options.lastPersistedCheckpointState
+    );
+    if (!options.forceCheckpointSync && (!hasCheckpointSource || archived.isWithinWeakSubjectivityPeriod)) {
+      return executeStateInitialization(
+        prepareArchivedStateInitialization(archived, context),
+        nativeStateTransition,
+        pubkeysFile,
         logger
       );
-
-      const lastProcessedSlot = stateAndCp.anchorState.latestBlockHeader.slot;
-      const {checkpoint} = computeAnchorCheckpoint(chainForkConfig, stateAndCp.anchorState);
-
-      logger.info("Initialized checkpoint state", {
-        slot: stateAndCp.anchorState.slot,
-        epoch: checkpoint.epoch,
-        checkpointRoot: toRootHex(checkpoint.root),
-        lastProcessedSlot,
-        isFinalized,
-      });
-
-      return {...stateAndCp, isFinalized};
     }
   }
-
-  const genesisStateFile = args.genesisStateFile || getGenesisFileUrl(args.network || defaultNetwork);
-  if (genesisStateFile && !args.forceGenesis) {
-    // genesis state is considered finalized
-    const isFinalized = true;
-    logger.info("Loading genesis state", {genesisStateFile});
-    let stateBytes = await downloadOrLoadFile(genesisStateFile);
-    logger.info("Loaded genesis state", {size: formatBytes(stateBytes.length)});
-    // Convert to `Uint8Array` to avoid unexpected behavior such as `Buffer.prototype.slice` not copying memory
-    stateBytes = new Uint8Array(stateBytes.buffer, stateBytes.byteOffset, stateBytes.byteLength);
-    const anchorState = getStateTypeFromBytes(chainForkConfig, stateBytes).deserializeToViewDU(stateBytes);
-    // Validate genesis state root
-    const stateRoot = toRootHex(anchorState.hashTreeRoot());
-    const expectedRoot = getGenesisStateRoot(args.network);
-    if (expectedRoot !== null && stateRoot !== expectedRoot) {
-      throw Error(`Genesis state root mismatch expected=${expectedRoot} received=${stateRoot}`);
-    }
-    const config = createBeaconConfig(chainForkConfig, anchorState.genesisValidatorsRoot);
-    const wssCheck = isWithinWeakSubjectivityPeriod(config, anchorState, getCheckpointFromState(anchorState));
-    await checkAndPersistAnchorState(config, db, logger, anchorState, stateBytes, {
-      isWithinWeakSubjectivityPeriod: wssCheck,
-      isCheckpointState: true,
-    });
-    logger.info("Initialized genesis state", {
-      slot: anchorState.slot,
-      stateRoot,
-      isFinalized,
-    });
-    return {anchorState, stateBytes, isFinalized};
+  let stateInit = await prepareCheckpointSourceInitialization(options, archived, context);
+  if (stateInit === null) {
+    // Without a usable checkpoint state, resume from the db as if no checkpoint source was set instead of genesis
+    stateInit =
+      archived !== null
+        ? prepareArchivedStateInitialization(archived, context)
+        : await prepareGenesisInitialization(options, context);
   }
-
-  throw Error("Failed to initialize beacon state, please provide a genesis state file or use checkpoint sync");
+  return executeStateInitialization(stateInit, nativeStateTransition, pubkeysFile, logger);
 }
 
-async function readWSState(
-  lastDbStateBytes: StateWithBytes | null,
-  lastDbValidatorsBytes: Uint8Array | null,
-  wssOpts: {
-    stateBytes: Uint8Array;
-    isFinalized: boolean;
-    wssCheckpoint?: string;
-    forceCheckpointSync?: boolean;
-    ignoreWeakSubjectivityCheck?: boolean;
-  },
-  chainForkConfig: ChainForkConfig,
-  db: IBeaconDb,
-  logger: Logger
-): Promise<{anchorState: BeaconStateAllForks; stateBytes: Uint8Array}> {
-  // weak subjectivity sync from a provided state file:
-  // if a weak subjectivity checkpoint has been provided, it is used for additional verification
-  // otherwise, the state itself is used for verification (not bad, because the trusted state has been explicitly provided)
-  const {stateBytes, isFinalized, wssCheckpoint, forceCheckpointSync, ignoreWeakSubjectivityCheck} = wssOpts;
-  const lastDbState = lastDbStateBytes?.state ?? null;
-
-  let wsState: BeaconStateAllForks;
-  if (lastDbState && lastDbValidatorsBytes) {
-    // use lastDbState to load wsState if possible to share the same state tree
-    wsState = loadState(chainForkConfig, lastDbState, stateBytes, lastDbValidatorsBytes).state;
-  } else {
-    wsState = getStateTypeFromBytes(chainForkConfig, stateBytes).deserializeToViewDU(stateBytes);
+/**
+ * Read the archived DB anchor without constructing a state. Retain its metadata, weak-subjectivity summary,
+ * and period verdict so selection and initialization use the same result without rescanning or checking time again.
+ */
+async function readLatestArchivedStateBytes({
+  chainForkConfig,
+  db,
+  logger,
+}: StatePreparationContext): Promise<ArchivedStateBytes | null> {
+  const slot = await db.stateArchive.lastKey();
+  const bytes = slot === null ? null : await db.stateArchive.getBinary(slot);
+  if (bytes === null) return null;
+  logger.verbose("Found the last archived state", {slot, size: formatBytes(bytes.length)});
+  const stateBytes = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const metadata = readBeaconStateBytesMetadata(stateBytes);
+  if (metadata === null) {
+    throw new StateInitializationError(
+      {code: StateInitializationErrorCode.MALFORMED_STATE_BYTES},
+      "Cannot read metadata from archived state bytes"
+    );
   }
-  const config = createBeaconConfig(chainForkConfig, wsState.genesisValidatorsRoot);
-  const wsStateBytes = {state: wsState, stateBytes};
-  const store = lastDbStateBytes ?? wsStateBytes;
-  const checkpoint = wssCheckpoint ? getCheckpointFromArg(wssCheckpoint) : getCheckpointFromState(wsState);
-  return initAndVerifyWeakSubjectivityState(config, db, logger, store, wsStateBytes, isFinalized, checkpoint, {
-    forceCheckpointSync,
-    ignoreWeakSubjectivityCheck,
-  });
+  const weakSubjectivity = computeWeakSubjectivitySummaryFromStateBytes(chainForkConfig, stateBytes, metadata);
+  if (weakSubjectivity === null) {
+    throw new StateInitializationError(
+      {code: StateInitializationErrorCode.MALFORMED_STATE_BYTES},
+      `Cannot extract weak subjectivity summary from archived state bytes, expected ${chainForkConfig.getForkName(metadata.slot)} state at slot ${metadata.slot}, possible fork or network mismatch`
+    );
+  }
+  return {
+    stateBytes,
+    metadata,
+    weakSubjectivity,
+    isWithinWeakSubjectivityPeriod: isWithinWeakSubjectivityPeriodFromSummary(chainForkConfig, weakSubjectivity),
+  };
 }
 
-async function fetchWSStateFromBeaconApi(
-  lastDbStateBytes: StateWithBytes | null,
-  lastDbValidatorsBytes: Uint8Array | null,
-  wssOpts: {
-    checkpointSyncUrl: string;
-    wssCheckpoint?: string;
-    forceCheckpointSync?: boolean;
-    ignoreWeakSubjectivityCheck?: boolean;
-  },
-  chainForkConfig: ChainForkConfig,
-  db: IBeaconDb,
+/**
+ * Shared completion template for all sources: construct only the selected state, exactly once.
+ * Validate before persistence, and log success only after any required writes succeed.
+ */
+async function executeStateInitialization(
+  stateInit: StateInitialization,
+  nativeStateTransition: boolean,
+  pubkeysFile: string,
   logger: Logger
-): Promise<{anchorState: BeaconStateAllForks; stateBytes: Uint8Array}> {
-  // weak subjectivity sync from a state that needs to be fetched:
-  // if a weak subjectivity checkpoint has been provided, it is used to inform which state to download and used for additional verification
-  // otherwise, the 'finalized' state is downloaded and the state itself is used for verification (all trust delegated to the remote beacon node)
-  try {
-    // Validate the weakSubjectivityServerUrl and only log the origin to mask the
-    // username password credentials
-    const checkpointSyncUrl = new URL(wssOpts.checkpointSyncUrl);
-    logger.info("Fetching checkpoint state", {
-      checkpointSyncUrl: checkpointSyncUrl.origin,
-    });
-  } catch (e) {
-    logger.error("Invalid", {checkpointSyncUrl: wssOpts.checkpointSyncUrl}, e as Error);
-    throw e;
+): Promise<InitBeaconStateResult> {
+  const {config, stateBytes} = stateInit;
+  const validatorCount = getValidatorCountFromStateBytes(config, stateBytes);
+  if (validatorCount === null) {
+    throw new StateInitializationError(
+      {code: StateInitializationErrorCode.MALFORMED_STATE_BYTES},
+      "Cannot read validator count from selected state bytes"
+    );
   }
-
-  const {wsState, wsStateBytes, wsCheckpoint} = await fetchWeakSubjectivityState(chainForkConfig, logger, wssOpts, {
-    lastDbState: lastDbStateBytes?.state ?? null,
-    lastDbValidatorsBytes,
-  });
-
-  const config = createBeaconConfig(chainForkConfig, wsState.genesisValidatorsRoot);
-  const wsStateWithBytes = {state: wsState, stateBytes: wsStateBytes};
-  const store = lastDbStateBytes ?? wsStateWithBytes;
-  // a fetched ws state is trusted to be finalized
-  const isFinalized = true;
-  return initAndVerifyWeakSubjectivityState(config, db, logger, store, wsStateWithBytes, isFinalized, wsCheckpoint, {
-    forceCheckpointSync: wssOpts.forceCheckpointSync,
-    ignoreWeakSubjectivityCheck: wssOpts.ignoreWeakSubjectivityCheck,
-  });
+  // Reserve 3 months of worst-case registry growth (MAX_PENDING_DEPOSITS_PER_EPOCH per epoch),
+  // over a year at organic rates, to avoid routine cache reallocations. Cache growth is protected
+  // by its native lock; if this headroom is exceeded, it grows by the same fixed step.
+  // The view syncs pubkeys during construction, so capacity must be reserved first.
+  const headroomEpochs = (90 * 24 * 60 * 60) / (config.SECONDS_PER_SLOT * SLOTS_PER_EPOCH);
+  const pubkeyCacheCapacity = validatorCount + MAX_PENDING_DEPOSITS_PER_EPOCH * Math.ceil(headroomEpochs);
+  loadPubkeysFile(pubkeyCache, pubkeysFile, pubkeyCacheCapacity, config, stateBytes, validatorCount, logger);
+  // unilaterally expand capacity after best-effort pubkey file loading
+  pubkeyCache.ensureCapacity(pubkeyCacheCapacity);
+  const anchorState = createBeaconStateView({nativeStateTransition, config, stateBytes});
+  stateInit.validate(anchorState);
+  const earliestAvailableSlot = await stateInit.initializeEarliestAvailableSlot(anchorState);
+  await stateInit.persist?.(anchorState, stateBytes);
+  stateInit.log(anchorState, nativeStateTransition);
+  return {anchorState, config, isFinalized: stateInit.isFinalized, earliestAvailableSlot};
 }