@lodestar/state-transition 1.35.0-dev.955e9f89ed → 1.35.0-dev.98d359db41

package/src/slot/upgradeStateToAltair.ts

@@ -0,0 +1,149 @@
+import {CompositeViewDU} from "@chainsafe/ssz";
+import {ForkSeq} from "@lodestar/params";
+import {ssz} from "@lodestar/types";
+import {getAttestationParticipationStatus} from "../block/processAttestationsAltair.js";
+import {getCachedBeaconState} from "../cache/stateCache.js";
+import {CachedBeaconStateAltair, CachedBeaconStatePhase0} from "../types.js";
+import {RootCache, newZeroedArray} from "../util/index.js";
+import {getNextSyncCommittee} from "../util/syncCommittee.js";
+import {sumTargetUnslashedBalanceIncrements} from "../util/targetUnslashedBalance.js";
+
+/**
+ * Upgrade a state from phase0 to altair.
+ */
+export function upgradeStateToAltair(statePhase0: CachedBeaconStatePhase0): CachedBeaconStateAltair {
+  const {config} = statePhase0;
+
+  // Get underlying node and cast phase0 tree to altair tree
+  //
+  // A phase0 BeaconState tree can be safely casted to an altair BeaconState tree because:
+  // - Deprecated fields are replaced by new fields at the exact same indexes
+  // - All new fields are appended at the end
+  //
+  // So by just setting all new fields to some value, all the old nodes are dropped
+  //
+  // phase0                        | op   | altair
+  // ----------------------------- | ---- | ------------
+  // genesis_time                  | -    | genesis_time
+  // genesis_validators_root       | -    | genesis_validators_root
+  // slot                          | -    | slot
+  // fork                          | -    | fork
+  // latest_block_header           | -    | latest_block_header
+  // block_roots                   | -    | block_roots
+  // state_roots                   | -    | state_roots
+  // historical_roots              | -    | historical_roots
+  // eth1_data                     | -    | eth1_data
+  // eth1_data_votes               | -    | eth1_data_votes
+  // eth1_deposit_index            | -    | eth1_deposit_index
+  // validators                    | -    | validators
+  // balances                      | -    | balances
+  // randao_mixes                  | -    | randao_mixes
+  // slashings                     | -    | slashings
+  // previous_epoch_attestations   | diff | previous_epoch_participation
+  // current_epoch_attestations    | diff | current_epoch_participation
+  // justification_bits            | -    | justification_bits
+  // previous_justified_checkpoint | -    | previous_justified_checkpoint
+  // current_justified_checkpoint  | -    | current_justified_checkpoint
+  // finalized_checkpoint          | -    | finalized_checkpoint
+  // -                             | new  | inactivity_scores
+  // -                             | new  | current_sync_committee
+  // -                             | new  | next_sync_committee
+
+  const statePhase0Node = ssz.phase0.BeaconState.commitViewDU(statePhase0);
+  const stateAltairView = ssz.altair.BeaconState.getViewDU(statePhase0Node);
+  // Attach existing BeaconStateCache from statePhase0 to new stateAltairView object
+  const stateAltair = getCachedBeaconState(stateAltairView, statePhase0);
+
+  stateAltair.fork = ssz.phase0.Fork.toViewDU({
+    previousVersion: statePhase0.fork.currentVersion,
+    currentVersion: config.ALTAIR_FORK_VERSION,
+    epoch: statePhase0.epochCtx.epoch,
+  });
+
+  const validatorCount = statePhase0.validators.length;
+  const emptyEpochParticipationView = ssz.altair.EpochParticipation.toViewDU(newZeroedArray(validatorCount));
+  const emptyEpochParticipationNode = ssz.altair.EpochParticipation.commitViewDU(emptyEpochParticipationView);
+  stateAltair.previousEpochParticipation = emptyEpochParticipationView;
+  // Cloned instance with same immutable Node
+  stateAltair.currentEpochParticipation = ssz.altair.EpochParticipation.getViewDU(emptyEpochParticipationNode);
+
+  stateAltair.inactivityScores = ssz.altair.InactivityScores.toViewDU(newZeroedArray(validatorCount));
+
+  const {syncCommittee, indices} = getNextSyncCommittee(
+    ForkSeq.altair,
+    stateAltair,
+    stateAltair.epochCtx.nextActiveIndices,
+    stateAltair.epochCtx.effectiveBalanceIncrements
+  );
+  const syncCommitteeView = ssz.altair.SyncCommittee.toViewDU(syncCommittee);
+
+  stateAltair.currentSyncCommittee = syncCommitteeView;
+  stateAltair.nextSyncCommittee = syncCommitteeView;
+  stateAltair.epochCtx.setSyncCommitteesIndexed(indices);
+
+  const pendingAttesations = statePhase0.previousEpochAttestations;
+  translateParticipation(stateAltair, pendingAttesations);
+
+  // Commit new added fields ViewDU to the root node
+  stateAltair.commit();
+  // Clear cache to ensure the cache of phase0 fields is not used by new altair fields
+  // [15] previous_epoch_attestations -> previous_epoch_participation
+  // [16] current_epoch_attestations -> current_epoch_participation
+  //
+  // TODO: This could only drop the caches of index 15,16. However this would couple this code tightly with SSZ ViewDU
+  //       internals. If the cache is not cleared, consuming the ViewDU instance could break in strange ways.
+  // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
+  stateAltair["clearCache"]();
+
+  // TODO: describe issue. Compute progressive target balances
+  //
+  // Note: in EpochCache.afterProcessEpoch previousTargetUnslashedBalanceIncrements is overwritten,
+  //       currentTargetUnslashedBalanceIncrements is rotated to previousTargetUnslashedBalanceIncrements
+  //
+  // Here target balance is computed in full, which is slightly less performant than doing so in the loop
+  // above but gurantees consistency with EpochCache.createFromState(). Note execution order below:
+  // ```
+  // processEpoch()
+  // epochCtx.afterProcessEpoch()
+  // if (...) upgradeStateToAltair()
+  // ```
+  const previousEpoch = stateAltair.epochCtx.epoch - 1;
+  stateAltair.epochCtx.previousTargetUnslashedBalanceIncrements = sumTargetUnslashedBalanceIncrements(
+    stateAltair.previousEpochParticipation.getAll(),
+    previousEpoch,
+    stateAltair.validators.getAllReadonlyValues()
+  );
+
+  return stateAltair;
+}
+
+/**
+ * Translate_participation in https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/altair/fork.md
+ */
+function translateParticipation(
+  state: CachedBeaconStateAltair,
+  pendingAttesations: CompositeViewDU<typeof ssz.phase0.EpochAttestations>
+): void {
+  const {epochCtx} = state;
+  const rootCache = new RootCache(state);
+  const epochParticipation = state.previousEpochParticipation;
+
+  for (const attestation of pendingAttesations.getAllReadonly()) {
+    const data = attestation.data;
+    const attestationFlags = getAttestationParticipationStatus(
+      ForkSeq.altair,
+      data,
+      attestation.inclusionDelay,
+      epochCtx.epoch,
+      rootCache
+    );
+
+    const committeeIndices = epochCtx.getBeaconCommittee(data.slot, data.index);
+    const attestingIndices = attestation.aggregationBits.intersectValues(committeeIndices);
+
+    for (const index of attestingIndices) {
+      // ParticipationFlags type uses option {setBitwiseOR: true}, .set() does a |= operation
+      epochParticipation.set(index, attestationFlags);
+    }
+  }
+}

