@lodestar/state-transition 1.50.0-dev.2e668c516f → 1.50.0-dev.3430a7cf04

package/src/block/processOperations.ts

@@ -1,4 +1,4 @@
-import {ForkSeq} from "@lodestar/params";
+import {ForkPreHeze, ForkSeq} from "@lodestar/params";
 import {BeaconBlockBody, Slot, capella, electra, gloas} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {
@@ -6,6 +6,7 @@ import {
   CachedBeaconStateCapella,
   CachedBeaconStateElectra,
   CachedBeaconStateGloas,
+  CachedBeaconStatePreHeze,
 } from "../types.js";
 import {getEth1DepositCount} from "../util/deposit.js";
 import {processAttestations} from "./processAttestations.js";
@@ -40,13 +41,15 @@ export function processOperations(
   opts: ProcessBlockOpts = {verifySignatures: true},
   metrics?: BeaconStateTransitionMetrics | null
 ): void {
-  // verify that outstanding deposits are processed up to the maximum number of deposits.
-  // From Fulu the eth1 bridge deposit mechanism was removed, so blocks must not contain any deposits.
-  const maxDeposits = fork >= ForkSeq.fulu ? 0 : getEth1DepositCount(state);
-  if (body.deposits.length !== maxDeposits) {
-    throw new Error(
-      `Block contains incorrect number of deposits: depositCount=${body.deposits.length} expected=${maxDeposits}`
-    );
+  if (fork < ForkSeq.heze) {
+    // From Fulu the eth1 bridge deposit mechanism was removed, so blocks must not contain any deposits.
+    const deposits = (body as BeaconBlockBody<ForkPreHeze>).deposits;
+    const maxDeposits = fork >= ForkSeq.fulu ? 0 : getEth1DepositCount(state as CachedBeaconStatePreHeze);
+    if (deposits.length !== maxDeposits) {
+      throw new Error(
+        `Block contains incorrect number of deposits: depositCount=${deposits.length} expected=${maxDeposits}`
+      );
+    }
   }
 
   {
@@ -71,10 +74,10 @@ export function processOperations(
     timer?.();
   }
 
-  {
+  if (fork < ForkSeq.heze) {
     const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processDeposit});
-    for (const deposit of body.deposits) {
-      processDeposit(fork, state, deposit);
+    for (const deposit of (body as BeaconBlockBody<ForkPreHeze>).deposits) {
+      processDeposit(fork, state as CachedBeaconStatePreHeze, deposit);
     }
     timer?.();
   }

package/src/block/processParentExecutionPayload.ts

@@ -3,6 +3,7 @@ import {BeaconBlock, gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot} from "../util/epoch.js";
+import {IndexedBuilderState} from "./indexedBuilderState.js";
 import {processBuilderDepositRequest} from "./processBuilderDepositRequest.js";
 import {processBuilderExitRequest} from "./processBuilderExitRequest.js";
 import {processConsolidationRequest} from "./processConsolidationRequest.js";
@@ -53,29 +54,8 @@ export function applyParentExecutionPayload(state: CachedBeaconStateGloas, reque
   const parentEpoch = computeEpochAtSlot(parentSlot);
   const currentEpoch = computeEpochAtSlot(state.slot);
 
-  // Process execution requests from parent's payload. The execution
-  // requests are processed at state.slot (child's slot), not the parent's slot.
-  for (const deposit of requests.deposits) {
-    processDepositRequest(fork, state, deposit);
-  }
-
-  for (const withdrawal of requests.withdrawals) {
-    processWithdrawalRequest(fork, state, withdrawal);
-  }
-
-  for (const consolidation of requests.consolidations) {
-    processConsolidationRequest(state, consolidation);
-  }
-
-  for (const builderDeposit of requests.builderDeposits) {
-    processBuilderDepositRequest(state, builderDeposit);
-  }
-
-  for (const builderExit of requests.builderExits) {
-    processBuilderExitRequest(state, builderExit);
-  }
-
-  // Settle the builder payment
+  // Settle the builder payment before the requests so that a builder exit request
+  // is rejected while the payment is pending
   if (parentEpoch === currentEpoch) {
     settleBuilderPayment(state, SLOTS_PER_EPOCH + (parentSlot % SLOTS_PER_EPOCH));
   } else if (parentEpoch === currentEpoch - 1) {
@@ -92,6 +72,30 @@ export function applyParentExecutionPayload(state: CachedBeaconStateGloas, reque
     );
   }
 
+  // Process execution requests from parent's payload. The execution
+  // requests are processed at state.slot (child's slot), not the parent's slot.
+  for (const deposit of requests.deposits) {
+    processDepositRequest(fork, state, deposit);
+  }
+
+  for (const withdrawal of requests.withdrawals) {
+    processWithdrawalRequest(fork, state, withdrawal);
+  }
+
+  for (const consolidation of requests.consolidations) {
+    processConsolidationRequest(state, consolidation);
+  }
+
+  if (requests.builderDeposits.length > 0 || requests.builderExits.length > 0) {
+    const indexedState = new IndexedBuilderState(state);
+    for (const builderDeposit of requests.builderDeposits) {
+      processBuilderDepositRequest(indexedState, builderDeposit);
+    }
+    for (const builderExit of requests.builderExits) {
+      processBuilderExitRequest(indexedState, builderExit);
+    }
+  }
+
   // Update parent payload availability and latest block hash
   state.executionPayloadAvailability.set(parentSlot % SLOTS_PER_HISTORICAL_ROOT, true);
   state.latestBlockHash = parentBid.blockHash;

package/src/block/processProposerSlashing.ts

@@ -1,9 +1,9 @@
 import {BeaconConfig} from "@lodestar/config";
-import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ForkSeq} from "@lodestar/params";
 import {Slot, phase0, ssz} from "@lodestar/types";
 import {Validator} from "@lodestar/types/phase0";
 import {getProposerSlashingSignatureSets} from "../signatureSets/index.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
+import {CachedBeaconStateAllForks} from "../types.js";
 import {computeEpochAtSlot, isSlashableValidator} from "../util/index.js";
 import {verifySignatureSet} from "../util/signatureSets.js";
 import {slashValidator} from "./slashValidator.js";
@@ -23,32 +23,6 @@ export function processProposerSlashing(
   const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
   assertValidProposerSlashing(state.config, state.slot, proposerSlashing, proposer, verifySignatures);
 
-  if (fork >= ForkSeq.gloas) {
-    // Remove the BuilderPendingPayment corresponding to this proposal if it is still in the
-    // 2-epoch window. Only clear it when the slashed validator is the proposer associated with
-    // the payment; otherwise an unrelated same-slot equivocation could grief an honest proposer's
-    // payment.
-    const slot = Number(proposerSlashing.signedHeader1.message.slot);
-    const proposalEpoch = computeEpochAtSlot(slot);
-    const currentEpoch = state.epochCtx.epoch;
-    const previousEpoch = currentEpoch - 1;
-
-    const paymentIndex =
-      proposalEpoch === currentEpoch
-        ? SLOTS_PER_EPOCH + (slot % SLOTS_PER_EPOCH)
-        : proposalEpoch === previousEpoch
-          ? slot % SLOTS_PER_EPOCH
-          : undefined;
-
-    if (paymentIndex !== undefined) {
-      const builderPendingPayments = (state as CachedBeaconStateGloas).builderPendingPayments;
-      const payment = builderPendingPayments.get(paymentIndex);
-      if (payment.proposerIndex === proposerSlashing.signedHeader1.message.proposerIndex) {
-        builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
-      }
-    }
-  }
-
   slashValidator(fork, state, proposerSlashing.signedHeader1.message.proposerIndex);
 }
 

package/src/block/slashValidator.ts

@@ -13,8 +13,8 @@ import {
   WHISTLEBLOWER_REWARD_QUOTIENT,
   WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA,
 } from "@lodestar/params";
-import {ValidatorIndex} from "@lodestar/types";
-import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
+import {ValidatorIndex, ssz} from "@lodestar/types";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair, CachedBeaconStateGloas} from "../types.js";
 import {decreaseBalance, increaseBalance} from "../util/index.js";
 import {initiateValidatorExit} from "./initiateValidatorExit.js";
 
@@ -95,4 +95,15 @@ export function slashValidator(
       );
     }
   }
+
+  if (fork >= ForkSeq.gloas) {
+    // Cleared on every slashing, not only proposer slashings: a proposer slashed via an attester slashing
+    // first would otherwise keep the builder paying for a block it equivocated on
+    const {builderPendingPayments} = state as CachedBeaconStateGloas;
+    for (let i = 0; i < builderPendingPayments.length; i++) {
+      if (builderPendingPayments.getReadonly(i).proposerIndex === slashedIndex) {
+        builderPendingPayments.set(i, ssz.gloas.BuilderPendingPayment.defaultViewDU());
+      }
+    }
+  }
 }

