Ignore nil cs (#13990)

Add has_compounding_withdrawal_credential helper

Progress

Tuesday night progress

Thursday night progress

Sunday afternoon progress

Tuesday progress

Monday night progress: tests are passing

Progress from last week, mostly on state

monday night progress: had to refactor a lot of tests to be blackbox tests

tuesday progress

wednesday progress

thursday progress

Friday progress

Monday progress

Fix up eip-7251 branch, fix issues, update to spec v1.5.0-alpha.0

More updates to spec 1.5.0-alpha.0, refactorings

Prepping for spectests

WIP: Electra beacon state HTR

Progress on custom HTR for beaconStateElectra

Rename eip7251 package to electra package

Working on beacon state changes and cleanup

Fix TestGetSpec

Fix ExpectedWithdrawals

Electra: full beacon config

Fixing conflicts

Resolve rebasing conflicts

Resolve rebasing conflicts

Update spectest to v1.5.0-alpha.1

Add PeerDAS config change

Fix API changes from beacon state PR

.buildkite-bazelrc

@@ -12,8 +12,7 @@
 build:remote-cache --remote_download_minimal
 build:remote-cache --remote_build_event_upload=minimal
 build:remote-cache --remote_cache=grpc://bazel-remote-cache:9092
-# Does not work with rules_oci. See https://github.com/bazel-contrib/rules_oci/issues/292
-#build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
+build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
 build:remote-cache --remote_local_fallback
 build:remote-cache --experimental_remote_cache_async
 build:remote-cache --experimental_remote_merkle_tree_cache

WORKSPACE

@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.0"
+consensus_spec_version = "v1.5.0-alpha.2"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "33c5547772b6d8d6f041dff7e7d26b0358c2392daed34394a3aa81147812a81c",
+    integrity = "sha256-NNXBa7SZ2sFb68HPNahgu1p0yDBpjuKJuLfRCl7vvoQ=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -259,7 +259,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "06f286199cf2fedd4700487fb8feb0904e0ae18daaa4b3f70ea430ca9c388167",
+    integrity = "sha256-7BnlBvGWU92iAB100cMaAXVQhRrqpMQbavgrI+/paCw=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -275,7 +275,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "5f2a4452b323075eba6bf950003f7d91fd04ebcbde5bd087beafb5d6f6325ad4",
+    integrity = "sha256-VCHhcNt+fynf/sHK11qbRBAy608u9T1qAafvAGfxQhA=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -290,7 +290,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "fd7e83e8cbeb3e297f2aeb93776305f7d606272c97834d8d9be673984501ed36",
+    integrity = "sha256-a2aCNFyFkYLtf6QSwGOHdx7xXHjA2NNT8x8ZuxB0aes=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/client/beacon/health.go

@@ -36,19 +36,19 @@ func (n *NodeHealthTracker) IsHealthy() bool {
 }
 
 func (n *NodeHealthTracker) CheckHealth(ctx context.Context) bool {
-	n.RLock()
+	n.Lock()
+	defer n.Unlock()
+
 	newStatus := n.node.IsHealthy(ctx)
 	if n.isHealthy == nil {
 		n.isHealthy = &newStatus
 	}
-	isStatusChanged := newStatus != *n.isHealthy
-	n.RUnlock()
 
+	isStatusChanged := newStatus != *n.isHealthy
 	if isStatusChanged {
-		n.Lock()
-		// Double-check the condition to ensure it hasn't changed since the first check.
+		// Update the health status
 		n.isHealthy = &newStatus
-		n.Unlock() // It's better to unlock as soon as the protected section is over.
+		// Send the new status to the health channel
 		n.healthChan <- newStatus
 	}
 	return newStatus

api/client/beacon/health_test.go

@@ -99,9 +99,9 @@ func TestNodeHealth_Concurrency(t *testing.T) {
 	for i := 0; i < numGoroutines; i++ {
 		go func() {
 			defer wg.Done()
-			client.EXPECT().IsHealthy(gomock.Any()).Return(false)
+			client.EXPECT().IsHealthy(gomock.Any()).Return(false).Times(1)
 			n.CheckHealth(context.Background())
-			client.EXPECT().IsHealthy(gomock.Any()).Return(true)
+			client.EXPECT().IsHealthy(gomock.Any()).Return(true).Times(1)
 			n.CheckHealth(context.Background())
 		}()
 	}

api/client/builder/bid.go

@@ -6,6 +6,7 @@ import (
 	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
@@ -22,7 +23,7 @@ type SignedBid interface {
 type Bid interface {
 	Header() (interfaces.ExecutionData, error)
 	BlobKzgCommitments() ([][]byte, error)
-	Value() []byte
+	Value() primitives.Wei
 	Pubkey() []byte
 	Version() int
 	IsNil() bool
@@ -125,8 +126,8 @@ func (b builderBid) Version() int {
 }
 
 // Value --
-func (b builderBid) Value() []byte {
-	return b.p.Value
+func (b builderBid) Value() primitives.Wei {
+	return primitives.LittleEndianBytesToWei(b.p.Value)
 }
 
 // Pubkey --
@@ -165,7 +166,7 @@ func WrappedBuilderBidCapella(p *ethpb.BuilderBidCapella) (Bid, error) {
 // Header returns the execution data interface.
 func (b builderBidCapella) Header() (interfaces.ExecutionData, error) {
 	// We have to convert big endian to little endian because the value is coming from the execution layer.
-	return blocks.WrappedExecutionPayloadHeaderCapella(b.p.Header, blocks.PayloadValueToWei(b.p.Value))
+	return blocks.WrappedExecutionPayloadHeaderCapella(b.p.Header)
 }
 
 // BlobKzgCommitments --
@@ -179,8 +180,8 @@ func (b builderBidCapella) Version() int {
 }
 
 // Value --
-func (b builderBidCapella) Value() []byte {
-	return b.p.Value
+func (b builderBidCapella) Value() primitives.Wei {
+	return primitives.LittleEndianBytesToWei(b.p.Value)
 }
 
 // Pubkey --
@@ -222,8 +223,8 @@ func (b builderBidDeneb) Version() int {
 }
 
 // Value --
-func (b builderBidDeneb) Value() []byte {
-	return b.p.Value
+func (b builderBidDeneb) Value() primitives.Wei {
+	return primitives.LittleEndianBytesToWei(b.p.Value)
 }
 
 // Pubkey --
@@ -249,7 +250,7 @@ func (b builderBidDeneb) HashTreeRootWith(hh *ssz.Hasher) error {
 // Header --
 func (b builderBidDeneb) Header() (interfaces.ExecutionData, error) {
 	// We have to convert big endian to little endian because the value is coming from the execution layer.
-	return blocks.WrappedExecutionPayloadHeaderDeneb(b.p.Header, blocks.PayloadValueToWei(b.p.Value))
+	return blocks.WrappedExecutionPayloadHeaderDeneb(b.p.Header)
 }
 
 // BlobKzgCommitments --

api/client/builder/client.go

@@ -330,7 +330,7 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 	if err != nil {
 		return nil, nil, err
 	}
-	ed, err := blocks.NewWrappedExecutionData(pb, nil)
+	ed, err := blocks.NewWrappedExecutionData(pb)
 	if err != nil {
 		return nil, nil, err
 	}

api/client/builder/client_test.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"math/big"
 	"net/http"
 	"net/url"
 	"strconv"
@@ -16,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	types "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
@@ -198,12 +198,12 @@ func TestClient_GetHeader(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, true, bytes.Equal(expectedTxRoot, withdrawalsRoot))
 		require.Equal(t, uint64(1), bidHeader.GasUsed())
-		value, err := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+		// this matches the value in the testExampleHeaderResponse
+		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
+		value, err := stringToUint256(bidStr)
 		require.NoError(t, err)
-		require.Equal(t, fmt.Sprintf("%#x", value.SSZBytes()), fmt.Sprintf("%#x", bid.Value()))
-		bidValue := bytesutil.ReverseByteOrder(bid.Value())
-		require.DeepEqual(t, bidValue, value.Bytes())
-		require.DeepEqual(t, big.NewInt(0).SetBytes(bidValue), value.Int)
+		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
+		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
 	})
 	t.Run("capella", func(t *testing.T) {
 		hc := &http.Client{
@@ -230,12 +230,11 @@ func TestClient_GetHeader(t *testing.T) {
 		withdrawalsRoot, err := bidHeader.WithdrawalsRoot()
 		require.NoError(t, err)
 		require.Equal(t, true, bytes.Equal(expectedWithdrawalsRoot, withdrawalsRoot))
-		value, err := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
+		value, err := stringToUint256(bidStr)
 		require.NoError(t, err)
-		require.Equal(t, fmt.Sprintf("%#x", value.SSZBytes()), fmt.Sprintf("%#x", bid.Value()))
-		bidValue := bytesutil.ReverseByteOrder(bid.Value())
-		require.DeepEqual(t, bidValue, value.Bytes())
-		require.DeepEqual(t, big.NewInt(0).SetBytes(bidValue), value.Int)
+		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
+		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
 	})
 	t.Run("deneb", func(t *testing.T) {
 		hc := &http.Client{
@@ -262,12 +261,13 @@ func TestClient_GetHeader(t *testing.T) {
 		withdrawalsRoot, err := bidHeader.WithdrawalsRoot()
 		require.NoError(t, err)
 		require.Equal(t, true, bytes.Equal(expectedWithdrawalsRoot, withdrawalsRoot))
-		value, err := stringToUint256("652312848583266388373324160190187140051835877600158453279131187530910662656")
+
+		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
+		value, err := stringToUint256(bidStr)
 		require.NoError(t, err)
-		require.Equal(t, fmt.Sprintf("%#x", value.SSZBytes()), fmt.Sprintf("%#x", bid.Value()))
-		bidValue := bytesutil.ReverseByteOrder(bid.Value())
-		require.DeepEqual(t, bidValue, value.Bytes())
-		require.DeepEqual(t, big.NewInt(0).SetBytes(bidValue), value.Int)
+		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
+		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
+
 		kcgCommitments, err := bid.BlobKzgCommitments()
 		require.NoError(t, err)
 		require.Equal(t, len(kcgCommitments) > 0, true)

api/client/builder/types.go

@@ -156,6 +156,8 @@ func (bb *BuilderBid) ToProto() (*eth.BuilderBid, error) {
 	}
 	return &eth.BuilderBid{
 		Header: header,
+		// Note that SSZBytes() reverses byte order for the little-endian representation.
+		// Uint256.Bytes() is big-endian, SSZBytes takes this value and reverses it.
 		Value:  bb.Value.SSZBytes(),
 		Pubkey: bb.Pubkey,
 	}, nil
@@ -484,6 +486,8 @@ func (bb *BuilderBidCapella) ToProto() (*eth.BuilderBidCapella, error) {
 	}
 	return &eth.BuilderBidCapella{
 		Header: header,
+		// Note that SSZBytes() reverses byte order for the little-endian representation.
+		// Uint256.Bytes() is big-endian, SSZBytes takes this value and reverses it.
 		Value:  bytesutil.SafeCopyBytes(bb.Value.SSZBytes()),
 		Pubkey: bytesutil.SafeCopyBytes(bb.Pubkey),
 	}, nil
@@ -1022,8 +1026,10 @@ func (bb *BuilderBidDeneb) ToProto() (*eth.BuilderBidDeneb, error) {
 	return &eth.BuilderBidDeneb{
 		Header:             header,
 		BlobKzgCommitments: kzgCommitments,
-		Value:              bytesutil.SafeCopyBytes(bb.Value.SSZBytes()),
-		Pubkey:             bytesutil.SafeCopyBytes(bb.Pubkey),
+		// Note that SSZBytes() reverses byte order for the little-endian representation.
+		// Uint256.Bytes() is big-endian, SSZBytes takes this value and reverses it.
+		Value:  bytesutil.SafeCopyBytes(bb.Value.SSZBytes()),
+		Pubkey: bytesutil.SafeCopyBytes(bb.Pubkey),
 	}, nil
 }
 

api/constants.go

@@ -4,6 +4,6 @@ const (
 	WebUrlPrefix        = "/v2/validator/"
 	WebApiUrlPrefix     = "/api/v2/validator/"
 	KeymanagerApiPrefix = "/eth/v1"
-
-	AuthTokenFileName = "auth-token"
+	SystemLogsPrefix    = "health/logs"
+	AuthTokenFileName   = "auth-token"
 )

beacon-chain/blockchain/execution_engine.go

@@ -325,7 +325,7 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 	var attr payloadattribute.Attributer
 	switch st.Version() {
 	case version.Deneb:
-		withdrawals, err := st.ExpectedWithdrawals()
+		withdrawals, _, err := st.ExpectedWithdrawals()
 		if err != nil {
 			log.WithError(err).Error("Could not get expected withdrawals to get payload attribute")
 			return emptyAttri
@@ -342,7 +342,7 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 			return emptyAttri
 		}
 	case version.Capella:
-		withdrawals, err := st.ExpectedWithdrawals()
+		withdrawals, _, err := st.ExpectedWithdrawals()
 		if err != nil {
 			log.WithError(err).Error("Could not get expected withdrawals to get payload attribute")
 			return emptyAttri

beacon-chain/blockchain/head_test.go

@@ -13,7 +13,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
@@ -313,7 +312,7 @@ func TestSaveOrphanedAtts(t *testing.T) {
 
 	require.NoError(t, service.saveOrphanedOperations(ctx, r3, r4))
 	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []interfaces.Attestation{
+	wantAtts := []ethpb.Att{
 		blk3.Block.Body.Attestations[0],
 		blk2.Block.Body.Attestations[0],
 		blk1.Block.Body.Attestations[0],
@@ -390,7 +389,7 @@ func TestSaveOrphanedOps(t *testing.T) {
 
 	require.NoError(t, service.saveOrphanedOperations(ctx, r3, r4))
 	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []interfaces.Attestation{
+	wantAtts := []ethpb.Att{
 		blk3.Block.Body.Attestations[0],
 		blk2.Block.Body.Attestations[0],
 		blk1.Block.Body.Attestations[0],
@@ -518,7 +517,7 @@ func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
 
 	require.NoError(t, service.saveOrphanedOperations(ctx, r3, r4))
 	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []interfaces.Attestation{
+	wantAtts := []ethpb.Att{
 		blk3.Block.Body.Attestations[0],
 		blk2.Block.Body.Attestations[0],
 		blk1.Block.Body.Attestations[0],

beacon-chain/blockchain/process_attestation.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
@@ -37,7 +36,7 @@ import (
 //
 //	 # Update latest messages for attesting indices
 //	 update_latest_messages(store, indexed_attestation.attesting_indices, attestation)
-func (s *Service) OnAttestation(ctx context.Context, a interfaces.Attestation, disparity time.Duration) error {
+func (s *Service) OnAttestation(ctx context.Context, a ethpb.Att, disparity time.Duration) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onAttestation")
 	defer span.End()
 

beacon-chain/blockchain/process_attestation_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"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/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -74,7 +73,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 
 	tests := []struct {
 		name      string
-		a         interfaces.Attestation
+		a         ethpb.Att
 		wantedErr string
 	}{
 		{

beacon-chain/blockchain/process_block.go

@@ -370,7 +370,7 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Re
 		if err != nil {
 			return err
 		}
-		indices, err := attestation.AttestingIndices(a.GetAggregationBits(), committee)
+		indices, err := attestation.AttestingIndices(a, committee)
 		if err != nil {
 			return err
 		}
@@ -387,7 +387,7 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Re
 // InsertSlashingsToForkChoiceStore inserts attester slashing indices to fork choice store.
 // To call this function, it's caller's responsibility to ensure the slashing object is valid.
 // This function requires a write lock on forkchoice.
-func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashings []interfaces.AttesterSlashing) {
+func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashings []ethpb.AttSlashing) {
 	for _, slashing := range slashings {
 		indices := blocks.SlashableAttesterIndices(slashing)
 		for _, index := range indices {

beacon-chain/blockchain/process_block_test.go

@@ -824,7 +824,7 @@ func TestRemoveBlockAttestationsInPool(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: r[:]}))
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, r))
 
-	atts := make([]interfaces.Attestation, len(b.Block.Body.Attestations))
+	atts := make([]ethpb.Att, len(b.Block.Body.Attestations))
 	for i, a := range b.Block.Body.Attestations {
 		atts[i] = a
 	}

beacon-chain/blockchain/receive_attestation.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"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/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -32,7 +31,7 @@ type AttestationStateFetcher interface {
 // AttestationReceiver interface defines the methods of chain service receive and processing new attestations.
 type AttestationReceiver interface {
 	AttestationStateFetcher
-	VerifyLmdFfgConsistency(ctx context.Context, att interfaces.Attestation) error
+	VerifyLmdFfgConsistency(ctx context.Context, att ethpb.Att) error
 	InForkchoice([32]byte) bool
 }
 
@@ -52,7 +51,7 @@ func (s *Service) AttestationTargetState(ctx context.Context, target *ethpb.Chec
 }
 
 // VerifyLmdFfgConsistency verifies that attestation's LMD and FFG votes are consistency to each other.
-func (s *Service) VerifyLmdFfgConsistency(ctx context.Context, a interfaces.Attestation) error {
+func (s *Service) VerifyLmdFfgConsistency(ctx context.Context, a ethpb.Att) error {
 	r, err := s.TargetRootForEpoch([32]byte(a.GetData().BeaconBlockRoot), a.GetData().Target.Epoch)
 	if err != nil {
 		return err
@@ -207,7 +206,7 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 //  1. Validate attestation, update validator's latest vote
 //  2. Apply fork choice to the processed attestation
 //  3. Save latest head info
-func (s *Service) receiveAttestationNoPubsub(ctx context.Context, att interfaces.Attestation, disparity time.Duration) error {
+func (s *Service) receiveAttestationNoPubsub(ctx context.Context, att ethpb.Att, disparity time.Duration) error {
 	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.receiveAttestationNoPubsub")
 	defer span.End()
 

beacon-chain/blockchain/receive_attestation_test.go

@@ -10,7 +10,6 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -84,7 +83,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	attsToSave := make([]interfaces.Attestation, len(atts))
+	attsToSave := make([]ethpb.Att, len(atts))
 	for i, a := range atts {
 		attsToSave[i] = a
 	}
@@ -126,7 +125,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	// Generate attestations for this block in Slot 1
 	atts, err := util.GenerateAttestations(copied, pks, 1, 1, false)
 	require.NoError(t, err)
-	attsToSave := make([]interfaces.Attestation, len(atts))
+	attsToSave := make([]ethpb.Att, len(atts))
 	for i, a := range atts {
 		attsToSave[i] = a
 	}

beacon-chain/blockchain/receive_block.go

@@ -52,7 +52,7 @@ type BlobReceiver interface {
 
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
-	ReceiveAttesterSlashing(ctx context.Context, slashing interfaces.AttesterSlashing)
+	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)
 }
 
 // ReceiveBlock is a function that defines the operations (minus pubsub)
@@ -295,10 +295,10 @@ func (s *Service) HasBlock(ctx context.Context, root [32]byte) bool {
 }
 
 // ReceiveAttesterSlashing receives an attester slashing and inserts it to forkchoice
-func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing interfaces.AttesterSlashing) {
+func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing) {
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	s.InsertSlashingsToForkChoiceStore(ctx, []interfaces.AttesterSlashing{slashing})
+	s.InsertSlashingsToForkChoiceStore(ctx, []ethpb.AttSlashing{slashing})
 }
 
 // prunePostBlockOperationPools only runs on new head otherwise should return a nil.

beacon-chain/blockchain/setup_test.go

@@ -20,7 +20,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"google.golang.org/protobuf/proto"
@@ -50,7 +49,7 @@ func (mb *mockBroadcaster) Broadcast(_ context.Context, _ proto.Message) error {
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ interfaces.Attestation) error {
+func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ ethpb.Att) error {
 	mb.broadcastCalled = true
 	return nil
 }

beacon-chain/blockchain/testing/mock.go

@@ -414,7 +414,7 @@ func (*ChainService) HeadGenesisValidatorsRoot() [32]byte {
 }
 
 // VerifyLmdFfgConsistency mocks VerifyLmdFfgConsistency and always returns nil.
-func (*ChainService) VerifyLmdFfgConsistency(_ context.Context, a interfaces.Attestation) error {
+func (*ChainService) VerifyLmdFfgConsistency(_ context.Context, a ethpb.Att) error {
 	if !bytes.Equal(a.GetData().BeaconBlockRoot, a.GetData().Target.Root) {
 		return errors.New("LMD and FFG miss matched")
 	}
@@ -495,7 +495,7 @@ func (s *ChainService) UpdateHead(ctx context.Context, slot primitives.Slot) {
 }
 
 // ReceiveAttesterSlashing mocks the same method in the chain service.
-func (*ChainService) ReceiveAttesterSlashing(context.Context, interfaces.AttesterSlashing) {}
+func (*ChainService) ReceiveAttesterSlashing(context.Context, ethpb.AttSlashing) {}
 
 // IsFinalized mocks the same method in the chain service.
 func (s *ChainService) IsFinalized(_ context.Context, blockRoot [32]byte) bool {

beacon-chain/builder/testing/mock.go

@@ -2,7 +2,6 @@ package testing
 
 import (
 	"context"
-	"math/big"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/client/builder"
@@ -29,6 +28,7 @@ type MockBuilderService struct {
 	Payload               *v1.ExecutionPayload
 	PayloadCapella        *v1.ExecutionPayloadCapella
 	PayloadDeneb          *v1.ExecutionPayloadDeneb
+	PayloadElectra        *v1.ExecutionPayloadElectra
 	BlobBundle            *v1.BlobsBundle
 	ErrSubmitBlindedBlock error
 	Bid                   *ethpb.SignedBuilderBid
@@ -55,17 +55,23 @@ func (s *MockBuilderService) SubmitBlindedBlock(_ context.Context, b interfaces.
 		}
 		return w, nil, s.ErrSubmitBlindedBlock
 	case version.Capella:
-		w, err := blocks.WrappedExecutionPayloadCapella(s.PayloadCapella, big.NewInt(0))
+		w, err := blocks.WrappedExecutionPayloadCapella(s.PayloadCapella)
 		if err != nil {
 			return nil, nil, errors.Wrap(err, "could not wrap capella payload")
 		}
 		return w, nil, s.ErrSubmitBlindedBlock
 	case version.Deneb:
-		w, err := blocks.WrappedExecutionPayloadDeneb(s.PayloadDeneb, big.NewInt(0))
+		w, err := blocks.WrappedExecutionPayloadDeneb(s.PayloadDeneb)
 		if err != nil {
 			return nil, nil, errors.Wrap(err, "could not wrap deneb payload")
 		}
 		return w, s.BlobBundle, s.ErrSubmitBlindedBlock
+	case version.Electra:
+		w, err := blocks.WrappedExecutionPayloadElectra(s.PayloadElectra)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "could not wrap electra payload")
+		}
+		return w, s.BlobBundle, s.ErrSubmitBlindedBlock
 	default:
 		return nil, nil, errors.New("unknown block version for mocking")
 	}

beacon-chain/core/altair/attestation.go

@@ -48,7 +48,7 @@ func ProcessAttestationsNoVerifySignature(
 func ProcessAttestationNoVerifySignature(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	att interfaces.Attestation,
+	att ethpb.Att,
 	totalBalance uint64,
 ) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "altair.ProcessAttestationNoVerifySignature")
@@ -70,7 +70,7 @@ func ProcessAttestationNoVerifySignature(
 	if err != nil {
 		return nil, err
 	}
-	indices, err := attestation.AttestingIndices(att.GetAggregationBits(), committee)
+	indices, err := attestation.AttestingIndices(att, committee)
 	if err != nil {
 		return nil, err
 	}

beacon-chain/core/altair/attestation_test.go

@@ -215,7 +215,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, att.Data.CommitteeIndex)
 	require.NoError(t, err)
-	attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
+	attestingIndices, err := attestation.AttestingIndices(att, committee)
 	require.NoError(t, err)
 	sigs := make([]bls.Signature, len(attestingIndices))
 	for i, indice := range attestingIndices {
@@ -273,7 +273,7 @@ func TestProcessAttestationNoVerify_SourceTargetHead(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, att.Data.CommitteeIndex)
 	require.NoError(t, err)
-	indices, err := attestation.AttestingIndices(att.AggregationBits, committee)
+	indices, err := attestation.AttestingIndices(att, committee)
 	require.NoError(t, err)
 	for _, index := range indices {
 		has, err := altair.HasValidatorFlag(p[index], params.BeaconConfig().TimelyHeadFlagIndex)

beacon-chain/core/altair/upgrade.go

@@ -158,7 +158,7 @@ func TranslateParticipation(ctx context.Context, state state.BeaconState, atts [
 		if err != nil {
 			return nil, err
 		}
-		indices, err := attestation.AttestingIndices(att.AggregationBits, committee)
+		indices, err := attestation.AttestingIndices(att, committee)
 		if err != nil {
 			return nil, err
 		}

beacon-chain/core/altair/upgrade_test.go

@@ -55,7 +55,7 @@ func TestTranslateParticipation(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(ctx, s, pendingAtts[0].Data.Slot, pendingAtts[0].Data.CommitteeIndex)
 	require.NoError(t, err)
-	indices, err := attestation.AttestingIndices(pendingAtts[0].AggregationBits, committee)
+	indices, err := attestation.AttestingIndices(pendingAtts[0], committee)
 	require.NoError(t, err)
 	for _, index := range indices {
 		has, err := altair.HasValidatorFlag(participation[index], params.BeaconConfig().TimelySourceFlagIndex)

beacon-chain/core/blocks/attestation.go

@@ -46,7 +46,7 @@ func ProcessAttestationsNoVerifySignature(
 func VerifyAttestationNoVerifySignature(
 	ctx context.Context,
 	beaconState state.ReadOnlyBeaconState,
-	att interfaces.Attestation,
+	att ethpb.Att,
 ) error {
 	ctx, span := trace.StartSpan(ctx, "core.VerifyAttestationNoVerifySignature")
 	defer span.End()
@@ -107,22 +107,53 @@ func VerifyAttestationNoVerifySignature(
 		return err
 	}
 	c := helpers.SlotCommitteeCount(activeValidatorCount)
-	if uint64(att.GetData().CommitteeIndex) >= c {
-		return fmt.Errorf("committee index %d >= committee count %d", att.GetData().CommitteeIndex, c)
-	}
 
-	if err := helpers.VerifyAttestationBitfieldLengths(ctx, beaconState, att); err != nil {
-		return errors.Wrap(err, "could not verify attestation bitfields")
-	}
+	var indexedAtt ethpb.IndexedAtt
 
-	// Verify attesting indices are correct.
-	committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
-	if err != nil {
-		return err
-	}
-	indexedAtt, err := attestation.ConvertToIndexed(ctx, att, committee)
-	if err != nil {
-		return err
+	if att.Version() < version.Electra {
+		if uint64(att.GetData().CommitteeIndex) >= c {
+			return fmt.Errorf("committee index %d >= committee count %d", att.GetData().CommitteeIndex, c)
+		}
+
+		if err = helpers.VerifyAttestationBitfieldLengths(ctx, beaconState, att); err != nil {
+			return errors.Wrap(err, "could not verify attestation bitfields")
+		}
+
+		// Verify attesting indices are correct.
+		committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
+		if err != nil {
+			return err
+		}
+		indexedAtt, err = attestation.ConvertToIndexed(ctx, att, committee)
+		if err != nil {
+			return err
+		}
+	} else {
+		if att.GetData().CommitteeIndex != 0 {
+			return errors.New("committee index must be 0 post-Electra")
+		}
+
+		committeeIndices := att.CommitteeBitsVal().BitIndices()
+		committees := make([][]primitives.ValidatorIndex, len(committeeIndices))
+		participantsCount := 0
+		var err error
+		for i, ci := range committeeIndices {
+			if uint64(ci) >= c {
+				return fmt.Errorf("committee index %d >= committee count %d", ci, c)
+			}
+			committees[i], err = helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, primitives.CommitteeIndex(ci))
+			if err != nil {
+				return err
+			}
+			participantsCount += len(committees[i])
+		}
+		if att.GetAggregationBits().Len() != uint64(participantsCount) {
+			return fmt.Errorf("aggregation bits count %d is different than participant count %d", att.GetAggregationBits().Len(), participantsCount)
+		}
+		indexedAtt, err = attestation.ConvertToIndexed(ctx, att, committees...)
+		if err != nil {
+			return err
+		}
 	}
 
 	return attestation.IsValidAttestationIndices(ctx, indexedAtt)
@@ -133,7 +164,7 @@ func VerifyAttestationNoVerifySignature(
 func ProcessAttestationNoVerifySignature(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	att interfaces.Attestation,
+	att ethpb.Att,
 ) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.ProcessAttestationNoVerifySignature")
 	defer span.End()
@@ -171,7 +202,7 @@ func ProcessAttestationNoVerifySignature(
 
 // VerifyAttestationSignature converts and attestation into an indexed attestation and verifies
 // the signature in that attestation.
-func VerifyAttestationSignature(ctx context.Context, beaconState state.ReadOnlyBeaconState, att interfaces.Attestation) error {
+func VerifyAttestationSignature(ctx context.Context, beaconState state.ReadOnlyBeaconState, att ethpb.Att) error {
 	if err := helpers.ValidateNilAttestation(att); err != nil {
 		return err
 	}

beacon-chain/core/blocks/attestation_test.go

@@ -11,7 +11,6 @@ import (
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"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/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -45,7 +44,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
 	require.NoError(t, err)
-	attestingIndices1, err := attestation.AttestingIndices(att1.AggregationBits, committee)
+	attestingIndices1, err := attestation.AttestingIndices(att1, committee)
 	require.NoError(t, err)
 	sigs := make([]bls.Signature, len(attestingIndices1))
 	for i, indice := range attestingIndices1 {
@@ -67,7 +66,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 
 	committee, err = helpers.BeaconCommitteeFromState(context.Background(), beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
 	require.NoError(t, err)
-	attestingIndices2, err := attestation.AttestingIndices(att2.AggregationBits, committee)
+	attestingIndices2, err := attestation.AttestingIndices(att2, committee)
 	require.NoError(t, err)
 	sigs = make([]bls.Signature, len(attestingIndices2))
 	for i, indice := range attestingIndices2 {
@@ -222,6 +221,83 @@ func TestVerifyAttestationNoVerifySignature_BadAttIdx(t *testing.T) {
 	require.ErrorContains(t, "committee index 100 >= committee count 1", err)
 }
 
+func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
+	var mockRoot [32]byte
+	copy(mockRoot[:], "hello-world")
+	var zeroSig [fieldparams.BLSSignatureLength]byte
+
+	beaconState, _ := util.DeterministicGenesisState(t, 100)
+	err := beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
+	require.NoError(t, err)
+	ckp := beaconState.CurrentJustifiedCheckpoint()
+	copy(ckp.Root, "hello-world")
+	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(ckp))
+	require.NoError(t, beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{}))
+
+	t.Run("ok", func(t *testing.T) {
+		aggBits := bitfield.NewBitlist(3)
+		aggBits.SetBitAt(1, true)
+		committeeBits := bitfield.NewBitvector64()
+		committeeBits.SetBitAt(0, true)
+		att := &ethpb.AttestationElectra{
+			Data: &ethpb.AttestationData{
+				Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			},
+			AggregationBits: aggBits,
+			CommitteeBits:   committeeBits,
+		}
+		att.Signature = zeroSig[:]
+		err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
+		assert.NoError(t, err)
+	})
+	t.Run("non-zero committee index", func(t *testing.T) {
+		att := &ethpb.AttestationElectra{
+			Data: &ethpb.AttestationData{
+				Source:         &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+				Target:         &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+				CommitteeIndex: 1,
+			},
+			AggregationBits: bitfield.NewBitlist(1),
+			CommitteeBits:   bitfield.NewBitvector64(),
+		}
+		err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
+		assert.ErrorContains(t, "committee index must be 0 post-Electra", err)
+	})
+	t.Run("index of committee too big", func(t *testing.T) {
+		aggBits := bitfield.NewBitlist(3)
+		committeeBits := bitfield.NewBitvector64()
+		committeeBits.SetBitAt(63, true)
+		att := &ethpb.AttestationElectra{
+			Data: &ethpb.AttestationData{
+				Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			},
+			AggregationBits: aggBits,
+			CommitteeBits:   committeeBits,
+		}
+		att.Signature = zeroSig[:]
+		err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
+		assert.ErrorContains(t, "committee index 63 >= committee count 1", err)
+	})
+	t.Run("wrong aggregation bits count", func(t *testing.T) {
+		aggBits := bitfield.NewBitlist(123)
+		committeeBits := bitfield.NewBitvector64()
+		committeeBits.SetBitAt(0, true)
+		att := &ethpb.AttestationElectra{
+			Data: &ethpb.AttestationData{
+				Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
+				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
+			},
+			AggregationBits: aggBits,
+			CommitteeBits:   committeeBits,
+		}
+		att.Signature = zeroSig[:]
+		err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
+		assert.ErrorContains(t, "aggregation bits count 123 is different than participant count 3", err)
+	})
+}
+
 func TestConvertToIndexed_OK(t *testing.T) {
 	helpers.ClearCache()
 	validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
@@ -387,7 +463,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 
 	sig := keys[0].Sign([]byte{'t', 'e', 's', 't'})
 	list := bitfield.Bitlist{0b11111}
-	var atts []interfaces.Attestation
+	var atts []ethpb.Att
 	for i := uint64(0); i < 1000; i++ {
 		atts = append(atts, &ethpb.Attestation{
 			Data: &ethpb.AttestationData{
@@ -403,7 +479,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	_, err := blocks.AttestationSignatureBatch(context.Background(), beaconState, atts)
 	assert.ErrorContains(t, want, err)
 
-	atts = []interfaces.Attestation{}
+	atts = []ethpb.Att{}
 	list = bitfield.Bitlist{0b10000}
 	for i := uint64(0); i < 1000; i++ {
 		atts = append(atts, &ethpb.Attestation{
@@ -544,7 +620,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	set, err := blocks.AttestationSignatureBatch(ctx, st, []interfaces.Attestation{att1, att2})
+	set, err := blocks.AttestationSignatureBatch(ctx, st, []ethpb.Att{att1, att2})
 	require.NoError(t, err)
 	verified, err := set.Verify()
 	require.NoError(t, err)
@@ -608,6 +684,6 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	_, err = blocks.AttestationSignatureBatch(ctx, st, []interfaces.Attestation{att1, att2})
+	_, err = blocks.AttestationSignatureBatch(ctx, st, []ethpb.Att{att1, att2})
 	require.NoError(t, err)
 }

beacon-chain/core/blocks/attester_slashing.go

@@ -7,14 +7,11 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"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/container/slice"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/slashings"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -41,7 +38,7 @@ import (
 func ProcessAttesterSlashings(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	slashings []interfaces.AttesterSlashing,
+	slashings []ethpb.AttSlashing,
 	slashFunc slashValidatorFunc,
 ) (state.BeaconState, error) {
 	var err error
@@ -58,7 +55,7 @@ func ProcessAttesterSlashings(
 func ProcessAttesterSlashing(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	slashing interfaces.AttesterSlashing,
+	slashing ethpb.AttSlashing,
 	slashFunc slashValidatorFunc,
 ) (state.BeaconState, error) {
 	if err := VerifyAttesterSlashing(ctx, beaconState, slashing); err != nil {
@@ -78,19 +75,7 @@ func ProcessAttesterSlashing(
 			return nil, err
 		}
 		if helpers.IsSlashableValidator(val.ActivationEpoch(), val.WithdrawableEpoch(), val.Slashed(), currentEpoch) {
-			cfg := params.BeaconConfig()
-			var slashingQuotient uint64
-			switch {
-			case beaconState.Version() == version.Phase0:
-				slashingQuotient = cfg.MinSlashingPenaltyQuotient
-			case beaconState.Version() == version.Altair:
-				slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
-			case beaconState.Version() >= version.Bellatrix:
-				slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
-			default:
-				return nil, errors.New("unknown state version")
-			}
-			beaconState, err = slashFunc(ctx, beaconState, primitives.ValidatorIndex(validatorIndex), slashingQuotient, cfg.ProposerRewardQuotient)
+			beaconState, err = slashFunc(ctx, beaconState, primitives.ValidatorIndex(validatorIndex))
 			if err != nil {
 				return nil, errors.Wrapf(err, "could not slash validator index %d",
 					validatorIndex)
@@ -105,18 +90,18 @@ func ProcessAttesterSlashing(
 }
 
 // VerifyAttesterSlashing validates the attestation data in both attestations in the slashing object.
-func VerifyAttesterSlashing(ctx context.Context, beaconState state.ReadOnlyBeaconState, slashing interfaces.AttesterSlashing) error {
+func VerifyAttesterSlashing(ctx context.Context, beaconState state.ReadOnlyBeaconState, slashing ethpb.AttSlashing) error {
 	if slashing == nil {
 		return errors.New("nil slashing")
 	}
-	if slashing.GetFirstAttestation() == nil || slashing.GetSecondAttestation() == nil {
+	if slashing.FirstAttestation() == nil || slashing.SecondAttestation() == nil {
 		return errors.New("nil attestation")
 	}
-	if slashing.GetFirstAttestation().GetData() == nil || slashing.GetSecondAttestation().GetData() == nil {
+	if slashing.FirstAttestation().GetData() == nil || slashing.SecondAttestation().GetData() == nil {
 		return errors.New("nil attestation data")
 	}
-	att1 := slashing.GetFirstAttestation()
-	att2 := slashing.GetSecondAttestation()
+	att1 := slashing.FirstAttestation()
+	att2 := slashing.SecondAttestation()
 	data1 := att1.GetData()
 	data2 := att2.GetData()
 	if !IsSlashableAttestationData(data1, data2) {
@@ -158,11 +143,11 @@ func IsSlashableAttestationData(data1, data2 *ethpb.AttestationData) bool {
 }
 
 // SlashableAttesterIndices returns the intersection of attester indices from both attestations in this slashing.
-func SlashableAttesterIndices(slashing interfaces.AttesterSlashing) []uint64 {
-	if slashing == nil || slashing.GetFirstAttestation() == nil || slashing.GetSecondAttestation() == nil {
+func SlashableAttesterIndices(slashing ethpb.AttSlashing) []uint64 {
+	if slashing == nil || slashing.FirstAttestation() == nil || slashing.SecondAttestation() == nil {
 		return nil
 	}
-	indices1 := slashing.GetFirstAttestation().GetAttestingIndices()
-	indices2 := slashing.GetSecondAttestation().GetAttestingIndices()
+	indices1 := slashing.FirstAttestation().GetAttestingIndices()
+	indices2 := slashing.SecondAttestation().GetAttestingIndices()
 	return slice.IntersectionUint64(indices1, indices2)
 }

beacon-chain/core/blocks/attester_slashing_test.go

@@ -9,7 +9,6 @@ import (
 	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	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/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -58,7 +57,7 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
 			AttesterSlashings: slashings,
 		},
 	}
-	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	ss := make([]ethpb.AttSlashing, len(b.Block.Body.AttesterSlashings))
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
@@ -97,7 +96,7 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
 		},
 	}
 
-	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	ss := make([]ethpb.AttSlashing, len(b.Block.Body.AttesterSlashings))
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
@@ -153,7 +152,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 		},
 	}
 
-	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	ss := make([]ethpb.AttSlashing, len(b.Block.Body.AttesterSlashings))
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
@@ -226,7 +225,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 		},
 	}
 
-	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	ss := make([]ethpb.AttSlashing, len(b.Block.Body.AttesterSlashings))
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
@@ -299,7 +298,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 		},
 	}
 
-	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	ss := make([]ethpb.AttSlashing, len(b.Block.Body.AttesterSlashings))
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
@@ -372,7 +371,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusCapella(t *testing.T) {
 		},
 	}
 
-	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	ss := make([]ethpb.AttSlashing, len(b.Block.Body.AttesterSlashings))
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -10,7 +10,6 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
@@ -217,7 +216,7 @@ func TestFuzzProcessAttesterSlashings_10000(t *testing.T) {
 		fuzzer.Fuzz(a)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		r, err := ProcessAttesterSlashings(ctx, s, []interfaces.AttesterSlashing{a}, v.SlashValidator)
+		r, err := ProcessAttesterSlashings(ctx, s, []ethpb.AttSlashing{a}, v.SlashValidator)
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and slashing: %v", r, err, state, a)
 		}

beacon-chain/core/blocks/block_regression_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
 	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	"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/bls"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -92,7 +91,7 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 		},
 	}
 
-	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	ss := make([]ethpb.AttSlashing, len(b.Block.Body.AttesterSlashings))
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}

beacon-chain/core/blocks/deposit.go

@@ -9,6 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/trie"
 	"github.com/prysmaticlabs/prysm/v5/contracts/deposit"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
@@ -136,26 +137,25 @@ func BatchVerifyDepositsSignatures(ctx context.Context, deposits []*ethpb.Deposi
 //
 //	pubkey = deposit.data.pubkey
 //	amount = deposit.data.amount
-//	validator_pubkeys = [v.pubkey for v in state.validators]
-//	if pubkey not in validator_pubkeys:
-//	    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
-//	    deposit_message = DepositMessage(
-//	        pubkey=deposit.data.pubkey,
-//	        withdrawal_credentials=deposit.data.withdrawal_credentials,
-//	        amount=deposit.data.amount,
-//	    )
-//	    domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
-//	    signing_root = compute_signing_root(deposit_message, domain)
-//	    if not bls.Verify(pubkey, signing_root, deposit.data.signature):
-//	        return
 //
-//	    # Add validator and balance entries
-//	    state.validators.append(get_validator_from_deposit(state, deposit))
-//	    state.balances.append(amount)
-//	else:
-//	    # Increase balance by deposit amount
-//	    index = ValidatorIndex(validator_pubkeys.index(pubkey))
-//	    increase_balance(state, index, amount)
+// TODO: This is apply_deposit, refactor to another function for readability.
+//
+//		validator_pubkeys = [v.pubkey for v in state.validators]
+//		if pubkey not in validator_pubkeys:
+//		    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//		    deposit_message = DepositMessage(
+//		        pubkey=deposit.data.pubkey,
+//		        withdrawal_credentials=deposit.data.withdrawal_credentials,
+//		        amount=deposit.data.amount,
+//		    )
+//		    domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
+//		    signing_root = compute_signing_root(deposit_message, domain)
+//	     if bls.Verify(pubkey, signing_root, signature):
+//	         add_validator_to_registry(state, pubkey, withdrawal_credentials, amount) // TODO: Missing spec def here
+//		else:
+//		    # Increase balance by deposit amount
+//		    index = ValidatorIndex(validator_pubkeys.index(pubkey))
+//		    state.pending_balance_deposits.append(PendingBalanceDeposit(index, amount)) # [Modified in EIP-7251]
 func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, bool, error) {
 	var newValidator bool
 	if err := verifyDeposit(beaconState, deposit); err != nil {
@@ -167,6 +167,7 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
 		return nil, newValidator, err
 	}
+	isElectraOrLater := beaconState.Fork() != nil && beaconState.Fork().Epoch >= params.BeaconConfig().ElectraForkEpoch
 	pubKey := deposit.Data.PublicKey
 	amount := deposit.Data.Amount
 	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
@@ -183,10 +184,16 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 			}
 		}
 
+		// NOTE: This is get_validator_from_deposit. There are changes in EIP-7251.
 		effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
 		if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
 			effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
 		}
+		if isElectraOrLater {
+			// In EIP-7251, the balance updates happen in the process_pending_balance_deposits method of
+			// the epoch transition function.
+			effectiveBalance = 0 // New in EIP-7251
+		}
 		if err := beaconState.AppendValidator(&ethpb.Validator{
 			PublicKey:                  pubKey,
 			WithdrawalCredentials:      deposit.Data.WithdrawalCredentials,
@@ -202,10 +209,24 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 		if err := beaconState.AppendBalance(amount); err != nil {
 			return nil, newValidator, err
 		}
-	} else if err := helpers.IncreaseBalance(beaconState, index, amount); err != nil {
-		return nil, newValidator, err
+		numVals := beaconState.NumValidators()
+		if numVals == 0 { // Cautiously prevent impossible underflow
+			return nil, false, errors.New("underflow: zero validators")
+		}
+		index = primitives.ValidatorIndex(numVals - 1)
+	} else {
+		if !isElectraOrLater {
+			if err := helpers.IncreaseBalance(beaconState, index, amount); err != nil {
+				return nil, newValidator, err
+			}
+		}
 	}
 
+	if isElectraOrLater {
+		if err := beaconState.AppendPendingBalanceDeposit(index, amount); err != nil {
+			return nil, newValidator, err
+		}
+	}
 	return beaconState, newValidator, nil
 }
 

beacon-chain/core/blocks/exit.go

@@ -40,6 +40,8 @@ var ValidatorCannotExitYetMsg = "validator has not been active long enough to ex
 //	 assert get_current_epoch(state) >= voluntary_exit.epoch
 //	 # Verify the validator has been active long enough
 //	 assert get_current_epoch(state) >= validator.activation_epoch + SHARD_COMMITTEE_PERIOD
+//	 # Only exit validator if it has no pending withdrawals in the queue
+//	 assert get_pending_balance_to_withdraw(state, voluntary_exit.validator_index) == 0  # [New in EIP7251]
 //	 # Verify signature
 //	 domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, voluntary_exit.epoch)
 //	 signing_root = compute_signing_root(voluntary_exit, domain)
@@ -98,6 +100,8 @@ func ProcessVoluntaryExits(
 //	 assert get_current_epoch(state) >= voluntary_exit.epoch
 //	 # Verify the validator has been active long enough
 //	 assert get_current_epoch(state) >= validator.activation_epoch + SHARD_COMMITTEE_PERIOD
+//	 # Only exit validator if it has no pending withdrawals in the queue
+//	 assert get_pending_balance_to_withdraw(state, voluntary_exit.validator_index) == 0  # [New in EIP7251]
 //	 # Verify signature
 //	 domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, voluntary_exit.epoch)
 //	 signing_root = compute_signing_root(voluntary_exit, domain)
@@ -128,7 +132,7 @@ func VerifyExitAndSignature(
 	}
 
 	exit := signed.Exit
-	if err := verifyExitConditions(validator, currentSlot, exit); err != nil {
+	if err := verifyExitConditions(state, validator, currentSlot, exit); err != nil {
 		return err
 	}
 	domain, err := signing.Domain(fork, exit.Epoch, params.BeaconConfig().DomainVoluntaryExit, genesisRoot)
@@ -157,13 +161,15 @@ func VerifyExitAndSignature(
 //	 assert get_current_epoch(state) >= voluntary_exit.epoch
 //	 # Verify the validator has been active long enough
 //	 assert get_current_epoch(state) >= validator.activation_epoch + SHARD_COMMITTEE_PERIOD
+//	 # Only exit validator if it has no pending withdrawals in the queue
+//	 assert get_pending_balance_to_withdraw(state, voluntary_exit.validator_index) == 0  # [New in Electra:EIP7251]
 //	 # Verify signature
 //	 domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, voluntary_exit.epoch)
 //	 signing_root = compute_signing_root(voluntary_exit, domain)
 //	 assert bls.Verify(validator.pubkey, signing_root, signed_voluntary_exit.signature)
 //	 # Initiate exit
 //	 initiate_validator_exit(state, voluntary_exit.validator_index)
-func verifyExitConditions(validator state.ReadOnlyValidator, currentSlot primitives.Slot, exit *ethpb.VoluntaryExit) error {
+func verifyExitConditions(st state.ReadOnlyBeaconState, validator state.ReadOnlyValidator, currentSlot primitives.Slot, exit *ethpb.VoluntaryExit) error {
 	currentEpoch := slots.ToEpoch(currentSlot)
 	// Verify the validator is active.
 	if !helpers.IsActiveValidatorUsingTrie(validator, currentEpoch) {
@@ -187,5 +193,14 @@ func verifyExitConditions(validator state.ReadOnlyValidator, currentSlot primiti
 			validator.ActivationEpoch()+params.BeaconConfig().ShardCommitteePeriod,
 		)
 	}
+	if st.Version() >= version.Electra {
+		pending, err := st.PendingBalanceToWithdraw(exit.ValidatorIndex)
+		if err != nil {
+			return err
+		}
+		if pending != 0 {
+			return fmt.Errorf("validator with index %d has pending balance to withdraw and cannot exit", exit.ValidatorIndex)
+		}
+	}
 	return nil
 }

beacon-chain/core/blocks/exit_test.go

@@ -135,8 +135,6 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 }
 
 func TestVerifyExitAndSignature(t *testing.T) {
-	undo := util.HackDenebMaxuint(t)
-	defer undo()
 	denebSlot, err := slots.EpochStart(params.BeaconConfig().DenebForkEpoch)
 	require.NoError(t, err)
 	tests := []struct {

beacon-chain/core/blocks/payload_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"math/big"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
@@ -610,7 +609,7 @@ func Test_ProcessPayloadCapella(t *testing.T) {
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	require.NoError(t, err)
 	payload.PrevRandao = random
-	wrapped, err := consensusblocks.WrappedExecutionPayloadCapella(payload, big.NewInt(0))
+	wrapped, err := consensusblocks.WrappedExecutionPayloadCapella(payload)
 	require.NoError(t, err)
 	_, err = blocks.ProcessPayload(st, wrapped)
 	require.NoError(t, err)
@@ -874,7 +873,7 @@ func emptyPayloadHeaderCapella() (interfaces.ExecutionData, error) {
 		BlockHash:        make([]byte, fieldparams.RootLength),
 		TransactionsRoot: make([]byte, fieldparams.RootLength),
 		WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
-	}, big.NewInt(0))
+	})
 }
 
 func emptyPayload() *enginev1.ExecutionPayload {

beacon-chain/core/blocks/proposer_slashing.go

@@ -12,12 +12,14 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"google.golang.org/protobuf/proto"
 )
 
-type slashValidatorFunc func(ctx context.Context, st state.BeaconState, vid primitives.ValidatorIndex, penaltyQuotient, proposerRewardQuotient uint64) (state.BeaconState, error)
+type slashValidatorFunc func(
+	ctx context.Context,
+	st state.BeaconState,
+	vid primitives.ValidatorIndex) (state.BeaconState, error)
 
 // ProcessProposerSlashings is one of the operations performed
 // on each processed beacon block to slash proposers based on
@@ -75,19 +77,7 @@ func ProcessProposerSlashing(
 	if err = VerifyProposerSlashing(beaconState, slashing); err != nil {
 		return nil, errors.Wrap(err, "could not verify proposer slashing")
 	}
-	cfg := params.BeaconConfig()
-	var slashingQuotient uint64
-	switch {
-	case beaconState.Version() == version.Phase0:
-		slashingQuotient = cfg.MinSlashingPenaltyQuotient
-	case beaconState.Version() == version.Altair:
-		slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
-	case beaconState.Version() >= version.Bellatrix:
-		slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
-	default:
-		return nil, errors.New("unknown state version")
-	}
-	beaconState, err = slashFunc(ctx, beaconState, slashing.Header_1.Header.ProposerIndex, slashingQuotient, cfg.ProposerRewardQuotient)
+	beaconState, err = slashFunc(ctx, beaconState, slashing.Header_1.Header.ProposerIndex)
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not slash proposer index %d", slashing.Header_1.Header.ProposerIndex)
 	}

beacon-chain/core/blocks/signature.go

@@ -179,7 +179,7 @@ func randaoSigningData(ctx context.Context, beaconState state.ReadOnlyBeaconStat
 func createAttestationSignatureBatch(
 	ctx context.Context,
 	beaconState state.ReadOnlyBeaconState,
-	atts []interfaces.Attestation,
+	atts []ethpb.Att,
 	domain []byte,
 ) (*bls.SignatureBatch, error) {
 	if len(atts) == 0 {
@@ -233,7 +233,7 @@ func createAttestationSignatureBatch(
 
 // AttestationSignatureBatch retrieves all the related attestation signature data such as the relevant public keys,
 // signatures and attestation signing data and collate it into a signature batch object.
-func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBeaconState, atts []interfaces.Attestation) (*bls.SignatureBatch, error) {
+func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBeaconState, atts []ethpb.Att) (*bls.SignatureBatch, error) {
 	if len(atts) == 0 {
 		return bls.NewSet(), nil
 	}
@@ -243,8 +243,8 @@ func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBe
 	dt := params.BeaconConfig().DomainBeaconAttester
 
 	// Split attestations by fork. Note: the signature domain will differ based on the fork.
-	var preForkAtts []interfaces.Attestation
-	var postForkAtts []interfaces.Attestation
+	var preForkAtts []ethpb.Att
+	var postForkAtts []ethpb.Att
 	for _, a := range atts {
 		if slots.ToEpoch(a.GetData().Slot) < fork.Epoch {
 			preForkAtts = append(preForkAtts, a)

beacon-chain/core/blocks/withdrawals.go

@@ -118,56 +118,46 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 // ProcessWithdrawals processes the validator withdrawals from the provided execution payload
 // into the beacon state.
 //
-// Spec pseudocode definition:
+// Spec definition:
 //
-// def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
+//	def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
+//	    expected_withdrawals, partial_withdrawals_count = get_expected_withdrawals(state)  # [Modified in Electra:EIP7251]
 //
-//	expected_withdrawals = get_expected_withdrawals(state)
-//	assert len(payload.withdrawals) == len(expected_withdrawals)
+//	    assert len(payload.withdrawals) == len(expected_withdrawals)
 //
-//	for expected_withdrawal, withdrawal in zip(expected_withdrawals, payload.withdrawals):
-//	    assert withdrawal == expected_withdrawal
-//	    decrease_balance(state, withdrawal.validator_index, withdrawal.amount)
+//	    for expected_withdrawal, withdrawal in zip(expected_withdrawals, payload.withdrawals):
+//	        assert withdrawal == expected_withdrawal
+//	        decrease_balance(state, withdrawal.validator_index, withdrawal.amount)
 //
-//	# Update the next withdrawal index if this block contained withdrawals
-//	if len(expected_withdrawals) != 0:
-//	    latest_withdrawal = expected_withdrawals[-1]
-//	    state.next_withdrawal_index = WithdrawalIndex(latest_withdrawal.index + 1)
+//	    # Update pending partial withdrawals [New in Electra:EIP7251]
+//	    state.pending_partial_withdrawals = state.pending_partial_withdrawals[partial_withdrawals_count:]
 //
-//	# Update the next validator index to start the next withdrawal sweep
-//	if len(expected_withdrawals) == MAX_WITHDRAWALS_PER_PAYLOAD:
-//	    # Next sweep starts after the latest withdrawal's validator index
-//	    next_validator_index = ValidatorIndex((expected_withdrawals[-1].validator_index + 1) % len(state.validators))
-//	    state.next_withdrawal_validator_index = next_validator_index
-//	else:
-//	    # Advance sweep by the max length of the sweep if there was not a full set of withdrawals
-//	    next_index = state.next_withdrawal_validator_index + MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP
-//	    next_validator_index = ValidatorIndex(next_index % len(state.validators))
-//	    state.next_withdrawal_validator_index = next_validator_index
+//	    # Update the next withdrawal index if this block contained withdrawals
+//	    if len(expected_withdrawals) != 0:
+//	        latest_withdrawal = expected_withdrawals[-1]
+//	        state.next_withdrawal_index = WithdrawalIndex(latest_withdrawal.index + 1)
+//
+//	    # Update the next validator index to start the next withdrawal sweep
+//	    if len(expected_withdrawals) == MAX_WITHDRAWALS_PER_PAYLOAD:
+//	        # Next sweep starts after the latest withdrawal's validator index
+//	        next_validator_index = ValidatorIndex((expected_withdrawals[-1].validator_index + 1) % len(state.validators))
+//	        state.next_withdrawal_validator_index = next_validator_index
+//	    else:
+//	        # Advance sweep by the max length of the sweep if there was not a full set of withdrawals
+//	        next_index = state.next_withdrawal_validator_index + MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP
+//	        next_validator_index = ValidatorIndex(next_index % len(state.validators))
+//	        state.next_withdrawal_validator_index = next_validator_index
 func ProcessWithdrawals(st state.BeaconState, executionData interfaces.ExecutionData) (state.BeaconState, error) {
-	expectedWithdrawals, err := st.ExpectedWithdrawals()
+	expectedWithdrawals, partials, err := st.ExpectedWithdrawals()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals")
 	}
 
-	var wdRoot [32]byte
-	if executionData.IsBlinded() {
-		r, err := executionData.WithdrawalsRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals root")
-		}
-		wdRoot = bytesutil.ToBytes32(r)
-	} else {
-		wds, err := executionData.Withdrawals()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals")
-		}
-		wdRoot, err = ssz.WithdrawalSliceRoot(wds, fieldparams.MaxWithdrawalsPerPayload)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals root")
-		}
+	// Instead of checking "assert withdrawal == expected_withdrawal", we check the withdrawals root.
+	wdRoot, err := withdrawalsRootFromMaybeBlindedExecutionData(executionData)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get withdrawals root")
 	}
-
 	expectedRoot, err := ssz.WithdrawalSliceRoot(expectedWithdrawals, fieldparams.MaxWithdrawalsPerPayload)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals root")
@@ -182,6 +172,13 @@ func ProcessWithdrawals(st state.BeaconState, executionData interfaces.Execution
 			return nil, errors.Wrap(err, "could not decrease balance")
 		}
 	}
+
+	if partials > 0 {
+		if err := st.DequeuePartialWithdrawals(partials); err != nil {
+			return nil, fmt.Errorf("could not dequeue partial withdrawals: %w", err)
+		}
+	}
+
 	if len(expectedWithdrawals) > 0 {
 		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
 			return nil, errors.Wrap(err, "could not set next withdrawal index")
@@ -207,6 +204,21 @@ func ProcessWithdrawals(st state.BeaconState, executionData interfaces.Execution
 	return st, nil
 }
 
+func withdrawalsRootFromMaybeBlindedExecutionData(ed interfaces.ExecutionData) ([32]byte, error) {
+	if ed.IsBlinded() {
+		r, err := ed.WithdrawalsRoot()
+		if err != nil {
+			return [32]byte{}, errors.Wrap(err, "could not get withdrawals root from blinded execution data")
+		}
+		return bytesutil.ToBytes32(r), nil
+	}
+	wds, err := ed.Withdrawals()
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not get withdrawals")
+	}
+	return ssz.WithdrawalSliceRoot(wds, fieldparams.MaxWithdrawalsPerPayload)
+}
+
 // BLSChangesSignatureBatch extracts the relevant signatures from the provided execution change
 // messages and transforms them into a signature batch object.
 func BLSChangesSignatureBatch(

beacon-chain/core/blocks/withdrawals_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"math/big"
 	"math/rand"
 	"testing"
 
@@ -643,10 +642,7 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 			require.NoError(t, err)
 			wdRoot, err := ssz.WithdrawalSliceRoot(test.Args.Withdrawals, fieldparams.MaxWithdrawalsPerPayload)
 			require.NoError(t, err)
-			p, err := consensusblocks.WrappedExecutionPayloadHeaderCapella(
-				&enginev1.ExecutionPayloadHeaderCapella{WithdrawalsRoot: wdRoot[:]},
-				big.NewInt(0),
-			)
+			p, err := consensusblocks.WrappedExecutionPayloadHeaderCapella(&enginev1.ExecutionPayloadHeaderCapella{WithdrawalsRoot: wdRoot[:]})
 			require.NoError(t, err)
 			post, err := blocks.ProcessWithdrawals(st, p)
 			if test.Control.ExpectedError {
@@ -1064,7 +1060,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			}
 			st, err := prepareValidators(spb, test.Args)
 			require.NoError(t, err)
-			p, err := consensusblocks.WrappedExecutionPayloadCapella(&enginev1.ExecutionPayloadCapella{Withdrawals: test.Args.Withdrawals}, big.NewInt(0))
+			p, err := consensusblocks.WrappedExecutionPayloadCapella(&enginev1.ExecutionPayloadCapella{Withdrawals: test.Args.Withdrawals})
 			require.NoError(t, err)
 			post, err := blocks.ProcessWithdrawals(st, p)
 			if test.Control.ExpectedError {

beacon-chain/core/electra/BUILD.bazel

@@ -0,0 +1,72 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "churn.go",
+        "consolidations.go",
+        "deposits.go",
+        "effective_balance_updates.go",
+        "epoch_processing.go",
+        "registry_updates.go",
+        "transition.go",
+        "upgrade.go",
+        "validator.go",
+        "withdrawals.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/core/epoch:go_default_library",
+        "//beacon-chain/core/epoch/precompute:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
+        "//beacon-chain/core/time:go_default_library",
+        "//beacon-chain/core/validators: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",
+        "//crypto/bls: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",
+        "@io_opencensus_go//trace:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "churn_test.go",
+        "consolidations_test.go",
+        "deposits_test.go",
+        "effective_balance_updates_test.go",
+        "upgrade_test.go",
+        "validator_test.go",
+    ],
+    deps = [
+        ":go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/signing: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/fieldparams:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//crypto/bls/blst:go_default_library",
+        "//crypto/bls/common:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/interop:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+        "//time/slots:go_default_library",
+    ],
+)

beacon-chain/core/electra/churn.go

@@ -0,0 +1,85 @@
+package electra
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+// ComputeConsolidationEpochAndUpdateChurn fulfills the consensus spec definition below. This method
+// calls mutating methods to the beacon state.
+//
+// Spec definition:
+//
+//	def compute_consolidation_epoch_and_update_churn(state: BeaconState, consolidation_balance: Gwei) -> Epoch:
+//	    earliest_consolidation_epoch = max(
+//	        state.earliest_consolidation_epoch, compute_activation_exit_epoch(get_current_epoch(state)))
+//	    per_epoch_consolidation_churn = get_consolidation_churn_limit(state)
+//	    # New epoch for consolidations.
+//	    if state.earliest_consolidation_epoch < earliest_consolidation_epoch:
+//	        consolidation_balance_to_consume = per_epoch_consolidation_churn
+//	    else:
+//	        consolidation_balance_to_consume = state.consolidation_balance_to_consume
+//
+//	    # Consolidation doesn't fit in the current earliest epoch.
+//	    if consolidation_balance > consolidation_balance_to_consume:
+//	        balance_to_process = consolidation_balance - consolidation_balance_to_consume
+//	        additional_epochs = (balance_to_process - 1) // per_epoch_consolidation_churn + 1
+//	        earliest_consolidation_epoch += additional_epochs
+//	        consolidation_balance_to_consume += additional_epochs * per_epoch_consolidation_churn
+//
+//	    # Consume the balance and update state variables.
+//	    state.consolidation_balance_to_consume = consolidation_balance_to_consume - consolidation_balance
+//	    state.earliest_consolidation_epoch = earliest_consolidation_epoch
+//
+//	    return state.earliest_consolidation_epoch
+func ComputeConsolidationEpochAndUpdateChurn(ctx context.Context, s state.BeaconState, consolidationBalance primitives.Gwei) (primitives.Epoch, error) {
+	earliestEpoch, err := s.EarliestConsolidationEpoch()
+	if err != nil {
+		return 0, err
+	}
+	earliestConsolidationEpoch := max(earliestEpoch, helpers.ActivationExitEpoch(slots.ToEpoch(s.Slot())))
+	activeBal, err := helpers.TotalActiveBalance(s)
+	if err != nil {
+		return 0, err
+	}
+	perEpochConsolidationChurn := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
+
+	// New epoch for consolidations.
+	var consolidationBalanceToConsume primitives.Gwei
+	if earliestEpoch < earliestConsolidationEpoch {
+		consolidationBalanceToConsume = perEpochConsolidationChurn
+	} else {
+		consolidationBalanceToConsume, err = s.ConsolidationBalanceToConsume()
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	// Consolidation doesn't fit in the current earliest epoch.
+	if consolidationBalance > consolidationBalanceToConsume {
+		balanceToProcess := consolidationBalance - consolidationBalanceToConsume
+		// additional_epochs = (balance_to_process - 1) // per_epoch_consolidation_churn + 1
+		additionalEpochs, err := math.Div64(uint64(balanceToProcess-1), uint64(perEpochConsolidationChurn))
+		if err != nil {
+			return 0, err
+		}
+		additionalEpochs++
+		earliestConsolidationEpoch += primitives.Epoch(additionalEpochs)
+		consolidationBalanceToConsume += primitives.Gwei(additionalEpochs) * perEpochConsolidationChurn
+	}
+
+	// Consume the balance and update state variables.
+	if err := s.SetConsolidationBalanceToConsume(consolidationBalanceToConsume - consolidationBalance); err != nil {
+		return 0, err
+	}
+	if err := s.SetEarliestConsolidationEpoch(earliestConsolidationEpoch); err != nil {
+		return 0, err
+	}
+
+	return earliestConsolidationEpoch, nil
+}

beacon-chain/core/electra/churn_test.go

@@ -0,0 +1,141 @@
+package electra_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"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"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+func createValidatorsWithTotalActiveBalance(totalBal primitives.Gwei) []*eth.Validator {
+	num := totalBal / primitives.Gwei(params.BeaconConfig().MinActivationBalance)
+	vals := make([]*eth.Validator, num)
+	for i := range vals {
+		vals[i] = &eth.Validator{
+			ActivationEpoch:  primitives.Epoch(0),
+			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
+			EffectiveBalance: params.BeaconConfig().MinActivationBalance,
+		}
+	}
+	if totalBal%primitives.Gwei(params.BeaconConfig().MinActivationBalance) != 0 {
+		vals = append(vals, &eth.Validator{
+			ActivationEpoch:  primitives.Epoch(0),
+			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
+			EffectiveBalance: uint64(totalBal) % params.BeaconConfig().MinActivationBalance,
+		})
+	}
+	return vals
+}
+
+func TestComputeConsolidationEpochAndUpdateChurn(t *testing.T) {
+	// Test setup: create a state with 32M ETH total active balance.
+	// In this state, the churn is expected to be 232 ETH per epoch.
+	tests := []struct {
+		name                                  string
+		state                                 state.BeaconState
+		consolidationBalance                  primitives.Gwei
+		expectedEpoch                         primitives.Epoch
+		expectedConsolidationBalanceToConsume primitives.Gwei
+	}{
+		{
+			name: "compute consolidation with no consolidation balance",
+			state: func(t *testing.T) state.BeaconState {
+				s, err := state_native.InitializeFromProtoUnsafeElectra(&eth.BeaconStateElectra{
+					Slot:                       slots.UnsafeEpochStart(10),
+					EarliestConsolidationEpoch: 9,
+					Validators:                 createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+				})
+				require.NoError(t, err)
+				return s
+			}(t),
+			consolidationBalance:                  0,            // 0 ETH
+			expectedEpoch:                         15,           // current epoch + 1 + MaxSeedLookahead
+			expectedConsolidationBalanceToConsume: 232000000000, // 232 ETH
+		},
+		{
+			name: "new epoch for consolidations",
+			state: func(t *testing.T) state.BeaconState {
+				s, err := state_native.InitializeFromProtoUnsafeElectra(&eth.BeaconStateElectra{
+					Slot:                       slots.UnsafeEpochStart(10),
+					EarliestConsolidationEpoch: 9,
+					Validators:                 createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+				})
+				require.NoError(t, err)
+				return s
+			}(t),
+			consolidationBalance:                  32000000000,  // 32 ETH
+			expectedEpoch:                         15,           // current epoch + 1 + MaxSeedLookahead
+			expectedConsolidationBalanceToConsume: 200000000000, // 200 ETH
+		},
+		{
+			name: "flows into another epoch",
+			state: func(t *testing.T) state.BeaconState {
+				s, err := state_native.InitializeFromProtoUnsafeElectra(&eth.BeaconStateElectra{
+					Slot:                       slots.UnsafeEpochStart(10),
+					EarliestConsolidationEpoch: 9,
+					Validators:                 createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+				})
+				require.NoError(t, err)
+				return s
+			}(t),
+			consolidationBalance:                  235000000000, // 235 ETH
+			expectedEpoch:                         16,           // Flows into another epoch.
+			expectedConsolidationBalanceToConsume: 229000000000, // 229 ETH
+		},
+		{
+			name: "not a new epoch, fits in remaining balance of current epoch",
+			state: func(t *testing.T) state.BeaconState {
+				s, err := state_native.InitializeFromProtoUnsafeElectra(&eth.BeaconStateElectra{
+					Slot:                          slots.UnsafeEpochStart(10),
+					EarliestConsolidationEpoch:    15,
+					ConsolidationBalanceToConsume: 200000000000,                                              // 200 ETH
+					Validators:                    createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+				})
+				require.NoError(t, err)
+				return s
+			}(t),
+			consolidationBalance:                  32000000000,  // 32 ETH
+			expectedEpoch:                         15,           // Fits into current earliest consolidation epoch.
+			expectedConsolidationBalanceToConsume: 168000000000, // 126 ETH
+		},
+		{
+			name: "not a new epoch, fits in remaining balance of current epoch",
+			state: func(t *testing.T) state.BeaconState {
+				s, err := state_native.InitializeFromProtoUnsafeElectra(&eth.BeaconStateElectra{
+					Slot:                          slots.UnsafeEpochStart(10),
+					EarliestConsolidationEpoch:    15,
+					ConsolidationBalanceToConsume: 200000000000,                                              // 200 ETH
+					Validators:                    createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+				})
+				require.NoError(t, err)
+				return s
+			}(t),
+			consolidationBalance:                  232000000000, // 232 ETH
+			expectedEpoch:                         16,           // Flows into another epoch.
+			expectedConsolidationBalanceToConsume: 200000000000, // 200 ETH
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotEpoch, err := electra.ComputeConsolidationEpochAndUpdateChurn(context.TODO(), tt.state, tt.consolidationBalance)
+			require.NoError(t, err)
+			require.Equal(t, tt.expectedEpoch, gotEpoch)
+			// Check consolidation balance to consume is set on the state.
+			cbtc, err := tt.state.ConsolidationBalanceToConsume()
+			require.NoError(t, err)
+			require.Equal(t, tt.expectedConsolidationBalanceToConsume, cbtc)
+			// Check earliest consolidation epoch was set on the state.
+			gotEpoch, err = tt.state.EarliestConsolidationEpoch()
+			require.NoError(t, err)
+			require.Equal(t, tt.expectedEpoch, gotEpoch)
+		})
+	}
+}

beacon-chain/core/electra/consolidations.go

@@ -0,0 +1,258 @@
+package electra
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
+)
+
+// ProcessPendingConsolidations implements the spec definition below. This method makes mutating
+// calls to the beacon state.
+//
+// Spec definition:
+//
+//	def process_pending_consolidations(state: BeaconState) -> None:
+//	    next_pending_consolidation = 0
+//	    for pending_consolidation in state.pending_consolidations:
+//	        source_validator = state.validators[pending_consolidation.source_index]
+//	        if source_validator.slashed:
+//	            next_pending_consolidation += 1
+//	            continue
+//	        if source_validator.withdrawable_epoch > get_current_epoch(state):
+//	            break
+//
+//	        # Churn any target excess active balance of target and raise its max
+//	        switch_to_compounding_validator(state, pending_consolidation.target_index)
+//	        # Move active balance to target. Excess balance is withdrawable.
+//	        active_balance = get_active_balance(state, pending_consolidation.source_index)
+//	        decrease_balance(state, pending_consolidation.source_index, active_balance)
+//	        increase_balance(state, pending_consolidation.target_index, active_balance)
+//	        next_pending_consolidation += 1
+//
+//	    state.pending_consolidations = state.pending_consolidations[next_pending_consolidation:]
+func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) error {
+	ctx, span := trace.StartSpan(ctx, "electra.ProcessPendingConsolidations")
+	defer span.End()
+
+	if st == nil || st.IsNil() {
+		return errors.New("nil state")
+	}
+
+	currentEpoch := slots.ToEpoch(st.Slot())
+
+	var nextPendingConsolidation uint64
+	pendingConsolidations, err := st.PendingConsolidations()
+	if err != nil {
+		return err
+	}
+
+	for _, pc := range pendingConsolidations {
+		sourceValidator, err := st.ValidatorAtIndex(pc.SourceIndex)
+		if err != nil {
+			return err
+		}
+		if sourceValidator.Slashed {
+			nextPendingConsolidation++
+			continue
+		}
+		if sourceValidator.WithdrawableEpoch > currentEpoch {
+			break
+		}
+
+		if err := SwitchToCompoundingValidator(ctx, st, pc.TargetIndex); err != nil {
+			return err
+		}
+
+		activeBalance, err := st.ActiveBalanceAtIndex(pc.SourceIndex)
+		if err != nil {
+			return err
+		}
+		if err := helpers.DecreaseBalance(st, pc.SourceIndex, activeBalance); err != nil {
+			return err
+		}
+		if err := helpers.IncreaseBalance(st, pc.TargetIndex, activeBalance); err != nil {
+			return err
+		}
+		nextPendingConsolidation++
+	}
+
+	if nextPendingConsolidation > 0 {
+		return st.SetPendingConsolidations(pendingConsolidations[nextPendingConsolidation:])
+	}
+
+	return nil
+}
+
+// ProcessConsolidations implements the spec definition below. This method makes mutating calls to
+// the beacon state.
+//
+// Spec definition:
+//
+//	def process_consolidation(state: BeaconState, signed_consolidation: SignedConsolidation) -> None:
+//	    # If the pending consolidations queue is full, no consolidations are allowed in the block
+//	    assert len(state.pending_consolidations) < PENDING_CONSOLIDATIONS_LIMIT
+//	    # If there is too little available consolidation churn limit, no consolidations are allowed in the block
+//	    assert get_consolidation_churn_limit(state) > MIN_ACTIVATION_BALANCE
+//	    consolidation = signed_consolidation.message
+//	    # Verify that source != target, so a consolidation cannot be used as an exit.
+//	    assert consolidation.source_index != consolidation.target_index
+//
+//	    source_validator = state.validators[consolidation.source_index]
+//	    target_validator = state.validators[consolidation.target_index]
+//	    # Verify the source and the target are active
+//	    current_epoch = get_current_epoch(state)
+//	    assert is_active_validator(source_validator, current_epoch)
+//	    assert is_active_validator(target_validator, current_epoch)
+//	    # Verify exits for source and target have not been initiated
+//	    assert source_validator.exit_epoch == FAR_FUTURE_EPOCH
+//	    assert target_validator.exit_epoch == FAR_FUTURE_EPOCH
+//	    # Consolidations must specify an epoch when they become valid; they are not valid before then
+//	    assert current_epoch >= consolidation.epoch
+//
+//	    # Verify the source and the target have Execution layer withdrawal credentials
+//	    assert has_execution_withdrawal_credential(source_validator)
+//	    assert has_execution_withdrawal_credential(target_validator)
+//	    # Verify the same withdrawal address
+//	    assert source_validator.withdrawal_credentials[12:] == target_validator.withdrawal_credentials[12:]
+//
+//	    # Verify consolidation is signed by the source and the target
+//	    domain = compute_domain(DOMAIN_CONSOLIDATION, genesis_validators_root=state.genesis_validators_root)
+//	    signing_root = compute_signing_root(consolidation, domain)
+//	    pubkeys = [source_validator.pubkey, target_validator.pubkey]
+//	    assert bls.FastAggregateVerify(pubkeys, signing_root, signed_consolidation.signature)
+//
+//	    # Initiate source validator exit and append pending consolidation
+//	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
+//	        state, source_validator.effective_balance)
+//	    source_validator.withdrawable_epoch = Epoch(
+//	        source_validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+//	    )
+//	    state.pending_consolidations.append(PendingConsolidation(
+//	        source_index=consolidation.source_index,
+//	        target_index=consolidation.target_index
+//	    ))
+func ProcessConsolidations(ctx context.Context, st state.BeaconState, cs []*ethpb.SignedConsolidation) error {
+	_, span := trace.StartSpan(ctx, "electra.ProcessConsolidations")
+	defer span.End()
+
+	if st == nil || st.IsNil() {
+		return errors.New("nil state")
+	}
+
+	if len(cs) == 0 {
+		return nil // Nothing to process.
+	}
+
+	domain, err := signing.ComputeDomain(
+		params.BeaconConfig().DomainConsolidation,
+		nil, // Use genesis fork version
+		st.GenesisValidatorsRoot(),
+	)
+	if err != nil {
+		return err
+	}
+
+	totalBalance, err := helpers.TotalActiveBalance(st)
+	if err != nil {
+		return err
+	}
+
+	if helpers.ConsolidationChurnLimit(primitives.Gwei(totalBalance)) <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
+		return errors.New("too little available consolidation churn limit")
+	}
+
+	currentEpoch := slots.ToEpoch(st.Slot())
+
+	for _, c := range cs {
+		if c == nil || c.Message == nil {
+			return errors.New("nil consolidation")
+		}
+
+		if n, err := st.NumPendingConsolidations(); err != nil {
+			return err
+		} else if n >= params.BeaconConfig().PendingConsolidationsLimit {
+			return errors.New("pending consolidations queue is full")
+		}
+
+		if c.Message.SourceIndex == c.Message.TargetIndex {
+			return errors.New("source and target index are the same")
+		}
+		source, err := st.ValidatorAtIndex(c.Message.SourceIndex)
+		if err != nil {
+			return err
+		}
+		target, err := st.ValidatorAtIndex(c.Message.TargetIndex)
+		if err != nil {
+			return err
+		}
+		if !helpers.IsActiveValidator(source, currentEpoch) {
+			return errors.New("source is not active")
+		}
+		if !helpers.IsActiveValidator(target, currentEpoch) {
+			return errors.New("target is not active")
+		}
+		if source.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
+			return errors.New("source exit epoch has been initiated")
+		}
+		if target.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
+			return errors.New("target exit epoch has been initiated")
+		}
+		if currentEpoch < c.Message.Epoch {
+			return errors.New("consolidation is not valid yet")
+		}
+
+		if !helpers.HasExecutionWithdrawalCredentials(source) {
+			return errors.New("source does not have execution withdrawal credentials")
+		}
+		if !helpers.HasExecutionWithdrawalCredentials(target) {
+			return errors.New("target does not have execution withdrawal credentials")
+		}
+		if !helpers.IsSameWithdrawalCredentials(source, target) {
+			return errors.New("source and target have different withdrawal credentials")
+		}
+
+		sr, err := signing.ComputeSigningRoot(c.Message, domain)
+		if err != nil {
+			return err
+		}
+		sourcePk, err := bls.PublicKeyFromBytes(source.PublicKey)
+		if err != nil {
+			return errors.Wrap(err, "could not convert source public key bytes to bls public key")
+		}
+		targetPk, err := bls.PublicKeyFromBytes(target.PublicKey)
+		if err != nil {
+			return errors.Wrap(err, "could not convert target public key bytes to bls public key")
+		}
+		sig, err := bls.SignatureFromBytes(c.Signature)
+		if err != nil {
+			return errors.Wrap(err, "could not convert bytes to signature")
+		}
+		if !sig.FastAggregateVerify([]bls.PublicKey{sourcePk, targetPk}, sr) {
+			return errors.New("consolidation signature verification failed")
+		}
+
+		sEE, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(source.EffectiveBalance))
+		if err != nil {
+			return err
+		}
+		source.ExitEpoch = sEE
+		source.WithdrawableEpoch = sEE + params.BeaconConfig().MinValidatorWithdrawabilityDelay
+		if err := st.UpdateValidatorAtIndex(c.Message.SourceIndex, source); err != nil {
+			return err
+		}
+		if err := st.AppendPendingConsolidation(c.Message.ToPendingConsolidation()); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

beacon-chain/core/electra/consolidations_test.go

@@ -0,0 +1,441 @@
+package electra_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls/blst"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls/common"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/interop"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func TestProcessPendingConsolidations(t *testing.T) {
+	tests := []struct {
+		name    string
+		state   state.BeaconState
+		check   func(*testing.T, state.BeaconState)
+		wantErr bool
+	}{
+		{
+			name:    "nil state",
+			state:   nil,
+			wantErr: true,
+		},
+		{
+			name: "no pending consolidations",
+			state: func() state.BeaconState {
+				pb := &eth.BeaconStateElectra{}
+
+				st, err := state_native.InitializeFromProtoUnsafeElectra(pb)
+				require.NoError(t, err)
+				return st
+			}(),
+			wantErr: false,
+		},
+		{
+			name: "processes pending consolidation successfully",
+			state: func() state.BeaconState {
+				pb := &eth.BeaconStateElectra{
+					Validators: []*eth.Validator{
+						{
+							WithdrawalCredentials: []byte{0x01, 0xFF},
+						},
+						{
+							WithdrawalCredentials: []byte{0x01, 0xAB},
+						},
+					},
+					Balances: []uint64{
+						params.BeaconConfig().MinActivationBalance,
+						params.BeaconConfig().MinActivationBalance,
+					},
+					PendingConsolidations: []*eth.PendingConsolidation{
+						{
+							SourceIndex: 0,
+							TargetIndex: 1,
+						},
+					},
+				}
+
+				st, err := state_native.InitializeFromProtoUnsafeElectra(pb)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				// Balances are transferred from v0 to v1.
+				bal0, err := st.BalanceAtIndex(0)
+				require.NoError(t, err)
+				require.Equal(t, uint64(0), bal0)
+				bal1, err := st.BalanceAtIndex(1)
+				require.NoError(t, err)
+				require.Equal(t, 2*params.BeaconConfig().MinActivationBalance, bal1)
+
+				// The pending consolidation is removed from the list.
+				num, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, uint64(0), num)
+
+				// v1 is switched to compounding validator.
+				v1, err := st.ValidatorAtIndex(1)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().CompoundingWithdrawalPrefixByte, v1.WithdrawalCredentials[0])
+			},
+			wantErr: false,
+		},
+		{
+			name: "stop processing when a source val withdrawable epoch is in the future",
+			state: func() state.BeaconState {
+				pb := &eth.BeaconStateElectra{
+					Validators: []*eth.Validator{
+						{
+							WithdrawalCredentials: []byte{0x01, 0xFF},
+							WithdrawableEpoch:     100,
+						},
+						{
+							WithdrawalCredentials: []byte{0x01, 0xAB},
+						},
+					},
+					Balances: []uint64{
+						params.BeaconConfig().MinActivationBalance,
+						params.BeaconConfig().MinActivationBalance,
+					},
+					PendingConsolidations: []*eth.PendingConsolidation{
+						{
+							SourceIndex: 0,
+							TargetIndex: 1,
+						},
+					},
+				}
+
+				st, err := state_native.InitializeFromProtoUnsafeElectra(pb)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				// No balances are transferred from v0 to v1.
+				bal0, err := st.BalanceAtIndex(0)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance, bal0)
+				bal1, err := st.BalanceAtIndex(1)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance, bal1)
+
+				// The pending consolidation is still in the list.
+				num, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, uint64(1), num)
+			},
+			wantErr: false,
+		},
+		{
+			name: "slashed validator is not consolidated",
+			state: func() state.BeaconState {
+				pb := &eth.BeaconStateElectra{
+					Validators: []*eth.Validator{
+						{
+							WithdrawalCredentials: []byte{0x01, 0xFF},
+						},
+						{
+							WithdrawalCredentials: []byte{0x01, 0xAB},
+						},
+						{
+							Slashed: true,
+						},
+						{
+							WithdrawalCredentials: []byte{0x01, 0xCC},
+						},
+					},
+					Balances: []uint64{
+						params.BeaconConfig().MinActivationBalance,
+						params.BeaconConfig().MinActivationBalance,
+						params.BeaconConfig().MinActivationBalance,
+						params.BeaconConfig().MinActivationBalance,
+					},
+					PendingConsolidations: []*eth.PendingConsolidation{
+						{
+							SourceIndex: 2,
+							TargetIndex: 3,
+						},
+						{
+							SourceIndex: 0,
+							TargetIndex: 1,
+						},
+					},
+				}
+
+				st, err := state_native.InitializeFromProtoUnsafeElectra(pb)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				// No balances are transferred from v2 to v3.
+				bal0, err := st.BalanceAtIndex(2)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance, bal0)
+				bal1, err := st.BalanceAtIndex(3)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance, bal1)
+
+				// No pending consolidation remaining.
+				num, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, uint64(0), num)
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := electra.ProcessPendingConsolidations(context.TODO(), tt.state)
+			require.Equal(t, tt.wantErr, err != nil)
+			if tt.check != nil {
+				tt.check(t, tt.state)
+			}
+		})
+	}
+}
+
+func stateWithActiveBalanceETH(t *testing.T, balETH uint64) state.BeaconState {
+	gwei := balETH * 1_000_000_000
+	balPerVal := params.BeaconConfig().MinActivationBalance
+	numVals := gwei / balPerVal
+
+	vals := make([]*eth.Validator, numVals)
+	bals := make([]uint64, numVals)
+	for i := uint64(0); i < numVals; i++ {
+		wc := make([]byte, 32)
+		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+		wc[31] = byte(i)
+		vals[i] = &eth.Validator{
+			ActivationEpoch:       0,
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			EffectiveBalance:      balPerVal,
+			WithdrawalCredentials: wc,
+		}
+		bals[i] = balPerVal
+	}
+	st, err := state_native.InitializeFromProtoUnsafeElectra(&eth.BeaconStateElectra{
+		Slot:       10 * params.BeaconConfig().SlotsPerEpoch,
+		Validators: vals,
+		Balances:   bals,
+		Fork: &eth.Fork{
+			CurrentVersion: params.BeaconConfig().ElectraForkVersion,
+		},
+	})
+	require.NoError(t, err)
+
+	return st
+}
+
+func TestProcessConsolidations(t *testing.T) {
+	secretKeys, publicKeys, err := interop.DeterministicallyGenerateKeys(0, 2)
+	require.NoError(t, err)
+
+	genesisValidatorRoot := bytesutil.PadTo([]byte("genesisValidatorRoot"), fieldparams.RootLength)
+
+	_ = secretKeys
+
+	tests := []struct {
+		name    string
+		state   state.BeaconState
+		scs     []*eth.SignedConsolidation
+		check   func(*testing.T, state.BeaconState)
+		wantErr string
+	}{
+		{
+			name:    "nil state",
+			scs:     make([]*eth.SignedConsolidation, 10),
+			wantErr: "nil state",
+		},
+		{
+			name:    "nil consolidation in slice",
+			state:   stateWithActiveBalanceETH(t, 19_000_000),
+			scs:     []*eth.SignedConsolidation{nil, nil},
+			wantErr: "nil consolidation",
+		},
+		{
+			name: "state is 100% full of pending consolidations",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				pc := make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit)
+				require.NoError(t, st.SetPendingConsolidations(pc))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{}}},
+			wantErr: "pending consolidations queue is full",
+		},
+		{
+			name: "state has too little consolidation churn limit available to process a consolidation",
+			state: func() state.BeaconState {
+				st, _ := util.DeterministicGenesisStateElectra(t, 1)
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{}}},
+			wantErr: "too little available consolidation churn limit",
+		},
+		{
+			name:    "consolidation with source and target as the same index is rejected",
+			state:   stateWithActiveBalanceETH(t, 19_000_000),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 100}}},
+			wantErr: "source and target index are the same",
+		},
+		{
+			name: "consolidation with inactive source is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 25, TargetIndex: 100}}},
+			wantErr: "source is not active",
+		},
+		{
+			name: "consolidation with inactive target is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25}}},
+			wantErr: "target is not active",
+		},
+		{
+			name: "consolidation with exiting source is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.ExitEpoch = 256
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 25, TargetIndex: 100}}},
+			wantErr: "source exit epoch has been initiated",
+		},
+		{
+			name: "consolidation with exiting target is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.ExitEpoch = 256
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25}}},
+			wantErr: "target exit epoch has been initiated",
+		},
+		{
+			name:    "consolidation with future epoch is rejected",
+			state:   stateWithActiveBalanceETH(t, 19_000_000),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25, Epoch: 55}}},
+			wantErr: "consolidation is not valid yet",
+		},
+		{
+			name: "source validator without withdrawal credentials is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.WithdrawalCredentials = []byte{}
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 25, TargetIndex: 100}}},
+			wantErr: "source does not have execution withdrawal credentials",
+		},
+		{
+			name: "target validator without withdrawal credentials is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.WithdrawalCredentials = []byte{}
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25}}},
+			wantErr: "target does not have execution withdrawal credentials",
+		},
+		{
+			name:    "source and target with different withdrawal credentials is rejected",
+			state:   stateWithActiveBalanceETH(t, 19_000_000),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25}}},
+			wantErr: "source and target have different withdrawal credentials",
+		},
+		{
+			name: "consolidation with valid signatures is OK",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				require.NoError(t, st.SetGenesisValidatorsRoot(genesisValidatorRoot))
+				source, err := st.ValidatorAtIndex(100)
+				require.NoError(t, err)
+				target, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				source.PublicKey = publicKeys[0].Marshal()
+				source.WithdrawalCredentials = target.WithdrawalCredentials
+				require.NoError(t, st.UpdateValidatorAtIndex(100, source))
+				target.PublicKey = publicKeys[1].Marshal()
+				require.NoError(t, st.UpdateValidatorAtIndex(25, target))
+				return st
+			}(),
+			scs: func() []*eth.SignedConsolidation {
+				sc := &eth.SignedConsolidation{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25, Epoch: 8}}
+
+				domain, err := signing.ComputeDomain(
+					params.BeaconConfig().DomainConsolidation,
+					nil,
+					genesisValidatorRoot,
+				)
+				require.NoError(t, err)
+				sr, err := signing.ComputeSigningRoot(sc.Message, domain)
+				require.NoError(t, err)
+
+				sig0 := secretKeys[0].Sign(sr[:])
+				sig1 := secretKeys[1].Sign(sr[:])
+
+				sc.Signature = blst.AggregateSignatures([]common.Signature{sig0, sig1}).Marshal()
+
+				return []*eth.SignedConsolidation{sc}
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				source, err := st.ValidatorAtIndex(100)
+				require.NoError(t, err)
+				// The consolidated validator is exiting.
+				require.Equal(t, primitives.Epoch(15), source.ExitEpoch) // 15 = state.Epoch(10) + MIN_SEED_LOOKAHEAD(4) + 1
+				require.Equal(t, primitives.Epoch(15+params.BeaconConfig().MinValidatorWithdrawabilityDelay), source.WithdrawableEpoch)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := electra.ProcessConsolidations(context.TODO(), tt.state, tt.scs)
+			if len(tt.wantErr) > 0 {
+				require.ErrorContains(t, tt.wantErr, err)
+			} else {
+				require.NoError(t, err)
+			}
+			if tt.check != nil {
+				tt.check(t, tt.state)
+			}
+		})
+	}
+}

beacon-chain/core/electra/deposits.go

@@ -0,0 +1,87 @@
+package electra
+
+import (
+	"context"
+	"errors"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"go.opencensus.io/trace"
+)
+
+// ProcessPendingBalanceDeposits implements the spec definition below. This method mutates the state.
+//
+// Spec definition:
+//
+//	def process_pending_balance_deposits(state: BeaconState) -> None:
+//	    available_for_processing = state.deposit_balance_to_consume + get_activation_exit_churn_limit(state)
+//	    processed_amount = 0
+//	    next_deposit_index = 0
+//
+//	    for deposit in state.pending_balance_deposits:
+//	        if processed_amount + deposit.amount > available_for_processing:
+//	            break
+//	        increase_balance(state, deposit.index, deposit.amount)
+//	        processed_amount += deposit.amount
+//	        next_deposit_index += 1
+//
+//	    state.pending_balance_deposits = state.pending_balance_deposits[next_deposit_index:]
+//
+//	    if len(state.pending_balance_deposits) == 0:
+//	        state.deposit_balance_to_consume = Gwei(0)
+//	    else:
+//	        state.deposit_balance_to_consume = available_for_processing - processed_amount
+func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, activeBalance primitives.Gwei) error {
+	_, span := trace.StartSpan(ctx, "electra.ProcessPendingBalanceDeposits")
+	defer span.End()
+
+	if st == nil || st.IsNil() {
+		return errors.New("nil state")
+	}
+
+	depBalToConsume, err := st.DepositBalanceToConsume()
+	if err != nil {
+		return err
+	}
+
+	availableForProcessing := depBalToConsume + helpers.ActivationExitChurnLimit(activeBalance)
+	nextDepositIndex := 0
+
+	deposits, err := st.PendingBalanceDeposits()
+	if err != nil {
+		return err
+	}
+
+	for _, deposit := range deposits {
+		if primitives.Gwei(deposit.Amount) > availableForProcessing {
+			break
+		}
+		if err := helpers.IncreaseBalance(st, deposit.Index, deposit.Amount); err != nil {
+			return err
+		}
+		availableForProcessing -= primitives.Gwei(deposit.Amount)
+		nextDepositIndex++
+	}
+
+	deposits = deposits[nextDepositIndex:]
+	if err := st.SetPendingBalanceDeposits(deposits); err != nil {
+		return err
+	}
+
+	if len(deposits) == 0 {
+		return st.SetDepositBalanceToConsume(0)
+	} else {
+		return st.SetDepositBalanceToConsume(availableForProcessing)
+	}
+}
+
+// ProcessDepositReceipts is a function as part of electra to process execution layer deposits
+func ProcessDepositReceipts(ctx context.Context, beaconState state.BeaconState, receipts []*enginev1.DepositReceipt) (state.BeaconState, error) {
+	_, span := trace.StartSpan(ctx, "electra.ProcessDepositReceipts")
+	defer span.End()
+	// TODO: replace with 6110 logic
+	// return b.ProcessDepositReceipts(beaconState, receipts)
+	return beaconState, nil
+}

beacon-chain/core/electra/deposits_test.go

@@ -0,0 +1,128 @@
+package electra_test
+
+import (
+	"context"
+	"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/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestProcessPendingBalanceDeposits(t *testing.T) {
+	tests := []struct {
+		name    string
+		state   state.BeaconState
+		wantErr bool
+		check   func(*testing.T, state.BeaconState)
+	}{
+		{
+			name:    "nil state fails",
+			state:   nil,
+			wantErr: true,
+		},
+		{
+			name: "no deposits resets balance to consume",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 1_000)
+				require.NoError(t, st.SetDepositBalanceToConsume(100))
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				res, err := st.DepositBalanceToConsume()
+				require.NoError(t, err)
+				require.Equal(t, primitives.Gwei(0), res)
+			},
+		},
+		{
+			name: "more deposits than balance to consume processes partial deposits",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 1_000)
+				require.NoError(t, st.SetDepositBalanceToConsume(100))
+				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
+				deps := make([]*eth.PendingBalanceDeposit, 20)
+				for i := 0; i < len(deps); i += 1 {
+					deps[i] = &eth.PendingBalanceDeposit{
+						Amount: uint64(amountAvailForProcessing) / 10,
+						Index:  primitives.ValidatorIndex(i),
+					}
+				}
+				require.NoError(t, st.SetPendingBalanceDeposits(deps))
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
+				res, err := st.DepositBalanceToConsume()
+				require.NoError(t, err)
+				require.Equal(t, primitives.Gwei(100), res)
+				// Validators 0..9 should have their balance increased
+				for i := primitives.ValidatorIndex(0); i < 10; i++ {
+					b, err := st.BalanceAtIndex(i)
+					require.NoError(t, err)
+					require.Equal(t, params.BeaconConfig().MinActivationBalance+uint64(amountAvailForProcessing)/10, b)
+				}
+
+				// Half of the balance deposits should have been processed.
+				remaining, err := st.PendingBalanceDeposits()
+				require.NoError(t, err)
+				require.Equal(t, 10, len(remaining))
+			},
+		},
+		{
+			name: "less deposits than balance to consume processes all deposits",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 1_000)
+				require.NoError(t, st.SetDepositBalanceToConsume(0))
+				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
+				deps := make([]*eth.PendingBalanceDeposit, 5)
+				for i := 0; i < len(deps); i += 1 {
+					deps[i] = &eth.PendingBalanceDeposit{
+						Amount: uint64(amountAvailForProcessing) / 5,
+						Index:  primitives.ValidatorIndex(i),
+					}
+				}
+				require.NoError(t, st.SetPendingBalanceDeposits(deps))
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
+				res, err := st.DepositBalanceToConsume()
+				require.NoError(t, err)
+				require.Equal(t, primitives.Gwei(0), res)
+				// Validators 0..4 should have their balance increased
+				for i := primitives.ValidatorIndex(0); i < 4; i++ {
+					b, err := st.BalanceAtIndex(i)
+					require.NoError(t, err)
+					require.Equal(t, params.BeaconConfig().MinActivationBalance+uint64(amountAvailForProcessing)/5, b)
+				}
+
+				// All of the balance deposits should have been processed.
+				remaining, err := st.PendingBalanceDeposits()
+				require.NoError(t, err)
+				require.Equal(t, 0, len(remaining))
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var tab uint64
+			var err error
+			if tt.state != nil {
+				// The caller of this method would normally have the precompute balance values for total
+				// active balance for this epoch. For ease of test setup, we will compute total active
+				// balance from the given state.
+				tab, err = helpers.TotalActiveBalance(tt.state)
+			}
+			require.NoError(t, err)
+			err = electra.ProcessPendingBalanceDeposits(context.TODO(), tt.state, primitives.Gwei(tab))
+			require.Equal(t, tt.wantErr, err != nil, "wantErr=%v, got err=%s", tt.wantErr, err)
+			if tt.check != nil {
+				tt.check(t, tt.state)
+			}
+		})
+	}
+}

beacon-chain/core/electra/effective_balance_updates.go

@@ -0,0 +1,65 @@
+package electra
+
+import (
+	"fmt"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+)
+
+// ProcessEffectiveBalanceUpdates processes effective balance updates during epoch processing.
+//
+// Spec pseudocode definition:
+//
+//	def process_effective_balance_updates(state: BeaconState) -> None:
+//	    # Update effective balances with hysteresis
+//	    for index, validator in enumerate(state.validators):
+//	        balance = state.balances[index]
+//	        HYSTERESIS_INCREMENT = uint64(EFFECTIVE_BALANCE_INCREMENT // HYSTERESIS_QUOTIENT)
+//	        DOWNWARD_THRESHOLD = HYSTERESIS_INCREMENT * HYSTERESIS_DOWNWARD_MULTIPLIER
+//	        UPWARD_THRESHOLD = HYSTERESIS_INCREMENT * HYSTERESIS_UPWARD_MULTIPLIER
+//	        EFFECTIVE_BALANCE_LIMIT = (
+//	            MAX_EFFECTIVE_BALANCE_EIP7251 if has_compounding_withdrawal_credential(validator)
+//	            else MIN_ACTIVATION_BALANCE
+//	        )
+//
+//	        if (
+//	            balance + DOWNWARD_THRESHOLD < validator.effective_balance
+//	            or validator.effective_balance + UPWARD_THRESHOLD < balance
+//	        ):
+//	            validator.effective_balance = min(balance - balance % EFFECTIVE_BALANCE_INCREMENT, EFFECTIVE_BALANCE_LIMIT)
+func ProcessEffectiveBalanceUpdates(state state.BeaconState) error {
+	effBalanceInc := params.BeaconConfig().EffectiveBalanceIncrement
+	hysteresisInc := effBalanceInc / params.BeaconConfig().HysteresisQuotient
+	downwardThreshold := hysteresisInc * params.BeaconConfig().HysteresisDownwardMultiplier
+	upwardThreshold := hysteresisInc * params.BeaconConfig().HysteresisUpwardMultiplier
+
+	bals := state.Balances()
+
+	// Update effective balances with hysteresis.
+	validatorFunc := func(idx int, val *ethpb.Validator) (bool, *ethpb.Validator, error) {
+		if val == nil {
+			return false, nil, fmt.Errorf("validator %d is nil in state", idx)
+		}
+		if idx >= len(bals) {
+			return false, nil, fmt.Errorf("validator index exceeds validator length in state %d >= %d", idx, len(state.Balances()))
+		}
+		balance := bals[idx]
+
+		effectiveBalanceLimit := params.BeaconConfig().MinActivationBalance
+		if helpers.HasCompoundingWithdrawalCredential(val) {
+			effectiveBalanceLimit = params.BeaconConfig().MaxEffectiveBalanceElectra
+		}
+
+		if balance+downwardThreshold < val.EffectiveBalance || val.EffectiveBalance+upwardThreshold < balance {
+			effectiveBal := min(balance-balance%effBalanceInc, effectiveBalanceLimit)
+			val.EffectiveBalance = effectiveBal
+			return false, val, nil
+		}
+		return false, val, nil
+	}
+
+	return state.ApplyToEveryValidator(validatorFunc)
+}

beacon-chain/core/electra/effective_balance_updates_test.go

@@ -0,0 +1,144 @@
+package electra_test
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"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"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestProcessEffectiveBalnceUpdates(t *testing.T) {
+	effBalanceInc := params.BeaconConfig().EffectiveBalanceIncrement
+	hysteresisInc := effBalanceInc / params.BeaconConfig().HysteresisQuotient
+	downwardThreshold := hysteresisInc * params.BeaconConfig().HysteresisDownwardMultiplier
+	upwardThreshold := hysteresisInc * params.BeaconConfig().HysteresisUpwardMultiplier
+
+	tests := []struct {
+		name    string
+		state   state.BeaconState
+		wantErr bool
+		check   func(*testing.T, state.BeaconState)
+	}{
+		{
+			name: "validator with compounding withdrawal credentials updates effective balance",
+			state: func() state.BeaconState {
+				pb := &eth.BeaconStateElectra{
+					Validators: []*eth.Validator{
+						{
+							EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
+							WithdrawalCredentials: []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte, 0x11},
+						},
+					},
+					Balances: []uint64{
+						params.BeaconConfig().MaxEffectiveBalanceElectra * 2,
+					},
+				}
+				st, err := state_native.InitializeFromProtoElectra(pb)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, bs state.BeaconState) {
+				val, err := bs.ValidatorAtIndex(0)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MaxEffectiveBalanceElectra, val.EffectiveBalance)
+			},
+		},
+		{
+			name: "validator without compounding withdrawal credentials updates effective balance",
+			state: func() state.BeaconState {
+				pb := &eth.BeaconStateElectra{
+					Validators: []*eth.Validator{
+						{
+							EffectiveBalance:      params.BeaconConfig().MinActivationBalance / 2,
+							WithdrawalCredentials: nil,
+						},
+					},
+					Balances: []uint64{
+						params.BeaconConfig().MaxEffectiveBalanceElectra,
+					},
+				}
+				st, err := state_native.InitializeFromProtoElectra(pb)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, bs state.BeaconState) {
+				val, err := bs.ValidatorAtIndex(0)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance, val.EffectiveBalance)
+			},
+		},
+		{
+			name: "validator effective balance moves only when outside of threshold",
+			state: func() state.BeaconState {
+				pb := &eth.BeaconStateElectra{
+					Validators: []*eth.Validator{
+						{
+							EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
+							WithdrawalCredentials: []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte, 0x11},
+						},
+						{
+							EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
+							WithdrawalCredentials: []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte, 0x11},
+						},
+						{
+							EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
+							WithdrawalCredentials: []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte, 0x11},
+						},
+						{
+							EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
+							WithdrawalCredentials: []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte, 0x11},
+						},
+					},
+					Balances: []uint64{
+						params.BeaconConfig().MinActivationBalance - downwardThreshold - 1, // beyond downward threshold
+						params.BeaconConfig().MinActivationBalance - downwardThreshold + 1, // within downward threshold
+						params.BeaconConfig().MinActivationBalance + upwardThreshold + 1,   // beyond upward threshold
+						params.BeaconConfig().MinActivationBalance + upwardThreshold - 1,   // within upward threshold
+					},
+				}
+				st, err := state_native.InitializeFromProtoElectra(pb)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, bs state.BeaconState) {
+				// validator 0 has a balance diff exceeding the threshold so a diff should be applied to
+				// effective balance and it moves by effective balance increment.
+				val, err := bs.ValidatorAtIndex(0)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance-params.BeaconConfig().EffectiveBalanceIncrement, val.EffectiveBalance)
+
+				// validator 1 has a balance diff within the threshold so the effective balance should not
+				// have changed.
+				val, err = bs.ValidatorAtIndex(1)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance, val.EffectiveBalance)
+
+				// Validator 2 has a balance diff exceeding the threshold so a diff should be applied to the
+				// effective balance and it moves by effective balance increment.
+				val, err = bs.ValidatorAtIndex(2)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance+params.BeaconConfig().EffectiveBalanceIncrement, val.EffectiveBalance)
+
+				// Validator 3 has a balance diff within the threshold so the effective balance should not
+				// have changed.
+				val, err = bs.ValidatorAtIndex(3)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().MinActivationBalance, val.EffectiveBalance)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := electra.ProcessEffectiveBalanceUpdates(tt.state)
+			require.Equal(t, tt.wantErr, err != nil, "unexpected error returned wanted error=nil (%s), got error=%s", tt.wantErr, err)
+			if tt.check != nil {
+				tt.check(t, tt.state)
+			}
+		})
+	}
+}

