Electra: upgrade (#13933)

* wip fork logic upgrade * fixing replay and fork.go * improving process function and adding tests for transition * updating unit tests and temporarily removing some fields on state_trie.go * updating state * wip adding upgrade to electra code * adding some comments * adding spec tests * fixing values used in state transition logic * updating upgrade test * gofmt * avoid dup word linting * fixing spec tests for fork * gaz * fixing tests * improving unit test with new getters * fixing bazel for minimal fork test * adding bazel file * Update beacon-chain/core/electra/upgrade.go Co-authored-by: Preston Van Loon <pvanloon@offchainlabs.com> * addressing some comments and adding more tests * addressing more feedback * one more feedback * changing value to interface after talking to preston * adding missed review feedback * fixing linting * noticed I was using the wrong function in the state upgrade * fixing and ignoring some deepsource issues * moving core electra validator functions to helper to remove circular dependencies in other PRs * missed deepsource complaint * Update upgrade.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * Update testing/util/electra_state.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * Update testing/util/electra_state.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * addressing feedback * removing deepsoure ignore comments --------- Co-authored-by: Preston Van Loon <pvanloon@offchainlabs.com> Co-authored-by: Radosław Kapka <rkapka@wp.pl>
2026-01-10 07:58:22 -05:00 · 2024-05-08 10:16:31 -05:00
parent e9606b3635
commit 2fa3694746
36 changed files with 1261 additions and 15 deletions
--- a/beacon-chain/core/electra/BUILD.bazel
+++ b/beacon-chain/core/electra/BUILD.bazel
@@ -0,0 +1,41 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["upgrade.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/time:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//time/slots:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["upgrade_test.go"],
+    deps = [
+        ":go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/time:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+        "//time/slots:go_default_library",
+    ],
+)
--- a/beacon-chain/core/electra/upgrade.go
+++ b/beacon-chain/core/electra/upgrade.go
@@ -0,0 +1,312 @@
+package electra
+
+import (
+	"sort"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+// UpgradeToElectra updates inputs a generic state to return the version Electra state.
+// def upgrade_to_electra(pre: deneb.BeaconState) -> BeaconState:
+//
+//	epoch = deneb.get_current_epoch(pre)
+//	latest_execution_payload_header = ExecutionPayloadHeader(
+//	    parent_hash=pre.latest_execution_payload_header.parent_hash,
+//	    fee_recipient=pre.latest_execution_payload_header.fee_recipient,
+//	    state_root=pre.latest_execution_payload_header.state_root,
+//	    receipts_root=pre.latest_execution_payload_header.receipts_root,
+//	    logs_bloom=pre.latest_execution_payload_header.logs_bloom,
+//	    prev_randao=pre.latest_execution_payload_header.prev_randao,
+//	    block_number=pre.latest_execution_payload_header.block_number,
+//	    gas_limit=pre.latest_execution_payload_header.gas_limit,
+//	    gas_used=pre.latest_execution_payload_header.gas_used,
+//	    timestamp=pre.latest_execution_payload_header.timestamp,
+//	    extra_data=pre.latest_execution_payload_header.extra_data,
+//	    base_fee_per_gas=pre.latest_execution_payload_header.base_fee_per_gas,
+//	    block_hash=pre.latest_execution_payload_header.block_hash,
+//	    transactions_root=pre.latest_execution_payload_header.transactions_root,
+//	    withdrawals_root=pre.latest_execution_payload_header.withdrawals_root,
+//	    blob_gas_used=pre.latest_execution_payload_header.blob_gas_used,
+//	    excess_blob_gas=pre.latest_execution_payload_header.excess_blob_gas,
+//	    deposit_receipts_root=Root(),  # [New in Electra:EIP6110]
+//	    withdrawal_requests_root=Root(),  # [New in Electra:EIP7002],
+//	)
+//
+//	exit_epochs = [v.exit_epoch for v in pre.validators if v.exit_epoch != FAR_FUTURE_EPOCH]
+//	if not exit_epochs:
+//	    exit_epochs = [get_current_epoch(pre)]
+//	earliest_exit_epoch = max(exit_epochs) + 1
+//
+//	post = BeaconState(
+//	    # Versioning
+//	    genesis_time=pre.genesis_time,
+//	    genesis_validators_root=pre.genesis_validators_root,
+//	    slot=pre.slot,
+//	    fork=Fork(
+//	        previous_version=pre.fork.current_version,
+//	        current_version=ELECTRA_FORK_VERSION,  # [Modified in Electra:EIP6110]
+//	        epoch=epoch,
+//	    ),
+//	    # History
+//	    latest_block_header=pre.latest_block_header,
+//	    block_roots=pre.block_roots,
+//	    state_roots=pre.state_roots,
+//	    historical_roots=pre.historical_roots,
+//	    # Eth1
+//	    eth1_data=pre.eth1_data,
+//	    eth1_data_votes=pre.eth1_data_votes,
+//	    eth1_deposit_index=pre.eth1_deposit_index,
+//	    # Registry
+//	    validators=pre.validators,
+//	    balances=pre.balances,
+//	    # Randomness
+//	    randao_mixes=pre.randao_mixes,
+//	    # Slashings
+//	    slashings=pre.slashings,
+//	    # Participation
+//	    previous_epoch_participation=pre.previous_epoch_participation,
+//	    current_epoch_participation=pre.current_epoch_participation,
+//	    # Finality
+//	    justification_bits=pre.justification_bits,
+//	    previous_justified_checkpoint=pre.previous_justified_checkpoint,
+//	    current_justified_checkpoint=pre.current_justified_checkpoint,
+//	    finalized_checkpoint=pre.finalized_checkpoint,
+//	    # Inactivity
+//	    inactivity_scores=pre.inactivity_scores,
+//	    # Sync
+//	    current_sync_committee=pre.current_sync_committee,
+//	    next_sync_committee=pre.next_sync_committee,
+//	    # Execution-layer
+//	    latest_execution_payload_header=latest_execution_payload_header,  # [Modified in Electra:EIP6110:EIP7002]
+//	    # Withdrawals
+//	    next_withdrawal_index=pre.next_withdrawal_index,
+//	    next_withdrawal_validator_index=pre.next_withdrawal_validator_index,
+//	    # Deep history valid from Capella onwards
+//	    historical_summaries=pre.historical_summaries,
+//	    # [New in Electra:EIP6110]
+//	    deposit_receipts_start_index=UNSET_DEPOSIT_RECEIPTS_START_INDEX,
+//	    # [New in Electra:EIP7251]
+//	    deposit_balance_to_consume=0,
+//	    exit_balance_to_consume=0,
+//	    earliest_exit_epoch=earliest_exit_epoch,
+//	    consolidation_balance_to_consume=0,
+//	    earliest_consolidation_epoch=compute_activation_exit_epoch(get_current_epoch(pre)),
+//	    pending_balance_deposits=[],
+//	    pending_partial_withdrawals=[],
+//	    pending_consolidations=[],
+//	)
+//
+//	post.exit_balance_to_consume = get_activation_exit_churn_limit(post)
+//	post.consolidation_balance_to_consume = get_consolidation_churn_limit(post)
+//
+//	# [New in Electra:EIP7251]
+//	# add validators that are not yet active to pending balance deposits
+//	pre_activation = sorted([
+//	    index for index, validator in enumerate(post.validators)
+//	    if validator.activation_epoch == FAR_FUTURE_EPOCH
+//	], key=lambda index: (
+//	    post.validators[index].activation_eligibility_epoch,
+//	    index
+//	))
+//
+//	for index in pre_activation:
+//	    queue_entire_balance_and_reset_validator(post, ValidatorIndex(index))
+//
+//	# Ensure early adopters of compounding credentials go through the activation churn
+//	for index, validator in enumerate(post.validators):
+//	    if has_compounding_withdrawal_credential(validator):
+//	        queue_excess_active_balance(post, ValidatorIndex(index))
+//
+//	return post
+func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error) {
+	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSyncCommittee, err := beaconState.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	inactivityScores, err := beaconState.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	payloadHeader, err := beaconState.LatestExecutionPayloadHeader()
+	if err != nil {
+		return nil, err
+	}
+	txRoot, err := payloadHeader.TransactionsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wdRoot, err := payloadHeader.WithdrawalsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wi, err := beaconState.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	vi, err := beaconState.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	summaries, err := beaconState.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+	historicalRoots, err := beaconState.HistoricalRoots()
+	if err != nil {
+		return nil, err
+	}
+	excessBlobGas, err := payloadHeader.ExcessBlobGas()
+	if err != nil {
+		return nil, err
+	}
+	blobGasUsed, err := payloadHeader.BlobGasUsed()
+	if err != nil {
+		return nil, err
+	}
+
+	// [New in Electra:EIP7251]
+	earliestExitEpoch := time.CurrentEpoch(beaconState)
+	preActivationIndices := make([]primitives.ValidatorIndex, 0)
+	compoundWithdrawalIndices := make([]primitives.ValidatorIndex, 0)
+	if err = beaconState.ReadFromEveryValidator(func(index int, val state.ReadOnlyValidator) error {
+		if val.ExitEpoch() != params.BeaconConfig().FarFutureEpoch && val.ExitEpoch() > earliestExitEpoch {
+			earliestExitEpoch = val.ExitEpoch()
+		}
+		if val.ActivationEpoch() == params.BeaconConfig().FarFutureEpoch {
+			preActivationIndices = append(preActivationIndices, primitives.ValidatorIndex(index))
+		}
+		if helpers.HasCompoundingWithdrawalCredential(val) {
+			compoundWithdrawalIndices = append(compoundWithdrawalIndices, primitives.ValidatorIndex(index))
+		}
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+
+	earliestExitEpoch++ // Increment to find the earliest possible exit epoch
+
+	// note: should be the same in prestate and post beaconState.
+	// we are deviating from the specs a bit as it calls for using the post beaconState
+	tab, err := helpers.TotalActiveBalance(beaconState)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get total active balance")
+	}
+
+	s := &ethpb.BeaconStateElectra{
+		GenesisTime:           beaconState.GenesisTime(),
+		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
+		Slot:                  beaconState.Slot(),
+		Fork: &ethpb.Fork{
+			PreviousVersion: beaconState.Fork().CurrentVersion,
+			CurrentVersion:  params.BeaconConfig().ElectraForkVersion,
+			Epoch:           time.CurrentEpoch(beaconState),
+		},
+		LatestBlockHeader:           beaconState.LatestBlockHeader(),
+		BlockRoots:                  beaconState.BlockRoots(),
+		StateRoots:                  beaconState.StateRoots(),
+		HistoricalRoots:             historicalRoots,
+		Eth1Data:                    beaconState.Eth1Data(),
+		Eth1DataVotes:               beaconState.Eth1DataVotes(),
+		Eth1DepositIndex:            beaconState.Eth1DepositIndex(),
+		Validators:                  beaconState.Validators(),
+		Balances:                    beaconState.Balances(),
+		RandaoMixes:                 beaconState.RandaoMixes(),
+		Slashings:                   beaconState.Slashings(),
+		PreviousEpochParticipation:  prevEpochParticipation,
+		CurrentEpochParticipation:   currentEpochParticipation,
+		JustificationBits:           beaconState.JustificationBits(),
+		PreviousJustifiedCheckpoint: beaconState.PreviousJustifiedCheckpoint(),
+		CurrentJustifiedCheckpoint:  beaconState.CurrentJustifiedCheckpoint(),
+		FinalizedCheckpoint:         beaconState.FinalizedCheckpoint(),
+		InactivityScores:            inactivityScores,
+		CurrentSyncCommittee:        currentSyncCommittee,
+		NextSyncCommittee:           nextSyncCommittee,
+		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderElectra{
+			ParentHash:             payloadHeader.ParentHash(),
+			FeeRecipient:           payloadHeader.FeeRecipient(),
+			StateRoot:              payloadHeader.StateRoot(),
+			ReceiptsRoot:           payloadHeader.ReceiptsRoot(),
+			LogsBloom:              payloadHeader.LogsBloom(),
+			PrevRandao:             payloadHeader.PrevRandao(),
+			BlockNumber:            payloadHeader.BlockNumber(),
+			GasLimit:               payloadHeader.GasLimit(),
+			GasUsed:                payloadHeader.GasUsed(),
+			Timestamp:              payloadHeader.Timestamp(),
+			ExtraData:              payloadHeader.ExtraData(),
+			BaseFeePerGas:          payloadHeader.BaseFeePerGas(),
+			BlockHash:              payloadHeader.BlockHash(),
+			TransactionsRoot:       txRoot,
+			WithdrawalsRoot:        wdRoot,
+			ExcessBlobGas:          excessBlobGas,
+			BlobGasUsed:            blobGasUsed,
+			DepositReceiptsRoot:    bytesutil.Bytes32(0), // [New in Electra:EIP6110]
+			WithdrawalRequestsRoot: bytesutil.Bytes32(0), // [New in Electra:EIP7002]
+		},
+		NextWithdrawalIndex:          wi,
+		NextWithdrawalValidatorIndex: vi,
+		HistoricalSummaries:          summaries,
+
+		DepositReceiptsStartIndex:     params.BeaconConfig().UnsetDepositReceiptsStartIndex,
+		DepositBalanceToConsume:       0,
+		ExitBalanceToConsume:          helpers.ActivationExitChurnLimit(math.Gwei(tab)),
+		EarliestExitEpoch:             earliestExitEpoch,
+		ConsolidationBalanceToConsume: helpers.ConsolidationChurnLimit(math.Gwei(tab)),
+		EarliestConsolidationEpoch:    helpers.ActivationExitEpoch(slots.ToEpoch(beaconState.Slot())),
+		PendingBalanceDeposits:        make([]*ethpb.PendingBalanceDeposit, 0),
+		PendingPartialWithdrawals:     make([]*ethpb.PendingPartialWithdrawal, 0),
+		PendingConsolidations:         make([]*ethpb.PendingConsolidation, 0),
+	}
+
+	// Sorting preActivationIndices based on a custom criteria
+	sort.Slice(preActivationIndices, func(i, j int) bool {
+		// Comparing based on ActivationEligibilityEpoch and then by index if the epochs are the same
+		if s.Validators[preActivationIndices[i]].ActivationEligibilityEpoch == s.Validators[preActivationIndices[j]].ActivationEligibilityEpoch {
+			return preActivationIndices[i] < preActivationIndices[j]
+		}
+		return s.Validators[preActivationIndices[i]].ActivationEligibilityEpoch < s.Validators[preActivationIndices[j]].ActivationEligibilityEpoch
+	})
+
+	// need to cast the beaconState to use in helper functions
+	post, err := state_native.InitializeFromProtoUnsafeElectra(s)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to initialize post electra beaconState")
+	}
+
+	for _, index := range preActivationIndices {
+		if err := helpers.QueueEntireBalanceAndResetValidator(post, index); err != nil {
+			return nil, errors.Wrap(err, "failed to queue entire balance and reset validator")
+		}
+	}
+
+	// Ensure early adopters of compounding credentials go through the activation churn
+	for _, index := range compoundWithdrawalIndices {
+		if err := helpers.QueueExcessActiveBalance(post, index); err != nil {
+			return nil, errors.Wrap(err, "failed to queue excess active balance")
+		}
+	}
+
+	return post, nil
+}
--- a/beacon-chain/core/electra/upgrade_test.go
+++ b/beacon-chain/core/electra/upgrade_test.go
@@ -0,0 +1,189 @@
+package electra_test
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+func TestUpgradeToElectra(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateDeneb(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	require.NoError(t, st.SetHistoricalRoots([][]byte{{1}}))
+	vals := st.Validators()
+	vals[0].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+	vals[1].WithdrawalCredentials = []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte}
+	require.NoError(t, st.SetValidators(vals))
+	bals := st.Balances()
+	bals[1] = params.BeaconConfig().MinActivationBalance + 1000
+	require.NoError(t, st.SetBalances(bals))
+
+	preForkState := st.Copy()
+	mSt, err := electra.UpgradeToElectra(st)
+	require.NoError(t, err)
+
+	require.Equal(t, preForkState.GenesisTime(), mSt.GenesisTime())
+	require.DeepSSZEqual(t, preForkState.GenesisValidatorsRoot(), mSt.GenesisValidatorsRoot())
+	require.Equal(t, preForkState.Slot(), mSt.Slot())
+	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), mSt.LatestBlockHeader())
+	require.DeepSSZEqual(t, preForkState.BlockRoots(), mSt.BlockRoots())
+	require.DeepSSZEqual(t, preForkState.StateRoots(), mSt.StateRoots())
+	require.DeepSSZEqual(t, preForkState.Validators()[2:], mSt.Validators()[2:])
+	require.DeepSSZEqual(t, preForkState.Balances()[2:], mSt.Balances()[2:])
+	require.DeepSSZEqual(t, preForkState.Eth1Data(), mSt.Eth1Data())
+	require.DeepSSZEqual(t, preForkState.Eth1DataVotes(), mSt.Eth1DataVotes())
+	require.DeepSSZEqual(t, preForkState.Eth1DepositIndex(), mSt.Eth1DepositIndex())
+	require.DeepSSZEqual(t, preForkState.RandaoMixes(), mSt.RandaoMixes())
+	require.DeepSSZEqual(t, preForkState.Slashings(), mSt.Slashings())
+	require.DeepSSZEqual(t, preForkState.JustificationBits(), mSt.JustificationBits())
+	require.DeepSSZEqual(t, preForkState.PreviousJustifiedCheckpoint(), mSt.PreviousJustifiedCheckpoint())
+	require.DeepSSZEqual(t, preForkState.CurrentJustifiedCheckpoint(), mSt.CurrentJustifiedCheckpoint())
+	require.DeepSSZEqual(t, preForkState.FinalizedCheckpoint(), mSt.FinalizedCheckpoint())
+
+	require.Equal(t, len(preForkState.Validators()), len(mSt.Validators()))
+
+	preVal, err := preForkState.ValidatorAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, preVal.EffectiveBalance)
+
+	preVal2, err := preForkState.ValidatorAtIndex(1)
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, preVal2.EffectiveBalance)
+
+	mVal, err := mSt.ValidatorAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), mVal.EffectiveBalance)
+
+	mVal2, err := mSt.ValidatorAtIndex(1)
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MinActivationBalance, mVal2.EffectiveBalance)
+
+	numValidators := mSt.NumValidators()
+	p, err := mSt.PreviousEpochParticipation()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, make([]byte, numValidators), p)
+	p, err = mSt.CurrentEpochParticipation()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, make([]byte, numValidators), p)
+	s, err := mSt.InactivityScores()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, make([]uint64, numValidators), s)
+
+	hr1, err := preForkState.HistoricalRoots()
+	require.NoError(t, err)
+	hr2, err := mSt.HistoricalRoots()
+	require.NoError(t, err)
+	require.DeepEqual(t, hr1, hr2)
+
+	f := mSt.Fork()
+	require.DeepSSZEqual(t, &ethpb.Fork{
+		PreviousVersion: st.Fork().CurrentVersion,
+		CurrentVersion:  params.BeaconConfig().ElectraForkVersion,
+		Epoch:           time.CurrentEpoch(st),
+	}, f)
+	csc, err := mSt.CurrentSyncCommittee()
+	require.NoError(t, err)
+	psc, err := preForkState.CurrentSyncCommittee()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, psc, csc)
+	nsc, err := mSt.NextSyncCommittee()
+	require.NoError(t, err)
+	psc, err = preForkState.NextSyncCommittee()
+	require.NoError(t, err)
+	require.DeepSSZEqual(t, psc, nsc)
+
+	header, err := mSt.LatestExecutionPayloadHeader()
+	require.NoError(t, err)
+	protoHeader, ok := header.Proto().(*enginev1.ExecutionPayloadHeaderElectra)
+	require.Equal(t, true, ok)
+	prevHeader, err := preForkState.LatestExecutionPayloadHeader()
+	require.NoError(t, err)
+	txRoot, err := prevHeader.TransactionsRoot()
+	require.NoError(t, err)
+
+	wdRoot, err := prevHeader.WithdrawalsRoot()
+	require.NoError(t, err)
+	wanted := &enginev1.ExecutionPayloadHeaderElectra{
+		ParentHash:             prevHeader.ParentHash(),
+		FeeRecipient:           prevHeader.FeeRecipient(),
+		StateRoot:              prevHeader.StateRoot(),
+		ReceiptsRoot:           prevHeader.ReceiptsRoot(),
+		LogsBloom:              prevHeader.LogsBloom(),
+		PrevRandao:             prevHeader.PrevRandao(),
+		BlockNumber:            prevHeader.BlockNumber(),
+		GasLimit:               prevHeader.GasLimit(),
+		GasUsed:                prevHeader.GasUsed(),
+		Timestamp:              prevHeader.Timestamp(),
+		ExtraData:              prevHeader.ExtraData(),
+		BaseFeePerGas:          prevHeader.BaseFeePerGas(),
+		BlockHash:              prevHeader.BlockHash(),
+		TransactionsRoot:       txRoot,
+		WithdrawalsRoot:        wdRoot,
+		DepositReceiptsRoot:    bytesutil.Bytes32(0),
+		WithdrawalRequestsRoot: bytesutil.Bytes32(0),
+	}
+	require.DeepEqual(t, wanted, protoHeader)
+
+	nwi, err := mSt.NextWithdrawalIndex()
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), nwi)
+
+	lwvi, err := mSt.NextWithdrawalValidatorIndex()
+	require.NoError(t, err)
+	require.Equal(t, primitives.ValidatorIndex(0), lwvi)
+
+	summaries, err := mSt.HistoricalSummaries()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(summaries))
+
+	startIndex, err := mSt.DepositReceiptsStartIndex()
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().UnsetDepositReceiptsStartIndex, startIndex)
+
+	balance, err := mSt.DepositBalanceToConsume()
+	require.NoError(t, err)
+	require.Equal(t, math.Gwei(0), balance)
+
+	tab, err := helpers.TotalActiveBalance(mSt)
+	require.NoError(t, err)
+
+	ebtc, err := mSt.ExitBalanceToConsume()
+	require.NoError(t, err)
+	require.Equal(t, helpers.ActivationExitChurnLimit(math.Gwei(tab)), ebtc)
+
+	eee, err := mSt.EarliestExitEpoch()
+	require.NoError(t, err)
+	require.Equal(t, primitives.Epoch(1), eee)
+
+	cbtc, err := mSt.ConsolidationBalanceToConsume()
+	require.NoError(t, err)
+	require.Equal(t, helpers.ConsolidationChurnLimit(math.Gwei(tab)), cbtc)
+
+	earliestConsolidationEpoch, err := mSt.EarliestConsolidationEpoch()
+	require.NoError(t, err)
+	require.Equal(t, helpers.ActivationExitEpoch(slots.ToEpoch(preForkState.Slot())), earliestConsolidationEpoch)
+
+	pendingBalanceDeposits, err := mSt.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 2, len(pendingBalanceDeposits))
+	require.Equal(t, uint64(1000), pendingBalanceDeposits[1].Amount)
+
+	numPendingPartialWithdrawals, err := mSt.NumPendingPartialWithdrawals()
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), numPendingPartialWithdrawals)
+
+	consolidations, err := mSt.PendingConsolidations()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(consolidations))
+
+}
--- a/beacon-chain/core/helpers/validators.go
+++ b/beacon-chain/core/helpers/validators.go
@@ -12,6 +12,7 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -520,11 +521,11 @@ func isETH1WithdrawalCredential(creds []byte) bool {
 //	    Check if ``validator`` has an 0x02 prefixed "compounding" withdrawal credential.
 //	    """
 //	    return is_compounding_withdrawal_credential(validator.withdrawal_credentials)
-func HasCompoundingWithdrawalCredential(v *ethpb.Validator) bool {
+func HasCompoundingWithdrawalCredential(v interfaces.WithWithdrawalCredentials) bool {
 	if v == nil {
 		return false
 	}
-	return isCompoundingWithdrawalCredential(v.WithdrawalCredentials)
+	return isCompoundingWithdrawalCredential(v.GetWithdrawalCredentials())
 }

 // isCompoundingWithdrawalCredential checks if the credentials are a compounding withdrawal credential.
@@ -673,3 +674,68 @@ func ValidatorMaxEffectiveBalance(val *ethpb.Validator) uint64 {
 	}
 	return params.BeaconConfig().MinActivationBalance
 }
+
+// QueueExcessActiveBalance queues validators with balances above the min activation balance and adds to pending balance deposit.
+//
+// Spec definition:
+//
+//	def queue_excess_active_balance(state: BeaconState, index: ValidatorIndex) -> None:
+//	    balance = state.balances[index]
+//	    if balance > MIN_ACTIVATION_BALANCE:
+//	        excess_balance = balance - MIN_ACTIVATION_BALANCE
+//	        state.balances[index] = MIN_ACTIVATION_BALANCE
+//	        state.pending_balance_deposits.append(
+//	            PendingBalanceDeposit(index=index, amount=excess_balance)
+//	        )
+func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex) error {
+	bal, err := s.BalanceAtIndex(idx)
+	if err != nil {
+		return err
+	}
+
+	if bal > params.BeaconConfig().MinActivationBalance {
+		excessBalance := bal - params.BeaconConfig().MinActivationBalance
+		if err := s.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
+			return err
+		}
+		return s.AppendPendingBalanceDeposit(idx, excessBalance)
+	}
+	return nil
+}
+
+// QueueEntireBalanceAndResetValidator queues the entire balance and resets the validator. This is used in electra fork logic.
+//
+// Spec definition:
+//
+//	def queue_entire_balance_and_reset_validator(state: BeaconState, index: ValidatorIndex) -> None:
+//	    balance = state.balances[index]
+//	    validator = state.validators[index]
+//		state.balances[index] = 0
+//	    validator.effective_balance = 0
+//	    validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
+//	    state.pending_balance_deposits.append(
+//	        PendingBalanceDeposit(index=index, amount=balance)
+//	    )
+func QueueEntireBalanceAndResetValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
+	bal, err := s.BalanceAtIndex(idx)
+	if err != nil {
+		return err
+	}
+
+	if err := s.UpdateBalancesAtIndex(idx, 0); err != nil {
+		return err
+	}
+
+	v, err := s.ValidatorAtIndex(idx)
+	if err != nil {
+		return err
+	}
+
+	v.EffectiveBalance = 0
+	v.ActivationEligibilityEpoch = params.BeaconConfig().FarFutureEpoch
+	if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
+		return err
+	}
+
+	return s.AppendPendingBalanceDeposit(idx, bal)
+}
--- a/beacon-chain/core/helpers/validators_test.go
+++ b/beacon-chain/core/helpers/validators_test.go
@@ -18,6 +18,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )

 func TestIsActiveValidator_OK(t *testing.T) {
@@ -1119,3 +1120,40 @@ func TestValidatorMaxEffectiveBalance(t *testing.T) {
 	// Sanity check that MinActivationBalance equals (pre-electra) MaxEffectiveBalance
 	assert.Equal(t, params.BeaconConfig().MinActivationBalance, params.BeaconConfig().MaxEffectiveBalance)
 }
+
+func TestQueueExcessActiveBalance_Ok(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	bals := st.Balances()
+	bals[0] = params.BeaconConfig().MinActivationBalance + 1000
+	require.NoError(t, st.SetBalances(bals))
+
+	err := helpers.QueueExcessActiveBalance(st, 0)
+	require.NoError(t, err)
+
+	pbd, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, uint64(1000), pbd[0].Amount)
+
+	bals = st.Balances()
+	require.Equal(t, params.BeaconConfig().MinActivationBalance, bals[0])
+}
+
+func TestQueueEntireBalanceAndResetValidator_Ok(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	val, err := st.ValidatorAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, val.EffectiveBalance)
+	pbd, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(pbd))
+	err = helpers.QueueEntireBalanceAndResetValidator(st, 0)
+	require.NoError(t, err)
+
+	pbd, err = st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(pbd))
+
+	val, err = st.ValidatorAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), val.EffectiveBalance)
+}
--- a/beacon-chain/core/time/slot_epoch.go
+++ b/beacon-chain/core/time/slot_epoch.go
@@ -90,6 +90,15 @@ func CanUpgradeToDeneb(slot primitives.Slot) bool {
 	return epochStart && DenebEpoch
 }