package/src/slot/upgradeStateToBellatrix.ts

@@ -0,0 +1,63 @@
+import {ssz} from "@lodestar/types";
+import {getCachedBeaconState} from "../cache/stateCache.js";
+import {CachedBeaconStateAltair, CachedBeaconStateBellatrix} from "../types.js";
+
+/**
+ * Upgrade a state from altair to bellatrix.
+ */
+export function upgradeStateToBellatrix(stateAltair: CachedBeaconStateAltair): CachedBeaconStateBellatrix {
+  const {config} = stateAltair;
+
+  // Get underlying node and cast altair tree to bellatrix tree
+  //
+  // An altair BeaconState tree can be safely casted to a bellatrix BeaconState tree because:
+  // - All new fields are appended at the end
+  //
+  // altair                        | op  | bellatrix
+  // ----------------------------- | --- | ------------
+  // genesis_time                  | -   | genesis_time
+  // genesis_validators_root       | -   | genesis_validators_root
+  // slot                          | -   | slot
+  // fork                          | -   | fork
+  // latest_block_header           | -   | latest_block_header
+  // block_roots                   | -   | block_roots
+  // state_roots                   | -   | state_roots
+  // historical_roots              | -   | historical_roots
+  // eth1_data                     | -   | eth1_data
+  // eth1_data_votes               | -   | eth1_data_votes
+  // eth1_deposit_index            | -   | eth1_deposit_index
+  // validators                    | -   | validators
+  // balances                      | -   | balances
+  // randao_mixes                  | -   | randao_mixes
+  // slashings                     | -   | slashings
+  // previous_epoch_participation  | -   | previous_epoch_participation
+  // current_epoch_participation   | -   | current_epoch_participation
+  // justification_bits            | -   | justification_bits
+  // previous_justified_checkpoint | -   | previous_justified_checkpoint
+  // current_justified_checkpoint  | -   | current_justified_checkpoint
+  // finalized_checkpoint          | -   | finalized_checkpoint
+  // inactivity_scores             | -   | inactivity_scores
+  // current_sync_committee        | -   | current_sync_committee
+  // next_sync_committee           | -   | next_sync_committee
+  // -                             | new | latest_execution_payload_header
+
+  const stateAltairNode = ssz.altair.BeaconState.commitViewDU(stateAltair);
+  const stateBellatrixView = ssz.bellatrix.BeaconState.getViewDU(stateAltairNode);
+  // Attach existing BeaconStateCache from stateAltair to new stateBellatrixView object
+  const stateBellatrix = getCachedBeaconState(stateBellatrixView, stateAltair);
+
+  stateBellatrix.fork = ssz.phase0.Fork.toViewDU({
+    previousVersion: stateAltair.fork.currentVersion,
+    currentVersion: config.BELLATRIX_FORK_VERSION,
+    epoch: stateAltair.epochCtx.epoch,
+  });
+
+  // Execution-layer
+  stateBellatrix.latestExecutionPayloadHeader = ssz.bellatrix.ExecutionPayloadHeader.defaultViewDU();
+
+  // Commit new added fields ViewDU to the root node
+  stateBellatrix.commit();
+  // No need to clear cache since no index is replaced, only appended at the end
+
+  return stateBellatrix;
+}

