Lower log level to debug for "Attestation is too old to broadcast, discarding it"

* Cleanup part 1

* Cleanup part 2

* Cleanup part 3

* remove lock field init

* doc for SignerConfig

* remove vars

* use full Keymanager word in function

* revert interface rename

* linter

* fix build issues

* review

.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

MODULE.bazel.lock

@@ -1123,6 +1123,27 @@
         "recordedRepoMappingEntries": []
       }
     },
+    "@@bazel_tools//tools/test:extensions.bzl%remote_coverage_tools_extension": {
+      "general": {
+        "bzlTransitiveDigest": "l5mcjH2gWmbmIycx97bzI2stD0Q0M5gpDc0aLOHKIm8=",
+        "recordedFileInputs": {},
+        "recordedDirentsInputs": {},
+        "envVariables": {},
+        "generatedRepoSpecs": {
+          "remote_coverage_tools": {
+            "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl",
+            "ruleClassName": "http_archive",
+            "attributes": {
+              "sha256": "7006375f6756819b7013ca875eab70a541cf7d89142d9c511ed78ea4fefa38af",
+              "urls": [
+                "https://mirror.bazel.build/bazel_coverage_output_generator/releases/coverage_output_generator-v2.6.zip"
+              ]
+            }
+          }
+        },
+        "recordedRepoMappingEntries": []
+      }
+    },
     "@@rules_java~//java:extensions.bzl%toolchains": {
       "general": {
         "bzlTransitiveDigest": "tJHbmWnq7m+9eUBnUdv7jZziQ26FmcGL9C5/hU3Q9UQ=",

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/builder/BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/api/client/builder",
     visibility = ["//visibility:public"],
     deps = [
+        "//api:go_default_library",
         "//api/server/structs:go_default_library",
         "//config/fieldparams:go_default_library",
         "//consensus-types:go_default_library",
@@ -28,6 +29,7 @@ go_library(
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
 
@@ -49,6 +51,7 @@ go_test(
         "//math:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",

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"
 )
@@ -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, primitives.BigEndianBytesToWei(b.p.Value))
 }
 
 // BlobKzgCommitments --

api/client/builder/client.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"math/big"
 	"net"
 	"net/http"
 	"net/url"
@@ -14,11 +13,11 @@ import (
 	"text/template"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"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"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -282,133 +281,68 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 	return err
 }
 
+var errResponseVersionMismatch = errors.New("builder API response uses a different version than requested in " + api.VersionHeader + " header")
+
 // SubmitBlindedBlock calls the builder API endpoint that binds the validator to the builder and submits the block.
 // The response is the full execution payload used to create the blinded block.
 func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
 	if !sb.IsBlinded() {
 		return nil, nil, errNotBlinded
 	}
-	switch sb.Version() {
-	case version.Bellatrix:
-		psb, err := sb.PbBlindedBellatrixBlock()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not get protobuf block")
-		}
-		b, err := structs.SignedBlindedBeaconBlockBellatrixFromConsensus(&ethpb.SignedBlindedBeaconBlockBellatrix{Block: psb.Block, Signature: bytesutil.SafeCopyBytes(psb.Signature)})
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not convert SignedBlindedBeaconBlockBellatrix to json marshalable type")
-		}
-		body, err := json.Marshal(b)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockBellatrix value body in SubmitBlindedBlock")
-		}
-		versionOpt := func(r *http.Request) {
-			r.Header.Add("Eth-Consensus-Version", version.String(version.Bellatrix))
-			r.Header.Set("Content-Type", "application/json")
-			r.Header.Set("Accept", "application/json")
-		}
-		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
 
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockBellatrix to the builder api")
-		}
-		ep := &ExecPayloadResponse{}
-		if err := json.Unmarshal(rb, ep); err != nil {
-			return nil, nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlock response")
-		}
-		if strings.ToLower(ep.Version) != version.String(version.Bellatrix) {
-			return nil, nil, errors.New("not a bellatrix payload")
-		}
-		p, err := ep.ToProto()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not extract proto message from payload")
-		}
-		payload, err := blocks.WrappedExecutionPayload(p)
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not wrap execution payload in interface")
-		}
-		return payload, nil, nil
-	case version.Capella:
-		psb, err := sb.PbBlindedCapellaBlock()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not get protobuf block")
-		}
-		b, err := structs.SignedBlindedBeaconBlockCapellaFromConsensus(&ethpb.SignedBlindedBeaconBlockCapella{Block: psb.Block, Signature: bytesutil.SafeCopyBytes(psb.Signature)})
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not convert SignedBlindedBeaconBlockCapella to json marshalable type")
-		}
-		body, err := json.Marshal(b)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockCapella value body in SubmitBlindedBlockCapella")
-		}
-		versionOpt := func(r *http.Request) {
-			r.Header.Add("Eth-Consensus-Version", version.String(version.Capella))
-			r.Header.Set("Content-Type", "application/json")
-			r.Header.Set("Accept", "application/json")
-		}
-		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
-
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockCapella to the builder api")
-		}
-		ep := &ExecPayloadResponseCapella{}
-		if err := json.Unmarshal(rb, ep); err != nil {
-			return nil, nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlockCapella response")
-		}
-		if strings.ToLower(ep.Version) != version.String(version.Capella) {
-			return nil, nil, errors.New("not a capella payload")
-		}
-		p, err := ep.ToProto()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not extract proto message from payload")
-		}
-		payload, err := blocks.WrappedExecutionPayloadCapella(p, big.NewInt(0))
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not wrap execution payload in interface")
-		}
-		return payload, nil, nil
-	case version.Deneb:
-		psb, err := sb.PbBlindedDenebBlock()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not get protobuf block")
-		}
-		b, err := structs.SignedBlindedBeaconBlockDenebFromConsensus(&ethpb.SignedBlindedBeaconBlockDeneb{Message: psb.Message, Signature: bytesutil.SafeCopyBytes(psb.Signature)})
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not convert SignedBlindedBeaconBlockDeneb to json marshalable type")
-		}
-		body, err := json.Marshal(b)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error encoding the SignedBlindedBeaconBlockDeneb value body in SubmitBlindedBlockDeneb")
-		}
-
-		versionOpt := func(r *http.Request) {
-			r.Header.Add("Eth-Consensus-Version", version.String(version.Deneb))
-			r.Header.Set("Content-Type", "application/json")
-			r.Header.Set("Accept", "application/json")
-		}
-		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockDeneb to the builder api")
-		}
-		ep := &ExecPayloadResponseDeneb{}
-		if err := json.Unmarshal(rb, ep); err != nil {
-			return nil, nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlockDeneb response")
-		}
-		if strings.ToLower(ep.Version) != version.String(version.Deneb) {
-			return nil, nil, errors.New("not a deneb payload")
-		}
-		p, blobBundle, err := ep.ToProto()
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not extract proto message from payload")
-		}
-		payload, err := blocks.WrappedExecutionPayloadDeneb(p, big.NewInt(0))
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "could not wrap execution payload in interface")
-		}
-		return payload, blobBundle, nil
-	default:
-		return nil, nil, fmt.Errorf("unsupported block version %s", version.String(sb.Version()))
+	// massage the proto struct type data into the api response type.
+	mj, err := structs.SignedBeaconBlockMessageJsoner(sb)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "error generating blinded beacon block post request")
 	}
+
+	body, err := json.Marshal(mj)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "error marshaling blinded block post request to json")
+	}
+	postOpts := func(r *http.Request) {
+		r.Header.Add("Eth-Consensus-Version", version.String(sb.Version()))
+		r.Header.Set("Content-Type", api.JsonMediaType)
+		r.Header.Set("Accept", api.JsonMediaType)
+	}
+	// post the blinded block - the execution payload response should contain the unblinded payload, along with the
+	// blobs bundle if it is post deneb.
+	rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), postOpts)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "error posting the blinded block to the builder api")
+	}
+	// ExecutionPayloadResponse parses just the outer container and the Value key, enabling it to use the .Value
+	// key to determine which underlying data type to use to finish the unmarshaling.
+	ep := &ExecutionPayloadResponse{}
+	if err := json.Unmarshal(rb, ep); err != nil {
+		return nil, nil, errors.Wrap(err, "error unmarshaling the builder ExecutionPayloadResponse")
+	}
+	if strings.ToLower(ep.Version) != version.String(sb.Version()) {
+		return nil, nil, errors.Wrapf(errResponseVersionMismatch, "req=%s, recv=%s", strings.ToLower(ep.Version), version.String(sb.Version()))
+	}
+	// This parses the rest of the response and returns the inner data field.
+	pp, err := ep.ParsePayload()
+	if err != nil {
+		return nil, nil, errors.Wrapf(err, "failed to parse execution payload from builder with version=%s", ep.Version)
+	}
+	// Get the payload as a proto.Message so it can be wrapped as an execution payload interface.
+	pb, err := pp.PayloadProto()
+	if err != nil {
+		return nil, nil, err
+	}
+	ed, err := blocks.NewWrappedExecutionData(pb, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	bb, ok := pp.(BlobBundler)
+	if ok {
+		bbpb, err := bb.BundleProto()
+		if err != nil {
+			return nil, nil, errors.Wrapf(err, "failed to extract blobs bundle from builder response with version=%s", ep.Version)
+		}
+		return ed, bbpb, nil
+	}
+	return ed, nil, nil
 }
 
 // Status asks the remote builder server for a health check. A response of 200 with an empty body is the success/healthy

api/client/builder/client_test.go

@@ -432,7 +432,7 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
 		require.NoError(t, err)
 		_, _, err = c.SubmitBlindedBlock(ctx, sbbb)