beacon-chain/core/electra/epoch_processing.go

@@ -0,0 +1,27 @@
+package electra
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+)
+
+// sortableIndices implements the Sort interface to sort newly activated validator indices
+// by activation epoch and by index number.
+type sortableIndices struct {
+	indices    []primitives.ValidatorIndex
+	validators []*ethpb.Validator
+}
+
+// Len is the number of elements in the collection.
+func (s sortableIndices) Len() int { return len(s.indices) }
+
+// Swap swaps the elements with indexes i and j.
+func (s sortableIndices) Swap(i, j int) { s.indices[i], s.indices[j] = s.indices[j], s.indices[i] }
+
+// Less reports whether the element with index i must sort before the element with index j.
+func (s sortableIndices) Less(i, j int) bool {
+	if s.validators[s.indices[i]].ActivationEligibilityEpoch == s.validators[s.indices[j]].ActivationEligibilityEpoch {
+		return s.indices[i] < s.indices[j]
+	}
+	return s.validators[s.indices[i]].ActivationEligibilityEpoch < s.validators[s.indices[j]].ActivationEligibilityEpoch
+}

beacon-chain/core/electra/registry_updates.go

@@ -0,0 +1,34 @@
+package electra
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+)
+
+// ProcessRegistryUpdates rotates validators in and out of active pool.
+// the amount to rotate is determined churn limit.
+//
+// Spec pseudocode definition:
+//
+//		def process_registry_updates(state: BeaconState) -> None:
+//		    # Process activation eligibility and ejections
+//		    for index, validator in enumerate(state.validators):
+//		        if is_eligible_for_activation_queue(validator):
+//		            validator.activation_eligibility_epoch = get_current_epoch(state) + 1
+//
+//		        if (
+//		            is_active_validator(validator, get_current_epoch(state))
+//		            and validator.effective_balance <= EJECTION_BALANCE
+//		        ):
+//		            initiate_validator_exit(state, ValidatorIndex(index))
+//
+//	         # Activate all eligible validators
+//	         activation_epoch = compute_activation_exit_epoch(get_current_epoch(state))
+//	         for validator in state.validators:
+//	             if is_eligible_for_activation(state, validator):
+//	                 validator.activation_epoch = activation_epoch
+func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
+	// TODO: replace with real implementation
+	return state, nil
+}