package/src/slot/upgradeStateToCapella.ts

@@ -0,0 +1,71 @@
+import {ssz} from "@lodestar/types";
+import {getCachedBeaconState} from "../cache/stateCache.js";
+import {CachedBeaconStateBellatrix, CachedBeaconStateCapella} from "../types.js";
+
+/**
+ * Upgrade a state from bellatrix to capella.
+ */
+export function upgradeStateToCapella(stateBellatrix: CachedBeaconStateBellatrix): CachedBeaconStateCapella {
+  const {config} = stateBellatrix;
+
+  // Get underlying node and cast bellatrix tree to capella tree
+  //
+  // An bellatrix BeaconState tree can be safely casted to a capella BeaconState tree because:
+  // - Deprecated fields are replaced by new fields at the exact same indexes
+  // - All new fields are appended at the end
+  //
+  // bellatrix                        | op    | capella
+  // -------------------------------- | ----  | ------------
+  // genesis_time                     | -     | genesis_time
+  // genesis_validators_root          | -     | genesis_validators_root
+  // slot                             | -     | slot
+  // fork                             | -     | fork
+  // latest_block_header              | -     | latest_block_header
+  // block_roots                      | -     | block_roots
+  // state_roots                      | -     | state_roots
+  // historical_roots                 | frozen| historical_roots
+  // eth1_data                        | -     | eth1_data
+  // eth1_data_votes                  | -     | eth1_data_votes
+  // eth1_deposit_index               | -     | eth1_deposit_index
+  // validators                       | -     | validators
+  // balances                         | -     | balances
+  // randao_mixes                     | -     | randao_mixes
+  // slashings                        | -     | slashings
+  // previous_epoch_participation     | -     | previous_epoch_participation
+  // current_epoch_participation      | -     | current_epoch_participation
+  // justification_bits               | -     | justification_bits
+  // previous_justified_checkpoint    | -     | previous_justified_checkpoint
+  // current_justified_checkpoint     | -     | current_justified_checkpoint
+  // finalized_checkpoint             | -     | finalized_checkpoint
+  // inactivity_scores                | -     | inactivity_scores
+  // current_sync_committee           | -     | current_sync_committee
+  // next_sync_committee              | -     | next_sync_committee
+  // latest_execution_payload_header  | diff  | latest_execution_payload_header
+  // -                                | new   | next_withdrawal_index
+  // -                                | new   | next_withdrawal_validator_index
+  // -                                | new   | historical_summaries
+
+  const stateBellatrixNode = ssz.bellatrix.BeaconState.commitViewDU(stateBellatrix);
+  const stateCapellaView = ssz.capella.BeaconState.getViewDU(stateBellatrixNode);
+  // Attach existing BeaconStateCache from stateBellatrix to new stateCapellaView object
+  const stateCapella = getCachedBeaconState(stateCapellaView, stateBellatrix);
+
+  stateCapella.fork = ssz.phase0.Fork.toViewDU({
+    previousVersion: stateBellatrix.fork.currentVersion,
+    currentVersion: config.CAPELLA_FORK_VERSION,
+    epoch: stateBellatrix.epochCtx.epoch,
+  });
+
+  // nextWithdrawalIndex and nextWithdrawalValidatorIndex are already set to 0 by default
+  // latestExecutionPayloadHeader's withdrawalRoot set to zeros by default
+  // historicalRoots should be cloned over already and historicalSummaries need to be default []
+  stateCapella.historicalSummaries = ssz.capella.BeaconState.fields.historicalSummaries.defaultViewDU();
+
+  // Commit new added fields ViewDU to the root node
+  stateCapella.commit();
+  // Clear cache to ensure the cache of bellatrix fields is not used by new capella fields
+  // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
+  stateCapella["clearCache"]();
+
+  return stateCapella;
+}

