@chainsafe/lodestar 1.50.0-dev.fef46df5ba → 1.50.0

package/lib/options/beaconNodeOptions/execution.js.map

@@ -1 +1 @@
-{"version":3,"file":"execution.js","sourceRoot":"","sources":["../../../src/options/beaconNodeOptions/execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,EAAqB,8BAA8B,EAAC,MAAM,uBAAuB,CAAC;AAEzF,OAAO,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAYxD,MAAM,UAAU,SAAS,CAAC,IAAyB;IACjD,IAAI,IAAI,CAAC,sBAAsB,CAAC,EAAE,CAAC;QACjC,sEAAsE;QACtE,OAAO;YACL,IAAI,EAAE,MAAM;SACb,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC;QAC5B,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC;QAClC,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC;QAClC,UAAU,EAAE,IAAI,CAAC,sBAAsB,CAAC;QACxC;;;WAGG;QACH,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,mBAAmB,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS;QAC/G,KAAK,EAAE,IAAI,CAAC,KAAK;KAClB,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,OAAO,GAA2C;IAC7D,gBAAgB,EAAE;QAChB,WAAW,EAAE,qCAAqC;QAClD,OAAO,EAAE,8BAA8B,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;QACtD,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,IAAI;QACZ,MAAM,EAAE,CAAC,IAAc,EAAY,EAAE;QACnC,0CAA0C;QAC1C,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACzC,KAAK,EAAE,WAAW;KACnB;IAED,mBAAmB,EAAE;QACnB,WAAW,EAAE,8DAA8D;QAC3E,IAAI,EAAE,QAAQ;QACd,kBAAkB,EAAE,MAAM,CAAC,8BAA8B,CAAC,OAAO,CAAC;QAClE,KAAK,EAAE,WAAW;KACnB;IAED,mBAAmB,EAAE;QACnB,KAAK,EAAE,CAAC,yBAAyB,CAAC;QAClC,WAAW,EAAE,qDAAqD;QAClE,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,8BAA8B,CAAC,OAAO;QAC/C,KAAK,EAAE,WAAW;KACnB;IAED,sBAAsB,EAAE;QACtB,WAAW,EAAE,4FAA4F;QACzG,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,8BAA8B,CAAC,UAAU;QAClD,KAAK,EAAE,WAAW;KACnB;IAED,sBAAsB,EAAE;QACtB,WAAW,EAAE,0DAA0D;QACvE,IAAI,EAAE,SAAS;QACf,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,WAAW;KACnB;IAED,SAAS,EAAE;QACT,WAAW,EACT,mQAAmQ;QACrQ,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,WAAW;KACnB;IAED,KAAK,EAAE;QACL,WAAW,EACT,+JAA+J;QACjK,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,WAAW;KACnB;CACF,CAAC"}
+{"version":3,"file":"execution.js","sourceRoot":"","sources":["../../../src/options/beaconNodeOptions/execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,EAAoC,8BAA8B,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAExH,OAAO,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAaxD,MAAM,UAAU,SAAS,CAAC,IAAyB;IACjD,IAAI,IAAI,CAAC,sBAAsB,CAAC,EAAE,CAAC;QACjC,sEAAsE;QACtE,OAAO;YACL,IAAI,EAAE,MAAM;SACb,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC;QAC5B,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC;QAClC,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC;QAClC,UAAU,EAAE,IAAI,CAAC,sBAAsB,CAAC;QACxC,SAAS,EAAE,IAAI,CAAC,qBAAqB,CAAC;QACtC;;;WAGG;QACH,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,mBAAmB,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS;QAC/G,KAAK,EAAE,IAAI,CAAC,KAAK;KAClB,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,OAAO,GAA2C;IAC7D,gBAAgB,EAAE;QAChB,WAAW,EAAE,qCAAqC;QAClD,OAAO,EAAE,8BAA8B,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;QACtD,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,IAAI;QACZ,MAAM,EAAE,CAAC,IAAc,EAAY,EAAE;QACnC,0CAA0C;QAC1C,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACzC,KAAK,EAAE,WAAW;KACnB;IAED,mBAAmB,EAAE;QACnB,WAAW,EAAE,8DAA8D;QAC3E,IAAI,EAAE,QAAQ;QACd,kBAAkB,EAAE,MAAM,CAAC,8BAA8B,CAAC,OAAO,CAAC;QAClE,KAAK,EAAE,WAAW;KACnB;IAED,mBAAmB,EAAE;QACnB,KAAK,EAAE,CAAC,yBAAyB,CAAC;QAClC,WAAW,EAAE,qDAAqD;QAClE,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,8BAA8B,CAAC,OAAO;QAC/C,KAAK,EAAE,WAAW;KACnB;IAED,sBAAsB,EAAE;QACtB,WAAW,EAAE,4FAA4F;QACzG,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,8BAA8B,CAAC,UAAU;QAClD,KAAK,EAAE,WAAW;KACnB;IAED,qBAAqB,EAAE;QACrB,WAAW,EACT,6PAA6P;QAC/P,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,cAAc;QACvB,OAAO,EAAE,8BAA8B,CAAC,SAAS;QACjD,KAAK,EAAE,WAAW;KACnB;IAED,sBAAsB,EAAE;QACtB,WAAW,EAAE,0DAA0D;QACvE,IAAI,EAAE,SAAS;QACf,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,WAAW;KACnB;IAED,SAAS,EAAE;QACT,WAAW,EACT,mQAAmQ;QACrQ,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,WAAW;KACnB;IAED,KAAK,EAAE;QACL,WAAW,EACT,+JAA+J;QACjK,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,WAAW;KACnB;CACF,CAAC"}

package/lib/options/beaconNodeOptions/index.d.ts

@@ -43,6 +43,7 @@ export declare const beaconNodeOptions: {
     "chain.blsVerifyAllMainThread": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
     "chain.disableBlsBatchVerify": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
     "chain.persistProducedBlocks": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
+    "chain.persistProducedPayloadEnvelopes": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
     "chain.persistInvalidSszObjects": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
     "chain.persistOrphanedBlocks": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
     "chain.dedupePayloads": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
@@ -67,7 +68,7 @@ export declare const beaconNodeOptions: {
         demandOption: true;
     });
     "chain.nHistoricalStatesFileDataStore": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
-    "chain.nativeStateView": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
+    "chain.nativeStateTransition": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
     "chain.maxBlockStates": import("@lodestar/utils").CliOptionDefinition<number | undefined>;
     "chain.maxCPStateEpochsInMemory": import("@lodestar/utils").CliOptionDefinition<number | undefined>;
     "chain.maxCPStateEpochsOnDisk": import("@lodestar/utils").CliOptionDefinition<number | undefined>;
@@ -88,6 +89,7 @@ export declare const beaconNodeOptions: {
     "execution.retryDelay": import("@lodestar/utils").CliOptionDefinition<number> & (Required<Pick<import("yargs").Options, "default">> | {
         demandOption: true;
     });
+    "execution.engineApi": import("@lodestar/utils").CliOptionDefinition<import("@lodestar/beacon-node").EngineApiMode | undefined>;
     "execution.engineMock": import("@lodestar/utils").CliOptionDefinition<boolean | undefined>;
     jwtSecret: import("@lodestar/utils").CliOptionDefinition<string | undefined>;
     jwtId: import("@lodestar/utils").CliOptionDefinition<string | undefined>;

package/lib/options/beaconNodeOptions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/options/beaconNodeOptions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,OAAO,GACtC,KAAK,CAAC,SAAS,GACf,IAAI,CAAC,QAAQ,GACb,SAAS,CAAC,mBAAmB,GAC7B,OAAO,CAAC,oBAAoB,GAC5B,OAAO,CAAC,WAAW,GACnB,UAAU,CAAC,cAAc,GACzB,OAAO,CAAC,WAAW,GACnB,IAAI,CAAC,QAAQ,CAAC;AAEhB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,cAAc,GAAG,gBAAgB,CAAC,kBAAkB,CAAC,CAa9F;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAU7B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/options/beaconNodeOptions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,OAAO,GACtC,KAAK,CAAC,SAAS,GACf,IAAI,CAAC,QAAQ,GACb,SAAS,CAAC,mBAAmB,GAC7B,OAAO,CAAC,oBAAoB,GAC5B,OAAO,CAAC,WAAW,GACnB,UAAU,CAAC,cAAc,GACzB,OAAO,CAAC,WAAW,GACnB,IAAI,CAAC,QAAQ,CAAC;AAEhB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,cAAc,GAAG,gBAAgB,CAAC,kBAAkB,CAAC,CAa9F;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAU7B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainsafe/lodestar",
-  "version": "1.50.0-dev.fef46df5ba",
+  "version": "1.50.0",
   "description": "Command line interface for lodestar",
   "author": "ChainSafe Systems",
   "license": "Apache-2.0",
@@ -63,22 +63,22 @@
     "@chainsafe/enr": "^6.0.2",
     "@chainsafe/lodestar-z": "catalog:",
     "@chainsafe/persistent-merkle-tree": "^1.3.1",
-    "@chainsafe/ssz": "^1.8.0",
+    "@chainsafe/ssz": "^1.8.1",
     "@chainsafe/threads": "^1.11.3",
     "@libp2p/crypto": "^5.1.23",
     "@libp2p/interface": "^3.3.0",
     "@libp2p/peer-id": "^6.0.15",
-    "@lodestar/api": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/beacon-node": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/builder": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/config": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/db": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/logger": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/params": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/state-transition": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/types": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/utils": "^1.50.0-dev.fef46df5ba",
-    "@lodestar/validator": "^1.50.0-dev.fef46df5ba",
+    "@lodestar/api": "^1.50.0",
+    "@lodestar/beacon-node": "^1.50.0",
+    "@lodestar/builder": "^1.50.0",
+    "@lodestar/config": "^1.50.0",
+    "@lodestar/db": "^1.50.0",
+    "@lodestar/logger": "^1.50.0",
+    "@lodestar/params": "^1.50.0",
+    "@lodestar/state-transition": "^1.50.0",
+    "@lodestar/types": "^1.50.0",
+    "@lodestar/utils": "^1.50.0",
+    "@lodestar/validator": "^1.50.0",
     "@multiformats/multiaddr": "^13.0.1",
     "deepmerge": "^4.3.1",
     "ethers": "^6.7.0",
@@ -94,7 +94,7 @@
   "devDependencies": {
     "@chainsafe/as-sha256": "^1.2.5",
     "@ethereumjs/rlp": "^4.0.1",
-    "@lodestar/test-utils": "^1.50.0-dev.fef46df5ba",
+    "@lodestar/test-utils": "^1.50.0",
     "@types/debug": "^4.1.7",
     "@types/inquirer": "^9.0.3",
     "@types/js-yaml": "^4.0.5",
@@ -108,5 +108,5 @@
     "web3": "^4.0.3",
     "web3-eth-accounts": "^4.0.3"
   },
-  "gitHead": "7bfba11e49ff8dccb7cfeace4992a714cb7dfb83"
+  "gitHead": "003bd66543fa65b5c1e954eec9e8077054c226dc"
 }

package/src/cmds/beacon/handler.ts

@@ -27,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;
@@ -78,7 +79,8 @@ export async function beaconHandler(args: BeaconArgs & GlobalArgs): Promise<void
       anchorState,
       config: beaconConfig,
       isFinalized,
-    } = await initBeaconState(args, beaconPaths.dataDir, config, db, logger);
+      earliestAvailableSlot,
+    } = await initBeaconState(args, beaconPaths.dataDir, beaconPaths.pubkeysFile, config, db, logger);
 
     const node = await BeaconNode.init({
       opts: options,
@@ -93,6 +95,7 @@ export async function beaconHandler(args: BeaconArgs & GlobalArgs): Promise<void
       peerStoreDir: beaconPaths.peerStoreDir,
       anchorState,
       isAnchorStateFinalized: isFinalized,
+      earliestAvailableSlot,
     });
 
     // dev debug option to have access to the BN instance