beacon-chain/core/electra/transition.go

@@ -0,0 +1,129 @@
+package electra
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
+	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/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"go.opencensus.io/trace"
+)
+
+// Re-exports for methods that haven't changed in Electra.
+var (
+	InitializePrecomputeValidators       = altair.InitializePrecomputeValidators
+	ProcessEpochParticipation            = altair.ProcessEpochParticipation
+	ProcessInactivityScores              = altair.ProcessInactivityScores
+	ProcessRewardsAndPenaltiesPrecompute = altair.ProcessRewardsAndPenaltiesPrecompute
+	ProcessSlashings                     = e.ProcessSlashings
+	ProcessEth1DataReset                 = e.ProcessEth1DataReset
+	ProcessSlashingsReset                = e.ProcessSlashingsReset
+	ProcessRandaoMixesReset              = e.ProcessRandaoMixesReset
+	ProcessHistoricalDataUpdate          = e.ProcessHistoricalDataUpdate
+	ProcessParticipationFlagUpdates      = altair.ProcessParticipationFlagUpdates
+	ProcessSyncCommitteeUpdates          = altair.ProcessSyncCommitteeUpdates
+	AttestationsDelta                    = altair.AttestationsDelta
+	ProcessSyncAggregate                 = altair.ProcessSyncAggregate
+
+	// These need to be rewritten for electra.
+	ProcessDeposits                      = altair.ProcessDeposits
+	ProcessAttestationsNoVerifySignature = altair.ProcessAttestationsNoVerifySignature
+)
+
+// ProcessEpoch describes the per epoch operations that are performed on the beacon state.
+// It's optimized by pre computing validator attested info and epoch total/attested balances upfront.
+//
+// Spec definition:
+//
+//	def process_epoch(state: BeaconState) -> None:
+//	    process_justification_and_finalization(state)
+//	    process_inactivity_updates(state)
+//	    process_rewards_and_penalties(state)
+//	    process_registry_updates(state)
+//	    process_slashings(state)
+//	    process_eth1_data_reset(state)
+//	    process_pending_balance_deposits(state)  # New in EIP7251
+//	    process_pending_consolidations(state)  # New in EIP7251
+//	    process_effective_balance_updates(state)
+//	    process_slashings_reset(state)
+//	    process_randao_mixes_reset(state)
+func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "electra.ProcessEpoch")
+	defer span.End()
+
+	if state == nil || state.IsNil() {
+		return nil, errors.New("nil state")
+	}
+	vp, bp, err := InitializePrecomputeValidators(ctx, state)
+	if err != nil {
+		return nil, err
+	}
+	vp, bp, err = ProcessEpochParticipation(ctx, state, bp, vp)
+	if err != nil {
+		return nil, err
+	}
+	state, err = precompute.ProcessJustificationAndFinalizationPreCompute(state, bp)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process justification")
+	}
+	state, vp, err = ProcessInactivityScores(ctx, state, vp)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process inactivity updates")
+	}
+	state, err = ProcessRewardsAndPenaltiesPrecompute(state, bp, vp)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process rewards and penalties")
+	}
+	state, err = ProcessRegistryUpdates(ctx, state)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process registry updates")
+	}
+	proportionalSlashingMultiplier, err := state.ProportionalSlashingMultiplier()
+	if err != nil {
+		return nil, err
+	}
+	state, err = ProcessSlashings(state, proportionalSlashingMultiplier)
+	if err != nil {
+		return nil, err
+	}
+	state, err = ProcessEth1DataReset(state)
+	if err != nil {
+		return nil, err
+	}
+	if err = ProcessPendingBalanceDeposits(ctx, state, primitives.Gwei(bp.ActiveCurrentEpoch)); err != nil {
+		return nil, err
+	}
+	if err := ProcessPendingConsolidations(ctx, state); err != nil {
+		return nil, err
+	}
+	if err := ProcessEffectiveBalanceUpdates(state); err != nil {
+		return nil, err
+	}
+	state, err = ProcessSlashingsReset(state)
+	if err != nil {
+		return nil, err
+	}
+	state, err = ProcessRandaoMixesReset(state)
+	if err != nil {
+		return nil, err
+	}
+	state, err = ProcessHistoricalDataUpdate(state)
+	if err != nil {
+		return nil, err
+	}
+
+	state, err = ProcessParticipationFlagUpdates(state)
+	if err != nil {
+		return nil, err
+	}
+
+	state, err = ProcessSyncCommitteeUpdates(ctx, state)
+	if err != nil {
+		return nil, err
+	}
+
+	return state, nil
+}