package/src/slot/upgradeStateToDeneb.ts

@@ -0,0 +1,40 @@
+import {ssz} from "@lodestar/types";
+import {getCachedBeaconState} from "../cache/stateCache.js";
+import {CachedBeaconStateCapella, CachedBeaconStateDeneb} from "../types.js";
+
+/**
+ * Upgrade a state from Capella to Deneb.
+ */
+export function upgradeStateToDeneb(stateCapella: CachedBeaconStateCapella): CachedBeaconStateDeneb {
+  const {config} = stateCapella;
+
+  const stateCapellaNode = ssz.capella.BeaconState.commitViewDU(stateCapella);
+  const stateDenebView = ssz.deneb.BeaconState.getViewDU(stateCapellaNode);
+
+  const stateDeneb = getCachedBeaconState(stateDenebView, stateCapella);
+
+  stateDeneb.fork = ssz.phase0.Fork.toViewDU({
+    previousVersion: stateCapella.fork.currentVersion,
+    currentVersion: config.DENEB_FORK_VERSION,
+    epoch: stateCapella.epochCtx.epoch,
+  });
+
+  // Since excessBlobGas and blobGasUsed are appened in the end to latestExecutionPayloadHeader so they should
+  // be set to defaults and need no assigning, but right now any access to latestExecutionPayloadHeader fails
+  // with LeafNode has no left node. Weirdly its beacuse of addition of the second field as with one field
+  // it seems to work.
+  //
+  // TODO DENEB: Debug and remove the following cloning
+  stateDeneb.latestExecutionPayloadHeader = ssz.deneb.BeaconState.fields.latestExecutionPayloadHeader.toViewDU({
+    ...stateCapella.latestExecutionPayloadHeader.toValue(),
+    excessBlobGas: BigInt(0),
+    blobGasUsed: BigInt(0),
+  });
+
+  stateDeneb.commit();
+  // Clear cache to ensure the cache of capella fields is not used by new deneb fields
+  // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
+  stateDeneb["clearCache"]();
+
+  return stateDeneb;
+}

