@lodestar/beacon-node 1.42.0-dev.f6213da56d → 1.42.0-dev.fb8f8a700e

package/src/chain/blocks/importExecutionPayload.ts

@@ -1,11 +1,7 @@
 import {routes} from "@lodestar/api";
-import {ForkName} from "@lodestar/params";
-import {
-  BeaconStateView,
-  CachedBeaconStateGloas,
-  getExecutionPayloadEnvelopeSignatureSet,
-} from "@lodestar/state-transition";
-import {processExecutionPayloadEnvelope} from "@lodestar/state-transition/block";
+import {ExecutionStatus, PayloadExecutionStatus} from "@lodestar/fork-choice";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {getExecutionPayloadEnvelopeSignatureSet, isStatePostGloas} from "@lodestar/state-transition";
 import {byteArrayEquals, fromHex, toRootHex} from "@lodestar/utils";
 import {ExecutionPayloadStatus} from "../../execution/index.js";
 import {isQueueErrorAborted} from "../../util/queue/index.js";
@@ -56,18 +52,33 @@ export class PayloadError extends Error {
   }
 }
 
+function toForkChoiceExecutionStatus(status: ExecutionPayloadStatus): PayloadExecutionStatus {
+  switch (status) {
+    case ExecutionPayloadStatus.VALID:
+      return ExecutionStatus.Valid;
+    // TODO GLOAS: Handle optimistic import for payload
+    case ExecutionPayloadStatus.SYNCING:
+    case ExecutionPayloadStatus.ACCEPTED:
+      return ExecutionStatus.Syncing;
+    default:
+      throw new Error(`Unexpected execution payload status for fork choice: ${status}`);
+  }
+}
+
 /**
  * Import an execution payload envelope after all data is available.
  *
  * This function:
- * 1. Gets the ProtoBlock from fork choice
- * 2. Applies write-queue backpressure (waitForSpace) early, before verification
- * 3. Regenerates the block state
- * 4. Runs EL verification (notifyNewPayload) in parallel with signature verification and processExecutionPayloadEnvelope
- * 5. Persists verified payload envelope to hot DB
- * 6. Updates fork choice
- * 7. Caches the post-execution payload state
- * 8. Records metrics for column sources
+ * 1. Emits `execution_payload_available` if payload is for current slot
+ * 2. Gets the ProtoBlock from fork choice
+ * 3. Applies write-queue backpressure (waitForSpace) early, before verification
+ * 4. Regenerates the block state
+ * 5. Runs EL verification (notifyNewPayload) in parallel with signature verification and processExecutionPayloadEnvelope
+ * 6. Persists verified payload envelope to hot DB
+ * 7. Updates fork choice
+ * 8. Caches the post-execution payload state
+ * 9. Records metrics for column sources
+ * 10. Emits `execution_payload` for recent enough payloads after successful import
  *
  */
 export async function importExecutionPayload(
@@ -75,10 +86,24 @@ export async function importExecutionPayload(
   payloadInput: PayloadEnvelopeInput,
   opts: ImportPayloadOpts = {}
 ): Promise<void> {
-  const envelope = payloadInput.getPayloadEnvelope();
+  const signedEnvelope = payloadInput.getPayloadEnvelope();
+  const envelope = signedEnvelope.message;
   const blockRootHex = payloadInput.blockRootHex;
+  const blockHashHex = payloadInput.getBlockHashHex();
+  const fork = this.config.getForkName(envelope.slot);
+
+  // 1. Emit `execution_payload_available` event at the start of import. At this point the payload input
+  // is already complete, so the payload and required data are available for payload attestation.
+  // This event is only about availability, not validity of the execution payload, hence we can emit
+  // it before getting a response from the execution client on whether the payload is valid or not.
+  if (this.clock.currentSlot - envelope.slot < EVENTSTREAM_EMIT_RECENT_EXECUTION_PAYLOAD_SLOTS) {
+    this.emitter.emit(routes.events.EventType.executionPayloadAvailable, {
+      slot: envelope.slot,
+      blockRoot: blockRootHex,
+    });
+  }
 
-  // 1. Get ProtoBlock for parent root lookup
+  // 2. Get ProtoBlock for parent root lookup
   const protoBlock = this.forkChoice.getBlockHexDefaultStatus(blockRootHex);
   if (!protoBlock) {
     throw new PayloadError({
@@ -87,29 +112,35 @@ export async function importExecutionPayload(
     });
   }
 
-  // 2. Apply backpressure from the write queue early, before doing verification work.
+  // 3. Apply backpressure from the write queue early, before doing verification work.
   // The actual DB write is deferred until after verification succeeds.
   await this.unfinalizedPayloadEnvelopeWrites.waitForSpace();
 
-  // 3. Get pre-state for processExecutionPayloadEnvelope
+  // 4. Get pre-state for processExecutionPayloadEnvelope
   // We need the block state (post-block, pre-payload) to process the envelope
-  const blockState = (await this.regen.getBlockSlotState(
+  const blockState = await this.regen.getBlockSlotState(
     protoBlock,
     protoBlock.slot,
     {dontTransferCache: true},
     RegenCaller.processBlock
-  )) as CachedBeaconStateGloas;
+  );
+  if (!isStatePostGloas(blockState)) {
+    throw new PayloadError({
+      code: PayloadErrorCode.STATE_TRANSITION_ERROR,
+      message: `Expected gloas+ block state for payload import, got fork=${blockState.forkName}`,
+    });
+  }
 
-  // 4. Run verification steps in parallel
+  // 5. Run verification steps in parallel
   // Note: No data availability check needed here - importExecutionPayload is only
   // called when payloadInput.isComplete() is true, so all data is already available.
   const [execResult, signatureValid, postPayloadResult] = await Promise.all([
     this.executionEngine.notifyNewPayload(
-      ForkName.gloas,
-      envelope.message.payload,
+      fork,
+      envelope.payload,
       payloadInput.getVersionedHashes(),
       fromHex(protoBlock.parentRoot),
-      envelope.message.executionRequests
+      envelope.executionRequests
     ),
 
     opts.validSignature === true
@@ -117,9 +148,9 @@ export async function importExecutionPayload(
       : (async () => {
           const signatureSet = getExecutionPayloadEnvelopeSignatureSet(
             this.config,
-            blockState.epochCtx.pubkeyCache,
-            new BeaconStateView(blockState),
-            envelope,
+            this.pubkeyCache,
+            blockState,
+            signedEnvelope,
             payloadInput.proposerIndex
           );
           return this.bls.verifySignatureSets([signatureSet]);
@@ -130,7 +161,7 @@ export async function importExecutionPayload(
     (async () => {
       try {
         return {
-          postPayloadState: processExecutionPayloadEnvelope(blockState, envelope, {
+          postPayloadState: blockState.processExecutionPayloadEnvelope(signedEnvelope, {
             verifySignature: false,
             verifyStateRoot: false,
           }),
@@ -147,12 +178,12 @@ export async function importExecutionPayload(
     })(),
   ]);
 
-  // 4b. Check signature verification result
+  // 5a. Check signature verification result
   if (!signatureValid) {
     throw new PayloadError({code: PayloadErrorCode.INVALID_SIGNATURE});
   }
 
-  // 5. Handle EL response
+  // 5b. Handle EL response
   switch (execResult.status) {
     case ExecutionPayloadStatus.VALID:
       break;
@@ -166,12 +197,7 @@ export async function importExecutionPayload(
 
     case ExecutionPayloadStatus.ACCEPTED:
     case ExecutionPayloadStatus.SYNCING:
-      // TODO GLOAS: Handle optimistic import for payload - for now treat as error
-      throw new PayloadError({
-        code: PayloadErrorCode.EXECUTION_ENGINE_ERROR,
-        execStatus: execResult.status,
-        errorMessage: execResult.validationError ?? "EL syncing, payload not yet validated",
-      });
+      break;
 
     case ExecutionPayloadStatus.INVALID_BLOCK_HASH:
     case ExecutionPayloadStatus.ELERROR:
@@ -183,59 +209,69 @@ export async function importExecutionPayload(
       });
   }
 
-  // 5b. Verify envelope state root matches post-state
+  // 5c. Verify envelope state root matches post-state
   const postPayloadState = postPayloadResult.postPayloadState;
   const postPayloadStateRoot = postPayloadState.hashTreeRoot();
-  if (!byteArrayEquals(envelope.message.stateRoot, postPayloadStateRoot)) {
+  if (!byteArrayEquals(envelope.stateRoot, postPayloadStateRoot)) {
     throw new PayloadError({
       code: PayloadErrorCode.STATE_TRANSITION_ERROR,
-      message: `Envelope state root mismatch expected=${toRootHex(envelope.message.stateRoot)} actual=${toRootHex(postPayloadStateRoot)}`,
+      message: `Envelope state root mismatch expected=${toRootHex(envelope.stateRoot)} actual=${toRootHex(postPayloadStateRoot)}`,
     });
   }
 
-  // 5c. Persist payload envelope to hot DB (performed asynchronously to avoid blocking)
+  // 6. Persist payload envelope to hot DB (performed asynchronously to avoid blocking)
   this.unfinalizedPayloadEnvelopeWrites.push(payloadInput).catch((e) => {
     if (!isQueueErrorAborted(e)) {
       this.logger.error(
         "Error pushing payload envelope to unfinalized write queue",
-        {slot: payloadInput.slot, root: blockRootHex},
+        {slot: envelope.slot, blockRoot: blockRootHex},
         e as Error
       );
     }
   });
 
-  // 6. Update fork choice
+  // 7. Update fork choice
   this.forkChoice.onExecutionPayload(
     blockRootHex,
-    payloadInput.getBlockHashHex(),
-    envelope.message.payload.blockNumber,
-    toRootHex(postPayloadStateRoot)
+    blockHashHex,
+    envelope.payload.blockNumber,
+    toRootHex(postPayloadStateRoot),
+    toForkChoiceExecutionStatus(execResult.status)
   );
 
-  // 7. Cache payload state
-  // TODO GLOAS: Enable when PR #8868 merged (adds processPayloadState)
-  // this.regen.processPayloadState(postPayloadState);
-  // if epoch boundary also call
-  // this.regen.addCheckpointState(cp, checkpointState, true);
+  // 8. Cache payload state
+  this.regen.processPayloadState(postPayloadState);
+  if (postPayloadState.slot % SLOTS_PER_EPOCH === 0) {
+    const {checkpoint} = postPayloadState.computeAnchorCheckpoint();
+    this.regen.addCheckpointState(checkpoint, postPayloadState, true);
+  }
 
-  // 8. Record metrics for payload envelope and column sources
+  // 9. Record metrics for payload envelope and column sources
   this.metrics?.importPayload.bySource.inc({source: payloadInput.getPayloadEnvelopeSource().source});
   for (const {source} of payloadInput.getSampledColumnsWithSource()) {
     this.metrics?.importPayload.columnsBySource.inc({source});
   }
 
-  this.logger.verbose("Execution payload imported", {
-    slot: payloadInput.slot,
-    root: blockRootHex,
-    blockHash: payloadInput.getBlockHashHex(),
-  });
+  const stateRootHex = toRootHex(envelope.stateRoot);
 
-  // 9. Emit event after payload is fully verified and imported to fork choice, only for recent enough payloads
-  const currentSlot = this.clock.currentSlot;
-  if (currentSlot - payloadInput.slot < EVENTSTREAM_EMIT_RECENT_EXECUTION_PAYLOAD_SLOTS) {
-    this.emitter.emit(routes.events.EventType.executionPayloadAvailable, {
-      slot: payloadInput.slot,
+  // 10. Emit event after payload is fully verified and imported to fork choice, only for recent enough payloads
+  if (this.clock.currentSlot - envelope.slot < EVENTSTREAM_EMIT_RECENT_EXECUTION_PAYLOAD_SLOTS) {
+    this.emitter.emit(routes.events.EventType.executionPayload, {
+      slot: envelope.slot,
+      builderIndex: envelope.builderIndex,
+      blockHash: blockHashHex,
       blockRoot: blockRootHex,
+      stateRoot: stateRootHex,
+      // TODO GLOAS: revisit once we support optimistic import
+      executionOptimistic: false,
     });
   }
+
+  this.logger.verbose("Execution payload imported", {
+    slot: envelope.slot,
+    builderIndex: envelope.builderIndex,
+    blockRoot: blockRootHex,
+    blockHash: blockHashHex,
+    stateRoot: stateRootHex,
+  });
 }

package/src/chain/blocks/index.ts

@@ -88,7 +88,8 @@ export async function processBlocks(
     const fullyVerifiedBlocks = relevantBlocks.map(
       (block, i): FullyVerifiedBlock => ({
         blockInput: block,
-        postState: postStates[i],
+        postBlockState: postStates[i],
+        postEnvelopeState: null,
         parentBlockSlot: parentSlots[i],
         executionStatus: executionStatuses[i],
         // start supporting optimistic syncing/processing
@@ -126,7 +127,7 @@ export async function processBlocks(
         const {state} = err.type;
         const forkTypes = this.config.getForkTypes(blockSlot);
         this.persistInvalidSszValue(forkTypes.SignedBeaconBlock, signedBlock, `${blockSlot}_invalid_signature`);
-        this.persistInvalidSszView(state, `${state.slot}_invalid_signature`);
+        this.persistInvalidSszBytes("BeaconState", state.serialize(), `${state.slot}_invalid_signature`);
       } else if (err.type.code === BlockErrorCode.INVALID_STATE_ROOT) {
         const {signedBlock} = err;
         const blockSlot = signedBlock.message.slot;

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

@@ -1,8 +1,9 @@
-import {NUMBER_OF_COLUMNS} from "@lodestar/params";
-import {ColumnIndex, DataColumnSidecars, RootHex, Slot, ValidatorIndex, deneb, gloas} from "@lodestar/types";
+import {ForkName, NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {ColumnIndex, RootHex, Slot, ValidatorIndex, deneb, gloas} from "@lodestar/types";
 import {toRootHex, withTimeout} from "@lodestar/utils";
 import {VersionedHashes} from "../../../execution/index.js";
 import {kzgCommitmentToVersionedHash} from "../../../util/blobs.js";
+import {MissingColumnMeta} from "../blockInput/types.js";
 import {AddPayloadEnvelopeProps, ColumnWithSource, CreateFromBlockProps, SourceMeta} from "./types.js";
 
 export type PayloadEnvelopeInputState =
@@ -59,6 +60,7 @@ function createPromise<T>(): PromiseParts<T> {
 export class PayloadEnvelopeInput {
   readonly blockRootHex: RootHex;
   readonly slot: Slot;
+  readonly forkName: ForkName;
   readonly proposerIndex: ValidatorIndex;
   readonly bid: gloas.ExecutionPayloadBid;
   readonly versionedHashes: VersionedHashes;
@@ -71,13 +73,14 @@ export class PayloadEnvelopeInput {
   private timeCreatedSec: number;
 
   private readonly payloadEnvelopeDataPromise: PromiseParts<gloas.SignedExecutionPayloadEnvelope>;
-  private readonly columnsDataPromise: PromiseParts<DataColumnSidecars>;
+  private readonly columnsDataPromise: PromiseParts<gloas.DataColumnSidecar[]>;
 
   state: PayloadEnvelopeInputState;
 
   private constructor(props: {
     blockRootHex: RootHex;
     slot: Slot;
+    forkName: ForkName;
     proposerIndex: ValidatorIndex;
     bid: gloas.ExecutionPayloadBid;
     sampledColumns: ColumnIndex[];
@@ -86,6 +89,7 @@ export class PayloadEnvelopeInput {
   }) {
     this.blockRootHex = props.blockRootHex;
     this.slot = props.slot;
+    this.forkName = props.forkName;
     this.proposerIndex = props.proposerIndex;
     this.bid = props.bid;
     this.versionedHashes = props.bid.blobKzgCommitments.map(kzgCommitmentToVersionedHash);
@@ -112,6 +116,7 @@ export class PayloadEnvelopeInput {
     return new PayloadEnvelopeInput({
       blockRootHex: props.blockRootHex,
       slot: props.block.message.slot,
+      forkName: props.forkName,
       proposerIndex: props.block.message.proposerIndex,
       bid,
       sampledColumns: props.sampledColumns,
@@ -173,8 +178,12 @@ export class PayloadEnvelopeInput {
     }
   }
 
-  addColumn(columnWithSource: ColumnWithSource): void {
+  addColumn(columnWithSource: ColumnWithSource): boolean {
     const {columnSidecar, seenTimestampSec} = columnWithSource;
+    if (this.columnsCache.has(columnSidecar.index)) {
+      return false;
+    }
+
     this.columnsCache.set(columnSidecar.index, columnWithSource);
 
     const sampledColumns = this.getSampledColumns();
@@ -191,7 +200,7 @@ export class PayloadEnvelopeInput {
       sampledColumns.length === this.sampledColumns.length;
 
     if (!hasAllData) {
-      return;
+      return true;
     }
 
     if (hasComputedAllData) {
@@ -217,6 +226,20 @@ export class PayloadEnvelopeInput {
         hasComputedAllData: hasComputedAllData || this.state.hasComputedAllData,
       };
     }
+
+    return true;
+  }
+
+  hasColumn(index: ColumnIndex): boolean {
+    return this.columnsCache.has(index);
+  }
+
+  getColumn(index: ColumnIndex): gloas.DataColumnSidecar | undefined {
+    return this.columnsCache.get(index)?.columnSidecar;
+  }
+
+  getAllColumns(): gloas.DataColumnSidecar[] {
+    return [...this.columnsCache.values()].map(({columnSidecar}) => columnSidecar);
   }
 
   getVersionedHashes(): VersionedHashes {
@@ -237,8 +260,8 @@ export class PayloadEnvelopeInput {
     return this.state.payloadEnvelopeSource;
   }
 
-  getSampledColumns(): gloas.DataColumnSidecars {
-    const columns: gloas.DataColumnSidecars = [];
+  getSampledColumns(): gloas.DataColumnSidecar[] {
+    const columns: gloas.DataColumnSidecar[] = [];
     for (const index of this.sampledColumns) {
       const column = this.columnsCache.get(index);
       if (column) {
@@ -259,8 +282,8 @@ export class PayloadEnvelopeInput {
     return columns;
   }
 
-  getCustodyColumns(): gloas.DataColumnSidecars {
-    const columns: gloas.DataColumnSidecars = [];
+  getCustodyColumns(): gloas.DataColumnSidecar[] {
+    const columns: gloas.DataColumnSidecar[] = [];
     for (const index of this.custodyColumns) {
       const column = this.columnsCache.get(index);
       if (column) {
@@ -270,11 +293,29 @@ export class PayloadEnvelopeInput {
     return columns;
   }
 
+  hasAllData(): boolean {
+    return this.state.hasAllData;
+  }
+
+  getMissingSampledColumnMeta(): MissingColumnMeta {
+    if (this.state.hasAllData) {
+      return {missing: [], versionedHashes: this.versionedHashes};
+    }
+
+    const missing: ColumnIndex[] = [];
+    for (const index of this.sampledColumns) {
+      if (!this.columnsCache.has(index)) {
+        missing.push(index);
+      }
+    }
+    return {missing, versionedHashes: this.versionedHashes};
+  }
+
   hasComputedAllData(): boolean {
     return this.state.hasComputedAllData;
   }
 
-  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<DataColumnSidecars> {
+  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<gloas.DataColumnSidecar[]> {
     if (this.state.hasComputedAllData) {
       return Promise.resolve(this.getSampledColumns());
     }
@@ -319,7 +360,7 @@ export class PayloadEnvelopeInput {
     hasAllData: boolean;
     hasComputedAllData: boolean;
     isComplete: boolean;
-    columnsCount: number;
+    receivedColumns: number;
     sampledColumnsCount: number;
   } {
     return {
@@ -329,7 +370,7 @@ export class PayloadEnvelopeInput {
       hasAllData: this.state.hasAllData,
       hasComputedAllData: this.state.hasComputedAllData,
       isComplete: this.isComplete(),
-      columnsCount: this.columnsCache.size,
+      receivedColumns: this.columnsCache.size,
       sampledColumnsCount: this.sampledColumns.length,
     };
   }

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

@@ -1,4 +1,4 @@
-import {ForkPostGloas} from "@lodestar/params";
+import {ForkName, ForkPostGloas} from "@lodestar/params";
 import {ColumnIndex, RootHex, SignedBeaconBlock, gloas} from "@lodestar/types";
 
 export enum PayloadEnvelopeInputSource {
@@ -23,6 +23,7 @@ export type ColumnWithSource = SourceMeta & {
 export type CreateFromBlockProps = {
   blockRootHex: RootHex;
   block: SignedBeaconBlock<ForkPostGloas>;
+  forkName: ForkName;
   sampledColumns: ColumnIndex[];
   custodyColumns: ColumnIndex[];
   timeCreatedSec: number;

package/src/chain/blocks/types.ts

@@ -1,7 +1,7 @@
 import type {ChainForkConfig} from "@lodestar/config";
-import {MaybeValidExecutionStatus} from "@lodestar/fork-choice";
+import {BlockExecutionStatus, PayloadExecutionStatus} from "@lodestar/fork-choice";
 import {ForkSeq} from "@lodestar/params";
-import {CachedBeaconStateAllForks, DataAvailabilityStatus, computeEpochAtSlot} from "@lodestar/state-transition";
+import {DataAvailabilityStatus, IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
 import type {IndexedAttestation, Slot, fulu} from "@lodestar/types";
 import {IBlockInput} from "./blockInput/types.js";
 
@@ -88,24 +88,35 @@ export type ImportBlockOpts = {
   seenTimestampSec?: number;
 };
 
-/**
- * A wrapper around a `SignedBeaconBlock` that indicates that this block is fully verified and ready to import
- */
-export type FullyVerifiedBlock = {
+type FullyVerifiedBlockBase = {
   blockInput: IBlockInput;
-  postState: CachedBeaconStateAllForks;
+  postBlockState: IBeaconStateView;
   parentBlockSlot: Slot;
   proposerBalanceDelta: number;
-  /**
-   * If the execution payload couldnt be verified because of EL syncing status,
-   * used in optimistic sync or for merge block
-   */
-  executionStatus: MaybeValidExecutionStatus;
   dataAvailabilityStatus: DataAvailabilityStatus;
-  /**
-   * Pre-computed indexed attestations from signature verification to avoid duplicate work
-   */
+  /** Pre-computed indexed attestations from signature verification to avoid duplicate work */
   indexedAttestations: IndexedAttestation[];
   /** Seen timestamp seconds */
   seenTimestampSec: number;
 };
+
+/**
+ * A wrapper around a `SignedBeaconBlock` that indicates that this block is fully verified and ready to import.
+ *
+ * Discriminated union on `postEnvelopeState`:
+ * - `null`  → block has no pre-verified envelope; `executionStatus` is any `BlockExecutionStatus`
+ * - non-null → envelope was pre-verified during state transition; `executionStatus` is narrowed to
+ *              `Valid | Syncing` (matching what `forkChoice.onExecutionPayload` expects)
+ */
+export type FullyVerifiedBlock = FullyVerifiedBlockBase &
+  (
+    | {
+        postEnvelopeState: null;
+        /** If the execution payload couldn't be verified because of EL syncing status, used in optimistic sync or for merge block */
+        executionStatus: BlockExecutionStatus;
+      }
+    | {
+        postEnvelopeState: IBeaconStateView;
+        executionStatus: PayloadExecutionStatus;
+      }
+  );

package/src/chain/blocks/utils/checkpoint.ts

@@ -1,12 +1,12 @@
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
-import {CachedBeaconStateAllForks, computeEpochAtSlot} from "@lodestar/state-transition";
+import {IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
 import {phase0, ssz} from "@lodestar/types";
 import {ZERO_HASH} from "../../../constants/index.js";
 
 /**
  * Compute a Checkpoint type from `state.latestBlockHeader`
  */
-export function getCheckpointFromState(checkpointState: CachedBeaconStateAllForks): phase0.Checkpoint {
+export function getCheckpointFromState(checkpointState: IBeaconStateView): phase0.Checkpoint {
   const slot = checkpointState.slot;
 
   if (slot % SLOTS_PER_EPOCH !== 0) {

package/src/chain/blocks/verifyBlock.ts

@@ -1,11 +1,6 @@
 import {ExecutionStatus, ProtoBlock} from "@lodestar/fork-choice";
 import {ForkName, isForkPostFulu} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  DataAvailabilityStatus,
-  computeEpochAtSlot,
-  isStateValidatorsNodesPopulated,
-} from "@lodestar/state-transition";
+import {DataAvailabilityStatus, IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
 import {IndexedAttestation, deneb} from "@lodestar/types";
 import type {BeaconChain} from "../chain.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
@@ -39,7 +34,7 @@ export async function verifyBlocksInEpoch(
   blockInputs: IBlockInput[],
   opts: BlockProcessOpts & ImportBlockOpts
 ): Promise<{
-  postStates: CachedBeaconStateAllForks[];
+  postStates: IBeaconStateView[];
   proposerBalanceDeltas: number[];
   segmentExecStatus: SegmentExecStatus;
   dataAvailabilityStatuses: DataAvailabilityStatus[];
@@ -78,10 +73,10 @@ export async function verifyBlocksInEpoch(
   // otherwise it may fail to get indexed attestations from shuffling cache later
   this.shufflingCache.processState(preState0);
 
-  if (!isStateValidatorsNodesPopulated(preState0)) {
+  if (!preState0.isStateValidatorsNodesPopulated()) {
     this.logger.verbose("verifyBlocksInEpoch preState0 SSZ cache stats", {
       slot: preState0.slot,
-      cache: isStateValidatorsNodesPopulated(preState0),
+      cache: preState0.isStateValidatorsNodesPopulated(),
       clonedCount: preState0.clonedCount,
       clonedCountWithTransferCache: preState0.clonedCountWithTransferCache,
       createdWithTransferCache: preState0.createdWithTransferCache,
@@ -110,7 +105,7 @@ export async function verifyBlocksInEpoch(
     for (const [i, block] of blocks.entries()) {
       indexedAttestationsByBlock[i] = block.message.body.attestations.map((attestation) => {
         const attEpoch = computeEpochAtSlot(attestation.data.slot);
-        const decisionRoot = preState0.epochCtx.getShufflingDecisionRoot(attEpoch);
+        const decisionRoot = preState0.getShufflingDecisionRoot(attEpoch);
         return this.shufflingCache.getIndexedAttestation(attEpoch, decisionRoot, fork, attestation);
       });
     }

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -1,19 +1,14 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {
+  BlockExecutionStatus,
   ExecutionStatus,
   IForkChoice,
   LVHInvalidResponse,
   LVHValidResponse,
-  MaybeValidExecutionStatus,
   ProtoBlock,
 } from "@lodestar/fork-choice";
 import {ForkSeq} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  isExecutionBlockBodyType,
-  isExecutionEnabled,
-  isExecutionStateType,
-} from "@lodestar/state-transition";
+import {IBeaconStateView, isExecutionBlockBodyType, isStatePostBellatrix} from "@lodestar/state-transition";
 import {bellatrix, electra} from "@lodestar/types";
 import {ErrorAborted, Logger, toRootHex} from "@lodestar/utils";
 import {ExecutionPayloadStatus, IExecutionEngine} from "../../execution/engine/interface.js";
@@ -38,7 +33,7 @@ type ExecAbortType = {blockIndex: number; execError: BlockError};
 export type SegmentExecStatus =
   | {
       execAborted: null;
-      executionStatuses: MaybeValidExecutionStatus[];
+      executionStatuses: BlockExecutionStatus[];
       executionTime: number;
     }
   | {execAborted: ExecAbortType; invalidSegmentLVH?: LVHInvalidResponse};
@@ -63,11 +58,11 @@ export async function verifyBlocksExecutionPayload(
   chain: VerifyBlockExecutionPayloadModules,
   parentBlock: ProtoBlock,
   blockInputs: IBlockInput[],
-  preState0: CachedBeaconStateAllForks,
+  preState0: IBeaconStateView,
   signal: AbortSignal,
   opts: BlockProcessOpts & ImportBlockOpts
 ): Promise<SegmentExecStatus> {
-  const executionStatuses: MaybeValidExecutionStatus[] = [];
+  const executionStatuses: BlockExecutionStatus[] = [];
   const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
   const lastBlock = blockInputs.at(-1);
 
@@ -108,7 +103,7 @@ export async function verifyBlocksExecutionPayload(
       return getSegmentErrorResponse({verifyResponse, blockIndex}, parentBlock, blockInputs);
     }
 
-    // If we are here then its because executionStatus is one of MaybeValidExecutionStatus
+    // If we are here then its because executionStatus is one of BlockExecutionStatus
     const {executionStatus} = verifyResponse;
     executionStatuses.push(executionStatus);
   }
@@ -146,7 +141,7 @@ export async function verifyBlocksExecutionPayload(
 export async function verifyBlockExecutionPayload(
   chain: VerifyBlockExecutionPayloadModules,
   blockInput: IBlockInput,
-  preState0: CachedBeaconStateAllForks
+  preState0: IBeaconStateView
 ): Promise<VerifyBlockExecutionResponse> {
   const block = blockInput.getBlock();
 
@@ -157,9 +152,10 @@ export async function verifyBlockExecutionPayload(
 
   /** Not null if execution is enabled */
   const executionPayloadEnabled =
-    isExecutionStateType(preState0) &&
+    isStatePostBellatrix(preState0) &&
+    preState0.isExecutionStateType &&
     isExecutionBlockBodyType(block.message.body) &&
-    isExecutionEnabled(preState0, block.message)
+    preState0.isExecutionEnabled(block.message)
       ? block.message.body.executionPayload
       : null;