@lodestar/beacon-node 1.42.0-dev.4411584fd8 → 1.42.0-dev.47afaa6bb7

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

@@ -0,0 +1,377 @@
+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 =
+  | {
+      hasPayload: false;
+      hasAllData: false;
+      hasComputedAllData: false;
+    }
+  | {
+      hasPayload: false;
+      hasAllData: true;
+      hasComputedAllData: boolean;
+    }
+  | {
+      hasPayload: true;
+      hasAllData: false;
+      hasComputedAllData: false;
+      payloadEnvelope: gloas.SignedExecutionPayloadEnvelope;
+      payloadEnvelopeSource: SourceMeta;
+    }
+  | {
+      hasPayload: true;
+      hasAllData: true;
+      hasComputedAllData: boolean;
+      payloadEnvelope: gloas.SignedExecutionPayloadEnvelope;
+      payloadEnvelopeSource: SourceMeta;
+      timeCompleteSec: number;
+    };
+
+type PromiseParts<T> = {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (e: Error) => void;
+};
+
+function createPromise<T>(): PromiseParts<T> {
+  let resolve!: (value: T) => void;
+  let reject!: (e: Error) => void;
+  const promise = new Promise<T>((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return {promise, resolve, reject};
+}
+
+/**
+ * Tracks bid + payload envelope + data columns for a Gloas block.
+ *
+ * Created during block import from signedExecutionPayloadBid in block body.
+ * Always has bid (required for creation).
+ *
+ * Completion requires: payload envelope + all sampled columns
+ */
+export class PayloadEnvelopeInput {
+  readonly blockRootHex: RootHex;
+  readonly slot: Slot;
+  readonly forkName: ForkName;
+  readonly proposerIndex: ValidatorIndex;
+  readonly bid: gloas.ExecutionPayloadBid;
+  readonly versionedHashes: VersionedHashes;
+
+  private columnsCache = new Map<ColumnIndex, ColumnWithSource>();
+
+  private readonly sampledColumns: ColumnIndex[];
+  private readonly custodyColumns: ColumnIndex[];
+
+  private timeCreatedSec: number;
+
+  private readonly payloadEnvelopeDataPromise: PromiseParts<gloas.SignedExecutionPayloadEnvelope>;
+  private readonly columnsDataPromise: PromiseParts<gloas.DataColumnSidecar[]>;
+
+  state: PayloadEnvelopeInputState;
+
+  private constructor(props: {
+    blockRootHex: RootHex;
+    slot: Slot;
+    forkName: ForkName;
+    proposerIndex: ValidatorIndex;
+    bid: gloas.ExecutionPayloadBid;
+    sampledColumns: ColumnIndex[];
+    custodyColumns: ColumnIndex[];
+    timeCreatedSec: number;
+  }) {
+    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);
+    this.sampledColumns = props.sampledColumns;
+    this.custodyColumns = props.custodyColumns;
+    this.timeCreatedSec = props.timeCreatedSec;
+    this.payloadEnvelopeDataPromise = createPromise();
+    this.columnsDataPromise = createPromise();
+
+    const noBlobs = props.bid.blobKzgCommitments.length === 0;
+    const noSampledColumns = props.sampledColumns.length === 0;
+    const hasAllData = noBlobs || noSampledColumns;
+
+    if (hasAllData) {
+      this.state = {hasPayload: false, hasAllData: true, hasComputedAllData: true};
+      this.columnsDataPromise.resolve(this.getSampledColumns());
+    } else {
+      this.state = {hasPayload: false, hasAllData: false, hasComputedAllData: false};
+    }
+  }
+
+  static createFromBlock(props: CreateFromBlockProps): PayloadEnvelopeInput {
+    const bid = (props.block.message.body as gloas.BeaconBlockBody).signedExecutionPayloadBid.message;
+    return new PayloadEnvelopeInput({
+      blockRootHex: props.blockRootHex,
+      slot: props.block.message.slot,
+      forkName: props.forkName,
+      proposerIndex: props.block.message.proposerIndex,
+      bid,
+      sampledColumns: props.sampledColumns,
+      custodyColumns: props.custodyColumns,
+      timeCreatedSec: props.timeCreatedSec,
+    });
+  }
+
+  getBid(): gloas.ExecutionPayloadBid {
+    return this.bid;
+  }
+
+  getBuilderIndex(): ValidatorIndex {
+    return this.bid.builderIndex;
+  }
+
+  getBlockHashHex(): RootHex {
+    return toRootHex(this.bid.blockHash);
+  }
+
+  getBlobKzgCommitments(): deneb.BlobKzgCommitments {
+    return this.bid.blobKzgCommitments;
+  }
+
+  addPayloadEnvelope(props: AddPayloadEnvelopeProps): void {
+    if (this.state.hasPayload) {
+      throw new Error(`Payload envelope already set for block ${this.blockRootHex}`);
+    }
+    if (toRootHex(props.envelope.message.beaconBlockRoot) !== this.blockRootHex) {
+      throw new Error("Payload envelope beacon_block_root mismatch");
+    }
+
+    const source: SourceMeta = {
+      source: props.source,
+      seenTimestampSec: props.seenTimestampSec,
+      peerIdStr: props.peerIdStr,
+    };
+
+    if (this.state.hasAllData) {
+      // Complete state
+      this.state = {
+        hasPayload: true,
+        hasAllData: true,
+        hasComputedAllData: this.state.hasComputedAllData,
+        payloadEnvelope: props.envelope,
+        payloadEnvelopeSource: source,
+        timeCompleteSec: props.seenTimestampSec,
+      };
+      this.payloadEnvelopeDataPromise.resolve(props.envelope);
+    } else {
+      // Has payload, waiting for columns
+      this.state = {
+        hasPayload: true,
+        hasAllData: false,
+        hasComputedAllData: false,
+        payloadEnvelope: props.envelope,
+        payloadEnvelopeSource: source,
+      };
+    }
+  }
+
+  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();
+    const hasAllData =
+      // already hasAllData
+      this.state.hasAllData ||
+      // has all sampled columns
+      sampledColumns.length === this.sampledColumns.length ||
+      // has enough columns to reconstruct the rest
+      this.columnsCache.size >= NUMBER_OF_COLUMNS / 2;
+
+    const hasComputedAllData =
+      // has all sampled columns
+      sampledColumns.length === this.sampledColumns.length;
+
+    if (!hasAllData) {
+      return true;
+    }
+
+    if (hasComputedAllData) {
+      this.columnsDataPromise.resolve(sampledColumns);
+    }
+
+    if (this.state.hasPayload) {
+      // Complete state
+      this.state = {
+        hasPayload: true,
+        hasAllData: true,
+        hasComputedAllData: hasComputedAllData || this.state.hasComputedAllData,
+        payloadEnvelope: this.state.payloadEnvelope,
+        payloadEnvelopeSource: this.state.payloadEnvelopeSource,
+        timeCompleteSec: seenTimestampSec,
+      };
+      this.payloadEnvelopeDataPromise.resolve(this.state.payloadEnvelope);
+    } else {
+      // No payload yet, all data ready
+      this.state = {
+        hasPayload: false,
+        hasAllData: true,
+        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 {
+    return this.versionedHashes;
+  }
+
+  hasPayloadEnvelope(): boolean {
+    return this.state.hasPayload;
+  }
+
+  getPayloadEnvelope(): gloas.SignedExecutionPayloadEnvelope {
+    if (!this.state.hasPayload) throw new Error("Payload envelope not set");
+    return this.state.payloadEnvelope;
+  }
+
+  getPayloadEnvelopeSource(): SourceMeta {
+    if (!this.state.hasPayload) throw new Error("Payload envelope source not set");
+    return this.state.payloadEnvelopeSource;
+  }
+
+  getSampledColumns(): gloas.DataColumnSidecar[] {
+    const columns: gloas.DataColumnSidecar[] = [];
+    for (const index of this.sampledColumns) {
+      const column = this.columnsCache.get(index);
+      if (column) {
+        columns.push(column.columnSidecar);
+      }
+    }
+    return columns;
+  }
+
+  getSampledColumnsWithSource(): ColumnWithSource[] {
+    const columns: ColumnWithSource[] = [];
+    for (const index of this.sampledColumns) {
+      const column = this.columnsCache.get(index);
+      if (column) {
+        columns.push(column);
+      }
+    }
+    return columns;
+  }
+
+  getCustodyColumns(): gloas.DataColumnSidecar[] {
+    const columns: gloas.DataColumnSidecar[] = [];
+    for (const index of this.custodyColumns) {
+      const column = this.columnsCache.get(index);
+      if (column) {
+        columns.push(column.columnSidecar);
+      }
+    }
+    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<gloas.DataColumnSidecar[]> {
+    if (this.state.hasComputedAllData) {
+      return Promise.resolve(this.getSampledColumns());
+    }
+    return withTimeout(() => this.columnsDataPromise.promise, timeout, signal);
+  }
+
+  getTimeCreated(): number {
+    return this.timeCreatedSec;
+  }
+
+  getTimeComplete(): number {
+    if (!this.state.hasPayload || !this.state.hasAllData) throw new Error("Not yet complete");
+    return this.state.timeCompleteSec;
+  }
+
+  isComplete(): boolean {
+    return this.state.hasPayload && this.state.hasAllData;
+  }
+
+  async waitForData(): Promise<gloas.SignedExecutionPayloadEnvelope> {
+    return this.payloadEnvelopeDataPromise.promise;
+  }
+
+  getSerializedCacheKeys(): object[] {
+    const objects: object[] = [];
+
+    if (this.state.hasPayload) {
+      objects.push(this.state.payloadEnvelope);
+    }
+
+    for (const {columnSidecar} of this.columnsCache.values()) {
+      objects.push(columnSidecar);
+    }
+
+    return objects;
+  }
+
+  getLogMeta(): {
+    slot: number;
+    blockRoot: string;
+    hasPayload: boolean;
+    hasAllData: boolean;
+    hasComputedAllData: boolean;
+    isComplete: boolean;
+    receivedColumns: number;
+    sampledColumnsCount: number;
+  } {
+    return {
+      slot: this.slot,
+      blockRoot: this.blockRootHex,
+      hasPayload: this.state.hasPayload,
+      hasAllData: this.state.hasAllData,
+      hasComputedAllData: this.state.hasComputedAllData,
+      isComplete: this.isComplete(),
+      receivedColumns: this.columnsCache.size,
+      sampledColumnsCount: this.sampledColumns.length,
+    };
+  }
+}

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

@@ -0,0 +1,34 @@
+import {ForkName, ForkPostGloas} from "@lodestar/params";
+import {ColumnIndex, RootHex, SignedBeaconBlock, gloas} from "@lodestar/types";
+
+export enum PayloadEnvelopeInputSource {
+  gossip = "gossip",
+  api = "api",
+  engine = "engine",
+  byRange = "req_resp_by_range",
+  byRoot = "req_resp_by_root",
+  recovery = "recovery",
+}
+
+export type SourceMeta = {
+  source: PayloadEnvelopeInputSource;
+  seenTimestampSec: number;
+  peerIdStr?: string;
+};
+
+export type ColumnWithSource = SourceMeta & {
+  columnSidecar: gloas.DataColumnSidecar;
+};
+
+export type CreateFromBlockProps = {
+  blockRootHex: RootHex;
+  block: SignedBeaconBlock<ForkPostGloas>;
+  forkName: ForkName;
+  sampledColumns: ColumnIndex[];
+  custodyColumns: ColumnIndex[];
+  timeCreatedSec: number;
+};
+
+export type AddPayloadEnvelopeProps = SourceMeta & {
+  envelope: gloas.SignedExecutionPayloadEnvelope;
+};

package/src/chain/blocks/payloadEnvelopeProcessor.ts

@@ -0,0 +1,61 @@
+import {Metrics} from "../../metrics/metrics.js";
+import {JobItemQueue} from "../../util/queue/index.js";
+import type {BeaconChain} from "../chain.js";
+import {PayloadEnvelopeInput} from "../seenCache/seenPayloadEnvelopeInput.js";
+import {importExecutionPayload} from "./importExecutionPayload.js";
+import {ImportPayloadOpts} from "./types.js";
+
+// TODO GLOAS: Set to be equal to DEFAULT_MAX_PENDING_UNFINALIZED_PAYLOAD_ENVELOPE_WRITES for now
+const QUEUE_MAX_LENGTH = 16;
+
+enum PayloadEnvelopeImportStatus {
+  queued = "queued",
+  importing = "importing",
+  imported = "imported",
+}
+
+/**
+ * PayloadEnvelopeProcessor processes payload envelope jobs in a queued fashion, one after the other.
+ */
+export class PayloadEnvelopeProcessor {
+  readonly jobQueue: JobItemQueue<[PayloadEnvelopeInput, ImportPayloadOpts], void>;
+  private readonly importStatus = new WeakMap<PayloadEnvelopeInput, PayloadEnvelopeImportStatus>();
+
+  constructor(chain: BeaconChain, metrics: Metrics | null, signal: AbortSignal) {
+    this.jobQueue = new JobItemQueue<[PayloadEnvelopeInput, ImportPayloadOpts], void>(
+      (payloadInput, opts) => {
+        this.importStatus.set(payloadInput, PayloadEnvelopeImportStatus.importing);
+        return importExecutionPayload.call(chain, payloadInput, opts);
+      },
+      {maxLength: QUEUE_MAX_LENGTH, noYieldIfOneItem: true, signal},
+      metrics?.payloadEnvelopeProcessorQueue ?? undefined
+    );
+  }
+
+  async processPayloadEnvelopeJob(payloadInput: PayloadEnvelopeInput, opts: ImportPayloadOpts = {}): Promise<void> {
+    if (!payloadInput.isComplete()) {
+      return;
+    }
+
+    if (this.importStatus.get(payloadInput) !== undefined) {
+      return;
+    }
+
+    await this.jobQueue.waitForSpace();
+
+    // Re-check after await, as another call may have queued this payload.
+    if (this.importStatus.get(payloadInput) !== undefined) {
+      return;
+    }
+
+    this.importStatus.set(payloadInput, PayloadEnvelopeImportStatus.queued);
+
+    try {
+      await this.jobQueue.push(payloadInput, opts);
+      this.importStatus.set(payloadInput, PayloadEnvelopeImportStatus.imported);
+    } catch (e) {
+      this.importStatus.delete(payloadInput);
+      throw e;
+    }
+  }
+}

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";
 
@@ -41,6 +41,14 @@ export enum BlobSidecarValidation {
   Full,
 }
 
+export type ImportPayloadOpts = {
+  /**
+   * Set to true if envelope signature was already verified (e.g., during gossip/API validation).
+   * When false/undefined, signature will be verified during import.
+   */
+  validSignature?: boolean;
+};
+
 export type ImportBlockOpts = {
   /**
    * TEMP: Review if this is safe, Lighthouse always imports attestations even in finalized sync.
@@ -80,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 `postPayloadState`:
+ * - `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 &
+  (
+    | {
+        postPayloadState: null;
+        /** If the execution payload couldn't be verified because of EL syncing status, used in optimistic sync or for merge block */
+        executionStatus: BlockExecutionStatus;
+      }
+    | {
+        postPayloadState: 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;