package/src/slot/upgradeStateToElectra.ts

@@ -0,0 +1,126 @@
+import {FAR_FUTURE_EPOCH, GENESIS_SLOT, UNSET_DEPOSIT_REQUESTS_START_INDEX} from "@lodestar/params";
+import {ValidatorIndex, ssz} from "@lodestar/types";
+import {CachedBeaconStateElectra, getCachedBeaconState} from "../cache/stateCache.js";
+import {G2_POINT_AT_INFINITY} from "../constants/constants.js";
+import {CachedBeaconStateDeneb} from "../types.js";
+import {hasCompoundingWithdrawalCredential, queueExcessActiveBalance} from "../util/electra.js";
+import {computeActivationExitEpoch} from "../util/epoch.js";
+import {getActivationExitChurnLimit, getConsolidationChurnLimit} from "../util/validator.js";
+
+/**
+ * Upgrade a state from Deneb to Electra.
+ */
+export function upgradeStateToElectra(stateDeneb: CachedBeaconStateDeneb): CachedBeaconStateElectra {
+  const {config} = stateDeneb;
+
+  ssz.deneb.BeaconState.commitViewDU(stateDeneb);
+  const stateElectraCloned = stateDeneb;
+
+  const stateElectraView = ssz.electra.BeaconState.defaultViewDU();
+  stateElectraView.genesisTime = stateElectraCloned.genesisTime;
+  stateElectraView.genesisValidatorsRoot = stateElectraCloned.genesisValidatorsRoot;
+  stateElectraView.slot = stateElectraCloned.slot;
+  stateElectraView.fork = ssz.phase0.Fork.toViewDU({
+    previousVersion: stateDeneb.fork.currentVersion,
+    currentVersion: config.ELECTRA_FORK_VERSION,
+    epoch: stateDeneb.epochCtx.epoch,
+  });
+  stateElectraView.latestBlockHeader = stateElectraCloned.latestBlockHeader;
+  stateElectraView.blockRoots = stateElectraCloned.blockRoots;
+  stateElectraView.stateRoots = stateElectraCloned.stateRoots;
+  stateElectraView.historicalRoots = stateElectraCloned.historicalRoots;
+  stateElectraView.eth1Data = stateElectraCloned.eth1Data;
+  stateElectraView.eth1DataVotes = stateElectraCloned.eth1DataVotes;
+  stateElectraView.eth1DepositIndex = stateElectraCloned.eth1DepositIndex;
+  stateElectraView.validators = stateElectraCloned.validators;
+  stateElectraView.balances = stateElectraCloned.balances;
+  stateElectraView.randaoMixes = stateElectraCloned.randaoMixes;
+  stateElectraView.slashings = stateElectraCloned.slashings;
+  stateElectraView.previousEpochParticipation = stateElectraCloned.previousEpochParticipation;
+  stateElectraView.currentEpochParticipation = stateElectraCloned.currentEpochParticipation;
+  stateElectraView.justificationBits = stateElectraCloned.justificationBits;
+  stateElectraView.previousJustifiedCheckpoint = stateElectraCloned.previousJustifiedCheckpoint;
+  stateElectraView.currentJustifiedCheckpoint = stateElectraCloned.currentJustifiedCheckpoint;
+  stateElectraView.finalizedCheckpoint = stateElectraCloned.finalizedCheckpoint;
+  stateElectraView.inactivityScores = stateElectraCloned.inactivityScores;
+  stateElectraView.currentSyncCommittee = stateElectraCloned.currentSyncCommittee;
+  stateElectraView.nextSyncCommittee = stateElectraCloned.nextSyncCommittee;
+  stateElectraView.latestExecutionPayloadHeader = stateElectraCloned.latestExecutionPayloadHeader;
+  stateElectraView.nextWithdrawalIndex = stateDeneb.nextWithdrawalIndex;
+  stateElectraView.nextWithdrawalValidatorIndex = stateDeneb.nextWithdrawalValidatorIndex;
+  stateElectraView.historicalSummaries = stateElectraCloned.historicalSummaries;
+
+  // default value of depositRequestsStartIndex is UNSET_DEPOSIT_REQUESTS_START_INDEX
+  stateElectraView.depositRequestsStartIndex = UNSET_DEPOSIT_REQUESTS_START_INDEX;
+  stateElectraView.depositBalanceToConsume = BigInt(0);
+  stateElectraView.exitBalanceToConsume = BigInt(0);
+
+  const validatorsArr = stateElectraView.validators.getAllReadonly();
+  const currentEpochPre = stateDeneb.epochCtx.epoch;
+  let earliestExitEpoch = computeActivationExitEpoch(currentEpochPre);
+
+  // [EIP-7251]: add validators that are not yet active to pending balance deposits
+  const preActivation: ValidatorIndex[] = [];
+  for (let validatorIndex = 0; validatorIndex < validatorsArr.length; validatorIndex++) {
+    const {activationEpoch, exitEpoch} = validatorsArr[validatorIndex];
+    if (activationEpoch === FAR_FUTURE_EPOCH) {
+      preActivation.push(validatorIndex);
+    }
+    if (exitEpoch !== FAR_FUTURE_EPOCH && exitEpoch > earliestExitEpoch) {
+      earliestExitEpoch = exitEpoch;
+    }
+  }
+
+  stateElectraView.earliestExitEpoch = earliestExitEpoch + 1;
+  stateElectraView.consolidationBalanceToConsume = BigInt(0);
+  stateElectraView.earliestConsolidationEpoch = computeActivationExitEpoch(currentEpochPre);
+  // TODO-electra: can we improve this?
+  stateElectraView.commit();
+  const tmpElectraState = getCachedBeaconState(stateElectraView, stateDeneb);
+  stateElectraView.exitBalanceToConsume = BigInt(getActivationExitChurnLimit(tmpElectraState.epochCtx));
+  stateElectraView.consolidationBalanceToConsume = BigInt(getConsolidationChurnLimit(tmpElectraState.epochCtx));
+
+  preActivation.sort((i0, i1) => {
+    const res = validatorsArr[i0].activationEligibilityEpoch - validatorsArr[i1].activationEligibilityEpoch;
+    return res !== 0 ? res : i0 - i1;
+  });
+
+  for (const validatorIndex of preActivation) {
+    const stateElectra = stateElectraView as CachedBeaconStateElectra;
+    const balance = stateElectra.balances.get(validatorIndex);
+    stateElectra.balances.set(validatorIndex, 0);
+
+    const validator = stateElectra.validators.get(validatorIndex);
+    validator.effectiveBalance = 0;
+    stateElectra.epochCtx.effectiveBalanceIncrementsSet(validatorIndex, 0);
+    validator.activationEligibilityEpoch = FAR_FUTURE_EPOCH;
+
+    const pendingDeposit = ssz.electra.PendingDeposit.toViewDU({
+      pubkey: validator.pubkey,
+      withdrawalCredentials: validator.withdrawalCredentials,
+      amount: balance,
+      signature: G2_POINT_AT_INFINITY,
+      slot: GENESIS_SLOT,
+    });
+    stateElectra.pendingDeposits.push(pendingDeposit);
+  }
+
+  for (let i = 0; i < validatorsArr.length; i++) {
+    const validator = validatorsArr[i];
+
+    // [EIP-7251]: Ensure early adopters of compounding credentials go through the activation churn
+    const withdrawalCredential = validator.withdrawalCredentials;
+    if (hasCompoundingWithdrawalCredential(withdrawalCredential)) {
+      queueExcessActiveBalance(stateElectraView as CachedBeaconStateElectra, i);
+    }
+  }
+
+  const stateElectra = getCachedBeaconState(stateElectraView, stateDeneb);
+  // Commit new added fields ViewDU to the root node
+  stateElectra.commit();
+  // Clear cache to ensure the cache of deneb fields is not used by new ELECTRA fields
+  // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
+  stateElectra["clearCache"]();
+
+  return stateElectra;
+}