+// CanUpgradeToElectra returns true if the input `slot` can upgrade to Electra.
+// Spec code:
+// If state.slot % SLOTS_PER_EPOCH == 0 and compute_epoch_at_slot(state.slot) == ELECTRA_FORK_EPOCH
+func CanUpgradeToElectra(slot primitives.Slot) bool {
+	epochStart := slots.IsEpochStart(slot)
+	electraEpoch := slots.ToEpoch(slot) == params.BeaconConfig().ElectraForkEpoch
+	return epochStart && electraEpoch
+}
+
 // CanProcessEpoch checks the eligibility to process epoch.
 // The epoch can be processed at the end of the last slot of every epoch.
 //
--- a/beacon-chain/core/time/slot_epoch_test.go
+++ b/beacon-chain/core/time/slot_epoch_test.go
@@ -333,3 +333,38 @@ func TestCanUpgradeToDeneb(t *testing.T) {
 		})
 	}
 }
+
+func TestCanUpgradeToElectra(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	bc := params.BeaconConfig()
+	bc.ElectraForkEpoch = 5
+	params.OverrideBeaconConfig(bc)
+	tests := []struct {
+		name string
+		slot primitives.Slot
+		want bool
+	}{
+		{
+			name: "not epoch start",
+			slot: 1,
+			want: false,
+		},
+		{
+			name: "not electra epoch",
+			slot: params.BeaconConfig().SlotsPerEpoch,
+			want: false,
+		},
+		{
+			name: "electra epoch",
+			slot: primitives.Slot(params.BeaconConfig().ElectraForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := time.CanUpgradeToElectra(tt.slot); got != tt.want {
+				t.Errorf("CanUpgradeToElectra() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
--- a/beacon-chain/core/transition/BUILD.bazel
+++ b/beacon-chain/core/transition/BUILD.bazel
@@ -19,6 +19,7 @@ go_library(
        "//beacon-chain/core/blocks:go_default_library",
        "//beacon-chain/core/capella:go_default_library",
        "//beacon-chain/core/deneb:go_default_library",
+        "//beacon-chain/core/electra:go_default_library",
        "//beacon-chain/core/epoch:go_default_library",
        "//beacon-chain/core/epoch/precompute:go_default_library",
        "//beacon-chain/core/execution:go_default_library",
--- a/beacon-chain/core/transition/transition.go
+++ b/beacon-chain/core/transition/transition.go
@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/capella"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/deneb"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
 	e "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/execution"
@@ -320,6 +321,14 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			return nil, err
 		}
 	}
+
+	if time.CanUpgradeToElectra(state.Slot()) {
+		state, err = electra.UpgradeToElectra(state)
+		if err != nil {
+			tracing.AnnotateError(span, err)
+			return nil, err
+		}
+	}
 	return state, nil
 }

--- a/beacon-chain/core/transition/transition_test.go
+++ b/beacon-chain/core/transition/transition_test.go
@@ -651,6 +651,20 @@ func TestProcessSlots_ThroughDenebEpoch(t *testing.T) {
 	require.Equal(t, params.BeaconConfig().SlotsPerEpoch*10, st.Slot())
 }

+func TestProcessSlots_ThroughElectraEpoch(t *testing.T) {
+	transition.SkipSlotCache.Disable()
+	params.SetupTestConfigCleanup(t)
+	conf := params.BeaconConfig()
+	conf.ElectraForkEpoch = 5
+	params.OverrideBeaconConfig(conf)
+
+	st, _ := util.DeterministicGenesisStateDeneb(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	st, err := transition.ProcessSlots(context.Background(), st, params.BeaconConfig().SlotsPerEpoch*10)
+	require.NoError(t, err)
+	require.Equal(t, version.Electra, st.Version())
+	require.Equal(t, params.BeaconConfig().SlotsPerEpoch*10, st.Slot())
+}
+
 func TestProcessSlotsUsingNextSlotCache(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 1)
 	r := []byte{'a'}
--- a/beacon-chain/rpc/eth/beacon/handlers_validator.go
+++ b/beacon-chain/rpc/eth/beacon/handlers_validator.go
@@ -404,7 +404,7 @@ func valContainerFromReadOnlyVal(
 		Status:  valStatus.String(),
 		Validator: &structs.Validator{
 			Pubkey:                     hexutil.Encode(pubkey[:]),
-			WithdrawalCredentials:      hexutil.Encode(val.WithdrawalCredentials()),
+			WithdrawalCredentials:      hexutil.Encode(val.GetWithdrawalCredentials()),
 			EffectiveBalance:           strconv.FormatUint(val.EffectiveBalance(), 10),
 			Slashed:                    val.Slashed(),
 			ActivationEligibilityEpoch: strconv.FormatUint(uint64(val.ActivationEligibilityEpoch()), 10),
--- a/beacon-chain/rpc/eth/config/handlers_test.go
+++ b/beacon-chain/rpc/eth/config/handlers_test.go
@@ -149,6 +149,7 @@ func TestGetSpec(t *testing.T) {
 	config.MaxAttestationsElectra = 89
 	config.MaxWithdrawalRequestsPerPayload = 90
 	config.MaxCellsInExtendedMatrix = 91
+	config.UnsetDepositReceiptsStartIndex = 92

 	var dbp [4]byte
 	copy(dbp[:], []byte{'0', '0', '0', '1'})
@@ -191,7 +192,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)

-	assert.Equal(t, 153, len(data))
+	assert.Equal(t, 154, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -524,6 +525,8 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "90", v)
 			case "MAX_CELLS_IN_EXTENDED_MATRIX":
 				assert.Equal(t, "91", v)
+			case "UNSET_DEPOSIT_RECEIPTS_START_INDEX":
+				assert.Equal(t, "92", v)
 			default:
 				t.Errorf("Incorrect key: %s", k)
 			}
--- a/beacon-chain/state/interfaces.go
+++ b/beacon-chain/state/interfaces.go
@@ -49,6 +49,7 @@ type ReadOnlyBeaconState interface {
 	ReadOnlyStateRoots
 	ReadOnlyRandaoMixes
 	ReadOnlyEth1Data
+	ReadOnlyExits
 	ReadOnlyValidators
 	ReadOnlyBalances
 	ReadOnlyCheckpoint
@@ -115,7 +116,7 @@ type ReadOnlyValidator interface {
 	WithdrawableEpoch() primitives.Epoch
 	ExitEpoch() primitives.Epoch
 	PublicKey() [fieldparams.BLSPubkeyLength]byte
-	WithdrawalCredentials() []byte
+	GetWithdrawalCredentials() []byte
 	Slashed() bool
 	IsNil() bool
 }
@@ -179,6 +180,12 @@ type ReadOnlyEth1Data interface {
 	Eth1DepositIndex() uint64
 }

+// ReadOnlyExits defines a struct which only has read access to Exit related methods.
+type ReadOnlyExits interface {
+	ExitBalanceToConsume() (math.Gwei, error)
+	EarliestExitEpoch() (primitives.Epoch, error)
+}
+
 // ReadOnlyAttestations defines a struct which only has read access to attestations methods.
 type ReadOnlyAttestations interface {
 	PreviousEpochAttestations() ([]*ethpb.PendingAttestation, error)
--- a/beacon-chain/state/state-native/BUILD.bazel
+++ b/beacon-chain/state/state-native/BUILD.bazel
@@ -14,6 +14,7 @@ go_library(
        "getters_consolidation.go",
        "getters_deposit_receipts.go",
        "getters_eth1.go",
+        "getters_exit.go",
        "getters_misc.go",
        "getters_participation.go",
        "getters_payload_header.go",
@@ -94,6 +95,7 @@ go_test(
        "getters_checkpoint_test.go",
        "getters_consolidation_test.go",
        "getters_deposit_receipts_test.go",
+        "getters_exit_test.go",
        "getters_participation_test.go",
        "getters_test.go",
        "getters_validator_test.go",
--- a/beacon-chain/state/state-native/getters_exit.go
+++ b/beacon-chain/state/state-native/getters_exit.go
@@ -0,0 +1,29 @@
+package state_native
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+)
+
+// ExitBalanceToConsume is used for returning the ExitBalanceToConsume as part of eip 7251
+func (b *BeaconState) ExitBalanceToConsume() (math.Gwei, error) {
+	if b.version < version.Electra {
+		return 0, errNotSupported("ExitBalanceToConsume", b.version)
+	}
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.exitBalanceToConsume, nil
+}
+
+// EarliestExitEpoch is used for returning the EarliestExitEpoch as part of eip 7251
+func (b *BeaconState) EarliestExitEpoch() (primitives.Epoch, error) {
+	if b.version < version.Electra {
+		return 0, errNotSupported("EarliestExitEpoch", b.version)
+	}
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.earliestExitEpoch, nil
+}
--- a/beacon-chain/state/state-native/getters_exit_test.go
+++ b/beacon-chain/state/state-native/getters_exit_test.go
@@ -0,0 +1,44 @@
+package state_native_test
+
+import (
+	"testing"
+
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func TestExitBalanceToConsume(t *testing.T) {
+	t.Run("previous fork returns expected error", func(t *testing.T) {
+		dState, _ := util.DeterministicGenesisState(t, 1)
+		_, err := dState.ExitBalanceToConsume()
+		require.ErrorContains(t, "is not supported", err)
+	})
+	t.Run("electra returns expected value", func(t *testing.T) {
+		want := math.Gwei(2)
+		dState, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{ExitBalanceToConsume: want})
+		require.NoError(t, err)
+		got, err := dState.ExitBalanceToConsume()
+		require.NoError(t, err)
+		require.Equal(t, want, got)
+	})
+}
+
+func TestEarliestExitEpoch(t *testing.T) {
+	t.Run("previous fork returns expected error", func(t *testing.T) {
+		dState, _ := util.DeterministicGenesisState(t, 1)
+		_, err := dState.EarliestExitEpoch()
+		require.ErrorContains(t, "is not supported", err)
+	})
+	t.Run("electra returns expected value", func(t *testing.T) {
+		want := primitives.Epoch(2)
+		dState, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{EarliestExitEpoch: want})
+		require.NoError(t, err)
+		got, err := dState.EarliestExitEpoch()
+		require.NoError(t, err)
+		require.Equal(t, want, got)
+	})
+}
--- a/beacon-chain/state/state-native/readonly_validator.go
+++ b/beacon-chain/state/state-native/readonly_validator.go
@@ -77,7 +77,7 @@ func (v readOnlyValidator) publicKeySlice() []byte {

 // WithdrawalCredentials returns the withdrawal credentials of the
 // read only validator.
-func (v readOnlyValidator) WithdrawalCredentials() []byte {
+func (v readOnlyValidator) GetWithdrawalCredentials() []byte {
 	creds := make([]byte, len(v.validator.WithdrawalCredentials))
 	copy(creds, v.validator.WithdrawalCredentials)
 	return creds
--- a/beacon-chain/state/state-native/readonly_validator_test.go
+++ b/beacon-chain/state/state-native/readonly_validator_test.go
@@ -63,7 +63,7 @@ func TestReadOnlyValidator_WithdrawalCredentials(t *testing.T) {
 	creds := []byte{0xFA, 0xCC}
 	v, err := statenative.NewValidator(&ethpb.Validator{WithdrawalCredentials: creds})
 	require.NoError(t, err)
-	assert.DeepEqual(t, creds, v.WithdrawalCredentials())
+	assert.DeepEqual(t, creds, v.GetWithdrawalCredentials())
 }

 func TestReadOnlyValidator_Slashed(t *testing.T) {
--- a/beacon-chain/state/stategen/BUILD.bazel
+++ b/beacon-chain/state/stategen/BUILD.bazel
@@ -23,6 +23,7 @@ go_library(
        "//beacon-chain/core/altair:go_default_library",
        "//beacon-chain/core/capella:go_default_library",
        "//beacon-chain/core/deneb:go_default_library",
+        "//beacon-chain/core/electra:go_default_library",
        "//beacon-chain/core/execution:go_default_library",
        "//beacon-chain/core/helpers:go_default_library",
        "//beacon-chain/core/time:go_default_library",
--- a/beacon-chain/state/stategen/replay.go
+++ b/beacon-chain/state/stategen/replay.go
@@ -9,6 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/capella"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/deneb"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/execution"
 	prysmtime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
@@ -26,7 +27,7 @@ import (
 // ReplayBlocks replays the input blocks on the input state until the target slot is reached.
 //
 // WARNING Blocks passed to the function must be in decreasing slots order.
-func (_ *State) replayBlocks(
+func (*State) replayBlocks(
 	ctx context.Context,
 	state state.BeaconState,
 	signed []interfaces.ReadOnlySignedBeaconBlock,
@@ -201,21 +202,18 @@ func ReplayProcessSlots(ctx context.Context, state state.BeaconState, slot primi
 			return nil, errors.Wrap(err, "could not process slot")
 		}
 		if prysmtime.CanProcessEpoch(state) {
-			switch state.Version() {
-			case version.Phase0:
+			if state.Version() == version.Phase0 {
 				state, err = transition.ProcessEpochPrecompute(ctx, state)
 				if err != nil {
 					tracing.AnnotateError(span, err)
 					return nil, errors.Wrap(err, "could not process epoch with optimizations")
 				}
-			case version.Altair, version.Bellatrix, version.Capella, version.Deneb:
+			} else {
 				state, err = altair.ProcessEpoch(ctx, state)
 				if err != nil {
 					tracing.AnnotateError(span, err)
 					return nil, errors.Wrap(err, "could not process epoch")
 				}
-			default:
-				return nil, fmt.Errorf("unsupported beacon state version: %s", version.String(state.Version()))
 			}
 		}
 		if err := state.SetSlot(state.Slot() + 1); err != nil {
@@ -254,6 +252,14 @@ func ReplayProcessSlots(ctx context.Context, state state.BeaconState, slot primi
 				return nil, err
 			}
 		}
+
+		if prysmtime.CanUpgradeToElectra(state.Slot()) {
+			state, err = electra.UpgradeToElectra(state)
+			if err != nil {
+				tracing.AnnotateError(span, err)
+				return nil, err
+			}
+		}
 	}

 	return state, nil
--- a/beacon-chain/state/stategen/replay_test.go
+++ b/beacon-chain/state/stategen/replay_test.go
@@ -140,7 +140,7 @@ func TestReplayBlocks_ThroughForkBoundary(t *testing.T) {
 	assert.Equal(t, version.Altair, newState.Version())
 }

-func TestReplayBlocks_ThroughCapellaForkBoundary(t *testing.T) {
+func TestReplayBlocks_ThroughFutureForkBoundaries(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	bCfg := params.BeaconConfig().Copy()
 	bCfg.AltairForkEpoch = 1
@@ -149,6 +149,10 @@ func TestReplayBlocks_ThroughCapellaForkBoundary(t *testing.T) {
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.BellatrixForkVersion)] = 2
 	bCfg.CapellaForkEpoch = 3
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.CapellaForkVersion)] = 3
+	bCfg.DenebForkEpoch = 4
+	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.DenebForkVersion)] = 4
+	bCfg.ElectraForkEpoch = 5
+	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.ElectraForkVersion)] = 5
 	params.OverrideBeaconConfig(bCfg)

 	beaconState, _ := util.DeterministicGenesisState(t, 32)
@@ -177,6 +181,20 @@ func TestReplayBlocks_ThroughCapellaForkBoundary(t *testing.T) {

 	// Verify state is version Capella.
 	assert.Equal(t, version.Capella, newState.Version())
+
+	targetSlot = params.BeaconConfig().SlotsPerEpoch * 4
+	newState, err = service.replayBlocks(context.Background(), newState, []interfaces.ReadOnlySignedBeaconBlock{}, targetSlot)
+	require.NoError(t, err)
+
+	// Verify state is version Deneb.
+	assert.Equal(t, version.Deneb, newState.Version())
+
+	targetSlot = params.BeaconConfig().SlotsPerEpoch * 5
+	newState, err = service.replayBlocks(context.Background(), newState, []interfaces.ReadOnlySignedBeaconBlock{}, targetSlot)
+	require.NoError(t, err)
+
+	// Verify state is version Electra.
+	assert.Equal(t, version.Electra, newState.Version())
 }

 func TestLoadBlocks_FirstBranch(t *testing.T) {
--- a/config/params/config.go
+++ b/config/params/config.go
@@ -250,6 +250,7 @@ type BeaconChainConfig struct {
 	MaxPendingPartialsPerWithdrawalsSweep uint64 `yaml:"MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP" spec:"true"` // MaxPendingPartialsPerWithdrawalsSweep is the maximum number of pending partial withdrawals to process per payload.
 	FullExitRequestAmount                 uint64 `yaml:"FULL_EXIT_REQUEST_AMOUNT" spec:"true"`                   // FullExitRequestAmount is the amount of Gwei required to request a full exit.
 	MaxWithdrawalRequestsPerPayload       uint64 `yaml:"MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD" spec:"true"`        // MaxWithdrawalRequestsPerPayload is the maximum number of execution layer withdrawal requests in each payload.
+	UnsetDepositReceiptsStartIndex        uint64 `yaml:"UNSET_DEPOSIT_RECEIPTS_START_INDEX" spec:"true"`         // UnsetDepositReceiptsStartIndex is used to check the start index for eip6110

 	// Networking Specific Parameters
 	GossipMaxSize                   uint64          `yaml:"GOSSIP_MAX_SIZE" spec:"true"`                    // GossipMaxSize is the maximum allowed size of uncompressed gossip messages.
--- a/config/params/loader.go
+++ b/config/params/loader.go
@@ -232,6 +232,8 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("MESSAGE_DOMAIN_INVALID_SNAPPY:  %#x", cfg.MessageDomainInvalidSnappy),
 		fmt.Sprintf("MESSAGE_DOMAIN_VALID_SNAPPY: %#x", cfg.MessageDomainValidSnappy),
 		fmt.Sprintf("MIN_EPOCHS_FOR_BLOCK_REQUESTS: %d", int(cfg.MinEpochsForBlockRequests)),
+		fmt.Sprintf("ELECTRA_FORK_EPOCH: %d", cfg.ElectraForkEpoch),
+		fmt.Sprintf("ELECTRA_FORK_VERSION: %#x", cfg.ElectraForkVersion),
 	}

 	yamlFile := []byte(strings.Join(lines, "\n"))
--- a/config/params/loader_test.go
+++ b/config/params/loader_test.go
@@ -147,12 +147,14 @@ func assertEqualConfigs(t *testing.T, name string, fields []string, expected, ac
 	assert.Equal(t, expected.BellatrixForkEpoch, actual.BellatrixForkEpoch, "%s: BellatrixForkEpoch", name)
 	assert.Equal(t, expected.CapellaForkEpoch, actual.CapellaForkEpoch, "%s: CapellaForkEpoch", name)
 	assert.Equal(t, expected.DenebForkEpoch, actual.DenebForkEpoch, "%s: DenebForkEpoch", name)
+	assert.Equal(t, expected.ElectraForkEpoch, actual.ElectraForkEpoch, "%s: ElectraForkEpoch", name)
 	assert.Equal(t, expected.SqrRootSlotsPerEpoch, actual.SqrRootSlotsPerEpoch, "%s: SqrRootSlotsPerEpoch", name)
 	assert.DeepEqual(t, expected.GenesisForkVersion, actual.GenesisForkVersion, "%s: GenesisForkVersion", name)
 	assert.DeepEqual(t, expected.AltairForkVersion, actual.AltairForkVersion, "%s: AltairForkVersion", name)
 	assert.DeepEqual(t, expected.BellatrixForkVersion, actual.BellatrixForkVersion, "%s: BellatrixForkVersion", name)
 	assert.DeepEqual(t, expected.CapellaForkVersion, actual.CapellaForkVersion, "%s: CapellaForkVersion", name)
 	assert.DeepEqual(t, expected.DenebForkVersion, actual.DenebForkVersion, "%s: DenebForkVersion", name)
+	assert.DeepEqual(t, expected.ElectraForkVersion, actual.ElectraForkVersion, "%s: ElectraForkVersion", name)

 	assertYamlFieldsMatch(t, name, fields, expected, actual)
 }
--- a/config/params/mainnet_config.go
+++ b/config/params/mainnet_config.go
@@ -290,6 +290,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	MaxPendingPartialsPerWithdrawalsSweep: 8,
 	FullExitRequestAmount:                 0,
 	MaxWithdrawalRequestsPerPayload:       16,
+	UnsetDepositReceiptsStartIndex:        math.MaxUint64,

 	// Values related to networking parameters.
 	GossipMaxSize:                   10 * 1 << 20, // 10 MiB
--- a/consensus-types/interfaces/BUILD.bazel
+++ b/consensus-types/interfaces/BUILD.bazel
@@ -7,6 +7,7 @@ go_library(
        "cast.go",
        "error.go",
        "utils.go",
+        "validator.go",
    ],
    importpath = "github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces",
    visibility = ["//visibility:public"],
--- a/consensus-types/interfaces/validator.go
+++ b/consensus-types/interfaces/validator.go
@@ -0,0 +1,5 @@
+package interfaces
+
+type WithWithdrawalCredentials interface {
+	GetWithdrawalCredentials() []byte
+}
--- a/testing/endtoend/evaluators/operations.go
+++ b/testing/endtoend/evaluators/operations.go
@@ -365,7 +365,7 @@ func proposeVoluntaryExit(ec *e2etypes.EvaluationContext, conns ...*grpc.ClientC
 	}
 	var execIndices []int
 	err = st.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
-		if val.WithdrawalCredentials()[0] == params.BeaconConfig().ETH1AddressWithdrawalPrefixByte {
+		if val.GetWithdrawalCredentials()[0] == params.BeaconConfig().ETH1AddressWithdrawalPrefixByte {
 			execIndices = append(execIndices, idx)
 		}
 		return nil
--- a/testing/spectest/mainnet/electra/fork_helper/BUILD.bazel
+++ b/testing/spectest/mainnet/electra/fork_helper/BUILD.bazel
@@ -0,0 +1,13 @@
+load("@prysm//tools/go:def.bzl", "go_test")
+
+go_test(
+    name = "go_default_test",
+    size = "small",
+    srcs = ["upgrade_to_electra_test.go"],
+    data = glob(["*.yaml"]) + [
+        "@consensus_spec_tests_mainnet//:test_data",
+    ],
+    shard_count = 4,
+    tags = ["spectest"],
+    deps = ["//testing/spectest/shared/electra/fork:go_default_library"],
+)
--- a/testing/spectest/mainnet/electra/fork_helper/upgrade_to_electra_test.go
+++ b/testing/spectest/mainnet/electra/fork_helper/upgrade_to_electra_test.go
@@ -0,0 +1,11 @@
+package fork_helper
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/electra/fork"
+)
+
+func TestMainnet_UpgradeToElectra(t *testing.T) {
+	fork.RunUpgradeToElectra(t, "mainnet")
+}
--- a/testing/spectest/minimal/electra/fork/BUILD.bazel
+++ b/testing/spectest/minimal/electra/fork/BUILD.bazel
@@ -0,0 +1,17 @@
+load("@prysm//tools/go:def.bzl", "go_test")
+
+go_test(
+    name = "go_default_test",
+    size = "small",
+    srcs = ["upgrade_to_electra_test.go"],
+    data = glob(["*.yaml"]) + [
+        "@consensus_spec_tests_minimal//:test_data",
+    ],
+    eth_network = "minimal",
+    shard_count = 4,
+    tags = [
+        "minimal",
+        "spectest",
+    ],
+    deps = ["//testing/spectest/shared/electra/fork:go_default_library"],
+)
--- a/testing/spectest/minimal/electra/fork/upgrade_to_electra_test.go
+++ b/testing/spectest/minimal/electra/fork/upgrade_to_electra_test.go
@@ -0,0 +1,11 @@
+package fork
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/electra/fork"
+)
+
+func TestMinimal_UpgradeToElectra(t *testing.T) {
+	fork.RunUpgradeToElectra(t, "minimal")
+}
--- a/testing/spectest/shared/electra/fork/BUILD.bazel
+++ b/testing/spectest/shared/electra/fork/BUILD.bazel
@@ -0,0 +1,22 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    testonly = True,
+    srcs = ["upgrade_to_electra.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/testing/spectest/shared/electra/fork",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/electra:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/spectest/utils:go_default_library",
+        "//testing/util:go_default_library",
+        "@com_github_golang_snappy//:go_default_library",
+        "@com_github_google_go_cmp//cmp:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
+        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
+    ],
+)
--- a/testing/spectest/shared/electra/fork/upgrade_to_electra.go
+++ b/testing/spectest/shared/electra/fork/upgrade_to_electra.go
@@ -0,0 +1,61 @@
+package fork
+
+import (
+	"path"
+	"testing"
+
+	"github.com/golang/snappy"
+	"github.com/google/go-cmp/cmp"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/spectest/utils"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/testing/protocmp"
+)
+
+// RunUpgradeToElectra is a helper function that runs Electra's fork spec tests.
+// It unmarshals a pre- and post-state to check `UpgradeToDeneb` comply with spec implementation.
+func RunUpgradeToElectra(t *testing.T, config string) {
+	require.NoError(t, utils.SetConfig(t, config))
+
+	testFolders, testsFolderPath := utils.TestFolders(t, config, "electra", "fork/fork/pyspec_tests")
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			helpers.ClearCache()
+			folderPath := path.Join(testsFolderPath, folder.Name())
+
+			preStateFile, err := util.BazelFileBytes(path.Join(folderPath, "pre.ssz_snappy"))
+			require.NoError(t, err)
+			preStateSSZ, err := snappy.Decode(nil /* dst */, preStateFile)
+			require.NoError(t, err, "Failed to decompress")
+			preStateBase := &ethpb.BeaconStateDeneb{}
+			if err := preStateBase.UnmarshalSSZ(preStateSSZ); err != nil {
+				t.Fatalf("Failed to unmarshal: %v", err)
+			}
+			preState, err := state_native.InitializeFromProtoDeneb(preStateBase)
+			require.NoError(t, err)
+			postState, err := electra.UpgradeToElectra(preState)
+			require.NoError(t, err)
+			postStateFromFunction, err := state_native.ProtobufBeaconStateElectra(postState.ToProtoUnsafe())
+			require.NoError(t, err)
+
+			postStateFile, err := util.BazelFileBytes(path.Join(folderPath, "post.ssz_snappy"))
+			require.NoError(t, err)
+			postStateSSZ, err := snappy.Decode(nil /* dst */, postStateFile)
+			require.NoError(t, err, "Failed to decompress")
+			postStateFromFile := &ethpb.BeaconStateElectra{}
+			if err := postStateFromFile.UnmarshalSSZ(postStateSSZ); err != nil {
+				t.Fatalf("Failed to unmarshal: %v", err)
+			}
+
+			if !proto.Equal(postStateFromFile, postStateFromFunction) {
+				t.Log(cmp.Diff(postStateFromFile, postStateFromFunction, protocmp.Transform()))
+				t.Fatal("Post state does not match expected")
+			}
+		})
+	}
+}
--- a/testing/util/BUILD.bazel
+++ b/testing/util/BUILD.bazel
@@ -17,6 +17,7 @@ go_library(
        "deneb_state.go",
        "deposits.go",
        "electra.go",
+        "electra_state.go",
        "helpers.go",
        "merge.go",
        "state.go",
@@ -48,6 +49,7 @@ go_library(
        "//crypto/hash:go_default_library",
        "//crypto/rand:go_default_library",
        "//encoding/bytesutil:go_default_library",
+        "//math:go_default_library",
        "//network/forks:go_default_library",
        "//proto/engine/v1:go_default_library",
        "//proto/eth/v1:go_default_library",
--- a/testing/util/electra_state.go
+++ b/testing/util/electra_state.go
@@ -0,0 +1,273 @@
+package util
+
+import (
+	"context"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stateutil"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+// DeterministicGenesisStateElectra returns a genesis state in Electra format made using the deterministic deposits.
+func DeterministicGenesisStateElectra(t testing.TB, numValidators uint64) (state.BeaconState, []bls.SecretKey) {
+	deposits, privKeys, err := DeterministicDepositsAndKeys(numValidators)
+	if err != nil {
+		t.Fatal(errors.Wrapf(err, "failed to get %d deposits", numValidators))
+	}
+	eth1Data, err := DeterministicEth1Data(len(deposits))
+	if err != nil {
+		t.Fatal(errors.Wrapf(err, "failed to get eth1data for %d deposits", numValidators))
+	}
+	beaconState, err := genesisBeaconStateElectra(context.Background(), deposits, uint64(0), eth1Data)
+	if err != nil {
+		t.Fatal(errors.Wrapf(err, "failed to get genesis beacon state of %d validators", numValidators))
+	}
+	resetCache()
+	return beaconState, privKeys
+}
+
+// genesisBeaconStateElectra returns the genesis beacon state.
+func genesisBeaconStateElectra(ctx context.Context, deposits []*ethpb.Deposit, genesisTime uint64, eth1Data *ethpb.Eth1Data) (state.BeaconState, error) {
+	st, err := emptyGenesisStateElectra()
+	if err != nil {
+		return nil, err
+	}
+
+	// Process initial deposits.
+	st, err = helpers.UpdateGenesisEth1Data(st, deposits, eth1Data)
+	if err != nil {
+		return nil, err
+	}
+
+	st, err = processPreGenesisDeposits(ctx, st, deposits)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process validator deposits")
+	}
+
+	return buildGenesisBeaconStateElectra(genesisTime, st, st.Eth1Data())
+}
+
+// emptyGenesisStateDeneb returns an empty genesis state in Electra format.
+func emptyGenesisStateElectra() (state.BeaconState, error) {
+	st := &ethpb.BeaconStateElectra{
+		// Misc fields.
+		Slot: 0,
+		Fork: &ethpb.Fork{
+			PreviousVersion: params.BeaconConfig().BellatrixForkVersion,
+			CurrentVersion:  params.BeaconConfig().DenebForkVersion,
+			Epoch:           0,
+		},
+		// Validator registry fields.
+		Validators:       []*ethpb.Validator{},
+		Balances:         []uint64{},
+		InactivityScores: []uint64{},
+
+		JustificationBits:          []byte{0},
+		HistoricalRoots:            [][]byte{},
+		CurrentEpochParticipation:  []byte{},
+		PreviousEpochParticipation: []byte{},
+
+		// Eth1 data.
+		Eth1Data:         &ethpb.Eth1Data{},
+		Eth1DataVotes:    []*ethpb.Eth1Data{},
+		Eth1DepositIndex: 0,
+
+		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderElectra{},
+	}
+	return state_native.InitializeFromProtoElectra(st)
+}
+
+func buildGenesisBeaconStateElectra(genesisTime uint64, preState state.BeaconState, eth1Data *ethpb.Eth1Data) (state.BeaconState, error) {
+	if eth1Data == nil {
+		return nil, errors.New("no eth1data provided for genesis state")
+	}
+
+	randaoMixes := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)
+	for i := 0; i < len(randaoMixes); i++ {
+		h := make([]byte, 32)
+		copy(h, eth1Data.BlockHash)
+		randaoMixes[i] = h
+	}
+
+	zeroHash := params.BeaconConfig().ZeroHash[:]
+
+	activeIndexRoots := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)
+	for i := 0; i < len(activeIndexRoots); i++ {
+		activeIndexRoots[i] = zeroHash
+	}
+
+	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
+	for i := 0; i < len(blockRoots); i++ {
+		blockRoots[i] = zeroHash
+	}
+
+	stateRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
+	for i := 0; i < len(stateRoots); i++ {
+		stateRoots[i] = zeroHash
+	}
+
+	slashings := make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector)
+
+	genesisValidatorsRoot, err := stateutil.ValidatorRegistryRoot(preState.Validators())
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not hash tree root genesis validators %v", err)
+	}
+
+	prevEpochParticipation, err := preState.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currEpochParticipation, err := preState.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	scores, err := preState.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	tab, err := helpers.TotalActiveBalance(preState)
+	if err != nil {
+		return nil, err
+	}
+	st := &ethpb.BeaconStateElectra{
+		// Misc fields.
+		Slot:                  0,
+		GenesisTime:           genesisTime,
+		GenesisValidatorsRoot: genesisValidatorsRoot[:],
+
+		Fork: &ethpb.Fork{
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+			Epoch:           0,
+		},
+
+		// Validator registry fields.
+		Validators:                 preState.Validators(),
+		Balances:                   preState.Balances(),
+		PreviousEpochParticipation: prevEpochParticipation,
+		CurrentEpochParticipation:  currEpochParticipation,
+		InactivityScores:           scores,
+
+		// Randomness and committees.
+		RandaoMixes: randaoMixes,
+
+		// Finality.
+		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{
+			Epoch: 0,
+			Root:  params.BeaconConfig().ZeroHash[:],
+		},
+		CurrentJustifiedCheckpoint: &ethpb.Checkpoint{
+			Epoch: 0,
+			Root:  params.BeaconConfig().ZeroHash[:],
+		},
+		JustificationBits: []byte{0},
+		FinalizedCheckpoint: &ethpb.Checkpoint{
+			Epoch: 0,
+			Root:  params.BeaconConfig().ZeroHash[:],
+		},
+
+		HistoricalRoots: [][]byte{},
+		BlockRoots:      blockRoots,
+		StateRoots:      stateRoots,
+		Slashings:       slashings,
+
+		// Eth1 data.
+		Eth1Data:         eth1Data,
+		Eth1DataVotes:    []*ethpb.Eth1Data{},
+		Eth1DepositIndex: preState.Eth1DepositIndex(),
+
+		// Electra Data
+		DepositReceiptsStartIndex:     params.BeaconConfig().UnsetDepositReceiptsStartIndex,
+		ExitBalanceToConsume:          helpers.ActivationExitChurnLimit(math.Gwei(tab)),
+		EarliestConsolidationEpoch:    helpers.ActivationExitEpoch(slots.ToEpoch(preState.Slot())),
+		ConsolidationBalanceToConsume: helpers.ConsolidationChurnLimit(math.Gwei(tab)),
+		PendingBalanceDeposits:        make([]*ethpb.PendingBalanceDeposit, 0),
+		PendingPartialWithdrawals:     make([]*ethpb.PendingPartialWithdrawal, 0),
+		PendingConsolidations:         make([]*ethpb.PendingConsolidation, 0),
+	}
+
+	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
+	bodyRoot, err := (&ethpb.BeaconBlockBodyElectra{
+		RandaoReveal: make([]byte, 96),
+		Eth1Data: &ethpb.Eth1Data{
+			DepositRoot: make([]byte, 32),
+			BlockHash:   make([]byte, 32),
+		},
+		Graffiti: make([]byte, 32),
+		SyncAggregate: &ethpb.SyncAggregate{
+			SyncCommitteeBits:      scBits[:],
+			SyncCommitteeSignature: make([]byte, 96),
+		},
+		ExecutionPayload: &enginev1.ExecutionPayloadElectra{
+			ParentHash:         make([]byte, 32),
+			FeeRecipient:       make([]byte, 20),
+			StateRoot:          make([]byte, 32),
+			ReceiptsRoot:       make([]byte, 32),
+			LogsBloom:          make([]byte, 256),
+			PrevRandao:         make([]byte, 32),
+			ExtraData:          make([]byte, 0),
+			BaseFeePerGas:      make([]byte, 32),
+			BlockHash:          make([]byte, 32),
+			Transactions:       make([][]byte, 0),
+			Withdrawals:        make([]*enginev1.Withdrawal, 0),
+			DepositReceipts:    make([]*enginev1.DepositReceipt, 0),
+			WithdrawalRequests: make([]*enginev1.ExecutionLayerWithdrawalRequest, 0),
+		},
+	}).HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not hash tree root empty block body")
+	}
+
+	st.LatestBlockHeader = &ethpb.BeaconBlockHeader{
+		ParentRoot: zeroHash,
+		StateRoot:  zeroHash,
+		BodyRoot:   bodyRoot[:],
+	}
+
+	var pubKeys [][]byte
+	vals := preState.Validators()
+	for i := uint64(0); i < params.BeaconConfig().SyncCommitteeSize; i++ {
+		j := i % uint64(len(vals))
+		pubKeys = append(pubKeys, vals[j].PublicKey)
+	}
+	aggregated, err := bls.AggregatePublicKeys(pubKeys)
+	if err != nil {
+		return nil, err
+	}
+	st.CurrentSyncCommittee = &ethpb.SyncCommittee{
+		Pubkeys:         pubKeys,
+		AggregatePubkey: aggregated.Marshal(),
+	}
+	st.NextSyncCommittee = &ethpb.SyncCommittee{
+		Pubkeys:         pubKeys,
+		AggregatePubkey: aggregated.Marshal(),
+	}
+
+	st.LatestExecutionPayloadHeader = &enginev1.ExecutionPayloadHeaderElectra{
+		ParentHash:             make([]byte, 32),
+		FeeRecipient:           make([]byte, 20),
+		StateRoot:              make([]byte, 32),
+		ReceiptsRoot:           make([]byte, 32),
+		LogsBloom:              make([]byte, 256),
+		PrevRandao:             make([]byte, 32),
+		ExtraData:              make([]byte, 0),
+		BaseFeePerGas:          make([]byte, 32),
+		BlockHash:              make([]byte, 32),
+		TransactionsRoot:       make([]byte, 32),
+		WithdrawalsRoot:        make([]byte, 32),
+		DepositReceiptsRoot:    make([]byte, 32),
+		WithdrawalRequestsRoot: make([]byte, 32),
+	}
+
+	return state_native.InitializeFromProtoElectra(st)
+}