@chainsafe/lodestar 1.50.0-dev.5866a397b6 → 1.50.0-dev.70314c9caa

package/src/networks/index.ts

@@ -4,15 +4,9 @@ import {WireFormat, getClient} from "@lodestar/api";
 import {getStateSlotFromBytes} from "@lodestar/beacon-node";
 import {ChainConfig, ChainForkConfig} from "@lodestar/config";
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
-import {
-  BeaconStateAllForks,
-  computeCheckpointEpochAtStateSlot,
-  getLatestBlockRoot,
-  loadState,
-} from "@lodestar/state-transition";
-import {Slot, sszTypesFor} from "@lodestar/types";
+import {Slot} from "@lodestar/types";
 import {Checkpoint} from "@lodestar/types/phase0";
-import {Logger, callFnWhenAwait, fetch, formatBytes, fromHex} from "@lodestar/utils";
+import {LodestarError, Logger, callFnWhenAwait, fetch, formatBytes, fromHex} from "@lodestar/utils";
 import {parseBootnodesFile} from "../util/format.js";
 import * as chiado from "./chiado.js";
 import * as dev from "./dev.js";
@@ -160,15 +154,11 @@ export function readBootnodes(bootnodesFilePath: string): string[] {
 /**
  * Fetch weak subjectivity state from a remote beacon node
  */
-export async function fetchWeakSubjectivityState(
+export async function fetchWeakSubjectivityStateBytes(
   config: ChainForkConfig,
   logger: Logger,
-  {checkpointSyncUrl, wssCheckpoint}: {checkpointSyncUrl: string; wssCheckpoint?: string},
-  {
-    lastDbState,
-    lastDbValidatorsBytes,
-  }: {lastDbState: BeaconStateAllForks | null; lastDbValidatorsBytes: Uint8Array | null}
-): Promise<{wsState: BeaconStateAllForks; wsStateBytes: Uint8Array; wsCheckpoint: Checkpoint}> {
+  {checkpointSyncUrl, wssCheckpoint}: {checkpointSyncUrl: string; wssCheckpoint?: string}
+): Promise<{stateBytes: Uint8Array; expectedCheckpoint: Checkpoint | null}> {
   try {
     let wsCheckpoint: Checkpoint | null;
     let stateId: Slot | "finalized";
@@ -178,7 +168,7 @@ export async function fetchWeakSubjectivityState(
       wsCheckpoint = getCheckpointFromArg(wssCheckpoint);
       stateId = wsCheckpoint.epoch * SLOTS_PER_EPOCH;
     } else {
-      // Fetch current finalized state and extract checkpoint from it
+      // Checkpoint identity can be derived after the selected state is constructed.
       stateId = "finalized";
       wsCheckpoint = null;
     }
@@ -186,33 +176,37 @@ export async function fetchWeakSubjectivityState(
     // getStateV2 should be available for all forks including phase0
     const getStatePromise = api.debug.getStateV2({stateId}, {responseWireFormat: WireFormat.ssz});
 
-    const {wsStateBytes, fork} = await callFnWhenAwait(
+    const response = await callFnWhenAwait(
       getStatePromise,
       () => logger.info("Download in progress, please wait..."),
       GET_STATE_LOG_INTERVAL
-    ).then((res) => {
-      return {wsStateBytes: res.ssz(), fork: res.meta().version};
-    });
+    );
+    const wsStateBytes = response.ssz();
+    const {version} = response.meta();
 
     const wsSlot = getStateSlotFromBytes(wsStateBytes);
     const logData = {stateId, size: formatBytes(wsStateBytes.length)};
     logger.info("Download completed", typeof stateId === "number" ? logData : {...logData, slot: wsSlot});
 
-    let wsState: BeaconStateAllForks;
-    if (lastDbState && lastDbValidatorsBytes) {
-      // use lastDbState to load wsState if possible to share the same state tree
-      wsState = loadState(config, lastDbState, wsStateBytes, lastDbValidatorsBytes).state;
-    } else {
-      wsState = sszTypesFor(fork).BeaconState.deserializeToViewDU(wsStateBytes);
+    const expectedFork = config.getForkName(wsSlot);
+    if (version !== expectedFork) {
+      throw new LodestarError(
+        {code: "CHECKPOINT_FORK_MISMATCH"},
+        `Checkpoint sync server returned ${version} state at slot ${wsSlot} but local config expects ${expectedFork}, verify --network or the chain config`
+      );
     }
 
     return {
-      wsState,
-      wsStateBytes,
-      wsCheckpoint: wsCheckpoint ?? getCheckpointFromState(wsState),
+      stateBytes: new Uint8Array(wsStateBytes.buffer, wsStateBytes.byteOffset, wsStateBytes.byteLength),
+      expectedCheckpoint: wsCheckpoint,
     };
   } catch (e) {
-    throw new Error("Unable to fetch weak subjectivity state: " + (e as Error).message);
+    const error = new LodestarError(
+      {code: "CHECKPOINT_DOWNLOAD_FAILED"},
+      "Unable to fetch weak subjectivity state: " + (e as Error).message
+    );
+    error.cause = e;
+    throw error;
   }
 }
 
@@ -220,16 +214,7 @@ export function getCheckpointFromArg(checkpointStr: string): Checkpoint {
   const checkpointRegex = /^(?:0x)?([0-9a-f]{64}):([0-9]+)$/;
   const match = checkpointRegex.exec(checkpointStr.toLowerCase());
   if (!match) {
-    throw new Error(`Could not parse checkpoint string: ${checkpointStr}`);
+    throw new LodestarError({code: "INVALID_CHECKPOINT"}, `Could not parse checkpoint string: ${checkpointStr}`);
   }
   return {root: fromHex(match[1]), epoch: parseInt(match[2])};
 }
-
-export function getCheckpointFromState(state: BeaconStateAllForks): Checkpoint {
-  return {
-    // the correct checkpoint is based on state's slot, its latestBlockHeader's slot's epoch can be
-    // behind the state
-    epoch: computeCheckpointEpochAtStateSlot(state.slot),
-    root: getLatestBlockRoot(state),
-  };
-}

package/src/options/beaconNodeOptions/chain.ts

@@ -187,7 +187,7 @@ Will double processing times. Use only for debugging purposes.",
   "chain.dedupePayloads": {
     type: "boolean",
     description:
-      "Archive finalized Gloas execution payload envelopes in header form and rebuild transactions, withdrawals and block access lists from the execution client when serving them. Serving then depends on the execution client still holding the block access list, whose retention is implementation-dependent. Set to false to keep full envelopes on disk.",
+      "Archive finalized Gloas execution payload envelopes in header form and rebuild transactions, withdrawals and block access lists from the execution client when serving them. Serving then depends on the execution client still holding the block access list. Set to false to keep full envelopes on disk.",
     defaultDescription: String(defaultOptions.chain.dedupePayloads),
     group: "chain",
   },
@@ -240,7 +240,7 @@ Will double processing times. Use only for debugging purposes.",
 
   "chain.fastConfirmation": {
     type: "boolean",
-    description: "Enable Fast Confirmation Rule for faster block confirmation (experimental)",
+    description: "Enable Fast Confirmation Rule for faster block confirmation",
     defaultDescription: String(defaultOptions.chain.fastConfirmation),
     group: "chain",
   },