package/src/slot/upgradeStateToFulu.ts

@@ -0,0 +1,31 @@
+import {ssz} from "@lodestar/types";
+import {getCachedBeaconState} from "../cache/stateCache.js";
+import {CachedBeaconStateElectra, CachedBeaconStateFulu} from "../types.js";
+import {initializeProposerLookahead} from "../util/fulu.js";
+
+/**
+ * Upgrade a state from Electra to Fulu.
+ */
+export function upgradeStateToFulu(stateElectra: CachedBeaconStateElectra): CachedBeaconStateFulu {
+  const {config} = stateElectra;
+
+  const stateElectraNode = ssz.electra.BeaconState.commitViewDU(stateElectra);
+  const stateFuluView = ssz.fulu.BeaconState.getViewDU(stateElectraNode);
+
+  const stateFulu = getCachedBeaconState(stateFuluView, stateElectra);
+
+  stateFulu.fork = ssz.phase0.Fork.toViewDU({
+    previousVersion: stateElectra.fork.currentVersion,
+    currentVersion: config.FULU_FORK_VERSION,
+    epoch: stateElectra.epochCtx.epoch,
+  });
+
+  stateFulu.proposerLookahead = ssz.fulu.ProposerLookahead.toViewDU(initializeProposerLookahead(stateElectra));
+
+  stateFulu.commit();
+  // Clear cache to ensure the cache of electra fields is not used by new fulu fields
+  // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
+  stateFulu["clearCache"]();
+
+  return stateFulu;
+}

package/src/slot/upgradeStateToGloas.ts

@@ -0,0 +1,29 @@
+import {ssz} from "@lodestar/types";
+import {getCachedBeaconState} from "../cache/stateCache.js";
+import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
+
+/**
+ * Upgrade a state from Fulu to Gloas.
+ * TODO GLOAS: Implement this
+ */
+export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBeaconStateGloas {
+  const {config} = stateFulu;
+
+  const stateFuluNode = ssz.fulu.BeaconState.commitViewDU(stateFulu);
+  const stateGloasView = ssz.gloas.BeaconState.getViewDU(stateFuluNode);
+
+  const stateGloas = getCachedBeaconState(stateGloasView, stateFulu);
+
+  stateGloas.fork = ssz.phase0.Fork.toViewDU({
+    previousVersion: stateFulu.fork.currentVersion,
+    currentVersion: config.GLOAS_FORK_VERSION,
+    epoch: stateFulu.epochCtx.epoch,
+  });
+
+  stateGloas.commit();
+  // Clear cache to ensure the cache of fulu fields is not used by new gloas fields
+  // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
+  stateGloas["clearCache"]();
+
+  return stateGloas;
+}