@lodestar/beacon-node 1.50.0-dev.033e6b7138 → 1.50.0-dev.0af9fb2c02

package/src/chain/archiveStore/archiveStore.ts

@@ -1,6 +1,7 @@
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {Slot} from "@lodestar/types";
 import {Checkpoint} from "@lodestar/types/phase0";
 import {callFnWhenAwait} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
@@ -47,6 +48,8 @@ export class ArchiveStore {
   private jobQueue: JobItemQueue<[CheckpointWithHex], void>;
 
   private archiveDataEpochs?: number;
+  // Finalized state writes are monotonic; reset on restart to include the newly persisted anchor.
+  private statePruneFromSlot: Slot = 0;
   private readonly statesArchiverStrategy: StateArchiveStrategy;
   private readonly chain: IBeaconChain;
   private readonly db: IBeaconDb;
@@ -103,7 +106,7 @@ export class ArchiveStore {
     if (this.opts.pruneHistory) {
       // prune ALL stale data before starting
       this.logger.info("Pruning historical data");
-      await callFnWhenAwait(
+      const {stateCutoffSlot} = await callFnWhenAwait(
         pruneHistory(
           this.chain.config,
           this.db,
@@ -116,6 +119,7 @@ export class ArchiveStore {
         30_000,
         this.signal
       );
+      this.statePruneFromSlot = stateCutoffSlot;
     }
 
     // Initialize earliestAvailableSlot from the earliest block actually retained (after any pruning
@@ -144,7 +148,7 @@ export class ArchiveStore {
           genesisTime: this.chain.clock.genesisTime,
           dbLocation: this.opts.dbName,
           dataColumnDir: this.opts.dataColumnDir,
-          nativeStateView: this.opts.nativeStateView ?? false,
+          nativeStateTransition: this.opts.nativeStateTransition ?? false,
         },
         config: this.chain.config,
         metrics: this.metrics,
@@ -255,14 +259,16 @@ export class ArchiveStore {
 
       if (this.opts.pruneHistory) {
         timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
-        const blockCutoffSlot = await pruneHistory(
+        const {blockCutoffSlot, stateCutoffSlot} = await pruneHistory(
           this.chain.config,
           this.db,
           this.logger,
           this.metrics,
           finalizedEpoch,
-          this.chain.clock.currentEpoch
+          this.chain.clock.currentEpoch,
+          this.statePruneFromSlot
         );
+        this.statePruneFromSlot = stateCutoffSlot;
         this.chain.earliestAvailableSlot = Math.max(this.chain.earliestAvailableSlot, blockCutoffSlot);
         timer?.({source: ArchiveStoreTask.PruneHistory});
       }

package/src/chain/archiveStore/historicalState/getHistoricalState.ts

@@ -17,7 +17,7 @@ export async function getNearestState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  nativeStateView: boolean
+  nativeStateTransition: boolean
 ): Promise<IBeaconStateView> {
   const stateBytesArr = await db.stateArchive.binaries({limit: 1, lte: slot, reverse: true});
   if (!stateBytesArr.length) {
@@ -25,9 +25,7 @@ export async function getNearestState(
   }
 
   const stateBytes = stateBytesArr[0];
-  return nativeStateView
-    ? createBeaconStateViewForHistoricalRegen({useNative: true, stateBytes})
-    : createBeaconStateViewForHistoricalRegen({useNative: false, config, stateBytes});
+  return createBeaconStateViewForHistoricalRegen({nativeStateTransition: nativeStateTransition, config, stateBytes});
 }
 
 /**
@@ -37,13 +35,13 @@ export async function getHistoricalState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  nativeStateView: boolean,
+  nativeStateTransition: boolean,
   metrics?: HistoricalStateRegenMetrics
 ): Promise<Uint8Array> {
   const regenTimer = metrics?.regenTime.startTimer();
 
   const loadStateTimer = metrics?.loadStateTime.startTimer();
-  let state = await getNearestState(slot, config, db, nativeStateView).catch((e) => {
+  let state = await getNearestState(slot, config, db, nativeStateTransition).catch((e) => {
     metrics?.regenErrorCount.inc({reason: RegenErrorType.loadState});
     throw e;
   });
@@ -54,7 +52,7 @@ export async function getHistoricalState(
   for await (const block of db.blockArchive.valuesStream({gt: state.slot, lte: slot})) {
     try {
       state = state.stateTransition(
-        block,
+        {block},
         {
           verifyProposer: false,
           verifySignatures: false,

package/src/chain/archiveStore/historicalState/historicalStateRegen.ts

@@ -36,7 +36,7 @@ export class HistoricalStateRegen implements HistoricalStateWorkerApi {
       dataColumnDir: modules.opts.dataColumnDir,
       metricsEnabled: Boolean(modules.metrics),
       loggerOpts: modules.logger.toOpts(),
-      nativeStateView: modules.opts.nativeStateView,
+      nativeStateTransition: modules.opts.nativeStateTransition,
     };
 
     const worker = new Worker(path.join(WORKER_DIR, "worker.js"), {

package/src/chain/archiveStore/historicalState/types.ts

@@ -8,7 +8,7 @@ export type HistoricalStateRegenInitModules = {
     genesisTime: number;
     dbLocation: string;
     dataColumnDir: string;
-    nativeStateView: boolean;
+    nativeStateTransition: boolean;
   };
   config: BeaconConfig;
   logger: LoggerNode;
@@ -29,7 +29,7 @@ export type HistoricalStateWorkerData = {
   dataColumnDir: string;
   metricsEnabled: boolean;
   loggerOpts: LoggerNodeOpts;
-  nativeStateView: boolean;
+  nativeStateTransition: boolean;
 };
 
 export type HistoricalStateWorkerApi = {

package/src/chain/archiveStore/historicalState/worker.ts

@@ -36,7 +36,6 @@ const abortController = new AbortController();
 const metricsRegister = workerData.metricsEnabled ? new RegistryMetricCreator() : null;
 let historicalStateRegenMetrics: HistoricalStateRegenMetrics | undefined;
 let queueMetrics: QueueMetrics | undefined;
-
 if (metricsRegister) {
   const closeMetrics = collectNodeJSMetrics(metricsRegister, "lodestar_historical_state_worker_");
   abortController.signal.addEventListener("abort", closeMetrics, {once: true});
@@ -65,7 +64,7 @@ const api: HistoricalStateWorkerApi = {
     historicalStateRegenMetrics?.regenRequestCount.inc();
 
     const stateBytes = await queue.push<Uint8Array>(() =>
-      getHistoricalState(slot, config, db, workerData.nativeStateView, historicalStateRegenMetrics)
+      getHistoricalState(slot, config, db, workerData.nativeStateTransition, historicalStateRegenMetrics)
     );
     const result = Transfer(stateBytes, [stateBytes.buffer]) as unknown as Uint8Array;
 

package/src/chain/archiveStore/interface.ts

@@ -25,7 +25,7 @@ export type ArchiveStoreOpts = StatesArchiveOpts & {
   archiveDataEpochs?: number;
   pruneHistory?: boolean;
   serveHistoricalState?: boolean;
-  nativeStateView?: boolean;
+  nativeStateTransition?: boolean;
 };
 
 export type ProposalStats = {

package/src/chain/archiveStore/utils/pruneHistory.ts

@@ -11,8 +11,9 @@ export async function pruneHistory(
   logger: Logger,
   metrics: Metrics | null | undefined,
   finalizedEpoch: Epoch,
-  currentEpoch: Epoch
-): Promise<Slot> {
+  currentEpoch: Epoch,
+  statePruneFromSlot: Slot = 0
+): Promise<{blockCutoffSlot: Slot; stateCutoffSlot: Slot}> {
   const blockCutoffEpoch = Math.min(
     // set by config, with underflow protection
     Math.max(currentEpoch - config.MIN_EPOCHS_FOR_BLOCK_REQUESTS, 0),
@@ -28,6 +29,7 @@ export async function pruneHistory(
     currentEpoch,
     finalizedEpoch,
     blockCutoffEpoch,
+    statePruneFromSlot,
     stateCutoffSlot,
   });
 
@@ -35,7 +37,7 @@ export async function pruneHistory(
   const [blocks, envelopes, states] = await Promise.all([
     db.blockArchive.keys({gte: 0, lt: blockCutoffSlot}),
     db.executionPayloadEnvelopeArchive.keys({gte: 0, lt: blockCutoffSlot}),
-    db.stateArchive.keys({gte: 0, lt: stateCutoffSlot}),
+    stateCutoffSlot > statePruneFromSlot ? db.stateArchive.keys({gte: statePruneFromSlot, lt: stateCutoffSlot}) : [],
   ]);
   step0?.();
 
@@ -64,5 +66,5 @@ export async function pruneHistory(
 
   metrics?.pruneHistory.pruneCount.inc();
 
-  return blockCutoffSlot;
+  return {blockCutoffSlot, stateCutoffSlot};
 }

package/src/chain/blocks/importBlock.ts

@@ -538,6 +538,10 @@ export async function importBlock(
           block: blockRootHex,
           slot: blockSlot,
           executionOptimistic: blockSummary != null && isOptimisticBlock(blockSummary),
+          ...(isGloasBeaconBlock(block.message) && {
+            blockHash: toRootHex(block.message.body.signedExecutionPayloadBid.message.blockHash),
+            builderIndex: block.message.body.signedExecutionPayloadBid.message.builderIndex,
+          }),
         });
       }
       if (this.emitter.listenerCount(routes.events.EventType.voluntaryExit)) {

package/src/chain/blocks/payloadEnvelopeInput/types.ts

@@ -22,8 +22,9 @@ export enum PayloadEnvelopeInputSource {
  * - finalized: below the finalized slot
  * - prune: explicit prune by root
  * - cap: insertion-order backstop cap (MAX_PAYLOAD_ENVELOPE_INPUT_CACHE_SIZE)
+ * - invalid: the cached envelope failed import with a definitive invalid verdict
  */
-export type PayloadEnvelopeInputPruneReason = "belowParent" | "finalized" | "remove" | "cap";
+export type PayloadEnvelopeInputPruneReason = "belowParent" | "finalized" | "remove" | "cap" | "invalid";
 
 export type SourceMeta = {
   source: PayloadEnvelopeInputSource;

package/src/chain/blocks/verifyBlock.ts

@@ -188,6 +188,7 @@ export async function verifyBlocksInEpoch(
         blockInputs,
         // hack availability for state transition eval as availability is separately determined
         blocks.map(() => DataAvailabilityStatus.Available),
+        this.serializedCache,
         this.logger,
         this.metrics,
         this.validatorMonitor,

package/src/chain/blocks/verifyBlocksStateTransitionOnly.ts

@@ -7,6 +7,7 @@ import {
 import {ErrorAborted, Logger, byteArrayEquals} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
 import {nextEventLoop} from "../../util/eventLoop.js";
+import {SerializedCache} from "../../util/serializedCache.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {BlockProcessOpts} from "../options.js";
 import {ValidatorMonitor} from "../validatorMonitor.js";
@@ -25,6 +26,7 @@ export async function verifyBlocksStateTransitionOnly(
   preState0: IBeaconStateView,
   blocks: IBlockInput[],
   dataAvailabilityStatuses: DataAvailabilityStatus[],
+  serializedCache: SerializedCache,
   logger: Logger,
   metrics: Metrics | null,
   validatorMonitor: ValidatorMonitor | null,
@@ -37,7 +39,8 @@ export async function verifyBlocksStateTransitionOnly(
 
   for (let i = 0; i < blocks.length; i++) {
     const {validProposerSignature, validSignatures} = opts;
-    const block = blocks[i].getBlock();
+    const blockInput = blocks[i];
+    const block = blockInput.getBlock();
     const preState = i === 0 ? preState0 : postStates[i - 1];
     const dataAvailabilityStatus = dataAvailabilityStatuses[i];
 
@@ -47,7 +50,7 @@ export async function verifyBlocksStateTransitionOnly(
     let postState: IBeaconStateView;
     try {
       postState = preState.stateTransition(
-        block,
+        {block, ssz: serializedCache.get(block)},
         {
           // NOTE: Assume valid for now while sending payload to execution engine in parallel
           // Latter verifyBlocksInEpoch() will make sure that payload is indeed valid
@@ -60,7 +63,7 @@ export async function verifyBlocksStateTransitionOnly(
           verifySignatures: !useBlsBatchVerify && !validSignatures,
           dontTransferCache: false,
         },
-        {metrics, validatorMonitor}
+        {metrics: metrics?.stateTransition, validatorMonitor}
       );
     } catch (e) {
       throw new BlockError(block, {

package/src/chain/chain.ts

@@ -71,7 +71,7 @@ import {BufferPool} from "../util/bufferPool.js";
 import {Clock, ClockEvent, IClock} from "../util/clock.js";
 import {CustodyConfig, getValidatorsCustodyRequirement} from "../util/dataColumns.js";
 import {callInNextEventLoop} from "../util/eventLoop.js";
-import {ReconstructMismatchPolicy, isRebuildMiss, reconstructExecutionPayloadEnvelopes} from "../util/execution.js";
+import {ReconstructMissPolicy, isRebuildMiss, reconstructExecutionPayloadEnvelopes} from "../util/execution.js";
 import {ensureDir, writeIfNotExist} from "../util/file.js";
 import {isOptimisticBlock} from "../util/forkChoice.js";
 import {JobItemQueue} from "../util/queue/itemQueue.js";
@@ -432,6 +432,7 @@ export class BeaconChain implements IBeaconChain {
       blockStateCache,
       checkpointStateCache,
       seenBlockInputCache: this.seenBlockInputCache,
+      serializedCache: this.serializedCache,
       db,
       metrics,
       validatorMonitor,
@@ -611,7 +612,7 @@ export class BeaconChain implements IBeaconChain {
   /** Populate in-memory caches with persisted data. Call at least once on startup */
   async loadFromDisk(): Promise<void> {
     await this.regen.init();
-    await this.opPool.fromPersisted(this.db);
+    await this.opPool.fromPersisted(this.db, this.getHeadState(), this.bls, this.clock.currentSlot);
   }
 
   /** Persist in-memory data to the DB. Call at least once before stopping the process */
@@ -702,6 +703,26 @@ export class BeaconChain implements IBeaconChain {
     stateRoot: RootHex,
     opts?: StateGetOpts
   ): Promise<{state: IBeaconStateView | Uint8Array; executionOptimistic: boolean; finalized: boolean} | null> {
+    const finalizedBlock = this.forkChoice.getFinalizedBlock();
+    const finalizedCheckpoint = this.forkChoice.getFinalizedCheckpoint();
+    // Checkpoint state only equals the block post-state if the block is at the epoch start slot
+    if (
+      finalizedBlock.stateRoot === stateRoot &&
+      finalizedBlock.slot === computeStartSlotAtEpoch(finalizedCheckpoint.epoch)
+    ) {
+      const state = this.regen.getCheckpointStateSync({
+        epoch: finalizedCheckpoint.epoch,
+        rootHex: finalizedCheckpoint.rootHex,
+      });
+      if (state) {
+        return {
+          state,
+          executionOptimistic: isOptimisticBlock(finalizedBlock),
+          finalized: finalizedCheckpoint.epoch !== GENESIS_EPOCH,
+        };
+      }
+    }
+
     if (opts?.allowRegen) {
       const state = await this.regen.getState(stateRoot, RegenCaller.restApi);
       const block = this.forkChoice.getBlockDefaultStatus(
@@ -934,12 +955,13 @@ export class BeaconChain implements IBeaconChain {
 
   /**
    * Batch variant: archived header envelopes are rebuilt 32 per EL round-trip. Aligned with `requests`.
-   * A body root mismatch is a local inconsistency: `"throw"` surfaces it, `"omit"` logs it and
-   * returns null for that entry, for peer-facing paths where the spec allows omission.
+   * An archived envelope that cannot be rebuilt (EL-unavailable body or body root mismatch) is not the
+   * same as an unknown one: `"throw"` surfaces it, `"omit"` returns null for that entry, for
+   * peer-facing paths where the spec allows omission.
    */
   async getSerializedExecutionPayloadEnvelopes(
     requests: {blockSlot: Slot; blockRootHex: RootHex}[],
-    onMismatch: ReconstructMismatchPolicy = "throw"
+    onMiss: ReconstructMissPolicy = "throw"
   ): Promise<(Uint8Array | null)[]> {
     const out: (Uint8Array | null)[] = new Array(requests.length).fill(null);
     const headerEnvelopes: gloas.SignedExecutionPayloadHeaderEnvelope[] = [];
@@ -978,14 +1000,14 @@ export class BeaconChain implements IBeaconChain {
       for (let j = 0; j < rebuilt.length; j++) {
         const result = rebuilt[j];
         if (isRebuildMiss(result)) {
-          if (result.reason === "mismatch") {
-            if (onMismatch === "throw") throw result.error;
-            this.logger.debug(
-              "Archived envelope failed body root check against EL bodies",
-              {slot: result.slot},
-              result.error
-            );
-          }
+          if (onMiss === "throw") throw result.error;
+          this.logger.debug(
+            result.reason === "mismatch"
+              ? "Archived envelope failed body root check against EL bodies"
+              : "EL cannot serve bodies for archived envelope, omitting",
+            {slot: result.slot},
+            result.error
+          );
           continue;
         }
         out[headerEnvelopeIdxs[j]] = ssz.gloas.SignedExecutionPayloadEnvelope.serialize(result);
@@ -1016,10 +1038,7 @@ export class BeaconChain implements IBeaconChain {
     const [result] = await reconstructExecutionPayloadEnvelopes(this.executionEngine, this.metrics, [
       archived.headerEnvelope,
     ]);
-    if (isRebuildMiss(result)) {
-      if (result.reason === "mismatch") throw result.error;
-      return null;
-    }
+    if (isRebuildMiss(result)) throw result.error;
     return result;
   }
 
@@ -1329,13 +1348,13 @@ export class BeaconChain implements IBeaconChain {
       };
 
       try {
-        await validateApiProposerSlashing(this, proposerSlashing);
+        const verifiedDomain = await validateApiProposerSlashing(this, proposerSlashing);
+        this.opPool.insertProposerSlashing(proposerSlashing, verifiedDomain);
       } catch (e) {
         this.logger.debug("Produced proposer slashing is not valid", {slot: blockSlot, proposerIndex}, e as Error);
         return;
       }
 
-      this.opPool.insertProposerSlashing(proposerSlashing);
       this.emitter.emit(routes.events.EventType.proposerSlashing, proposerSlashing);
       this.emitter.emit(ChainEvent.publishProposerSlashing, proposerSlashing);
       this.metrics?.opPool.proposerSlashingsProduced.inc();

package/src/chain/emitter.ts

@@ -1,7 +1,7 @@
 import {EventEmitter} from "node:events";
 import {StrictEventEmitter} from "strict-event-emitter-types";
 import {routes} from "@lodestar/api";
-import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {CheckpointWithHex, PtcQuorumEvent} from "@lodestar/fork-choice";
 import {IBeaconStateView} from "@lodestar/state-transition";
 import {DataColumnSidecar, RootHex, Slot, deneb, phase0} from "@lodestar/types";
 import {PeerIdStr} from "../util/peerId.js";
@@ -36,6 +36,11 @@ export enum ChainEvent {
    * This event is guaranteed to be triggered whenever the fork choice finalized checkpoint is updated. This is either in response to a newly processed block or a new clock tick.
    */
   forkChoiceFinalized = "forkChoice:finalized",
+  /**
+   * This event signals that the PTC verdict on a block was decided: a majority against payload presence or blob data
+   * availability, or a majority for both.
+   */
+  forkChoicePtcQuorum = "forkChoice:ptcQuorum",
   /**
    * This event signals that dependent services (e.g. custody sampling) should update to account for the new target group count.
    */
@@ -112,6 +117,7 @@ export type IChainEvents = ApiEvents & {
 
   [ChainEvent.forkChoiceJustified]: (checkpoint: CheckpointWithHex) => void;
   [ChainEvent.forkChoiceFinalized]: (checkpoint: CheckpointWithHex) => void;
+  [ChainEvent.forkChoicePtcQuorum]: (data: PtcQuorumEvent) => void;
 
   [ChainEvent.updateTargetCustodyGroupCount]: (targetGroupCount: number) => void;
 

package/src/chain/errors/envelopeReconstructionError.ts

@@ -4,6 +4,8 @@ import {LodestarError} from "@lodestar/utils";
 export enum EnvelopeReconstructionErrorCode {
   /** The EL failed to answer engine_getPayloadBodiesByHashV2 (transport / EL down). Transient. */
   ENGINE_UNAVAILABLE = "ENVELOPE_RECONSTRUCTION_ERROR_ENGINE_UNAVAILABLE",
+  /** The EL does not have the block or its block access list (pruned, or not yet re-indexed after a restart). May recover. */
+  BODY_UNAVAILABLE = "ENVELOPE_RECONSTRUCTION_ERROR_BODY_UNAVAILABLE",
   /** A body returned by the EL does not hash to the root stored in the header envelope. Local DB/EL inconsistency. */
   BODY_ROOT_MISMATCH = "ENVELOPE_RECONSTRUCTION_ERROR_BODY_ROOT_MISMATCH",
   /** A by-range stream stopped short at a slot that cannot be served; the response so far is still valid */
@@ -12,6 +14,7 @@ export enum EnvelopeReconstructionErrorCode {
 
 export type EnvelopeReconstructionErrorType =
   | {code: EnvelopeReconstructionErrorCode.ENGINE_UNAVAILABLE}
+  | {code: EnvelopeReconstructionErrorCode.BODY_UNAVAILABLE; slot: Slot}
   | {
       code: EnvelopeReconstructionErrorCode.BODY_ROOT_MISMATCH;
       slot: Slot;

package/src/chain/errors/gossipValidation.ts

@@ -9,6 +9,8 @@ export enum GossipErrorCode {
   INVALID_SERIALIZED_BYTES_ERROR_CODE = "GOSSIP_ERROR_INVALID_SERIALIZED_BYTES",
   PAST_SLOT = "GOSSIP_ERROR_PAST_SLOT",
   FUTURE_SLOT = "GOSSIP_ERROR_FUTURE_SLOT",
+  FATAL_PEER = "GOSSIP_ERROR_FATAL_PEER",
+  INVALID_SLOT = "GOSSIP_ERROR_INVALID_SLOT",
 }
 
 export class GossipActionError<T extends {code: string}> extends LodestarError<T> {

package/src/chain/forkChoice/index.ts

@@ -124,6 +124,7 @@ export function initializeForkChoiceFromFinalizedState(
         onFinalized: (cp) => emitter.emit(ChainEvent.forkChoiceFinalized, cp),
         onFastConfirmation: ({block, slot, currentSlot}) =>
           emitter.emit(routes.events.EventType.fastConfirmation, {block, slot, currentSlot}),
+        onPtcQuorum: (data) => emitter.emit(ChainEvent.forkChoicePtcQuorum, data),
       }
     ),
 
@@ -222,6 +223,7 @@ export function initializeForkChoiceFromUnfinalizedState(
       onFinalized: (cp) => emitter.emit(ChainEvent.forkChoiceFinalized, cp),
       onFastConfirmation: ({block, slot, currentSlot}) =>
         emitter.emit(routes.events.EventType.fastConfirmation, {block, slot, currentSlot}),
+      onPtcQuorum: (data) => emitter.emit(ChainEvent.forkChoicePtcQuorum, data),
     }
   );
 

package/src/chain/initState.ts

@@ -1,14 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {ForkPostGloas, ForkSeq, ZERO_HASH} from "@lodestar/params";
-import {
-  BeaconStateAllForks,
-  BeaconStateGloas,
-  IBeaconStateView,
-  computeEpochAtSlot,
-  computeStartSlotAtEpoch,
-} from "@lodestar/state-transition";
+import {BeaconStateAllForks, IBeaconStateView, computeEpochAtSlot, isStatePostGloas} from "@lodestar/state-transition";
 import {SignedBeaconBlock, ssz} from "@lodestar/types";
-import {Logger, byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
+import {LodestarError, Logger, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {GENESIS_SLOT} from "../constants/index.js";
 import {IBeaconDb} from "../db/index.js";
 import {Metrics} from "../metrics/index.js";
@@ -17,7 +11,7 @@ import {getStateTypeFromBytes} from "../util/multifork.js";
 export async function persistAnchorState(
   config: ChainForkConfig,
   db: IBeaconDb,
-  anchorState: BeaconStateAllForks,
+  anchorState: IBeaconStateView,
   anchorStateBytes: Uint8Array
 ): Promise<void> {
   if (anchorState.slot === GENESIS_SLOT) {
@@ -33,7 +27,8 @@ export async function persistAnchorState(
     const latestBlockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(latestBlockHeader);
 
     if (!byteArrayEquals(blockRoot, latestBlockRoot)) {
-      throw Error(
+      throw new LodestarError(
+        {code: "GENESIS_BLOCK_ROOT_MISMATCH"},
         `Genesis block root ${toRootHex(blockRoot)} does not match genesis state latest block root ${toRootHex(latestBlockRoot)}`
       );
     }
@@ -48,16 +43,15 @@ export async function persistAnchorState(
   }
 }
 
-export function createGenesisBlock(config: ChainForkConfig, genesisState: BeaconStateAllForks): SignedBeaconBlock {
+export function createGenesisBlock(config: ChainForkConfig, genesisState: IBeaconStateView): SignedBeaconBlock {
   const types = config.getForkTypes(GENESIS_SLOT);
   const genesisBlock = types.SignedBeaconBlock.defaultValue();
   const stateRoot = genesisState.hashTreeRoot();
   genesisBlock.message.stateRoot = stateRoot;
 
-  if (config.getForkSeq(GENESIS_SLOT) >= ForkSeq.gloas) {
+  if (config.getForkSeq(GENESIS_SLOT) >= ForkSeq.gloas && isStatePostGloas(genesisState)) {
     const gloasBlock = genesisBlock as SignedBeaconBlock<ForkPostGloas>;
-    const gloasState = genesisState as BeaconStateGloas;
-    gloasBlock.message.body.signedExecutionPayloadBid.message = gloasState.latestExecutionPayloadBid.toValue();
+    gloasBlock.message.body.signedExecutionPayloadBid.message = genesisState.latestExecutionPayloadBid;
   }
 
   return genesisBlock;
@@ -86,52 +80,6 @@ export async function initStateFromDb(
   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: IBeaconStateView): void {
   metrics.headSlot.set(state.slot);
   metrics.previousJustifiedEpoch.set(state.previousJustifiedCheckpoint.epoch);

package/src/chain/interface.ts

@@ -30,7 +30,7 @@ import {Metrics} from "../metrics/metrics.js";
 import {BufferPool} from "../util/bufferPool.js";
 import {IClock} from "../util/clock.js";
 import {CustodyConfig} from "../util/dataColumns.js";
-import {ReconstructMismatchPolicy} from "../util/execution.js";
+import {ReconstructMissPolicy} from "../util/execution.js";
 import {SerializedCache} from "../util/serializedCache.js";
 import {IArchiveStore} from "./archiveStore/interface.js";
 import {CheckpointBalancesCache} from "./balancesCache.js";
@@ -239,7 +239,7 @@ export interface IBeaconChain {
   getSerializedExecutionPayloadEnvelope(blockSlot: Slot, blockRootHex: string): Promise<Uint8Array | null>;
   getSerializedExecutionPayloadEnvelopes(
     requests: {blockSlot: Slot; blockRootHex: RootHex}[],
-    onMismatch?: ReconstructMismatchPolicy
+    onMiss?: ReconstructMissPolicy
   ): Promise<(Uint8Array | null)[]>;
   getExecutionPayloadEnvelope(
     blockSlot: Slot,