@lodestar/beacon-node 1.42.0-dev.c35b4283f1 → 1.42.0-dev.c58e92512e

package/src/chain/opPools/aggregatedAttestationPool.ts

@@ -19,16 +19,15 @@ import {
   isForkPostElectra,
 } from "@lodestar/params";
 import {
-  CachedBeaconStateAllForks,
-  CachedBeaconStateAltair,
-  CachedBeaconStateGloas,
   EffectiveBalanceIncrements,
+  IBeaconStateView,
   RootCache,
   computeEpochAtSlot,
   computeSlotsSinceEpochStart,
   computeStartSlotAtEpoch,
   getAttestationParticipationStatus,
-  getBlockRootAtSlot,
+  isStatePostAltair,
+  isStatePostGloas,
 } from "@lodestar/state-transition";
 import {Attestation, Epoch, RootHex, Slot, electra, isElectraAttestation, phase0, ssz} from "@lodestar/types";
 import {MapDef, assert, toRootHex} from "@lodestar/utils";
@@ -212,7 +211,7 @@ export class AggregatedAttestationPool {
     fork: ForkName,
     forkChoice: IForkChoice,
     shufflingCache: ShufflingCache,
-    state: CachedBeaconStateAllForks
+    state: IBeaconStateView
   ): Attestation[] {
     const forkSeq = ForkSeq[fork];
     if (forkSeq < ForkSeq.electra) {
@@ -229,10 +228,10 @@ export class AggregatedAttestationPool {
     fork: ForkName,
     forkChoice: IForkChoice,
     shufflingCache: ShufflingCache,
-    state: CachedBeaconStateAllForks
+    state: IBeaconStateView
   ): electra.Attestation[] {
     const stateSlot = state.slot;
-    const stateEpoch = state.epochCtx.epoch;
+    const stateEpoch = state.epoch;
     const statePrevEpoch = stateEpoch - 1;
     const rootCache = new RootCache(state);
 
@@ -312,7 +311,7 @@ export class AggregatedAttestationPool {
           // The committeeCountPerSlot can be precomputed once per slot
           const getAttestationGroupResult = attestationGroup.getAttestationsForBlock(
             fork,
-            state.epochCtx.effectiveBalanceIncrements,
+            state.effectiveBalanceIncrements,
             notSeenCommitteeMembers,
             MAX_ATTESTATIONS_PER_GROUP_ELECTRA
           );
@@ -362,9 +361,7 @@ export class AggregatedAttestationPool {
             inclusionDistance,
             stateEpoch,
             rootCache,
-            ForkSeq[fork] >= ForkSeq.gloas
-              ? (state as CachedBeaconStateGloas).executionPayloadAvailability.toBoolArray()
-              : null
+            isStatePostGloas(state) ? state.executionPayloadAvailability : null
           );
 
           const weight =
@@ -735,27 +732,29 @@ export function aggregateConsolidation({byCommittee, attData}: AttestationsConso
 }
 
 /**
- * Pre-compute participation from a CachedBeaconStateAllForks, for use to check if an attestation's committee
+ * Pre-compute participation from a IBeaconStateView, for use to check if an attestation's committee
  * has already attested or not.
  */
 export function getNotSeenValidatorsFn(
   config: BeaconConfig,
   shufflingCache: ShufflingCache,
-  state: CachedBeaconStateAllForks
+  state: IBeaconStateView
 ): GetNotSeenValidatorsFn {
   const stateSlot = state.slot;
   if (config.getForkName(stateSlot) === ForkName.phase0) {
     throw new Error("getNotSeenValidatorsFn is not supported phase0 state");
   }
+  if (!isStatePostAltair(state)) {
+    throw new Error("Expected Altair state for participation tracking");
+  }
 
   // altair and future forks
   // Get attestations to be included in an altair block.
   // Attestations are sorted by inclusion distance then number of attesters.
   // Attestations should pass the validation when processing attestations in state-transition.
   // check for altair block already
-  const altairState = state as CachedBeaconStateAltair;
-  const previousParticipation = altairState.previousEpochParticipation.getAll();
-  const currentParticipation = altairState.currentEpochParticipation.getAll();
+  const previousParticipation = state.previousEpochParticipation;
+  const currentParticipation = state.currentEpochParticipation;
   const stateEpoch = computeEpochAtSlot(stateSlot);
   // this function could be called multiple times with same slot + committeeIndex
   const cachedNotSeenValidators = new Map<string, Set<number>>();
@@ -774,7 +773,7 @@ export function getNotSeenValidatorsFn(
       return notSeenCommitteeMembers.size === 0 ? null : notSeenCommitteeMembers;
     }
 
-    const decisionRoot = state.epochCtx.getShufflingDecisionRoot(computeEpochAtSlot(slot));
+    const decisionRoot = state.getShufflingDecisionRoot(computeEpochAtSlot(slot));
     const committee = shufflingCache.getBeaconCommittee(epoch, decisionRoot, slot, committeeIndex);
     notSeenCommitteeMembers = new Set<number>();
     for (const [i, validatorIndex] of committee.entries()) {
@@ -804,11 +803,11 @@ export function getNotSeenValidatorsFn(
  */
 export function getValidateAttestationDataFn(
   forkChoice: IForkChoice,
-  state: CachedBeaconStateAllForks
+  state: IBeaconStateView
 ): ValidateAttestationDataFn {
   const cachedValidatedAttestationData = new Map<string, InvalidAttestationData | null>();
   const {previousJustifiedCheckpoint, currentJustifiedCheckpoint} = state;
-  const stateEpoch = state.epochCtx.epoch;
+  const stateEpoch = state.epoch;
   return (attData: phase0.AttestationData) => {
     const targetEpoch = attData.target.epoch;
     let justifiedCheckpoint: phase0.Checkpoint;
@@ -850,14 +849,14 @@ export function getValidateAttestationDataFn(
  */
 function isValidShuffling(
   forkChoice: IForkChoice,
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   blockRootHex: RootHex,
   targetEpoch: Epoch
 ): InvalidAttestationData | null {
   // Otherwise the shuffling is determined by the block at the end of the target epoch
   // minus the shuffling lookahead (usually 2). We call this the "pivot".
   const pivotSlot = computeStartSlotAtEpoch(targetEpoch - 1) - 1;
-  const stateDependentRoot = toRootHex(getBlockRootAtSlot(state, pivotSlot));
+  const stateDependentRoot = toRootHex(state.getBlockRootAtSlot(pivotSlot));
 
   // Use fork choice's view of the block DAG to quickly evaluate whether the attestation's
   // pivot block is the same as the current state's pivot block. If it is, then the

package/src/chain/opPools/executionPayloadBidPool.ts

@@ -59,13 +59,13 @@ export class ExecutionPayloadBidPool {
   }
 
   /**
-   * Return the highest-value bid matching slot, parent block root, and parent block hash.
+   * Return the highest-value bid matching slot, parent block hash, and parent block root.
    * Used for gossip validation and block production.
    */
   getBestBid(
-    parentBlockRoot: BlockRootHex,
+    slot: Slot,
     parentBlockHash: BlockHashHex,
-    slot: Slot
+    parentBlockRoot: BlockRootHex
   ): gloas.ExecutionPayloadBid | null {
     const bidByParentHash = this.bidByParentHashByParentRootBySlot.get(slot)?.get(parentBlockRoot);
     return bidByParentHash?.get(parentBlockHash) ?? null;

package/src/chain/opPools/opPool.ts

@@ -11,11 +11,10 @@ import {
   MAX_VOLUNTARY_EXITS,
 } from "@lodestar/params";
 import {
-  CachedBeaconStateAllForks,
+  IBeaconStateView,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
   getAttesterSlashableIndices,
-  isValidVoluntaryExit,
 } from "@lodestar/state-transition";
 import {
   AttesterSlashing,
@@ -185,7 +184,7 @@ export class OpPool {
    * slashings included earlier in the block.
    */
   getSlashingsAndExits(
-    state: CachedBeaconStateAllForks,
+    state: IBeaconStateView,
     blockType: BlockType,
     metrics: Metrics | null
   ): [
@@ -207,7 +206,7 @@ export class OpPool {
     const endProposerSlashing = stepsMetrics?.startTimer();
     for (const proposerSlashing of this.proposerSlashings.values()) {
       const index = proposerSlashing.signedHeader1.message.proposerIndex;
-      const validator = state.validators.getReadonly(index);
+      const validator = state.getValidator(index);
       if (!validator.slashed && validator.activationEpoch <= stateEpoch && stateEpoch < validator.withdrawableEpoch) {
         proposerSlashings.push(proposerSlashing);
         // Set of validators to be slashed, so we don't attempt to construct invalid attester slashings.
@@ -234,7 +233,7 @@ export class OpPool {
           continue attesterSlashing;
         }
 
-        const validator = state.validators.getReadonly(index);
+        const validator = state.getValidator(index);
         if (isSlashableAtEpoch(validator, stateEpoch)) {
           slashableIndices.add(index);
         }
@@ -261,7 +260,7 @@ export class OpPool {
     for (const voluntaryExit of this.voluntaryExits.values()) {
       if (
         !toBeSlashedIndices.has(voluntaryExit.message.validatorIndex) &&
-        isValidVoluntaryExit(stateFork, state, voluntaryExit, false) &&
+        state.isValidVoluntaryExit(voluntaryExit, false) &&
         // Signature validation is skipped in `isValidVoluntaryExit(,,false)` since it was already validated in gossip
         // However we must make sure that the signature fork is the same, or it will become invalid if included through
         // a future fork.
@@ -320,7 +319,7 @@ export class OpPool {
   /**
    * Prune all types of transactions given the latest head state
    */
-  pruneAll(headBlock: SignedBeaconBlock, headState: CachedBeaconStateAllForks): void {
+  pruneAll(headBlock: SignedBeaconBlock, headState: IBeaconStateView): void {
     this.pruneAttesterSlashings(headState);
     this.pruneProposerSlashings(headState);
     this.pruneVoluntaryExits(headState);
@@ -330,7 +329,7 @@ export class OpPool {
   /**
    * Prune attester slashings for all slashed or withdrawn validators.
    */
-  private pruneAttesterSlashings(headState: CachedBeaconStateAllForks): void {
+  private pruneAttesterSlashings(headState: IBeaconStateView): void {
     const finalizedEpoch = headState.finalizedCheckpoint.epoch;
     attesterSlashing: for (const [key, attesterSlashing] of this.attesterSlashings.entries()) {
       // Slashings that don't slash any validators can be dropped
@@ -342,7 +341,7 @@ export class OpPool {
         //
         // We cannot check the `slashed` field since the `head` is not finalized and
         // a fork could un-slash someone.
-        if (headState.validators.getReadonly(index).exitEpoch > finalizedEpoch) {
+        if (headState.getValidator(index).exitEpoch > finalizedEpoch) {
           continue attesterSlashing;
         }
       }
@@ -355,11 +354,11 @@ export class OpPool {
   /**
    * Prune proposer slashings for validators which are exited in the finalized epoch.
    */
-  private pruneProposerSlashings(headState: CachedBeaconStateAllForks): void {
+  private pruneProposerSlashings(headState: IBeaconStateView): void {
     const finalizedEpoch = headState.finalizedCheckpoint.epoch;
     for (const [key, proposerSlashing] of this.proposerSlashings.entries()) {
       const index = proposerSlashing.signedHeader1.message.proposerIndex;
-      if (headState.validators.getReadonly(index).exitEpoch <= finalizedEpoch) {
+      if (headState.getValidator(index).exitEpoch <= finalizedEpoch) {
         this.proposerSlashings.delete(key);
       }
     }
@@ -369,7 +368,7 @@ export class OpPool {
    * Call after finalizing
    * Prune if validator has already exited at or before the finalized checkpoint of the head.
    */
-  private pruneVoluntaryExits(headState: CachedBeaconStateAllForks): void {
+  private pruneVoluntaryExits(headState: IBeaconStateView): void {
     const headStateFork = this.config.getForkSeq(headState.slot);
     const finalizedEpoch = headState.finalizedCheckpoint.epoch;
 
@@ -392,7 +391,7 @@ export class OpPool {
    * In the worse case where head block is reorged, the same BlsToExecutionChange message can be re-added
    * to opPool once gossipsub seen cache TTL passes.
    */
-  private pruneBlsToExecutionChanges(headBlock: SignedBeaconBlock, headState: CachedBeaconStateAllForks): void {
+  private pruneBlsToExecutionChanges(headBlock: SignedBeaconBlock, headState: IBeaconStateView): void {
     const recentBlsToExecutionChanges =
       this.config.getForkSeq(headBlock.message.slot) >= ForkSeq.capella
         ? (headBlock as capella.SignedBeaconBlock).message.body.blsToExecutionChanges
@@ -405,7 +404,7 @@ export class OpPool {
     for (const [key, blsToExecutionChange] of this.blsToExecutionChanges.entries()) {
       const {validatorIndex} = blsToExecutionChange.data.message;
       if (!recentBlsToExecutionChangeIndexes.has(validatorIndex)) {
-        const validator = headState.validators.getReadonly(validatorIndex);
+        const validator = headState.getValidator(validatorIndex);
         if (validator.withdrawalCredentials[0] !== BLS_WITHDRAWAL_PREFIX) {
           this.blsToExecutionChanges.delete(key);
         }

package/src/chain/opPools/utils.ts

@@ -1,6 +1,6 @@
 import {Signature} from "@chainsafe/blst";
 import {BLS_WITHDRAWAL_PREFIX} from "@lodestar/params";
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
+import {IBeaconStateView} from "@lodestar/state-transition";
 import {Slot, capella} from "@lodestar/types";
 import {AggregateFast, AggregateFastElectra} from "./attestationPool.js";
 
@@ -38,7 +38,7 @@ export function signatureFromBytesNoCheck(signature: Uint8Array): Signature {
  * can become invalid for certain forks.
  */
 export function isValidBlsToExecutionChangeForBlockInclusion(
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   signedBLSToExecutionChange: capella.SignedBLSToExecutionChange
 ): boolean {
   // For each condition from https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/capella/beacon-chain.md#new-process_bls_to_execution_change
@@ -48,7 +48,7 @@ export function isValidBlsToExecutionChangeForBlockInclusion(
   //
   // 2. assert validator.withdrawal_credentials[:1] == BLS_WITHDRAWAL_PREFIX:
   //    Must be checked again, since it can already be changed by now.
-  const validator = state.validators.getReadonly(signedBLSToExecutionChange.message.validatorIndex);
+  const validator = state.getValidator(signedBLSToExecutionChange.message.validatorIndex);
   const {withdrawalCredentials} = validator;
   if (withdrawalCredentials[0] !== BLS_WITHDRAWAL_PREFIX) {
     return false;

package/src/chain/options.ts

@@ -47,6 +47,7 @@ export type IChainOptions = BlockProcessOpts &
     minSameMessageSignatureSetsToBatch: number;
     archiveDateEpochs?: number;
     nHistoricalStatesFileDataStore?: boolean;
+    nativeStateView?: boolean;
   };
 
 export type BlockProcessOpts = {
@@ -124,6 +125,7 @@ export const defaultChainOptions: IChainOptions = {
   //   - users can prune the persisted checkpoint state files manually to save disc space
   //   - it helps debug easier when network is unfinalized
   nHistoricalStatesFileDataStore: true,
+  nativeStateView: false,
   maxBlockStates: DEFAULT_MAX_BLOCK_STATES,
   maxCPStateEpochsInMemory: DEFAULT_MAX_CP_STATE_EPOCHS_IN_MEMORY,
   maxCPStateEpochsOnDisk: DEFAULT_MAX_CP_STATE_ON_DISK,

package/src/chain/prepareNextSlot.ts

@@ -3,12 +3,11 @@ import {ChainForkConfig} from "@lodestar/config";
 import {PayloadStatus, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH, isForkPostBellatrix} from "@lodestar/params";
 import {
-  CachedBeaconStateAllForks,
-  CachedBeaconStateExecutions,
-  CachedBeaconStateGloas,
+  IBeaconStateView,
   StateHashTreeRootSource,
   computeEpochAtSlot,
   computeTimeAtSlot,
+  isStatePostBellatrix,
 } from "@lodestar/state-transition";
 import {Slot} from "@lodestar/types";
 import {Logger, fromHex, isErrorAborted, sleep} from "@lodestar/utils";
@@ -121,9 +120,9 @@ export class PrepareNextSlotScheduler {
       );
 
       if (isForkPostBellatrix(fork)) {
-        const proposerIndex = prepareState.epochCtx.getBeaconProposer(prepareSlot);
+        const proposerIndex = prepareState.getBeaconProposer(prepareSlot);
         const feeRecipient = this.chain.beaconProposerCache.get(proposerIndex);
-        let updatedPrepareState = prepareState as CachedBeaconStateExecutions | CachedBeaconStateGloas;
+        let updatedPrepareState = prepareState;
         let updatedHeadRoot = headRoot;
 
         if (feeRecipient) {
@@ -140,13 +139,13 @@ export class PrepareNextSlotScheduler {
               headRoot,
             });
             this.metrics?.weakHeadDetected.inc();
-            updatedPrepareState = (await this.chain.regen.getBlockSlotState(
+            updatedPrepareState = await this.chain.regen.getBlockSlotState(
               proposerHead,
               prepareSlot,
               // only transfer cache if epoch transition because that's the state we will use to stateTransition() the 1st block of epoch
               {dontTransferCache: !isEpochTransition},
               RegenCaller.predictProposerHead
-            )) as CachedBeaconStateExecutions | CachedBeaconStateGloas;
+            );
             updatedHeadRoot = proposerHeadRoot;
           }
 
@@ -161,6 +160,9 @@ export class PrepareNextSlotScheduler {
           const preparationTime =
             computeTimeAtSlot(this.config, prepareSlot, this.chain.genesisTime) - Date.now() / 1000;
           this.metrics?.blockPayload.payloadAdvancePrepTime.observe(preparationTime);
+          if (!isStatePostBellatrix(updatedPrepareState)) {
+            throw new Error("Expected Bellatrix state for payload preparation");
+          }
 
           const safeBlockHash = getSafeExecutionBlockHash(this.chain.forkChoice);
           const finalizedBlockHash =
@@ -185,6 +187,10 @@ export class PrepareNextSlotScheduler {
           });
         }
 
+        if (!isStatePostBellatrix(updatedPrepareState)) {
+          throw new Error("Expected Bellatrix state for payload attributes");
+        }
+
         this.computeStateHashTreeRoot(updatedPrepareState, isEpochTransition);
 
         // If emitPayloadAttributes is true emit a SSE payloadAttributes event
@@ -239,7 +245,7 @@ export class PrepareNextSlotScheduler {
     }
   };
 
-  computeStateHashTreeRoot(state: CachedBeaconStateAllForks, isEpochTransition: boolean): void {
+  computeStateHashTreeRoot(state: IBeaconStateView, isEpochTransition: boolean): void {
     // cache HashObjects for faster hashTreeRoot() later, especially for computeNewStateRoot() if we need to produce a block at slot 0 of epoch
     // see https://github.com/ChainSafe/lodestar/issues/6194
     const hashTreeRootTimer = this.metrics?.stateHashTreeRootTime.startTimer({

package/src/chain/produceBlock/computeNewStateRoot.ts

@@ -1,13 +1,11 @@
 import {
-  CachedBeaconStateAllForks,
-  CachedBeaconStateGloas,
   DataAvailabilityStatus,
   ExecutionPayloadStatus,
   G2_POINT_AT_INFINITY,
+  IBeaconStateView,
+  IBeaconStateViewGloas,
   StateHashTreeRootSource,
-  stateTransition,
 } from "@lodestar/state-transition";
-import {processExecutionPayloadEnvelope} from "@lodestar/state-transition/block";
 import {BeaconBlock, BlindedBeaconBlock, Gwei, Root, gloas} from "@lodestar/types";
 import {ZERO_HASH} from "../../constants/index.js";
 import {Metrics} from "../../metrics/index.js";
@@ -19,14 +17,13 @@ import {Metrics} from "../../metrics/index.js";
  */
 export function computeNewStateRoot(
   metrics: Metrics | null,
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   block: BeaconBlock | BlindedBeaconBlock
-): {newStateRoot: Root; proposerReward: Gwei; postState: CachedBeaconStateAllForks} {
+): {newStateRoot: Root; proposerReward: Gwei; postState: IBeaconStateView} {
   // Set signature to zero to re-use stateTransition() function which requires the SignedBeaconBlock type
   const blockEmptySig = {message: block, signature: ZERO_HASH};
 
-  const postState = stateTransition(
-    state,
+  const postState = state.stateTransition(
     blockEmptySig,
     {
       // ExecutionPayloadStatus.valid: Assume payload valid, it has been produced by a trusted EL
@@ -64,7 +61,7 @@ export function computeNewStateRoot(
  */
 export function computeEnvelopeStateRoot(
   metrics: Metrics | null,
-  postBlockState: CachedBeaconStateGloas,
+  postBlockState: IBeaconStateViewGloas,
   envelope: gloas.ExecutionPayloadEnvelope
 ): Root {
   const signedEnvelope: gloas.SignedExecutionPayloadEnvelope = {
@@ -73,7 +70,7 @@ export function computeEnvelopeStateRoot(
   };
 
   const processEnvelopeTimer = metrics?.blockPayload.executionPayloadEnvelopeProcessingTime.startTimer();
-  const postEnvelopeState = processExecutionPayloadEnvelope(postBlockState, signedEnvelope, {
+  const postEnvelopeState = postBlockState.processExecutionPayloadEnvelope(signedEnvelope, {
     // Signature is zero-ed (G2_POINT_AT_INFINITY), skip verification
     verifySignature: false,
     // State root is being computed here, the envelope doesn't have it yet

package/src/chain/produceBlock/produceBlockBody.ts

@@ -15,15 +15,14 @@ import {
   isForkPostGloas,
 } from "@lodestar/params";
 import {
-  CachedBeaconStateAllForks,
-  CachedBeaconStateBellatrix,
-  CachedBeaconStateCapella,
-  CachedBeaconStateExecutions,
-  CachedBeaconStateGloas,
   G2_POINT_AT_INFINITY,
+  IBeaconStateView,
+  type IBeaconStateViewBellatrix,
   computeTimeAtSlot,
-  getExpectedWithdrawals,
-  getRandaoMix,
+  isParentBlockFull,
+  isStatePostBellatrix,
+  isStatePostCapella,
+  isStatePostGloas,
 } from "@lodestar/state-transition";
 import {
   BLSPubkey,
@@ -161,7 +160,7 @@ export type ProduceResult =
 export async function produceBlockBody<T extends BlockType>(
   this: BeaconChain,
   blockType: T,
-  currentState: CachedBeaconStateAllForks,
+  currentState: IBeaconStateView,
   blockAttr: BlockAttributes & {
     proposerIndex: ValidatorIndex;
     proposerPubKey: BLSPubkey;
@@ -201,10 +200,13 @@ export async function produceBlockBody<T extends BlockType>(
   this.logger.verbose("Producing beacon block body", logMeta);
 
   if (isForkPostGloas(fork)) {
+    if (!isStatePostGloas(currentState)) {
+      throw new Error("Expected Gloas state for Gloas block production");
+    }
+
     // TODO GLOAS: support non self-building here, the block type differentiation between
     // full and blinded no longer makes sense in gloas, it might be a good idea to move
     // this into a completely separate function and have pre/post gloas more separated
-    const gloasState = currentState as CachedBeaconStateGloas;
     const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice);
     const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
     const feeRecipient = requestedFeeRecipient ?? this.beaconProposerCache.getOrDefault(proposerIndex);
@@ -225,7 +227,7 @@ export async function produceBlockBody<T extends BlockType>(
       parentBlockRoot,
       safeBlockHash,
       finalizedBlockHash ?? ZERO_HASH_HEX,
-      gloasState,
+      currentState,
       feeRecipient
     );
 
@@ -259,10 +261,10 @@ export async function produceBlockBody<T extends BlockType>(
 
     // Create self-build execution payload bid
     const bid: gloas.ExecutionPayloadBid = {
-      parentBlockHash: gloasState.latestBlockHash,
+      parentBlockHash: currentState.latestBlockHash,
       parentBlockRoot: parentBlockRoot,
       blockHash: executionPayload.blockHash,
-      prevRandao: getRandaoMix(gloasState, gloasState.epochCtx.epoch),
+      prevRandao: currentState.getRandaoMix(currentState.epoch),
       feeRecipient: executionPayload.feeRecipient,
       gasLimit: BigInt(executionPayload.gasLimit),
       builderIndex: BUILDER_INDEX_SELF_BUILD,
@@ -308,6 +310,10 @@ export async function produceBlockBody<T extends BlockType>(
       shouldOverrideBuilder,
     });
   } else if (isForkPostBellatrix(fork)) {
+    if (!isStatePostBellatrix(currentState)) {
+      throw new Error("Expected Bellatrix state for execution block production");
+    }
+
     const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice);
     const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
     const feeRecipient = requestedFeeRecipient ?? this.beaconProposerCache.getOrDefault(proposerIndex);
@@ -336,7 +342,7 @@ export async function produceBlockBody<T extends BlockType>(
             parentBlockRoot,
             safeBlockHash,
             finalizedBlockHash ?? ZERO_HASH_HEX,
-            currentState as CachedBeaconStateBellatrix,
+            currentState,
             executionBuilder.issueLocalFcUWithFeeRecipient
           );
         }
@@ -348,12 +354,7 @@ export async function produceBlockBody<T extends BlockType>(
           slot: blockSlot,
           proposerPubKey: toHex(proposerPubKey),
         });
-        const headerRes = await prepareExecutionPayloadHeader(
-          this,
-          fork,
-          currentState as CachedBeaconStateBellatrix,
-          proposerPubKey
-        );
+        const headerRes = await prepareExecutionPayloadHeader(this, fork, currentState, proposerPubKey);
 
         endExecutionPayloadHeader?.({
           step: BlockProductionStep.executionPayload,
@@ -388,7 +389,7 @@ export async function produceBlockBody<T extends BlockType>(
         });
       } else {
         const headerGasLimit = builderRes.header.gasLimit;
-        const parentGasLimit = (currentState as CachedBeaconStateBellatrix).latestExecutionPayloadHeader.gasLimit;
+        const parentGasLimit = currentState.latestExecutionPayloadHeader.gasLimit;
         const expectedGasLimit = getExpectedGasLimit(parentGasLimit, targetGasLimit);
 
         const lowerBound = Math.min(parentGasLimit, expectedGasLimit);
@@ -449,7 +450,7 @@ export async function produceBlockBody<T extends BlockType>(
           parentBlockRoot,
           safeBlockHash,
           finalizedBlockHash ?? ZERO_HASH_HEX,
-          currentState as CachedBeaconStateExecutions,
+          currentState,
           feeRecipient
         );
 
@@ -614,14 +615,12 @@ export async function prepareExecutionPayload(
   parentBlockRoot: Root,
   safeBlockHash: RootHex,
   finalizedBlockHash: RootHex,
-  state: CachedBeaconStateExecutions | CachedBeaconStateGloas,
+  state: IBeaconStateViewBellatrix,
   suggestedFeeRecipient: string
 ): Promise<{prepType: PayloadPreparationType; payloadId: PayloadId}> {
-  const parentHash = isForkPostGloas(fork)
-    ? (state as CachedBeaconStateGloas).latestBlockHash
-    : (state as CachedBeaconStateExecutions).latestExecutionPayloadHeader.blockHash;
+  const parentHash = state.latestBlockHash;
   const timestamp = computeTimeAtSlot(chain.config, state.slot, state.genesisTime);
-  const prevRandao = getRandaoMix(state, state.epochCtx.epoch);
+  const prevRandao = state.getRandaoMix(state.epoch);
 
   const payloadIdCached = chain.executionEngine.payloadIdCache.get({
     headBlockHash: toRootHex(parentHash),
@@ -684,7 +683,7 @@ async function prepareExecutionPayloadHeader(
     config: ChainForkConfig;
   },
   fork: ForkPostBellatrix,
-  state: CachedBeaconStateBellatrix,
+  state: IBeaconStateViewBellatrix,
   proposerPubKey: BLSPubkey
 ): Promise<{
   header: ExecutionPayloadHeader;
@@ -711,16 +710,9 @@ export function getPayloadAttributesForSSE(
     prepareSlot,
     parentBlockRoot,
     feeRecipient,
-  }: {
-    prepareState: CachedBeaconStateExecutions | CachedBeaconStateGloas;
-    prepareSlot: Slot;
-    parentBlockRoot: Root;
-    feeRecipient: string;
-  }
+  }: {prepareState: IBeaconStateViewBellatrix; prepareSlot: Slot; parentBlockRoot: Root; feeRecipient: string}
 ): SSEPayloadAttributes {
-  const parentHash = isForkPostGloas(fork)
-    ? (prepareState as CachedBeaconStateGloas).latestBlockHash
-    : (prepareState as CachedBeaconStateExecutions).latestExecutionPayloadHeader.blockHash;
+  const parentHash = prepareState.latestBlockHash;
   const payloadAttributes = preparePayloadAttributes(fork, chain, {
     prepareState,
     prepareSlot,
@@ -736,11 +728,11 @@ export function getPayloadAttributesForSSE(
     }
     parentBlockNumber = parentBlock.executionPayloadNumber;
   } else {
-    parentBlockNumber = (prepareState as CachedBeaconStateExecutions).latestExecutionPayloadHeader.blockNumber;
+    parentBlockNumber = prepareState.payloadBlockNumber;
   }
 
   const ssePayloadAttributes: SSEPayloadAttributes = {
-    proposerIndex: prepareState.epochCtx.getBeaconProposer(prepareSlot),
+    proposerIndex: prepareState.getBeaconProposer(prepareSlot),
     proposalSlot: prepareSlot,
     parentBlockNumber,
     parentBlockRoot,
@@ -761,14 +753,14 @@ function preparePayloadAttributes(
     parentBlockRoot,
     feeRecipient,
   }: {
-    prepareState: CachedBeaconStateExecutions | CachedBeaconStateGloas;
+    prepareState: IBeaconStateViewBellatrix;
     prepareSlot: Slot;
     parentBlockRoot: Root;
     feeRecipient: string;
   }
 ): SSEPayloadAttributes["payloadAttributes"] {
   const timestamp = computeTimeAtSlot(chain.config, prepareSlot, prepareState.genesisTime);
-  const prevRandao = getRandaoMix(prepareState, prepareState.epochCtx.epoch);
+  const prevRandao = prepareState.getRandaoMix(prepareState.epoch);
   const payloadAttributes = {
     timestamp,
     prevRandao,
@@ -776,11 +768,22 @@ function preparePayloadAttributes(
   };
 
   if (ForkSeq[fork] >= ForkSeq.capella) {
-    // withdrawals logic is now fork aware as it changes on electra fork post capella
-    (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals = getExpectedWithdrawals(
-      ForkSeq[fork],
-      prepareState as CachedBeaconStateCapella
-    ).expectedWithdrawals;
+    if (!isStatePostCapella(prepareState)) {
+      throw new Error("Expected Capella state for withdrawals");
+    }
+
+    if (isStatePostGloas(prepareState) && !isParentBlockFull(prepareState)) {
+      // When the parent block is empty, state.payloadExpectedWithdrawals holds a batch
+      // already deducted from CL balances but never credited on the EL (the envelope
+      // was not delivered). The next payload must carry those same withdrawals to
+      // restore CL/EL consistency, otherwise validators permanently lose that balance.
+      (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+        prepareState.payloadExpectedWithdrawals;
+    } else {
+      // withdrawals logic is now fork aware as it changes on electra fork post capella
+      (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+        prepareState.getExpectedWithdrawals().expectedWithdrawals;
+    }
   }
 
   if (ForkSeq[fork] >= ForkSeq.deneb) {
@@ -793,7 +796,7 @@ function preparePayloadAttributes(
 export async function produceCommonBlockBody<T extends BlockType>(
   this: BeaconChain,
   blockType: T,
-  currentState: CachedBeaconStateAllForks,
+  currentState: IBeaconStateView,
   {randaoReveal, graffiti, slot, parentBlock}: BlockAttributes
 ): Promise<CommonBlockBody> {
   const stepsMetrics =