beacon-chain/core/electra/upgrade.go

@@ -0,0 +1,311 @@
+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"
+	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(primitives.Gwei(tab)),
+		EarliestExitEpoch:             earliestExitEpoch,
+		ConsolidationBalanceToConsume: helpers.ConsolidationChurnLimit(primitives.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
+}

beacon-chain/core/electra/upgrade_test.go

@@ -0,0 +1,188 @@
+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"
+	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, primitives.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(primitives.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(primitives.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))
+
+}

beacon-chain/core/electra/validator.go

@@ -0,0 +1,105 @@
+package electra
+
+import (
+	"context"
+	"errors"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+)
+
+// SwitchToCompoundingValidator
+//
+// Spec definition:
+//
+//	 def switch_to_compounding_validator(state: BeaconState, index: ValidatorIndex) -> None:
+//		validator = state.validators[index]
+//		if has_eth1_withdrawal_credential(validator):
+//		    validator.withdrawal_credentials = COMPOUNDING_WITHDRAWAL_PREFIX + validator.withdrawal_credentials[1:]
+//		    queue_excess_active_balance(state, index)
+func SwitchToCompoundingValidator(ctx context.Context, s state.BeaconState, idx primitives.ValidatorIndex) error {
+	v, err := s.ValidatorAtIndex(idx)
+	if err != nil {
+		return err
+	}
+	if len(v.WithdrawalCredentials) == 0 {
+		return errors.New("validator has no withdrawal credentials")
+	}
+	if helpers.HasETH1WithdrawalCredential(v) {
+		v.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+		if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
+			return err
+		}
+		return queueExcessActiveBalance(ctx, s, idx)
+	}
+	return nil
+}
+
+// queueExcessActiveBalance
+//
+// 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(ctx context.Context, 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]
+//	    state.balances[index] = 0
+//	    validator = state.validators[index]
+//	    validator.effective_balance = 0
+//	    validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
+//	    state.pending_balance_deposits.append(
+//	        PendingBalanceDeposit(index=index, amount=balance)
+//	    )
+//
+//nolint:dupword
+func QueueEntireBalanceAndResetValidator(ctx context.Context, 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)
+}

beacon-chain/core/electra/validator_test.go

@@ -0,0 +1,90 @@
+package electra_test
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	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"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestSwitchToCompoundingValidator(t *testing.T) {
+	s, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{
+		Validators: []*eth.Validator{
+			{
+				WithdrawalCredentials: []byte{}, // No withdrawal credentials
+			},
+			{
+				WithdrawalCredentials: []byte{0x01, 0xFF}, // Has withdrawal credentials
+			},
+			{
+				WithdrawalCredentials: []byte{0x01, 0xFF}, // Has withdrawal credentials
+			},
+		},
+		Balances: []uint64{
+			params.BeaconConfig().MinActivationBalance,
+			params.BeaconConfig().MinActivationBalance,
+			params.BeaconConfig().MinActivationBalance + 100_000, // Has excess balance
+		},
+	})
+	// Test that a validator with no withdrawal credentials cannot be switched to compounding.
+	require.NoError(t, err)
+	require.ErrorContains(t, "validator has no withdrawal credentials", electra.SwitchToCompoundingValidator(context.TODO(), s, 0))
+
+	// Test that a validator with withdrawal credentials can be switched to compounding.
+	require.NoError(t, electra.SwitchToCompoundingValidator(context.TODO(), s, 1))
+	v, err := s.ValidatorAtIndex(1)
+	require.NoError(t, err)
+	require.Equal(t, true, bytes.HasPrefix(v.WithdrawalCredentials, []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte}), "withdrawal credentials were not updated")
+	// val_1 Balance is not changed
+	b, err := s.BalanceAtIndex(1)
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MinActivationBalance, b, "balance was changed")
+	pbd, err := s.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(pbd), "pending balance deposits should be empty")
+
+	// Test that a validator with excess balance can be switched to compounding, excess balance is queued.
+	require.NoError(t, electra.SwitchToCompoundingValidator(context.TODO(), s, 2))
+	b, err = s.BalanceAtIndex(2)
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MinActivationBalance, b, "balance was not changed")
+	pbd, err = s.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(pbd), "pending balance deposits should have one element")
+	require.Equal(t, uint64(100_000), pbd[0].Amount, "pending balance deposit amount is incorrect")
+	require.Equal(t, primitives.ValidatorIndex(2), pbd[0].Index, "pending balance deposit index is incorrect")
+}
+
+func TestQueueEntireBalanceAndResetValidator(t *testing.T) {
+	s, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{
+		Validators: []*eth.Validator{
+			{
+				EffectiveBalance:           params.BeaconConfig().MinActivationBalance + 100_000,
+				ActivationEligibilityEpoch: primitives.Epoch(100),
+			},
+		},
+		Balances: []uint64{
+			params.BeaconConfig().MinActivationBalance + 100_000,
+		},
+	})
+	require.NoError(t, err)
+	require.NoError(t, electra.QueueEntireBalanceAndResetValidator(context.TODO(), s, 0))
+	b, err := s.BalanceAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), b, "balance was not changed")
+	v, err := s.ValidatorAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), v.EffectiveBalance, "effective balance was not reset")
+	require.Equal(t, params.BeaconConfig().FarFutureEpoch, v.ActivationEligibilityEpoch, "activation eligibility epoch was not reset")
+	pbd, err := s.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(pbd), "pending balance deposits should have one element")
+	require.Equal(t, params.BeaconConfig().MinActivationBalance+100_000, pbd[0].Amount, "pending balance deposit amount is incorrect")
+	require.Equal(t, primitives.ValidatorIndex(0), pbd[0].Index, "pending balance deposit index is incorrect")
+}

beacon-chain/core/electra/withdrawals.go

@@ -0,0 +1,80 @@
+package electra
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+)
+
+// ProcessExecutionLayerWithdrawRequests processes the validator withdrawals from the provided execution payload
+// into the beacon state triggered by the execution layer.
+//
+// Spec pseudocode definition:
+//
+// def process_execution_layer_withdrawal_request(
+//
+//		state: BeaconState,
+//		execution_layer_withdrawal_request: ExecutionLayerWithdrawalRequest
+//
+//	 ) -> None:
+//	   amount = execution_layer_withdrawal_request.amount
+//	   is_full_exit_request = amount == FULL_EXIT_REQUEST_AMOUNT
+//
+//	   # If partial withdrawal queue is full, only full exits are processed
+//	   if len(state.pending_partial_withdrawals) == PENDING_PARTIAL_WITHDRAWALS_LIMIT and not is_full_exit_request:
+//	   return
+//
+//	   validator_pubkeys = [v.pubkey for v in state.validators]
+//	   # Verify pubkey exists
+//	   request_pubkey = execution_layer_withdrawal_request.validator_pubkey
+//	   if request_pubkey not in validator_pubkeys:
+//	   return
+//	   index = ValidatorIndex(validator_pubkeys.index(request_pubkey))
+//	   validator = state.validators[index]
+//
+//	   # Verify withdrawal credentials
+//	   has_correct_credential = has_execution_withdrawal_credential(validator)
+//	   is_correct_source_address = (
+//	    validator.withdrawal_credentials[12:] == execution_layer_withdrawal_request.source_address
+//	   )
+//	   if not (has_correct_credential and is_correct_source_address):
+//	   return
+//	   # Verify the validator is active
+//	   if not is_active_validator(validator, get_current_epoch(state)):
+//	   return
+//	   # Verify exit has not been initiated
+//	   if validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	   return
+//	   # Verify the validator has been active long enough
+//	   if get_current_epoch(state) < validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
+//	   return
+//
+//	   pending_balance_to_withdraw = get_pending_balance_to_withdraw(state, index)
+//
+//	   if is_full_exit_request:
+//	   # Only exit validator if it has no pending withdrawals in the queue
+//	   if pending_balance_to_withdraw == 0:
+//	   initiate_validator_exit(state, index)
+//	   return
+//
+//	   has_sufficient_effective_balance = validator.effective_balance >= MIN_ACTIVATION_BALANCE
+//	   has_excess_balance = state.balances[index] > MIN_ACTIVATION_BALANCE + pending_balance_to_withdraw
+//
+//	   # Only allow partial withdrawals with compounding withdrawal credentials
+//	   if has_compounding_withdrawal_credential(validator) and has_sufficient_effective_balance and has_excess_balance:
+//	   to_withdraw = min(
+//	   state.balances[index] - MIN_ACTIVATION_BALANCE - pending_balance_to_withdraw,
+//	    amount
+//	   )
+//	   exit_queue_epoch = compute_exit_epoch_and_update_churn(state, to_withdraw)
+//	   withdrawable_epoch = Epoch(exit_queue_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY)
+//	   state.pending_partial_withdrawals.append(PendingPartialWithdrawal(
+//	   index=index,
+//	   amount=to_withdraw,
+//	   withdrawable_epoch=withdrawable_epoch,
+//	   ))
+func ProcessExecutionLayerWithdrawRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.ExecutionLayerWithdrawalRequest) (state.BeaconState, error) {
+	//TODO: replace with real implementation
+	return st, nil
+}

beacon-chain/core/epoch/epoch_processing.go