-		require.ErrorContains(t, "not a bellatrix payload", err)
+		require.ErrorIs(t, err, errResponseVersionMismatch)
 	})
 	t.Run("not blinded", func(t *testing.T) {
 		sbb, err := blocks.NewSignedBeaconBlock(&eth.SignedBeaconBlockBellatrix{Block: &eth.BeaconBlockBellatrix{Body: &eth.BeaconBlockBodyBellatrix{ExecutionPayload: &v1.ExecutionPayload{}}}})

api/client/builder/types.go

@@ -9,11 +9,15 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"google.golang.org/protobuf/proto"
 )
 
 var errInvalidUint256 = errors.New("invalid Uint256")
@@ -44,6 +48,9 @@ func sszBytesToUint256(b []byte) (Uint256, error) {
 
 // SSZBytes creates an ssz-style (little-endian byte slice) representation of the Uint256.
 func (s Uint256) SSZBytes() []byte {
+	if s.Int == nil {
+		s.Int = big.NewInt(0)
+	}
 	if !math.IsValidUint256(s.Int) {
 		return []byte{}
 	}
@@ -91,6 +98,9 @@ func (s Uint256) MarshalJSON() ([]byte, error) {
 
 // MarshalText returns a text byte representation of Uint256.
 func (s Uint256) MarshalText() ([]byte, error) {
+	if s.Int == nil {
+		s.Int = big.NewInt(0)
+	}
 	if !math.IsValidUint256(s.Int) {
 		return nil, errors.Wrapf(errInvalidUint256, "value=%s", s.Int)
 	}
@@ -265,6 +275,11 @@ func (r *ExecPayloadResponse) ToProto() (*v1.ExecutionPayload, error) {
 	return r.Data.ToProto()
 }
 
+func (r *ExecutionPayload) PayloadProto() (proto.Message, error) {
+	pb, err := r.ToProto()
+	return pb, err
+}
+
 // ToProto returns a ExecutionPayload Proto
 func (p *ExecutionPayload) ToProto() (*v1.ExecutionPayload, error) {
 	txs := make([][]byte, len(p.Transactions))
@@ -396,6 +411,51 @@ func FromProtoDeneb(payload *v1.ExecutionPayloadDeneb) (ExecutionPayloadDeneb, e
 	}, nil
 }
 
+var errInvalidTypeConversion = errors.New("unable to translate between api and foreign type")
+
+// ExecutionPayloadResponseFromData converts an ExecutionData interface value to a payload response.
+// This involves serializing the execution payload value so that the abstract payload envelope can be used.
+func ExecutionPayloadResponseFromData(ed interfaces.ExecutionData, bundle *v1.BlobsBundle) (*ExecutionPayloadResponse, error) {
+	pb := ed.Proto()
+	var data interface{}
+	var err error
+	var ver string
+	switch pbStruct := pb.(type) {
+	case *v1.ExecutionPayload:
+		ver = version.String(version.Bellatrix)
+		data, err = FromProto(pbStruct)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert a Bellatrix ExecutionPayload to an API response")
+		}
+	case *v1.ExecutionPayloadCapella:
+		ver = version.String(version.Capella)
+		data, err = FromProtoCapella(pbStruct)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert a Capella ExecutionPayload to an API response")
+		}
+	case *v1.ExecutionPayloadDeneb:
+		ver = version.String(version.Deneb)
+		payloadStruct, err := FromProtoDeneb(pbStruct)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to convert a Deneb ExecutionPayload to an API response")
+		}
+		data = &ExecutionPayloadDenebAndBlobsBundle{
+			ExecutionPayload: &payloadStruct,
+			BlobsBundle:      FromBundleProto(bundle),
+		}
+	default:
+		return nil, errInvalidTypeConversion
+	}
+	encoded, err := json.Marshal(data)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to marshal execution payload version=%s", ver)
+	}
+	return &ExecutionPayloadResponse{
+		Version: ver,
+		Data:    encoded,
+	}, nil
+}
+
 // ExecHeaderResponseCapella is the response of builder API /eth/v1/builder/header/{slot}/{parent_hash}/{pubkey} for Capella.
 type ExecHeaderResponseCapella struct {
 	Data struct {
@@ -523,6 +583,42 @@ type ExecPayloadResponseCapella struct {
 	Data    ExecutionPayloadCapella `json:"data"`
 }
 
+// ExecutionPayloadResponse allows for unmarshaling just the Version field of the payload.
+// This allows it to return different ExecutionPayload types based on the version field.
+type ExecutionPayloadResponse struct {
+	Version string          `json:"version"`
+	Data    json.RawMessage `json:"data"`
+}
+
+// ParsedPayload can retrieve the underlying protobuf message for the given execution payload response.
+type ParsedPayload interface {
+	PayloadProto() (proto.Message, error)
+}
+
+// BlobBundler can retrieve the underlying blob bundle protobuf message for the given execution payload response.
+type BlobBundler interface {
+	BundleProto() (*v1.BlobsBundle, error)
+}
+
+func (r *ExecutionPayloadResponse) ParsePayload() (ParsedPayload, error) {
+	var toProto ParsedPayload
+	switch r.Version {
+	case version.String(version.Bellatrix):
+		toProto = &ExecutionPayload{}
+	case version.String(version.Capella):
+		toProto = &ExecutionPayloadCapella{}
+	case version.String(version.Deneb):
+		toProto = &ExecutionPayloadDenebAndBlobsBundle{}
+	default:
+		return nil, consensusblocks.ErrUnsupportedVersion
+	}
+
+	if err := json.Unmarshal(r.Data, toProto); err != nil {
+		return nil, errors.Wrap(err, "failed to unmarshal the response .Data field with the stated version schema")
+	}
+	return toProto, nil
+}
+
 // ExecutionPayloadCapella is a field of ExecPayloadResponseCapella.
 type ExecutionPayloadCapella struct {
 	ParentHash    hexutil.Bytes   `json:"parent_hash"`
@@ -547,6 +643,11 @@ func (r *ExecPayloadResponseCapella) ToProto() (*v1.ExecutionPayloadCapella, err
 	return r.Data.ToProto()
 }
 
+func (p *ExecutionPayloadCapella) PayloadProto() (proto.Message, error) {
+	pb, err := p.ToProto()
+	return pb, err
+}
+
 // ToProto returns a ExecutionPayloadCapella Proto.
 func (p *ExecutionPayloadCapella) ToProto() (*v1.ExecutionPayloadCapella, error) {
 	txs := make([][]byte, len(p.Transactions))
@@ -1128,6 +1229,12 @@ func (r *ExecPayloadResponseDeneb) ToProto() (*v1.ExecutionPayloadDeneb, *v1.Blo
 	if r.Data == nil {
 		return nil, nil, errors.New("data field in response is empty")
 	}
+	if r.Data.ExecutionPayload == nil {
+		return nil, nil, errors.Wrap(consensusblocks.ErrNilObject, "nil execution payload")
+	}
+	if r.Data.BlobsBundle == nil {
+		return nil, nil, errors.Wrap(consensusblocks.ErrNilObject, "nil blobs bundle")
+	}
 	payload, err := r.Data.ExecutionPayload.ToProto()
 	if err != nil {
 		return nil, nil, err
@@ -1139,8 +1246,26 @@ func (r *ExecPayloadResponseDeneb) ToProto() (*v1.ExecutionPayloadDeneb, *v1.Blo
 	return payload, bundle, nil
 }
 
+func (r *ExecutionPayloadDenebAndBlobsBundle) PayloadProto() (proto.Message, error) {
+	if r.ExecutionPayload == nil {
+		return nil, errors.Wrap(consensusblocks.ErrNilObject, "nil execution payload in combined deneb payload")
+	}
+	pb, err := r.ExecutionPayload.ToProto()
+	return pb, err
+}
+
+func (r *ExecutionPayloadDenebAndBlobsBundle) BundleProto() (*v1.BlobsBundle, error) {
+	if r.BlobsBundle == nil {
+		return nil, errors.Wrap(consensusblocks.ErrNilObject, "nil blobs bundle")
+	}
+	return r.BlobsBundle.ToProto()
+}
+
 // ToProto returns the ExecutionPayloadDeneb Proto.
 func (p *ExecutionPayloadDeneb) ToProto() (*v1.ExecutionPayloadDeneb, error) {
+	if p == nil {
+		return nil, errors.Wrap(consensusblocks.ErrNilObject, "nil execution payload")
+	}
 	txs := make([][]byte, len(p.Transactions))
 	for i := range p.Transactions {
 		txs[i] = bytesutil.SafeCopyBytes(p.Transactions[i])

api/client/builder/types_test.go

@@ -15,9 +15,11 @@ import (
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
@@ -1600,7 +1602,6 @@ func TestBuilderBidUnmarshalUint256(t *testing.T) {
 	require.NoError(t, expectedValue.UnmarshalText([]byte(base10)))
 	r := &ExecHeaderResponse{}
 	require.NoError(t, json.Unmarshal([]byte(testBuilderBid), r))
-	//require.Equal(t, expectedValue, r.Data.Message.Value)
 	marshaled := r.Data.Message.Value.String()
 	require.Equal(t, base10, marshaled)
 	require.Equal(t, 0, expectedValue.Cmp(r.Data.Message.Value.Int))
@@ -1907,3 +1908,40 @@ func TestErrorMessage_non200Err(t *testing.T) {
 		})
 	}
 }
+
+func TestEmptyResponseBody(t *testing.T) {
+	t.Run("empty buffer", func(t *testing.T) {
+		var b []byte
+		r := &ExecutionPayloadResponse{}
+		err := json.Unmarshal(b, r)
+		_, ok := err.(*json.SyntaxError)
+		require.Equal(t, true, ok)
+	})
+	t.Run("empty object", func(t *testing.T) {
+		empty := []byte("{}")
+		emptyResponse := &ExecutionPayloadResponse{}
+		require.NoError(t, json.Unmarshal(empty, emptyResponse))
+		_, err := emptyResponse.ParsePayload()
+		require.ErrorIs(t, err, consensusblocks.ErrUnsupportedVersion)
+	})
+	versions := []int{version.Bellatrix, version.Capella, version.Deneb}
+	for i := range versions {
+		vstr := version.String(versions[i])
+		t.Run("populated version without payload"+vstr, func(t *testing.T) {
+			in := &ExecutionPayloadResponse{Version: vstr}
+			encoded, err := json.Marshal(in)
+			require.NoError(t, err)
+			epr := &ExecutionPayloadResponse{}
+			require.NoError(t, json.Unmarshal(encoded, epr))
+			pp, err := epr.ParsePayload()
+			require.NoError(t, err)
+			pb, err := pp.PayloadProto()
+			if err == nil {
+				require.NoError(t, err)
+				require.Equal(t, false, pb == nil)
+			} else {
+				require.ErrorIs(t, err, consensusblocks.ErrNilObject)
+			}
+		})
+	}
+}

api/server/structs/BUILD.bazel

@@ -26,6 +26,7 @@ go_library(
         "//api/server:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
         "//container/slice:go_default_library",

api/server/structs/block.go

@@ -1,10 +1,34 @@
 package structs
 
+import "encoding/json"
+
+// MessageJsoner describes a signed consensus type wrapper that can return the `.Message` field in a json envelope
+// encoded as a []byte, for use as a json.RawMessage value when encoding the outer envelope.
+type MessageJsoner interface {
+	MessageRawJson() ([]byte, error)
+}
+
+// SignedMessageJsoner embeds MessageJsoner and adds a method to also retrieve the Signature field as a string.
+type SignedMessageJsoner interface {
+	MessageJsoner
+	SigString() string
+}
+
 type SignedBeaconBlock struct {
 	Message   *BeaconBlock `json:"message"`
 	Signature string       `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlock{}
+
+func (s *SignedBeaconBlock) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlock) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlock struct {
 	Slot          string           `json:"slot"`
 	ProposerIndex string           `json:"proposer_index"`
@@ -29,6 +53,16 @@ type SignedBeaconBlockAltair struct {
 	Signature string             `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlockAltair{}
+
+func (s *SignedBeaconBlockAltair) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlockAltair) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlockAltair struct {
 	Slot          string                 `json:"slot"`
 	ProposerIndex string                 `json:"proposer_index"`
@@ -54,6 +88,16 @@ type SignedBeaconBlockBellatrix struct {
 	Signature string                `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlockBellatrix{}
+
+func (s *SignedBeaconBlockBellatrix) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlockBellatrix) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlockBellatrix struct {
 	Slot          string                    `json:"slot"`
 	ProposerIndex string                    `json:"proposer_index"`
@@ -80,6 +124,16 @@ type SignedBlindedBeaconBlockBellatrix struct {
 	Signature string                       `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBlindedBeaconBlockBellatrix{}
+
+func (s *SignedBlindedBeaconBlockBellatrix) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBlindedBeaconBlockBellatrix) SigString() string {
+	return s.Signature
+}
+
 type BlindedBeaconBlockBellatrix struct {
 	Slot          string                           `json:"slot"`
 	ProposerIndex string                           `json:"proposer_index"`
@@ -106,6 +160,16 @@ type SignedBeaconBlockCapella struct {
 	Signature string              `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlockCapella{}
+
+func (s *SignedBeaconBlockCapella) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlockCapella) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlockCapella struct {
 	Slot          string                  `json:"slot"`
 	ProposerIndex string                  `json:"proposer_index"`
@@ -133,6 +197,16 @@ type SignedBlindedBeaconBlockCapella struct {
 	Signature string                     `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBlindedBeaconBlockCapella{}
+
+func (s *SignedBlindedBeaconBlockCapella) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBlindedBeaconBlockCapella) SigString() string {
+	return s.Signature
+}
+
 type BlindedBeaconBlockCapella struct {
 	Slot          string                         `json:"slot"`
 	ProposerIndex string                         `json:"proposer_index"`
@@ -172,6 +246,16 @@ type SignedBeaconBlockDeneb struct {
 	Signature string            `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBeaconBlockDeneb{}
+
+func (s *SignedBeaconBlockDeneb) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBeaconBlockDeneb) SigString() string {
+	return s.Signature
+}
+
 type BeaconBlockDeneb struct {
 	Slot          string                `json:"slot"`
 	ProposerIndex string                `json:"proposer_index"`
@@ -208,6 +292,16 @@ type SignedBlindedBeaconBlockDeneb struct {
 	Signature string                   `json:"signature"`
 }
 
+var _ SignedMessageJsoner = &SignedBlindedBeaconBlockDeneb{}
+
+func (s *SignedBlindedBeaconBlockDeneb) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
+}
+
+func (s *SignedBlindedBeaconBlockDeneb) SigString() string {
+	return s.Signature
+}
+
 type BlindedBeaconBlockBodyDeneb struct {
 	RandaoReveal           string                        `json:"randao_reveal"`
 	Eth1Data               *Eth1Data                     `json:"eth1_data"`

api/server/structs/conversions_block.go

@@ -6,8 +6,10 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"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/encoding/bytesutil"
@@ -15,6 +17,8 @@ import (
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
+var ErrUnsupportedConversion = errors.New("Could not determine api struct type to use for value")
+
 func (h *SignedBeaconBlockHeader) ToConsensus() (*eth.SignedBeaconBlockHeader, error) {
 	msg, err := h.Message.ToConsensus()
 	if err != nil {
@@ -1852,7 +1856,34 @@ func BeaconBlockFromConsensus(b *eth.BeaconBlock) *BeaconBlock {
 	}
 }
 
-func SignedBeaconBlockFromConsensus(b *eth.SignedBeaconBlock) *SignedBeaconBlock {
+func SignedBeaconBlockMessageJsoner(block interfaces.ReadOnlySignedBeaconBlock) (SignedMessageJsoner, error) {
+	pb, err := block.Proto()
+	if err != nil {
+		return nil, err
+	}
+	switch pbStruct := pb.(type) {
+	case *eth.SignedBeaconBlock:
+		return SignedBeaconBlockPhase0FromConsensus(pbStruct), nil
+	case *eth.SignedBeaconBlockAltair:
+		return SignedBeaconBlockAltairFromConsensus(pbStruct), nil
+	case *eth.SignedBlindedBeaconBlockBellatrix:
+		return SignedBlindedBeaconBlockBellatrixFromConsensus(pbStruct)
+	case *eth.SignedBeaconBlockBellatrix:
+		return SignedBeaconBlockBellatrixFromConsensus(pbStruct)
+	case *eth.SignedBlindedBeaconBlockCapella:
+		return SignedBlindedBeaconBlockCapellaFromConsensus(pbStruct)
+	case *eth.SignedBeaconBlockCapella:
+		return SignedBeaconBlockCapellaFromConsensus(pbStruct)
+	case *eth.SignedBlindedBeaconBlockDeneb:
+		return SignedBlindedBeaconBlockDenebFromConsensus(pbStruct)
+	case *eth.SignedBeaconBlockDeneb:
+		return SignedBeaconBlockDenebFromConsensus(pbStruct)
+	default:
+		return nil, ErrUnsupportedConversion
+	}
+}
+
+func SignedBeaconBlockPhase0FromConsensus(b *eth.SignedBeaconBlock) *SignedBeaconBlock {
 	return &SignedBeaconBlock{
 		Message:   BeaconBlockFromConsensus(b.Block),
 		Signature: hexutil.Encode(b.Signature),

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

@@ -401,7 +401,7 @@ func (s *Service) saveOrphanedOperations(ctx context.Context, orphanedRoot [32]b
 		}
 		for _, a := range orphanedBlk.Block().Body().Attestations() {
 			// if the attestation is one epoch older, it wouldn't been useful to save it.
-			if a.Data.Slot+params.BeaconConfig().SlotsPerEpoch < s.CurrentSlot() {
+			if a.GetData().Slot+params.BeaconConfig().SlotsPerEpoch < s.CurrentSlot() {
 				continue
 			}
 			if helpers.IsAggregated(a) {

beacon-chain/blockchain/head_test.go

@@ -13,6 +13,7 @@ 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"
@@ -312,14 +313,14 @@ func TestSaveOrphanedAtts(t *testing.T) {
 
 	require.NoError(t, service.saveOrphanedOperations(ctx, r3, r4))
 	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []*ethpb.Attestation{
+	wantAtts := []interfaces.Attestation{
 		blk3.Block.Body.Attestations[0],
 		blk2.Block.Body.Attestations[0],
 		blk1.Block.Body.Attestations[0],
 	}
 	atts := service.cfg.AttPool.AggregatedAttestations()
 	sort.Slice(atts, func(i, j int) bool {
-		return atts[i].Data.Slot > atts[j].Data.Slot
+		return atts[i].GetData().Slot > atts[j].GetData().Slot
 	})
 	require.DeepEqual(t, wantAtts, atts)
 }
@@ -389,14 +390,14 @@ func TestSaveOrphanedOps(t *testing.T) {
 
 	require.NoError(t, service.saveOrphanedOperations(ctx, r3, r4))
 	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []*ethpb.Attestation{
+	wantAtts := []interfaces.Attestation{
 		blk3.Block.Body.Attestations[0],
 		blk2.Block.Body.Attestations[0],
 		blk1.Block.Body.Attestations[0],
 	}
 	atts := service.cfg.AttPool.AggregatedAttestations()
 	sort.Slice(atts, func(i, j int) bool {
-		return atts[i].Data.Slot > atts[j].Data.Slot
+		return atts[i].GetData().Slot > atts[j].GetData().Slot
 	})
 	require.DeepEqual(t, wantAtts, atts)
 	require.Equal(t, 1, len(service.cfg.SlashingPool.PendingProposerSlashings(ctx, st, false)))
@@ -517,14 +518,14 @@ func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
 
 	require.NoError(t, service.saveOrphanedOperations(ctx, r3, r4))
 	require.Equal(t, 3, service.cfg.AttPool.AggregatedAttestationCount())
-	wantAtts := []*ethpb.Attestation{
+	wantAtts := []interfaces.Attestation{
 		blk3.Block.Body.Attestations[0],
 		blk2.Block.Body.Attestations[0],
 		blk1.Block.Body.Attestations[0],
 	}
 	atts := service.cfg.AttPool.AggregatedAttestations()
 	sort.Slice(atts, func(i, j int) bool {
-		return atts[i].Data.Slot > atts[j].Data.Slot
+		return atts[i].GetData().Slot > atts[j].GetData().Slot
 	})
 	require.DeepEqual(t, wantAtts, atts)
 }

beacon-chain/blockchain/metrics.go

@@ -369,6 +369,6 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 
 func reportAttestationInclusion(blk interfaces.ReadOnlyBeaconBlock) {
 	for _, att := range blk.Body().Attestations() {
-		attestationInclusionDelay.Observe(float64(blk.Slot() - att.Data.Slot))
+		attestationInclusionDelay.Observe(float64(blk.Slot() - att.GetData().Slot))
 	}
 }

beacon-chain/blockchain/process_attestation.go

@@ -6,6 +6,7 @@ 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"
@@ -36,17 +37,17 @@ import (
 //
 //	 # Update latest messages for attesting indices
 //	 update_latest_messages(store, indexed_attestation.attesting_indices, attestation)
-func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation, disparity time.Duration) error {
+func (s *Service) OnAttestation(ctx context.Context, a interfaces.Attestation, disparity time.Duration) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onAttestation")
 	defer span.End()
 
 	if err := helpers.ValidateNilAttestation(a); err != nil {
 		return err
 	}
-	if err := helpers.ValidateSlotTargetEpoch(a.Data); err != nil {
+	if err := helpers.ValidateSlotTargetEpoch(a.GetData()); err != nil {
 		return err
 	}
-	tgt := ethpb.CopyCheckpoint(a.Data.Target)
+	tgt := ethpb.CopyCheckpoint(a.GetData().Target)
 
 	// Note that target root check is ignored here because it was performed in sync's validation pipeline:
 	// validate_aggregate_proof.go and validate_beacon_attestation.go
@@ -67,7 +68,7 @@ func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation, dispa
 	}
 
 	// Verify attestation beacon block is known and not from the future.
-	if err := s.verifyBeaconBlock(ctx, a.Data); err != nil {
+	if err := s.verifyBeaconBlock(ctx, a.GetData()); err != nil {
 		return errors.Wrap(err, "could not verify attestation beacon block")
 	}
 
@@ -75,12 +76,12 @@ func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation, dispa
 	// validate_aggregate_proof.go and validate_beacon_attestation.go
 
 	// Verify attestations can only affect the fork choice of subsequent slots.
-	if err := slots.VerifyTime(genesisTime, a.Data.Slot+1, disparity); err != nil {
+	if err := slots.VerifyTime(genesisTime, a.GetData().Slot+1, disparity); err != nil {
 		return err
 	}
 
 	// Use the target state to verify attesting indices are valid.
-	committee, err := helpers.BeaconCommitteeFromState(ctx, baseState, a.Data.Slot, a.Data.CommitteeIndex)
+	committee, err := helpers.BeaconCommitteeFromState(ctx, baseState, a.GetData().Slot, a.GetData().CommitteeIndex)
 	if err != nil {
 		return err
 	}
@@ -97,7 +98,7 @@ func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation, dispa
 	// We assume trusted attestation in this function has verified signature.
 
 	// Update forkchoice store with the new attestation for updating weight.
-	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.AttestingIndices, bytesutil.ToBytes32(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
+	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(a.GetData().BeaconBlockRoot), a.GetData().Target.Epoch)
 
 	return nil
 }

beacon-chain/blockchain/process_attestation_test.go

@@ -9,6 +9,7 @@ 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"
@@ -73,7 +74,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 
 	tests := []struct {
 		name      string
-		a         *ethpb.Attestation
+		a         interfaces.Attestation
 		wantedErr string
 	}{
 		{

beacon-chain/blockchain/process_block.go

@@ -366,17 +366,17 @@ func (s *Service) handleEpochBoundary(ctx context.Context, slot primitives.Slot,
 func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock, st state.BeaconState) error {
 	// Feed in block's attestations to fork choice store.
 	for _, a := range blk.Body().Attestations() {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, st, a.Data.Slot, a.Data.CommitteeIndex)
+		committee, err := helpers.BeaconCommitteeFromState(ctx, st, a.GetData().Slot, a.GetData().CommitteeIndex)
 		if err != nil {
 			return err
 		}
-		indices, err := attestation.AttestingIndices(a.AggregationBits, committee)
+		indices, err := attestation.AttestingIndices(a, committee)
 		if err != nil {
 			return err
 		}
-		r := bytesutil.ToBytes32(a.Data.BeaconBlockRoot)
+		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
 		if s.cfg.ForkChoiceStore.HasNode(r) {
-			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.Data.Target.Epoch)
+			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Target.Epoch)
 		} else if err := s.cfg.AttPool.SaveBlockAttestation(a); 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 []*ethpb.AttesterSlashing) {
+func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashings []interfaces.AttesterSlashing) {
 	for _, slashing := range slashings {
 		indices := blocks.SlashableAttesterIndices(slashing)
 		for _, index := range indices {

beacon-chain/blockchain/process_block_test.go

@@ -824,7 +824,10 @@ 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 := b.Block.Body.Attestations
+	atts := make([]interfaces.Attestation, len(b.Block.Body.Attestations))
+	for i, a := range b.Block.Body.Attestations {
+		atts[i] = a
+	}
 	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
 	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
@@ -2010,12 +2013,12 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 
 	require.Equal(t, 1, len(wsb.Block().Body().Attestations()))
 	a := wsb.Block().Body().Attestations()[0]
-	r := bytesutil.ToBytes32(a.Data.BeaconBlockRoot)
+	r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
 	require.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(r))
 
 	require.Equal(t, 1, len(wsb.Block().Body().Attestations()))
 	a3 := wsb3.Block().Body().Attestations()[0]
-	r3 := bytesutil.ToBytes32(a3.Data.BeaconBlockRoot)
+	r3 := bytesutil.ToBytes32(a3.GetData().BeaconBlockRoot)
 	require.Equal(t, false, service.cfg.ForkChoiceStore.HasNode(r3))
 
 	require.NoError(t, service.handleBlockAttestations(ctx, wsb.Block(), st)) // fine to use the same committee as st

beacon-chain/blockchain/receive_attestation.go

@@ -10,6 +10,7 @@ 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"
@@ -31,7 +32,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 *ethpb.Attestation) error
+	VerifyLmdFfgConsistency(ctx context.Context, att interfaces.Attestation) error
 	InForkchoice([32]byte) bool
 }
 
@@ -51,13 +52,13 @@ 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 *ethpb.Attestation) error {
-	r, err := s.TargetRootForEpoch([32]byte(a.Data.BeaconBlockRoot), a.Data.Target.Epoch)
+func (s *Service) VerifyLmdFfgConsistency(ctx context.Context, a interfaces.Attestation) error {
+	r, err := s.TargetRootForEpoch([32]byte(a.GetData().BeaconBlockRoot), a.GetData().Target.Epoch)
 	if err != nil {
 		return err
 	}
-	if !bytes.Equal(a.Data.Target.Root, r[:]) {
-		return fmt.Errorf("FFG and LMD votes are not consistent, block root: %#x, target root: %#x, canonical target root: %#x", a.Data.BeaconBlockRoot, a.Data.Target.Root, r)
+	if !bytes.Equal(a.GetData().Target.Root, r[:]) {
+		return fmt.Errorf("FFG and LMD votes are not consistent, block root: %#x, target root: %#x, canonical target root: %#x", a.GetData().BeaconBlockRoot, a.GetData().Target.Root, r)
 	}
 	return nil
 }
@@ -170,13 +171,13 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 		// Based on the spec, don't process the attestation until the subsequent slot.
 		// This delays consideration in the fork choice until their slot is in the past.
 		// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
-		nextSlot := a.Data.Slot + 1
+		nextSlot := a.GetData().Slot + 1
 		if err := slots.VerifyTime(uint64(s.genesisTime.Unix()), nextSlot, disparity); err != nil {
 			continue
 		}
 
-		hasState := s.cfg.BeaconDB.HasStateSummary(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
-		hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.Data.BeaconBlockRoot))
+		hasState := s.cfg.BeaconDB.HasStateSummary(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
+		hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
 		if !(hasState && hasBlock) {
 			continue
 		}
@@ -185,17 +186,17 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 			log.WithError(err).Error("Could not delete fork choice attestation in pool")
 		}
 
-		if !helpers.VerifyCheckpointEpoch(a.Data.Target, s.genesisTime) {
+		if !helpers.VerifyCheckpointEpoch(a.GetData().Target, s.genesisTime) {
 			continue
 		}
 
 		if err := s.receiveAttestationNoPubsub(ctx, a, disparity); err != nil {
 			log.WithFields(logrus.Fields{
-				"slot":             a.Data.Slot,
-				"committeeIndex":   a.Data.CommitteeIndex,
-				"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.BeaconBlockRoot)),
-				"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.Data.Target.Root)),
-				"aggregationCount": a.AggregationBits.Count(),
+				"slot":             a.GetData().Slot,
+				"committeeIndex":   a.GetData().CommitteeIndex,
+				"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
+				"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
+				"aggregationCount": a.GetAggregationBits().Count(),
 			}).WithError(err).Warn("Could not process attestation for fork choice")
 		}
 	}
@@ -206,7 +207,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 *ethpb.Attestation, disparity time.Duration) error {
+func (s *Service) receiveAttestationNoPubsub(ctx context.Context, att interfaces.Attestation, disparity time.Duration) error {
 	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.receiveAttestationNoPubsub")
 	defer span.End()
 

beacon-chain/blockchain/receive_attestation_test.go

@@ -10,6 +10,7 @@ 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"
@@ -83,7 +84,11 @@ 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))
-	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
+	attsToSave := make([]interfaces.Attestation, len(atts))
+	for i, a := range atts {
+		attsToSave[i] = a
+	}
+	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(attsToSave))
 	service.processAttestations(ctx, 0)
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations()))
 	require.LogsDoNotContain(t, hook, "Could not process attestation for fork choice")
@@ -121,7 +126,11 @@ 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)
-	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
+	attsToSave := make([]interfaces.Attestation, len(atts))
+	for i, a := range atts {
+		attsToSave[i] = a
+	}
+	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(attsToSave))
 	// Verify the target is in forkchoice
 	require.Equal(t, true, fcs.HasNode(bytesutil.ToBytes32(atts[0].Data.BeaconBlockRoot)))
 	require.Equal(t, tRoot, bytesutil.ToBytes32(atts[0].Data.BeaconBlockRoot))

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, slashings *ethpb.AttesterSlashing)
+	ReceiveAttesterSlashing(ctx context.Context, slashing interfaces.AttesterSlashing)
 }
 
 // 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 *ethpb.AttesterSlashing) {
+func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing interfaces.AttesterSlashing) {
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	s.InsertSlashingsToForkChoiceStore(ctx, []*ethpb.AttesterSlashing{slashing})
+	s.InsertSlashingsToForkChoiceStore(ctx, []interfaces.AttesterSlashing{slashing})
 }
 
 // prunePostBlockOperationPools only runs on new head otherwise should return a nil.
@@ -479,7 +479,7 @@ func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySigne
 	// is done in the background to avoid adding more load to this critical code path.
 	ctx := context.TODO()
 	for _, att := range signed.Block().Body().Attestations() {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, preState, att.Data.Slot, att.Data.CommitteeIndex)
+		committee, err := helpers.BeaconCommitteeFromState(ctx, preState, att.GetData().Slot, att.GetData().CommitteeIndex)
 		if err != nil {
 			log.WithError(err).Error("Could not get attestation committee")
 			return

beacon-chain/blockchain/setup_test.go

@@ -20,6 +20,7 @@ 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"
@@ -49,7 +50,7 @@ func (mb *mockBroadcaster) Broadcast(_ context.Context, _ proto.Message) error {
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ *ethpb.Attestation) error {
+func (mb *mockBroadcaster) BroadcastAttestation(_ context.Context, _ uint64, _ interfaces.Attestation) error {
 	mb.broadcastCalled = true
 	return nil
 }

beacon-chain/blockchain/testing/mock.go

@@ -414,8 +414,8 @@ func (*ChainService) HeadGenesisValidatorsRoot() [32]byte {
 }
 
 // VerifyLmdFfgConsistency mocks VerifyLmdFfgConsistency and always returns nil.
-func (*ChainService) VerifyLmdFfgConsistency(_ context.Context, a *ethpb.Attestation) error {
-	if !bytes.Equal(a.Data.BeaconBlockRoot, a.Data.Target.Root) {
+func (*ChainService) VerifyLmdFfgConsistency(_ context.Context, a interfaces.Attestation) error {
+	if !bytes.Equal(a.GetData().BeaconBlockRoot, a.GetData().Target.Root) {
 		return errors.New("LMD and FFG miss matched")
 	}
 	return nil
@@ -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, *ethpb.AttesterSlashing) {}
+func (*ChainService) ReceiveAttesterSlashing(context.Context, interfaces.AttesterSlashing) {}
 
 // IsFinalized mocks the same method in the chain service.
 func (s *ChainService) IsFinalized(_ context.Context, blockRoot [32]byte) bool {

beacon-chain/cache/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
         "active_balance.go",
         "active_balance_disabled.go",  # keep
         "attestation_data.go",
+        "balance_cache_key.go",
         "checkpoint_state.go",
         "committee.go",
         "committee_disabled.go",  # keep
@@ -70,6 +71,7 @@ go_test(
         "committee_fuzz_test.go",
         "committee_test.go",
         "payload_id_test.go",
+        "private_access_test.go",
         "proposer_indices_test.go",
         "registration_test.go",
         "skip_slot_cache_test.go",
@@ -93,6 +95,7 @@ go_test(
         "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
+        "@com_github_hashicorp_golang_lru//:go_default_library",
         "@com_github_stretchr_testify//require:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],

beacon-chain/cache/active_balance.go

@@ -3,17 +3,13 @@
 package cache
 
 import (
-	"encoding/binary"
 	"sync"
 
 	lru "github.com/hashicorp/golang-lru"
-	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	lruwrpr "github.com/prysmaticlabs/prysm/v5/cache/lru"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
 const (
@@ -86,36 +82,3 @@ func (c *BalanceCache) Get(st state.ReadOnlyBeaconState) (uint64, error) {
 	balanceCacheHit.Inc()
 	return value.(uint64), nil
 }
-
-// Given input state `st`, balance key is constructed as:
-// (block_root in `st` at epoch_start_slot - 1) + current_epoch + validator_count
-func balanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	currentEpoch := st.Slot().DivSlot(slotsPerEpoch)
-	epochStartSlot, err := slotsPerEpoch.SafeMul(uint64(currentEpoch))
-	if err != nil {
-		// impossible condition due to early division
-		return "", errors.Errorf("start slot calculation overflows: %v", err)
-	}
-	prevSlot := primitives.Slot(0)
-	if epochStartSlot > 1 {
-		prevSlot = epochStartSlot - 1
-	}
-	r, err := st.BlockRootAtIndex(uint64(prevSlot % params.BeaconConfig().SlotsPerHistoricalRoot))
-	if err != nil {
-		// impossible condition because index is always constrained within state
-		return "", err
-	}
-
-	// Mix in current epoch
-	b := make([]byte, 8)
-	binary.LittleEndian.PutUint64(b, uint64(currentEpoch))
-	key := append(r, b...)
-
-	// Mix in validator count
-	b = make([]byte, 8)
-	binary.LittleEndian.PutUint64(b, uint64(st.NumValidators()))
-	key = append(key, b...)
-
-	return string(key), nil
-}

beacon-chain/cache/active_balance_test.go

@@ -1,12 +1,13 @@
 //go:build !fuzz
 
-package cache
+package cache_test
 
 import (
 	"encoding/binary"
 	"math"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	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"
@@ -27,33 +28,33 @@ func TestBalanceCache_AddGetBalance(t *testing.T) {
 	st, err := state_native.InitializeFromProtoPhase0(raw)
 	require.NoError(t, err)
 
-	cache := NewEffectiveBalanceCache()
-	_, err = cache.Get(st)
-	require.ErrorContains(t, ErrNotFound.Error(), err)
+	cc := cache.NewEffectiveBalanceCache()
+	_, err = cc.Get(st)
+	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
 
 	b := uint64(100)
-	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
-	cachedB, err := cache.Get(st)
+	require.NoError(t, cc.AddTotalEffectiveBalance(st, b))
+	cachedB, err := cc.Get(st)
 	require.NoError(t, err)
 	require.Equal(t, b, cachedB)
 
 	require.NoError(t, st.SetSlot(1000))
-	_, err = cache.Get(st)
-	require.ErrorContains(t, ErrNotFound.Error(), err)
+	_, err = cc.Get(st)
+	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
 
 	b = uint64(200)
-	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
-	cachedB, err = cache.Get(st)
+	require.NoError(t, cc.AddTotalEffectiveBalance(st, b))
+	cachedB, err = cc.Get(st)
 	require.NoError(t, err)
 	require.Equal(t, b, cachedB)
 
 	require.NoError(t, st.SetSlot(1000+params.BeaconConfig().SlotsPerHistoricalRoot))
-	_, err = cache.Get(st)
-	require.ErrorContains(t, ErrNotFound.Error(), err)
+	_, err = cc.Get(st)
+	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
 
 	b = uint64(300)
-	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
-	cachedB, err = cache.Get(st)
+	require.NoError(t, cc.AddTotalEffectiveBalance(st, b))
+	cachedB, err = cc.Get(st)
 	require.NoError(t, err)
 	require.Equal(t, b, cachedB)
 }
@@ -72,6 +73,6 @@ func TestBalanceCache_BalanceKey(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(primitives.Slot(math.MaxUint64)))
 
-	_, err = balanceCacheKey(st)
+	_, err = cache.BalanceCacheKey(st)
 	require.NoError(t, err)
 }

beacon-chain/cache/balance_cache_key.go

@@ -0,0 +1,43 @@
+package cache
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+)
+
+// Given input state `st`, balance key is constructed as:
+// (block_root in `st` at epoch_start_slot - 1) + current_epoch + validator_count
+func balanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	currentEpoch := st.Slot().DivSlot(slotsPerEpoch)
+	epochStartSlot, err := slotsPerEpoch.SafeMul(uint64(currentEpoch))
+	if err != nil {
+		// impossible condition due to early division
+		return "", fmt.Errorf("start slot calculation overflows: %w", err)
+	}
+	prevSlot := primitives.Slot(0)
+	if epochStartSlot > 1 {
+		prevSlot = epochStartSlot - 1
+	}
+	r, err := st.BlockRootAtIndex(uint64(prevSlot % params.BeaconConfig().SlotsPerHistoricalRoot))
+	if err != nil {
+		// impossible condition because index is always constrained within state
+		return "", err
+	}
+
+	// Mix in current epoch
+	b := make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, uint64(currentEpoch))
+	key := append(r, b...)
+
+	// Mix in validator count
+	b = make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, uint64(st.NumValidators()))
+	key = append(key, b...)
+
+	return string(key), nil
+}

beacon-chain/cache/checkpoint_state_test.go

@@ -1,8 +1,9 @@
-package cache
+package cache_test
 
 import (
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"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"
@@ -15,7 +16,7 @@ import (
 )
 
 func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
-	cache := NewCheckpointStateCache()
+	cache := cache.NewCheckpointStateCache()
 
 	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
 	st, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
@@ -58,16 +59,16 @@ func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 }
 
 func TestCheckpointStateCache_MaxSize(t *testing.T) {
-	c := NewCheckpointStateCache()
+	c := cache.NewCheckpointStateCache()
 	st, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
 		Slot: 0,
 	})
 	require.NoError(t, err)
 
-	for i := uint64(0); i < uint64(maxCheckpointStateSize+100); i++ {
+	for i := uint64(0); i < uint64(cache.MaxCheckpointStateSize()+100); i++ {
 		require.NoError(t, st.SetSlot(primitives.Slot(i)))
 		require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: primitives.Epoch(i), Root: make([]byte, 32)}, st))
 	}
 
-	assert.Equal(t, maxCheckpointStateSize, len(c.cache.Keys()))
+	assert.Equal(t, cache.MaxCheckpointStateSize(), len(c.Cache().Keys()))
 }

beacon-chain/cache/private_access_test.go

@@ -0,0 +1,18 @@
+package cache
+
+import (
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+)
+
+func BalanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
+	return balanceCacheKey(st)
+}
+
+func MaxCheckpointStateSize() int {
+	return maxCheckpointStateSize
+}
+
+func (c *CheckpointStateCache) Cache() *lru.Cache {
+	return c.cache
+}

beacon-chain/cache/sync_committee_head_state_test.go

@@ -1,8 +1,9 @@
-package cache
+package cache_test
 
 import (
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"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"
@@ -125,7 +126,7 @@ func TestSyncCommitteeHeadState(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := NewSyncCommitteeHeadState()
+			c := cache.NewSyncCommitteeHeadState()
 			if tt.put != nil {
 				err := c.Put(tt.put.slot, tt.put.state)
 				if (err != nil) != tt.wantPutErr {

beacon-chain/core/altair/attestation.go

@@ -48,7 +48,7 @@ func ProcessAttestationsNoVerifySignature(
 func ProcessAttestationNoVerifySignature(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	att *ethpb.Attestation,
+	att interfaces.Attestation,
 	totalBalance uint64,
 ) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "altair.ProcessAttestationNoVerifySignature")
@@ -58,24 +58,24 @@ func ProcessAttestationNoVerifySignature(
 		return nil, err
 	}
 
-	delay, err := beaconState.Slot().SafeSubSlot(att.Data.Slot)
+	delay, err := beaconState.Slot().SafeSubSlot(att.GetData().Slot)
 	if err != nil {
-		return nil, fmt.Errorf("att slot %d can't be greater than state slot %d", att.Data.Slot, beaconState.Slot())
+		return nil, fmt.Errorf("att slot %d can't be greater than state slot %d", att.GetData().Slot, beaconState.Slot())
 	}
-	participatedFlags, err := AttestationParticipationFlagIndices(beaconState, att.Data, delay)
+	participatedFlags, err := AttestationParticipationFlagIndices(beaconState, att.GetData(), delay)
 	if err != nil {
 		return nil, err
 	}
-	committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.Data.Slot, att.Data.CommitteeIndex)
+	committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
 	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
 	}
 
-	return SetParticipationAndRewardProposer(ctx, beaconState, att.Data.Target.Epoch, indices, participatedFlags, totalBalance)
+	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance)
 }
 
 // SetParticipationAndRewardProposer retrieves and sets the epoch participation bits in state. Based on the epoch participation, it rewards

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 *ethpb.Attestation,
+	att interfaces.Attestation,
 ) error {
 	ctx, span := trace.StartSpan(ctx, "core.VerifyAttestationNoVerifySignature")
 	defer span.End()
@@ -56,7 +56,7 @@ func VerifyAttestationNoVerifySignature(
 	}
 	currEpoch := time.CurrentEpoch(beaconState)
 	prevEpoch := time.PrevEpoch(beaconState)
-	data := att.Data
+	data := att.GetData()
 	if data.Target.Epoch != prevEpoch && data.Target.Epoch != currEpoch {
 		return fmt.Errorf(
 			"expected target epoch (%d) to be the previous epoch (%d) or the current epoch (%d)",
@@ -76,11 +76,11 @@ func VerifyAttestationNoVerifySignature(
 		}
 	}
 
-	if err := helpers.ValidateSlotTargetEpoch(att.Data); err != nil {
+	if err := helpers.ValidateSlotTargetEpoch(att.GetData()); err != nil {
 		return err
 	}
 
-	s := att.Data.Slot
+	s := att.GetData().Slot
 	minInclusionCheck := s+params.BeaconConfig().MinAttestationInclusionDelay <= beaconState.Slot()
 	if !minInclusionCheck {
 		return fmt.Errorf(
@@ -102,27 +102,58 @@ func VerifyAttestationNoVerifySignature(
 			)
 		}
 	}
-	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, beaconState, att.Data.Target.Epoch)
+	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, beaconState, att.GetData().Target.Epoch)
 	if err != nil {
 		return err
 	}
 	c := helpers.SlotCommitteeCount(activeValidatorCount)
-	if uint64(att.Data.CommitteeIndex) >= c {
-		return fmt.Errorf("committee index %d >= committee count %d", att.Data.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.Data.Slot, att.Data.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.GetCommitteeBitsVal().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 *ethpb.Attestation,
+	att interfaces.Attestation,
 ) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.ProcessAttestationNoVerifySignature")
 	defer span.End()
@@ -143,15 +174,15 @@ func ProcessAttestationNoVerifySignature(
 	}
 
 	currEpoch := time.CurrentEpoch(beaconState)
-	data := att.Data
-	s := att.Data.Slot
+	data := att.GetData()
+	s := att.GetData().Slot
 	proposerIndex, err := helpers.BeaconProposerIndex(ctx, beaconState)
 	if err != nil {
 		return nil, err
 	}
 	pendingAtt := &ethpb.PendingAttestation{
 		Data:            data,
-		AggregationBits: att.AggregationBits,
+		AggregationBits: att.GetAggregationBits(),
 		InclusionDelay:  beaconState.Slot() - s,
 		ProposerIndex:   proposerIndex,
 	}
@@ -171,11 +202,11 @@ 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 *ethpb.Attestation) error {
+func VerifyAttestationSignature(ctx context.Context, beaconState state.ReadOnlyBeaconState, att interfaces.Attestation) error {
 	if err := helpers.ValidateNilAttestation(att); err != nil {
 		return err
 	}
-	committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.Data.Slot, att.Data.CommitteeIndex)
+	committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
 	if err != nil {
 		return err
 	}
@@ -203,7 +234,7 @@ func VerifyAttestationSignature(ctx context.Context, beaconState state.ReadOnlyB
 //	  domain = get_domain(state, DOMAIN_BEACON_ATTESTER, indexed_attestation.data.target.epoch)
 //	  signing_root = compute_signing_root(indexed_attestation.data, domain)
 //	  return bls.FastAggregateVerify(pubkeys, signing_root, indexed_attestation.signature)
-func VerifyIndexedAttestation(ctx context.Context, beaconState state.ReadOnlyBeaconState, indexedAtt *ethpb.IndexedAttestation) error {
+func VerifyIndexedAttestation(ctx context.Context, beaconState state.ReadOnlyBeaconState, indexedAtt ethpb.IndexedAtt) error {
 	ctx, span := trace.StartSpan(ctx, "core.VerifyIndexedAttestation")
 	defer span.End()
 
@@ -212,14 +243,14 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState state.ReadOnlyBea
 	}
 	domain, err := signing.Domain(
 		beaconState.Fork(),
-		indexedAtt.Data.Target.Epoch,
+		indexedAtt.GetData().Target.Epoch,
 		params.BeaconConfig().DomainBeaconAttester,
 		beaconState.GenesisValidatorsRoot(),
 	)
 	if err != nil {
 		return err
 	}
-	indices := indexedAtt.AttestingIndices
+	indices := indexedAtt.GetAttestingIndices()
 	var pubkeys []bls.PublicKey
 	for i := 0; i < len(indices); i++ {
 		pubkeyAtIdx := beaconState.PubkeyAtIndex(primitives.ValidatorIndex(indices[i]))

beacon-chain/core/blocks/attestation_test.go

@@ -11,6 +11,7 @@ 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"
@@ -44,7 +45,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 {
@@ -66,7 +67,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 {
@@ -221,6 +222,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)
@@ -386,7 +464,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 
 	sig := keys[0].Sign([]byte{'t', 'e', 's', 't'})
 	list := bitfield.Bitlist{0b11111}
-	var atts []*ethpb.Attestation
+	var atts []interfaces.Attestation
 	for i := uint64(0); i < 1000; i++ {
 		atts = append(atts, &ethpb.Attestation{
 			Data: &ethpb.AttestationData{
@@ -402,7 +480,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	_, err := blocks.AttestationSignatureBatch(context.Background(), beaconState, atts)
 	assert.ErrorContains(t, want, err)
 
-	atts = []*ethpb.Attestation{}
+	atts = []interfaces.Attestation{}
 	list = bitfield.Bitlist{0b10000}
 	for i := uint64(0); i < 1000; i++ {
 		atts = append(atts, &ethpb.Attestation{
@@ -543,7 +621,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	set, err := blocks.AttestationSignatureBatch(ctx, st, []*ethpb.Attestation{att1, att2})
+	set, err := blocks.AttestationSignatureBatch(ctx, st, []interfaces.Attestation{att1, att2})
 	require.NoError(t, err)
 	verified, err := set.Verify()
 	require.NoError(t, err)
@@ -607,6 +685,6 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	_, err = blocks.AttestationSignatureBatch(ctx, st, []*ethpb.Attestation{att1, att2})
+	_, err = blocks.AttestationSignatureBatch(ctx, st, []interfaces.Attestation{att1, att2})
 	require.NoError(t, err)
 }

beacon-chain/core/blocks/attester_slashing.go

@@ -7,13 +7,12 @@ 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"
 )
 
@@ -40,7 +39,7 @@ import (
 func ProcessAttesterSlashings(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	slashings []*ethpb.AttesterSlashing,
+	slashings []interfaces.AttesterSlashing,
 	slashFunc slashValidatorFunc,
 ) (state.BeaconState, error) {
 	var err error
@@ -57,7 +56,7 @@ func ProcessAttesterSlashings(
 func ProcessAttesterSlashing(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	slashing *ethpb.AttesterSlashing,
+	slashing interfaces.AttesterSlashing,
 	slashFunc slashValidatorFunc,
 ) (state.BeaconState, error) {
 	if err := VerifyAttesterSlashing(ctx, beaconState, slashing); err != nil {
@@ -77,19 +76,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)
@@ -104,20 +91,20 @@ func ProcessAttesterSlashing(
 }
 
 // VerifyAttesterSlashing validates the attestation data in both attestations in the slashing object.
-func VerifyAttesterSlashing(ctx context.Context, beaconState state.ReadOnlyBeaconState, slashing *ethpb.AttesterSlashing) error {
+func VerifyAttesterSlashing(ctx context.Context, beaconState state.ReadOnlyBeaconState, slashing interfaces.AttesterSlashing) error {
 	if slashing == nil {
 		return errors.New("nil slashing")
 	}
-	if slashing.Attestation_1 == nil || slashing.Attestation_2 == nil {
+	if slashing.GetFirstAttestation() == nil || slashing.GetSecondAttestation() == nil {
 		return errors.New("nil attestation")
 	}
-	if slashing.Attestation_1.Data == nil || slashing.Attestation_2.Data == nil {
+	if slashing.GetFirstAttestation().GetData() == nil || slashing.GetSecondAttestation().GetData() == nil {
 		return errors.New("nil attestation data")
 	}
-	att1 := slashing.Attestation_1
-	att2 := slashing.Attestation_2
-	data1 := att1.Data
-	data2 := att2.Data
+	att1 := slashing.GetFirstAttestation()
+	att2 := slashing.GetSecondAttestation()
+	data1 := att1.GetData()
+	data2 := att2.GetData()
 	if !IsSlashableAttestationData(data1, data2) {
 		return errors.New("attestations are not slashable")
 	}
@@ -157,11 +144,11 @@ func IsSlashableAttestationData(data1, data2 *ethpb.AttestationData) bool {
 }
 
 // SlashableAttesterIndices returns the intersection of attester indices from both attestations in this slashing.
-func SlashableAttesterIndices(slashing *ethpb.AttesterSlashing) []uint64 {
-	if slashing == nil || slashing.Attestation_1 == nil || slashing.Attestation_2 == nil {
+func SlashableAttesterIndices(slashing interfaces.AttesterSlashing) []uint64 {
+	if slashing == nil || slashing.GetFirstAttestation() == nil || slashing.GetSecondAttestation() == nil {
 		return nil
 	}
-	indices1 := slashing.Attestation_1.AttestingIndices
-	indices2 := slashing.Attestation_2.AttestingIndices
+	indices1 := slashing.GetFirstAttestation().GetAttestingIndices()
+	indices2 := slashing.GetSecondAttestation().GetAttestingIndices()
 	return slice.IntersectionUint64(indices1, indices2)
 }

beacon-chain/core/blocks/attester_slashing_test.go

@@ -9,6 +9,7 @@ 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"
@@ -57,7 +58,11 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
 			AttesterSlashings: slashings,
 		},
 	}
-	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, b.Block.Body.AttesterSlashings, v.SlashValidator)
+	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	for i, s := range b.Block.Body.AttesterSlashings {
+		ss[i] = s
+	}
+	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	assert.ErrorContains(t, "attestations are not slashable", err)
 }
 
@@ -92,7 +97,11 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
 		},
 	}
 
-	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, b.Block.Body.AttesterSlashings, v.SlashValidator)
+	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	for i, s := range b.Block.Body.AttesterSlashings {
+		ss[i] = s
+	}
+	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	assert.ErrorContains(t, "validator indices count exceeds MAX_VALIDATORS_PER_COMMITTEE", err)
 }
 
@@ -144,7 +153,11 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 		},
 	}
 
-	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b.Block.Body.AttesterSlashings, v.SlashValidator)
+	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	for i, s := range b.Block.Body.AttesterSlashings {
+		ss[i] = s
+	}
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	require.NoError(t, err)
 	newRegistry := newState.Validators()
 
@@ -213,7 +226,11 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 		},
 	}
 
-	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b.Block.Body.AttesterSlashings, v.SlashValidator)
+	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	for i, s := range b.Block.Body.AttesterSlashings {
+		ss[i] = s
+	}
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	require.NoError(t, err)
 	newRegistry := newState.Validators()
 
@@ -282,7 +299,11 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 		},
 	}
 
-	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b.Block.Body.AttesterSlashings, v.SlashValidator)
+	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	for i, s := range b.Block.Body.AttesterSlashings {
+		ss[i] = s
+	}
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	require.NoError(t, err)
 	newRegistry := newState.Validators()
 
@@ -351,7 +372,11 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusCapella(t *testing.T) {
 		},
 	}
 
-	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b.Block.Body.AttesterSlashings, v.SlashValidator)
+	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	for i, s := range b.Block.Body.AttesterSlashings {
+		ss[i] = s
+	}
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	require.NoError(t, err)
 	newRegistry := newState.Validators()
 

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -10,6 +10,7 @@ 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"
@@ -216,7 +217,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, []*ethpb.AttesterSlashing{a}, v.SlashValidator)
+		r, err := ProcessAttesterSlashings(ctx, s, []interfaces.AttesterSlashing{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,6 +8,7 @@ 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"
@@ -91,7 +92,11 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 		},
 	}
 
-	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, b.Block.Body.AttesterSlashings, v.SlashValidator)
+	ss := make([]interfaces.AttesterSlashing, len(b.Block.Body.AttesterSlashings))
+	for i, s := range b.Block.Body.AttesterSlashings {
+		ss[i] = s
+	}
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	require.NoError(t, err)
 	newRegistry := newState.Validators()
 	if !newRegistry[expectedSlashedVal].Slashed {

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/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 []*ethpb.Attestation,
+	atts []interfaces.Attestation,
 	domain []byte,
 ) (*bls.SignatureBatch, error) {
 	if len(atts) == 0 {
@@ -191,8 +191,8 @@ func createAttestationSignatureBatch(
 	msgs := make([][32]byte, len(atts))
 	descs := make([]string, len(atts))
 	for i, a := range atts {
-		sigs[i] = a.Signature
-		c, err := helpers.BeaconCommitteeFromState(ctx, beaconState, a.Data.Slot, a.Data.CommitteeIndex)
+		sigs[i] = a.GetSignature()
+		c, err := helpers.BeaconCommitteeFromState(ctx, beaconState, a.GetData().Slot, a.GetData().CommitteeIndex)
 		if err != nil {
 			return nil, err
 		}
@@ -203,7 +203,7 @@ func createAttestationSignatureBatch(
 		if err := attestation.IsValidAttestationIndices(ctx, ia); err != nil {
 			return nil, err
 		}
-		indices := ia.AttestingIndices
+		indices := ia.GetAttestingIndices()
 		pubkeys := make([][]byte, len(indices))
 		for i := 0; i < len(indices); i++ {
 			pubkeyAtIdx := beaconState.PubkeyAtIndex(primitives.ValidatorIndex(indices[i]))
@@ -215,7 +215,7 @@ func createAttestationSignatureBatch(
 		}
 		pks[i] = aggP
 
-		root, err := signing.ComputeSigningRoot(ia.Data, domain)
+		root, err := signing.ComputeSigningRoot(ia.GetData(), domain)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get signing root of object")
 		}
@@ -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 []*ethpb.Attestation) (*bls.SignatureBatch, error) {
+func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBeaconState, atts []interfaces.Attestation) (*bls.SignatureBatch, error) {
 	if len(atts) == 0 {
 		return bls.NewSet(), nil
 	}
@@ -243,10 +243,10 @@ 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 []*ethpb.Attestation
-	var postForkAtts []*ethpb.Attestation
+	var preForkAtts []interfaces.Attestation
+	var postForkAtts []interfaces.Attestation
 	for _, a := range atts {
-		if slots.ToEpoch(a.Data.Slot) < fork.Epoch {
+		if slots.ToEpoch(a.GetData().Slot) < fork.Epoch {
 			preForkAtts = append(preForkAtts, a)
 		} else {
 			postForkAtts = append(postForkAtts, a)

beacon-chain/core/blocks/withdrawals.go

@@ -145,7 +145,7 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 //	    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, _, err := st.ExpectedWithdrawals()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals")
 	}

beacon-chain/core/blocks/withdrawals_test.go

@@ -250,12 +250,12 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 	maxEffectiveBalance := params.BeaconConfig().MaxEffectiveBalance
 
 	type args struct {
-		Name                         string
-		NextWithdrawalValidatorIndex primitives.ValidatorIndex
-		NextWithdrawalIndex          uint64
-		FullWithdrawalIndices        []primitives.ValidatorIndex
-		PartialWithdrawalIndices     []primitives.ValidatorIndex
-		Withdrawals                  []*enginev1.Withdrawal
+		Name                            string
+		NextWithdrawalValidatorIndex    primitives.ValidatorIndex
+		NextWithdrawalIndex             uint64
+		FullWithdrawalIndices           []primitives.ValidatorIndex
+		PendingPartialWithdrawalIndices []primitives.ValidatorIndex
+		Withdrawals                     []*enginev1.Withdrawal
 	}
 	type control struct {
 		NextWithdrawalValidatorIndex primitives.ValidatorIndex
@@ -283,7 +283,7 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 			Amount:         withdrawalAmount(i),
 		}
 	}
-	partialWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
+	PendingPartialWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
 		return &enginev1.Withdrawal{
 			Index:          idx,
 			ValidatorIndex: i,
@@ -321,12 +321,12 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "success one partial withdrawal",
-				NextWithdrawalIndex:          21,
-				NextWithdrawalValidatorIndex: 120,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{7},
+				Name:                            "success one partial withdrawal",
+				NextWithdrawalIndex:             21,
+				NextWithdrawalValidatorIndex:    120,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(7, 21),
+					PendingPartialWithdrawal(7, 21),
 				},
 			},
 			Control: control{
@@ -386,12 +386,12 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "success many partial withdrawals",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 4,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{7, 19, 28},
+				Name:                            "success many partial withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    4,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7, 19, 28},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(7, 22), partialWithdrawal(19, 23), partialWithdrawal(28, 24),
+					PendingPartialWithdrawal(7, 22), PendingPartialWithdrawal(19, 23), PendingPartialWithdrawal(28, 24),
 				},
 			},
 			Control: control{
@@ -406,14 +406,14 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "success many withdrawals",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 88,
-				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28},
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{2, 1, 89, 15},
+				Name:                            "success many withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    88,
+				FullWithdrawalIndices:           []primitives.ValidatorIndex{7, 19, 28},
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{2, 1, 89, 15},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(89, 22), partialWithdrawal(1, 23), partialWithdrawal(2, 24),
-					fullWithdrawal(7, 25), partialWithdrawal(15, 26), fullWithdrawal(19, 27),
+					PendingPartialWithdrawal(89, 22), PendingPartialWithdrawal(1, 23), PendingPartialWithdrawal(2, 24),
+					fullWithdrawal(7, 25), PendingPartialWithdrawal(15, 26), fullWithdrawal(19, 27),
 					fullWithdrawal(28, 28),
 				},
 			},
@@ -453,17 +453,17 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "success more than max partially withdrawals",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 0,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
+				Name:                            "success more than max partially withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    0,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(1, 22), partialWithdrawal(2, 23), partialWithdrawal(3, 24),
-					partialWithdrawal(4, 25), partialWithdrawal(5, 26), partialWithdrawal(6, 27),
-					partialWithdrawal(7, 28), partialWithdrawal(8, 29), partialWithdrawal(9, 30),
-					partialWithdrawal(21, 31), partialWithdrawal(22, 32), partialWithdrawal(23, 33),
-					partialWithdrawal(24, 34), partialWithdrawal(25, 35), partialWithdrawal(26, 36),
-					partialWithdrawal(27, 37),
+					PendingPartialWithdrawal(1, 22), PendingPartialWithdrawal(2, 23), PendingPartialWithdrawal(3, 24),
+					PendingPartialWithdrawal(4, 25), PendingPartialWithdrawal(5, 26), PendingPartialWithdrawal(6, 27),
+					PendingPartialWithdrawal(7, 28), PendingPartialWithdrawal(8, 29), PendingPartialWithdrawal(9, 30),
+					PendingPartialWithdrawal(21, 31), PendingPartialWithdrawal(22, 32), PendingPartialWithdrawal(23, 33),
+					PendingPartialWithdrawal(24, 34), PendingPartialWithdrawal(25, 35), PendingPartialWithdrawal(26, 36),
+					PendingPartialWithdrawal(27, 37),
 				},
 			},
 			Control: control{
@@ -491,12 +491,12 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "failure wrong number of partial withdrawal",
-				NextWithdrawalIndex:          21,
-				NextWithdrawalValidatorIndex: 37,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{7},
+				Name:                            "failure wrong number of partial withdrawal",
+				NextWithdrawalIndex:             21,
+				NextWithdrawalValidatorIndex:    37,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(7, 21), partialWithdrawal(9, 22),
+					PendingPartialWithdrawal(7, 21), PendingPartialWithdrawal(9, 22),
 				},
 			},
 			Control: control{
@@ -540,7 +540,7 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 				NextWithdrawalValidatorIndex: 4,
 				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28, 1},
 				Withdrawals: []*enginev1.Withdrawal{
-					fullWithdrawal(7, 22), fullWithdrawal(19, 23), partialWithdrawal(28, 24),
+					fullWithdrawal(7, 22), fullWithdrawal(19, 23), PendingPartialWithdrawal(28, 24),
 					fullWithdrawal(1, 25),
 				},
 			},
@@ -564,10 +564,10 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "failure validator not partially withdrawable",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 4,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{notPartiallyWithdrawable},
+				Name:                            "failure validator not partially withdrawable",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    4,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{notPartiallyWithdrawable},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(notPartiallyWithdrawable, 22),
 				},
@@ -611,7 +611,7 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 			st.Balances[idx] = withdrawalAmount(idx)
 			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 		}
-		for _, idx := range arguments.PartialWithdrawalIndices {
+		for _, idx := range arguments.PendingPartialWithdrawalIndices {
 			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 			st.Balances[idx] = withdrawalAmount(idx)
 		}
@@ -629,8 +629,8 @@ func TestProcessBlindWithdrawals(t *testing.T) {
 			if test.Args.FullWithdrawalIndices == nil {
 				test.Args.FullWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
 			}
-			if test.Args.PartialWithdrawalIndices == nil {
-				test.Args.PartialWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
+			if test.Args.PendingPartialWithdrawalIndices == nil {
+				test.Args.PendingPartialWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
 			}
 			slot, err := slots.EpochStart(currentEpoch)
 			require.NoError(t, err)
@@ -673,12 +673,12 @@ func TestProcessWithdrawals(t *testing.T) {
 	maxEffectiveBalance := params.BeaconConfig().MaxEffectiveBalance
 
 	type args struct {
-		Name                         string
-		NextWithdrawalValidatorIndex primitives.ValidatorIndex
-		NextWithdrawalIndex          uint64
-		FullWithdrawalIndices        []primitives.ValidatorIndex
-		PartialWithdrawalIndices     []primitives.ValidatorIndex
-		Withdrawals                  []*enginev1.Withdrawal
+		Name                            string
+		NextWithdrawalValidatorIndex    primitives.ValidatorIndex
+		NextWithdrawalIndex             uint64
+		FullWithdrawalIndices           []primitives.ValidatorIndex
+		PendingPartialWithdrawalIndices []primitives.ValidatorIndex
+		Withdrawals                     []*enginev1.Withdrawal
 	}
 	type control struct {
 		NextWithdrawalValidatorIndex primitives.ValidatorIndex
@@ -706,7 +706,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			Amount:         withdrawalAmount(i),
 		}
 	}
-	partialWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
+	PendingPartialWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
 		return &enginev1.Withdrawal{
 			Index:          idx,
 			ValidatorIndex: i,
@@ -744,12 +744,12 @@ func TestProcessWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "success one partial withdrawal",
-				NextWithdrawalIndex:          21,
-				NextWithdrawalValidatorIndex: 120,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{7},
+				Name:                            "success one partial withdrawal",
+				NextWithdrawalIndex:             21,
+				NextWithdrawalValidatorIndex:    120,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(7, 21),
+					PendingPartialWithdrawal(7, 21),
 				},
 			},
 			Control: control{
@@ -809,12 +809,12 @@ func TestProcessWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "success many partial withdrawals",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 4,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{7, 19, 28},
+				Name:                            "success many partial withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    4,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7, 19, 28},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(7, 22), partialWithdrawal(19, 23), partialWithdrawal(28, 24),
+					PendingPartialWithdrawal(7, 22), PendingPartialWithdrawal(19, 23), PendingPartialWithdrawal(28, 24),
 				},
 			},
 			Control: control{
@@ -829,14 +829,14 @@ func TestProcessWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "success many withdrawals",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 88,
-				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28},
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{2, 1, 89, 15},
+				Name:                            "success many withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    88,
+				FullWithdrawalIndices:           []primitives.ValidatorIndex{7, 19, 28},
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{2, 1, 89, 15},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(89, 22), partialWithdrawal(1, 23), partialWithdrawal(2, 24),
-					fullWithdrawal(7, 25), partialWithdrawal(15, 26), fullWithdrawal(19, 27),
+					PendingPartialWithdrawal(89, 22), PendingPartialWithdrawal(1, 23), PendingPartialWithdrawal(2, 24),
+					fullWithdrawal(7, 25), PendingPartialWithdrawal(15, 26), fullWithdrawal(19, 27),
 					fullWithdrawal(28, 28),
 				},
 			},
@@ -876,17 +876,17 @@ func TestProcessWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "success more than max partially withdrawals",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 0,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
+				Name:                            "success more than max partially withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    0,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(1, 22), partialWithdrawal(2, 23), partialWithdrawal(3, 24),
-					partialWithdrawal(4, 25), partialWithdrawal(5, 26), partialWithdrawal(6, 27),
-					partialWithdrawal(7, 28), partialWithdrawal(8, 29), partialWithdrawal(9, 30),
-					partialWithdrawal(21, 31), partialWithdrawal(22, 32), partialWithdrawal(23, 33),
-					partialWithdrawal(24, 34), partialWithdrawal(25, 35), partialWithdrawal(26, 36),
-					partialWithdrawal(27, 37),
+					PendingPartialWithdrawal(1, 22), PendingPartialWithdrawal(2, 23), PendingPartialWithdrawal(3, 24),
+					PendingPartialWithdrawal(4, 25), PendingPartialWithdrawal(5, 26), PendingPartialWithdrawal(6, 27),
+					PendingPartialWithdrawal(7, 28), PendingPartialWithdrawal(8, 29), PendingPartialWithdrawal(9, 30),
+					PendingPartialWithdrawal(21, 31), PendingPartialWithdrawal(22, 32), PendingPartialWithdrawal(23, 33),
+					PendingPartialWithdrawal(24, 34), PendingPartialWithdrawal(25, 35), PendingPartialWithdrawal(26, 36),
+					PendingPartialWithdrawal(27, 37),
 				},
 			},
 			Control: control{
@@ -914,12 +914,12 @@ func TestProcessWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "failure wrong number of partial withdrawal",
-				NextWithdrawalIndex:          21,
-				NextWithdrawalValidatorIndex: 37,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{7},
+				Name:                            "failure wrong number of partial withdrawal",
+				NextWithdrawalIndex:             21,
+				NextWithdrawalValidatorIndex:    37,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7},
 				Withdrawals: []*enginev1.Withdrawal{
-					partialWithdrawal(7, 21), partialWithdrawal(9, 22),
+					PendingPartialWithdrawal(7, 21), PendingPartialWithdrawal(9, 22),
 				},
 			},
 			Control: control{
@@ -963,7 +963,7 @@ func TestProcessWithdrawals(t *testing.T) {
 				NextWithdrawalValidatorIndex: 4,
 				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28, 1},
 				Withdrawals: []*enginev1.Withdrawal{
-					fullWithdrawal(7, 22), fullWithdrawal(19, 23), partialWithdrawal(28, 24),
+					fullWithdrawal(7, 22), fullWithdrawal(19, 23), PendingPartialWithdrawal(28, 24),
 					fullWithdrawal(1, 25),
 				},
 			},
@@ -987,10 +987,10 @@ func TestProcessWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "failure validator not partially withdrawable",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 4,
-				PartialWithdrawalIndices:     []primitives.ValidatorIndex{notPartiallyWithdrawable},
+				Name:                            "failure validator not partially withdrawable",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    4,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{notPartiallyWithdrawable},
 				Withdrawals: []*enginev1.Withdrawal{
 					fullWithdrawal(notPartiallyWithdrawable, 22),
 				},
@@ -1034,7 +1034,7 @@ func TestProcessWithdrawals(t *testing.T) {
 			st.Balances[idx] = withdrawalAmount(idx)
 			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 		}
-		for _, idx := range arguments.PartialWithdrawalIndices {
+		for _, idx := range arguments.PendingPartialWithdrawalIndices {
 			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 			st.Balances[idx] = withdrawalAmount(idx)
 		}
@@ -1052,8 +1052,8 @@ func TestProcessWithdrawals(t *testing.T) {
 			if test.Args.FullWithdrawalIndices == nil {
 				test.Args.FullWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
 			}
-			if test.Args.PartialWithdrawalIndices == nil {
-				test.Args.PartialWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
+			if test.Args.PendingPartialWithdrawalIndices == nil {
+				test.Args.PendingPartialWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
 			}
 			slot, err := slots.EpochStart(currentEpoch)
 			require.NoError(t, err)

beacon-chain/core/electra/BUILD.bazel

@@ -0,0 +1,65 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "balance_deposits.go",
+        "churn.go",
+        "consolidations.go",
+        "transition.go",
+        "upgrade.go",
+        "validator.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/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/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 = [
+        "balance_deposits_test.go",
+        "churn_test.go",
+        "consolidations_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/balance_deposits.go

@@ -0,0 +1,77 @@
+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"
+	"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)
+	}
+}

beacon-chain/core/electra/balance_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/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/transition.go

@@ -0,0 +1,23 @@
+package electra
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
+	e "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
+)
+
+// 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
+)

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/epoch/epoch_processing.go

@@ -99,7 +99,7 @@ func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state
 	activationEligibilityEpoch := time.CurrentEpoch(state) + 1
 	for idx, validator := range vals {
 		// Process the validators for activation eligibility.
-		if helpers.IsEligibleForActivationQueue(validator) {
+		if helpers.IsEligibleForActivationQueue(validator, currentEpoch) {
 			validator.ActivationEligibilityEpoch = activationEligibilityEpoch
 			if err := state.UpdateValidatorAtIndex(primitives.ValidatorIndex(idx), validator); err != nil {
 				return nil, err
@@ -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

@@ -54,11 +54,11 @@ func ProcessAttestations(
 			return nil, nil, errors.Wrap(err, "could not check validator attested previous epoch")
 		}
 
-		committee, err := helpers.BeaconCommitteeFromState(ctx, state, a.Data.Slot, a.Data.CommitteeIndex)
+		committee, err := helpers.BeaconCommitteeFromState(ctx, state, a.GetData().Slot, a.GetData().CommitteeIndex)
 		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,6 +11,7 @@ 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,6 +3,7 @@ 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"
 )
 
@@ -37,7 +38,7 @@ const (
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
 type UnAggregatedAttReceivedData struct {
 	// Attestation is the unaggregated attestation object.
-	Attestation *ethpb.Attestation
+	Attestation interfaces.Attestation
 }
 
 // AggregatedAttReceivedData is the data sent with AggregatedAttReceived events.
@@ -75,5 +76,5 @@ type ProposerSlashingReceivedData struct {
 
 // AttesterSlashingReceivedData is the data sent with AttesterSlashingReceived events.
 type AttesterSlashingReceivedData struct {
-	AttesterSlashing *ethpb.AttesterSlashing
+	AttesterSlashing interfaces.AttesterSlashing
 }

beacon-chain/core/helpers/BUILD.bazel

@@ -12,6 +12,7 @@ go_library(
         "rewards_penalties.go",
         "shuffle.go",
         "sync_committee.go",
+        "validator_churn.go",
         "validators.go",
         "weak_subjectivity.go",
     ],
@@ -24,6 +25,7 @@ go_library(
         "//beacon-chain/state: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",
         "//container/trie:go_default_library",
@@ -56,6 +58,7 @@ go_test(
         "rewards_penalties_test.go",
         "shuffle_test.go",
         "sync_committee_test.go",
+        "validator_churn_test.go",
         "validators_test.go",
         "weak_subjectivity_test.go",
     ],
@@ -70,6 +73,7 @@ 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,6 +7,7 @@ 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"
@@ -21,20 +22,20 @@ 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 *ethpb.Attestation) error {
+func ValidateNilAttestation(attestation interfaces.Attestation) error {
 	if attestation == nil {
 		return errors.New("attestation can't be nil")
 	}
-	if attestation.Data == nil {
+	if attestation.GetData() == nil {
 		return errors.New("attestation's data can't be nil")
 	}
-	if attestation.Data.Source == nil {
+	if attestation.GetData().Source == nil {
 		return errors.New("attestation's source can't be nil")
 	}
-	if attestation.Data.Target == nil {
+	if attestation.GetData().Target == nil {
 		return errors.New("attestation's target can't be nil")
 	}
-	if attestation.AggregationBits == nil {
+	if attestation.GetAggregationBits() == nil {
 		return errors.New("attestation's bitfield can't be nil")
 	}
 	return nil
@@ -71,8 +72,8 @@ func IsAggregator(committeeCount uint64, slotSig []byte) (bool, error) {
 
 // IsAggregated returns true if the attestation is an aggregated attestation,
 // false otherwise.
-func IsAggregated(attestation *ethpb.Attestation) bool {
-	return attestation.AggregationBits.Count() > 1
+func IsAggregated(attestation interfaces.Attestation) bool {
+	return attestation.GetAggregationBits().Count() > 1
 }
 
 // ComputeSubnetForAttestation returns the subnet for which the provided attestation will be broadcasted to.
@@ -90,8 +91,8 @@ func IsAggregated(attestation *ethpb.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 *ethpb.Attestation) uint64 {
-	return ComputeSubnetFromCommitteeAndSlot(activeValCount, att.Data.CommitteeIndex, att.Data.Slot)
+func ComputeSubnetForAttestation(activeValCount uint64, att interfaces.Attestation) uint64 {
+	return ComputeSubnetFromCommitteeAndSlot(activeValCount, att.GetData().CommitteeIndex, att.GetData().Slot)
 }
 
 // ComputeSubnetFromCommitteeAndSlot is a flattened version of ComputeSubnetForAttestation where we only pass in

beacon-chain/core/helpers/attestation_test.go

@@ -9,6 +9,7 @@ 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"
@@ -238,7 +239,7 @@ func TestVerifyCheckpointEpoch_Ok(t *testing.T) {
 func TestValidateNilAttestation(t *testing.T) {
 	tests := []struct {
 		name        string
-		attestation *ethpb.Attestation
+		attestation interfaces.Attestation
 		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,8 +257,8 @@ 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 *ethpb.Attestation) error {
-	committee, err := BeaconCommitteeFromState(ctx, state, att.Data.Slot, att.Data.CommitteeIndex)
+func VerifyAttestationBitfieldLengths(ctx context.Context, state state.ReadOnlyBeaconState, att interfaces.Attestation) error {
+	committee, err := BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
 	if err != nil {
 		return errors.Wrap(err, "could not retrieve beacon committees")
 	}
@@ -267,7 +267,7 @@ func VerifyAttestationBitfieldLengths(ctx context.Context, state state.ReadOnlyB
 		return errors.New("no committee exist for this attestation")
 	}
 
-	if err := VerifyBitfieldLength(att.AggregationBits, uint64(len(committee))); err != nil {
+	if err := VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee))); err != nil {
 		return errors.Wrap(err, "failed to verify aggregation bitfield")
 	}
 	return nil
@@ -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

@@ -0,0 +1,53 @@
+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.
+// New in Electra EIP-7251: https://eips.ethereum.org/EIPS/eip-7251
+//
+// Spec definition:
+//
+//	def get_balance_churn_limit(state: BeaconState) -> Gwei:
+//	    """
+//	    Return the churn limit for the current epoch.
+//	    """
+//	    churn = max(
+//	        MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA,
+//	        get_total_active_balance(state) // CHURN_LIMIT_QUOTIENT
+//	    )
+//	    return churn - churn % EFFECTIVE_BALANCE_INCREMENT
+func BalanceChurnLimit(activeBalance primitives.Gwei) primitives.Gwei {
+	churn := max(
+		params.BeaconConfig().MinPerEpochChurnLimitElectra,
+		(uint64(activeBalance) / params.BeaconConfig().ChurnLimitQuotient),
+	)
+	return primitives.Gwei(churn - churn%params.BeaconConfig().EffectiveBalanceIncrement)
+}
+
+// ActivationExitChurnLimit for the current active balance, in gwei.
+// New in Electra EIP-7251: https://eips.ethereum.org/EIPS/eip-7251
+//
+// Spec definition:
+//
+//	def get_activation_exit_churn_limit(state: BeaconState) -> Gwei:
+//	    """
+//	    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(activeBalance primitives.Gwei) primitives.Gwei {
+	return min(primitives.Gwei(params.BeaconConfig().MaxPerEpochActivationExitChurnLimit), BalanceChurnLimit(activeBalance))
+}
+
+// ConsolidationChurnLimit for the current active balance, in gwei.
+// New in EIP-7251: https://eips.ethereum.org/EIPS/eip-7251
+//
+// Spec definition:
+//
+//	def get_consolidation_churn_limit(state: BeaconState) -> Gwei:
+//	    return get_balance_churn_limit(state) - get_activation_exit_churn_limit(state)
+func ConsolidationChurnLimit(activeBalance primitives.Gwei) primitives.Gwei {
+	return BalanceChurnLimit(activeBalance) - ActivationExitChurnLimit(activeBalance)
+}

beacon-chain/core/helpers/validator_churn_test.go

@@ -0,0 +1,72 @@
+package helpers_test
+
+import (
+	"testing"
+
+	"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 primitives.Gwei
+		expected      primitives.Gwei
+	}{
+		{
+			name:          "less than MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA",
+			activeBalance: 111,
+			expected:      primitives.Gwei(params.BeaconConfig().MinPerEpochChurnLimitElectra),
+		},
+		{
+			name:          "modulo EFFECTIVE_BALANCE_INCREMENT",
+			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: primitives.Gwei(2000 * params.BeaconConfig().EffectiveBalanceIncrement * params.BeaconConfig().ChurnLimitQuotient),
+			expected:      primitives.Gwei(2000 * params.BeaconConfig().EffectiveBalanceIncrement),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, helpers.BalanceChurnLimit(tt.activeBalance))
+		})
+	}
+}
+
+func TestActivationExitChurnLimit(t *testing.T) {
+	tests := []struct {
+		name          string
+		activeBalance primitives.Gwei
+		expected      primitives.Gwei
+	}{
+		{
+			name:          "less than MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT",
+			activeBalance: 1,
+			expected:      primitives.Gwei(params.BeaconConfig().MinPerEpochChurnLimitElectra),
+		},
+		{
+			name:          "more than MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT",
+			activeBalance: primitives.Gwei(2000 * params.BeaconConfig().EffectiveBalanceIncrement * params.BeaconConfig().ChurnLimitQuotient),
+			expected:      primitives.Gwei(params.BeaconConfig().MaxPerEpochActivationExitChurnLimit),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, helpers.ActivationExitChurnLimit(tt.activeBalance))
+		})
+	}
+}
+
+// FuzzConsolidationChurnLimit exercises BalanceChurnLimit and ActivationExitChurnLimit
+func FuzzConsolidationChurnLimit(f *testing.F) {
+	f.Fuzz(func(t *testing.T, activeBalance uint64) {
+		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"
@@ -393,6 +394,24 @@ func ComputeProposerIndex(bState state.ReadOnlyValidators, activeIndices []primi
 // IsEligibleForActivationQueue checks if the validator is eligible to
 // be placed into the activation queue.
 //
+// Spec definition:
+//
+//	def is_eligible_for_activation_queue(validator: Validator) -> bool:
+//	    """
+//	    Check if ``validator`` is eligible to be placed into the activation queue.
+//	    """
+//	    return (
+//	        validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH
+//	        and validator.effective_balance >= MIN_ACTIVATION_BALANCE  # [Modified in Electra:EIP7251]
+//	    )
+func IsEligibleForActivationQueue(validator *ethpb.Validator, currentEpoch primitives.Epoch) bool {
+	if currentEpoch >= params.BeaconConfig().ElectraForkEpoch {
+		return isEligibleForActivationQueueElectra(validator.ActivationEligibilityEpoch, validator.EffectiveBalance)
+	}
+	return isEligibleForActivationQueue(validator.ActivationEligibilityEpoch, validator.EffectiveBalance)
+}
+
+// isEligibleForActivationQueue carries out the logic for IsEligibleForActivationQueue
 // Spec pseudocode definition:
 //
 //	def is_eligible_for_activation_queue(validator: Validator) -> bool:
@@ -403,22 +422,29 @@ func ComputeProposerIndex(bState state.ReadOnlyValidators, activeIndices []primi
 //	      validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH
 //	      and validator.effective_balance == MAX_EFFECTIVE_BALANCE
 //	  )
-func IsEligibleForActivationQueue(validator *ethpb.Validator) bool {
-	return isEligibileForActivationQueue(validator.ActivationEligibilityEpoch, validator.EffectiveBalance)
-}
-
-// IsEligibleForActivationQueueUsingTrie checks if the read-only validator is eligible to
-// be placed into the activation queue.
-func IsEligibleForActivationQueueUsingTrie(validator state.ReadOnlyValidator) bool {
-	return isEligibileForActivationQueue(validator.ActivationEligibilityEpoch(), validator.EffectiveBalance())
-}
-
-// isEligibleForActivationQueue carries out the logic for IsEligibleForActivationQueue*
-func isEligibileForActivationQueue(activationEligibilityEpoch primitives.Epoch, effectiveBalance uint64) bool {
+func isEligibleForActivationQueue(activationEligibilityEpoch primitives.Epoch, effectiveBalance uint64) bool {
 	return activationEligibilityEpoch == params.BeaconConfig().FarFutureEpoch &&
 		effectiveBalance == params.BeaconConfig().MaxEffectiveBalance
 }
 
+// IsEligibleForActivationQueue checks if the validator is eligible to
+// be placed into the activation queue.
+//
+// Spec definition:
+//
+//	def is_eligible_for_activation_queue(validator: Validator) -> bool:
+//	    """
+//	    Check if ``validator`` is eligible to be placed into the activation queue.
+//	    """
+//	    return (
+//	        validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH
+//	        and validator.effective_balance >= MIN_ACTIVATION_BALANCE  # [Modified in Electra:EIP7251]
+//	    )
+func isEligibleForActivationQueueElectra(activationEligibilityEpoch primitives.Epoch, effectiveBalance uint64) bool {
+	return activationEligibilityEpoch == params.BeaconConfig().FarFutureEpoch &&
+		effectiveBalance >= params.BeaconConfig().MinActivationBalance
+}
+
 // IsEligibleForActivation checks if the validator is eligible for activation.
 //
 // Spec pseudocode definition:
@@ -471,3 +497,245 @@ func LastActivatedValidatorIndex(ctx context.Context, st state.ReadOnlyBeaconSta
 	}
 	return lastActivatedvalidatorIndex, nil
 }
+
+// hasETH1WithdrawalCredential returns whether the validator has an ETH1
+// Withdrawal prefix. It assumes that the caller has a lock on the state
+func HasETH1WithdrawalCredential(val *ethpb.Validator) bool {
+	if val == nil {
+		return false
+	}
+	return isETH1WithdrawalCredential(val.WithdrawalCredentials)
+}
+
+func isETH1WithdrawalCredential(creds []byte) bool {
+	return bytes.HasPrefix(creds, []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte})
+}
+
+// HasCompoundingWithdrawalCredential checks if the validator has a compounding withdrawal credential.
+// New in Electra EIP-7251: https://eips.ethereum.org/EIPS/eip-7251
+//
+// Spec definition:
+//
+//	def has_compounding_withdrawal_credential(validator: Validator) -> bool:
+//	    """
+//	    Check if ``validator`` has an 0x02 prefixed "compounding" withdrawal credential.
+//	    """
+//	    return is_compounding_withdrawal_credential(validator.withdrawal_credentials)
+func HasCompoundingWithdrawalCredential(v interfaces.WithWithdrawalCredentials) bool {
+	if v == nil {
+		return false
+	}
+	return isCompoundingWithdrawalCredential(v.GetWithdrawalCredentials())
+}
+
+// isCompoundingWithdrawalCredential checks if the credentials are a compounding withdrawal credential.
+//
+// Spec definition:
+//
+//	def is_compounding_withdrawal_credential(withdrawal_credentials: Bytes32) -> bool:
+//	    return withdrawal_credentials[:1] == COMPOUNDING_WITHDRAWAL_PREFIX
+func isCompoundingWithdrawalCredential(creds []byte) bool {
+	return bytes.HasPrefix(creds, []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte})
+}
+
+// HasExecutionWithdrawalCredentials checks if the validator has an execution withdrawal credential or compounding credential.
+// New in Electra EIP-7251: https://eips.ethereum.org/EIPS/eip-7251
+//
+// Spec definition:
+//
+//	def has_execution_withdrawal_credential(validator: Validator) -> bool:
+//	    """
+//	    Check if ``validator`` has a 0x01 or 0x02 prefixed withdrawal credential.
+//	    """
+//	    return has_compounding_withdrawal_credential(validator) or has_eth1_withdrawal_credential(validator)
+func HasExecutionWithdrawalCredentials(v *ethpb.Validator) bool {
+	if v == nil {
+		return false
+	}
+	return HasCompoundingWithdrawalCredential(v) || HasETH1WithdrawalCredential(v)
+}
+
+// IsSameWithdrawalCredentials returns true if both validators have the same withdrawal credentials.
+//
+//	return a.withdrawal_credentials[12:] == b.withdrawal_credentials[12:]
+func IsSameWithdrawalCredentials(a, b *ethpb.Validator) bool {
+	if a == nil || b == nil {
+		return false
+	}
+	if len(a.WithdrawalCredentials) <= 12 || len(b.WithdrawalCredentials) <= 12 {
+		return false
+	}
+	return bytes.Equal(a.WithdrawalCredentials[12:], b.WithdrawalCredentials[12:])
+}
+
+// IsFullyWithdrawableValidator returns whether the validator is able to perform a full
+// withdrawal. This function assumes that the caller holds a lock on the state.
+//
+// Spec definition:
+//
+//	def is_fully_withdrawable_validator(validator: Validator, balance: Gwei, epoch: Epoch) -> bool:
+//	    """
+//	    Check if ``validator`` is fully withdrawable.
+//	    """
+//	    return (
+//	        has_execution_withdrawal_credential(validator)  # [Modified in Electra:EIP7251]
+//	        and validator.withdrawable_epoch <= epoch
+//	        and balance > 0
+//	    )
+func IsFullyWithdrawableValidator(val *ethpb.Validator, balance uint64, epoch primitives.Epoch) bool {
+	if val == nil || balance <= 0 {
+		return false
+	}
+
+	// Electra / EIP-7251 logic
+	if epoch >= params.BeaconConfig().ElectraForkEpoch {
+		return HasExecutionWithdrawalCredentials(val) && val.WithdrawableEpoch <= epoch
+	}
+
+	return HasETH1WithdrawalCredential(val) && val.WithdrawableEpoch <= epoch
+}
+
+// IsPartiallyWithdrawableValidator returns whether the validator is able to perform a
+// partial withdrawal. This function assumes that the caller has a lock on the state.
+// This method conditionally calls the fork appropriate implementation based on the epoch argument.
+func IsPartiallyWithdrawableValidator(val *ethpb.Validator, balance uint64, epoch primitives.Epoch) bool {
+	if val == nil {
+		return false
+	}
+
+	if epoch < params.BeaconConfig().ElectraForkEpoch {
+		return isPartiallyWithdrawableValidatorCapella(val, balance, epoch)
+	}
+
+	return isPartiallyWithdrawableValidatorElectra(val, balance, epoch)
+}
+
+// isPartiallyWithdrawableValidatorElectra implements is_partially_withdrawable_validator in the
+// electra fork.
+//
+// Spec definition:
+//
+// def is_partially_withdrawable_validator(validator: Validator, balance: Gwei) -> bool:
+//
+//	"""
+//	Check if ``validator`` is partially withdrawable.
+//	"""
+//	max_effective_balance = get_validator_max_effective_balance(validator)
+//	has_max_effective_balance = validator.effective_balance == max_effective_balance  # [Modified in Electra:EIP7251]
+//	has_excess_balance = balance > max_effective_balance  # [Modified in Electra:EIP7251]
+//	return (
+//	    has_execution_withdrawal_credential(validator)  # [Modified in Electra:EIP7251]
+//	    and has_max_effective_balance
+//	    and has_excess_balance
+//	)
+func isPartiallyWithdrawableValidatorElectra(val *ethpb.Validator, balance uint64, epoch primitives.Epoch) bool {
+	maxEB := ValidatorMaxEffectiveBalance(val)
+	hasMaxBalance := val.EffectiveBalance == maxEB
+	hasExcessBalance := balance > maxEB
+
+	return HasExecutionWithdrawalCredentials(val) &&
+		hasMaxBalance &&
+		hasExcessBalance
+}
+
+// isPartiallyWithdrawableValidatorCapella implements is_partially_withdrawable_validator in the
+// capella fork.
+//
+// Spec definition:
+//
+//	def is_partially_withdrawable_validator(validator: Validator, balance: Gwei) -> bool:
+//	    """
+//	    Check if ``validator`` is partially withdrawable.
+//	    """
+//	    has_max_effective_balance = validator.effective_balance == MAX_EFFECTIVE_BALANCE
+//	    has_excess_balance = balance > MAX_EFFECTIVE_BALANCE
+//	    return has_eth1_withdrawal_credential(validator) and has_max_effective_balance and has_excess_balance
+func isPartiallyWithdrawableValidatorCapella(val *ethpb.Validator, balance uint64, epoch primitives.Epoch) bool {
+	hasMaxBalance := val.EffectiveBalance == params.BeaconConfig().MaxEffectiveBalance
+	hasExcessBalance := balance > params.BeaconConfig().MaxEffectiveBalance
+	return HasETH1WithdrawalCredential(val) && hasExcessBalance && hasMaxBalance
+}
+
+// ValidatorMaxEffectiveBalance returns the maximum effective balance for a validator.
+//
+// Spec definition:
+//
+//	def get_validator_max_effective_balance(validator: Validator) -> Gwei:
+//	    """
+//	    Get max effective balance for ``validator``.
+//	    """
+//	    if has_compounding_withdrawal_credential(validator):
+//	        return MAX_EFFECTIVE_BALANCE_ELECTRA
+//	    else:
+//	        return MIN_ACTIVATION_BALANCE
+func ValidatorMaxEffectiveBalance(val *ethpb.Validator) uint64 {
+	if HasCompoundingWithdrawalCredential(val) {
+		return params.BeaconConfig().MaxEffectiveBalanceElectra
+	}
+	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) {
@@ -703,25 +704,47 @@ func TestComputeProposerIndex(t *testing.T) {
 
 func TestIsEligibleForActivationQueue(t *testing.T) {
 	tests := []struct {
-		name      string
-		validator *ethpb.Validator
-		want      bool
+		name         string
+		validator    *ethpb.Validator
+		currentEpoch primitives.Epoch
+		want         bool
 	}{
-		{"Eligible",
-			&ethpb.Validator{ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
-			true},
-		{"Incorrect activation eligibility epoch",
-			&ethpb.Validator{ActivationEligibilityEpoch: 1, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
-			false},
-		{"Not enough balance",
-			&ethpb.Validator{ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: 1},
-			false},
+		{
+			name:         "Eligible",
+			validator:    &ethpb.Validator{ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+			currentEpoch: primitives.Epoch(params.BeaconConfig().ElectraForkEpoch - 1),
+			want:         true,
+		},
+		{
+			name:         "Incorrect activation eligibility epoch",
+			validator:    &ethpb.Validator{ActivationEligibilityEpoch: 1, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+			currentEpoch: primitives.Epoch(params.BeaconConfig().ElectraForkEpoch - 1),
+			want:         false,
+		},
+		{
+			name:         "Not enough balance",
+			validator:    &ethpb.Validator{ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: 1},
+			currentEpoch: primitives.Epoch(params.BeaconConfig().ElectraForkEpoch - 1),
+			want:         false,
+		},
+		{
+			name:         "More than max effective balance before electra",
+			validator:    &ethpb.Validator{ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance + 1},
+			currentEpoch: primitives.Epoch(params.BeaconConfig().ElectraForkEpoch - 1),
+			want:         false,
+		},
+		{
+			name:         "More than min activation balance after electra",
+			validator:    &ethpb.Validator{ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MinActivationBalance + 1},
+			currentEpoch: primitives.Epoch(params.BeaconConfig().ElectraForkEpoch),
+			want:         true,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			helpers.ClearCache()
 
-			assert.Equal(t, tt.want, helpers.IsEligibleForActivationQueue(tt.validator), "IsEligibleForActivationQueue()")
+			assert.Equal(t, tt.want, helpers.IsEligibleForActivationQueue(tt.validator, tt.currentEpoch), "IsEligibleForActivationQueue()")
 		})
 	}
 }
@@ -828,3 +851,309 @@ func TestProposerIndexFromCheckpoint(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, ids[5], id)
 }
+
+func TestHasETH1WithdrawalCredentials(t *testing.T) {
+	creds := []byte{0xFA, 0xCC}
+	v := &ethpb.Validator{WithdrawalCredentials: creds}
+	require.Equal(t, false, helpers.HasETH1WithdrawalCredential(v))
+	creds = []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, 0xCC}
+	v = &ethpb.Validator{WithdrawalCredentials: creds}
+	require.Equal(t, true, helpers.HasETH1WithdrawalCredential(v))
+	// No Withdrawal cred
+	v = &ethpb.Validator{}
+	require.Equal(t, false, helpers.HasETH1WithdrawalCredential(v))
+}
+
+func TestHasCompoundingWithdrawalCredential(t *testing.T) {
+	tests := []struct {
+		name      string
+		validator *ethpb.Validator
+		want      bool
+	}{
+		{"Has compounding withdrawal credential",
+			&ethpb.Validator{WithdrawalCredentials: bytesutil.PadTo([]byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte}, 32)},
+			true},
+		{"Does not have compounding withdrawal credential",
+			&ethpb.Validator{WithdrawalCredentials: bytesutil.PadTo([]byte{0x00}, 32)},
+			false},
+		{"Handles nil case", nil, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, helpers.HasCompoundingWithdrawalCredential(tt.validator))
+		})
+	}
+}
+
+func TestHasExecutionWithdrawalCredentials(t *testing.T) {
+	tests := []struct {
+		name      string
+		validator *ethpb.Validator
+		want      bool
+	}{
+		{"Has compounding withdrawal credential",
+			&ethpb.Validator{WithdrawalCredentials: bytesutil.PadTo([]byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte}, 32)},
+			true},
+		{"Has eth1 withdrawal credential",
+			&ethpb.Validator{WithdrawalCredentials: bytesutil.PadTo([]byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte}, 32)},
+			true},
+		{"Does not have compounding withdrawal credential or eth1 withdrawal credential",
+			&ethpb.Validator{WithdrawalCredentials: bytesutil.PadTo([]byte{0x00}, 32)},
+			false},
+		{"Handles nil case", nil, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, helpers.HasExecutionWithdrawalCredentials(tt.validator))
+		})
+	}
+}
+
+func TestIsFullyWithdrawableValidator(t *testing.T) {
+	tests := []struct {
+		name      string
+		validator *ethpb.Validator
+		balance   uint64
+		epoch     primitives.Epoch
+		want      bool
+	}{
+		{
+			name:      "Handles nil case",
+			validator: nil,
+			balance:   0,
+			epoch:     0,
+			want:      false,
+		},
+		{
+			name: "No ETH1 prefix",
+			validator: &ethpb.Validator{
+				WithdrawalCredentials: []byte{0xFA, 0xCC},
+				WithdrawableEpoch:     2,
+			},
+			balance: params.BeaconConfig().MaxEffectiveBalance,
+			epoch:   3,
+			want:    false,
+		},
+		{
+			name: "Wrong withdrawable epoch",
+			validator: &ethpb.Validator{
+				WithdrawalCredentials: []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, 0xCC},
+				WithdrawableEpoch:     2,
+			},
+			balance: params.BeaconConfig().MaxEffectiveBalance,
+			epoch:   1,
+			want:    false,
+		},
+		{
+			name: "No balance",
+			validator: &ethpb.Validator{
+				WithdrawalCredentials: []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, 0xCC},
+				WithdrawableEpoch:     2,
+			},
+			balance: 0,
+			epoch:   3,
+			want:    false,
+		},
+		{
+			name: "Fully withdrawable",
+			validator: &ethpb.Validator{
+				WithdrawalCredentials: []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, 0xCC},
+				WithdrawableEpoch:     2,
+			},
+			balance: params.BeaconConfig().MaxEffectiveBalance,
+			epoch:   3,
+			want:    true,
+		},
+		{
+			name: "Fully withdrawable compounding validator electra",
+			validator: &ethpb.Validator{
+				WithdrawalCredentials: []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte, 0xCC},
+				WithdrawableEpoch:     2,
+			},
+			balance: params.BeaconConfig().MaxEffectiveBalance,
+			epoch:   params.BeaconConfig().ElectraForkEpoch,
+			want:    true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, helpers.IsFullyWithdrawableValidator(tt.validator, tt.balance, tt.epoch))
+		})
+	}
+}
+
+func TestIsPartiallyWithdrawableValidator(t *testing.T) {
+	tests := []struct {
+		name      string
+		validator *ethpb.Validator
+		balance   uint64
+		epoch     primitives.Epoch
+		want      bool
+	}{
+		{
+			name:      "Handles nil case",
+			validator: nil,
+			balance:   0,
+			epoch:     0,
+			want:      false,
+		},
+		{
+			name: "No ETH1 prefix",
+			validator: &ethpb.Validator{
+				EffectiveBalance:      params.BeaconConfig().MaxEffectiveBalance,
+				WithdrawalCredentials: []byte{0xFA, 0xCC},
+			},
+			balance: params.BeaconConfig().MaxEffectiveBalance,
+			epoch:   3,
+			want:    false,
+		},
+		{
+			name: "No balance",
+			validator: &ethpb.Validator{
+				EffectiveBalance:      params.BeaconConfig().MaxEffectiveBalance,
+				WithdrawalCredentials: []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, 0xCC},
+			},
+			balance: 0,
+			epoch:   3,
+			want:    false,
+		},
+		{
+			name: "Partially withdrawable",
+			validator: &ethpb.Validator{
+				EffectiveBalance:      params.BeaconConfig().MaxEffectiveBalance,
+				WithdrawalCredentials: []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, 0xCC},
+			},
+			balance: params.BeaconConfig().MaxEffectiveBalance * 2,
+			epoch:   3,
+			want:    true,
+		},
+		{
+			name: "Fully withdrawable vanilla validator electra",
+			validator: &ethpb.Validator{
+				EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
+				WithdrawalCredentials: []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, 0xCC},
+			},
+			balance: params.BeaconConfig().MinActivationBalance * 2,
+			epoch:   params.BeaconConfig().ElectraForkEpoch,
+			want:    true,
+		},
+		{
+			name: "Fully withdrawable compounding validator electra",
+			validator: &ethpb.Validator{
+				EffectiveBalance:      params.BeaconConfig().MaxEffectiveBalanceElectra,
+				WithdrawalCredentials: []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte, 0xCC},
+			},
+			balance: params.BeaconConfig().MaxEffectiveBalanceElectra * 2,
+			epoch:   params.BeaconConfig().ElectraForkEpoch,
+			want:    true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, helpers.IsPartiallyWithdrawableValidator(tt.validator, tt.balance, tt.epoch))
+		})
+	}
+}
+
+func TestIsSameWithdrawalCredentials(t *testing.T) {
+	makeWithdrawalCredentials := func(address []byte) []byte {
+		b := make([]byte, 12)
+		return append(b, address...)
+	}
+
+	tests := []struct {
+		name string
+		a    *ethpb.Validator
+		b    *ethpb.Validator
+		want bool
+	}{
+		{
+			"Same credentials",
+			&ethpb.Validator{WithdrawalCredentials: makeWithdrawalCredentials([]byte("same"))},
+			&ethpb.Validator{WithdrawalCredentials: makeWithdrawalCredentials([]byte("same"))},
+			true,
+		},
+		{
+			"Different credentials",
+			&ethpb.Validator{WithdrawalCredentials: makeWithdrawalCredentials([]byte("foo"))},
+			&ethpb.Validator{WithdrawalCredentials: makeWithdrawalCredentials([]byte("bar"))},
+			false,
+		},
+		{"Handles nil case", nil, nil, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, helpers.IsSameWithdrawalCredentials(tt.a, tt.b))
+		})
+	}
+}
+
+func TestValidatorMaxEffectiveBalance(t *testing.T) {
+	tests := []struct {
+		name      string
+		validator *ethpb.Validator
+		want      uint64
+	}{
+		{
+			name:      "Compounding withdrawal credential",
+			validator: &ethpb.Validator{WithdrawalCredentials: []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte, 0xCC}},
+			want:      params.BeaconConfig().MaxEffectiveBalanceElectra,
+		},
+		{
+			name:      "Vanilla credentials",
+			validator: &ethpb.Validator{WithdrawalCredentials: []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, 0xCC}},
+			want:      params.BeaconConfig().MinActivationBalance,
+		},
+		{
+			"Handles nil case",
+			nil,
+			params.BeaconConfig().MinActivationBalance,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, helpers.ValidatorMaxEffectiveBalance(tt.validator))
+		})
+	}
+	// 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"
@@ -320,6 +321,14 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			return nil, err
 		}
 	}
+
+	if time.CanUpgradeToElectra(state.Slot()) {
+		state, err = electra.UpgradeToElectra(state)
+		if err != nil {
+			tracing.AnnotateError(span, err)
+			return nil, err
+		}
+	}
 	return state, nil
 }
 

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -257,7 +257,7 @@ func ProcessOperationsNoVerifyAttsSigs(
 		if err != nil {
 			return nil, err
 		}
-	case version.Altair, version.Bellatrix, version.Capella, version.Deneb:
+	case version.Altair, version.Bellatrix, version.Capella, version.Deneb, version.Electra:
 		state, err = altairOperations(ctx, state, beaconBlock)
 		if err != nil {
 			return nil, err

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/filesystem/BUILD.bazel

@@ -18,10 +18,12 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//io/file:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/logging:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",

beacon-chain/db/filesystem/blob.go

@@ -10,11 +10,13 @@ import (
 	"strings"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/io/file"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/logging"
@@ -27,6 +29,7 @@ var (
 	errEmptyBlobWritten    = errors.New("zero bytes written to disk when saving blob sidecar")
 	errSidecarEmptySSZData = errors.New("sidecar marshalled to an empty ssz byte slice")
 	errNoBasePath          = errors.New("BlobStorage base path not specified in init")
+	errInvalidRootString   = errors.New("Could not parse hex string as a [32]byte")
 )
 
 const (
@@ -333,3 +336,11 @@ func (p blobNamer) path() string {
 func rootString(root [32]byte) string {
 	return fmt.Sprintf("%#x", root)
 }
+
+func stringToRoot(str string) ([32]byte, error) {
+	slice, err := hexutil.Decode(str)
+	if err != nil {
+		return [32]byte{}, errors.Wrapf(errInvalidRootString, "input=%s", str)
+	}
+	return bytesutil.ToBytes32(slice), nil
+}

beacon-chain/db/filesystem/cache.go

@@ -48,27 +48,26 @@ type BlobStorageSummarizer interface {
 type blobStorageCache struct {
 	mu     sync.RWMutex
 	nBlobs float64
-	cache  map[string]BlobStorageSummary
+	cache  map[[32]byte]BlobStorageSummary
 }
 
 var _ BlobStorageSummarizer = &blobStorageCache{}
 
 func newBlobStorageCache() *blobStorageCache {
 	return &blobStorageCache{
-		cache: make(map[string]BlobStorageSummary, params.BeaconConfig().MinEpochsForBlobsSidecarsRequest*fieldparams.SlotsPerEpoch),
+		cache: make(map[[32]byte]BlobStorageSummary, params.BeaconConfig().MinEpochsForBlobsSidecarsRequest*fieldparams.SlotsPerEpoch),
 	}
 }
 
 // Summary returns the BlobStorageSummary for `root`. The BlobStorageSummary can be used to check for the presence of
 // BlobSidecars based on Index.
 func (s *blobStorageCache) Summary(root [32]byte) BlobStorageSummary {
-	k := rootString(root)
 	s.mu.RLock()
 	defer s.mu.RUnlock()
-	return s.cache[k]
+	return s.cache[root]
 }
 
-func (s *blobStorageCache) ensure(key string, slot primitives.Slot, idx uint64) error {
+func (s *blobStorageCache) ensure(key [32]byte, slot primitives.Slot, idx uint64) error {
 	if idx >= fieldparams.MaxBlobsPerBlock {
 		return errIndexOutOfBounds
 	}
@@ -84,7 +83,7 @@ func (s *blobStorageCache) ensure(key string, slot primitives.Slot, idx uint64)
 	return nil
 }
 
-func (s *blobStorageCache) slot(key string) (primitives.Slot, bool) {
+func (s *blobStorageCache) slot(key [32]byte) (primitives.Slot, bool) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	v, ok := s.cache[key]
@@ -94,7 +93,7 @@ func (s *blobStorageCache) slot(key string) (primitives.Slot, bool) {
 	return v.slot, ok
 }
 
-func (s *blobStorageCache) evict(key string) {
+func (s *blobStorageCache) evict(key [32]byte) {
 	var deleted float64
 	s.mu.Lock()
 	v, ok := s.cache[key]

beacon-chain/db/filesystem/cache_test.go

@@ -48,7 +48,7 @@ func TestSlotByRoot_Summary(t *testing.T) {
 	sc := newBlobStorageCache()
 	for _, c := range cases {
 		if c.expected != nil {
-			key := rootString(bytesutil.ToBytes32([]byte(c.name)))
+			key := bytesutil.ToBytes32([]byte(c.name))
 			sc.cache[key] = BlobStorageSummary{slot: 0, mask: *c.expected}
 		}
 	}

beacon-chain/db/filesystem/mock.go

@@ -66,7 +66,7 @@ func NewMockBlobStorageSummarizer(t *testing.T, set map[[32]byte][]int) BlobStor
 	c := newBlobStorageCache()
 	for k, v := range set {
 		for i := range v {
-			if err := c.ensure(rootString(k), 0, uint64(v[i])); err != nil {
+			if err := c.ensure(k, 0, uint64(v[i])); err != nil {
 				t.Fatal(err)
 			}
 		}

beacon-chain/db/filesystem/pruner.go

@@ -64,7 +64,7 @@ func newBlobPruner(fs afero.Fs, retain primitives.Epoch, opts ...prunerOpt) (*bl
 // notify updates the pruner's view of root->blob mappings. This allows the pruner to build a cache
 // of root->slot mappings and decide when to evict old blobs based on the age of present blobs.
 func (p *blobPruner) notify(root [32]byte, latest primitives.Slot, idx uint64) error {
-	if err := p.cache.ensure(rootString(root), latest, idx); err != nil {
+	if err := p.cache.ensure(root, latest, idx); err != nil {
 		return err
 	}
 	pruned := uint64(windowMin(latest, p.windowSize))
@@ -160,7 +160,10 @@ func shouldRetain(slot, pruneBefore primitives.Slot) bool {
 }
 
 func (p *blobPruner) tryPruneDir(dir string, pruneBefore primitives.Slot) (int, error) {
-	root := rootFromDir(dir)
+	root, err := rootFromDir(dir)
+	if err != nil {
+		return 0, errors.Wrapf(err, "invalid directory, could not parse subdir as root %s", dir)
+	}
 	slot, slotCached := p.cache.slot(root)
 	// Return early if the slot is cached and doesn't need pruning.
 	if slotCached && shouldRetain(slot, pruneBefore) {
@@ -218,7 +221,7 @@ func (p *blobPruner) tryPruneDir(dir string, pruneBefore primitives.Slot) (int,
 		return removed, errors.Wrapf(err, "unable to remove blob directory %s", dir)
 	}
 
-	p.cache.evict(rootFromDir(dir))
+	p.cache.evict(root)
 	return len(scFiles), nil
 }
 
@@ -235,8 +238,13 @@ func idxFromPath(fname string) (uint64, error) {
 	return strconv.ParseUint(parts[0], 10, 64)
 }
 
-func rootFromDir(dir string) string {
-	return filepath.Base(dir) // end of the path should be the blob directory, named by hex encoding of root
+func rootFromDir(dir string) ([32]byte, error) {
+	subdir := filepath.Base(dir) // end of the path should be the blob directory, named by hex encoding of root
+	root, err := stringToRoot(subdir)
+	if err != nil {
+		return root, errors.Wrapf(err, "invalid directory, could not parse subdir as root %s", dir)
+	}
+	return root, nil
 }
 
 // Read slot from marshaled BlobSidecar data in the given file. See slotFromBlob for details.

beacon-chain/db/filesystem/pruner_test.go

@@ -25,11 +25,11 @@ func TestTryPruneDir_CachedNotExpired(t *testing.T) {
 	_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, slot, fieldparams.MaxBlobsPerBlock)
 	sc, err := verification.BlobSidecarNoop(sidecars[0])
 	require.NoError(t, err)
-	root := fmt.Sprintf("%#x", sc.BlockRoot())
+	rootStr := rootString(sc.BlockRoot())
 	// This slot is right on the edge of what would need to be pruned, so by adding it to the cache and
 	// skipping any other test setup, we can be certain the hot cache path never touches the filesystem.
-	require.NoError(t, pr.cache.ensure(root, sc.Slot(), 0))
-	pruned, err := pr.tryPruneDir(root, pr.windowSize)
+	require.NoError(t, pr.cache.ensure(sc.BlockRoot(), sc.Slot(), 0))
+	pruned, err := pr.tryPruneDir(rootStr, pr.windowSize)
 	require.NoError(t, err)
 	require.Equal(t, 0, pruned)
 }
@@ -43,10 +43,10 @@ func TestTryPruneDir_CachedExpired(t *testing.T) {
 		_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, slot, 1)
 		sc, err := verification.BlobSidecarNoop(sidecars[0])
 		require.NoError(t, err)
-		root := fmt.Sprintf("%#x", sc.BlockRoot())
-		require.NoError(t, fs.Mkdir(root, directoryPermissions)) // make empty directory
-		require.NoError(t, pr.cache.ensure(root, sc.Slot(), 0))
-		pruned, err := pr.tryPruneDir(root, slot+1)
+		rootStr := rootString(sc.BlockRoot())
+		require.NoError(t, fs.Mkdir(rootStr, directoryPermissions)) // make empty directory
+		require.NoError(t, pr.cache.ensure(sc.BlockRoot(), sc.Slot(), 0))
+		pruned, err := pr.tryPruneDir(rootStr, slot+1)
 		require.NoError(t, err)
 		require.Equal(t, 0, pruned)
 	})
@@ -61,20 +61,21 @@ func TestTryPruneDir_CachedExpired(t *testing.T) {
 		require.NoError(t, bs.Save(scs[1]))
 
 		// check that the root->slot is cached
-		root := fmt.Sprintf("%#x", scs[0].BlockRoot())
-		cs, cok := bs.pruner.cache.slot(root)
+		root := scs[0].BlockRoot()
+		rootStr := rootString(root)
+		cs, cok := bs.pruner.cache.slot(scs[0].BlockRoot())
 		require.Equal(t, true, cok)
 		require.Equal(t, slot, cs)
 
 		// ensure that we see the saved files in the filesystem
-		files, err := listDir(fs, root)
+		files, err := listDir(fs, rootStr)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(files))
 
-		pruned, err := bs.pruner.tryPruneDir(root, slot+1)
+		pruned, err := bs.pruner.tryPruneDir(rootStr, slot+1)
 		require.NoError(t, err)
 		require.Equal(t, 2, pruned)
-		files, err = listDir(fs, root)
+		files, err = listDir(fs, rootStr)
 		require.ErrorIs(t, err, os.ErrNotExist)
 		require.Equal(t, 0, len(files))
 	})
@@ -92,7 +93,8 @@ func TestTryPruneDir_SlotFromFile(t *testing.T) {
 		require.NoError(t, bs.Save(scs[1]))
 
 		// check that the root->slot is cached
-		root := fmt.Sprintf("%#x", scs[0].BlockRoot())
+		root := scs[0].BlockRoot()
+		rootStr := rootString(root)
 		cs, ok := bs.pruner.cache.slot(root)
 		require.Equal(t, true, ok)
 		require.Equal(t, slot, cs)
@@ -102,14 +104,14 @@ func TestTryPruneDir_SlotFromFile(t *testing.T) {
 		require.Equal(t, false, ok)
 
 		// ensure that we see the saved files in the filesystem
-		files, err := listDir(fs, root)
+		files, err := listDir(fs, rootStr)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(files))
 
-		pruned, err := bs.pruner.tryPruneDir(root, slot+1)
+		pruned, err := bs.pruner.tryPruneDir(rootStr, slot+1)
 		require.NoError(t, err)
 		require.Equal(t, 2, pruned)
-		files, err = listDir(fs, root)
+		files, err = listDir(fs, rootStr)
 		require.ErrorIs(t, err, os.ErrNotExist)
 		require.Equal(t, 0, len(files))
 	})
@@ -125,24 +127,25 @@ func TestTryPruneDir_SlotFromFile(t *testing.T) {
 		require.NoError(t, bs.Save(scs[1]))
 
 		// Evict slot mapping from the cache so that we trigger the file read path.
-		root := fmt.Sprintf("%#x", scs[0].BlockRoot())
+		root := scs[0].BlockRoot()
+		rootStr := rootString(root)
 		bs.pruner.cache.evict(root)
 		_, ok := bs.pruner.cache.slot(root)
 		require.Equal(t, false, ok)
 
 		// Ensure that we see the saved files in the filesystem.
-		files, err := listDir(fs, root)
+		files, err := listDir(fs, rootStr)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(files))
 
 		// This should use the slotFromFile code (simulating restart).
 		// Setting pruneBefore == slot, so that the slot will be outside the window (at the boundary).
-		pruned, err := bs.pruner.tryPruneDir(root, slot)
+		pruned, err := bs.pruner.tryPruneDir(rootStr, slot)
 		require.NoError(t, err)
 		require.Equal(t, 0, pruned)
 
 		// Ensure files are still present.
-		files, err = listDir(fs, root)
+		files, err = listDir(fs, rootStr)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(files))
 	})
@@ -316,3 +319,45 @@ func TestListDir(t *testing.T) {
 		})
 	}
 }
+
+func TestRootFromDir(t *testing.T) {
+	cases := []struct {
+		name string
+		dir  string
+		err  error
+		root [32]byte
+	}{
+		{
+			name: "happy path",
+			dir:  "0xffff875e1d985c5ccb214894983f2428edb271f0f87b68ba7010e4a99df3b5cb",
+			root: [32]byte{255, 255, 135, 94, 29, 152, 92, 92, 203, 33, 72, 148, 152, 63, 36, 40,
+				237, 178, 113, 240, 248, 123, 104, 186, 112, 16, 228, 169, 157, 243, 181, 203},
+		},
+		{
+			name: "too short",
+			dir:  "0xffff875e1d985c5ccb214894983f2428edb271f0f87b68ba7010e4a99df3b5c",
+			err:  errInvalidRootString,
+		},
+		{
+			name: "too log",
+			dir:  "0xffff875e1d985c5ccb214894983f2428edb271f0f87b68ba7010e4a99df3b5cbb",
+			err:  errInvalidRootString,
+		},
+		{
+			name: "missing prefix",
+			dir:  "ffff875e1d985c5ccb214894983f2428edb271f0f87b68ba7010e4a99df3b5cb",
+			err:  errInvalidRootString,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			root, err := stringToRoot(c.dir)
+			if c.err != nil {
+				require.ErrorIs(t, err, c.err)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, c.root, root)
+		})
+	}
+}

beacon-chain/db/kv/BUILD.bazel

@@ -115,6 +115,7 @@ go_test(
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/testing:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

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

@@ -14,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"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/testing/util"
@@ -124,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) {
@@ -180,7 +222,7 @@ func TestStore_BlocksCRUD(t *testing.T) {
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
 			wanted := retrievedBlock
-			if _, err := retrievedBlock.PbBellatrixBlock(); err == nil {
+			if retrievedBlock.Version() >= version.Bellatrix {
 				wanted, err = retrievedBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -368,15 +410,7 @@ func TestStore_BlocksCRUD_NoCache(t *testing.T) {
 			require.NoError(t, err)
 
 			wanted := blk
-			if _, err := blk.PbBellatrixBlock(); err == nil {
-				wanted, err = blk.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := blk.PbCapellaBlock(); err == nil {
-				wanted, err = blk.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := blk.PbDenebBlock(); err == nil {
+			if blk.Version() >= version.Bellatrix {
 				wanted, err = blk.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -595,15 +629,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted := block1
-			if _, err := block1.PbBellatrixBlock(); err == nil {
-				wanted, err = wanted.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := block1.PbCapellaBlock(); err == nil {
-				wanted, err = wanted.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := block1.PbDenebBlock(); err == nil {
+			if block1.Version() >= version.Bellatrix {
 				wanted, err = wanted.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -621,15 +647,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted2 := block2
-			if _, err := block2.PbBellatrixBlock(); err == nil {
-				wanted2, err = block2.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := block2.PbCapellaBlock(); err == nil {
-				wanted2, err = block2.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := block2.PbDenebBlock(); err == nil {
+			if block2.Version() >= version.Bellatrix {
 				wanted2, err = block2.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -647,15 +665,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = block3
-			if _, err := block3.PbBellatrixBlock(); err == nil {
-				wanted, err = wanted.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := block3.PbCapellaBlock(); err == nil {
-				wanted, err = wanted.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := block3.PbDenebBlock(); err == nil {
+			if block3.Version() >= version.Bellatrix {
 				wanted, err = wanted.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -691,15 +701,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted := block1
-			if _, err := block1.PbBellatrixBlock(); err == nil {
-				wanted, err = block1.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := block1.PbCapellaBlock(); err == nil {
-				wanted, err = block1.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := block1.PbDenebBlock(); err == nil {
+			if block1.Version() >= version.Bellatrix {
 				wanted, err = block1.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -716,15 +718,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = genesisBlock
-			if _, err := genesisBlock.PbBellatrixBlock(); err == nil {
-				wanted, err = genesisBlock.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := genesisBlock.PbCapellaBlock(); err == nil {
-				wanted, err = genesisBlock.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := genesisBlock.PbDenebBlock(); err == nil {
+			if genesisBlock.Version() >= version.Bellatrix {
 				wanted, err = genesisBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -741,15 +735,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = genesisBlock
-			if _, err := genesisBlock.PbBellatrixBlock(); err == nil {
-				wanted, err = genesisBlock.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := genesisBlock.PbCapellaBlock(); err == nil {
-				wanted, err = genesisBlock.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := genesisBlock.PbDenebBlock(); err == nil {
+			if genesisBlock.Version() >= version.Bellatrix {
 				wanted, err = genesisBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -845,15 +831,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			require.NoError(t, err)
 
 			wanted := b1
-			if _, err := b1.PbBellatrixBlock(); err == nil {
-				wanted, err = b1.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := b1.PbCapellaBlock(); err == nil {
-				wanted, err = b1.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := b1.PbDenebBlock(); err == nil {
+			if b1.Version() >= version.Bellatrix {
 				wanted, err = b1.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -869,15 +847,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 				t.Fatalf("Expected 2 blocks, received %d blocks", len(retrievedBlocks))
 			}
 			wanted = b2
-			if _, err := b2.PbBellatrixBlock(); err == nil {
-				wanted, err = b2.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := b2.PbCapellaBlock(); err == nil {
-				wanted, err = b2.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := b2.PbDenebBlock(); err == nil {
+			if b2.Version() >= version.Bellatrix {
 				wanted, err = b2.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -887,15 +857,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			require.NoError(t, err)
 			assert.Equal(t, true, proto.Equal(wantedPb, retrieved0Pb), "Wanted: %v, received: %v", retrievedBlocks[0], wanted)
 			wanted = b3
-			if _, err := b3.PbBellatrixBlock(); err == nil {
-				wanted, err = b3.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := b3.PbCapellaBlock(); err == nil {
-				wanted, err = b3.ToBlinded()
-				require.NoError(t, err)
-			}
-			if _, err := b3.PbDenebBlock(); err == nil {
+			if b3.Version() >= version.Bellatrix {
 				wanted, err = b3.ToBlinded()
 				require.NoError(t, err)
 			}

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

@@ -132,6 +132,33 @@ func TestState_CanSaveRetrieve(t *testing.T) {
 			},
 			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),
+				}, big.NewInt(0))
+				require.NoError(t, err)
+				require.NoError(t, st.SetLatestExecutionPayloadHeader(p))
+				return st
+			},
+			rootSeed: 'E',
+		},
 	}
 
 	db := setupDB(t)
@@ -1138,6 +1165,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/db/slasherkv/slasher.go

@@ -156,10 +156,10 @@ func (s *Store) CheckAttesterDoubleVotes(
 				signingRootsBkt := tx.Bucket(attestationDataRootsBucket)
 				attRecordsBkt := tx.Bucket(attestationRecordsBucket)
 
-				encEpoch := encodeTargetEpoch(attToProcess.IndexedAttestation.Data.Target.Epoch)
+				encEpoch := encodeTargetEpoch(attToProcess.IndexedAttestation.GetData().Target.Epoch)
 				localDoubleVotes := make([]*slashertypes.AttesterDoubleVote, 0)
 
-				for _, valIdx := range attToProcess.IndexedAttestation.AttestingIndices {
+				for _, valIdx := range attToProcess.IndexedAttestation.GetAttestingIndices() {
 					// Check if there is signing root in the database for this combination
 					// of validator index and target epoch.
 					encIdx := encodeValidatorIndex(primitives.ValidatorIndex(valIdx))
@@ -194,7 +194,7 @@ func (s *Store) CheckAttesterDoubleVotes(
 					// Build the proof of double vote.
 					slashAtt := &slashertypes.AttesterDoubleVote{
 						ValidatorIndex: primitives.ValidatorIndex(valIdx),
-						Target:         attToProcess.IndexedAttestation.Data.Target.Epoch,
+						Target:         attToProcess.IndexedAttestation.GetData().Target.Epoch,
 						Wrapper_1:      existingAttRecord,
 						Wrapper_2:      attToProcess,
 					}
@@ -280,7 +280,7 @@ func (s *Store) SaveAttestationRecordsForValidators(
 	encodedRecords := make([][]byte, attWrappersCount)
 
 	for i, attestation := range attWrappers {
-		encEpoch := encodeTargetEpoch(attestation.IndexedAttestation.Data.Target.Epoch)
+		encEpoch := encodeTargetEpoch(attestation.IndexedAttestation.GetData().Target.Epoch)
 
 		value, err := encodeAttestationRecord(attestation)
 		if err != nil {
@@ -325,7 +325,7 @@ func (s *Store) SaveAttestationRecordsForValidators(
 					return err
 				}
 
-				for _, validatorIndex := range attWrapper.IndexedAttestation.AttestingIndices {
+				for _, validatorIndex := range attWrapper.IndexedAttestation.GetAttestingIndices() {
 					encodedIndex := encodeValidatorIndex(primitives.ValidatorIndex(validatorIndex))
 
 					key := append(encodedTargetEpoch, encodedIndex...)
@@ -638,8 +638,8 @@ func (s *Store) HighestAttestations(
 					}
 					highestAtt := &ethpb.HighestAttestation{
 						ValidatorIndex:     uint64(indices[i]),
-						HighestSourceEpoch: attWrapper.IndexedAttestation.Data.Source.Epoch,
-						HighestTargetEpoch: attWrapper.IndexedAttestation.Data.Target.Epoch,
+						HighestSourceEpoch: attWrapper.IndexedAttestation.GetData().Source.Epoch,
+						HighestTargetEpoch: attWrapper.IndexedAttestation.GetData().Target.Epoch,
 					}
 					history = append(history, highestAtt)
 					break

beacon-chain/db/slasherkv/slasher_test.go

@@ -62,7 +62,7 @@ func TestStore_AttestationRecordForValidator_SaveRetrieve(t *testing.T) {
 		actual, err := beaconDB.AttestationRecordForValidator(ctx, validatorIndex, primitives.Epoch(i+1))
 		require.NoError(t, err)
 
-		require.DeepEqual(t, expected.IndexedAttestation.Data.Source.Epoch, actual.IndexedAttestation.Data.Source.Epoch)
+		require.DeepEqual(t, expected.IndexedAttestation.GetData().Source.Epoch, actual.IndexedAttestation.GetData().Source.Epoch)
 	}
 }
 
@@ -544,7 +544,7 @@ func BenchmarkHighestAttestations(b *testing.B) {
 	for i := 0; i < count; i++ {
 		indicesForAtt := make([]primitives.ValidatorIndex, valsPerAtt)
 		for r := 0; r < valsPerAtt; r++ {
-			indicesForAtt[r] = primitives.ValidatorIndex(atts[i].IndexedAttestation.AttestingIndices[r])
+			indicesForAtt[r] = primitives.ValidatorIndex(atts[i].IndexedAttestation.GetAttestingIndices()[r])
 		}
 		allIndices = append(allIndices, indicesForAtt...)
 	}