package/src/cache/stateCache.ts

@@ -15,6 +15,7 @@ import {
   BeaconStateGloas,
   BeaconStateHeze,
   BeaconStatePhase0,
+  BeaconStatePreHeze,
 } from "./types.js";
 
 export type BeaconStateCache = {
@@ -142,6 +143,7 @@ export type CachedBeaconStateHeze = CachedBeaconState<BeaconStateHeze>;
 
 export type CachedBeaconStateAllForks = CachedBeaconState<BeaconStateAllForks>;
 export type CachedBeaconStateExecutions = CachedBeaconState<BeaconStateExecutions>;
+export type CachedBeaconStatePreHeze = CachedBeaconState<BeaconStatePreHeze>;
 /**
  * Create CachedBeaconState computing a new EpochCache instance
  * TODO ELECTRA: rename this to createFinalizedCachedBeaconState() as it's intended for finalized state only

package/src/cache/types.ts

@@ -1,5 +1,5 @@
 import {CompositeViewDU} from "@chainsafe/ssz";
-import {ForkAll, ForkName, ForkPostBellatrix, ForkPreGloas} from "@lodestar/params";
+import {ForkAll, ForkName, ForkPostBellatrix, ForkPreGloas, ForkPreHeze} from "@lodestar/params";
 import {Epoch, RootHex, SSZTypesFor} from "@lodestar/types";
 import {EpochShuffling} from "../util/epochShuffling.js";
 
@@ -15,5 +15,6 @@ export type BeaconStateHeze = CompositeViewDU<SSZTypesFor<ForkName.heze, "Beacon
 
 export type BeaconStateAllForks = CompositeViewDU<SSZTypesFor<ForkAll, "BeaconState">>;
 export type BeaconStateExecutions = CompositeViewDU<SSZTypesFor<ForkPostBellatrix & ForkPreGloas, "BeaconState">>;
+export type BeaconStatePreHeze = CompositeViewDU<SSZTypesFor<ForkPreHeze, "BeaconState">>;
 
 export type ShufflingGetter = (shufflingEpoch: Epoch, dependentRoot: RootHex) => EpochShuffling | null;

package/src/epoch/index.ts

@@ -14,6 +14,7 @@ import {
   CachedBeaconStateFulu,
   CachedBeaconStateGloas,
   CachedBeaconStatePhase0,
+  CachedBeaconStatePreHeze,
   EpochTransitionCache,
 } from "../types.js";
 import {processBuilderPendingPayments} from "./processBuilderPendingPayments.js";
@@ -140,7 +141,9 @@ export function processEpoch(
     timer?.();
   }
 
-  processEth1DataReset(state, cache);
+  if (fork < ForkSeq.heze) {
+    processEth1DataReset(state as CachedBeaconStatePreHeze, cache);
+  }
 
   if (fork >= ForkSeq.electra) {
     const stateElectra = state as CachedBeaconStateElectra;

package/src/epoch/processEth1DataReset.ts

@@ -1,13 +1,13 @@
 import {EPOCHS_PER_ETH1_VOTING_PERIOD} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
-import {CachedBeaconStateAllForks, EpochTransitionCache} from "../types.js";
+import {CachedBeaconStatePreHeze, EpochTransitionCache} from "../types.js";
 
 /**
  * Reset eth1DataVotes tree every `EPOCHS_PER_ETH1_VOTING_PERIOD`.
  *
  * PERF: Almost no (constant) cost
  */
-export function processEth1DataReset(state: CachedBeaconStateAllForks, cache: EpochTransitionCache): void {
+export function processEth1DataReset(state: CachedBeaconStatePreHeze, cache: EpochTransitionCache): void {
   const nextEpoch = cache.currentEpoch + 1;
 
   // reset eth1 data votes

package/src/epoch/processPendingDeposits.ts

@@ -1,4 +1,10 @@
-import {FAR_FUTURE_EPOCH, ForkSeq, GENESIS_SLOT, MAX_PENDING_DEPOSITS_PER_EPOCH} from "@lodestar/params";
+import {
+  BLS_WITHDRAWAL_PREFIX,
+  FAR_FUTURE_EPOCH,
+  ForkSeq,
+  GENESIS_SLOT,
+  MAX_PENDING_DEPOSITS_PER_EPOCH,
+} from "@lodestar/params";
 import {electra} from "@lodestar/types";
 import {addValidatorToRegistry, isValidDepositSignature} from "../block/processDeposit.js";
 import {CachedBeaconStateElectra, EpochTransitionCache} from "../types.js";
@@ -71,7 +77,7 @@ export function processPendingDeposits(state: CachedBeaconStateElectra, cache: E
 
       if (isValidatorWithdrawn) {
         // Deposited balance will never become active. Increase balance but do not consume churn
-        applyPendingDeposit(state, deposit, cache);
+        applyPendingDeposit(fork, state, deposit, cache);
       } else if (isValidatorExited) {
         // Validator is exiting, postpone the deposit until after withdrawable epoch
         depositsToPostpone.push(deposit);
@@ -83,7 +89,7 @@ export function processPendingDeposits(state: CachedBeaconStateElectra, cache: E
         }
         // Consume churn and apply deposit.
         processedAmount += deposit.amount;
-        applyPendingDeposit(state, deposit, cache);
+        applyPendingDeposit(fork, state, deposit, cache);
       }
 
       // Regardless of how the deposit was handled, we move on in the queue.
@@ -110,6 +116,7 @@ export function processPendingDeposits(state: CachedBeaconStateElectra, cache: E
 }
 
 function applyPendingDeposit(
+  fork: ForkSeq,
   state: CachedBeaconStateElectra,
   deposit: electra.PendingDeposit,
   cache: EpochTransitionCache
@@ -119,6 +126,10 @@ function applyPendingDeposit(
   const cachedBalances = cache.balances;
 
   if (!isValidatorKnown(state, validatorIndex)) {
+    // Do not create validators with BLS withdrawal credentials, the deposit is skipped without a refund
+    if (fork >= ForkSeq.heze && withdrawalCredentials[0] === BLS_WITHDRAWAL_PREFIX) {
+      return;
+    }
     // Verify the deposit signature (proof of possession) which is not checked by the deposit contract
     if (isValidDepositSignature(state.config, pubkey, withdrawalCredentials, amount, signature)) {
       addValidatorToRegistry(ForkSeq.electra, state, pubkey, withdrawalCredentials, amount);

package/src/index.ts

@@ -1,4 +1,5 @@
 export {type BlockExternalData, DataAvailabilityStatus, ExecutionPayloadStatus} from "./block/externalData.js";
+export {IndexedBuilderState} from "./block/indexedBuilderState.js";
 export {getAttestationParticipationStatus, processAttestationsAltair} from "./block/processAttestationsAltair.js";
 export {assertValidAttesterSlashing} from "./block/processAttesterSlashing.js";
 export {isValidBlsToExecutionChange} from "./block/processBlsToExecutionChange.js";
@@ -43,7 +44,7 @@ export * from "./signatureSets/index.js";
 export * from "./stateTransition.js";
 export {BeaconStateView} from "./stateView/beaconStateView.js";
 export {
-  type ComputeNewStateRootInput,
+  type BlockSTFInput,
   type ComputeNewStateRootResult,
   type IBeaconStateView,
   type IBeaconStateViewAltair,
@@ -54,6 +55,7 @@ export {
   type IBeaconStateViewFulu,
   type IBeaconStateViewGloas,
   type IBeaconStateViewHeze,
+  type IBeaconStateViewNative,
   isStatePostAltair,
   isStatePostBellatrix,
   isStatePostCapella,
@@ -63,6 +65,7 @@ export {
   isStatePostGloas,
   isStatePostHeze,
 } from "./stateView/interface.js";
+export {NativeBeaconStateView} from "./stateView/nativeBeaconStateView.js";
 export {createBeaconStateView, createBeaconStateViewForHistoricalRegen} from "./stateView/stateViewFactory.js";
 export type {
   BeaconStateAllForks,
@@ -77,6 +80,7 @@ export type {
   BeaconStateHeze,
   // Non-cached states
   BeaconStatePhase0,
+  BeaconStatePreHeze,
   CachedBeaconStateAllForks,
   CachedBeaconStateAltair,
   CachedBeaconStateBellatrix,
@@ -88,5 +92,6 @@ export type {
   CachedBeaconStateGloas,
   CachedBeaconStateHeze,
   CachedBeaconStatePhase0,
+  CachedBeaconStatePreHeze,
 } from "./types.js";
 export * from "./util/index.js";

package/src/rewards/attestationsRewards.ts

@@ -18,6 +18,8 @@ import {
 import {ValidatorIndex, rewards} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {EpochTransitionCache, beforeProcessEpoch} from "../cache/epochTransitionCache.js";
+import {processInactivityUpdates} from "../epoch/processInactivityUpdates.js";
+import {processJustificationAndFinalization} from "../epoch/processJustificationAndFinalization.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
 import {
   FLAG_ELIGIBLE_ATTESTER,
@@ -45,8 +47,13 @@ export async function computeAttestationsRewards(
     throw Error("Unsupported fork. Attestations rewards calculation is not available in phase0");
   }
 
-  const stateAltair = state as CachedBeaconStateAltair;
+  // Rewards are computed after justification and inactivity updates in epoch processing, so apply both to a clone
+  // before reading finality and inactivity scores, see
+  // https://github.com/ethereum/consensus-specs/blob/v1.7.0-beta.2/specs/altair/beacon-chain.md#epoch-processing
+  const stateAltair = state.clone() as CachedBeaconStateAltair;
   const transitionCache = beforeProcessEpoch(stateAltair);
+  processJustificationAndFinalization(stateAltair, transitionCache);
+  processInactivityUpdates(stateAltair, transitionCache);
 
   const [idealRewards, penalties] = computeIdealAttestationsRewardsAndPenaltiesAltair(
     config,

package/src/signatureSets/index.ts

@@ -12,7 +12,7 @@ import {getPayloadAttestationDataSigningRoot} from "./indexedPayloadAttestation.
 import {getBlockProposerSignatureSet} from "./proposer.js";
 import {getProposerSlashingsSignatureSets} from "./proposerSlashings.js";
 import {getRandaoRevealSignatureSet} from "./randao.js";
-import {getVoluntaryExitsSignatureSets} from "./voluntaryExits.js";
+import {getVoluntaryExitSignatureSet} from "./voluntaryExits.js";
 
 export * from "./attesterSlashings.js";
 export * from "./blsToExecutionChange.js";
@@ -49,7 +49,9 @@ export function getBlockSignatureSets(
     ...getProposerSlashingsSignatureSets(config, signedBlock),
     ...getAttesterSlashingsSignatureSets(config, signedBlock),
     ...getAttestationsSignatureSets(config, signedBlock, indexedAttestations),
-    ...getVoluntaryExitsSignatureSets(config, state, signedBlock),
+    ...signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
+      getVoluntaryExitSignatureSet(config, state, voluntaryExit)
+    ),
   ];
 
   if (!opts?.skipProposerSignature) {

package/src/signatureSets/voluntaryExits.ts

@@ -1,14 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
-import {ForkSeq} from "@lodestar/params";
-import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
-import {IBeaconStateView, IBeaconStateViewGloas, isStatePostGloas} from "../stateView/interface.js";
+import {phase0, ssz} from "@lodestar/types";
+import {IBeaconStateView} from "../stateView/interface.js";
 import {
   ISignatureSet,
   SignatureSetType,
   computeSigningRoot,
   computeStartSlotAtEpoch,
-  convertValidatorIndexToBuilderIndex,
-  isBuilderIndex,
   verifySignatureSet,
 } from "../util/index.js";
 
@@ -27,36 +24,9 @@ export function getVoluntaryExitSignatureSet(
   config: BeaconConfig,
   state: IBeaconStateView,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
-): ISignatureSet {
-  const fork = config.getForkSeq(state.slot);
-
-  if (fork >= ForkSeq.gloas && isBuilderVoluntaryExit(signedVoluntaryExit)) {
-    if (!isStatePostGloas(state)) {
-      throw new Error(`Expected gloas+ state for builder voluntary exit signature, got fork=${state.forkName}`);
-    }
-    return getBuilderVoluntaryExitSignatureSet(config, state, signedVoluntaryExit);
-  }
-
-  return getValidatorVoluntaryExitSignatureSet(config, state.slot, signedVoluntaryExit);
-}
-
-export function getVoluntaryExitsSignatureSets(
-  config: BeaconConfig,
-  state: IBeaconStateView,
-  signedBlock: SignedBeaconBlock
-): ISignatureSet[] {
-  return signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
-    getVoluntaryExitSignatureSet(config, state, voluntaryExit)
-  );
-}
-
-export function getValidatorVoluntaryExitSignatureSet(
-  config: BeaconConfig,
-  stateSlot: Slot,
-  signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
   const messageSlot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
-  const domain = config.getDomainForVoluntaryExit(stateSlot, messageSlot);
+  const domain = config.getDomainForVoluntaryExit(state.slot, messageSlot);
 
   return {
     type: SignatureSetType.indexed,
@@ -65,25 +35,3 @@ export function getValidatorVoluntaryExitSignatureSet(
     signature: signedVoluntaryExit.signature,
   };
 }
-
-export function getBuilderVoluntaryExitSignatureSet(
-  config: BeaconConfig,
-  state: IBeaconStateViewGloas,
-  signedVoluntaryExit: phase0.SignedVoluntaryExit
-): ISignatureSet {
-  const messageSlot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
-  const domain = config.getDomainForVoluntaryExit(state.slot, messageSlot);
-  const builderIndex = convertValidatorIndexToBuilderIndex(signedVoluntaryExit.message.validatorIndex);
-  const builder = state.getBuilder(builderIndex);
-
-  return {
-    type: SignatureSetType.single,
-    pubkey: builder.pubkey,
-    signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
-    signature: signedVoluntaryExit.signature,
-  };
-}
-
-export function isBuilderVoluntaryExit(signedVoluntaryExit: phase0.SignedVoluntaryExit): boolean {
-  return isBuilderIndex(signedVoluntaryExit.message.validatorIndex);
-}

package/src/slot/upgradeStateToHeze.ts

@@ -7,6 +7,12 @@ import {CachedBeaconStateGloas, CachedBeaconStateHeze} from "../types.js";
  * Spec: heze/fork.md `upgrade_to_heze`.
  */
 export function upgradeStateToHeze(stateGloas: CachedBeaconStateGloas): CachedBeaconStateHeze {
+  // In Heze, the old deposit mechanism must be fully drained before the fork
+  if (BigInt(stateGloas.eth1DepositIndex) !== stateGloas.depositRequestsStartIndex) {
+    throw new Error(
+      `Cannot upgrade to Heze: legacy deposit mechanism still active eth1DepositIndex=${stateGloas.eth1DepositIndex} depositRequestsStartIndex=${stateGloas.depositRequestsStartIndex}`
+    );
+  }
   const {config} = stateGloas;
 
   ssz.gloas.BeaconState.commitViewDU(stateGloas);
@@ -26,9 +32,6 @@ export function upgradeStateToHeze(stateGloas: CachedBeaconStateGloas): CachedBe
   stateHezeView.blockRoots = stateHezeCloned.blockRoots;
   stateHezeView.stateRoots = stateHezeCloned.stateRoots;
   stateHezeView.historicalRoots = stateHezeCloned.historicalRoots;
-  stateHezeView.eth1Data = stateHezeCloned.eth1Data;
-  stateHezeView.eth1DataVotes = stateHezeCloned.eth1DataVotes;
-  stateHezeView.eth1DepositIndex = stateHezeCloned.eth1DepositIndex;
   stateHezeView.validators = stateHezeCloned.validators;
   stateHezeView.balances = stateHezeCloned.balances;
   stateHezeView.randaoMixes = stateHezeCloned.randaoMixes;
@@ -46,7 +49,6 @@ export function upgradeStateToHeze(stateGloas: CachedBeaconStateGloas): CachedBe
   stateHezeView.nextWithdrawalIndex = stateHezeCloned.nextWithdrawalIndex;
   stateHezeView.nextWithdrawalValidatorIndex = stateHezeCloned.nextWithdrawalValidatorIndex;
   stateHezeView.historicalSummaries = stateHezeCloned.historicalSummaries;
-  stateHezeView.depositRequestsStartIndex = stateHezeCloned.depositRequestsStartIndex;
   stateHezeView.depositBalanceToConsume = stateHezeCloned.depositBalanceToConsume;
   stateHezeView.exitBalanceToConsume = stateHezeCloned.exitBalanceToConsume;
   stateHezeView.earliestExitEpoch = stateHezeCloned.earliestExitEpoch;