@@ -474,7 +474,7 @@ func UnslashedAttestingIndices(ctx context.Context, state state.ReadOnlyBeaconSt
 		if err != nil {
 			return nil, err
 		}
-		attestingIndices, err := attestation.AttestingIndices(att.AggregationBits, committee)
+		attestingIndices, err := attestation.AttestingIndices(att, committee)
 		if err != nil {
 			return nil, err
 		}

beacon-chain/core/epoch/precompute/attestation.go

@@ -58,7 +58,7 @@ func ProcessAttestations(
 		if err != nil {
 			return nil, nil, err
 		}
-		indices, err := attestation.AttestingIndices(a.AggregationBits, committee)
+		indices, err := attestation.AttestingIndices(a, committee)
 		if err != nil {
 			return nil, nil, err
 		}

beacon-chain/core/epoch/precompute/attestation_test.go

@@ -211,7 +211,7 @@ func TestProcessAttestations(t *testing.T) {
 
 	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
 	require.NoError(t, err)
-	indices, err := attestation.AttestingIndices(att1.AggregationBits, committee)
+	indices, err := attestation.AttestingIndices(att1, committee)
 	require.NoError(t, err)
 	for _, i := range indices {
 		if !pVals[i].IsPrevEpochAttester {
@@ -220,7 +220,7 @@ func TestProcessAttestations(t *testing.T) {
 	}
 	committee, err = helpers.BeaconCommitteeFromState(context.Background(), beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
 	require.NoError(t, err)
-	indices, err = attestation.AttestingIndices(att2.AggregationBits, committee)
+	indices, err = attestation.AttestingIndices(att2, committee)
 	require.NoError(t, err)
 	for _, i := range indices {
 		assert.Equal(t, true, pVals[i].IsPrevEpochAttester, "Not a prev epoch attester")

beacon-chain/core/feed/operation/BUILD.bazel

@@ -11,7 +11,6 @@ go_library(
     deps = [
         "//async/event:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
     ],
 )

beacon-chain/core/feed/operation/events.go

@@ -3,7 +3,6 @@ package operation
 
 import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
@@ -38,7 +37,7 @@ const (
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
 type UnAggregatedAttReceivedData struct {
 	// Attestation is the unaggregated attestation object.
-	Attestation interfaces.Attestation
+	Attestation ethpb.Att
 }
 
 // AggregatedAttReceivedData is the data sent with AggregatedAttReceived events.
@@ -76,5 +75,5 @@ type ProposerSlashingReceivedData struct {
 
 // AttesterSlashingReceivedData is the data sent with AttesterSlashingReceived events.
 type AttesterSlashingReceivedData struct {
-	AttesterSlashing interfaces.AttesterSlashing
+	AttesterSlashing ethpb.AttSlashing
 }

beacon-chain/core/helpers/BUILD.bazel

@@ -73,7 +73,6 @@ go_test(
         "//beacon-chain/state/state-native:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
         "//crypto/hash:go_default_library",

beacon-chain/core/helpers/attestation.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"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"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -22,7 +21,7 @@ var (
 // ValidateNilAttestation checks if any composite field of input attestation is nil.
 // Access to these nil fields will result in run time panic,
 // it is recommended to run these checks as first line of defense.
-func ValidateNilAttestation(attestation interfaces.Attestation) error {
+func ValidateNilAttestation(attestation ethpb.Att) error {
 	if attestation == nil {
 		return errors.New("attestation can't be nil")
 	}
@@ -72,7 +71,7 @@ func IsAggregator(committeeCount uint64, slotSig []byte) (bool, error) {
 
 // IsAggregated returns true if the attestation is an aggregated attestation,
 // false otherwise.
-func IsAggregated(attestation interfaces.Attestation) bool {
+func IsAggregated(attestation ethpb.Att) bool {
 	return attestation.GetAggregationBits().Count() > 1
 }
 
@@ -91,7 +90,7 @@ func IsAggregated(attestation interfaces.Attestation) bool {
 //	committees_since_epoch_start = committees_per_slot * slots_since_epoch_start
 //
 //	return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
-func ComputeSubnetForAttestation(activeValCount uint64, att interfaces.Attestation) uint64 {
+func ComputeSubnetForAttestation(activeValCount uint64, att ethpb.Att) uint64 {
 	return ComputeSubnetFromCommitteeAndSlot(activeValCount, att.GetData().CommitteeIndex, att.GetData().Slot)
 }
 

beacon-chain/core/helpers/attestation_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	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/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
@@ -239,7 +238,7 @@ func TestVerifyCheckpointEpoch_Ok(t *testing.T) {
 func TestValidateNilAttestation(t *testing.T) {
 	tests := []struct {
 		name        string
-		attestation interfaces.Attestation
+		attestation ethpb.Att
 		errString   string
 	}{
 		{

beacon-chain/core/helpers/beacon_committee.go

@@ -15,12 +15,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"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/container/slice"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -257,7 +257,7 @@ func VerifyBitfieldLength(bf bitfield.Bitfield, committeeSize uint64) error {
 
 // VerifyAttestationBitfieldLengths verifies that an attestations aggregation bitfields is
 // a valid length matching the size of the committee.
-func VerifyAttestationBitfieldLengths(ctx context.Context, state state.ReadOnlyBeaconState, att interfaces.Attestation) error {
+func VerifyAttestationBitfieldLengths(ctx context.Context, state state.ReadOnlyBeaconState, att ethpb.Att) error {
 	committee, err := BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
 	if err != nil {
 		return errors.Wrap(err, "could not retrieve beacon committees")
@@ -295,6 +295,21 @@ func ShuffledIndices(s state.ReadOnlyBeaconState, epoch primitives.Epoch) ([]pri
 	return UnshuffleList(indices, seed)
 }
 
+// CommitteeIndices return beacon committee indices corresponding to bits that are set on the argument bitfield.
+//
+// Spec pseudocode definition:
+//
+//	def get_committee_indices(committee_bits: Bitvector) -> Sequence[CommitteeIndex]:
+//	   return [CommitteeIndex(index) for index, bit in enumerate(committee_bits) if bit]
+func CommitteeIndices(committeeBits bitfield.Bitfield) []primitives.CommitteeIndex {
+	indices := committeeBits.BitIndices()
+	committeeIndices := make([]primitives.CommitteeIndex, len(indices))
+	for i, ix := range indices {
+		committeeIndices[i] = primitives.CommitteeIndex(uint64(ix))
+	}
+	return committeeIndices
+}
+
 // UpdateCommitteeCache gets called at the beginning of every epoch to cache the committee shuffled indices
 // list with committee index and epoch number. It caches the shuffled indices for the input epoch.
 func UpdateCommitteeCache(ctx context.Context, state state.ReadOnlyBeaconState, e primitives.Epoch) error {

beacon-chain/core/helpers/beacon_committee_test.go

@@ -699,3 +699,12 @@ func TestPrecomputeProposerIndices_Ok(t *testing.T) {
 	}
 	assert.DeepEqual(t, wantedProposerIndices, proposerIndices, "Did not precompute proposer indices correctly")
 }
+
+func TestCommitteeIndices(t *testing.T) {
+	bitfield := bitfield.NewBitvector4()
+	bitfield.SetBitAt(0, true)
+	bitfield.SetBitAt(1, true)
+	bitfield.SetBitAt(3, true)
+	indices := helpers.CommitteeIndices(bitfield)
+	assert.DeepEqual(t, []primitives.CommitteeIndex{0, 1, 3}, indices)
+}

beacon-chain/core/helpers/validator_churn.go

@@ -2,6 +2,7 @@ package helpers
 
 import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
 // BalanceChurnLimit for the current active balance, in gwei.
@@ -18,12 +19,12 @@ import (
 //	        get_total_active_balance(state) // CHURN_LIMIT_QUOTIENT
 //	    )
 //	    return churn - churn % EFFECTIVE_BALANCE_INCREMENT
-func BalanceChurnLimit(activeBalanceGwei uint64) uint64 {
+func BalanceChurnLimit(activeBalance primitives.Gwei) primitives.Gwei {
 	churn := max(
 		params.BeaconConfig().MinPerEpochChurnLimitElectra,
-		(activeBalanceGwei / params.BeaconConfig().ChurnLimitQuotient),
+		(uint64(activeBalance) / params.BeaconConfig().ChurnLimitQuotient),
 	)
-	return churn - churn%params.BeaconConfig().EffectiveBalanceIncrement
+	return primitives.Gwei(churn - churn%params.BeaconConfig().EffectiveBalanceIncrement)
 }
 
 // ActivationExitChurnLimit for the current active balance, in gwei.
@@ -36,8 +37,8 @@ func BalanceChurnLimit(activeBalanceGwei uint64) uint64 {
 //	    Return the churn limit for the current epoch dedicated to activations and exits.
 //	    """
 //	    return min(MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT, get_balance_churn_limit(state))
-func ActivationExitChurnLimit(activeBalanceGwei uint64) uint64 {
-	return min(params.BeaconConfig().MaxPerEpochActivationExitChurnLimit, BalanceChurnLimit(activeBalanceGwei))
+func ActivationExitChurnLimit(activeBalance primitives.Gwei) primitives.Gwei {
+	return min(primitives.Gwei(params.BeaconConfig().MaxPerEpochActivationExitChurnLimit), BalanceChurnLimit(activeBalance))
 }
 
 // ConsolidationChurnLimit for the current active balance, in gwei.
@@ -47,6 +48,6 @@ func ActivationExitChurnLimit(activeBalanceGwei uint64) uint64 {
 //
 //	def get_consolidation_churn_limit(state: BeaconState) -> Gwei:
 //	    return get_balance_churn_limit(state) - get_activation_exit_churn_limit(state)
-func ConsolidationChurnLimit(activeBalanceGwei uint64) uint64 {
-	return BalanceChurnLimit(activeBalanceGwei) - ActivationExitChurnLimit(activeBalanceGwei)
+func ConsolidationChurnLimit(activeBalance primitives.Gwei) primitives.Gwei {
+	return BalanceChurnLimit(activeBalance) - ActivationExitChurnLimit(activeBalance)
 }

beacon-chain/core/helpers/validator_churn_test.go

@@ -5,29 +5,30 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 )
 
 func TestBalanceChurnLimit(t *testing.T) {
 	tests := []struct {
 		name          string
-		activeBalance uint64
-		expected      uint64
+		activeBalance primitives.Gwei
+		expected      primitives.Gwei
 	}{
 		{
 			name:          "less than MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA",
 			activeBalance: 111,
-			expected:      params.BeaconConfig().MinPerEpochChurnLimitElectra,
+			expected:      primitives.Gwei(params.BeaconConfig().MinPerEpochChurnLimitElectra),
 		},
 		{
 			name:          "modulo EFFECTIVE_BALANCE_INCREMENT",
-			activeBalance: 111 + params.BeaconConfig().MinPerEpochChurnLimitElectra*params.BeaconConfig().ChurnLimitQuotient,
-			expected:      params.BeaconConfig().MinPerEpochChurnLimitElectra,
+			activeBalance: primitives.Gwei(111 + params.BeaconConfig().MinPerEpochChurnLimitElectra*params.BeaconConfig().ChurnLimitQuotient),
+			expected:      primitives.Gwei(params.BeaconConfig().MinPerEpochChurnLimitElectra),
 		},
 		{
 			name:          "more than MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA",
-			activeBalance: 2000 * params.BeaconConfig().EffectiveBalanceIncrement * params.BeaconConfig().ChurnLimitQuotient,
-			expected:      2000 * params.BeaconConfig().EffectiveBalanceIncrement,
+			activeBalance: primitives.Gwei(2000 * params.BeaconConfig().EffectiveBalanceIncrement * params.BeaconConfig().ChurnLimitQuotient),
+			expected:      primitives.Gwei(2000 * params.BeaconConfig().EffectiveBalanceIncrement),
 		},
 	}
 
@@ -41,18 +42,18 @@ func TestBalanceChurnLimit(t *testing.T) {
 func TestActivationExitChurnLimit(t *testing.T) {
 	tests := []struct {
 		name          string
-		activeBalance uint64
-		expected      uint64
+		activeBalance primitives.Gwei
+		expected      primitives.Gwei
 	}{
 		{
 			name:          "less than MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT",
 			activeBalance: 1,
-			expected:      params.BeaconConfig().MinPerEpochChurnLimitElectra,
+			expected:      primitives.Gwei(params.BeaconConfig().MinPerEpochChurnLimitElectra),
 		},
 		{
 			name:          "more than MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT",
-			activeBalance: 2000 * params.BeaconConfig().EffectiveBalanceIncrement * params.BeaconConfig().ChurnLimitQuotient,
-			expected:      params.BeaconConfig().MaxPerEpochActivationExitChurnLimit,
+			activeBalance: primitives.Gwei(2000 * params.BeaconConfig().EffectiveBalanceIncrement * params.BeaconConfig().ChurnLimitQuotient),
+			expected:      primitives.Gwei(params.BeaconConfig().MaxPerEpochActivationExitChurnLimit),
 		},
 	}
 
@@ -66,6 +67,6 @@ func TestActivationExitChurnLimit(t *testing.T) {
 // FuzzConsolidationChurnLimit exercises BalanceChurnLimit and ActivationExitChurnLimit
 func FuzzConsolidationChurnLimit(f *testing.F) {
 	f.Fuzz(func(t *testing.T, activeBalance uint64) {
-		helpers.ConsolidationChurnLimit(activeBalance)
+		helpers.ConsolidationChurnLimit(primitives.Gwei(activeBalance))
 	})
 }

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)
+}

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)
+}

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.
 //

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)
+			}
+		})
+	}
+}

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",

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"
@@ -255,14 +256,18 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot primitives.
 					tracing.AnnotateError(span, err)
 					return nil, errors.Wrap(err, "could not process epoch with optimizations")
 				}
-			} else if state.Version() >= version.Altair {
+			} else if state.Version() <= version.Deneb {
 				state, err = altair.ProcessEpoch(ctx, state)
 				if err != nil {
 					tracing.AnnotateError(span, err)
-					return nil, errors.Wrap(err, "could not process epoch")
+					return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
 				}
 			} else {
-				return nil, errors.New("beacon state should have a version")
+				state, err = electra.ProcessEpoch(ctx, state)
+				if err != nil {
+					tracing.AnnotateError(span, err)
+					return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
+				}
 			}
 		}
 		if err := state.SetSlot(state.Slot() + 1); err != nil {
@@ -320,6 +325,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
 }
 

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -8,6 +8,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	b "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition/interop"
 	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
@@ -223,19 +224,29 @@ func ProcessBlockNoVerifyAnySig(
 //
 // Spec pseudocode definition:
 //
-//	def process_operations(state: BeaconState, body: ReadOnlyBeaconBlockBody) -> None:
-//	  # Verify that outstanding deposits are processed up to the maximum number of deposits
-//	  assert len(body.deposits) == min(MAX_DEPOSITS, state.eth1_data.deposit_count - state.eth1_deposit_index)
+//	def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
+//	    # [Modified in Electra:EIP6110]
+//	    # Disable former deposit mechanism once all prior deposits are processed
+//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_receipts_start_index)
+//	    if state.eth1_deposit_index < eth1_deposit_index_limit:
+//	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
+//	    else:
+//	        assert len(body.deposits) == 0
 //
-//	  def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
-//	      for operation in operations:
-//	          fn(state, operation)
+//	    def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
+//	        for operation in operations:
+//	            fn(state, operation)
 //
-//	  for_ops(body.proposer_slashings, process_proposer_slashing)
-//	  for_ops(body.attester_slashings, process_attester_slashing)
-//	  for_ops(body.attestations, process_attestation)
-//	  for_ops(body.deposits, process_deposit)
-//	  for_ops(body.voluntary_exits, process_voluntary_exit)
+//	    for_ops(body.proposer_slashings, process_proposer_slashing)
+//	    for_ops(body.attester_slashings, process_attester_slashing)
+//	    for_ops(body.attestations, process_attestation)  # [Modified in Electra:EIP7549]
+//	    for_ops(body.deposits, process_deposit)  # [Modified in Electra:EIP7251]
+//	    for_ops(body.voluntary_exits, process_voluntary_exit)  # [Modified in Electra:EIP7251]
+//	    for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
+//	    # [New in Electra:EIP7002:EIP7251]
+//	    for_ops(body.execution_payload.withdrawal_requests, process_execution_layer_withdrawal_request)
+//	    for_ops(body.execution_payload.deposit_receipts, process_deposit_receipt)  # [New in Electra:EIP6110]
+//	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
 func ProcessOperationsNoVerifyAttsSigs(
 	ctx context.Context,
 	state state.BeaconState,
@@ -262,6 +273,11 @@ func ProcessOperationsNoVerifyAttsSigs(
 		if err != nil {
 			return nil, err
 		}
+	case version.Electra:
+		state, err = electraOperations(ctx, state, beaconBlock)
+		if err != nil {
+			return nil, err
+		}
 	default:
 		return nil, errors.New("block does not have correct version")
 	}
@@ -378,6 +394,71 @@ func VerifyBlobCommitmentCount(blk interfaces.ReadOnlyBeaconBlock) error {
 	return nil
 }
 
+// electraOperations
+//
+// Spec definition:
+//
+//	def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
+//	    # [Modified in Electra:EIP6110]
+//	    # Disable former deposit mechanism once all prior deposits are processed
+//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_receipts_start_index)
+//	    if state.eth1_deposit_index < eth1_deposit_index_limit:
+//	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
+//	    else:
+//	        assert len(body.deposits) == 0
+//
+//	    def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
+//	        for operation in operations:
+//	            fn(state, operation)
+//
+//	    for_ops(body.proposer_slashings, process_proposer_slashing)
+//	    for_ops(body.attester_slashings, process_attester_slashing)
+//	    for_ops(body.attestations, process_attestation)  # [Modified in Electra:EIP7549]
+//	    for_ops(body.deposits, process_deposit)  # [Modified in Electra:EIP7251]
+//	    for_ops(body.voluntary_exits, process_voluntary_exit)  # [Modified in Electra:EIP7251]
+//	    for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
+//	    # [New in Electra:EIP7002:EIP7251]
+//	    for_ops(body.execution_payload.withdrawal_requests, process_execution_layer_withdrawal_request)
+//	    for_ops(body.execution_payload.deposit_receipts, process_deposit_receipt)  # [New in Electra:EIP6110]
+//	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
+func electraOperations(
+	ctx context.Context,
+	st state.BeaconState,
+	block interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
+	// 6110 validations are in VerifyOperationLengths
+
+	// Electra extends the altair operations.
+	st, err := altairOperations(ctx, st, block)
+	if err != nil {
+		return nil, err
+	}
+	b := block.Body()
+	bod, ok := b.(interfaces.ROBlockBodyElectra)
+	if !ok {
+		return nil, errors.New("could not cast block body to electra block body")
+	}
+	e, err := bod.Execution()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution data from block")
+	}
+	exe, ok := e.(interfaces.ExecutionDataElectra)
+	if !ok {
+		return nil, errors.New("could not cast execution data to electra execution data")
+	}
+	st, err = electra.ProcessExecutionLayerWithdrawRequests(ctx, st, exe.WithdrawalRequests())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process execution layer withdrawal requests")
+	}
+	st, err = electra.ProcessDepositReceipts(ctx, st, exe.DepositReceipts())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process deposit receipts")
+	}
+	if err := electra.ProcessConsolidations(ctx, st, bod.Consolidations()); err != nil {
+		return nil, errors.Wrap(err, "could not process consolidations")
+	}
+	return st, nil
+}
+
 // This calls altair block operations.
 func altairOperations(
 	ctx context.Context,

beacon-chain/core/transition/transition_test.go

@@ -311,7 +311,7 @@ func createFullBlockWithOperations(t *testing.T) (state.BeaconState,
 
 	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, blockAtt.Data.Slot, blockAtt.Data.CommitteeIndex)
 	assert.NoError(t, err)
-	attestingIndices, err := attestation.AttestingIndices(blockAtt.AggregationBits, committee)
+	attestingIndices, err := attestation.AttestingIndices(blockAtt, committee)
 	require.NoError(t, err)
 	assert.NoError(t, err)
 	hashTreeRoot, err = signing.ComputeSigningRoot(blockAtt.Data, domain)
@@ -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'}

beacon-chain/core/validators/BUILD.bazel

@@ -2,7 +2,10 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = ["validator.go"],
+    srcs = [
+        "slashing.go",
+        "validator.go",
+    ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators",
     visibility = [
         "//beacon-chain:__subpackages__",
@@ -15,7 +18,9 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
@@ -24,9 +29,12 @@ go_library(
 go_test(
     name = "go_default_test",
     size = "small",
-    srcs = ["validator_test.go"],
-    embed = [":go_default_library"],
+    srcs = [
+        "slashing_test.go",
+        "validator_test.go",
+    ],
     deps = [
+        ":go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
@@ -36,5 +44,6 @@ go_test(
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
+        "//time/slots:go_default_library",
     ],
 )

beacon-chain/core/validators/slashing.go

@@ -0,0 +1,33 @@
+package validators
+
+import (
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+)
+
+// SlashingParamsPerVersion returns the slashing parameters for the given state version.
+func SlashingParamsPerVersion(v int) (slashingQuotient, proposerRewardQuotient, whistleblowerRewardQuotient uint64, err error) {
+	cfg := params.BeaconConfig()
+	switch v {
+	case version.Phase0:
+		slashingQuotient = cfg.MinSlashingPenaltyQuotient
+		proposerRewardQuotient = cfg.ProposerRewardQuotient
+		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
+	case version.Altair:
+		slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
+		proposerRewardQuotient = cfg.ProposerRewardQuotient
+		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
+	case version.Bellatrix, version.Capella, version.Deneb:
+		slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
+		proposerRewardQuotient = cfg.ProposerRewardQuotient
+		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
+	case version.Electra:
+		slashingQuotient = cfg.MinSlashingPenaltyQuotientElectra
+		proposerRewardQuotient = cfg.ProposerRewardQuotient
+		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotientElectra
+	default:
+		err = errors.New("unknown state version")
+	}
+	return
+}

beacon-chain/core/validators/slashing_test.go

@@ -0,0 +1,18 @@
+package validators_test
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+)
+
+func TestSlashingParamsPerVersion_NoErrors(t *testing.T) {
+	for _, v := range version.All() {
+		_, _, _, err := validators.SlashingParamsPerVersion(v)
+		if err != nil {
+			// If this test is failing, you need to add a case for the version in slashingParamsPerVersion.
+			t.Errorf("Error occurred for version %d: %v", v, err)
+		}
+	}
+}

beacon-chain/core/validators/validator.go

@@ -13,7 +13,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"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/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -43,34 +45,26 @@ func MaxExitEpochAndChurn(s state.BeaconState) (maxExitEpoch primitives.Epoch, c
 
 // InitiateValidatorExit takes in validator index and updates
 // validator with correct voluntary exit parameters.
+// Note: As of Electra, the exitQueueEpoch and churn parameters are unused.
 //
 // Spec pseudocode definition:
 //
 //	def initiate_validator_exit(state: BeaconState, index: ValidatorIndex) -> None:
-//	  """
-//	  Initiate the exit of the validator with index ``index``.
-//	  """
-//	  # Return if validator already initiated exit
-//	  validator = state.validators[index]
-//	  if validator.exit_epoch != FAR_FUTURE_EPOCH:
-//	      return
+//	    """
+//	    Initiate the exit of the validator with index ``index``.
+//	    """
+//	    # Return if validator already initiated exit
+//	    validator = state.validators[index]
+//	    if validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	        return
 //
-//	  # Compute exit queue epoch
-//	  exit_epochs = [v.exit_epoch for v in state.validators if v.exit_epoch != FAR_FUTURE_EPOCH]
-//	  exit_queue_epoch = max(exit_epochs + [compute_activation_exit_epoch(get_current_epoch(state))])
-//	  exit_queue_churn = len([v for v in state.validators if v.exit_epoch == exit_queue_epoch])
-//	  if exit_queue_churn >= get_validator_churn_limit(state):
-//	      exit_queue_epoch += Epoch(1)
+//	    # Compute exit queue epoch [Modified in Electra:EIP7251]
+//	    exit_queue_epoch = compute_exit_epoch_and_update_churn(state, validator.effective_balance)
 //
-//	  # Set validator exit epoch and withdrawable epoch
-//	  validator.exit_epoch = exit_queue_epoch
-//	  validator.withdrawable_epoch = Epoch(validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY)
+//	    # Set validator exit epoch and withdrawable epoch
+//	    validator.exit_epoch = exit_queue_epoch
+//	    validator.withdrawable_epoch = Epoch(validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY)
 func InitiateValidatorExit(ctx context.Context, s state.BeaconState, idx primitives.ValidatorIndex, exitQueueEpoch primitives.Epoch, churn uint64) (state.BeaconState, primitives.Epoch, error) {
-	exitableEpoch := helpers.ActivationExitEpoch(time.CurrentEpoch(s))
-	if exitableEpoch > exitQueueEpoch {
-		exitQueueEpoch = exitableEpoch
-		churn = 0
-	}
 	validator, err := s.ValidatorAtIndex(idx)
 	if err != nil {
 		return nil, 0, err
@@ -78,14 +72,38 @@ func InitiateValidatorExit(ctx context.Context, s state.BeaconState, idx primiti
 	if validator.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
 		return s, validator.ExitEpoch, ErrValidatorAlreadyExited
 	}
-	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, s, time.CurrentEpoch(s))
-	if err != nil {
-		return nil, 0, errors.Wrap(err, "could not get active validator count")
-	}
-	currentChurn := helpers.ValidatorExitChurnLimit(activeValidatorCount)
 
-	if churn >= currentChurn {
-		exitQueueEpoch, err = exitQueueEpoch.SafeAdd(1)
+	// Compute exit queue epoch.
+	if s.Version() < version.Electra {
+		// Relevant spec code from deneb:
+		//
+		//	exit_epochs = [v.exit_epoch for v in state.validators if v.exit_epoch != FAR_FUTURE_EPOCH]
+		//	exit_queue_epoch = max(exit_epochs + [compute_activation_exit_epoch(get_current_epoch(state))])
+		//	exit_queue_churn = len([v for v in state.validators if v.exit_epoch == exit_queue_epoch])
+		//	if exit_queue_churn >= get_validator_churn_limit(state):
+		//	    exit_queue_epoch += Epoch(1)
+		exitableEpoch := helpers.ActivationExitEpoch(time.CurrentEpoch(s))
+		if exitableEpoch > exitQueueEpoch {
+			exitQueueEpoch = exitableEpoch
+			churn = 0
+		}
+		activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, s, time.CurrentEpoch(s))
+		if err != nil {
+			return nil, 0, errors.Wrap(err, "could not get active validator count")
+		}
+		currentChurn := helpers.ValidatorExitChurnLimit(activeValidatorCount)
+
+		if churn >= currentChurn {
+			exitQueueEpoch, err = exitQueueEpoch.SafeAdd(1)
+			if err != nil {
+				return nil, 0, err
+			}
+		}
+	} else {
+		// [Modified in Electra:EIP7251]
+		// exit_queue_epoch = compute_exit_epoch_and_update_churn(state, validator.effective_balance)
+		var err error
+		exitQueueEpoch, err = s.ExitEpochAndUpdateChurn(primitives.Gwei(validator.EffectiveBalance))
 		if err != nil {
 			return nil, 0, err
 		}
@@ -102,7 +120,8 @@ func InitiateValidatorExit(ctx context.Context, s state.BeaconState, idx primiti
 }
 
 // SlashValidator slashes the malicious validator's balance and awards
-// the whistleblower's balance.
+// the whistleblower's balance. Note: This implementation does not handle an
+// optional whistleblower index. The whistleblower index is always the proposer index.
 //
 // Spec pseudocode definition:
 //
@@ -118,22 +137,22 @@ func InitiateValidatorExit(ctx context.Context, s state.BeaconState, idx primiti
 //	  validator.slashed = True
 //	  validator.withdrawable_epoch = max(validator.withdrawable_epoch, Epoch(epoch + EPOCHS_PER_SLASHINGS_VECTOR))
 //	  state.slashings[epoch % EPOCHS_PER_SLASHINGS_VECTOR] += validator.effective_balance
-//	  decrease_balance(state, slashed_index, validator.effective_balance // MIN_SLASHING_PENALTY_QUOTIENT)
+//	  slashing_penalty = validator.effective_balance // MIN_SLASHING_PENALTY_QUOTIENT_EIP7251  # [Modified in EIP7251]
+//	  decrease_balance(state, slashed_index, slashing_penalty)
 //
 //	  # Apply proposer and whistleblower rewards
 //	  proposer_index = get_beacon_proposer_index(state)
 //	  if whistleblower_index is None:
 //	      whistleblower_index = proposer_index
-//	  whistleblower_reward = Gwei(validator.effective_balance // WHISTLEBLOWER_REWARD_QUOTIENT)
-//	  proposer_reward = Gwei(whistleblower_reward // PROPOSER_REWARD_QUOTIENT)
+//	  whistleblower_reward = Gwei(
+//	       validator.effective_balance // WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA)  # [Modified in EIP7251]
+//	  proposer_reward = Gwei(whistleblower_reward * PROPOSER_WEIGHT // WEIGHT_DENOMINATOR)
 //	  increase_balance(state, proposer_index, proposer_reward)
 //	  increase_balance(state, whistleblower_index, Gwei(whistleblower_reward - proposer_reward))
 func SlashValidator(
 	ctx context.Context,
 	s state.BeaconState,
-	slashedIdx primitives.ValidatorIndex,
-	penaltyQuotient uint64,
-	proposerRewardQuotient uint64) (state.BeaconState, error) {
+	slashedIdx primitives.ValidatorIndex) (state.BeaconState, error) {
 	maxExitEpoch, churn := MaxExitEpochAndChurn(s)
 	s, _, err := InitiateValidatorExit(ctx, s, slashedIdx, maxExitEpoch, churn)
 	if err != nil && !errors.Is(err, ErrValidatorAlreadyExited) {
@@ -161,7 +180,17 @@ func SlashValidator(
 	); err != nil {
 		return nil, err
 	}
-	if err := helpers.DecreaseBalance(s, slashedIdx, validator.EffectiveBalance/penaltyQuotient); err != nil {
+
+	slashingQuotient, proposerRewardQuotient, whistleblowerRewardQuotient, err := SlashingParamsPerVersion(s.Version())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get slashing parameters per version")
+	}
+
+	slashingPenalty, err := math.Div64(validator.EffectiveBalance, slashingQuotient)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to compute slashing slashingPenalty")
+	}
+	if err := helpers.DecreaseBalance(s, slashedIdx, slashingPenalty); err != nil {
 		return nil, err
 	}
 
@@ -170,14 +199,18 @@ func SlashValidator(
 		return nil, errors.Wrap(err, "could not get proposer idx")
 	}
 	whistleBlowerIdx := proposerIdx
-	whistleblowerReward := validator.EffectiveBalance / params.BeaconConfig().WhistleBlowerRewardQuotient
-	proposerReward := whistleblowerReward / proposerRewardQuotient
-	err = helpers.IncreaseBalance(s, proposerIdx, proposerReward)
+	whistleblowerReward, err := math.Div64(validator.EffectiveBalance, whistleblowerRewardQuotient)
 	if err != nil {
+		return nil, errors.Wrap(err, "failed to compute whistleblowerReward")
+	}
+	proposerReward, err := math.Div64(whistleblowerReward, proposerRewardQuotient)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to compute proposer reward")
+	}
+	if err := helpers.IncreaseBalance(s, proposerIdx, proposerReward); err != nil {
 		return nil, err
 	}
-	err = helpers.IncreaseBalance(s, whistleBlowerIdx, whistleblowerReward-proposerReward)
-	if err != nil {
+	if err := helpers.IncreaseBalance(s, whistleBlowerIdx, whistleblowerReward-proposerReward); err != nil {
 		return nil, err
 	}
 	return s, nil

beacon-chain/core/validators/validator_test.go

@@ -1,4 +1,4 @@
-package validators
+package validators_test
 
 import (
 	"context"
@@ -6,6 +6,7 @@ import (
 
 	"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/core/validators"
 	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"
@@ -13,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
 func TestHasVoted_OK(t *testing.T) {
@@ -48,8 +50,8 @@ func TestInitiateValidatorExit_AlreadyExited(t *testing.T) {
 	}}
 	state, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	newState, epoch, err := InitiateValidatorExit(context.Background(), state, 0, 199, 1)
-	require.ErrorIs(t, err, ErrValidatorAlreadyExited)
+	newState, epoch, err := validators.InitiateValidatorExit(context.Background(), state, 0, 199, 1)
+	require.ErrorIs(t, err, validators.ErrValidatorAlreadyExited)
 	require.Equal(t, exitEpoch, epoch)
 	v, err := newState.ValidatorAtIndex(0)
 	require.NoError(t, err)
@@ -67,7 +69,7 @@ func TestInitiateValidatorExit_ProperExit(t *testing.T) {
 	}}
 	state, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	newState, epoch, err := InitiateValidatorExit(context.Background(), state, idx, exitedEpoch+2, 1)
+	newState, epoch, err := validators.InitiateValidatorExit(context.Background(), state, idx, exitedEpoch+2, 1)
 	require.NoError(t, err)
 	require.Equal(t, exitedEpoch+2, epoch)
 	v, err := newState.ValidatorAtIndex(idx)
@@ -87,7 +89,7 @@ func TestInitiateValidatorExit_ChurnOverflow(t *testing.T) {
 	}}
 	state, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	newState, epoch, err := InitiateValidatorExit(context.Background(), state, idx, exitedEpoch+2, 4)
+	newState, epoch, err := validators.InitiateValidatorExit(context.Background(), state, idx, exitedEpoch+2, 4)
 	require.NoError(t, err)
 	require.Equal(t, exitedEpoch+3, epoch)
 
@@ -109,10 +111,58 @@ func TestInitiateValidatorExit_WithdrawalOverflows(t *testing.T) {
 	}}
 	state, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	_, _, err = InitiateValidatorExit(context.Background(), state, 1, params.BeaconConfig().FarFutureEpoch-1, 1)
+	_, _, err = validators.InitiateValidatorExit(context.Background(), state, 1, params.BeaconConfig().FarFutureEpoch-1, 1)
 	require.ErrorContains(t, "addition overflows", err)
 }
 
+func TestInitiateValidatorExit_ProperExit_Electra(t *testing.T) {
+	exitedEpoch := primitives.Epoch(100)
+	idx := primitives.ValidatorIndex(3)
+	base := &ethpb.BeaconStateElectra{
+		Slot: slots.UnsafeEpochStart(exitedEpoch + 1),
+		Validators: []*ethpb.Validator{
+			{
+				ExitEpoch:        exitedEpoch,
+				EffectiveBalance: params.BeaconConfig().MinActivationBalance,
+			},
+			{
+				ExitEpoch:        exitedEpoch + 1,
+				EffectiveBalance: params.BeaconConfig().MinActivationBalance,
+			},
+			{
+				ExitEpoch:        exitedEpoch + 2,
+				EffectiveBalance: params.BeaconConfig().MinActivationBalance,
+			},
+			{
+				ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
+				EffectiveBalance: params.BeaconConfig().MinActivationBalance,
+			},
+		},
+	}
+	state, err := state_native.InitializeFromProtoElectra(base)
+	require.NoError(t, err)
+
+	// Pre-check: Exit balance to consume should be zero.
+	ebtc, err := state.ExitBalanceToConsume()
+	require.NoError(t, err)
+	require.Equal(t, primitives.Gwei(0), ebtc)
+
+	newState, epoch, err := validators.InitiateValidatorExit(context.Background(), state, idx, 0, 0) // exitQueueEpoch and churn are not used in electra
+	require.NoError(t, err)
+
+	// Expect that the exit epoch is the next available epoch with max seed lookahead.
+	want := helpers.ActivationExitEpoch(exitedEpoch + 1)
+	require.Equal(t, want, epoch)
+	v, err := newState.ValidatorAtIndex(idx)
+	require.NoError(t, err)
+	assert.Equal(t, want, v.ExitEpoch, "Exit epoch was not the highest")
+
+	// Check that the exit balance to consume has been updated on the state.
+	ebtc, err = state.ExitBalanceToConsume()
+	require.NoError(t, err)
+	require.NotEqual(t, primitives.Gwei(0), ebtc, "Exit balance to consume was not updated")
+}
+
 func TestSlashValidator_OK(t *testing.T) {
 	validatorCount := 100
 	registry := make([]*ethpb.Validator, 0, validatorCount)
@@ -141,8 +191,7 @@ func TestSlashValidator_OK(t *testing.T) {
 	require.NoError(t, err, "Could not get proposer")
 	proposerBal, err := state.BalanceAtIndex(proposer)
 	require.NoError(t, err)
-	cfg := params.BeaconConfig()
-	slashedState, err := SlashValidator(context.Background(), state, slashedIdx, cfg.MinSlashingPenaltyQuotient, cfg.ProposerRewardQuotient)
+	slashedState, err := validators.SlashValidator(context.Background(), state, slashedIdx)
 	require.NoError(t, err, "Could not slash validator")
 	require.Equal(t, true, slashedState.Version() == version.Phase0)
 
@@ -167,6 +216,59 @@ func TestSlashValidator_OK(t *testing.T) {
 	assert.Equal(t, maxBalance-(v.EffectiveBalance/params.BeaconConfig().MinSlashingPenaltyQuotient), bal, "Did not get expected balance for slashed validator")
 }
 
+func TestSlashValidator_Electra(t *testing.T) {
+	validatorCount := 100
+	registry := make([]*ethpb.Validator, 0, validatorCount)
+	balances := make([]uint64, 0, validatorCount)
+	for i := 0; i < validatorCount; i++ {
+		registry = append(registry, &ethpb.Validator{
+			ActivationEpoch:  0,
+			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
+			EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
+		})
+		balances = append(balances, params.BeaconConfig().MaxEffectiveBalance)
+	}
+
+	base := &ethpb.BeaconStateElectra{
+		Validators:  registry,
+		Slashings:   make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		Balances:    balances,
+	}
+	state, err := state_native.InitializeFromProtoElectra(base)
+	require.NoError(t, err)
+
+	slashedIdx := primitives.ValidatorIndex(3)
+
+	proposer, err := helpers.BeaconProposerIndex(context.Background(), state)
+	require.NoError(t, err, "Could not get proposer")
+	proposerBal, err := state.BalanceAtIndex(proposer)
+	require.NoError(t, err)
+	slashedState, err := validators.SlashValidator(context.Background(), state, slashedIdx)
+	require.NoError(t, err, "Could not slash validator")
+	require.Equal(t, true, slashedState.Version() == version.Electra)
+
+	v, err := state.ValidatorAtIndex(slashedIdx)
+	require.NoError(t, err)
+	assert.Equal(t, true, v.Slashed, "Validator not slashed despite supposed to being slashed")
+	assert.Equal(t, time.CurrentEpoch(state)+params.BeaconConfig().EpochsPerSlashingsVector, v.WithdrawableEpoch, "Withdrawable epoch not the expected value")
+
+	maxBalance := params.BeaconConfig().MaxEffectiveBalance
+	slashedBalance := state.Slashings()[state.Slot().Mod(uint64(params.BeaconConfig().EpochsPerSlashingsVector))]
+	assert.Equal(t, maxBalance, slashedBalance, "Slashed balance isn't the expected amount")
+
+	whistleblowerReward := slashedBalance / params.BeaconConfig().WhistleBlowerRewardQuotientElectra
+	bal, err := state.BalanceAtIndex(proposer)
+	require.NoError(t, err)
+	// The proposer is the whistleblower.
+	assert.Equal(t, proposerBal+whistleblowerReward, bal, "Did not get expected balance for proposer")
+	bal, err = state.BalanceAtIndex(slashedIdx)
+	require.NoError(t, err)
+	v, err = state.ValidatorAtIndex(slashedIdx)
+	require.NoError(t, err)
+	assert.Equal(t, maxBalance-(v.EffectiveBalance/params.BeaconConfig().MinSlashingPenaltyQuotientElectra), bal, "Did not get expected balance for slashed validator")
+}
+
 func TestActivatedValidatorIndices(t *testing.T) {
 	tests := []struct {
 		state  *ethpb.BeaconState
@@ -219,7 +321,7 @@ func TestActivatedValidatorIndices(t *testing.T) {
 	for _, tt := range tests {
 		s, err := state_native.InitializeFromProtoPhase0(tt.state)
 		require.NoError(t, err)
-		activatedIndices := ActivatedValidatorIndices(time.CurrentEpoch(s), tt.state.Validators)
+		activatedIndices := validators.ActivatedValidatorIndices(time.CurrentEpoch(s), tt.state.Validators)
 		assert.DeepEqual(t, tt.wanted, activatedIndices)
 	}
 }
@@ -273,7 +375,7 @@ func TestSlashedValidatorIndices(t *testing.T) {
 	for _, tt := range tests {
 		s, err := state_native.InitializeFromProtoPhase0(tt.state)
 		require.NoError(t, err)
-		slashedIndices := SlashedValidatorIndices(time.CurrentEpoch(s), tt.state.Validators)
+		slashedIndices := validators.SlashedValidatorIndices(time.CurrentEpoch(s), tt.state.Validators)
 		assert.DeepEqual(t, tt.wanted, slashedIndices)
 	}
 }
@@ -335,7 +437,7 @@ func TestExitedValidatorIndices(t *testing.T) {
 		require.NoError(t, err)
 		activeCount, err := helpers.ActiveValidatorCount(context.Background(), s, time.PrevEpoch(s))
 		require.NoError(t, err)
-		exitedIndices, err := ExitedValidatorIndices(0, tt.state.Validators, activeCount)
+		exitedIndices, err := validators.ExitedValidatorIndices(0, tt.state.Validators, activeCount)
 		require.NoError(t, err)
 		assert.DeepEqual(t, tt.wanted, exitedIndices)
 	}
@@ -410,7 +512,7 @@ func TestValidatorMaxExitEpochAndChurn(t *testing.T) {
 	for _, tt := range tests {
 		s, err := state_native.InitializeFromProtoPhase0(tt.state)
 		require.NoError(t, err)
-		epoch, churn := MaxExitEpochAndChurn(s)
+		epoch, churn := validators.MaxExitEpochAndChurn(s)
 		require.Equal(t, tt.wantedEpoch, epoch)
 		require.Equal(t, tt.wantedChurn, churn)
 	}

beacon-chain/db/kv/blocks.go

@@ -813,6 +813,16 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.ReadOnlySignedBea
 		if err := rawBlock.UnmarshalSSZ(enc[len(denebBlindKey):]); err != nil {
 			return nil, errors.Wrap(err, "could not unmarshal blinded Deneb block")
 		}
+	case hasElectraKey(enc):
+		rawBlock = &ethpb.SignedBeaconBlockElectra{}
+		if err := rawBlock.UnmarshalSSZ(enc[len(electraKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Electra block")
+		}
+	case hasElectraBlindKey(enc):
+		rawBlock = &ethpb.SignedBlindedBeaconBlockElectra{}
+		if err := rawBlock.UnmarshalSSZ(enc[len(electraBlindKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal blinded Electra block")
+		}
 	default:
 		// Marshal block bytes to phase 0 beacon block.
 		rawBlock = &ethpb.SignedBeaconBlock{}
@@ -842,6 +852,11 @@ func encodeBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 
 func keyForBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 	switch blk.Version() {
+	case version.Electra:
+		if blk.IsBlinded() {
+			return electraBlindKey, nil
+		}
+		return electraKey, nil
 	case version.Deneb:
 		if blk.IsBlinded() {
 			return denebBlindKey, nil

beacon-chain/db/kv/blocks_test.go

@@ -125,6 +125,47 @@ var blockTests = []struct {
 			return blocks.NewSignedBeaconBlock(b)
 		},
 	},
+	{
+		name: "electra",
+		newBlock: func(slot primitives.Slot, root []byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
+			b := util.NewBeaconBlockElectra()
+			b.Block.Slot = slot
+			if root != nil {
+				b.Block.ParentRoot = root
+				b.Block.Body.Consolidations = []*ethpb.SignedConsolidation{
+					{
+						Message: &ethpb.Consolidation{
+							SourceIndex: 1,
+							TargetIndex: 2,
+							Epoch:       3,
+						},
+						Signature: make([]byte, 96),
+					},
+				}
+			}
+			return blocks.NewSignedBeaconBlock(b)
+		},
+	},
+	{
+		name: "electra blind",
+		newBlock: func(slot primitives.Slot, root []byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
+			b := util.NewBlindedBeaconBlockElectra()
+			b.Message.Slot = slot
+			if root != nil {
+				b.Message.ParentRoot = root
+				b.Message.Body.Consolidations = []*ethpb.SignedConsolidation{
+					{
+						Message: &ethpb.Consolidation{
+							SourceIndex: 1,
+							TargetIndex: 2,
+							Epoch:       3,
+						},
+						Signature: make([]byte, 96),
+					},
+				}
+			}
+			return blocks.NewSignedBeaconBlock(b)
+		}},
 }
 
 func TestStore_SaveBlock_NoDuplicates(t *testing.T) {

beacon-chain/db/kv/key.go

@@ -51,3 +51,17 @@ func hasDenebBlindKey(enc []byte) bool {
 	}
 	return bytes.Equal(enc[:len(denebBlindKey)], denebBlindKey)
 }
+
+func hasElectraKey(enc []byte) bool {
+	if len(electraKey) >= len(enc) {
+		return false
+	}
+	return bytes.Equal(enc[:len(electraKey)], electraKey)
+}
+
+func hasElectraBlindKey(enc []byte) bool {
+	if len(electraBlindKey) >= len(enc) {
+		return false
+	}
+	return bytes.Equal(enc[:len(electraBlindKey)], electraBlindKey)
+}

beacon-chain/db/kv/schema.go

@@ -48,6 +48,8 @@ var (
 	saveBlindedBeaconBlocksKey = []byte("save-blinded-beacon-blocks")
 	denebKey                   = []byte("deneb")
 	denebBlindKey              = []byte("blind-deneb")
+	electraKey                 = []byte("electra")
+	electraBlindKey            = []byte("blind-electra")
 
 	// block root included in the beacon state used by weak subjectivity initial sync
 	originCheckpointBlockRootKey = []byte("origin-checkpoint-block-root")

beacon-chain/db/kv/state.go

@@ -229,160 +229,142 @@ func (s *Store) saveStatesEfficientInternal(ctx context.Context, tx *bolt.Tx, bl
 		// look at issue https://github.com/prysmaticlabs/prysm/issues/9262.
 		switch rawType := states[i].ToProtoUnsafe().(type) {
 		case *ethpb.BeaconState:
-			pbState, err := getPhase0PbState(rawType)
-			if err != nil {
-				return err
-			}
-			valEntries := pbState.Validators
-			pbState.Validators = make([]*ethpb.Validator, 0)
-			encodedState, err := encode(ctx, pbState)
-			if err != nil {
-				return err
-			}
-			pbState.Validators = valEntries
-			if err := bucket.Put(rt[:], encodedState); err != nil {
-				return err
-			}
-			if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
+			if err := s.processPhase0(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
 				return err
 			}
 		case *ethpb.BeaconStateAltair:
-			pbState, err := getAltairPbState(rawType)
-			if err != nil {
-				return err
-			}
-			valEntries := pbState.Validators
-			pbState.Validators = make([]*ethpb.Validator, 0)
-			rawObj, err := pbState.MarshalSSZ()
-			if err != nil {
-				return err
-			}
-			encodedState := snappy.Encode(nil, append(altairKey, rawObj...))
-			if err := bucket.Put(rt[:], encodedState); err != nil {
-				return err
-			}
-			pbState.Validators = valEntries
-			if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
+			if err := s.processAltair(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
 				return err
 			}
 		case *ethpb.BeaconStateBellatrix:
-			pbState, err := getBellatrixPbState(rawType)
-			if err != nil {
-				return err
-			}
-			valEntries := pbState.Validators
-			pbState.Validators = make([]*ethpb.Validator, 0)
-			rawObj, err := pbState.MarshalSSZ()
-			if err != nil {
-				return err
-			}
-			encodedState := snappy.Encode(nil, append(bellatrixKey, rawObj...))
-			if err := bucket.Put(rt[:], encodedState); err != nil {
-				return err
-			}
-			pbState.Validators = valEntries
-			if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
+			if err := s.processBellatrix(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
 				return err
 			}
 		case *ethpb.BeaconStateCapella:
-			pbState, err := getCapellaPbState(rawType)
-			if err != nil {
-				return err
-			}
-			valEntries := pbState.Validators
-			pbState.Validators = make([]*ethpb.Validator, 0)
-			rawObj, err := pbState.MarshalSSZ()
-			if err != nil {
-				return err
-			}
-			encodedState := snappy.Encode(nil, append(capellaKey, rawObj...))
-			if err := bucket.Put(rt[:], encodedState); err != nil {
-				return err
-			}
-			pbState.Validators = valEntries
-			if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
+			if err := s.processCapella(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
 				return err
 			}
 		case *ethpb.BeaconStateDeneb:
-			pbState, err := getDenebPbState(rawType)
-			if err != nil {
+			if err := s.processDeneb(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
 				return err
 			}
-			valEntries := pbState.Validators
-			pbState.Validators = make([]*ethpb.Validator, 0)
-			rawObj, err := pbState.MarshalSSZ()
-			if err != nil {
-				return err
-			}
-			encodedState := snappy.Encode(nil, append(denebKey, rawObj...))
-			if err := bucket.Put(rt[:], encodedState); err != nil {
-				return err
-			}
-			pbState.Validators = valEntries
-			if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
+		case *ethpb.BeaconStateElectra:
+			if err := s.processElectra(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
 				return err
 			}
 		default:
 			return errors.New("invalid state type")
 		}
 	}
-	// store the validator entries separately to save space.
+
 	return s.storeValidatorEntriesSeparately(ctx, tx, validatorsEntries)
 }
 
-func getPhase0PbState(rawState interface{}) (*ethpb.BeaconState, error) {
-	pbState, err := statenative.ProtobufBeaconStatePhase0(rawState)
+func (s *Store) processPhase0(ctx context.Context, pbState *ethpb.BeaconState, rootHash []byte, bucket, valIdxBkt *bolt.Bucket, validatorKey []byte) error {
+	valEntries := pbState.Validators
+	pbState.Validators = make([]*ethpb.Validator, 0)
+	encodedState, err := encode(ctx, pbState)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	if pbState == nil {
-		return nil, errors.New("nil state")
+	pbState.Validators = valEntries
+	if err := bucket.Put(rootHash, encodedState); err != nil {
+		return err
 	}
-	return pbState, nil
+	if err := valIdxBkt.Put(rootHash, validatorKey); err != nil {
+		return err
+	}
+	return nil
 }
 
-func getAltairPbState(rawState interface{}) (*ethpb.BeaconStateAltair, error) {
-	pbState, err := statenative.ProtobufBeaconStateAltair(rawState)
+func (s *Store) processAltair(ctx context.Context, pbState *ethpb.BeaconStateAltair, rootHash []byte, bucket, valIdxBkt *bolt.Bucket, validatorKey []byte) error {
+	valEntries := pbState.Validators
+	pbState.Validators = make([]*ethpb.Validator, 0)
+	rawObj, err := pbState.MarshalSSZ()
 	if err != nil {
-		return nil, err
+		return err
 	}
-	if pbState == nil {
-		return nil, errors.New("nil state")
+	encodedState := snappy.Encode(nil, append(altairKey, rawObj...))
+	if err := bucket.Put(rootHash, encodedState); err != nil {
+		return err
 	}
-	return pbState, nil
+	pbState.Validators = valEntries
+	if err := valIdxBkt.Put(rootHash, validatorKey); err != nil {
+		return err
+	}
+	return nil
 }
 
-func getBellatrixPbState(rawState interface{}) (*ethpb.BeaconStateBellatrix, error) {
-	pbState, err := statenative.ProtobufBeaconStateBellatrix(rawState)
+func (s *Store) processBellatrix(ctx context.Context, pbState *ethpb.BeaconStateBellatrix, rootHash []byte, bucket, valIdxBkt *bolt.Bucket, validatorKey []byte) error {
+	valEntries := pbState.Validators
+	pbState.Validators = make([]*ethpb.Validator, 0)
+	rawObj, err := pbState.MarshalSSZ()
 	if err != nil {
-		return nil, err
+		return err
 	}
-	if pbState == nil {
-		return nil, errors.New("nil state")
+	encodedState := snappy.Encode(nil, append(bellatrixKey, rawObj...))
+	if err := bucket.Put(rootHash, encodedState); err != nil {
+		return err
 	}
-	return pbState, nil
+	pbState.Validators = valEntries
+	if err := valIdxBkt.Put(rootHash, validatorKey); err != nil {
+		return err
+	}
+	return nil
 }
 
-func getCapellaPbState(rawState interface{}) (*ethpb.BeaconStateCapella, error) {
-	pbState, err := statenative.ProtobufBeaconStateCapella(rawState)
+func (s *Store) processCapella(ctx context.Context, pbState *ethpb.BeaconStateCapella, rootHash []byte, bucket, valIdxBkt *bolt.Bucket, validatorKey []byte) error {
+	valEntries := pbState.Validators
+	pbState.Validators = make([]*ethpb.Validator, 0)
+	rawObj, err := pbState.MarshalSSZ()
 	if err != nil {
-		return nil, err
+		return err
 	}
-	if pbState == nil {
-		return nil, errors.New("nil state")
+	encodedState := snappy.Encode(nil, append(capellaKey, rawObj...))
+	if err := bucket.Put(rootHash, encodedState); err != nil {
+		return err
 	}
-	return pbState, nil
+	pbState.Validators = valEntries
+	if err := valIdxBkt.Put(rootHash, validatorKey); err != nil {
+		return err
+	}
+	return nil
 }
 
-func getDenebPbState(rawState interface{}) (*ethpb.BeaconStateDeneb, error) {
-	pbState, err := statenative.ProtobufBeaconStateDeneb(rawState)
+func (s *Store) processDeneb(ctx context.Context, pbState *ethpb.BeaconStateDeneb, rootHash []byte, bucket, valIdxBkt *bolt.Bucket, validatorKey []byte) error {
+	valEntries := pbState.Validators
+	pbState.Validators = make([]*ethpb.Validator, 0)
+	rawObj, err := pbState.MarshalSSZ()
 	if err != nil {
-		return nil, err
+		return err
 	}
-	if pbState == nil {
-		return nil, errors.New("nil state")
+	encodedState := snappy.Encode(nil, append(denebKey, rawObj...))
+	if err := bucket.Put(rootHash, encodedState); err != nil {
+		return err
 	}
-	return pbState, nil
+	pbState.Validators = valEntries
+	if err := valIdxBkt.Put(rootHash, validatorKey); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *Store) processElectra(ctx context.Context, pbState *ethpb.BeaconStateElectra, rootHash []byte, bucket, valIdxBkt *bolt.Bucket, validatorKey []byte) error {
+	valEntries := pbState.Validators
+	pbState.Validators = make([]*ethpb.Validator, 0)
+	rawObj, err := pbState.MarshalSSZ()
+	if err != nil {
+		return err
+	}
+	encodedState := snappy.Encode(nil, append(electraKey, rawObj...))
+	if err := bucket.Put(rootHash, encodedState); err != nil {
+		return err
+	}
+	pbState.Validators = valEntries
+	if err := valIdxBkt.Put(rootHash, validatorKey); err != nil {
+		return err
+	}
+	return nil
 }
 
 func (s *Store) storeValidatorEntriesSeparately(ctx context.Context, tx *bolt.Tx, validatorsEntries map[string]*ethpb.Validator) error {
@@ -534,6 +516,19 @@ func (s *Store) unmarshalState(_ context.Context, enc []byte, validatorEntries [
 	}
 
 	switch {
+	case hasElectraKey(enc):
+		protoState := &ethpb.BeaconStateElectra{}
+		if err := protoState.UnmarshalSSZ(enc[len(electraKey):]); err != nil {
+			return nil, errors.Wrap(err, "failed to unmarshal encoding for Electra")
+		}
+		ok, err := s.isStateValidatorMigrationOver()
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			protoState.Validators = validatorEntries
+		}
+		return statenative.InitializeFromProtoUnsafeElectra(protoState)
 	case hasDenebKey(enc):
 		protoState := &ethpb.BeaconStateDeneb{}
 		if err := protoState.UnmarshalSSZ(enc[len(denebKey):]); err != nil {
@@ -667,6 +662,19 @@ func marshalState(ctx context.Context, st state.ReadOnlyBeaconState) ([]byte, er
 			return nil, err
 		}
 		return snappy.Encode(nil, append(denebKey, rawObj...)), nil
+	case *ethpb.BeaconStateElectra:
+		rState, ok := st.ToProtoUnsafe().(*ethpb.BeaconStateElectra)
+		if !ok {
+			return nil, errors.New("non valid inner state")
+		}
+		if rState == nil {
+			return nil, errors.New("nil state")
+		}
+		rawObj, err := rState.MarshalSSZ()
+		if err != nil {
+			return nil, err
+		}
+		return snappy.Encode(nil, append(electraKey, rawObj...)), nil
 	default:
 		return nil, errors.New("invalid inner state")
 	}

beacon-chain/db/kv/state_test.go

@@ -3,7 +3,6 @@ package kv
 import (
 	"context"
 	"encoding/binary"
-	"math/big"
 	"math/rand"
 	"strconv"
 	"testing"
@@ -100,7 +99,7 @@ func TestState_CanSaveRetrieve(t *testing.T) {
 					BlockHash:        make([]byte, 32),
 					TransactionsRoot: make([]byte, 32),
 					WithdrawalsRoot:  make([]byte, 32),
-				}, big.NewInt(0))
+				})
 				require.NoError(t, err)
 				require.NoError(t, st.SetLatestExecutionPayloadHeader(p))
 				return st
@@ -125,13 +124,40 @@ func TestState_CanSaveRetrieve(t *testing.T) {
 					BlockHash:        make([]byte, 32),
 					TransactionsRoot: make([]byte, 32),
 					WithdrawalsRoot:  make([]byte, 32),
-				}, big.NewInt(0))
+				})
 				require.NoError(t, err)
 				require.NoError(t, st.SetLatestExecutionPayloadHeader(p))
 				return st
 			},
 			rootSeed: 'D',
 		},
+		{
+			name: "electra",
+			s: func() state.BeaconState {
+				st, err := util.NewBeaconStateElectra()
+				require.NoError(t, err)
+				require.NoError(t, st.SetSlot(100))
+				p, err := blocks.WrappedExecutionPayloadHeaderElectra(&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:              []byte("foo"),
+					BaseFeePerGas:          make([]byte, 32),
+					BlockHash:              make([]byte, 32),
+					TransactionsRoot:       make([]byte, 32),
+					WithdrawalsRoot:        make([]byte, 32),
+					DepositReceiptsRoot:    make([]byte, 32),
+					WithdrawalRequestsRoot: make([]byte, 32),
+				})
+				require.NoError(t, err)
+				require.NoError(t, st.SetLatestExecutionPayloadHeader(p))
+				return st
+			},
+			rootSeed: 'E',
+		},
 	}
 
 	db := setupDB(t)
@@ -1138,6 +1164,100 @@ func TestStateDeneb_CanSaveRetrieveValidatorEntries(t *testing.T) {
 	require.NoError(t, err)
 }
 
+func TestElectraState_CanSaveRetrieve(t *testing.T) {
+	db := setupDB(t)
+
+	r := [32]byte{'A'}
+
+	require.Equal(t, false, db.HasState(context.Background(), r))
+
+	st, _ := util.DeterministicGenesisStateElectra(t, 1)
+	require.NoError(t, st.SetSlot(100))
+
+	require.NoError(t, db.SaveState(context.Background(), st, r))
+	require.Equal(t, true, db.HasState(context.Background(), r))
+
+	savedS, err := db.State(context.Background(), r)
+	require.NoError(t, err)
+
+	assert.DeepSSZEqual(t, st.ToProtoUnsafe(), savedS.ToProtoUnsafe())
+
+	savedS, err = db.State(context.Background(), [32]byte{'B'})
+	require.NoError(t, err)
+	require.Equal(t, state.ReadOnlyBeaconState(nil), savedS, "Unsaved state should've been nil")
+}
+
+func TestElectraState_CanDelete(t *testing.T) {
+	db := setupDB(t)
+
+	r := [32]byte{'A'}
+
+	require.Equal(t, false, db.HasState(context.Background(), r))
+
+	st, _ := util.DeterministicGenesisStateElectra(t, 1)
+	require.NoError(t, st.SetSlot(100))
+
+	require.NoError(t, db.SaveState(context.Background(), st, r))
+	require.Equal(t, true, db.HasState(context.Background(), r))
+
+	require.NoError(t, db.DeleteState(context.Background(), r))
+	savedS, err := db.State(context.Background(), r)
+	require.NoError(t, err)
+	require.Equal(t, state.ReadOnlyBeaconState(nil), savedS, "Unsaved state should've been nil")
+}
+
+func TestStateElectra_CanSaveRetrieveValidatorEntries(t *testing.T) {
+	db := setupDB(t)
+
+	// enable historical state representation flag to test this
+	resetCfg := features.InitWithReset(&features.Flags{
+		EnableHistoricalSpaceRepresentation: true,
+	})
+	defer resetCfg()
+
+	r := [32]byte{'A'}
+
+	require.Equal(t, false, db.HasState(context.Background(), r))
+
+	stateValidators := validators(10)
+	st, _ := util.DeterministicGenesisStateElectra(t, 20)
+	require.NoError(t, st.SetSlot(100))
+	require.NoError(t, st.SetValidators(stateValidators))
+
+	ctx := context.Background()
+	require.NoError(t, db.SaveState(ctx, st, r))
+	assert.Equal(t, true, db.HasState(context.Background(), r))
+
+	savedS, err := db.State(context.Background(), r)
+	require.NoError(t, err)
+
+	require.DeepSSZEqual(t, st.Validators(), savedS.Validators(), "saved state with validators and retrieved state are not matching")
+
+	// check if the index of the second state is still present.
+	err = db.db.Update(func(tx *bolt.Tx) error {
+		idxBkt := tx.Bucket(blockRootValidatorHashesBucket)
+		data := idxBkt.Get(r[:])
+		require.NotEqual(t, 0, len(data))
+		return nil
+	})
+	require.NoError(t, err)
+
+	// check if all the validator entries are still intact in the validator entry bucket.
+	err = db.db.Update(func(tx *bolt.Tx) error {
+		valBkt := tx.Bucket(stateValidatorsBucket)
+		// if any of the original validator entry is not present, then fail the test.
+		for _, val := range stateValidators {
+			hash, hashErr := val.HashTreeRoot()
+			assert.NoError(t, hashErr)
+			data := valBkt.Get(hash[:])
+			require.NotNil(t, data)
+			require.NotEqual(t, 0, len(data))
+		}
+		return nil
+	})
+	require.NoError(t, err)
+}
+
 func BenchmarkState_CheckStateSaveTime_1(b *testing.B)  { checkStateSaveTime(b, 1) }
 func BenchmarkState_CheckStateSaveTime_10(b *testing.B) { checkStateSaveTime(b, 10) }
 

beacon-chain/execution/BUILD.bazel

@@ -12,6 +12,7 @@ go_library(
         "log_processing.go",
         "metrics.go",
         "options.go",
+        "payload_body.go",
         "prometheus.go",
         "rpc_connection.go",
         "service.go",
@@ -86,6 +87,8 @@ go_test(
         "execution_chain_test.go",
         "init_test.go",
         "log_processing_test.go",
+        "mock_test.go",
+        "payload_body_test.go",
         "prometheus_test.go",
         "service_test.go",
     ],

beacon-chain/execution/engine_client.go

@@ -1,7 +1,6 @@
 package execution
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"math/big"
@@ -34,12 +33,19 @@ var (
 	supportedEngineEndpoints = []string{
 		NewPayloadMethod,
 		NewPayloadMethodV2,
+		NewPayloadMethodV3,
+		NewPayloadMethodV4,
 		ForkchoiceUpdatedMethod,
 		ForkchoiceUpdatedMethodV2,
+		ForkchoiceUpdatedMethodV3,
 		GetPayloadMethod,
 		GetPayloadMethodV2,
+		GetPayloadMethodV3,
+		GetPayloadMethodV4,
 		GetPayloadBodiesByHashV1,
 		GetPayloadBodiesByRangeV1,
+		GetPayloadBodiesByHashV2,
+		GetPayloadBodiesByRangeV2,
 	}
 )
 
@@ -49,6 +55,8 @@ const (
 	// NewPayloadMethodV2 v2 request string for JSON-RPC.
 	NewPayloadMethodV2 = "engine_newPayloadV2"
 	NewPayloadMethodV3 = "engine_newPayloadV3"
+	// NewPayloadMethodV4 is the engine_newPayloadVX method added at Electra.
+	NewPayloadMethodV4 = "engine_newPayloadV4"
 	// ForkchoiceUpdatedMethod v1 request string for JSON-RPC.
 	ForkchoiceUpdatedMethod = "engine_forkchoiceUpdatedV1"
 	// ForkchoiceUpdatedMethodV2 v2 request string for JSON-RPC.
@@ -59,21 +67,30 @@ const (
 	GetPayloadMethod = "engine_getPayloadV1"
 	// GetPayloadMethodV2 v2 request string for JSON-RPC.
 	GetPayloadMethodV2 = "engine_getPayloadV2"
+	// GetPayloadMethodV3 is the get payload method added for deneb
 	GetPayloadMethodV3 = "engine_getPayloadV3"
+	// GetPayloadMethodV4 is the get payload method added for electra
+	GetPayloadMethodV4 = "engine_getPayloadV4"
 	// BlockByHashMethod request string for JSON-RPC.
 	BlockByHashMethod = "eth_getBlockByHash"
 	// BlockByNumberMethod request string for JSON-RPC.
 	BlockByNumberMethod = "eth_getBlockByNumber"
-	// GetPayloadBodiesByHashV1 v1 request string for JSON-RPC.
+	// GetPayloadBodiesByHashV1 is the engine_getPayloadBodiesByHashX JSON-RPC method for pre-Electra payloads.
 	GetPayloadBodiesByHashV1 = "engine_getPayloadBodiesByHashV1"
-	// GetPayloadBodiesByRangeV1 v1 request string for JSON-RPC.
+	// GetPayloadBodiesByHashV2 is the engine_getPayloadBodiesByHashX JSON-RPC method introduced by Electra.
+	GetPayloadBodiesByHashV2 = "engine_getPayloadBodiesByHashV2"
+	// GetPayloadBodiesByRangeV1 is the engine_getPayloadBodiesByRangeX JSON-RPC method for pre-Electra payloads.
 	GetPayloadBodiesByRangeV1 = "engine_getPayloadBodiesByRangeV1"
+	// GetPayloadBodiesByRangeV2 is the engine_getPayloadBodiesByRangeX JSON-RPC method introduced by Electra.
+	GetPayloadBodiesByRangeV2 = "engine_getPayloadBodiesByRangeV2"
 	// ExchangeCapabilities request string for JSON-RPC.
 	ExchangeCapabilities = "engine_exchangeCapabilities"
 	// Defines the seconds before timing out engine endpoints with non-block execution semantics.
 	defaultEngineTimeout = time.Second
 )
 
+var errInvalidPayloadBodyResponse = errors.New("engine api payload body response is invalid")
+
 // ForkchoiceUpdatedResponse is the response kind received by the
 // engine_forkchoiceUpdatedV1 endpoint.
 type ForkchoiceUpdatedResponse struct {
@@ -82,7 +99,7 @@ type ForkchoiceUpdatedResponse struct {
 	ValidationError string             `json:"validationError"`
 }
 
-// ExecutionPayloadReconstructor defines a service that can reconstruct a full beacon
+// PayloadReconstructor defines a service that can reconstruct a full beacon
 // block with an execution payload from a signed beacon block and a connection
 // to an execution client's engine API.
 type PayloadReconstructor interface {
@@ -101,7 +118,7 @@ type EngineCaller interface {
 	ForkchoiceUpdated(
 		ctx context.Context, state *pb.ForkchoiceState, attrs payloadattribute.Attributer,
 	) (*pb.PayloadIDBytes, []byte, error)
-	GetPayload(ctx context.Context, payloadId [8]byte, slot primitives.Slot) (interfaces.ExecutionData, *pb.BlobsBundle, bool, error)
+	GetPayload(ctx context.Context, payloadId [8]byte, slot primitives.Slot) (*blocks.GetPayloadResponse, error)
 	ExecutionBlockByHash(ctx context.Context, hash common.Hash, withTxs bool) (*pb.ExecutionBlock, error)
 	GetTerminalBlockHash(ctx context.Context, transitionTime uint64) ([]byte, bool, error)
 }
@@ -150,6 +167,15 @@ func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionDa
 		if err != nil {
 			return nil, handleRPCError(err)
 		}
+	case *pb.ExecutionPayloadElectra:
+		payloadPb, ok := payload.Proto().(*pb.ExecutionPayloadElectra)
+		if !ok {
+			return nil, errors.New("execution data must be a Deneb execution payload")
+		}
+		err := s.rpcClient.CallContext(ctx, result, NewPayloadMethodV4, payloadPb, versionedHashes, parentBlockRoot)
+		if err != nil {
+			return nil, handleRPCError(err)
+		}
 	default:
 		return nil, errors.New("unknown execution data type")
 	}
@@ -208,7 +234,7 @@ func (s *Service) ForkchoiceUpdated(
 		if err != nil {
 			return nil, nil, handleRPCError(err)
 		}
-	case version.Deneb:
+	case version.Deneb, version.Electra:
 		a, err := attrs.PbV3()
 		if err != nil {
 			return nil, nil, err
@@ -240,56 +266,43 @@ func (s *Service) ForkchoiceUpdated(
 	}
 }
 
+func getPayloadMethodAndMessage(slot primitives.Slot) (string, proto.Message) {
+	pe := slots.ToEpoch(slot)
+	if pe >= params.BeaconConfig().ElectraForkEpoch {
+		return GetPayloadMethodV4, &pb.ExecutionPayloadElectraWithValueAndBlobsBundle{}
+	}
+	if pe >= params.BeaconConfig().DenebForkEpoch {
+		return GetPayloadMethodV3, &pb.ExecutionPayloadDenebWithValueAndBlobsBundle{}
+	}
+	if pe >= params.BeaconConfig().CapellaForkEpoch {
+		return GetPayloadMethodV2, &pb.ExecutionPayloadCapellaWithValue{}
+	}
+	return GetPayloadMethod, &pb.ExecutionPayload{}
+}
+
 // GetPayload calls the engine_getPayloadVX method via JSON-RPC.
 // It returns the execution data as well as the blobs bundle.
-func (s *Service) GetPayload(ctx context.Context, payloadId [8]byte, slot primitives.Slot) (interfaces.ExecutionData, *pb.BlobsBundle, bool, error) {
+func (s *Service) GetPayload(ctx context.Context, payloadId [8]byte, slot primitives.Slot) (*blocks.GetPayloadResponse, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetPayload")
 	defer span.End()
 	start := time.Now()
 	defer func() {
 		getPayloadLatency.Observe(float64(time.Since(start).Milliseconds()))
 	}()
-
 	d := time.Now().Add(defaultEngineTimeout)
 	ctx, cancel := context.WithDeadline(ctx, d)
 	defer cancel()
 
-	if slots.ToEpoch(slot) >= params.BeaconConfig().DenebForkEpoch {
-		result := &pb.ExecutionPayloadDenebWithValueAndBlobsBundle{}
-		err := s.rpcClient.CallContext(ctx, result, GetPayloadMethodV3, pb.PayloadIDBytes(payloadId))
-		if err != nil {
-			return nil, nil, false, handleRPCError(err)
-		}
-		ed, err := blocks.WrappedExecutionPayloadDeneb(result.Payload, blocks.PayloadValueToWei(result.Value))
-		if err != nil {
-			return nil, nil, false, err
-		}
-		return ed, result.BlobsBundle, result.ShouldOverrideBuilder, nil
-	}
-
-	if slots.ToEpoch(slot) >= params.BeaconConfig().CapellaForkEpoch {
-		result := &pb.ExecutionPayloadCapellaWithValue{}
-		err := s.rpcClient.CallContext(ctx, result, GetPayloadMethodV2, pb.PayloadIDBytes(payloadId))
-		if err != nil {
-			return nil, nil, false, handleRPCError(err)
-		}
-		ed, err := blocks.WrappedExecutionPayloadCapella(result.Payload, blocks.PayloadValueToWei(result.Value))
-		if err != nil {
-			return nil, nil, false, err
-		}
-		return ed, nil, false, nil
-	}
-
-	result := &pb.ExecutionPayload{}
-	err := s.rpcClient.CallContext(ctx, result, GetPayloadMethod, pb.PayloadIDBytes(payloadId))
+	method, result := getPayloadMethodAndMessage(slot)
+	err := s.rpcClient.CallContext(ctx, result, method, pb.PayloadIDBytes(payloadId))
 	if err != nil {
-		return nil, nil, false, handleRPCError(err)
+		return nil, handleRPCError(err)
 	}
-	ed, err := blocks.WrappedExecutionPayload(result)
+	res, err := blocks.NewGetPayloadResponse(result)
 	if err != nil {
-		return nil, nil, false, err
+		return nil, err
 	}
-	return ed, nil, false, nil
+	return res, nil
 }
 
 func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
@@ -482,93 +495,19 @@ func (s *Service) HeaderByNumber(ctx context.Context, number *big.Int) (*types.H
 	return hdr, err
 }
 
-// GetPayloadBodiesByHash returns the relevant payload bodies for the provided block hash.
-func (s *Service) GetPayloadBodiesByHash(ctx context.Context, executionBlockHashes []common.Hash) ([]*pb.ExecutionPayloadBodyV1, error) {
-	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetPayloadBodiesByHashV1")
-	defer span.End()
-
-	result := make([]*pb.ExecutionPayloadBodyV1, 0)
-	// Exit early if there are no execution hashes.
-	if len(executionBlockHashes) == 0 {
-		return result, nil
-	}
-	err := s.rpcClient.CallContext(ctx, &result, GetPayloadBodiesByHashV1, executionBlockHashes)
-	if err != nil {
-		return nil, handleRPCError(err)
-	}
-	if len(result) != len(executionBlockHashes) {
-		return nil, fmt.Errorf("mismatch of payloads retrieved from the execution client: %d vs %d", len(result), len(executionBlockHashes))
-	}
-	for i, item := range result {
-		if item == nil {
-			result[i] = &pb.ExecutionPayloadBodyV1{
-				Transactions: make([][]byte, 0),
-				Withdrawals:  make([]*pb.Withdrawal, 0),
-			}
-		}
-	}
-	return result, nil
-}
-
-// GetPayloadBodiesByRange returns the relevant payload bodies for the provided range.
-func (s *Service) GetPayloadBodiesByRange(ctx context.Context, start, count uint64) ([]*pb.ExecutionPayloadBodyV1, error) {
-	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetPayloadBodiesByRangeV1")
-	defer span.End()
-
-	result := make([]*pb.ExecutionPayloadBodyV1, 0)
-	err := s.rpcClient.CallContext(ctx, &result, GetPayloadBodiesByRangeV1, start, count)
-
-	for i, item := range result {
-		if item == nil {
-			result[i] = &pb.ExecutionPayloadBodyV1{
-				Transactions: make([][]byte, 0),
-				Withdrawals:  make([]*pb.Withdrawal, 0),
-			}
-		}
-	}
-	return result, handleRPCError(err)
-}
-
 // ReconstructFullBlock takes in a blinded beacon block and reconstructs
 // a beacon block with a full execution payload via the engine API.
 func (s *Service) ReconstructFullBlock(
 	ctx context.Context, blindedBlock interfaces.ReadOnlySignedBeaconBlock,
 ) (interfaces.SignedBeaconBlock, error) {
-	if err := blocks.BeaconBlockIsNil(blindedBlock); err != nil {
-		return nil, errors.Wrap(err, "cannot reconstruct bellatrix block from nil data")
-	}
-	if !blindedBlock.Block().IsBlinded() {
-		return nil, errors.New("can only reconstruct block from blinded block format")
-	}
-	header, err := blindedBlock.Block().Body().Execution()
+	reconstructed, err := s.ReconstructFullBellatrixBlockBatch(ctx, []interfaces.ReadOnlySignedBeaconBlock{blindedBlock})
 	if err != nil {
 		return nil, err
 	}
-	if header.IsNil() {
-		return nil, errors.New("execution payload header in blinded block was nil")
+	if len(reconstructed) != 1 {
+		return nil, errors.Errorf("could not retrieve the correct number of payload bodies: wanted 1 but got %d", len(reconstructed))
 	}
-
-	// If the payload header has a block hash of 0x0, it means we are pre-merge and should
-	// simply return the block with an empty execution payload.
-	if bytes.Equal(header.BlockHash(), params.BeaconConfig().ZeroHash[:]) {
-		payload, err := buildEmptyExecutionPayload(blindedBlock.Version())
-		if err != nil {
-			return nil, err
-		}
-		return blocks.BuildSignedBeaconBlockFromExecutionPayload(blindedBlock, payload)
-	}
-
-	executionBlockHash := common.BytesToHash(header.BlockHash())
-	payload, err := s.retrievePayloadFromExecutionHash(ctx, executionBlockHash, header, blindedBlock.Version())
-	if err != nil {
-		return nil, err
-	}
-	fullBlock, err := blocks.BuildSignedBeaconBlockFromExecutionPayload(blindedBlock, payload.Proto())
-	if err != nil {
-		return nil, err
-	}
-	reconstructedExecutionPayloadCount.Add(1)
-	return fullBlock, nil
+	return reconstructed[0], nil
 }
 
 // ReconstructFullBellatrixBlockBatch takes in a batch of blinded beacon blocks and reconstructs
@@ -576,208 +515,16 @@ func (s *Service) ReconstructFullBlock(
 func (s *Service) ReconstructFullBellatrixBlockBatch(
 	ctx context.Context, blindedBlocks []interfaces.ReadOnlySignedBeaconBlock,
 ) ([]interfaces.SignedBeaconBlock, error) {
-	if len(blindedBlocks) == 0 {
-		return []interfaces.SignedBeaconBlock{}, nil
-	}
-	var executionHashes []common.Hash
-	var validExecPayloads []int
-	var zeroExecPayloads []int
-	for i, b := range blindedBlocks {
-		if err := blocks.BeaconBlockIsNil(b); err != nil {
-			return nil, errors.Wrap(err, "cannot reconstruct bellatrix block from nil data")
-		}
-		if !b.Block().IsBlinded() {
-			return nil, errors.New("can only reconstruct block from blinded block format")
-		}
-		header, err := b.Block().Body().Execution()
-		if err != nil {
-			return nil, err
-		}
-		if header.IsNil() {
-			return nil, errors.New("execution payload header in blinded block was nil")
-		}
-		// Determine if the block is pre-merge or post-merge. Depending on the result,
-		// we will ask the execution engine for the full payload.
-		if bytes.Equal(header.BlockHash(), params.BeaconConfig().ZeroHash[:]) {
-			zeroExecPayloads = append(zeroExecPayloads, i)
-		} else {
-			executionBlockHash := common.BytesToHash(header.BlockHash())
-			validExecPayloads = append(validExecPayloads, i)
-			executionHashes = append(executionHashes, executionBlockHash)
-		}
-	}
-	fullBlocks, err := s.retrievePayloadsFromExecutionHashes(ctx, executionHashes, validExecPayloads, blindedBlocks)
+	unb, err := reconstructBlindedBlockBatch(ctx, s.rpcClient, blindedBlocks)
 	if err != nil {
 		return nil, err
 	}
-	// For blocks that are pre-merge we simply reconstruct them via an empty
-	// execution payload.
-	for _, realIdx := range zeroExecPayloads {
-		bblock := blindedBlocks[realIdx]
-		payload, err := buildEmptyExecutionPayload(bblock.Version())
-		if err != nil {
-			return nil, err
-		}
-		fullBlock, err := blocks.BuildSignedBeaconBlockFromExecutionPayload(blindedBlocks[realIdx], payload)
-		if err != nil {
-			return nil, err
-		}
-		fullBlocks[realIdx] = fullBlock
-	}
-	reconstructedExecutionPayloadCount.Add(float64(len(blindedBlocks)))
-	return fullBlocks, nil
-}
-
-func (s *Service) retrievePayloadFromExecutionHash(ctx context.Context, executionBlockHash common.Hash, header interfaces.ExecutionData, version int) (interfaces.ExecutionData, error) {
-	pBodies, err := s.GetPayloadBodiesByHash(ctx, []common.Hash{executionBlockHash})
-	if err != nil {
-		return nil, fmt.Errorf("could not get payload body by hash %#x: %v", executionBlockHash, err)
-	}
-	if len(pBodies) != 1 {
-		return nil, errors.Errorf("could not retrieve the correct number of payload bodies: wanted 1 but got %d", len(pBodies))
-	}
-	bdy := pBodies[0]
-	return fullPayloadFromPayloadBody(header, bdy, version)
-}
-
-// This method assumes that the provided execution hashes are all valid and part of the
-// canonical chain.
-func (s *Service) retrievePayloadsFromExecutionHashes(
-	ctx context.Context,
-	executionHashes []common.Hash,
-	validExecPayloads []int,
-	blindedBlocks []interfaces.ReadOnlySignedBeaconBlock) ([]interfaces.SignedBeaconBlock, error) {
-	fullBlocks := make([]interfaces.SignedBeaconBlock, len(blindedBlocks))
-	var payloadBodies []*pb.ExecutionPayloadBodyV1
-	var err error
-
-	payloadBodies, err = s.GetPayloadBodiesByHash(ctx, executionHashes)
-	if err != nil {
-		return nil, fmt.Errorf("could not fetch payload bodies by hash %#x: %v", executionHashes, err)
-	}
-
-	// For each valid payload, we reconstruct the full block from it with the
-	// blinded block.
-	for sliceIdx, realIdx := range validExecPayloads {
-		var payload interfaces.ExecutionData
-		bblock := blindedBlocks[realIdx]
-		b := payloadBodies[sliceIdx]
-		if b == nil {
-			return nil, fmt.Errorf("received nil payload body for request by hash %#x", executionHashes[sliceIdx])
-		}
-		header, err := bblock.Block().Body().Execution()
-		if err != nil {
-			return nil, err
-		}
-		payload, err = fullPayloadFromPayloadBody(header, b, bblock.Version())
-		if err != nil {
-			return nil, err
-		}
-		fullBlock, err := blocks.BuildSignedBeaconBlockFromExecutionPayload(bblock, payload.Proto())
-		if err != nil {
-			return nil, err
-		}
-		fullBlocks[realIdx] = fullBlock
-	}
-	return fullBlocks, nil
-}
-
-func fullPayloadFromExecutionBlock(
-	blockVersion int, header interfaces.ExecutionData, block *pb.ExecutionBlock,
-) (interfaces.ExecutionData, error) {
-	if header.IsNil() || block == nil {
-		return nil, errors.New("execution block and header cannot be nil")
-	}
-	blockHash := block.Hash
-	if !bytes.Equal(header.BlockHash(), blockHash[:]) {
-		return nil, fmt.Errorf(
-			"block hash field in execution header %#x does not match execution block hash %#x",
-			header.BlockHash(),
-			blockHash,
-		)
-	}
-	blockTransactions := block.Transactions
-	txs := make([][]byte, len(blockTransactions))
-	for i, tx := range blockTransactions {
-		txBin, err := tx.MarshalBinary()
-		if err != nil {
-			return nil, err
-		}
-		txs[i] = txBin
-	}
-
-	switch blockVersion {
-	case version.Bellatrix:
-		return blocks.WrappedExecutionPayload(&pb.ExecutionPayload{
-			ParentHash:    header.ParentHash(),
-			FeeRecipient:  header.FeeRecipient(),
-			StateRoot:     header.StateRoot(),
-			ReceiptsRoot:  header.ReceiptsRoot(),
-			LogsBloom:     header.LogsBloom(),
-			PrevRandao:    header.PrevRandao(),
-			BlockNumber:   header.BlockNumber(),
-			GasLimit:      header.GasLimit(),
-			GasUsed:       header.GasUsed(),
-			Timestamp:     header.Timestamp(),
-			ExtraData:     header.ExtraData(),
-			BaseFeePerGas: header.BaseFeePerGas(),
-			BlockHash:     blockHash[:],
-			Transactions:  txs,
-		})
-	case version.Capella:
-		return blocks.WrappedExecutionPayloadCapella(&pb.ExecutionPayloadCapella{
-			ParentHash:    header.ParentHash(),
-			FeeRecipient:  header.FeeRecipient(),
-			StateRoot:     header.StateRoot(),
-			ReceiptsRoot:  header.ReceiptsRoot(),
-			LogsBloom:     header.LogsBloom(),
-			PrevRandao:    header.PrevRandao(),
-			BlockNumber:   header.BlockNumber(),
-			GasLimit:      header.GasLimit(),
-			GasUsed:       header.GasUsed(),
-			Timestamp:     header.Timestamp(),
-			ExtraData:     header.ExtraData(),
-			BaseFeePerGas: header.BaseFeePerGas(),
-			BlockHash:     blockHash[:],
-			Transactions:  txs,
-			Withdrawals:   block.Withdrawals,
-		}, big.NewInt(0)) // We can't get the block value and don't care about the block value for this instance
-	case version.Deneb:
-		ebg, err := header.ExcessBlobGas()
-		if err != nil {
-			return nil, errors.Wrap(err, "unable to extract ExcessBlobGas attribute from execution payload header")
-		}
-		bgu, err := header.BlobGasUsed()
-		if err != nil {
-			return nil, errors.Wrap(err, "unable to extract BlobGasUsed attribute from execution payload header")
-		}
-		return blocks.WrappedExecutionPayloadDeneb(
-			&pb.ExecutionPayloadDeneb{
-				ParentHash:    header.ParentHash(),
-				FeeRecipient:  header.FeeRecipient(),
-				StateRoot:     header.StateRoot(),
-				ReceiptsRoot:  header.ReceiptsRoot(),
-				LogsBloom:     header.LogsBloom(),
-				PrevRandao:    header.PrevRandao(),
-				BlockNumber:   header.BlockNumber(),
-				GasLimit:      header.GasLimit(),
-				GasUsed:       header.GasUsed(),
-				Timestamp:     header.Timestamp(),
-				ExtraData:     header.ExtraData(),
-				BaseFeePerGas: header.BaseFeePerGas(),
-				BlockHash:     blockHash[:],
-				Transactions:  txs,
-				Withdrawals:   block.Withdrawals,
-				BlobGasUsed:   bgu,
-				ExcessBlobGas: ebg,
-			}, big.NewInt(0)) // We can't get the block value and don't care about the block value for this instance
-	default:
-		return nil, fmt.Errorf("unknown execution block version %d", block.Version)
-	}
+	reconstructedExecutionPayloadCount.Add(float64(len(unb)))
+	return unb, nil
 }
 
 func fullPayloadFromPayloadBody(
-	header interfaces.ExecutionData, body *pb.ExecutionPayloadBodyV1, bVersion int,
+	header interfaces.ExecutionData, body *pb.ExecutionPayloadBody, bVersion int,
 ) (interfaces.ExecutionData, error) {
 	if header.IsNil() || body == nil {
 		return nil, errors.New("execution block and header cannot be nil")
@@ -799,7 +546,7 @@ func fullPayloadFromPayloadBody(
 			ExtraData:     header.ExtraData(),
 			BaseFeePerGas: header.BaseFeePerGas(),
 			BlockHash:     header.BlockHash(),
-			Transactions:  body.Transactions,
+			Transactions:  pb.RecastHexutilByteSlice(body.Transactions),
 		})
 	case version.Capella:
 		return blocks.WrappedExecutionPayloadCapella(&pb.ExecutionPayloadCapella{
@@ -816,9 +563,9 @@ func fullPayloadFromPayloadBody(
 			ExtraData:     header.ExtraData(),
 			BaseFeePerGas: header.BaseFeePerGas(),
 			BlockHash:     header.BlockHash(),
-			Transactions:  body.Transactions,
+			Transactions:  pb.RecastHexutilByteSlice(body.Transactions),
 			Withdrawals:   body.Withdrawals,
-		}, big.NewInt(0)) // We can't get the block value and don't care about the block value for this instance
+		}) // We can't get the block value and don't care about the block value for this instance
 	case version.Deneb:
 		ebg, err := header.ExcessBlobGas()
 		if err != nil {
@@ -843,11 +590,50 @@ func fullPayloadFromPayloadBody(
 				ExtraData:     header.ExtraData(),
 				BaseFeePerGas: header.BaseFeePerGas(),
 				BlockHash:     header.BlockHash(),
-				Transactions:  body.Transactions,
+				Transactions:  pb.RecastHexutilByteSlice(body.Transactions),
 				Withdrawals:   body.Withdrawals,
 				ExcessBlobGas: ebg,
 				BlobGasUsed:   bgu,
-			}, big.NewInt(0)) // We can't get the block value and don't care about the block value for this instance
+			}) // We can't get the block value and don't care about the block value for this instance
+	case version.Electra:
+		ebg, err := header.ExcessBlobGas()
+		if err != nil {
+			return nil, errors.Wrap(err, "unable to extract ExcessBlobGas attribute from execution payload header")
+		}
+		bgu, err := header.BlobGasUsed()
+		if err != nil {
+			return nil, errors.Wrap(err, "unable to extract BlobGasUsed attribute from execution payload header")
+		}
+		wr, err := pb.JsonWithdrawalRequestsToProto(body.WithdrawalRequests)
+		if err != nil {
+			return nil, err
+		}
+		dr, err := pb.JsonDepositRequestsToProto(body.DepositRequests)
+		if err != nil {
+			return nil, err
+		}
+		return blocks.WrappedExecutionPayloadElectra(
+			&pb.ExecutionPayloadElectra{
+				ParentHash:         header.ParentHash(),
+				FeeRecipient:       header.FeeRecipient(),
+				StateRoot:          header.StateRoot(),
+				ReceiptsRoot:       header.ReceiptsRoot(),
+				LogsBloom:          header.LogsBloom(),
+				PrevRandao:         header.PrevRandao(),
+				BlockNumber:        header.BlockNumber(),
+				GasLimit:           header.GasLimit(),
+				GasUsed:            header.GasUsed(),
+				Timestamp:          header.Timestamp(),
+				ExtraData:          header.ExtraData(),
+				BaseFeePerGas:      header.BaseFeePerGas(),
+				BlockHash:          header.BlockHash(),
+				Transactions:       pb.RecastHexutilByteSlice(body.Transactions),
+				Withdrawals:        body.Withdrawals,
+				ExcessBlobGas:      ebg,
+				BlobGasUsed:        bgu,
+				DepositReceipts:    dr,
+				WithdrawalRequests: wr,
+			}) // We can't get the block value and don't care about the block value for this instance
 	default:
 		return nil, fmt.Errorf("unknown execution block version for payload %d", bVersion)
 	}
@@ -981,6 +767,22 @@ func buildEmptyExecutionPayload(v int) (proto.Message, error) {
 			Transactions:  make([][]byte, 0),
 			Withdrawals:   make([]*pb.Withdrawal, 0),
 		}, nil
+	case version.Electra:
+		return &pb.ExecutionPayloadElectra{
+			ParentHash:         make([]byte, fieldparams.RootLength),
+			FeeRecipient:       make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:          make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:       make([]byte, fieldparams.RootLength),
+			LogsBloom:          make([]byte, fieldparams.LogsBloomLength),
+			PrevRandao:         make([]byte, fieldparams.RootLength),
+			ExtraData:          make([]byte, 0),
+			BaseFeePerGas:      make([]byte, fieldparams.RootLength),
+			BlockHash:          make([]byte, fieldparams.RootLength),
+			Transactions:       make([][]byte, 0),
+			Withdrawals:        make([]*pb.Withdrawal, 0),
+			WithdrawalRequests: make([]*pb.ExecutionLayerWithdrawalRequest, 0),
+			DepositReceipts:    make([]*pb.DepositReceipt, 0),
+		}, nil
 	default:
 		return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
 	}

beacon-chain/execution/mock_test.go

@@ -0,0 +1,221 @@
+package execution
+
+import (
+	"context"
+	"encoding/json"
+	"math"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/rpc"
+	pb "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+var mockHandlerDefaultName = "__default__"
+
+type jsonError struct {
+	Code    int         `json:"code"`
+	Message string      `json:"message"`
+	Data    interface{} `json:"data,omitempty"`
+}
+
+type jsonrpcMessage struct {
+	Version string          `json:"jsonrpc,omitempty"`
+	ID      json.RawMessage `json:"id,omitempty"`
+	Method  string          `json:"method,omitempty"`
+	Params  json.RawMessage `json:"params,omitempty"`
+	Error   *jsonError      `json:"error,omitempty"`
+	Result  json.RawMessage `json:"result,omitempty"`
+}
+
+type mockHandler func(*jsonrpcMessage, http.ResponseWriter, *http.Request)
+
+type mockEngine struct {
+	t        *testing.T
+	handlers map[string]mockHandler
+	calls    map[string][]*jsonrpcMessage
+}
+
+func newMockEngine(t *testing.T) (*rpc.Client, *mockEngine) {
+	s := &mockEngine{t: t, handlers: make(map[string]mockHandler), calls: make(map[string][]*jsonrpcMessage)}
+	srv := httptest.NewServer(s)
+	c, err := rpc.DialHTTP(srv.URL)
+	require.NoError(t, err)
+	return c, s
+}
+
+func (s *mockEngine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	msg := &jsonrpcMessage{}
+	defer func() {
+		s.calls[msg.Method] = append(s.calls[msg.Method], msg)
+	}()
+	if err := json.NewDecoder(r.Body).Decode(msg); err != nil {
+		http.Error(w, "failed to decode request: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	defer func() {
+		require.NoError(s.t, r.Body.Close())
+	}()
+	handler, ok := s.handlers[msg.Method]
+	if !ok {
+		// Fallback to default handler if it is registered.
+		handler, ok = s.handlers[mockHandlerDefaultName]
+		if !ok {
+			s.t.Fatalf("mockEngine called with unexpected method %s", msg.Method)
+		}
+	}
+	handler(msg, w, r)
+}
+
+func (s *mockEngine) register(method string, handler mockHandler) {
+	s.handlers[method] = handler
+}
+
+func (s *mockEngine) registerDefault(handler mockHandler) {
+	s.handlers[mockHandlerDefaultName] = handler
+}
+
+func (s *mockEngine) callCount(method string) int {
+	return len(s.calls[method])
+}
+
+func mockParseUintList(t *testing.T, data json.RawMessage) []uint64 {
+	var list []uint64
+	if err := json.Unmarshal(data, &list); err != nil {
+		t.Fatalf("failed to parse uint list: %v", err)
+	}
+	return list
+}
+
+func mockParseHexByteList(t *testing.T, data json.RawMessage) []hexutil.Bytes {
+	var list [][]hexutil.Bytes
+	if err := json.Unmarshal(data, &list); err != nil {
+		t.Fatalf("failed to parse hex byte list: %v", err)
+	}
+	require.Equal(t, 1, len(list))
+	return list[0]
+}
+
+func strToHexBytes(t *testing.T, s string) hexutil.Bytes {
+	b := hexutil.Bytes{}
+	require.NoError(t, b.UnmarshalText([]byte(s)))
+	return b
+}
+
+func mockWriteResult(t *testing.T, w http.ResponseWriter, req *jsonrpcMessage, result any) {
+	marshaled, err := json.Marshal(result)
+	require.NoError(t, err)
+	req.Result = marshaled
+	require.NoError(t, json.NewEncoder(w).Encode(req))
+}
+
+func TestParseRequest(t *testing.T) {
+	ctx := context.Background()
+	cases := []struct {
+		method   string
+		uintArgs []uint64
+		byteArgs []hexutil.Bytes
+	}{
+		{
+			method: GetPayloadBodiesByHashV1,
+			byteArgs: []hexutil.Bytes{
+				strToHexBytes(t, "0x656d707479000000000000000000000000000000000000000000000000000000"),
+				strToHexBytes(t, "0x66756c6c00000000000000000000000000000000000000000000000000000000"),
+			},
+		},
+		{
+			method: GetPayloadBodiesByHashV2,
+			byteArgs: []hexutil.Bytes{
+				strToHexBytes(t, "0x656d707479000000000000000000000000000000000000000000000000000000"),
+				strToHexBytes(t, "0x66756c6c00000000000000000000000000000000000000000000000000000000"),
+			},
+		},
+		{
+			method:   GetPayloadBodiesByRangeV1,
+			uintArgs: []uint64{0, 1},
+		},
+		{
+			method:   GetPayloadBodiesByRangeV2,
+			uintArgs: []uint64{math.MaxUint64, 1},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.method, func(t *testing.T) {
+			cli, srv := newMockEngine(t)
+			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+				require.Equal(t, c.method, msg.Method)
+				nr := uint64(len(c.byteArgs))
+				if len(c.byteArgs) > 0 {
+					require.DeepEqual(t, c.byteArgs, mockParseHexByteList(t, msg.Params))
+				}
+				if len(c.uintArgs) > 0 {
+					rang := mockParseUintList(t, msg.Params)
+					require.DeepEqual(t, c.uintArgs, rang)
+					nr = rang[1]
+				}
+				mockWriteResult(t, w, msg, make([]*pb.ExecutionPayloadBody, nr))
+			})
+
+			result := make([]*pb.ExecutionPayloadBody, 0)
+			var args []interface{}
+			if len(c.byteArgs) > 0 {
+				args = []interface{}{c.byteArgs}
+			}
+			if len(c.uintArgs) > 0 {
+				args = make([]interface{}, len(c.uintArgs))
+				for i := range c.uintArgs {
+					args[i] = c.uintArgs[i]
+				}
+			}
+			require.NoError(t, cli.CallContext(ctx, &result, c.method, args...))
+			if len(c.byteArgs) > 0 {
+				require.Equal(t, len(c.byteArgs), len(result))
+			}
+			if len(c.uintArgs) > 0 {
+				require.Equal(t, int(c.uintArgs[1]), len(result))
+			}
+		})
+	}
+}
+
+func TestCallCount(t *testing.T) {
+	methods := []string{
+		GetPayloadBodiesByHashV1,
+		GetPayloadBodiesByHashV2,
+		GetPayloadBodiesByRangeV1,
+		GetPayloadBodiesByRangeV2,
+	}
+	cases := []struct {
+		method string
+		count  int
+	}{
+		{method: GetPayloadBodiesByHashV1, count: 1},
+		{method: GetPayloadBodiesByHashV1, count: 2},
+		{method: GetPayloadBodiesByHashV2, count: 1},
+		{method: GetPayloadBodiesByRangeV1, count: 1},
+		{method: GetPayloadBodiesByRangeV1, count: 2},
+		{method: GetPayloadBodiesByRangeV2, count: 1},
+	}
+	for _, c := range cases {
+		t.Run(c.method, func(t *testing.T) {
+			cli, srv := newMockEngine(t)
+			srv.register(c.method, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+				mockWriteResult(t, w, msg, nil)
+			})
+			for i := 0; i < c.count; i++ {
+				require.NoError(t, cli.CallContext(context.Background(), nil, c.method))
+			}
+			for _, m := range methods {
+				if m == c.method {
+					require.Equal(t, c.count, srv.callCount(m))
+				} else {
+					require.Equal(t, 0, srv.callCount(m))
+				}
+			}
+		})
+	}
+}

beacon-chain/execution/payload_body.go

@@ -0,0 +1,250 @@
+package execution
+
+import (
+	"context"
+	"sort"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	pb "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"google.golang.org/protobuf/proto"
+)
+
+var errNilPayloadBody = errors.New("nil payload body for block")
+
+type blockWithHeader struct {
+	block  interfaces.ReadOnlySignedBeaconBlock
+	header interfaces.ExecutionData
+}
+
+// reconstructionBatch is a map of block hashes to block numbers.
+type reconstructionBatch map[[32]byte]uint64
+
+type blindedBlockReconstructor struct {
+	orderedBlocks []*blockWithHeader
+	bodies        map[[32]byte]*pb.ExecutionPayloadBody
+	batches       map[string]reconstructionBatch
+}
+
+func reconstructBlindedBlockBatch(ctx context.Context, client RPCClient, sbb []interfaces.ReadOnlySignedBeaconBlock) ([]interfaces.SignedBeaconBlock, error) {
+	r, err := newBlindedBlockReconstructor(sbb)
+	if err != nil {
+		return nil, err
+	}
+	if err := r.requestBodies(ctx, client); err != nil {
+		return nil, err
+	}
+	return r.unblinded()
+}
+
+func newBlindedBlockReconstructor(sbb []interfaces.ReadOnlySignedBeaconBlock) (*blindedBlockReconstructor, error) {
+	r := &blindedBlockReconstructor{
+		orderedBlocks: make([]*blockWithHeader, 0, len(sbb)),
+		bodies:        make(map[[32]byte]*pb.ExecutionPayloadBody),
+	}
+	for i := range sbb {
+		if err := r.addToBatch(sbb[i]); err != nil {
+			return nil, err
+		}
+	}
+	return r, nil
+}
+
+func (r *blindedBlockReconstructor) addToBatch(b interfaces.ReadOnlySignedBeaconBlock) error {
+	if err := blocks.BeaconBlockIsNil(b); err != nil {
+		return errors.Wrap(err, "cannot reconstruct bellatrix block from nil data")
+	}
+	if !b.Block().IsBlinded() {
+		return errors.New("can only reconstruct block from blinded block format")
+	}
+	header, err := b.Block().Body().Execution()
+	if err != nil {
+		return err
+	}
+	if header.IsNil() {
+		return errors.New("execution payload header in blinded block was nil")
+	}
+	r.orderedBlocks = append(r.orderedBlocks, &blockWithHeader{block: b, header: header})
+	blockHash := bytesutil.ToBytes32(header.BlockHash())
+	if blockHash == params.BeaconConfig().ZeroHash {
+		return nil
+	}
+
+	method := payloadBodyMethodForBlock(b)
+	if r.batches == nil {
+		r.batches = make(map[string]reconstructionBatch)
+	}
+	if _, ok := r.batches[method]; !ok {
+		r.batches[method] = make(reconstructionBatch)
+	}
+	r.batches[method][bytesutil.ToBytes32(header.BlockHash())] = header.BlockNumber()
+	return nil
+}
+
+func payloadBodyMethodForBlock(b interface{ Version() int }) string {
+	if b.Version() > version.Deneb {
+		return GetPayloadBodiesByHashV2
+	}
+	return GetPayloadBodiesByHashV1
+}
+
+func (r *blindedBlockReconstructor) requestBodies(ctx context.Context, client RPCClient) error {
+	for method := range r.batches {
+		nilResults, err := r.requestBodiesByHash(ctx, client, method)
+		if err != nil {
+			return err
+		}
+		if err := r.handleNilResults(ctx, client, method, nilResults); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type hashBlockNumber struct {
+	h [32]byte
+	n uint64
+}
+
+func (r *blindedBlockReconstructor) handleNilResults(ctx context.Context, client RPCClient, method string, nilResults [][32]byte) error {
+	if len(nilResults) == 0 {
+		return nil
+	}
+	hbns := make([]hashBlockNumber, len(nilResults))
+	for i := range nilResults {
+		h := nilResults[i]
+		hbns[i] = hashBlockNumber{h: h, n: r.batches[method][h]}
+	}
+	reqs := computeRanges(hbns)
+	for i := range reqs {
+		if err := r.requestBodiesByRange(ctx, client, rangeMethodForHashMethod(method), reqs[i]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type byRangeReq struct {
+	start uint64
+	count uint64
+	hbns  []hashBlockNumber
+}
+
+func computeRanges(hbns []hashBlockNumber) []byRangeReq {
+	if len(hbns) == 0 {
+		return nil
+	}
+	sort.Slice(hbns, func(i, j int) bool {
+		return hbns[i].n < hbns[j].n
+	})
+	ranges := make([]byRangeReq, 0)
+	start := hbns[0].n
+	count := uint64(0)
+	for i := 0; i < len(hbns); i++ {
+		if hbns[i].n == start+count {
+			count++
+			continue
+		}
+		ranges = append(ranges, byRangeReq{start: start, count: count, hbns: hbns[uint64(i)-count : i]})
+		start = hbns[i].n
+		count = 1
+	}
+	ranges = append(ranges, byRangeReq{start: start, count: count, hbns: hbns[uint64(len(hbns))-count:]})
+	return ranges
+}
+
+func (r *blindedBlockReconstructor) requestBodiesByRange(ctx context.Context, client RPCClient, method string, req byRangeReq) error {
+	result := make([]*pb.ExecutionPayloadBody, 0)
+	if err := client.CallContext(ctx, &result, method, req.start, req.count); err != nil {
+		return err
+	}
+	if uint64(len(result)) != req.count {
+		return errors.Wrapf(errInvalidPayloadBodyResponse, "received %d payload bodies from %s with count=%d (start=%d)", len(result), method, req.count, req.start)
+	}
+	for i := range result {
+		if result[i] == nil {
+			return errors.Wrapf(errNilPayloadBody, "from %s, hash=%#x", method, req.hbns[i].h)
+		}
+		r.bodies[req.hbns[i].h] = result[i]
+	}
+	return nil
+}
+
+func (r *blindedBlockReconstructor) requestBodiesByHash(ctx context.Context, client RPCClient, method string) ([][32]byte, error) {
+	batch := r.batches[method]
+	if len(batch) == 0 {
+		return nil, nil
+	}
+	hashes := make([]common.Hash, 0, len(batch))
+	for h := range batch {
+		if h == params.BeaconConfig().ZeroHash {
+			continue
+		}
+		hashes = append(hashes, h)
+	}
+	result := make([]*pb.ExecutionPayloadBody, 0)
+	if err := client.CallContext(ctx, &result, method, hashes); err != nil {
+		return nil, err
+	}
+	if len(hashes) != len(result) {
+		return nil, errors.Wrapf(errInvalidPayloadBodyResponse, "received %d payload bodies for %d requested hashes", len(result), len(hashes))
+	}
+	nilBodies := make([][32]byte, 0)
+	for i := range result {
+		if result[i] == nil {
+			nilBodies = append(nilBodies, hashes[i])
+			continue
+		}
+		r.bodies[hashes[i]] = result[i]
+	}
+	return nilBodies, nil
+}
+
+func (r *blindedBlockReconstructor) payloadForHeader(header interfaces.ExecutionData, v int) (proto.Message, error) {
+	bodyKey := bytesutil.ToBytes32(header.BlockHash())
+	if bodyKey == params.BeaconConfig().ZeroHash {
+		payload, err := buildEmptyExecutionPayload(v)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to reconstruct payload for body hash %#x", bodyKey)
+		}
+		return payload, nil
+	}
+	body, ok := r.bodies[bodyKey]
+	if !ok {
+		return nil, errors.Wrapf(errNilPayloadBody, "hash %#x", bodyKey)
+	}
+	ed, err := fullPayloadFromPayloadBody(header, body, v)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to reconstruct payload for body hash %#x", bodyKey)
+	}
+	return ed.Proto(), nil
+}
+
+func (r *blindedBlockReconstructor) unblinded() ([]interfaces.SignedBeaconBlock, error) {
+	unblinded := make([]interfaces.SignedBeaconBlock, len(r.orderedBlocks))
+	for i := range r.orderedBlocks {
+		blk, header := r.orderedBlocks[i].block, r.orderedBlocks[i].header
+		payload, err := r.payloadForHeader(header, blk.Version())
+		if err != nil {
+			return nil, err
+		}
+		full, err := blocks.BuildSignedBeaconBlockFromExecutionPayload(blk, payload)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to build full block from execution payload for block hash %#x", header.BlockHash())
+		}
+		unblinded[i] = full
+	}
+	return unblinded, nil
+}
+
+func rangeMethodForHashMethod(method string) string {
+	if method == GetPayloadBodiesByHashV2 {
+		return GetPayloadBodiesByRangeV2
+	}
+	return GetPayloadBodiesByRangeV1
+}

beacon-chain/execution/payload_body_test.go

@@ -0,0 +1,408 @@
+package execution
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	pb "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+type versioner struct {
+	version int
+}
+
+func (v versioner) Version() int {
+	return v.version
+}
+
+func TestPayloadBodyMethodForBlock(t *testing.T) {
+	cases := []struct {
+		versions []int
+		want     string
+	}{
+		{
+			versions: []int{version.Phase0, version.Altair, version.Bellatrix, version.Capella, version.Deneb},
+			want:     GetPayloadBodiesByHashV1,
+		},
+		{
+			versions: []int{version.Electra},
+			want:     GetPayloadBodiesByHashV2,
+		},
+	}
+	for _, c := range cases {
+		for _, v := range c.versions {
+			t.Run(version.String(v), func(t *testing.T) {
+				v := versioner{version: v}
+				require.Equal(t, c.want, payloadBodyMethodForBlock(v))
+			})
+		}
+	}
+	t.Run("post-electra", func(t *testing.T) {
+		require.Equal(t, GetPayloadBodiesByHashV2, payloadBodyMethodForBlock(versioner{version: version.Electra + 1}))
+	})
+}
+
+func payloadToBody(t *testing.T, ed interfaces.ExecutionData) *pb.ExecutionPayloadBody {
+	body := &pb.ExecutionPayloadBody{}
+	txs, err := ed.Transactions()
+	require.NoError(t, err)
+	wd, err := ed.Withdrawals()
+	// Bellatrix does not have withdrawals and will return an error.
+	if err == nil {
+		body.Withdrawals = wd
+	}
+	for i := range txs {
+		body.Transactions = append(body.Transactions, txs[i])
+	}
+	eed, isElectra := ed.(interfaces.ExecutionDataElectra)
+	if isElectra {
+		body.DepositRequests = pb.ProtoDepositRequestsToJson(eed.DepositReceipts())
+		body.WithdrawalRequests = pb.ProtoWithdrawalRequestsToJson(eed.WithdrawalRequests())
+	}
+	return body
+}
+
+type blindedBlockFixtures struct {
+	denebBlock      *fullAndBlinded
+	emptyDenebBlock *fullAndBlinded
+	afterSkipDeneb  *fullAndBlinded
+	electra         *fullAndBlinded
+}
+
+type fullAndBlinded struct {
+	full    interfaces.ReadOnlySignedBeaconBlock
+	blinded *blockWithHeader
+}
+
+func blindedBlockWithHeader(t *testing.T, b interfaces.ReadOnlySignedBeaconBlock) *fullAndBlinded {
+	header, err := b.Block().Body().Execution()
+	require.NoError(t, err)
+	blinded, err := b.ToBlinded()
+	require.NoError(t, err)
+	return &fullAndBlinded{
+		full: b,
+		blinded: &blockWithHeader{
+			block:  blinded,
+			header: header,
+		}}
+}
+
+func denebSlot(t *testing.T) primitives.Slot {
+	s, err := slots.EpochStart(params.BeaconConfig().DenebForkEpoch)
+	require.NoError(t, err)
+	return s
+}
+
+func electraSlot(t *testing.T) primitives.Slot {
+	s, err := slots.EpochStart(params.BeaconConfig().ElectraForkEpoch)
+	require.NoError(t, err)
+	return s
+}
+
+func testBlindedBlockFixtures(t *testing.T) *blindedBlockFixtures {
+	pfx := fixturesStruct()
+	fx := &blindedBlockFixtures{}
+	full := pfx.ExecutionPayloadDeneb
+	// this func overrides fixture blockhashes to ensure they are unique
+	full.BlockHash = bytesutil.PadTo([]byte("full"), 32)
+	denebBlock, _ := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, denebSlot(t), 0, util.WithPayloadSetter(full))
+	fx.denebBlock = blindedBlockWithHeader(t, denebBlock)
+
+	empty := pfx.EmptyExecutionPayloadDeneb
+	empty.BlockHash = bytesutil.PadTo([]byte("empty"), 32)
+	empty.BlockNumber = 2
+	emptyDenebBlock, _ := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, denebSlot(t)+1, 0, util.WithPayloadSetter(empty))
+	fx.emptyDenebBlock = blindedBlockWithHeader(t, emptyDenebBlock)
+
+	afterSkip := fixturesStruct().ExecutionPayloadDeneb
+	// this func overrides fixture blockhashes to ensure they are unique
+	afterSkip.BlockHash = bytesutil.PadTo([]byte("afterSkip"), 32)
+	afterSkip.BlockNumber = 4
+	afterSkipBlock, _ := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, denebSlot(t)+3, 0, util.WithPayloadSetter(afterSkip))
+	fx.afterSkipDeneb = blindedBlockWithHeader(t, afterSkipBlock)
+
+	electra := fixturesStruct().ExecutionPayloadElectra
+	electra.BlockHash = bytesutil.PadTo([]byte("electra"), 32)
+	electra.BlockNumber = 5
+	electraBlock, _ := util.GenerateTestElectraBlockWithSidecar(t, [32]byte{}, electraSlot(t), 0, util.WithElectraPayload(electra))
+	fx.electra = blindedBlockWithHeader(t, electraBlock)
+	return fx
+}
+
+func TestPayloadBodiesViaUnblinder(t *testing.T) {
+	defer util.HackElectraMaxuint(t)()
+	fx := testBlindedBlockFixtures(t)
+	t.Run("mix of non-empty and empty", func(t *testing.T) {
+		cli, srv := newMockEngine(t)
+		srv.register(GetPayloadBodiesByHashV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{
+				payloadToBody(t, fx.denebBlock.blinded.header),
+				payloadToBody(t, fx.emptyDenebBlock.blinded.header),
+			}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		ctx := context.Background()
+
+		toUnblind := []interfaces.ReadOnlySignedBeaconBlock{
+			fx.denebBlock.blinded.block,
+			fx.emptyDenebBlock.blinded.block,
+		}
+		bbr, err := newBlindedBlockReconstructor(toUnblind)
+		require.NoError(t, err)
+		require.NoError(t, bbr.requestBodies(ctx, cli))
+
+		payload, err := bbr.payloadForHeader(fx.denebBlock.blinded.header, fx.denebBlock.blinded.block.Version())
+		require.NoError(t, err)
+		unblindFull, err := blocks.BuildSignedBeaconBlockFromExecutionPayload(fx.denebBlock.blinded.block, payload)
+		require.NoError(t, err)
+		testAssertReconstructedEquivalent(t, fx.denebBlock.full, unblindFull)
+
+		emptyPayload, err := bbr.payloadForHeader(fx.emptyDenebBlock.blinded.header, fx.emptyDenebBlock.blinded.block.Version())
+		require.NoError(t, err)
+		unblindEmpty, err := blocks.BuildSignedBeaconBlockFromExecutionPayload(fx.emptyDenebBlock.blinded.block, emptyPayload)
+		require.NoError(t, err)
+		testAssertReconstructedEquivalent(t, fx.emptyDenebBlock.full, unblindEmpty)
+	})
+}
+
+func TestFixtureEquivalence(t *testing.T) {
+	defer util.HackElectraMaxuint(t)()
+	fx := testBlindedBlockFixtures(t)
+	t.Run("full and blinded block equivalence", func(t *testing.T) {
+		testAssertReconstructedEquivalent(t, fx.denebBlock.blinded.block, fx.denebBlock.full)
+		testAssertReconstructedEquivalent(t, fx.emptyDenebBlock.blinded.block, fx.emptyDenebBlock.full)
+	})
+}
+
+func testAssertReconstructedEquivalent(t *testing.T, b, ogb interfaces.ReadOnlySignedBeaconBlock) {
+	bHtr, err := b.Block().HashTreeRoot()
+	require.NoError(t, err)
+	ogbHtr, err := ogb.Block().HashTreeRoot()
+	require.NoError(t, err)
+	require.Equal(t, bHtr, ogbHtr)
+}
+
+func TestComputeRanges(t *testing.T) {
+	cases := []struct {
+		name string
+		hbns []hashBlockNumber
+		want []byRangeReq
+	}{
+		{
+			name: "3 contiguous, 1 not",
+			hbns: []hashBlockNumber{
+				{h: [32]byte{5}, n: 5},
+				{h: [32]byte{3}, n: 3},
+				{h: [32]byte{2}, n: 2},
+				{h: [32]byte{1}, n: 1},
+			},
+			want: []byRangeReq{
+				{start: 1, count: 3, hbns: []hashBlockNumber{{h: [32]byte{1}, n: 1}, {h: [32]byte{2}, n: 2}, {h: [32]byte{3}, n: 3}}},
+				{start: 5, count: 1, hbns: []hashBlockNumber{{h: [32]byte{5}, n: 5}}},
+			},
+		},
+		{
+			name: "1 element",
+			hbns: []hashBlockNumber{
+				{h: [32]byte{1}, n: 1},
+			},
+			want: []byRangeReq{
+				{start: 1, count: 1, hbns: []hashBlockNumber{{h: [32]byte{1}, n: 1}}},
+			},
+		},
+		{
+			name: "2 contiguous",
+			hbns: []hashBlockNumber{
+				{h: [32]byte{2}, n: 2},
+				{h: [32]byte{1}, n: 1},
+			},
+			want: []byRangeReq{
+				{start: 1, count: 2, hbns: []hashBlockNumber{{h: [32]byte{1}, n: 1}, {h: [32]byte{2}, n: 2}}},
+			},
+		},
+		{
+			name: "2 non-contiguous",
+			hbns: []hashBlockNumber{
+				{h: [32]byte{3}, n: 3},
+				{h: [32]byte{1}, n: 1},
+			},
+			want: []byRangeReq{
+				{start: 1, count: 1, hbns: []hashBlockNumber{{h: [32]byte{1}, n: 1}}},
+				{start: 3, count: 1, hbns: []hashBlockNumber{{h: [32]byte{3}, n: 3}}},
+			},
+		},
+		{
+			name: "3 contiguous",
+			hbns: []hashBlockNumber{
+				{h: [32]byte{2}, n: 2},
+				{h: [32]byte{1}, n: 1},
+				{h: [32]byte{3}, n: 3},
+			},
+			want: []byRangeReq{
+				{start: 1, count: 3, hbns: []hashBlockNumber{{h: [32]byte{1}, n: 1}, {h: [32]byte{2}, n: 2}, {h: [32]byte{3}, n: 3}}},
+			},
+		},
+		{
+			name: "3 non-contiguous",
+			hbns: []hashBlockNumber{
+				{h: [32]byte{5}, n: 5},
+				{h: [32]byte{3}, n: 3},
+				{h: [32]byte{1}, n: 1},
+			},
+			want: []byRangeReq{
+				{start: 1, count: 1, hbns: []hashBlockNumber{{h: [32]byte{1}, n: 1}}},
+				{start: 3, count: 1, hbns: []hashBlockNumber{{h: [32]byte{3}, n: 3}}},
+				{start: 5, count: 1, hbns: []hashBlockNumber{{h: [32]byte{5}, n: 5}}},
+			},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := computeRanges(c.hbns)
+			for i := range got {
+				require.Equal(t, c.want[i].start, got[i].start)
+				require.Equal(t, c.want[i].count, got[i].count)
+				require.DeepEqual(t, c.want[i].hbns, got[i].hbns)
+			}
+		})
+	}
+}
+
+func TestReconstructBlindedBlockBatchFallbackToRange(t *testing.T) {
+	defer util.HackElectraMaxuint(t)()
+	ctx := context.Background()
+	t.Run("fallback fails", func(t *testing.T) {
+		cli, srv := newMockEngine(t)
+		fx := testBlindedBlockFixtures(t)
+		srv.register(GetPayloadBodiesByHashV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{nil, nil}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		srv.register(GetPayloadBodiesByRangeV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{nil, nil}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		toUnblind := []interfaces.ReadOnlySignedBeaconBlock{
+			fx.denebBlock.blinded.block,
+			fx.emptyDenebBlock.blinded.block,
+		}
+		_, err := reconstructBlindedBlockBatch(ctx, cli, toUnblind)
+		require.ErrorIs(t, err, errNilPayloadBody)
+		require.Equal(t, 1, srv.callCount(GetPayloadBodiesByHashV1))
+		require.Equal(t, 1, srv.callCount(GetPayloadBodiesByRangeV1))
+	})
+	t.Run("fallback succeeds", func(t *testing.T) {
+		cli, srv := newMockEngine(t)
+		fx := testBlindedBlockFixtures(t)
+		srv.register(GetPayloadBodiesByHashV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{nil, nil}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		srv.register(GetPayloadBodiesByRangeV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{
+				payloadToBody(t, fx.denebBlock.blinded.header),
+				payloadToBody(t, fx.emptyDenebBlock.blinded.header),
+			}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		unblind := []interfaces.ReadOnlySignedBeaconBlock{
+			fx.denebBlock.blinded.block,
+			fx.emptyDenebBlock.blinded.block,
+		}
+		_, err := reconstructBlindedBlockBatch(ctx, cli, unblind)
+		require.NoError(t, err)
+	})
+	t.Run("separated by block number gap", func(t *testing.T) {
+		cli, srv := newMockEngine(t)
+		fx := testBlindedBlockFixtures(t)
+		srv.register(GetPayloadBodiesByHashV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{nil, nil, nil}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		srv.register(GetPayloadBodiesByRangeV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			p := mockParseUintList(t, msg.Params)
+			require.Equal(t, 2, len(p))
+			start, count := p[0], p[1]
+			// Return first 2 blocks by number, which are contiguous.
+			if start == fx.denebBlock.blinded.header.BlockNumber() {
+				require.Equal(t, uint64(2), count)
+				executionPayloadBodies := []*pb.ExecutionPayloadBody{
+					payloadToBody(t, fx.denebBlock.blinded.header),
+					payloadToBody(t, fx.emptyDenebBlock.blinded.header),
+				}
+				mockWriteResult(t, w, msg, executionPayloadBodies)
+				return
+			}
+			// Assume it's the second request
+			require.Equal(t, fx.afterSkipDeneb.blinded.header.BlockNumber(), start)
+			require.Equal(t, uint64(1), count)
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{
+				payloadToBody(t, fx.afterSkipDeneb.blinded.header),
+			}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		// separate methods for the electra block
+		srv.register(GetPayloadBodiesByHashV2, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{nil}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		srv.register(GetPayloadBodiesByRangeV2, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			p := mockParseUintList(t, msg.Params)
+			require.Equal(t, 2, len(p))
+			start, count := p[0], p[1]
+			require.Equal(t, fx.electra.blinded.header.BlockNumber(), start)
+			require.Equal(t, uint64(1), count)
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{
+				payloadToBody(t, fx.electra.blinded.header),
+			}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		blind := []interfaces.ReadOnlySignedBeaconBlock{
+			fx.denebBlock.blinded.block,
+			fx.emptyDenebBlock.blinded.block,
+			fx.afterSkipDeneb.blinded.block,
+		}
+		unblind, err := reconstructBlindedBlockBatch(ctx, cli, blind)
+		require.NoError(t, err)
+		for i := range unblind {
+			testAssertReconstructedEquivalent(t, blind[i], unblind[i])
+		}
+	})
+}
+
+func TestReconstructBlindedBlockBatchDenebAndElectra(t *testing.T) {
+	defer util.HackElectraMaxuint(t)()
+	t.Run("deneb and electra", func(t *testing.T) {
+		cli, srv := newMockEngine(t)
+		fx := testBlindedBlockFixtures(t)
+		// The reconstructed should make separate calls for the deneb (v1) and electra (v2) blocks.
+		srv.register(GetPayloadBodiesByHashV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.denebBlock.blinded.header)}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		srv.register(GetPayloadBodiesByHashV2, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.electra.blinded.header)}
+			mockWriteResult(t, w, msg, executionPayloadBodies)
+		})
+		blinded := []interfaces.ReadOnlySignedBeaconBlock{
+			fx.denebBlock.blinded.block,
+			fx.electra.blinded.block,
+		}
+		unblinded, err := reconstructBlindedBlockBatch(context.Background(), cli, blinded)
+		require.NoError(t, err)
+		require.Equal(t, len(blinded), len(unblinded))
+		for i := range unblinded {
+			testAssertReconstructedEquivalent(t, blinded[i], unblinded[i])
+		}
+	})
+}

beacon-chain/execution/testing/BUILD.bazel

@@ -25,7 +25,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//accounts/abi/bind/backends:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",

beacon-chain/execution/testing/mock_engine_client.go

@@ -15,7 +15,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	pb "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
 // EngineClient --
@@ -23,25 +22,20 @@ type EngineClient struct {
 	NewPayloadResp              []byte
 	PayloadIDBytes              *pb.PayloadIDBytes
 	ForkChoiceUpdatedResp       []byte
-	ExecutionPayload            *pb.ExecutionPayload
-	ExecutionPayloadCapella     *pb.ExecutionPayloadCapella
-	ExecutionPayloadDeneb       *pb.ExecutionPayloadDeneb
 	ExecutionBlock              *pb.ExecutionBlock
 	Err                         error
 	ErrLatestExecBlock          error
 	ErrExecBlockByHash          error
 	ErrForkchoiceUpdated        error
 	ErrNewPayload               error
-	ErrGetPayload               error
 	ExecutionPayloadByBlockHash map[[32]byte]*pb.ExecutionPayload
 	BlockByHashMap              map[[32]byte]*pb.ExecutionBlock
 	NumReconstructedPayloads    uint64
 	TerminalBlockHash           []byte
 	TerminalBlockHashExists     bool
-	BuilderOverride             bool
 	OverrideValidHash           [32]byte
-	BlockValue                  uint64
-	BlobsBundle                 *pb.BlobsBundle
+	GetPayloadResponse          *blocks.GetPayloadResponse
+	ErrGetPayload               error
 }
 
 // NewPayload --
@@ -60,26 +54,8 @@ func (e *EngineClient) ForkchoiceUpdated(
 }
 
 // GetPayload --
-func (e *EngineClient) GetPayload(_ context.Context, _ [8]byte, s primitives.Slot) (interfaces.ExecutionData, *pb.BlobsBundle, bool, error) {
-	if slots.ToEpoch(s) >= params.BeaconConfig().DenebForkEpoch {
-		ed, err := blocks.WrappedExecutionPayloadDeneb(e.ExecutionPayloadDeneb, big.NewInt(int64(e.BlockValue)))
-		if err != nil {
-			return nil, nil, false, err
-		}
-		return ed, e.BlobsBundle, e.BuilderOverride, nil
-	}
-	if slots.ToEpoch(s) >= params.BeaconConfig().CapellaForkEpoch {
-		ed, err := blocks.WrappedExecutionPayloadCapella(e.ExecutionPayloadCapella, big.NewInt(int64(e.BlockValue)))
-		if err != nil {
-			return nil, nil, false, err
-		}
-		return ed, nil, e.BuilderOverride, nil
-	}
-	p, err := blocks.WrappedExecutionPayload(e.ExecutionPayload)
-	if err != nil {
-		return nil, nil, false, err
-	}
-	return p, nil, e.BuilderOverride, e.ErrGetPayload
+func (e *EngineClient) GetPayload(_ context.Context, _ [8]byte, s primitives.Slot) (*blocks.GetPayloadResponse, error) {
+	return e.GetPayloadResponse, e.ErrGetPayload
 }
 
 // LatestExecutionBlock --

beacon-chain/monitor/process_attestation.go

@@ -33,12 +33,12 @@ func (s *Service) canUpdateAttestedValidator(idx primitives.ValidatorIndex, slot
 }
 
 // attestingIndices returns the indices of validators that participated in the given aggregated attestation.
-func attestingIndices(ctx context.Context, state state.BeaconState, att interfaces.Attestation) ([]uint64, error) {
+func attestingIndices(ctx context.Context, state state.BeaconState, att ethpb.Att) ([]uint64, error) {
 	committee, err := helpers.BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
 	if err != nil {
 		return nil, err
 	}
-	return attestation.AttestingIndices(att.GetAggregationBits(), committee)
+	return attestation.AttestingIndices(att, committee)
 }
 
 // logMessageTimelyFlagsForIndex returns the log message with performance info for the attestation (head, source, target)
@@ -63,7 +63,7 @@ func (s *Service) processAttestations(ctx context.Context, state state.BeaconSta
 }
 
 // processIncludedAttestation logs in the event for the tracked validators' and their latest attestation gets processed.
-func (s *Service) processIncludedAttestation(ctx context.Context, state state.BeaconState, att interfaces.Attestation) {
+func (s *Service) processIncludedAttestation(ctx context.Context, state state.BeaconState, att ethpb.Att) {
 	attestingIndices, err := attestingIndices(ctx, state, att)
 	if err != nil {
 		log.WithError(err).Error("Could not get attesting indices")
@@ -161,7 +161,7 @@ func (s *Service) processIncludedAttestation(ctx context.Context, state state.Be
 }
 
 // processUnaggregatedAttestation logs when the beacon node observes an unaggregated attestation from tracked validator.
-func (s *Service) processUnaggregatedAttestation(ctx context.Context, att interfaces.Attestation) {
+func (s *Service) processUnaggregatedAttestation(ctx context.Context, att ethpb.Att) {
 	s.RLock()
 	defer s.RUnlock()
 	root := bytesutil.ToBytes32(att.GetData().BeaconBlockRoot)

beacon-chain/monitor/process_block.go

@@ -121,17 +121,20 @@ func (s *Service) processSlashings(blk interfaces.ReadOnlyBeaconBlock) {
 	for _, slashing := range blk.Body().AttesterSlashings() {
 		for _, idx := range blocks.SlashableAttesterIndices(slashing) {
 			if s.trackedIndex(primitives.ValidatorIndex(idx)) {
+				data1 := slashing.FirstAttestation().GetData()
+				data2 := slashing.SecondAttestation().GetData()
+
 				log.WithFields(logrus.Fields{
 					"attesterIndex":      idx,
 					"blockInclusionSlot": blk.Slot(),
-					"attestationSlot1":   slashing.GetFirstAttestation().GetData().Slot,
-					"beaconBlockRoot1":   fmt.Sprintf("%#x", bytesutil.Trunc(slashing.GetFirstAttestation().GetData().BeaconBlockRoot)),
-					"sourceEpoch1":       slashing.GetFirstAttestation().GetData().Source.Epoch,
-					"targetEpoch1":       slashing.GetFirstAttestation().GetData().Target.Epoch,
-					"attestationSlot2":   slashing.GetSecondAttestation().GetData().Slot,
-					"beaconBlockRoot2":   fmt.Sprintf("%#x", bytesutil.Trunc(slashing.GetSecondAttestation().GetData().BeaconBlockRoot)),
-					"sourceEpoch2":       slashing.GetSecondAttestation().GetData().Source.Epoch,
-					"targetEpoch2":       slashing.GetSecondAttestation().GetData().Target.Epoch,
+					"attestationSlot1":   data1.Slot,
+					"beaconBlockRoot1":   fmt.Sprintf("%#x", bytesutil.Trunc(data1.BeaconBlockRoot)),
+					"sourceEpoch1":       data1.Source.Epoch,
+					"targetEpoch1":       data1.Target.Epoch,
+					"attestationSlot2":   data2.Slot,
+					"beaconBlockRoot2":   fmt.Sprintf("%#x", bytesutil.Trunc(data2.BeaconBlockRoot)),
+					"sourceEpoch2":       data2.Source.Epoch,
+					"targetEpoch2":       data2.Target.Epoch,
 				}).Info("Attester slashing was included")
 			}
 		}

beacon-chain/operations/attestations/BUILD.bazel

@@ -20,9 +20,9 @@ go_library(
         "//cache/lru:go_default_library",
         "//config/features:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/hash:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation/aggregation/attestations:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
@@ -49,7 +49,6 @@ go_test(
         "//beacon-chain/operations/attestations/kv:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/operations/attestations/kv/BUILD.bazel

@@ -15,9 +15,9 @@ go_library(
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/hash:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation/aggregation/attestations:go_default_library",
         "@com_github_patrickmn_go_cache//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -39,7 +39,6 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//config/fieldparams:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//crypto/bls:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",

beacon-chain/operations/attestations/kv/aggregated.go

@@ -7,8 +7,8 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	attaggregation "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation/aggregation/attestations"
 	log "github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -28,11 +28,11 @@ func (c *AttCaches) AggregateUnaggregatedAttestations(ctx context.Context) error
 	return c.aggregateUnaggregatedAtts(ctx, unaggregatedAtts)
 }
 
-func (c *AttCaches) aggregateUnaggregatedAtts(ctx context.Context, unaggregatedAtts []interfaces.Attestation) error {
+func (c *AttCaches) aggregateUnaggregatedAtts(ctx context.Context, unaggregatedAtts []ethpb.Att) error {
 	_, span := trace.StartSpan(ctx, "operations.attestations.kv.aggregateUnaggregatedAtts")
 	defer span.End()
 
-	attsByDataRoot := make(map[[32]byte][]interfaces.Attestation, len(unaggregatedAtts))
+	attsByDataRoot := make(map[[32]byte][]ethpb.Att, len(unaggregatedAtts))
 	for _, att := range unaggregatedAtts {
 		attDataRoot, err := att.GetData().HashTreeRoot()
 		if err != nil {
@@ -66,12 +66,12 @@ func (c *AttCaches) aggregateUnaggregatedAtts(ctx context.Context, unaggregatedA
 // aggregateParallel aggregates attestations in parallel for `atts` and saves them in the pool,
 // returns the unaggregated attestations that weren't able to aggregate.
 // Given `n` CPU cores, it creates a channel of size `n` and spawns `n` goroutines to aggregate attestations
-func (c *AttCaches) aggregateParallel(atts map[[32]byte][]interfaces.Attestation, leftOver map[[32]byte]bool) map[[32]byte]bool {
+func (c *AttCaches) aggregateParallel(atts map[[32]byte][]ethpb.Att, leftOver map[[32]byte]bool) map[[32]byte]bool {
 	var leftoverLock sync.Mutex
 	wg := sync.WaitGroup{}
 
 	n := runtime.GOMAXPROCS(0) // defaults to the value of runtime.NumCPU
-	ch := make(chan []interfaces.Attestation, n)
+	ch := make(chan []ethpb.Att, n)
 	wg.Add(n)
 	for i := 0; i < n; i++ {
 		go func() {
@@ -87,7 +87,7 @@ func (c *AttCaches) aggregateParallel(atts map[[32]byte][]interfaces.Attestation
 					continue
 				}
 				if helpers.IsAggregated(aggregated) {
-					if err := c.SaveAggregatedAttestations([]interfaces.Attestation{aggregated}); err != nil {
+					if err := c.SaveAggregatedAttestations([]ethpb.Att{aggregated}); err != nil {
 						log.WithError(err).Error("could not save aggregated attestation")
 						continue
 					}
@@ -116,7 +116,7 @@ func (c *AttCaches) aggregateParallel(atts map[[32]byte][]interfaces.Attestation
 }
 
 // SaveAggregatedAttestation saves an aggregated attestation in cache.
-func (c *AttCaches) SaveAggregatedAttestation(att interfaces.Attestation) error {
+func (c *AttCaches) SaveAggregatedAttestation(att ethpb.Att) error {
 	if err := helpers.ValidateNilAttestation(att); err != nil {
 		return err
 	}
@@ -143,12 +143,12 @@ func (c *AttCaches) SaveAggregatedAttestation(att interfaces.Attestation) error
 	if err != nil {
 		return errors.Wrap(err, "could not tree hash attestation")
 	}
-	copiedAtt := interfaces.CopyAttestation(att)
+	copiedAtt := att.Copy()
 	c.aggregatedAttLock.Lock()
 	defer c.aggregatedAttLock.Unlock()
 	atts, ok := c.aggregatedAtt[r]
 	if !ok {
-		atts := []interfaces.Attestation{copiedAtt}
+		atts := []ethpb.Att{copiedAtt}
 		c.aggregatedAtt[r] = atts
 		return nil
 	}
@@ -163,7 +163,7 @@ func (c *AttCaches) SaveAggregatedAttestation(att interfaces.Attestation) error
 }
 
 // SaveAggregatedAttestations saves a list of aggregated attestations in cache.
-func (c *AttCaches) SaveAggregatedAttestations(atts []interfaces.Attestation) error {
+func (c *AttCaches) SaveAggregatedAttestations(atts []ethpb.Att) error {
 	for _, att := range atts {
 		if err := c.SaveAggregatedAttestation(att); err != nil {
 			log.WithError(err).Debug("Could not save aggregated attestation")
@@ -176,11 +176,11 @@ func (c *AttCaches) SaveAggregatedAttestations(atts []interfaces.Attestation) er
 }
 
 // AggregatedAttestations returns the aggregated attestations in cache.
-func (c *AttCaches) AggregatedAttestations() []interfaces.Attestation {
+func (c *AttCaches) AggregatedAttestations() []ethpb.Att {
 	c.aggregatedAttLock.RLock()
 	defer c.aggregatedAttLock.RUnlock()
 
-	atts := make([]interfaces.Attestation, 0)
+	atts := make([]ethpb.Att, 0)
 
 	for _, a := range c.aggregatedAtt {
 		atts = append(atts, a...)
@@ -191,11 +191,11 @@ func (c *AttCaches) AggregatedAttestations() []interfaces.Attestation {
 
 // AggregatedAttestationsBySlotIndex returns the aggregated attestations in cache,
 // filtered by committee index and slot.
-func (c *AttCaches) AggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []interfaces.Attestation {
+func (c *AttCaches) AggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []ethpb.Att {
 	_, span := trace.StartSpan(ctx, "operations.attestations.kv.AggregatedAttestationsBySlotIndex")
 	defer span.End()
 
-	atts := make([]interfaces.Attestation, 0)
+	atts := make([]ethpb.Att, 0)
 
 	c.aggregatedAttLock.RLock()
 	defer c.aggregatedAttLock.RUnlock()
@@ -209,7 +209,7 @@ func (c *AttCaches) AggregatedAttestationsBySlotIndex(ctx context.Context, slot
 }
 
 // DeleteAggregatedAttestation deletes the aggregated attestations in cache.
-func (c *AttCaches) DeleteAggregatedAttestation(att interfaces.Attestation) error {
+func (c *AttCaches) DeleteAggregatedAttestation(att ethpb.Att) error {
 	if err := helpers.ValidateNilAttestation(att); err != nil {
 		return err
 	}
@@ -232,7 +232,7 @@ func (c *AttCaches) DeleteAggregatedAttestation(att interfaces.Attestation) erro
 		return nil
 	}
 
-	filtered := make([]interfaces.Attestation, 0)
+	filtered := make([]ethpb.Att, 0)
 	for _, a := range attList {
 		if c, err := att.GetAggregationBits().Contains(a.GetAggregationBits()); err != nil {
 			return err
@@ -250,7 +250,7 @@ func (c *AttCaches) DeleteAggregatedAttestation(att interfaces.Attestation) erro
 }
 
 // HasAggregatedAttestation checks if the input attestations has already existed in cache.
-func (c *AttCaches) HasAggregatedAttestation(att interfaces.Attestation) (bool, error) {
+func (c *AttCaches) HasAggregatedAttestation(att ethpb.Att) (bool, error) {
 	if err := helpers.ValidateNilAttestation(att); err != nil {
 		return false, err
 	}