@@ -139,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}
     );
@@ -229,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

@@ -10,13 +10,16 @@ import {
   isWithinWeakSubjectivityPeriodFromSummary,
   readBeaconStateBytesMetadata,
 } from "@lodestar/state-transition";
+import {Slot} from "@lodestar/types";
 import {Logger, formatBytes} from "@lodestar/utils";
 import {GlobalArgs} from "../../options/globalOptions.js";
 import {BeaconArgs} from "./options.js";
+import {loadPubkeysFile} from "./pubkeysFile.js";
 import {StateInitializationError, StateInitializationErrorCode} from "./stateInitialization/errors.js";
+import {prepareGenesisInitialization} from "./stateInitialization/genesisState.js";
 import {
   prepareArchivedStateInitialization,
-  prepareCheckpointOrGenesisInitialization,
+  prepareCheckpointSourceInitialization,
 } from "./stateInitialization/prepareStateInitialization.js";
 import {
   ArchivedStateBytes,
@@ -25,21 +28,27 @@ import {
   StatePreparationContext,
 } from "./stateInitialization/types.js";
 
-type InitBeaconStateResult = {anchorState: IBeaconStateView; config: BeaconConfig; isFinalized: boolean};
+type InitBeaconStateResult = {
+  anchorState: IBeaconStateView;
+  config: BeaconConfig;
+  isFinalized: boolean;
+  earliestAvailableSlot: Slot;
+};
 
 /**
  * Select serialized anchor bytes before constructing the state used for validation, persistence, and return.
- * Populates the global `pubkeyCache` with the anchor state's validators.
+ * 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<InitBeaconStateResult> {
   const options: StateInitializationOptions = args;
-  const useNative = options["chain.nativeStateView"] ?? false;
+  const nativeStateTransition = options["chain.nativeStateTransition"] ?? false;
   if (
     options.forceCheckpointSync &&
     !(options.checkpointState || options.checkpointSyncUrl || options.unsafeCheckpointState)
@@ -65,11 +74,23 @@ export async function initBeaconState(
         options.lastPersistedCheckpointState
     );
     if (!options.forceCheckpointSync && (!hasCheckpointSource || archived.isWithinWeakSubjectivityPeriod)) {
-      return executeStateInitialization(prepareArchivedStateInitialization(archived, context), useNative);
+      return executeStateInitialization(
+        prepareArchivedStateInitialization(archived, context),
+        nativeStateTransition,
+        pubkeysFile,
+        logger
+      );
     }
   }
-  const stateInit = await prepareCheckpointOrGenesisInitialization(options, archived, context);
-  return executeStateInitialization(stateInit, useNative);
+  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);
+  }
+  return executeStateInitialization(stateInit, nativeStateTransition, pubkeysFile, logger);
 }
 
 /**
@@ -97,7 +118,7 @@ async function readLatestArchivedStateBytes({
   if (weakSubjectivity === null) {
     throw new StateInitializationError(
       {code: StateInitializationErrorCode.MALFORMED_STATE_BYTES},
-      "Cannot extract weak subjectivity summary from archived 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 {
@@ -114,7 +135,9 @@ async function readLatestArchivedStateBytes({
  */
 async function executeStateInitialization(
   stateInit: StateInitialization,
-  useNative: boolean
+  nativeStateTransition: boolean,
+  pubkeysFile: string,
+  logger: Logger
 ): Promise<InitBeaconStateResult> {
   const {config, stateBytes} = stateInit;
   const validatorCount = getValidatorCountFromStateBytes(config, stateBytes);
@@ -129,10 +152,14 @@ async function executeStateInitialization(
   // 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);
-  pubkeyCache.ensureCapacity(validatorCount + MAX_PENDING_DEPOSITS_PER_EPOCH * Math.ceil(headroomEpochs));
-  const anchorState = createBeaconStateView({useNative, config, stateBytes});
+  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);
-  return {anchorState, config, isFinalized: stateInit.isFinalized};
+  stateInit.log(anchorState, nativeStateTransition);
+  return {anchorState, config, isFinalized: stateInit.isFinalized, earliestAvailableSlot};
 }

package/src/cmds/beacon/options.ts

@@ -4,7 +4,6 @@ import {LogArgs, logOptions} from "../../options/logOptions.js";
 import {BeaconPaths, defaultBeaconPaths} from "./paths.js";
 
 type BeaconExtraArgs = {
-  forceGenesis?: boolean;
   genesisStateFile?: string;
   configFile?: string;
   bootnodesFile?: string;
@@ -22,6 +21,7 @@ type BeaconExtraArgs = {
   persistInvalidSszObjectsRetentionHours?: number;
   persistOrphanedBlocksDir?: string;
   peerStoreDir?: string;
+  pubkeysFile?: string;
   persistNetworkIdentity?: boolean;
   private?: boolean;
   validatorMonitorLogs?: boolean;
@@ -30,12 +30,6 @@ type BeaconExtraArgs = {
 };
 
 export const beaconExtraOptions: CliCommandOptions<BeaconExtraArgs> = {
-  forceGenesis: {
-    description: "Force beacon to create genesis without file",
-    type: "boolean",
-    hidden: true,
-  },
-
   genesisStateFile: {
     description: "Path or URL to download a genesis state file in ssz-encoded format",
     type: "string",
@@ -148,6 +142,13 @@ export const beaconExtraOptions: CliCommandOptions<BeaconExtraArgs> = {
     type: "string",
   },
 
+  pubkeysFile: {
+    hidden: true,
+    description: "Pubkey cache file, loaded on startup and saved on graceful shutdown",
+    defaultDescription: defaultBeaconPaths.pubkeysFile,
+    type: "string",
+  },
+
   persistNetworkIdentity: {
     description:
       "Whether to reuse the same peer-id across restarts. Validator custody requires custody group count to persist relative to a given ENR. Setting to false will reset ENR and validator custody requirements on restarts.",

package/src/cmds/beacon/paths.ts

@@ -9,6 +9,7 @@ export type BeaconPathsPartial = Partial<{
   dataColumnDir: string;
   persistInvalidSszObjectsDir: string;
   persistOrphanedBlocksDir?: string;
+  pubkeysFile: string;
 }>;
 
 export type BeaconPaths = {
@@ -18,6 +19,7 @@ export type BeaconPaths = {
   dataColumnDir: string;
   persistInvalidSszObjectsDir: string;
   persistOrphanedBlocksDir: string;
+  pubkeysFile: string;
 };
 
 /**
@@ -29,6 +31,7 @@ export type BeaconPaths = {
  *     ├── beacon.config.json
  *     ├── peer-id.json
  *     ├── enr
+ *     ├── pubkeys
  *     ├── chain-db
  *     └── beacon.log
  * ```
@@ -48,6 +51,7 @@ export function getBeaconPaths(
   const persistInvalidSszObjectsDir = args.persistInvalidSszObjectsDir ?? path.join(beaconDir, "invalidSszObjects");
   const peerStoreDir = args.peerStoreDir ?? path.join(beaconDir, "peerstore");
   const persistOrphanedBlocksDir = args.persistOrphanedBlocksDir ?? path.join(beaconDir, "orphaned_blocks");
+  const pubkeysFile = args.pubkeysFile ?? path.join(beaconDir, "pubkeys");
 
   return {
     ...globalPaths,
@@ -57,6 +61,7 @@ export function getBeaconPaths(
     persistInvalidSszObjectsDir,
     peerStoreDir,
     persistOrphanedBlocksDir,
+    pubkeysFile,
   };
 }
 

package/src/cmds/beacon/pubkeysFile.ts

@@ -0,0 +1,50 @@
+import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
+import {ChainForkConfig} from "@lodestar/config";
+import {getValidatorPubkeyFromStateBytes} from "@lodestar/state-transition";
+import {Logger, byteArrayEquals} from "@lodestar/utils";
+
+/**
+ * Best effort load of a trusted pubkey cache saved by a previous run, to skip decompressing every validator
+ * pubkey on boot. Must be called before any worker uses the cache.
+ */
+export function loadPubkeysFile(
+  pubkeyCache: PubkeyCache,
+  filepath: string,
+  maxCapacity: number,
+  config: ChainForkConfig,
+  anchorStateBytes: Uint8Array,
+  anchorValidatorCount: number,
+  logger: Logger
+): void {
+  const start = Date.now();
+  try {
+    pubkeyCache.load(filepath, maxCapacity);
+  } catch (e) {
+    logger.debug("Unable to load pubkeys file", {filepath}, e as Error);
+    return;
+  }
+
+  // load() only checks framing and checksum, so reject a file from another chain. Checking the endpoints
+  // suffices since the registry is append-only.
+  const overlap = Math.min(pubkeyCache.size, anchorValidatorCount);
+  for (const index of overlap > 0 ? [0, overlap - 1] : []) {
+    const anchorPubkey = getValidatorPubkeyFromStateBytes(config, anchorStateBytes, index);
+    if (anchorPubkey === null || !byteArrayEquals(pubkeyCache.getPubkeyBytesOrThrow(index), anchorPubkey)) {
+      pubkeyCache.reset();
+      logger.debug("Discarded pubkeys file not matching anchor state", {filepath, index});
+      return;
+    }
+  }
+
+  logger.debug("Loaded pubkeys file", {filepath, count: pubkeyCache.size, durationMs: Date.now() - start});
+}
+
+export function savePubkeysFile(pubkeyCache: PubkeyCache, filepath: string, logger: Logger): void {
+  const start = Date.now();
+  try {
+    pubkeyCache.save(filepath);
+    logger.debug("Saved pubkeys file", {filepath, count: pubkeyCache.size, durationMs: Date.now() - start});
+  } catch (e) {
+    logger.debug("Unable to save pubkeys file", {filepath}, e as Error);
+  }
+}

package/src/cmds/beacon/stateInitialization/checkpointState.ts

@@ -178,7 +178,7 @@ function prepareCheckpointInitialization(
   if (weakSubjectivity === null) {
     throw new StateInitializationError(
       {code: StateInitializationErrorCode.MALFORMED_STATE_BYTES},
-      `Cannot extract weak subjectivity summary from ${candidate.source}`
+      `Cannot extract weak subjectivity summary from ${candidate.source}, expected ${chainForkConfig.getForkName(metadata.slot)} state at slot ${metadata.slot}, possible fork or network mismatch`
     );
   }
   const expectedCheckpoint = useArchived ? null : candidate.expectedCheckpoint;
@@ -186,6 +186,16 @@ function prepareCheckpointInitialization(
   const {isFinalized, ignoreWeakSubjectivityCheck} = policy;
   const config = createBeaconConfig(chainForkConfig, metadata.genesisValidatorsRoot);
   const archivedWithinWeakSubjectivityPeriod = useArchived ? archived.isWithinWeakSubjectivityPeriod : null;
+  const passedValidation =
+    archivedWithinWeakSubjectivityPeriod ?? isWithinWeakSubjectivityPeriodFromSummary(config, weakSubjectivity);
+  // Fast-fail stale checkpoints before deserializing the state or reserving pubkey-cache capacity.
+  if (!passedValidation && !ignoreWeakSubjectivityCheck) {
+    const clockEpoch = computeEpochAtSlot(getCurrentSlot(config, weakSubjectivity.genesisTime));
+    throw new StateInitializationError(
+      {code: StateInitializationErrorCode.STALE_CHECKPOINT},
+      `The selected state with epoch ${weakSubjectivity.checkpointEpoch} is not within weak subjectivity period of ${weakSubjectivity.period} epochs from the current epoch ${clockEpoch}. Please verify your checkpoint source`
+    );
+  }
   // DB-selected anchors need no persistence, including at slot zero.
   const shouldPersist = isFinalized && !useArchived;
   return {
@@ -195,17 +205,8 @@ function prepareCheckpointInitialization(
     validate(state) {
       // A supplied checkpoint must match even when the period check is ignored.
       if (expectedCheckpoint !== null) assertStateMatchesCheckpoint(state, expectedCheckpoint);
-      const passedValidation =
-        archivedWithinWeakSubjectivityPeriod ?? isWithinWeakSubjectivityPeriodFromSummary(config, weakSubjectivity);
-      if (!passedValidation && !ignoreWeakSubjectivityCheck) {
-        const clockEpoch = computeEpochAtSlot(getCurrentSlot(config, weakSubjectivity.genesisTime));
-        throw new StateInitializationError(
-          {code: StateInitializationErrorCode.STALE_CHECKPOINT},
-          `The selected state with epoch ${weakSubjectivity.checkpointEpoch} is not within weak subjectivity period of ${weakSubjectivity.period} epochs from the current epoch ${clockEpoch}. Please verify your checkpoint source`
-        );
-      }
+      assertAnchorStateForkMatchesConfig(config, state);
       if (isFinalized) {
-        assertAnchorStateForkMatchesConfig(config, state);
         const source = useArchived ? "db" : "checkpoint";
         const logData = {
           slot: state.slot,
@@ -222,8 +223,22 @@ function prepareCheckpointInitialization(
         }
       }
     },
+    async initializeEarliestAvailableSlot(state) {
+      const stored = await db.earliestAvailableSlot.get();
+      const floor = useArchived ? (stored ?? state.slot) : Math.max(stored ?? 0, state.slot);
+      if (stored !== floor) {
+        await db.earliestAvailableSlot.set(floor);
+      }
+      logger.verbose("Initialized earliest available slot", {
+        source,
+        anchorSlot: state.slot,
+        previousSlot: stored,
+        earliestAvailableSlot: floor,
+      });
+      return floor;
+    },
     persist: shouldPersist ? (state, bytes) => persistAnchorState(config, db, state, bytes) : null,
-    log(state) {
+    log(state, nativeStateTransition) {
       const {checkpoint} = state.computeAnchorCheckpoint();
       logger.info("Initialized checkpoint state", {
         source,
@@ -233,6 +248,7 @@ function prepareCheckpointInitialization(
         stateRoot: toRootHex(state.hashTreeRoot()),
         checkpointRoot: toRootHex(checkpoint.root),
         isFinalized,
+        nativeStateTransition,
         ...(isFinalized ? {} : {lastProcessedSlot: state.latestBlockHeader.slot}),
       });
     },

package/src/cmds/beacon/stateInitialization/genesisState.ts

@@ -15,11 +15,11 @@ import {StateInitialization, StateInitializationOptions, StatePreparationContext
 import {assertAnchorStateForkMatchesConfig} from "./validation.js";
 
 export async function prepareGenesisInitialization(
-  options: Pick<StateInitializationOptions, "genesisStateFile" | "network" | "forceGenesis">,
+  options: Pick<StateInitializationOptions, "genesisStateFile" | "network">,
   {chainForkConfig, db, logger}: StatePreparationContext
 ): Promise<StateInitialization> {
   const source = options.genesisStateFile || getGenesisFileUrl(options.network || defaultNetwork);
-  if (!source || options.forceGenesis) {
+  if (!source) {
     throw new StateInitializationError(
       {code: StateInitializationErrorCode.MISSING_INITIALIZATION_SOURCE},
       "Failed to initialize beacon state, please provide a genesis state file or use checkpoint sync"
@@ -40,7 +40,7 @@ export async function prepareGenesisInitialization(
   if (weakSubjectivity === null) {
     throw new StateInitializationError(
       {code: StateInitializationErrorCode.MALFORMED_STATE_BYTES},
-      "Cannot extract weak subjectivity summary from genesis state bytes"
+      `Cannot extract weak subjectivity summary from genesis state bytes, expected ${chainForkConfig.getForkName(metadata.slot)} state at slot ${metadata.slot}, possible fork or network mismatch`
     );
   }
   const config = createBeaconConfig(chainForkConfig, metadata.genesisValidatorsRoot);
@@ -73,12 +73,26 @@ export async function prepareGenesisInitialization(
         logger.warn("Checkpoint sync recommended, please use --help to see checkpoint sync options");
       }
     },
+    async initializeEarliestAvailableSlot(state) {
+      const stored = await db.earliestAvailableSlot.get();
+      if (stored !== null && stored !== state.slot) {
+        logger.warn("Resetting earliest available slot for genesis initialization", {
+          previousSlot: stored,
+          earliestAvailableSlot: state.slot,
+        });
+      }
+      if (stored !== state.slot) {
+        await db.earliestAvailableSlot.set(state.slot);
+      }
+      return state.slot;
+    },
     persist: (state, bytes) => persistAnchorState(config, db, state, bytes),
-    log(state) {
+    log(state, nativeStateTransition) {
       logger.info("Initialized genesis state", {
         slot: state.slot,
         stateRoot: toRootHex(state.hashTreeRoot()),
         isFinalized: true,
+        nativeStateTransition,
       });
     },
   };

package/src/cmds/beacon/stateInitialization/prepareStateInitialization.ts

@@ -6,13 +6,12 @@ import {
   prepareCheckpointFileInitialization,
   prepareUnfinalizedCheckpointInitialization,
 } from "./checkpointState.js";
-import {prepareGenesisInitialization} from "./genesisState.js";
 import {ArchivedStateBytes, StateInitialization, StateInitializationOptions, StatePreparationContext} from "./types.js";
 import {assertAnchorStateForkMatchesConfig} from "./validation.js";
 
 export function prepareArchivedStateInitialization(
   {stateBytes, metadata, isWithinWeakSubjectivityPeriod}: ArchivedStateBytes,
-  {chainForkConfig, logger}: StatePreparationContext
+  {chainForkConfig, db, logger}: StatePreparationContext
 ): StateInitialization {
   const config = createBeaconConfig(chainForkConfig, metadata.genesisValidatorsRoot);
   return {
@@ -35,23 +34,38 @@ export function prepareArchivedStateInitialization(
         logger.warn("Checkpoint sync recommended, please use --help to see checkpoint sync options");
       }
     },
+    async initializeEarliestAvailableSlot(state) {
+      const stored = await db.earliestAvailableSlot.get();
+      // we bootstrap the node with archived db, use the previous earliestAvailableSLot
+      if (stored !== null) {
+        logger.verbose("Reusing persisted earliest available slot", {
+          anchorSlot: state.slot,
+          earliestAvailableSlot: stored,
+        });
+        return stored;
+      }
+      // legacy db: blockArchive.firstKey() is not a safe floor, a past checkpoint sync may have left a gap.
+      await db.earliestAvailableSlot.set(state.slot);
+      return state.slot;
+    },
     persist: null,
-    log(state) {
+    log(state, nativeStateTransition) {
       logger.info("Initialized state from db", {
         slot: state.slot,
         epoch: computeEpochAtSlot(state.slot),
         stateRoot: toRootHex(state.hashTreeRoot()),
         isFinalized: true,
+        nativeStateTransition,
       });
     },
   };
 }
 
-export async function prepareCheckpointOrGenesisInitialization(
+export async function prepareCheckpointSourceInitialization(
   options: StateInitializationOptions,
   archived: ArchivedStateBytes | null,
   context: StatePreparationContext
-): Promise<StateInitialization> {
+): Promise<StateInitialization | null> {
   if (options.checkpointState) {
     return prepareCheckpointFileInitialization(options.checkpointState, options, archived, context);
   }
@@ -59,8 +73,7 @@ export async function prepareCheckpointOrGenesisInitialization(
     return prepareCheckpointApiInitialization(options.checkpointSyncUrl, options, archived, context);
   }
   if (options.lastPersistedCheckpointState || options.unsafeCheckpointState) {
-    const stateInit = await prepareUnfinalizedCheckpointInitialization(options, archived, context);
-    if (stateInit !== null) return stateInit;
+    return prepareUnfinalizedCheckpointInitialization(options, archived, context);
   }
-  return prepareGenesisInitialization(options, context);
+  return null;
 }

package/src/cmds/beacon/stateInitialization/types.ts

@@ -1,6 +1,7 @@
 import {IBeaconDb} from "@lodestar/beacon-node";
 import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
 import {IBeaconStateView, StateBytesMetadata, WeakSubjectivitySummary} from "@lodestar/state-transition";
+import {Slot} from "@lodestar/types";
 import {Checkpoint} from "@lodestar/types/phase0";
 import {Logger} from "@lodestar/utils";
 import {GlobalArgs} from "../../../options/globalOptions.js";
@@ -16,10 +17,9 @@ export type StateInitializationOptions = Pick<
   | "wssCheckpoint"
   | "forceCheckpointSync"
   | "ignoreWeakSubjectivityCheck"
-  | "forceGenesis"
   | "network"
   | "chain.nHistoricalStatesFileDataStore"
-  | "chain.nativeStateView"
+  | "chain.nativeStateTransition"
 >;
 
 export type StatePreparationContext = {
@@ -54,6 +54,7 @@ export type StateInitialization = {
   config: BeaconConfig;
   isFinalized: boolean;
   validate: (state: IBeaconStateView) => void;
+  initializeEarliestAvailableSlot: (state: IBeaconStateView) => Promise<Slot>;
   persist: ((state: IBeaconStateView, stateBytes: Uint8Array) => Promise<void>) | null;
-  log: (state: IBeaconStateView) => void;
+  log: (state: IBeaconStateView, nativeStateTransition: boolean) => void;
 };

package/src/cmds/dev/handler.ts

@@ -31,7 +31,7 @@ export async function devHandler(args: IDevArgs & GlobalArgs): Promise<void> {
 
   // Note: defaults to network "dev", to all paths are custom and don't conflict with networks.
   // Flag --reset cleans up the custom dirs on dev stop
-  const beaconDbDir = getBeaconPaths(args, network).dbDir;
+  const {dbDir: beaconDbDir, pubkeysFile} = getBeaconPaths(args, network);
   const validatorsDbDir = getValidatorPaths(args, network).validatorsDbDir;
 
   // Remove slashing protection db. Otherwise the validators won't be able to propose nor attest
@@ -39,6 +39,8 @@ export async function devHandler(args: IDevArgs & GlobalArgs): Promise<void> {
   if (args.genesisTime === undefined) {
     await rimraf(beaconDbDir);
     await rimraf(validatorsDbDir);
+    // Validators deposited in the previous run do not exist on the new chain
+    await rimraf(pubkeysFile);
   }
 
   mkdir(beaconDbDir);