Fixing Proto Generation

* Update ckzg4844 to latest version

* Run go mod tidy

* Remove unnecessary tests & run goimports

* Remove fieldparams from blockchain/kzg

* Add back blank line

* Avoid large copies

* Run gazelle

* Use trusted setup from the specs & fix issue with struct

* Run goimports

* Fix mistake in makeCellsAndProofs

---------

Co-authored-by: Manu NALEPA <enalepa@offchainlabs.com>

.bazelrc

@@ -22,6 +22,7 @@ coverage --define=coverage_enabled=1
 build --workspace_status_command=./hack/workspace_status.sh
 
 build --define blst_disabled=false
+build --compilation_mode=opt
 run --define blst_disabled=false
 
 build:blst_disabled --define blst_disabled=true

.github/actions/gomodtidy/Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.21-alpine
+FROM golang:1.22-alpine
 
 COPY entrypoint.sh /entrypoint.sh
 

.github/workflows/fuzz.yml

@@ -16,7 +16,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v4
         with:
-          go-version: '1.21.5'
+          go-version: '1.22.3'
       - id: list
         uses: shogo82148/actions-go-fuzz/list@v0
         with:
@@ -36,7 +36,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v4
         with:
-          go-version: '1.21.5'
+          go-version: '1.22.3'
       - uses: shogo82148/actions-go-fuzz/run@v0
         with:
           packages: ${{ matrix.package }}

.github/workflows/go.yml

@@ -28,14 +28,14 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Set up Go 1.21
+      - name: Set up Go 1.22
         uses: actions/setup-go@v3
         with:
-          go-version: '1.21.5'
+          go-version: '1.22.3'
       - name: Run Gosec Security Scanner
         run: | # https://github.com/securego/gosec/issues/469
           export PATH=$PATH:$(go env GOPATH)/bin
-          go install github.com/securego/gosec/v2/cmd/gosec@v2.15.0
+          go install github.com/securego/gosec/v2/cmd/gosec@v2.19.0
           gosec -exclude-generated -exclude=G307 -exclude-dir=crypto/bls/herumi ./...
 
   lint:
@@ -45,10 +45,10 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v2
 
-      - name: Set up Go 1.21
+      - name: Set up Go 1.22
         uses: actions/setup-go@v3
         with:
-          go-version: '1.21.5'
+          go-version: '1.22.3'
           id: go
 
       - name: Golangci-lint
@@ -64,7 +64,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v2
         with:
-          go-version: '1.21.5'
+          go-version: '1.22.3'
         id: go
 
       - name: Check out code into the Go module directory

.golangci.yml

@@ -6,7 +6,7 @@ run:
     - proto
     - tools/analyzers
   timeout: 10m
-  go: '1.21.5'
+  go: '1.22.3'
 
 linters:
   enable-all: true
@@ -34,7 +34,6 @@ linters:
     - dogsled
     - dupl
     - durationcheck
-    - errorlint
     - exhaustive
     - exhaustruct
     - forbidigo
@@ -52,6 +51,7 @@ linters:
     - gofumpt
     - gomnd
     - gomoddirectives
+    - gosec
     - inamedparam
     - interfacebloat
     - ireturn

BUILD.bazel

@@ -224,6 +224,7 @@ nogo(
         "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_default_library",
         "@org_golang_x_tools//go/analysis/passes/defers:go_default_library",
         "@org_golang_x_tools//go/analysis/passes/directive:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/errorsas:go_default_library",
         # fieldalignment disabled
         #"@org_golang_x_tools//go/analysis/passes/fieldalignment:go_default_library",
         "@org_golang_x_tools//go/analysis/passes/findcall:go_default_library",

WORKSPACE

@@ -182,7 +182,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.21.8",
+    go_version = "1.22.4",
     nogo = "@//:nogo",
 )
 
@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.2"
+consensus_spec_version = "v1.5.0-alpha.3"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-NNXBa7SZ2sFb68HPNahgu1p0yDBpjuKJuLfRCl7vvoQ=",
+    integrity = "sha256-+byv+GUOQytex5GgtjBGVoNDseJZbiBdAjEtlgCbjEo=",
     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"],
 )
     """,
-    integrity = "sha256-7BnlBvGWU92iAB100cMaAXVQhRrqpMQbavgrI+/paCw=",
+    integrity = "sha256-JJUy/jT1h3kGQkinTuzL7gMOA1+qgmPgJXVrYuH63Cg=",
     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"],
 )
     """,
-    integrity = "sha256-VCHhcNt+fynf/sHK11qbRBAy608u9T1qAafvAGfxQhA=",
+    integrity = "sha256-T2VM4Qd0SwgGnTjWxjOX297DqEsovO9Ueij1UEJy48Y=",
     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"],
 )
     """,
-    integrity = "sha256-a2aCNFyFkYLtf6QSwGOHdx7xXHjA2NNT8x8ZuxB0aes=",
+    integrity = "sha256-OP9BCBcQ7i+93bwj7ktY8pZ5uWsGjgTe4XTp7BDhX+I=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -332,14 +332,14 @@ http_archive(
 filegroup(
     name = "configs",
     srcs = [
-        "custom_config_data/config.yaml",
+        "metadata/config.yaml",
     ],
     visibility = ["//visibility:public"],
 )
 """,
-    sha256 = "5f4be6fd088683ea9db45c863b9c5a1884422449e5b59fd2d561d3ba0f73ffd9",
-    strip_prefix = "holesky-9d9aabf2d4de51334ee5fed6c79a4d55097d1a43",
-    url = "https://github.com/eth-clients/holesky/archive/9d9aabf2d4de51334ee5fed6c79a4d55097d1a43.tar.gz",  # 2024-01-22
+    integrity = "sha256-b7ZTT+olF+VXEJYNTV5jggNtCkt9dOejm1i2VE+zy+0=",
+    strip_prefix = "holesky-874c199423ccd180607320c38cbaca05d9a1573a",
+    url = "https://github.com/eth-clients/holesky/archive/874c199423ccd180607320c38cbaca05d9a1573a.tar.gz",  # 2024-06-18
 )
 
 http_archive(

api/client/beacon/checkpoint_test.go

@@ -9,22 +9,20 @@ import (
 	"net/http"
 	"testing"
 
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/client"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	blocktest "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks/testing"
-	"github.com/prysmaticlabs/prysm/v5/network/forks"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
-
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz/detect"
+	"github.com/prysmaticlabs/prysm/v5/network/forks"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
 type testRT struct {

api/client/builder/BUILD.bazel

@@ -55,6 +55,7 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],

api/client/builder/types_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
@@ -1914,7 +1915,8 @@ func TestEmptyResponseBody(t *testing.T) {
 		var b []byte
 		r := &ExecutionPayloadResponse{}
 		err := json.Unmarshal(b, r)
-		_, ok := err.(*json.SyntaxError)
+		var syntaxError *json.SyntaxError
+		ok := errors.As(err, &syntaxError)
 		require.Equal(t, true, ok)
 	})
 	t.Run("empty object", func(t *testing.T) {

api/server/error.go

@@ -1,6 +1,7 @@
 package server
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 )
@@ -15,7 +16,8 @@ type DecodeError struct {
 // NewDecodeError wraps an error (either the initial decoding error or another DecodeError).
 // The current field that failed decoding must be passed in.
 func NewDecodeError(err error, field string) *DecodeError {
-	de, ok := err.(*DecodeError)
+	var de *DecodeError
+	ok := errors.As(err, &de)
 	if ok {
 		return &DecodeError{path: append([]string{field}, de.path...), err: de.err}
 	}

api/server/structs/conversions.go

@@ -8,11 +8,10 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/validator"
-	"github.com/prysmaticlabs/prysm/v5/container/slice"
-
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/validator"
+	"github.com/prysmaticlabs/prysm/v5/container/slice"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"

beacon-chain/blockchain/BUILD.bazel

@@ -26,6 +26,7 @@ go_library(
         "receive_attestation.go",
         "receive_blob.go",
         "receive_block.go",
+        "receive_data_column.go",
         "service.go",
         "tracked_proposer.go",
         "weak_subjectivity_checks.go",
@@ -48,6 +49,7 @@ go_library(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -64,6 +66,7 @@ go_library(
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/slasher/types:go_default_library",
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
@@ -138,6 +141,7 @@ go_test(
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
+        "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -157,6 +161,7 @@ go_test(
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/p2p/testing:go_default_library",
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
@@ -181,6 +186,7 @@ go_test(
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -6,8 +6,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	f "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
@@ -20,6 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which

beacon-chain/blockchain/error.go

@@ -33,6 +33,7 @@ var (
 )
 
 var errMaxBlobsExceeded = errors.New("Expected commitments in block exceeds MAX_BLOBS_PER_BLOCK")
+var errMaxDataColumnsExceeded = errors.New("Expected data columns for node exceeds NUMBER_OF_COLUMNS")
 
 // An invalid block is the block that fails state transition based on the core protocol rules.
 // The beacon node shall not be accepting nor building blocks that branch off from an invalid block.

beacon-chain/blockchain/execution_engine.go

@@ -74,8 +74,8 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	}
 	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, arg.attributes)
 	if err != nil {
-		switch err {
-		case execution.ErrAcceptedSyncingPayloadStatus:
+		switch {
+		case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
 			forkchoiceUpdatedOptimisticNodeCount.Inc()
 			log.WithFields(logrus.Fields{
 				"headSlot":                  headBlk.Slot(),
@@ -83,7 +83,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 				"finalizedPayloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(finalizedHash[:])),
 			}).Info("Called fork choice updated with optimistic block")
 			return payloadID, nil
-		case execution.ErrInvalidPayloadStatus:
+		case errors.Is(err, execution.ErrInvalidPayloadStatus):
 			forkchoiceUpdatedInvalidNodeCount.Inc()
 			headRoot := arg.headRoot
 			if len(lastValidHash) == 0 {
@@ -139,7 +139,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 				"newHeadRoot":          fmt.Sprintf("%#x", bytesutil.Trunc(r[:])),
 			}).Warn("Pruned invalid blocks")
 			return pid, invalidBlock{error: ErrInvalidPayload, root: arg.headRoot, invalidAncestorRoots: invalidRoots}
-
 		default:
 			log.WithError(err).Error(ErrUndefinedExecutionEngineError)
 			return nil, nil
@@ -231,18 +230,18 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
 	} else {
 		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, []common.Hash{}, &common.Hash{} /*empty version hashes and root before Deneb*/)
 	}
-	switch err {
-	case nil:
+	switch {
+	case err == nil:
 		newPayloadValidNodeCount.Inc()
 		return true, nil
-	case execution.ErrAcceptedSyncingPayloadStatus:
+	case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
 		newPayloadOptimisticNodeCount.Inc()
 		log.WithFields(logrus.Fields{
 			"slot":             blk.Block().Slot(),
 			"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
 		}).Info("Called new payload with optimistic block")
 		return false, nil
-	case execution.ErrInvalidPayloadStatus:
+	case errors.Is(err, execution.ErrInvalidPayloadStatus):
 		lvh := bytesutil.ToBytes32(lastValidHash)
 		return false, invalidBlock{
 			error:         ErrInvalidPayload,
@@ -324,7 +323,7 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 
 	var attr payloadattribute.Attributer
 	switch st.Version() {
-	case version.Deneb:
+	case version.Deneb, version.Electra:
 		withdrawals, _, err := st.ExpectedWithdrawals()
 		if err != nil {
 			log.WithError(err).Error("Could not get expected withdrawals to get payload attribute")

beacon-chain/blockchain/execution_engine_test.go

@@ -855,41 +855,63 @@ func Test_GetPayloadAttributeV2(t *testing.T) {
 	require.Equal(t, 0, len(a))
 }
 
-func Test_GetPayloadAttributeDeneb(t *testing.T) {
-	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
-	ctx := tr.ctx
+func Test_GetPayloadAttributeV3(t *testing.T) {
+	var testCases = []struct {
+		name string
+		st   bstate.BeaconState
+	}{
+		{
+			name: "deneb",
+			st: func() bstate.BeaconState {
+				st, _ := util.DeterministicGenesisStateDeneb(t, 1)
+				return st
+			}(),
+		},
+		{
+			name: "electra",
+			st: func() bstate.BeaconState {
+				st, _ := util.DeterministicGenesisStateElectra(t, 1)
+				return st
+			}(),
+		},
+	}
 
-	st, _ := util.DeterministicGenesisStateDeneb(t, 1)
-	attr := service.getPayloadAttribute(ctx, st, 0, []byte{})
-	require.Equal(t, true, attr.IsEmpty())
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+			service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+			ctx := tr.ctx
 
-	// Cache hit, advance state, no fee recipient
-	slot := primitives.Slot(1)
-	service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, Index: 0})
-	service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
-	attr = service.getPayloadAttribute(ctx, st, slot, params.BeaconConfig().ZeroHash[:])
-	require.Equal(t, false, attr.IsEmpty())
-	require.Equal(t, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(attr.SuggestedFeeRecipient()).String())
-	a, err := attr.Withdrawals()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(a))
+			attr := service.getPayloadAttribute(ctx, test.st, 0, []byte{})
+			require.Equal(t, true, attr.IsEmpty())
 
-	// Cache hit, advance state, has fee recipient
-	suggestedAddr := common.HexToAddress("123")
-	service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, FeeRecipient: primitives.ExecutionAddress(suggestedAddr), Index: 0})
-	service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
-	attr = service.getPayloadAttribute(ctx, st, slot, params.BeaconConfig().ZeroHash[:])
-	require.Equal(t, false, attr.IsEmpty())
-	require.Equal(t, suggestedAddr, common.BytesToAddress(attr.SuggestedFeeRecipient()))
-	a, err = attr.Withdrawals()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(a))
+			// Cache hit, advance state, no fee recipient
+			slot := primitives.Slot(1)
+			service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, Index: 0})
+			service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
+			attr = service.getPayloadAttribute(ctx, test.st, slot, params.BeaconConfig().ZeroHash[:])
+			require.Equal(t, false, attr.IsEmpty())
+			require.Equal(t, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(attr.SuggestedFeeRecipient()).String())
+			a, err := attr.Withdrawals()
+			require.NoError(t, err)
+			require.Equal(t, 0, len(a))
 
-	attrV3, err := attr.PbV3()
-	require.NoError(t, err)
-	hr := service.headRoot()
-	require.Equal(t, hr, [32]byte(attrV3.ParentBeaconBlockRoot))
+			// Cache hit, advance state, has fee recipient
+			suggestedAddr := common.HexToAddress("123")
+			service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, FeeRecipient: primitives.ExecutionAddress(suggestedAddr), Index: 0})
+			service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
+			attr = service.getPayloadAttribute(ctx, test.st, slot, params.BeaconConfig().ZeroHash[:])
+			require.Equal(t, false, attr.IsEmpty())
+			require.Equal(t, suggestedAddr, common.BytesToAddress(attr.SuggestedFeeRecipient()))
+			a, err = attr.Withdrawals()
+			require.NoError(t, err)
+			require.Equal(t, 0, len(a))
 
+			attrV3, err := attr.PbV3()
+			require.NoError(t, err)
+			hr := service.headRoot()
+			require.Equal(t, hr, [32]byte(attrV3.ParentBeaconBlockRoot))
+		})
+	}
 }
 
 func Test_UpdateLastValidatedCheckpoint(t *testing.T) {

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -3,6 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "kzg.go",
         "trusted_setup.go",
         "validation.go",
     ],
@@ -12,6 +13,9 @@ go_library(
     deps = [
         "//consensus-types/blocks:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
+        "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_ethereum_go_ethereum//crypto/kzg4844:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
 )

beacon-chain/blockchain/kzg/kzg.go

@@ -0,0 +1,109 @@
+package kzg
+
+import (
+	"errors"
+
+	ckzg4844 "github.com/ethereum/c-kzg-4844/bindings/go"
+	"github.com/ethereum/go-ethereum/crypto/kzg4844"
+)
+
+// BytesPerBlob is the number of bytes in a single blob.
+const BytesPerBlob = ckzg4844.BytesPerBlob
+
+// Blob represents a serialized chunk of data.
+type Blob [BytesPerBlob]byte
+
+// BytesPerCell is the number of bytes in a single cell.
+const BytesPerCell = ckzg4844.BytesPerCell
+
+// Cell represents a chunk of an encoded Blob.
+type Cell [BytesPerCell]byte
+
+// Commitment represent a KZG commitment to a Blob.
+type Commitment [48]byte
+
+// Proof represents a KZG proof that attests to the validity of a Blob or parts of it.
+type Proof [48]byte
+
+// Bytes48 is a 48-byte array.
+type Bytes48 = ckzg4844.Bytes48
+
+// Bytes32 is a 32-byte array.
+type Bytes32 = ckzg4844.Bytes32
+
+// CellsAndProofs represents the Cells and Proofs corresponding to
+// a single blob.
+type CellsAndProofs struct {
+	Cells  []Cell
+	Proofs []Proof
+}
+
+func BlobToKZGCommitment(blob *Blob) (Commitment, error) {
+	comm, err := kzg4844.BlobToCommitment(kzg4844.Blob(*blob))
+	if err != nil {
+		return Commitment{}, err
+	}
+	return Commitment(comm), nil
+}
+
+func ComputeBlobKZGProof(blob *Blob, commitment Commitment) (Proof, error) {
+	proof, err := kzg4844.ComputeBlobProof(kzg4844.Blob(*blob), kzg4844.Commitment(commitment))
+	if err != nil {
+		return [48]byte{}, err
+	}
+	return Proof(proof), nil
+}
+
+func ComputeCellsAndKZGProofs(blob *Blob) (CellsAndProofs, error) {
+	ckzgBlob := (*ckzg4844.Blob)(blob)
+	ckzgCells, ckzgProofs, err := ckzg4844.ComputeCellsAndKZGProofs(ckzgBlob)
+	if err != nil {
+		return CellsAndProofs{}, err
+	}
+
+	return makeCellsAndProofs(ckzgCells[:], ckzgProofs[:])
+}
+
+func VerifyCellKZGProofBatch(commitmentsBytes []Bytes48, cellIndices []uint64, cells []Cell, proofsBytes []Bytes48) (bool, error) {
+	// Convert `Cell` type to `ckzg4844.Cell`
+	ckzgCells := make([]ckzg4844.Cell, len(cells))
+	for i := range cells {
+		ckzgCells[i] = ckzg4844.Cell(cells[i])
+	}
+
+	return ckzg4844.VerifyCellKZGProofBatch(commitmentsBytes, cellIndices, ckzgCells, proofsBytes)
+}
+
+func RecoverCellsAndKZGProofs(cellIndices []uint64, partialCells []Cell) (CellsAndProofs, error) {
+	// Convert `Cell` type to `ckzg4844.Cell`
+	ckzgPartialCells := make([]ckzg4844.Cell, len(partialCells))
+	for i := range partialCells {
+		ckzgPartialCells[i] = ckzg4844.Cell(partialCells[i])
+	}
+
+	ckzgCells, ckzgProofs, err := ckzg4844.RecoverCellsAndKZGProofs(cellIndices, ckzgPartialCells)
+	if err != nil {
+		return CellsAndProofs{}, err
+	}
+
+	return makeCellsAndProofs(ckzgCells[:], ckzgProofs[:])
+}
+
+// Convert cells/proofs to the CellsAndProofs type defined in this package.
+func makeCellsAndProofs(ckzgCells []ckzg4844.Cell, ckzgProofs []ckzg4844.KZGProof) (CellsAndProofs, error) {
+	if len(ckzgCells) != len(ckzgProofs) {
+		return CellsAndProofs{}, errors.New("different number of cells/proofs")
+	}
+
+	var cells []Cell
+	var proofs []Proof
+	for i := range ckzgCells {
+		cells = append(cells, Cell(ckzgCells[i]))
+		proofs = append(proofs, Proof(ckzgProofs[i]))
+	}
+
+	return CellsAndProofs{
+		Cells:  cells,
+		Proofs: proofs,
+	}, nil
+}

beacon-chain/blockchain/kzg/trusted_setup.go

@@ -5,6 +5,8 @@ import (
 	"encoding/json"
 
 	GoKZG "github.com/crate-crypto/go-kzg-4844"
+	CKZG "github.com/ethereum/c-kzg-4844/bindings/go"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 )
 
@@ -12,17 +14,53 @@ var (
 	//go:embed trusted_setup.json
 	embeddedTrustedSetup []byte // 1.2Mb
 	kzgContext           *GoKZG.Context
+	kzgLoaded            bool
 )
 
+type TrustedSetup struct {
+	G1Monomial [GoKZG.ScalarsPerBlob]GoKZG.G1CompressedHexStr `json:"g1_monomial"`
+	G1Lagrange [GoKZG.ScalarsPerBlob]GoKZG.G1CompressedHexStr `json:"g1_lagrange"`
+	G2Monomial [65]GoKZG.G2CompressedHexStr                   `json:"g2_monomial"`
+}
+
 func Start() error {
-	parsedSetup := GoKZG.JSONTrustedSetup{}
-	err := json.Unmarshal(embeddedTrustedSetup, &parsedSetup)
+	trustedSetup := &TrustedSetup{}
+	err := json.Unmarshal(embeddedTrustedSetup, trustedSetup)
 	if err != nil {
 		return errors.Wrap(err, "could not parse trusted setup JSON")
 	}
-	kzgContext, err = GoKZG.NewContext4096(&parsedSetup)
+	kzgContext, err = GoKZG.NewContext4096(&GoKZG.JSONTrustedSetup{
+		SetupG2:         trustedSetup.G2Monomial[:],
+		SetupG1Lagrange: trustedSetup.G1Lagrange})
 	if err != nil {
 		return errors.Wrap(err, "could not initialize go-kzg context")
 	}
+
+	// Length of a G1 point, converted from hex to binary.
+	g1MonomialBytes := make([]byte, len(trustedSetup.G1Monomial)*(len(trustedSetup.G1Monomial[0])-2)/2)
+	for i, g1 := range &trustedSetup.G1Monomial {
+		copy(g1MonomialBytes[i*(len(g1)-2)/2:], hexutil.MustDecode(g1))
+	}
+	// Length of a G1 point, converted from hex to binary.
+	g1LagrangeBytes := make([]byte, len(trustedSetup.G1Lagrange)*(len(trustedSetup.G1Lagrange[0])-2)/2)
+	for i, g1 := range &trustedSetup.G1Lagrange {
+		copy(g1LagrangeBytes[i*(len(g1)-2)/2:], hexutil.MustDecode(g1))
+	}
+	// Length of a G2 point, converted from hex to binary.
+	g2MonomialBytes := make([]byte, len(trustedSetup.G2Monomial)*(len(trustedSetup.G2Monomial[0])-2)/2)
+	for i, g2 := range &trustedSetup.G2Monomial {
+		copy(g2MonomialBytes[i*(len(g2)-2)/2:], hexutil.MustDecode(g2))
+	}
+	if !kzgLoaded {
+		// TODO: Provide a configuration option for this.
+		var precompute uint = 0
+
+		// Free the current trusted setup before running this method. CKZG
+		// panics if the same setup is run multiple times.
+		if err = CKZG.LoadTrustedSetup(g1MonomialBytes, g1LagrangeBytes, g2MonomialBytes, precompute); err != nil {
+			panic(err)
+		}
+	}
+	kzgLoaded = true
 	return nil
 }

beacon-chain/blockchain/lightclient.go

@@ -69,7 +69,7 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	// assert sum(block.message.body.sync_aggregate.sync_committee_bits) >= MIN_SYNC_COMMITTEE_PARTICIPANTS
 	syncAggregate, err := block.Block().Body().SyncAggregate()
 	if err != nil {
-		return nil, fmt.Errorf("could not get sync aggregate %v", err)
+		return nil, fmt.Errorf("could not get sync aggregate %w", err)
 	}
 
 	if syncAggregate.SyncCommitteeBits.Count() < params.BeaconConfig().MinSyncCommitteeParticipants {
@@ -85,18 +85,18 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	header := state.LatestBlockHeader()
 	stateRoot, err := state.HashTreeRoot(ctx)
 	if err != nil {
-		return nil, fmt.Errorf("could not get state root %v", err)
+		return nil, fmt.Errorf("could not get state root %w", err)
 	}
 	header.StateRoot = stateRoot[:]
 
 	headerRoot, err := header.HashTreeRoot()
 	if err != nil {
-		return nil, fmt.Errorf("could not get header root %v", err)
+		return nil, fmt.Errorf("could not get header root %w", err)
 	}
 
 	blockRoot, err := block.Block().HashTreeRoot()
 	if err != nil {
-		return nil, fmt.Errorf("could not get block root %v", err)
+		return nil, fmt.Errorf("could not get block root %w", err)
 	}
 
 	if headerRoot != blockRoot {
@@ -114,14 +114,14 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	// attested_header.state_root = hash_tree_root(attested_state)
 	attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
 	if err != nil {
-		return nil, fmt.Errorf("could not get attested state root %v", err)
+		return nil, fmt.Errorf("could not get attested state root %w", err)
 	}
 	attestedHeader.StateRoot = attestedStateRoot[:]
 
 	// assert hash_tree_root(attested_header) == block.message.parent_root
 	attestedHeaderRoot, err := attestedHeader.HashTreeRoot()
 	if err != nil {
-		return nil, fmt.Errorf("could not get attested header root %v", err)
+		return nil, fmt.Errorf("could not get attested header root %w", err)
 	}
 
 	if attestedHeaderRoot != block.Block().ParentRoot() {
@@ -175,13 +175,13 @@ func NewLightClientFinalityUpdateFromBeaconState(
 		if finalizedBlock.Block().Slot() != 0 {
 			tempFinalizedHeader, err := finalizedBlock.Header()
 			if err != nil {
-				return nil, fmt.Errorf("could not get finalized header %v", err)
+				return nil, fmt.Errorf("could not get finalized header %w", err)
 			}
 			finalizedHeader = migration.V1Alpha1SignedHeaderToV1(tempFinalizedHeader).GetMessage()
 
 			finalizedHeaderRoot, err := finalizedHeader.HashTreeRoot()
 			if err != nil {
-				return nil, fmt.Errorf("could not get finalized header root %v", err)
+				return nil, fmt.Errorf("could not get finalized header root %w", err)
 			}
 
 			if finalizedHeaderRoot != bytesutil.ToBytes32(attestedState.FinalizedCheckpoint().Root) {
@@ -204,7 +204,7 @@ func NewLightClientFinalityUpdateFromBeaconState(
 		var bErr error
 		finalityBranch, bErr = attestedState.FinalizedRootProof(ctx)
 		if bErr != nil {
-			return nil, fmt.Errorf("could not get finalized root proof %v", bErr)
+			return nil, fmt.Errorf("could not get finalized root proof %w", bErr)
 		}
 	} else {
 		finalizedHeader = &ethpbv1.BeaconBlockHeader{

beacon-chain/blockchain/options.go

@@ -118,9 +118,9 @@ func WithBLSToExecPool(p blstoexec.PoolManager) Option {
 }
 
 // WithP2PBroadcaster to broadcast messages after appropriate processing.
-func WithP2PBroadcaster(p p2p.Broadcaster) Option {
+func WithP2PBroadcaster(p p2p.Acceser) Option {
 	return func(s *Service) error {
-		s.cfg.P2p = p
+		s.cfg.P2P = p
 		return nil
 	}
 }

beacon-chain/blockchain/process_block.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
@@ -32,6 +33,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // A custom slot deadline for processing state slots in our cache.
@@ -500,7 +503,7 @@ func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte
 	}
 	indices, err := bs.Indices(root)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "indices")
 	}
 	missing := make(map[uint64]struct{}, len(expected))
 	for i := range expected {
@@ -514,12 +517,35 @@ func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte
 	return missing, nil
 }
 
+func missingDataColumns(bs *filesystem.BlobStorage, root [32]byte, expected map[uint64]bool) (map[uint64]bool, error) {
+	if len(expected) == 0 {
+		return nil, nil
+	}
+	if len(expected) > int(params.BeaconConfig().NumberOfColumns) {
+		return nil, errMaxDataColumnsExceeded
+	}
+	indices, err := bs.ColumnIndices(root)
+	if err != nil {
+		return nil, err
+	}
+	missing := make(map[uint64]bool, len(expected))
+	for col := range expected {
+		if !indices[col] {
+			missing[col] = true
+		}
+	}
+	return missing, nil
+}
+
 // isDataAvailable blocks until all BlobSidecars committed to in the block are available,
 // or an error or context cancellation occurs. A nil result means that the data availability check is successful.
 // The function will first check the database to see if all sidecars have been persisted. If any
 // sidecars are missing, it will then read from the blobNotifier channel for the given root until the channel is
 // closed, the context hits cancellation/timeout, or notifications have been received for all the missing sidecars.
 func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
+	if coreTime.PeerDASIsActive(signed.Block().Slot()) {
+		return s.isDataAvailableDataColumns(ctx, root, signed)
+	}
 	if signed.Version() < version.Deneb {
 		return nil
 	}
@@ -549,7 +575,7 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 	// get a map of BlobSidecar indices that are not currently available.
 	missing, err := missingIndices(s.blobStorage, root, kzgCommitments)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "missing indices")
 	}
 	// If there are no missing indices, all BlobSidecars are available.
 	if len(missing) == 0 {
@@ -568,8 +594,13 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 			if len(missing) == 0 {
 				return
 			}
-			log.WithFields(daCheckLogFields(root, signed.Block().Slot(), expected, len(missing))).
-				Error("Still waiting for DA check at slot end.")
+
+			log.WithFields(logrus.Fields{
+				"slot":          signed.Block().Slot(),
+				"root":          fmt.Sprintf("%#x", root),
+				"blobsExpected": expected,
+				"blobsWaiting":  len(missing),
+			}).Error("Still waiting for blobs DA check at slot end.")
 		})
 		defer nst.Stop()
 	}
@@ -591,12 +622,100 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 	}
 }
 
-func daCheckLogFields(root [32]byte, slot primitives.Slot, expected, missing int) logrus.Fields {
-	return logrus.Fields{
-		"slot":          slot,
-		"root":          fmt.Sprintf("%#x", root),
-		"blobsExpected": expected,
-		"blobsWaiting":  missing,
+func (s *Service) isDataAvailableDataColumns(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
+	if signed.Version() < version.Deneb {
+		return nil
+	}
+
+	block := signed.Block()
+	if block == nil {
+		return errors.New("invalid nil beacon block")
+	}
+	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
+	if !params.WithinDAPeriod(slots.ToEpoch(block.Slot()), slots.ToEpoch(s.CurrentSlot())) {
+		return nil
+	}
+	body := block.Body()
+	if body == nil {
+		return errors.New("invalid nil beacon block body")
+	}
+	kzgCommitments, err := body.BlobKzgCommitments()
+	if err != nil {
+		return errors.Wrap(err, "could not get KZG commitments")
+	}
+	// If block has not commitments there is nothing to wait for.
+	if len(kzgCommitments) == 0 {
+		return nil
+	}
+
+	colMap, err := peerdas.CustodyColumns(s.cfg.P2P.NodeID(), peerdas.CustodySubnetCount())
+	if err != nil {
+		return err
+	}
+	// Expected is the number of custodied data columnns a node is expected to have.
+	expected := len(colMap)
+	if expected == 0 {
+		return nil
+	}
+
+	// Subscribe to newsly data columns stored in the database.
+	rootIndexChan := make(chan filesystem.RootIndexPair)
+	subscription := s.blobStorage.DataColumnFeed.Subscribe(rootIndexChan)
+	defer subscription.Unsubscribe()
+
+	// Get a map of data column indices that are not currently available.
+	missing, err := missingDataColumns(s.blobStorage, root, colMap)
+	if err != nil {
+		return err
+	}
+
+	// If there are no missing indices, all data column sidecars are available.
+	// This is the happy path.
+	if len(missing) == 0 {
+		return nil
+	}
+
+	// Log for DA checks that cross over into the next slot; helpful for debugging.
+	nextSlot := slots.BeginsAt(signed.Block().Slot()+1, s.genesisTime)
+	// Avoid logging if DA check is called after next slot start.
+	if nextSlot.After(time.Now()) {
+		nst := time.AfterFunc(time.Until(nextSlot), func() {
+			if len(missing) == 0 {
+				return
+			}
+
+			log.WithFields(logrus.Fields{
+				"slot":            signed.Block().Slot(),
+				"root":            fmt.Sprintf("%#x", root),
+				"columnsExpected": expected,
+				"columnsWaiting":  len(missing),
+			}).Error("Still waiting for data columns DA check at slot end.")
+		})
+		defer nst.Stop()
+	}
+	for {
+		select {
+		case rootIndex := <-rootIndexChan:
+			if rootIndex.Root != root {
+				// This is not the root we are looking for.
+				continue
+			}
+
+			// Remove the index from the missing map.
+			delete(missing, rootIndex.Index)
+
+			// Exit if there is no more missing data columns.
+			if len(missing) == 0 {
+				return nil
+			}
+		case <-ctx.Done():
+			missingIndexes := make([]uint64, 0, len(missing))
+			for val := range missing {
+				copiedVal := val
+				missingIndexes = append(missingIndexes, copiedVal)
+			}
+			return errors.Wrapf(ctx.Err(), "context deadline waiting for data column sidecars slot: %d, BlockRoot: %#x, missing %v", block.Slot(), root, missingIndexes)
+		}
 	}
 }
 

beacon-chain/blockchain/process_block_helpers.go

@@ -7,9 +7,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
@@ -25,6 +22,8 @@ import (
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // CurrentSlot returns the current slot based on time.

beacon-chain/blockchain/receive_block.go

@@ -13,6 +13,7 @@ import (
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/slasher/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -50,6 +51,12 @@ type BlobReceiver interface {
 	ReceiveBlob(context.Context, blocks.VerifiedROBlob) error
 }
 
+// DataColumnReceiver interface defines the methods of chain service for receiving new
+// data columns
+type DataColumnReceiver interface {
+	ReceiveDataColumn(context.Context, blocks.VerifiedRODataColumn) error
+}
+
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
 	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)
@@ -169,13 +176,8 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 	// Send finalized events and finalized deposits in the background
 	if newFinalized {
-		finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
-		go s.sendNewFinalizedEvent(ctx, postState)
-		depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
-		go func() {
-			s.insertFinalizedDeposits(depCtx, finalized.Root)
-			cancel()
-		}()
+		// hook to process all post state finalization tasks
+		s.executePostFinalizationTasks(ctx, postState)
 	}
 
 	// If slasher is configured, forward the attestations in the block via an event feed for processing.
@@ -224,6 +226,19 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	return nil
 }
 
+func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedState state.BeaconState) {
+	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
+	go func() {
+		finalizedState.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
+		s.sendNewFinalizedEvent(ctx, finalizedState)
+	}()
+	depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
+	go func() {
+		s.insertFinalizedDeposits(depCtx, finalized.Root)
+		cancel()
+	}()
+}
+
 // ReceiveBlockBatch processes the whole block batch at once, assuming the block batch is linear ,transitioning
 // the state, performing batch verification of all collected signatures and then performing the appropriate
 // actions for a block post-transition.
@@ -489,7 +504,7 @@ func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySigne
 			log.WithError(err).Error("Could not convert to indexed attestation")
 			return
 		}
-		s.cfg.SlasherAttestationsFeed.Send(indexedAtt)
+		s.cfg.SlasherAttestationsFeed.Send(&types.WrappedIndexedAtt{IndexedAtt: indexedAtt})
 	}
 }
 

beacon-chain/blockchain/receive_block_test.go

@@ -6,11 +6,14 @@ import (
 	"testing"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	blockchainTesting "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/voluntaryexits"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
+	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/primitives"
@@ -20,6 +23,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
@@ -415,3 +419,81 @@ func Test_sendNewFinalizedEvent(t *testing.T) {
 	assert.DeepEqual(t, finalizedStRoot[:], fc.State)
 	assert.Equal(t, false, fc.ExecutionOptimistic)
 }
+
+func Test_executePostFinalizationTasks(t *testing.T) {
+	resetFn := features.InitWithReset(&features.Flags{
+		EIP6110ValidatorIndexCache: true,
+	})
+	defer resetFn()
+
+	logHook := logTest.NewGlobal()
+
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	finalizedStRoot, err := headState.HashTreeRoot(context.Background())
+	require.NoError(t, err)
+
+	genesis := util.NewBeaconBlock()
+	genesisRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err)
+	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*122 + 1
+	headBlock := util.NewBeaconBlock()
+	headBlock.Block.Slot = finalizedSlot
+	headBlock.Block.StateRoot = finalizedStRoot[:]
+	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
+	headRoot, err := headBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	hexKey := "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+	key, err := hexutil.Decode(hexKey)
+	require.NoError(t, err)
+	require.NoError(t, headState.SetValidators([]*ethpb.Validator{
+		{
+			PublicKey:             key,
+			WithdrawalCredentials: make([]byte, fieldparams.RootLength),
+		},
+	}))
+	require.NoError(t, headState.SetSlot(finalizedSlot))
+	require.NoError(t, headState.SetFinalizedCheckpoint(&ethpb.Checkpoint{
+		Epoch: 123,
+		Root:  headRoot[:],
+	}))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
+
+	s, tr := minimalTestService(t, WithFinalizedStateAtStartUp(headState))
+	ctx, beaconDB, stateGen := tr.ctx, tr.db, tr.sg
+
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
+	util.SaveBlock(t, ctx, beaconDB, genesis)
+	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
+	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
+	util.SaveBlock(t, ctx, beaconDB, headBlock)
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
+
+	require.NoError(t, err)
+	require.NoError(t, stateGen.SaveState(ctx, headRoot, headState))
+	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
+
+	notifier := &blockchainTesting.MockStateNotifier{RecordEvents: true}
+	s.cfg.StateNotifier = notifier
+	s.executePostFinalizationTasks(s.ctx, headState)
+
+	time.Sleep(1 * time.Second) // sleep for a second because event is in a separate go routine
+	require.Equal(t, 1, len(notifier.ReceivedEvents()))
+	e := notifier.ReceivedEvents()[0]
+	assert.Equal(t, statefeed.FinalizedCheckpoint, int(e.Type))
+	fc, ok := e.Data.(*ethpbv1.EventFinalizedCheckpoint)
+	require.Equal(t, true, ok, "event has wrong data type")
+	assert.Equal(t, primitives.Epoch(123), fc.Epoch)
+	assert.DeepEqual(t, headRoot[:], fc.Block)
+	assert.DeepEqual(t, finalizedStRoot[:], fc.State)
+	assert.Equal(t, false, fc.ExecutionOptimistic)
+
+	// check the cache
+	index, ok := headState.ValidatorIndexByPubkey(bytesutil.ToBytes48(key))
+	require.Equal(t, true, ok)
+	require.Equal(t, primitives.ValidatorIndex(0), index) // first index
+
+	// check deposit
+	require.LogsContain(t, logHook, "Finalized deposit insertion completed at index")
+}

beacon-chain/blockchain/receive_data_column.go

@@ -0,0 +1,16 @@
+package blockchain
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+)
+
+func (s *Service) ReceiveDataColumn(ctx context.Context, ds blocks.VerifiedRODataColumn) error {
+	if err := s.blobStorage.SaveDataColumn(ds); err != nil {
+		return errors.Wrap(err, "save data column")
+	}
+
+	return nil
+}

beacon-chain/blockchain/service.go

@@ -11,8 +11,6 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
@@ -44,6 +42,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // Service represents a service that handles the internal
@@ -82,7 +81,7 @@ type config struct {
 	ExitPool                voluntaryexits.PoolManager
 	SlashingPool            slashings.PoolManager
 	BLSToExecPool           blstoexec.PoolManager
-	P2p                     p2p.Broadcaster
+	P2P                     p2p.Acceser
 	MaxRoutines             int
 	StateNotifier           statefeed.Notifier
 	ForkChoiceStore         f.ForkChoicer
@@ -107,15 +106,17 @@ var ErrMissingClockSetter = errors.New("blockchain Service initialized without a
 type blobNotifierMap struct {
 	sync.RWMutex
 	notifiers map[[32]byte]chan uint64
-	seenIndex map[[32]byte][fieldparams.MaxBlobsPerBlock]bool
+	seenIndex map[[32]byte][fieldparams.NumberOfColumns]bool
 }
 
 // notifyIndex notifies a blob by its index for a given root.
 // It uses internal maps to keep track of seen indices and notifier channels.
 func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
-	if idx >= fieldparams.MaxBlobsPerBlock {
-		return
-	}
+	// TODO: Separate Data Columns from blobs
+	/*
+		if idx >= fieldparams.MaxBlobsPerBlock {
+			return
+		}*/
 
 	bn.Lock()
 	seen := bn.seenIndex[root]
@@ -129,7 +130,7 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
 	// Retrieve or create the notifier channel for the given root.
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
+		c = make(chan uint64, fieldparams.NumberOfColumns)
 		bn.notifiers[root] = c
 	}
 
@@ -143,7 +144,7 @@ func (bn *blobNotifierMap) forRoot(root [32]byte) chan uint64 {
 	defer bn.Unlock()
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
+		c = make(chan uint64, fieldparams.NumberOfColumns)
 		bn.notifiers[root] = c
 	}
 	return c
@@ -169,7 +170,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	bn := &blobNotifierMap{
 		notifiers: make(map[[32]byte]chan uint64),
-		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
+		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
 	}
 	srv := &Service{
 		ctx:                  ctx,
@@ -330,6 +331,8 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
 
+	saved.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
+
 	return nil
 }
 
@@ -504,7 +507,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	}
 	genesisBlk, err := s.cfg.BeaconDB.GenesisBlock(ctx)
 	if err != nil || genesisBlk == nil || genesisBlk.IsNil() {
-		return fmt.Errorf("could not load genesis block: %v", err)
+		return fmt.Errorf("could not load genesis block: %w", err)
 	}
 	genesisBlkRoot, err := genesisBlk.Block().HashTreeRoot()
 	if err != nil {

beacon-chain/blockchain/service_test.go

@@ -8,9 +8,10 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache/depositsnapshot"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
@@ -29,6 +30,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "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/container/trie"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -95,7 +97,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		WithAttestationPool(attestations.NewPool()),
 		WithSlashingPool(slashings.NewPool()),
 		WithExitPool(voluntaryexits.NewPool()),
-		WithP2PBroadcaster(&mockBroadcaster{}),
+		WithP2PBroadcaster(&mockAccesser{}),
 		WithStateNotifier(&mockBeaconNode{}),
 		WithForkChoiceStore(fc),
 		WithAttestationService(attService),
@@ -203,7 +205,7 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 		BlockHash:    make([]byte, 32),
 	})
 	require.NoError(t, err)
-	genState, err = blocks.ProcessPreGenesisDeposits(ctx, genState, deposits)
+	genState, err = altair.ProcessPreGenesisDeposits(ctx, genState, deposits)
 	require.NoError(t, err)
 
 	_, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{DepositRoot: hashTreeRoot[:], BlockHash: make([]byte, 32)})
@@ -499,6 +501,66 @@ func TestChainService_EverythingOptimistic(t *testing.T) {
 	require.Equal(t, true, op)
 }
 
+func TestStartFromSavedState_ValidatorIndexCacheUpdated(t *testing.T) {
+	resetFn := features.InitWithReset(&features.Flags{
+		EnableStartOptimistic:      true,
+		EIP6110ValidatorIndexCache: true,
+	})
+	defer resetFn()
+
+	genesis := util.NewBeaconBlock()
+	genesisRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err)
+	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
+	headBlock := util.NewBeaconBlock()
+	headBlock.Block.Slot = finalizedSlot
+	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	hexKey := "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+	key, err := hexutil.Decode(hexKey)
+	require.NoError(t, err)
+	hexKey2 := "0x42247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+	key2, err := hexutil.Decode(hexKey2)
+	require.NoError(t, err)
+	require.NoError(t, headState.SetValidators([]*ethpb.Validator{
+		{
+			PublicKey:             key,
+			WithdrawalCredentials: make([]byte, fieldparams.RootLength),
+		},
+		{
+			PublicKey:             key2,
+			WithdrawalCredentials: make([]byte, fieldparams.RootLength),
+		},
+	}))
+	require.NoError(t, headState.SetSlot(finalizedSlot))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
+	headRoot, err := headBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	c, tr := minimalTestService(t, WithFinalizedStateAtStartUp(headState))
+	ctx, beaconDB, stateGen := tr.ctx, tr.db, tr.sg
+
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
+	util.SaveBlock(t, ctx, beaconDB, genesis)
+	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
+	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
+	util.SaveBlock(t, ctx, beaconDB, headBlock)
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
+
+	require.NoError(t, err)
+	require.NoError(t, stateGen.SaveState(ctx, headRoot, headState))
+	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
+	require.NoError(t, c.StartFromSavedState(headState))
+
+	index, ok := headState.ValidatorIndexByPubkey(bytesutil.ToBytes48(key))
+	require.Equal(t, true, ok)
+	require.Equal(t, primitives.ValidatorIndex(0), index) // first index
+	index2, ok := headState.ValidatorIndexByPubkey(bytesutil.ToBytes48(key2))
+	require.Equal(t, true, ok)
+	require.Equal(t, primitives.ValidatorIndex(1), index2) // first index
+}
+
 // MockClockSetter satisfies the ClockSetter interface for testing the conditions where blockchain.Service should
 // call SetGenesis.
 type MockClockSetter struct {
@@ -518,7 +580,7 @@ func (s *MockClockSetter) SetClock(g *startup.Clock) error {
 func TestNotifyIndex(t *testing.T) {
 	// Initialize a blobNotifierMap
 	bn := &blobNotifierMap{
-		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
+		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
 		notifiers: make(map[[32]byte]chan uint64),
 	}
 

beacon-chain/blockchain/setup_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
+	p2pTesting "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -45,6 +46,11 @@ type mockBroadcaster struct {
 	broadcastCalled bool
 }
 
+type mockAccesser struct {
+	mockBroadcaster
+	p2pTesting.MockPeerManager
+}
+
 func (mb *mockBroadcaster) Broadcast(_ context.Context, _ proto.Message) error {
 	mb.broadcastCalled = true
 	return nil
@@ -65,6 +71,11 @@ func (mb *mockBroadcaster) BroadcastBlob(_ context.Context, _ uint64, _ *ethpb.B
 	return nil
 }
 
+func (mb *mockBroadcaster) BroadcastDataColumn(_ context.Context, _ uint64, _ *ethpb.DataColumnSidecar) error {
+	mb.broadcastCalled = true
+	return nil
+}
+
 func (mb *mockBroadcaster) BroadcastBLSChanges(_ context.Context, _ []*ethpb.SignedBLSToExecutionChange) {
 }
 

beacon-chain/blockchain/testing/mock.go

@@ -628,6 +628,11 @@ func (c *ChainService) ReceiveBlob(_ context.Context, b blocks.VerifiedROBlob) e
 	return nil
 }
 
+// ReceiveDataColumn implements the same method in chain service
+func (c *ChainService) ReceiveDataColumn(_ context.Context, _ blocks.VerifiedRODataColumn) error {
+	return nil
+}
+
 // TargetRootForEpoch mocks the same method in the chain service
 func (c *ChainService) TargetRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil

beacon-chain/cache/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
         "attestation_data.go",
         "balance_cache_key.go",
         "checkpoint_state.go",
+        "column_subnet_ids.go",
         "committee.go",
         "committee_disabled.go",  # keep
         "committees.go",

beacon-chain/cache/column_subnet_ids.go

@@ -0,0 +1,65 @@
+package cache
+
+import (
+	"sync"
+	"time"
+
+	"github.com/patrickmn/go-cache"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+)
+
+type columnSubnetIDs struct {
+	colSubCache *cache.Cache
+	colSubLock  sync.RWMutex
+}
+
+// ColumnSubnetIDs for column subnet participants
+var ColumnSubnetIDs = newColumnSubnetIDs()
+
+const columnKey = "columns"
+
+func newColumnSubnetIDs() *columnSubnetIDs {
+	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
+	// Set the default duration of a column subnet subscription as the column expiry period.
+	subLength := epochDuration * time.Duration(params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest)
+	persistentCache := cache.New(subLength*time.Second, epochDuration*time.Second)
+	return &columnSubnetIDs{colSubCache: persistentCache}
+}
+
+// GetColumnSubnets retrieves the data column subnets.
+func (s *columnSubnetIDs) GetColumnSubnets() ([]uint64, bool, time.Time) {
+	s.colSubLock.RLock()
+	defer s.colSubLock.RUnlock()
+
+	id, duration, ok := s.colSubCache.GetWithExpiration(columnKey)
+	if !ok {
+		return nil, false, time.Time{}
+	}
+	// Retrieve indices from the cache.
+	idxs, ok := id.([]uint64)
+	if !ok {
+		return nil, false, time.Time{}
+	}
+
+	return idxs, ok, duration
+}
+
+// AddColumnSubnets adds the relevant data column subnets.
+func (s *columnSubnetIDs) AddColumnSubnets(colIdx []uint64) {
+	s.colSubLock.Lock()
+	defer s.colSubLock.Unlock()
+
+	s.colSubCache.Set(columnKey, colIdx, 0)
+}
+
+// EmptyAllCaches empties out all the related caches and flushes any stored
+// entries on them. This should only ever be used for testing, in normal
+// production, handling of the relevant subnets for each role is done
+// separately.
+func (s *columnSubnetIDs) EmptyAllCaches() {
+	// Clear the cache.
+	s.colSubLock.Lock()
+	defer s.colSubLock.Unlock()
+
+	s.colSubCache.Flush()
+}

beacon-chain/core/altair/BUILD.bazel

@@ -36,6 +36,7 @@ go_library(
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
+        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
@@ -78,6 +79,7 @@ go_test(
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation: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/core/altair/deposit.go

@@ -5,11 +5,32 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"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/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
+// ProcessPreGenesisDeposits processes a deposit for the beacon state before chainstart.
+func ProcessPreGenesisDeposits(
+	ctx context.Context,
+	beaconState state.BeaconState,
+	deposits []*ethpb.Deposit,
+) (state.BeaconState, error) {
+	var err error
+	beaconState, err = ProcessDeposits(ctx, beaconState, deposits)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process deposit")
+	}
+	beaconState, err = blocks.ActivateValidatorWithEffectiveBalance(beaconState, deposits)
+	if err != nil {
+		return nil, err
+	}
+	return beaconState, nil
+}
+
 // ProcessDeposits processes validator deposits for beacon state Altair.
 func ProcessDeposits(
 	ctx context.Context,
@@ -33,23 +54,158 @@ func ProcessDeposits(
 	return beaconState, nil
 }
 
-// ProcessDeposit processes validator deposit for beacon state Altair.
+// ProcessDeposit takes in a deposit object and inserts it
+// into the registry as a new validator or balance change.
+// Returns the resulting state, a boolean to indicate whether or not the deposit
+// resulted in a new validator entry into the beacon state, and any error.
+//
+// Spec pseudocode definition:
+// def process_deposit(state: BeaconState, deposit: Deposit) -> None:
+//
+//	# Verify the Merkle branch
+//	assert is_valid_merkle_branch(
+//		leaf=hash_tree_root(deposit.data),
+//		branch=deposit.proof,
+//		depth=DEPOSIT_CONTRACT_TREE_DEPTH + 1,  # Add 1 for the List length mix-in
+//		index=state.eth1_deposit_index,
+//		root=state.eth1_data.deposit_root,
+//	)
+//
+//	 # Deposits must be processed in order
+//	 state.eth1_deposit_index += 1
+//
+//	 apply_deposit(
+//	  state=state,
+//	  pubkey=deposit.data.pubkey,
+//	  withdrawal_credentials=deposit.data.withdrawal_credentials,
+//	  amount=deposit.data.amount,
+//	  signature=deposit.data.signature,
+//	 )
 func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
-	beaconState, isNewValidator, err := blocks.ProcessDeposit(beaconState, deposit, verifySignature)
-	if err != nil {
+	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
+		if deposit == nil || deposit.Data == nil {
+			return nil, err
+		}
+		return nil, errors.Wrapf(err, "could not verify deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
+	}
+	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
 		return nil, err
 	}
-	if isNewValidator {
-		if err := beaconState.AppendInactivityScore(0); err != nil {
+
+	return ApplyDeposit(beaconState, deposit.Data, verifySignature)
+}
+
+// ApplyDeposit
+// Spec pseudocode definition:
+// def apply_deposit(state: BeaconState, pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> None:
+//
+//	validator_pubkeys = [v.pubkey for v in state.validators]
+//	if pubkey not in validator_pubkeys:
+//	    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//	    deposit_message = DepositMessage(
+//	        pubkey=pubkey,
+//	        withdrawal_credentials=withdrawal_credentials,
+//	        amount=amount,
+//	    )
+//	    domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
+//	    signing_root = compute_signing_root(deposit_message, domain)
+//	    if bls.Verify(pubkey, signing_root, signature):
+//	        add_validator_to_registry(state, pubkey, withdrawal_credentials, amount)
+//	else:
+//	    # Increase balance by deposit amount
+//	    index = ValidatorIndex(validator_pubkeys.index(pubkey))
+//	    increase_balance(state, index, amount)
+func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
+	pubKey := data.PublicKey
+	amount := data.Amount
+	withdrawalCredentials := data.WithdrawalCredentials
+	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
+	if !ok {
+		if verifySignature {
+			valid, err := blocks.IsValidDepositSignature(data)
+			if err != nil {
+				return nil, err
+			}
+			if !valid {
+				return beaconState, nil
+			}
+		}
+		if err := AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, amount); err != nil {
 			return nil, err
 		}
-		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
-			return nil, err
-		}
-		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
+	} else {
+		if err := helpers.IncreaseBalance(beaconState, index, amount); err != nil {
 			return nil, err
 		}
 	}
-
 	return beaconState, nil
 }
+
+// AddValidatorToRegistry updates the beacon state with validator information
+// def add_validator_to_registry(state: BeaconState,
+//
+//	                          pubkey: BLSPubkey,
+//	                          withdrawal_credentials: Bytes32,
+//	                          amount: uint64) -> None:
+//	index = get_index_for_new_validator(state)
+//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials)
+//	set_or_append_list(state.validators, index, validator)
+//	set_or_append_list(state.balances, index, 0)
+//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
+//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
+//	set_or_append_list(state.inactivity_scores, index, uint64(0)) // New in Altair
+func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
+	val := GetValidatorFromDeposit(pubKey, withdrawalCredentials, amount)
+	if err := beaconState.AppendValidator(val); err != nil {
+		return err
+	}
+	if err := beaconState.AppendBalance(amount); err != nil {
+		return err
+	}
+
+	// only active in altair and only when it's a new validator (after append balance)
+	if beaconState.Version() >= version.Altair {
+		if err := beaconState.AppendInactivityScore(0); err != nil {
+			return err
+		}
+		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
+			return err
+		}
+		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetValidatorFromDeposit gets a new validator object with provided parameters
+//
+// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64) -> Validator:
+//
+//	effective_balance = min(amount - amount % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)
+//
+//	return Validator(
+//	    pubkey=pubkey,
+//	    withdrawal_credentials=withdrawal_credentials,
+//	    activation_eligibility_epoch=FAR_FUTURE_EPOCH,
+//	    activation_epoch=FAR_FUTURE_EPOCH,
+//	    exit_epoch=FAR_FUTURE_EPOCH,
+//	    withdrawable_epoch=FAR_FUTURE_EPOCH,
+//	    effective_balance=effective_balance,
+//	)
+func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
+	effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
+	if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
+		effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
+	}
+
+	return &ethpb.Validator{
+		PublicKey:                  pubKey,
+		WithdrawalCredentials:      withdrawalCredentials,
+		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
+		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+		EffectiveBalance:           effectiveBalance,
+	}
+}

beacon-chain/core/altair/deposit_fuzz_test.go

@@ -30,6 +30,59 @@ func TestFuzzProcessDeposits_10000(t *testing.T) {
 	}
 }
 
+func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
+	fuzzer := fuzz.NewWithSeed(0)
+	state := &ethpb.BeaconStateAltair{}
+	deposit := &ethpb.Deposit{}
+	ctx := context.Background()
+
+	for i := 0; i < 10000; i++ {
+		fuzzer.Fuzz(state)
+		fuzzer.Fuzz(deposit)
+		s, err := state_native.InitializeFromProtoUnsafeAltair(state)
+		require.NoError(t, err)
+		r, err := altair.ProcessPreGenesisDeposits(ctx, s, []*ethpb.Deposit{deposit})
+		if err != nil && r != nil {
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
+		}
+	}
+}
+
+func TestFuzzProcessPreGenesisDeposit_Phase0_10000(t *testing.T) {
+	fuzzer := fuzz.NewWithSeed(0)
+	state := &ethpb.BeaconState{}
+	deposit := &ethpb.Deposit{}
+	ctx := context.Background()
+
+	for i := 0; i < 10000; i++ {
+		fuzzer.Fuzz(state)
+		fuzzer.Fuzz(deposit)
+		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
+		require.NoError(t, err)
+		r, err := altair.ProcessPreGenesisDeposits(ctx, s, []*ethpb.Deposit{deposit})
+		if err != nil && r != nil {
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
+		}
+	}
+}
+
+func TestFuzzProcessDeposit_Phase0_10000(t *testing.T) {
+	fuzzer := fuzz.NewWithSeed(0)
+	state := &ethpb.BeaconState{}
+	deposit := &ethpb.Deposit{}
+
+	for i := 0; i < 10000; i++ {
+		fuzzer.Fuzz(state)
+		fuzzer.Fuzz(deposit)
+		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
+		require.NoError(t, err)
+		r, err := altair.ProcessDeposit(s, deposit, true)
+		if err != nil && r != nil {
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
+		}
+	}
+}
+
 func TestFuzzProcessDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconStateAltair{}

beacon-chain/core/altair/deposit_test.go

@@ -7,11 +7,14 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
 	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/container/trie"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	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"
 )
@@ -44,36 +47,6 @@ func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
 	require.Equal(t, 2, len(newState.Validators()), "Incorrect validator count")
 }
 
-func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
-	deposit := &ethpb.Deposit{
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
-			WithdrawalCredentials: make([]byte, 32),
-			Signature:             make([]byte, 96),
-		},
-	}
-	leaf, err := deposit.Data.HashTreeRoot()
-	require.NoError(t, err)
-
-	// We then create a merkle branch for the test.
-	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
-	require.NoError(t, err, "Could not generate trie")
-	proof, err := depositTrie.MerkleProof(0)
-	require.NoError(t, err, "Could not generate proof")
-
-	deposit.Proof = proof
-	beaconState, err := state_native.InitializeFromProtoAltair(&ethpb.BeaconStateAltair{
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: []byte{0},
-			BlockHash:   []byte{1},
-		},
-	})
-	require.NoError(t, err)
-	want := "deposit root did not verify"
-	_, err = altair.ProcessDeposits(context.Background(), beaconState, []*ethpb.Deposit{deposit})
-	require.ErrorContains(t, want, err)
-}
-
 func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
 	dep, _, err := util.DeterministicDepositsAndKeys(1)
 	require.NoError(t, err)
@@ -245,3 +218,158 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 		t.Errorf("Expected validator balance at index 0 to stay 0, received: %v", newState.Balances()[0])
 	}
 }
+
+func TestPreGenesisDeposits_SkipInvalidDeposit(t *testing.T) {
+
+	dep, _, err := util.DeterministicDepositsAndKeys(100)
+	require.NoError(t, err)
+	dep[0].Data.Signature = make([]byte, 96)
+	dt, _, err := util.DepositTrieFromDeposits(dep)
+	require.NoError(t, err)
+
+	for i := range dep {
+		proof, err := dt.MerkleProof(i)
+		require.NoError(t, err)
+		dep[i].Proof = proof
+	}
+	root, err := dt.HashTreeRoot()
+	require.NoError(t, err)
+
+	eth1Data := &ethpb.Eth1Data{
+		DepositRoot:  root[:],
+		DepositCount: 1,
+	}
+	registry := []*ethpb.Validator{
+		{
+			PublicKey:             []byte{1},
+			WithdrawalCredentials: []byte{1, 2, 3},
+		},
+	}
+	balances := []uint64{0}
+	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data:   eth1Data,
+		Fork: &ethpb.Fork{
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+		},
+	})
+	require.NoError(t, err)
+	newState, err := altair.ProcessPreGenesisDeposits(context.Background(), beaconState, dep)
+	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
+
+	_, ok := newState.ValidatorIndexByPubkey(bytesutil.ToBytes48(dep[0].Data.PublicKey))
+	require.Equal(t, false, ok, "bad pubkey should not exist in state")
+
+	for i := 1; i < newState.NumValidators(); i++ {
+		val, err := newState.ValidatorAtIndex(primitives.ValidatorIndex(i))
+		require.NoError(t, err)
+		require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, val.EffectiveBalance, "unequal effective balance")
+		require.Equal(t, primitives.Epoch(0), val.ActivationEpoch)
+		require.Equal(t, primitives.Epoch(0), val.ActivationEligibilityEpoch)
+	}
+	if newState.Eth1DepositIndex() != 100 {
+		t.Errorf(
+			"Expected Eth1DepositIndex to be increased by 99 after processing an invalid deposit, received change: %v",
+			newState.Eth1DepositIndex(),
+		)
+	}
+	if len(newState.Validators()) != 100 {
+		t.Errorf("Expected validator list to have length 100, received: %v", len(newState.Validators()))
+	}
+	if len(newState.Balances()) != 100 {
+		t.Errorf("Expected validator balances list to have length 100, received: %v", len(newState.Balances()))
+	}
+	if newState.Balances()[0] != 0 {
+		t.Errorf("Expected validator balance at index 0 to stay 0, received: %v", newState.Balances()[0])
+	}
+}
+
+func TestProcessDeposit_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey:             sk.PublicKey().Marshal(),
+			Amount:                1000,
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, 96),
+		},
+	}
+	sr, err := signing.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 32))
+	require.NoError(t, err)
+	sig := sk.Sign(sr[:])
+	deposit.Data.Signature = sig.Marshal()
+	leaf, err := deposit.Data.HashTreeRoot()
+	require.NoError(t, err)
+
+	// We then create a merkle branch for the test.
+	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
+	require.NoError(t, err, "Could not generate trie")
+	proof, err := depositTrie.MerkleProof(0)
+	require.NoError(t, err, "Could not generate proof")
+
+	deposit.Proof = proof
+	registry := []*ethpb.Validator{
+		{
+			PublicKey: []byte{1, 2, 3},
+		},
+		{
+			PublicKey:             sk.PublicKey().Marshal(),
+			WithdrawalCredentials: []byte{1},
+		},
+	}
+	balances := []uint64{0, 50}
+	root, err := depositTrie.HashTreeRoot()
+	require.NoError(t, err)
+
+	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data: &ethpb.Eth1Data{
+			DepositRoot: root[:],
+			BlockHash:   root[:],
+		},
+	})
+	require.NoError(t, err)
+	newState, err := altair.ProcessDeposit(beaconState, deposit, true /*verifySignature*/)
+	require.NoError(t, err, "Process deposit failed")
+	require.Equal(t, uint64(1000+50), newState.Balances()[1], "Expected balance at index 1 to be 1050")
+}
+
+func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, fieldparams.BLSPubkeyLength),
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, fieldparams.BLSSignatureLength),
+		},
+	}
+	leaf, err := deposit.Data.HashTreeRoot()
+	require.NoError(t, err)
+
+	// We then create a merkle branch for the test.
+	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
+	require.NoError(t, err, "Could not generate trie")
+	proof, err := depositTrie.MerkleProof(0)
+	require.NoError(t, err, "Could not generate proof")
+
+	deposit.Proof = proof
+	b := util.NewBeaconBlock()
+	b.Block = &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Deposits: []*ethpb.Deposit{deposit},
+		},
+	}
+	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+		Eth1Data: &ethpb.Eth1Data{
+			DepositRoot: []byte{0},
+			BlockHash:   []byte{1},
+		},
+	})
+	require.NoError(t, err)
+	want := "deposit root did not verify"
+	_, err = altair.ProcessDeposits(context.Background(), beaconState, b.Block.Body.Deposits)
+	assert.ErrorContains(t, want, err)
+}

beacon-chain/core/altair/sync_committee.go

@@ -18,6 +18,7 @@ import (
 	"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/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -101,7 +102,8 @@ func NextSyncCommittee(ctx context.Context, s state.BeaconState) (*ethpb.SyncCom
 //	    candidate_index = active_validator_indices[shuffled_index]
 //	    random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32]
 //	    effective_balance = state.validators[candidate_index].effective_balance
-//	    if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte:
+//	    # [Modified in Electra:EIP7251]
+//	    if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_byte:
 //	        sync_committee_indices.append(candidate_index)
 //	    i += 1
 //	return sync_committee_indices
@@ -121,6 +123,11 @@ func NextSyncCommitteeIndices(ctx context.Context, s state.BeaconState) ([]primi
 	cIndices := make([]primitives.ValidatorIndex, 0, syncCommitteeSize)
 	hashFunc := hash.CustomSHA256Hasher()
 
+	maxEB := cfg.MaxEffectiveBalanceElectra
+	if s.Version() < version.Electra {
+		maxEB = cfg.MaxEffectiveBalance
+	}
+
 	for i := primitives.ValidatorIndex(0); uint64(len(cIndices)) < params.BeaconConfig().SyncCommitteeSize; i++ {
 		if ctx.Err() != nil {
 			return nil, ctx.Err()
@@ -140,7 +147,7 @@ func NextSyncCommitteeIndices(ctx context.Context, s state.BeaconState) ([]primi
 		}
 
 		effectiveBal := v.EffectiveBalance()
-		if effectiveBal*maxRandomByte >= cfg.MaxEffectiveBalance*uint64(randomByte) {
+		if effectiveBal*maxRandomByte >= maxEB*uint64(randomByte) {
 			cIndices = append(cIndices, cIndex)
 		}
 	}

beacon-chain/core/altair/sync_committee_test.go

@@ -13,13 +13,14 @@ import (
 	"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/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 )
 
 func TestSyncCommitteeIndices_CanGet(t *testing.T) {
-	getState := func(t *testing.T, count uint64) state.BeaconState {
+	getState := func(t *testing.T, count uint64, vers int) state.BeaconState {
 		validators := make([]*ethpb.Validator, count)
 		for i := 0; i < len(validators); i++ {
 			validators[i] = &ethpb.Validator{
@@ -27,17 +28,28 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 				EffectiveBalance: params.BeaconConfig().MinDepositAmount,
 			}
 		}
-		st, err := state_native.InitializeFromProtoAltair(&ethpb.BeaconStateAltair{
-			RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-		})
+		var st state.BeaconState
+		var err error
+		switch vers {
+		case version.Altair:
+			st, err = state_native.InitializeFromProtoAltair(&ethpb.BeaconStateAltair{
+				RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+			})
+		case version.Electra:
+			st, err = state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{
+				RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+			})
+		default:
+			t.Fatal("Unknown version")
+		}
 		require.NoError(t, err)
 		require.NoError(t, st.SetValidators(validators))
 		return st
 	}
 
 	type args struct {
-		state state.BeaconState
-		epoch primitives.Epoch
+		validatorCount uint64
+		epoch          primitives.Epoch
 	}
 	tests := []struct {
 		name      string
@@ -48,32 +60,32 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 		{
 			name: "genesis validator count, epoch 0",
 			args: args{
-				state: getState(t, params.BeaconConfig().MinGenesisActiveValidatorCount),
-				epoch: 0,
+				validatorCount: params.BeaconConfig().MinGenesisActiveValidatorCount,
+				epoch:          0,
 			},
 			wantErr: false,
 		},
 		{
 			name: "genesis validator count, epoch 100",
 			args: args{
-				state: getState(t, params.BeaconConfig().MinGenesisActiveValidatorCount),
-				epoch: 100,
+				validatorCount: params.BeaconConfig().MinGenesisActiveValidatorCount,
+				epoch:          100,
 			},
 			wantErr: false,
 		},
 		{
 			name: "less than optimal validator count, epoch 100",
 			args: args{
-				state: getState(t, params.BeaconConfig().MaxValidatorsPerCommittee),
-				epoch: 100,
+				validatorCount: params.BeaconConfig().MaxValidatorsPerCommittee,
+				epoch:          100,
 			},
 			wantErr: false,
 		},
 		{
 			name: "no active validators, epoch 100",
 			args: args{
-				state: getState(t, 0), // Regression test for divide by zero. Issue #13051.
-				epoch: 100,
+				validatorCount: 0, // Regression test for divide by zero. Issue #13051.
+				epoch:          100,
 			},
 			wantErr:   true,
 			errString: "no active validator indices",
@@ -81,13 +93,18 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			helpers.ClearCache()
-			got, err := altair.NextSyncCommitteeIndices(context.Background(), tt.args.state)
-			if tt.wantErr {
-				require.ErrorContains(t, tt.errString, err)
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, int(params.BeaconConfig().SyncCommitteeSize), len(got))
+			for _, v := range []int{version.Altair, version.Electra} {
+				t.Run(version.String(v), func(t *testing.T) {
+					helpers.ClearCache()
+					st := getState(t, tt.args.validatorCount, v)
+					got, err := altair.NextSyncCommitteeIndices(context.Background(), st)
+					if tt.wantErr {
+						require.ErrorContains(t, tt.errString, err)
+					} else {
+						require.NoError(t, err)
+						require.Equal(t, int(params.BeaconConfig().SyncCommitteeSize), len(got))
+					}
+				})
 			}
 		})
 	}

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -297,60 +297,6 @@ func TestFuzzVerifyIndexedAttestationn_10000(t *testing.T) {
 	}
 }
 
-func TestFuzzProcessDeposits_10000(t *testing.T) {
-	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethpb.BeaconState{}
-	deposits := make([]*ethpb.Deposit, 100)
-	ctx := context.Background()
-	for i := 0; i < 10000; i++ {
-		fuzzer.Fuzz(state)
-		for i := range deposits {
-			fuzzer.Fuzz(deposits[i])
-		}
-		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
-		require.NoError(t, err)
-		r, err := ProcessDeposits(ctx, s, deposits)
-		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposits)
-		}
-	}
-}
-
-func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
-	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethpb.BeaconState{}
-	deposit := &ethpb.Deposit{}
-	ctx := context.Background()
-
-	for i := 0; i < 10000; i++ {
-		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(deposit)
-		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
-		require.NoError(t, err)
-		r, err := ProcessPreGenesisDeposits(ctx, s, []*ethpb.Deposit{deposit})
-		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
-		}
-	}
-}
-
-func TestFuzzProcessDeposit_10000(t *testing.T) {
-	fuzzer := fuzz.NewWithSeed(0)
-	state := &ethpb.BeaconState{}
-	deposit := &ethpb.Deposit{}
-
-	for i := 0; i < 10000; i++ {
-		fuzzer.Fuzz(state)
-		fuzzer.Fuzz(deposit)
-		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
-		require.NoError(t, err)
-		r, _, err := ProcessDeposit(s, deposit, true)
-		if err != nil && r != nil {
-			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
-		}
-	}
-}
-
 func TestFuzzverifyDeposit_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
@@ -360,7 +306,7 @@ func TestFuzzverifyDeposit_10000(t *testing.T) {
 		fuzzer.Fuzz(deposit)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		err = verifyDeposit(s, deposit)
+		err = VerifyDeposit(s, deposit)
 		_ = err
 	}
 }

beacon-chain/core/blocks/deposit.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 
 	"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"
@@ -17,24 +16,6 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
-// ProcessPreGenesisDeposits processes a deposit for the beacon state before chainstart.
-func ProcessPreGenesisDeposits(
-	ctx context.Context,
-	beaconState state.BeaconState,
-	deposits []*ethpb.Deposit,
-) (state.BeaconState, error) {
-	var err error
-	beaconState, err = ProcessDeposits(ctx, beaconState, deposits)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process deposit")
-	}
-	beaconState, err = ActivateValidatorWithEffectiveBalance(beaconState, deposits)
-	if err != nil {
-		return nil, err
-	}
-	return beaconState, nil
-}
-
 // ActivateValidatorWithEffectiveBalance updates validator's effective balance, and if it's above MaxEffectiveBalance, validator becomes active in genesis.
 func ActivateValidatorWithEffectiveBalance(beaconState state.BeaconState, deposits []*ethpb.Deposit) (state.BeaconState, error) {
 	for _, d := range deposits {
@@ -66,38 +47,6 @@ func ActivateValidatorWithEffectiveBalance(beaconState state.BeaconState, deposi
 	return beaconState, nil
 }
 
-// ProcessDeposits is one of the operations performed on each processed
-// beacon block to verify queued validators from the Ethereum 1.0 Deposit Contract
-// into the beacon chain.
-//
-// Spec pseudocode definition:
-//
-//	For each deposit in block.body.deposits:
-//	  process_deposit(state, deposit)
-func ProcessDeposits(
-	ctx context.Context,
-	beaconState state.BeaconState,
-	deposits []*ethpb.Deposit,
-) (state.BeaconState, error) {
-	// Attempt to verify all deposit signatures at once, if this fails then fall back to processing
-	// individual deposits with signature verification enabled.
-	batchVerified, err := BatchVerifyDepositsSignatures(ctx, deposits)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, d := range deposits {
-		if d == nil || d.Data == nil {
-			return nil, errors.New("got a nil deposit in block")
-		}
-		beaconState, _, err = ProcessDeposit(beaconState, d, batchVerified)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(d.Data.PublicKey))
-		}
-	}
-	return beaconState, nil
-}
-
 // BatchVerifyDepositsSignatures batch verifies deposit signatures.
 func BatchVerifyDepositsSignatures(ctx context.Context, deposits []*ethpb.Deposit) (bool, error) {
 	var err error
@@ -114,102 +63,28 @@ func BatchVerifyDepositsSignatures(ctx context.Context, deposits []*ethpb.Deposi
 	return verified, nil
 }
 
-// ProcessDeposit takes in a deposit object and inserts it
-// into the registry as a new validator or balance change.
-// Returns the resulting state, a boolean to indicate whether or not the deposit
-// resulted in a new validator entry into the beacon state, and any error.
+// IsValidDepositSignature returns whether deposit_data is valid
+// def is_valid_deposit_signature(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> bool:
 //
-// Spec pseudocode definition:
-// def process_deposit(state: BeaconState, deposit: Deposit) -> None:
-//
-//	# Verify the Merkle branch
-//	assert is_valid_merkle_branch(
-//	    leaf=hash_tree_root(deposit.data),
-//	    branch=deposit.proof,
-//	    depth=DEPOSIT_CONTRACT_TREE_DEPTH + 1,  # Add 1 for the List length mix-in
-//	    index=state.eth1_deposit_index,
-//	    root=state.eth1_data.deposit_root,
-//	)
-//
-//	# Deposits must be processed in order
-//	state.eth1_deposit_index += 1
-//
-//	pubkey = deposit.data.pubkey
-//	amount = deposit.data.amount
-//	validator_pubkeys = [v.pubkey for v in state.validators]
-//	if pubkey not in validator_pubkeys:
-//	    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
-//	    deposit_message = DepositMessage(
-//	        pubkey=deposit.data.pubkey,
-//	        withdrawal_credentials=deposit.data.withdrawal_credentials,
-//	        amount=deposit.data.amount,
-//	    )
-//	    domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
-//	    signing_root = compute_signing_root(deposit_message, domain)
-//	    if not bls.Verify(pubkey, signing_root, deposit.data.signature):
-//	        return
-//
-//	    # Add validator and balance entries
-//	    state.validators.append(get_validator_from_deposit(state, deposit))
-//	    state.balances.append(amount)
-//	else:
-//	    # Increase balance by deposit amount
-//	    index = ValidatorIndex(validator_pubkeys.index(pubkey))
-//	    increase_balance(state, index, amount)
-func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, bool, error) {
-	var newValidator bool
-	if err := verifyDeposit(beaconState, deposit); err != nil {
-		if deposit == nil || deposit.Data == nil {
-			return nil, newValidator, err
-		}
-		return nil, newValidator, errors.Wrapf(err, "could not verify deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
+//	deposit_message = DepositMessage( pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount, )
+//	domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
+//	signing_root = compute_signing_root(deposit_message, domain)
+//	return bls.Verify(pubkey, signing_root, signature)
+func IsValidDepositSignature(data *ethpb.Deposit_Data) (bool, error) {
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	if err != nil {
+		return false, err
 	}
-	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
-		return nil, newValidator, err
+	if err := verifyDepositDataSigningRoot(data, domain); err != nil {
+		// Ignore this error as in the spec pseudo code.
+		log.WithError(err).Debug("Skipping deposit: could not verify deposit data signature")
+		return false, nil
 	}
-	pubKey := deposit.Data.PublicKey
-	amount := deposit.Data.Amount
-	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
-	if !ok {
-		if verifySignature {
-			domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
-			if err != nil {
-				return nil, newValidator, err
-			}
-			if err := verifyDepositDataSigningRoot(deposit.Data, domain); err != nil {
-				// Ignore this error as in the spec pseudo code.
-				log.WithError(err).Debug("Skipping deposit: could not verify deposit data signature")
-				return beaconState, newValidator, nil
-			}
-		}
-
-		effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
-		if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
-			effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
-		}
-		if err := beaconState.AppendValidator(&ethpb.Validator{
-			PublicKey:                  pubKey,
-			WithdrawalCredentials:      deposit.Data.WithdrawalCredentials,
-			ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
-			ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
-			ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-			WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance:           effectiveBalance,
-		}); err != nil {
-			return nil, newValidator, err
-		}
-		newValidator = true
-		if err := beaconState.AppendBalance(amount); err != nil {
-			return nil, newValidator, err
-		}
-	} else if err := helpers.IncreaseBalance(beaconState, index, amount); err != nil {
-		return nil, newValidator, err
-	}
-
-	return beaconState, newValidator, nil
+	return true, nil
 }
 
-func verifyDeposit(beaconState state.ReadOnlyBeaconState, deposit *ethpb.Deposit) error {
+// VerifyDeposit verifies the deposit data and signature given the beacon state and deposit information
+func VerifyDeposit(beaconState state.ReadOnlyBeaconState, deposit *ethpb.Deposit) error {
 	// Verify Merkle proof of deposit and deposit trie root.
 	if deposit == nil || deposit.Data == nil {
 		return errors.New("received nil deposit or nil deposit data")

beacon-chain/core/blocks/deposit_test.go

@@ -9,59 +9,42 @@ 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/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/trie"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	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 TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
-	// Same validator created 3 valid deposits within the same block
-
-	dep, _, err := util.DeterministicDepositsAndKeysSameValidator(3)
-	require.NoError(t, err)
-	eth1Data, err := util.DeterministicEth1Data(len(dep))
-	require.NoError(t, err)
-	b := util.NewBeaconBlock()
-	b.Block = &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			// 3 deposits from the same validator
-			Deposits: []*ethpb.Deposit{dep[0], dep[1], dep[2]},
-		},
-	}
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1},
-			WithdrawalCredentials: []byte{1, 2, 3},
-		},
-	}
-	balances := []uint64{0}
-	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data:   eth1Data,
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, b.Block.Body.Deposits)
-	require.NoError(t, err, "Expected block deposits to process correctly")
-
-	assert.Equal(t, 2, len(newState.Validators()), "Incorrect validator count")
-}
-
-func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
+func TestBatchVerifyDepositsSignatures_Ok(t *testing.T) {
 	deposit := &ethpb.Deposit{
 		Data: &ethpb.Deposit_Data{
-			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, fieldparams.BLSPubkeyLength),
+			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
 			WithdrawalCredentials: make([]byte, 32),
-			Signature:             make([]byte, fieldparams.BLSSignatureLength),
+			Signature:             make([]byte, 96),
+		},
+	}
+	leaf, err := deposit.Data.HashTreeRoot()
+	require.NoError(t, err)
+	// We then create a merkle branch for the test.
+	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
+	require.NoError(t, err, "Could not generate trie")
+	proof, err := depositTrie.MerkleProof(0)
+	require.NoError(t, err, "Could not generate proof")
+
+	deposit.Proof = proof
+	require.NoError(t, err)
+	ok, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
+	require.NoError(t, err)
+	require.Equal(t, true, ok)
+}
+
+func TestVerifyDeposit_MerkleBranchFailsVerification(t *testing.T) {
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, 96),
 		},
 	}
 	leaf, err := deposit.Data.HashTreeRoot()
@@ -74,13 +57,7 @@ func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
 	require.NoError(t, err, "Could not generate proof")
 
 	deposit.Proof = proof
-	b := util.NewBeaconBlock()
-	b.Block = &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			Deposits: []*ethpb.Deposit{deposit},
-		},
-	}
-	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+	beaconState, err := state_native.InitializeFromProtoAltair(&ethpb.BeaconStateAltair{
 		Eth1Data: &ethpb.Eth1Data{
 			DepositRoot: []byte{0},
 			BlockHash:   []byte{1},
@@ -88,312 +65,31 @@ func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
 	})
 	require.NoError(t, err)
 	want := "deposit root did not verify"
-	_, err = blocks.ProcessDeposits(context.Background(), beaconState, b.Block.Body.Deposits)
-	assert.ErrorContains(t, want, err)
+	err = blocks.VerifyDeposit(beaconState, deposit)
+	require.ErrorContains(t, want, err)
 }
 
-func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
-	dep, _, err := util.DeterministicDepositsAndKeys(1)
-	require.NoError(t, err)
-	eth1Data, err := util.DeterministicEth1Data(len(dep))
-	require.NoError(t, err)
-
-	b := util.NewBeaconBlock()
-	b.Block = &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			Deposits: []*ethpb.Deposit{dep[0]},
-		},
-	}
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1},
-			WithdrawalCredentials: []byte{1, 2, 3},
-		},
-	}
-	balances := []uint64{0}
-	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data:   eth1Data,
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, b.Block.Body.Deposits)
-	require.NoError(t, err, "Expected block deposits to process correctly")
-	if newState.Balances()[1] != dep[0].Data.Amount {
-		t.Errorf(
-			"Expected state validator balances index 0 to equal %d, received %d",
-			dep[0].Data.Amount,
-			newState.Balances()[1],
-		)
-	}
-}
-
-func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T) {
+func TestIsValidDepositSignature_Ok(t *testing.T) {
 	sk, err := bls.RandKey()
 	require.NoError(t, err)
-	deposit := &ethpb.Deposit{
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             sk.PublicKey().Marshal(),
-			Amount:                1000,
-			WithdrawalCredentials: make([]byte, 32),
-			Signature:             make([]byte, fieldparams.BLSSignatureLength),
-		},
+	depositData := &ethpb.Deposit_Data{
+		PublicKey:             sk.PublicKey().Marshal(),
+		Amount:                0,
+		WithdrawalCredentials: make([]byte, 32),
+		Signature:             make([]byte, fieldparams.BLSSignatureLength),
 	}
-	sr, err := signing.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 32))
+	dm := &ethpb.DepositMessage{
+		PublicKey:             sk.PublicKey().Marshal(),
+		WithdrawalCredentials: make([]byte, 32),
+		Amount:                0,
+	}
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	require.NoError(t, err)
+	sr, err := signing.ComputeSigningRoot(dm, domain)
 	require.NoError(t, err)
 	sig := sk.Sign(sr[:])
-	deposit.Data.Signature = sig.Marshal()
-	leaf, err := deposit.Data.HashTreeRoot()
+	depositData.Signature = sig.Marshal()
+	valid, err := blocks.IsValidDepositSignature(depositData)
 	require.NoError(t, err)
-
-	// We then create a merkle branch for the test.
-	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
-	require.NoError(t, err, "Could not generate trie")
-	proof, err := depositTrie.MerkleProof(0)
-	require.NoError(t, err, "Could not generate proof")
-
-	deposit.Proof = proof
-	b := util.NewBeaconBlock()
-	b.Block = &ethpb.BeaconBlock{
-		Body: &ethpb.BeaconBlockBody{
-			Deposits: []*ethpb.Deposit{deposit},
-		},
-	}
-	registry := []*ethpb.Validator{
-		{
-			PublicKey: []byte{1, 2, 3},
-		},
-		{
-			PublicKey:             sk.PublicKey().Marshal(),
-			WithdrawalCredentials: []byte{1},
-		},
-	}
-	balances := []uint64{0, 50}
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: root[:],
-			BlockHash:   root[:],
-		},
-	})
-	require.NoError(t, err)
-	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, b.Block.Body.Deposits)
-	require.NoError(t, err, "Process deposit failed")
-	assert.Equal(t, uint64(1000+50), newState.Balances()[1], "Expected balance at index 1 to be 1050")
-}
-
-func TestProcessDeposit_AddsNewValidatorDeposit(t *testing.T) {
-	// Similar to TestProcessDeposits_AddsNewValidatorDeposit except that this test directly calls ProcessDeposit
-	dep, _, err := util.DeterministicDepositsAndKeys(1)
-	require.NoError(t, err)
-	eth1Data, err := util.DeterministicEth1Data(len(dep))
-	require.NoError(t, err)
-
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1},
-			WithdrawalCredentials: []byte{1, 2, 3},
-		},
-	}
-	balances := []uint64{0}
-	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data:   eth1Data,
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	newState, isNewValidator, err := blocks.ProcessDeposit(beaconState, dep[0], true)
-	require.NoError(t, err, "Process deposit failed")
-	assert.Equal(t, true, isNewValidator, "Expected isNewValidator to be true")
-	assert.Equal(t, 2, len(newState.Validators()), "Expected validator list to have length 2")
-	assert.Equal(t, 2, len(newState.Balances()), "Expected validator balances list to have length 2")
-	if newState.Balances()[1] != dep[0].Data.Amount {
-		t.Errorf(
-			"Expected state validator balances index 1 to equal %d, received %d",
-			dep[0].Data.Amount,
-			newState.Balances()[1],
-		)
-	}
-}
-
-func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
-	// Same test settings as in TestProcessDeposit_AddsNewValidatorDeposit, except that we use an invalid signature
-	dep, _, err := util.DeterministicDepositsAndKeys(1)
-	require.NoError(t, err)
-	dep[0].Data.Signature = make([]byte, 96)
-	dt, _, err := util.DepositTrieFromDeposits(dep)
-	require.NoError(t, err)
-	root, err := dt.HashTreeRoot()
-	require.NoError(t, err)
-	eth1Data := &ethpb.Eth1Data{
-		DepositRoot:  root[:],
-		DepositCount: 1,
-	}
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1},
-			WithdrawalCredentials: []byte{1, 2, 3},
-		},
-	}
-	balances := []uint64{0}
-	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data:   eth1Data,
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	newState, isNewValidator, err := blocks.ProcessDeposit(beaconState, dep[0], true)
-	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
-	assert.Equal(t, false, isNewValidator, "Expected isNewValidator to be false")
-
-	if newState.Eth1DepositIndex() != 1 {
-		t.Errorf(
-			"Expected Eth1DepositIndex to be increased by 1 after processing an invalid deposit, received change: %v",
-			newState.Eth1DepositIndex(),
-		)
-	}
-	if len(newState.Validators()) != 1 {
-		t.Errorf("Expected validator list to have length 1, received: %v", len(newState.Validators()))
-	}
-	if len(newState.Balances()) != 1 {
-		t.Errorf("Expected validator balances list to have length 1, received: %v", len(newState.Balances()))
-	}
-	if newState.Balances()[0] != 0 {
-		t.Errorf("Expected validator balance at index 0 to stay 0, received: %v", newState.Balances()[0])
-	}
-}
-
-func TestPreGenesisDeposits_SkipInvalidDeposit(t *testing.T) {
-
-	dep, _, err := util.DeterministicDepositsAndKeys(100)
-	require.NoError(t, err)
-	dep[0].Data.Signature = make([]byte, 96)
-	dt, _, err := util.DepositTrieFromDeposits(dep)
-	require.NoError(t, err)
-
-	for i := range dep {
-		proof, err := dt.MerkleProof(i)
-		require.NoError(t, err)
-		dep[i].Proof = proof
-	}
-	root, err := dt.HashTreeRoot()
-	require.NoError(t, err)
-
-	eth1Data := &ethpb.Eth1Data{
-		DepositRoot:  root[:],
-		DepositCount: 1,
-	}
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1},
-			WithdrawalCredentials: []byte{1, 2, 3},
-		},
-	}
-	balances := []uint64{0}
-	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data:   eth1Data,
-		Fork: &ethpb.Fork{
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		},
-	})
-	require.NoError(t, err)
-	newState, err := blocks.ProcessPreGenesisDeposits(context.Background(), beaconState, dep)
-	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
-
-	_, ok := newState.ValidatorIndexByPubkey(bytesutil.ToBytes48(dep[0].Data.PublicKey))
-	require.Equal(t, false, ok, "bad pubkey should not exist in state")
-
-	for i := 1; i < newState.NumValidators(); i++ {
-		val, err := newState.ValidatorAtIndex(primitives.ValidatorIndex(i))
-		require.NoError(t, err)
-		require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, val.EffectiveBalance, "unequal effective balance")
-		require.Equal(t, primitives.Epoch(0), val.ActivationEpoch)
-		require.Equal(t, primitives.Epoch(0), val.ActivationEligibilityEpoch)
-	}
-	if newState.Eth1DepositIndex() != 100 {
-		t.Errorf(
-			"Expected Eth1DepositIndex to be increased by 99 after processing an invalid deposit, received change: %v",
-			newState.Eth1DepositIndex(),
-		)
-	}
-	if len(newState.Validators()) != 100 {
-		t.Errorf("Expected validator list to have length 100, received: %v", len(newState.Validators()))
-	}
-	if len(newState.Balances()) != 100 {
-		t.Errorf("Expected validator balances list to have length 100, received: %v", len(newState.Balances()))
-	}
-	if newState.Balances()[0] != 0 {
-		t.Errorf("Expected validator balance at index 0 to stay 0, received: %v", newState.Balances()[0])
-	}
-}
-
-func TestProcessDeposit_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T) {
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	deposit := &ethpb.Deposit{
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             sk.PublicKey().Marshal(),
-			Amount:                1000,
-			WithdrawalCredentials: make([]byte, 32),
-			Signature:             make([]byte, 96),
-		},
-	}
-	sr, err := signing.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 32))
-	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
-	deposit.Data.Signature = sig.Marshal()
-	leaf, err := deposit.Data.HashTreeRoot()
-	require.NoError(t, err)
-
-	// We then create a merkle branch for the test.
-	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
-	require.NoError(t, err, "Could not generate trie")
-	proof, err := depositTrie.MerkleProof(0)
-	require.NoError(t, err, "Could not generate proof")
-
-	deposit.Proof = proof
-	registry := []*ethpb.Validator{
-		{
-			PublicKey: []byte{1, 2, 3},
-		},
-		{
-			PublicKey:             sk.PublicKey().Marshal(),
-			WithdrawalCredentials: []byte{1},
-		},
-	}
-	balances := []uint64{0, 50}
-	root, err := depositTrie.HashTreeRoot()
-	require.NoError(t, err)
-
-	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: registry,
-		Balances:   balances,
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: root[:],
-			BlockHash:   root[:],
-		},
-	})
-	require.NoError(t, err)
-	newState, isNewValidator, err := blocks.ProcessDeposit(beaconState, deposit, true /*verifySignature*/)
-	require.NoError(t, err, "Process deposit failed")
-	assert.Equal(t, false, isNewValidator, "Expected isNewValidator to be false")
-	assert.Equal(t, uint64(1000+50), newState.Balances()[1], "Expected balance at index 1 to be 1050")
+	require.Equal(t, true, valid)
 }

beacon-chain/core/blocks/exit.go

@@ -98,6 +98,8 @@ func ProcessVoluntaryExits(
 //	 assert get_current_epoch(state) >= voluntary_exit.epoch
 //	 # Verify the validator has been active long enough
 //	 assert get_current_epoch(state) >= validator.activation_epoch + SHARD_COMMITTEE_PERIOD
+//	 # Only exit validator if it has no pending withdrawals in the queue
+//	 assert get_pending_balance_to_withdraw(state, voluntary_exit.validator_index) == 0  # [New in Electra:EIP7251]
 //	 # Verify signature
 //	 domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, voluntary_exit.epoch)
 //	 signing_root = compute_signing_root(voluntary_exit, domain)
@@ -113,7 +115,6 @@ func VerifyExitAndSignature(
 		return errors.New("nil exit")
 	}
 
-	currentSlot := state.Slot()
 	fork := state.Fork()
 	genesisRoot := state.GenesisValidatorsRoot()
 
@@ -128,7 +129,7 @@ func VerifyExitAndSignature(
 	}
 
 	exit := signed.Exit
-	if err := verifyExitConditions(validator, currentSlot, exit); err != nil {
+	if err := verifyExitConditions(state, validator, exit); err != nil {
 		return err
 	}
 	domain, err := signing.Domain(fork, exit.Epoch, params.BeaconConfig().DomainVoluntaryExit, genesisRoot)
@@ -157,14 +158,16 @@ func VerifyExitAndSignature(
 //	 assert get_current_epoch(state) >= voluntary_exit.epoch
 //	 # Verify the validator has been active long enough
 //	 assert get_current_epoch(state) >= validator.activation_epoch + SHARD_COMMITTEE_PERIOD
+//	 # Only exit validator if it has no pending withdrawals in the queue
+//	 assert get_pending_balance_to_withdraw(state, voluntary_exit.validator_index) == 0  # [New in Electra:EIP7251]
 //	 # Verify signature
 //	 domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, voluntary_exit.epoch)
 //	 signing_root = compute_signing_root(voluntary_exit, domain)
 //	 assert bls.Verify(validator.pubkey, signing_root, signed_voluntary_exit.signature)
 //	 # Initiate exit
 //	 initiate_validator_exit(state, voluntary_exit.validator_index)
-func verifyExitConditions(validator state.ReadOnlyValidator, currentSlot primitives.Slot, exit *ethpb.VoluntaryExit) error {
-	currentEpoch := slots.ToEpoch(currentSlot)
+func verifyExitConditions(st state.ReadOnlyBeaconState, validator state.ReadOnlyValidator, exit *ethpb.VoluntaryExit) error {
+	currentEpoch := slots.ToEpoch(st.Slot())
 	// Verify the validator is active.
 	if !helpers.IsActiveValidatorUsingTrie(validator, currentEpoch) {
 		return errors.New("non-active validator cannot exit")
@@ -187,5 +190,17 @@ func verifyExitConditions(validator state.ReadOnlyValidator, currentSlot primiti
 			validator.ActivationEpoch()+params.BeaconConfig().ShardCommitteePeriod,
 		)
 	}
+
+	if st.Version() >= version.Electra {
+		// Only exit validator if it has no pending withdrawals in the queue.
+		ok, err := st.HasPendingBalanceToWithdraw(exit.ValidatorIndex)
+		if err != nil {
+			return fmt.Errorf("unable to retrieve pending balance to withdraw for validator %d: %w", exit.ValidatorIndex, err)
+		}
+		if ok {
+			return fmt.Errorf("validator %d must have no pending balance to withdraw", exit.ValidatorIndex)
+		}
+	}
+
 	return nil
 }

beacon-chain/core/blocks/exit_test.go

@@ -135,6 +135,11 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 }
 
 func TestVerifyExitAndSignature(t *testing.T) {
+	// Remove after electra fork epoch is defined.
+	cfg := params.BeaconConfig()
+	cfg.ElectraForkEpoch = cfg.DenebForkEpoch * 2
+	params.SetActiveTestCleanup(t, cfg)
+	// End remove section.
 	denebSlot, err := slots.EpochStart(params.BeaconConfig().DenebForkEpoch)
 	require.NoError(t, err)
 	tests := []struct {
@@ -167,7 +172,7 @@ func TestVerifyExitAndSignature(t *testing.T) {
 			wantErr: "nil exit",
 		},
 		{
-			name: "Happy Path",
+			name: "Happy Path phase0",
 			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, state.ReadOnlyBeaconState, error) {
 				fork := &ethpb.Fork{
 					PreviousVersion: params.BeaconConfig().GenesisForkVersion,
@@ -275,6 +280,52 @@ func TestVerifyExitAndSignature(t *testing.T) {
 				return validator, signedExit, bs, nil
 			},
 		},
+		{
+			name: "EIP-7251 - pending balance to withdraw must be zero",
+			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, state.ReadOnlyBeaconState, error) {
+				fork := &ethpb.Fork{
+					PreviousVersion: params.BeaconConfig().DenebForkVersion,
+					CurrentVersion:  params.BeaconConfig().ElectraForkVersion,
+					Epoch:           params.BeaconConfig().ElectraForkEpoch,
+				}
+				signedExit := &ethpb.SignedVoluntaryExit{
+					Exit: &ethpb.VoluntaryExit{
+						Epoch:          params.BeaconConfig().DenebForkEpoch + 1,
+						ValidatorIndex: 0,
+					},
+				}
+				electraSlot, err := slots.EpochStart(params.BeaconConfig().ElectraForkEpoch)
+				require.NoError(t, err)
+				bs, keys := util.DeterministicGenesisState(t, 1)
+				bs, err = state_native.InitializeFromProtoUnsafeElectra(&ethpb.BeaconStateElectra{
+					GenesisValidatorsRoot: bs.GenesisValidatorsRoot(),
+					Fork:                  fork,
+					Slot:                  electraSlot,
+					Validators:            bs.Validators(),
+				})
+				if err != nil {
+					return nil, nil, nil, err
+				}
+				validator := bs.Validators()[0]
+				validator.ActivationEpoch = 1
+				err = bs.UpdateValidatorAtIndex(0, validator)
+				require.NoError(t, err)
+				sb, err := signing.ComputeDomainAndSign(bs, signedExit.Exit.Epoch, signedExit.Exit, params.BeaconConfig().DomainVoluntaryExit, keys[0])
+				require.NoError(t, err)
+				sig, err := bls.SignatureFromBytes(sb)
+				require.NoError(t, err)
+				signedExit.Signature = sig.Marshal()
+
+				// Give validator a pending balance to withdraw.
+				require.NoError(t, bs.AppendPendingPartialWithdrawal(&ethpb.PendingPartialWithdrawal{
+					Index:  0,
+					Amount: 500,
+				}))
+
+				return validator, signedExit, bs, nil
+			},
+			wantErr: "validator 0 must have no pending balance to withdraw",
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

beacon-chain/core/blocks/signature.go

@@ -96,6 +96,24 @@ func VerifyBlockHeaderSignature(beaconState state.BeaconState, header *ethpb.Sig
 	return signing.VerifyBlockHeaderSigningRoot(header.Header, proposerPubKey, header.Signature, domain)
 }
 
+func VerifyBlockHeaderSignatureUsingCurrentFork(beaconState state.BeaconState, header *ethpb.SignedBeaconBlockHeader) error {
+	currentEpoch := slots.ToEpoch(header.Header.Slot)
+	fork, err := forks.Fork(currentEpoch)
+	if err != nil {
+		return err
+	}
+	domain, err := signing.Domain(fork, currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
+	if err != nil {
+		return err
+	}
+	proposer, err := beaconState.ValidatorAtIndex(header.Header.ProposerIndex)
+	if err != nil {
+		return err
+	}
+	proposerPubKey := proposer.PublicKey
+	return signing.VerifyBlockHeaderSigningRoot(header.Header, proposerPubKey, header.Signature, domain)
+}
+
 // VerifyBlockSignatureUsingCurrentFork verifies the proposer signature of a beacon block. This differs
 // from the above method by not using fork data from the state and instead retrieving it
 // via the respective epoch.
@@ -204,12 +222,7 @@ func createAttestationSignatureBatch(
 			return nil, err
 		}
 		indices := ia.GetAttestingIndices()
-		pubkeys := make([][]byte, len(indices))
-		for i := 0; i < len(indices); i++ {
-			pubkeyAtIdx := beaconState.PubkeyAtIndex(primitives.ValidatorIndex(indices[i]))
-			pubkeys[i] = pubkeyAtIdx[:]
-		}
-		aggP, err := bls.AggregatePublicKeys(pubkeys)
+		aggP, err := beaconState.AggregateKeyFromIndices(indices)
 		if err != nil {
 			return nil, err
 		}

beacon-chain/core/blocks/withdrawals.go

@@ -120,32 +120,35 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 //
 // Spec pseudocode definition:
 //
-// def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
+//	def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
+//	    expected_withdrawals, partial_withdrawals_count = get_expected_withdrawals(state)  # [Modified in Electra:EIP7251]
 //
-//	expected_withdrawals = get_expected_withdrawals(state)
-//	assert len(payload.withdrawals) == len(expected_withdrawals)
+//	    assert len(payload.withdrawals) == len(expected_withdrawals)
 //
-//	for expected_withdrawal, withdrawal in zip(expected_withdrawals, payload.withdrawals):
-//	    assert withdrawal == expected_withdrawal
-//	    decrease_balance(state, withdrawal.validator_index, withdrawal.amount)
+//	    for expected_withdrawal, withdrawal in zip(expected_withdrawals, payload.withdrawals):
+//	        assert withdrawal == expected_withdrawal
+//	        decrease_balance(state, withdrawal.validator_index, withdrawal.amount)
 //
-//	# Update the next withdrawal index if this block contained withdrawals
-//	if len(expected_withdrawals) != 0:
-//	    latest_withdrawal = expected_withdrawals[-1]
-//	    state.next_withdrawal_index = WithdrawalIndex(latest_withdrawal.index + 1)
+//	    # Update pending partial withdrawals [New in Electra:EIP7251]
+//	    state.pending_partial_withdrawals = state.pending_partial_withdrawals[partial_withdrawals_count:]
 //
-//	# Update the next validator index to start the next withdrawal sweep
-//	if len(expected_withdrawals) == MAX_WITHDRAWALS_PER_PAYLOAD:
-//	    # Next sweep starts after the latest withdrawal's validator index
-//	    next_validator_index = ValidatorIndex((expected_withdrawals[-1].validator_index + 1) % len(state.validators))
-//	    state.next_withdrawal_validator_index = next_validator_index
-//	else:
-//	    # Advance sweep by the max length of the sweep if there was not a full set of withdrawals
-//	    next_index = state.next_withdrawal_validator_index + MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP
-//	    next_validator_index = ValidatorIndex(next_index % len(state.validators))
-//	    state.next_withdrawal_validator_index = next_validator_index
+//	    # Update the next withdrawal index if this block contained withdrawals
+//	    if len(expected_withdrawals) != 0:
+//	        latest_withdrawal = expected_withdrawals[-1]
+//	        state.next_withdrawal_index = WithdrawalIndex(latest_withdrawal.index + 1)
+//
+//	    # Update the next validator index to start the next withdrawal sweep
+//	    if len(expected_withdrawals) == MAX_WITHDRAWALS_PER_PAYLOAD:
+//	        # Next sweep starts after the latest withdrawal's validator index
+//	        next_validator_index = ValidatorIndex((expected_withdrawals[-1].validator_index + 1) % len(state.validators))
+//	        state.next_withdrawal_validator_index = next_validator_index
+//	    else:
+//	        # Advance sweep by the max length of the sweep if there was not a full set of withdrawals
+//	        next_index = state.next_withdrawal_validator_index + MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP
+//	        next_validator_index = ValidatorIndex(next_index % len(state.validators))
+//	        state.next_withdrawal_validator_index = next_validator_index
 func ProcessWithdrawals(st state.BeaconState, executionData interfaces.ExecutionData) (state.BeaconState, error) {
-	expectedWithdrawals, _, err := st.ExpectedWithdrawals()
+	expectedWithdrawals, partialWithdrawalsCount, err := st.ExpectedWithdrawals()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals")
 	}
@@ -162,6 +165,11 @@ func ProcessWithdrawals(st state.BeaconState, executionData interfaces.Execution
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get withdrawals")
 		}
+
+		if len(wds) != len(expectedWithdrawals) {
+			return nil, fmt.Errorf("execution payload header has %d withdrawals when %d were expected", len(wds), len(expectedWithdrawals))
+		}
+
 		wdRoot, err = ssz.WithdrawalSliceRoot(wds, fieldparams.MaxWithdrawalsPerPayload)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get withdrawals root")
@@ -182,6 +190,13 @@ func ProcessWithdrawals(st state.BeaconState, executionData interfaces.Execution
 			return nil, errors.Wrap(err, "could not decrease balance")
 		}
 	}
+
+	if st.Version() >= version.Electra {
+		if err := st.DequeuePartialWithdrawals(partialWithdrawalsCount); err != nil {
+			return nil, fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
+		}
+	}
+
 	if len(expectedWithdrawals) > 0 {
 		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
 			return nil, errors.Wrap(err, "could not set next withdrawal index")

beacon-chain/core/blocks/withdrawals_test.go

@@ -12,6 +12,7 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "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/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls/common"
@@ -19,6 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
@@ -675,6 +677,7 @@ func TestProcessWithdrawals(t *testing.T) {
 		FullWithdrawalIndices           []primitives.ValidatorIndex
 		PendingPartialWithdrawalIndices []primitives.ValidatorIndex
 		Withdrawals                     []*enginev1.Withdrawal
+		PendingPartialWithdrawals       []*ethpb.PendingPartialWithdrawal // Electra
 	}
 	type control struct {
 		NextWithdrawalValidatorIndex primitives.ValidatorIndex
@@ -772,7 +775,7 @@ func TestProcessWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "Less than max sweep at end",
+				Name:                         "less than max sweep at end",
 				NextWithdrawalIndex:          22,
 				NextWithdrawalValidatorIndex: 4,
 				FullWithdrawalIndices:        []primitives.ValidatorIndex{80, 81, 82, 83},
@@ -789,7 +792,7 @@ func TestProcessWithdrawals(t *testing.T) {
 		},
 		{
 			Args: args{
-				Name:                         "Less than max sweep and beginning",
+				Name:                         "less than max sweep and beginning",
 				NextWithdrawalIndex:          22,
 				NextWithdrawalValidatorIndex: 4,
 				FullWithdrawalIndices:        []primitives.ValidatorIndex{4, 5, 6},
@@ -846,6 +849,36 @@ func TestProcessWithdrawals(t *testing.T) {
 				},
 			},
 		},
+		{
+			Args: args{
+				Name:                            "success many withdrawals with pending partial withdrawals in state",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    88,
+				FullWithdrawalIndices:           []primitives.ValidatorIndex{7, 19, 28},
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{2, 1, 89, 15},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(89, 22), PendingPartialWithdrawal(1, 23), PendingPartialWithdrawal(2, 24),
+					fullWithdrawal(7, 25), PendingPartialWithdrawal(15, 26), fullWithdrawal(19, 27),
+					fullWithdrawal(28, 28),
+				},
+				PendingPartialWithdrawals: []*ethpb.PendingPartialWithdrawal{
+					{
+						Index:  11,
+						Amount: withdrawalAmount(11) - maxEffectiveBalance,
+					},
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 40,
+				NextWithdrawalIndex:          29,
+				Balances: map[uint64]uint64{
+					7: 0, 19: 0, 28: 0,
+					2: maxEffectiveBalance, 1: maxEffectiveBalance, 89: maxEffectiveBalance,
+					15: maxEffectiveBalance,
+				},
+			},
+		},
+
 		{
 			Args: args{
 				Name:                         "success more than max fully withdrawals",
@@ -1011,65 +1044,97 @@ func TestProcessWithdrawals(t *testing.T) {
 		}
 	}
 
-	prepareValidators := func(st *ethpb.BeaconStateCapella, arguments args) (state.BeaconState, error) {
+	prepareValidators := func(st state.BeaconState, arguments args) error {
 		validators := make([]*ethpb.Validator, numValidators)
-		st.Balances = make([]uint64, numValidators)
+		if err := st.SetBalances(make([]uint64, numValidators)); err != nil {
+			return err
+		}
 		for i := range validators {
 			v := &ethpb.Validator{}
 			v.EffectiveBalance = maxEffectiveBalance
 			v.WithdrawableEpoch = epochInFuture
 			v.WithdrawalCredentials = make([]byte, 32)
 			v.WithdrawalCredentials[31] = byte(i)
-			st.Balances[i] = v.EffectiveBalance - uint64(rand.Intn(1000))
+			if err := st.UpdateBalancesAtIndex(primitives.ValidatorIndex(i), v.EffectiveBalance-uint64(rand.Intn(1000))); err != nil {
+				return err
+			}
 			validators[i] = v
 		}
 		for _, idx := range arguments.FullWithdrawalIndices {
 			if idx != notWithdrawableIndex {
 				validators[idx].WithdrawableEpoch = epochInPast
 			}
-			st.Balances[idx] = withdrawalAmount(idx)
+			if err := st.UpdateBalancesAtIndex(idx, withdrawalAmount(idx)); err != nil {
+				return err
+			}
 			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 		}
 		for _, idx := range arguments.PendingPartialWithdrawalIndices {
 			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-			st.Balances[idx] = withdrawalAmount(idx)
+			if err := st.UpdateBalancesAtIndex(idx, withdrawalAmount(idx)); err != nil {
+				return err
+			}
 		}
-		st.Validators = validators
-		return state_native.InitializeFromProtoCapella(st)
+		return st.SetValidators(validators)
 	}
 
 	for _, test := range tests {
 		t.Run(test.Args.Name, func(t *testing.T) {
-			saved := params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep
-			params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = maxSweep
-			if test.Args.Withdrawals == nil {
-				test.Args.Withdrawals = make([]*enginev1.Withdrawal, 0)
+			for _, fork := range []int{version.Capella, version.Electra} {
+				t.Run(version.String(fork), func(t *testing.T) {
+					saved := params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep
+					params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = maxSweep
+					if test.Args.Withdrawals == nil {
+						test.Args.Withdrawals = make([]*enginev1.Withdrawal, 0)
+					}
+					if test.Args.FullWithdrawalIndices == nil {
+						test.Args.FullWithdrawalIndices = 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)
+					var st state.BeaconState
+					var p interfaces.ExecutionData
+					switch fork {
+					case version.Capella:
+						spb := &ethpb.BeaconStateCapella{
+							Slot:                         slot,
+							NextWithdrawalValidatorIndex: test.Args.NextWithdrawalValidatorIndex,
+							NextWithdrawalIndex:          test.Args.NextWithdrawalIndex,
+						}
+						st, err = state_native.InitializeFromProtoUnsafeCapella(spb)
+						require.NoError(t, err)
+						p, err = consensusblocks.WrappedExecutionPayloadCapella(&enginev1.ExecutionPayloadCapella{Withdrawals: test.Args.Withdrawals})
+						require.NoError(t, err)
+					case version.Electra:
+						spb := &ethpb.BeaconStateElectra{
+							Slot:                         slot,
+							NextWithdrawalValidatorIndex: test.Args.NextWithdrawalValidatorIndex,
+							NextWithdrawalIndex:          test.Args.NextWithdrawalIndex,
+							PendingPartialWithdrawals:    test.Args.PendingPartialWithdrawals,
+						}
+						st, err = state_native.InitializeFromProtoUnsafeElectra(spb)
+						require.NoError(t, err)
+						p, err = consensusblocks.WrappedExecutionPayloadElectra(&enginev1.ExecutionPayloadElectra{Withdrawals: test.Args.Withdrawals})
+						require.NoError(t, err)
+					default:
+						t.Fatalf("Add a beacon state setup for version %s", version.String(fork))
+					}
+					err = prepareValidators(st, test.Args)
+					require.NoError(t, err)
+					post, err := blocks.ProcessWithdrawals(st, p)
+					if test.Control.ExpectedError {
+						require.NotNil(t, err)
+					} else {
+						require.NoError(t, err)
+						checkPostState(t, test.Control, post)
+					}
+					params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = saved
+
+				})
 			}
-			if test.Args.FullWithdrawalIndices == nil {
-				test.Args.FullWithdrawalIndices = 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)
-			spb := &ethpb.BeaconStateCapella{
-				Slot:                         slot,
-				NextWithdrawalValidatorIndex: test.Args.NextWithdrawalValidatorIndex,
-				NextWithdrawalIndex:          test.Args.NextWithdrawalIndex,
-			}
-			st, err := prepareValidators(spb, test.Args)
-			require.NoError(t, err)
-			p, err := consensusblocks.WrappedExecutionPayloadCapella(&enginev1.ExecutionPayloadCapella{Withdrawals: test.Args.Withdrawals})
-			require.NoError(t, err)
-			post, err := blocks.ProcessWithdrawals(st, p)
-			if test.Control.ExpectedError {
-				require.NotNil(t, err)
-			} else {
-				require.NoError(t, err)
-				checkPostState(t, test.Control, post)
-			}
-			params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = saved
 		})
 	}
 }

beacon-chain/core/electra/BUILD.bazel

@@ -10,6 +10,7 @@ go_library(
         "effective_balance_updates.go",
         "registry_updates.go",
         "transition.go",
+        "transition_no_verify_sig.go",
         "upgrade.go",
         "validator.go",
         "withdrawals.go",
@@ -18,6 +19,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -27,8 +29,9 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
+        "//contracts/deposit:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/engine/v1:go_default_library",
@@ -46,8 +49,11 @@ go_test(
     srcs = [
         "churn_test.go",
         "consolidations_test.go",
+        "deposit_fuzz_test.go",
         "deposits_test.go",
         "effective_balance_updates_test.go",
+        "registry_updates_test.go",
+        "transition_test.go",
         "upgrade_test.go",
         "validator_test.go",
         "withdrawals_test.go",
@@ -61,18 +67,19 @@ go_test(
         "//beacon-chain/state/state-native:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//crypto/bls/blst:go_default_library",
-        "//crypto/bls/common:go_default_library",
+        "//crypto/bls: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/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_google_gofuzz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
     ],

beacon-chain/core/electra/churn_test.go

@@ -2,6 +2,7 @@ package electra_test
 
 import (
 	"context"
+	"fmt"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
@@ -18,10 +19,17 @@ func createValidatorsWithTotalActiveBalance(totalBal primitives.Gwei) []*eth.Val
 	num := totalBal / primitives.Gwei(params.BeaconConfig().MinActivationBalance)
 	vals := make([]*eth.Validator, num)
 	for i := range vals {
+		wd := make([]byte, 32)
+		wd[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+		wd[31] = byte(i)
+
 		vals[i] = &eth.Validator{
-			ActivationEpoch:  primitives.Epoch(0),
-			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance: params.BeaconConfig().MinActivationBalance,
+			ActivationEpoch:       primitives.Epoch(0),
+			EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             []byte(fmt.Sprintf("val_%d", i)),
+			WithdrawableEpoch:     params.BeaconConfig().FarFutureEpoch,
+			WithdrawalCredentials: wd,
 		}
 	}
 	if totalBal%primitives.Gwei(params.BeaconConfig().MinActivationBalance) != 0 {

beacon-chain/core/electra/consolidations.go

@@ -1,16 +1,18 @@
 package electra
 
 import (
+	"bytes"
 	"context"
+	"fmt"
 
 	"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/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"go.opencensus.io/trace"
 )
@@ -40,7 +42,7 @@ import (
 //
 //	    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")
+	_, span := trace.StartSpan(ctx, "electra.ProcessPendingConsolidations")
 	defer span.End()
 
 	if st == nil || st.IsNil() {
@@ -68,7 +70,7 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 			break
 		}
 
-		if err := SwitchToCompoundingValidator(ctx, st, pc.TargetIndex); err != nil {
+		if err := SwitchToCompoundingValidator(st, pc.TargetIndex); err != nil {
 			return err
 		}
 
@@ -92,165 +94,159 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 	return nil
 }
 
-// ProcessConsolidations implements the spec definition below. This method makes mutating calls to
-// the beacon state.
+// ProcessConsolidationRequests implements the spec definition below. This method makes mutating
+// calls to the beacon state.
 //
-// Spec definition:
+//	def process_consolidation_request(
+//	    state: BeaconState,
+//	    consolidation_request: ConsolidationRequest
+//	) -> None:
+//	    # If the pending consolidations queue is full, consolidation requests are ignored
+//	    if len(state.pending_consolidations) == PENDING_CONSOLIDATIONS_LIMIT:
+//	        return
+//	    # If there is too little available consolidation churn limit, consolidation requests are ignored
+//	    if get_consolidation_churn_limit(state) <= MIN_ACTIVATION_BALANCE:
+//	        return
+//
+//	    validator_pubkeys = [v.pubkey for v in state.validators]
+//	    # Verify pubkeys exists
+//	    request_source_pubkey = consolidation_request.source_pubkey
+//	    request_target_pubkey = consolidation_request.target_pubkey
+//	    if request_source_pubkey not in validator_pubkeys:
+//	        return
+//	    if request_target_pubkey not in validator_pubkeys:
+//	        return
+//	    source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
+//	    target_index = ValidatorIndex(validator_pubkeys.index(request_target_pubkey))
+//	    source_validator = state.validators[source_index]
+//	    target_validator = state.validators[target_index]
 //
-//	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
+//	    if source_index == target_index:
+//	        return
+//
+//	    # Verify source withdrawal credentials
+//	    has_correct_credential = has_execution_withdrawal_credential(source_validator)
+//	    is_correct_source_address = (
+//	        source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
+//	    )
+//	    if not (has_correct_credential and is_correct_source_address):
+//	        return
+//
+//	    # Verify that target has execution withdrawal credentials
+//	    if not has_execution_withdrawal_credential(target_validator):
+//	        return
 //
-//	    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)
+//	    if not is_active_validator(source_validator, current_epoch):
+//	        return
+//	    if not is_active_validator(target_validator, current_epoch):
+//	        return
 //	    # 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)
+//	    if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	        return
+//	    if target_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	        return
 //
 //	    # Initiate source validator exit and append pending consolidation
 //	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
-//	        state, source_validator.effective_balance)
+//	        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
+//	        source_index=source_index,
+//	        target_index=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")
+func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
+	if len(reqs) == 0 || st == nil {
+		return nil
 	}
 
-	if len(cs) == 0 {
-		return nil // Nothing to process.
-	}
-
-	domain, err := signing.ComputeDomain(
-		params.BeaconConfig().DomainConsolidation,
-		nil, // Use genesis fork version
-		st.GenesisValidatorsRoot(),
-	)
+	activeBal, err := helpers.TotalActiveBalance(st)
 	if err != nil {
 		return err
 	}
-
-	totalBalance, err := helpers.TotalActiveBalance(st)
-	if err != nil {
-		return err
+	churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
+	if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
+		return nil
 	}
+	curEpoch := slots.ToEpoch(st.Slot())
+	ffe := params.BeaconConfig().FarFutureEpoch
+	minValWithdrawDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
+	pcLimit := params.BeaconConfig().PendingConsolidationsLimit
 
-	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")
+	for _, cr := range reqs {
+		if ctx.Err() != nil {
+			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
+		}
+		if npc, err := st.NumPendingConsolidations(); err != nil {
+			return fmt.Errorf("failed to fetch number of pending consolidations: %w", err) // This should never happen.
+		} else if npc >= pcLimit {
+			return nil
 		}
 
-		if n, err := st.NumPendingConsolidations(); err != nil {
-			return err
-		} else if n >= params.BeaconConfig().PendingConsolidationsLimit {
-			return errors.New("pending consolidations queue is full")
+		srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
+		if !ok {
+			continue
+		}
+		tgtIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.TargetPubkey))
+		if !ok {
+			continue
 		}
 
-		if c.Message.SourceIndex == c.Message.TargetIndex {
-			return errors.New("source and target index are the same")
+		if srcIdx == tgtIdx {
+			continue
 		}
-		source, err := st.ValidatorAtIndex(c.Message.SourceIndex)
+
+		srcV, err := st.ValidatorAtIndex(srcIdx)
 		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")
+			return fmt.Errorf("failed to fetch source validator: %w", err) // This should never happen.
 		}
 
-		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")
+		tgtV, err := st.ValidatorAtIndexReadOnly(tgtIdx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch target validator: %w", err) // This should never happen.
 		}
 
-		sr, err := signing.ComputeSigningRoot(c.Message, domain)
-		if err != nil {
-			return err
+		// Verify source withdrawal credentials
+		if !helpers.HasExecutionWithdrawalCredentials(srcV) {
+			continue
 		}
-		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")
+		// Confirm source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
+		if len(srcV.WithdrawalCredentials) != 32 || len(cr.SourceAddress) != 20 || !bytes.HasSuffix(srcV.WithdrawalCredentials, cr.SourceAddress) {
+			continue
 		}
 
-		sEE, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(source.EffectiveBalance))
+		// Target validator must have their withdrawal credentials set appropriately.
+		if !helpers.HasExecutionWithdrawalCredentials(tgtV) {
+			continue
+		}
+
+		// Both validators must be active.
+		if !helpers.IsActiveValidator(srcV, curEpoch) || !helpers.IsActiveValidatorUsingTrie(tgtV, curEpoch) {
+			continue
+		}
+		// Neither validator are exiting.
+		if srcV.ExitEpoch != ffe || tgtV.ExitEpoch() != ffe {
+			continue
+		}
+
+		// Initiate the exit of the source validator.
+		exitEpoch, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(srcV.EffectiveBalance))
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to compute consolidaiton epoch: %w", err)
 		}
-		source.ExitEpoch = sEE
-		source.WithdrawableEpoch = sEE + params.BeaconConfig().MinValidatorWithdrawabilityDelay
-		if err := st.UpdateValidatorAtIndex(c.Message.SourceIndex, source); err != nil {
-			return err
+		srcV.ExitEpoch = exitEpoch
+		srcV.WithdrawableEpoch = exitEpoch + minValWithdrawDelay
+		if err := st.UpdateValidatorAtIndex(srcIdx, srcV); err != nil {
+			return fmt.Errorf("failed to update validator: %w", err) // This should never happen.
 		}
-		if err := st.AppendPendingConsolidation(c.Message.ToPendingConsolidation()); err != nil {
-			return err
+
+		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
+			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
 		}
 	}
 

beacon-chain/core/electra/consolidations_test.go

@@ -5,19 +5,14 @@ import (
 	"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"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	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) {
@@ -238,203 +233,197 @@ func stateWithActiveBalanceETH(t *testing.T, balETH uint64) state.BeaconState {
 	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
-
+func TestProcessConsolidationRequests(t *testing.T) {
 	tests := []struct {
-		name    string
-		state   state.BeaconState
-		scs     []*eth.SignedConsolidation
-		check   func(*testing.T, state.BeaconState)
-		wantErr string
+		name     string
+		state    state.BeaconState
+		reqs     []*enginev1.ConsolidationRequest
+		validate func(*testing.T, state.BeaconState)
 	}{
 		{
-			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",
+			name: "one valid request",
 			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)
+				st := &eth.BeaconStateElectra{
+					Validators: createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+				}
+				// Validator scenario setup. See comments in reqs section.
+				st.Validators[3].WithdrawalCredentials = bytesutil.Bytes32(0)
+				st.Validators[8].WithdrawalCredentials = bytesutil.Bytes32(0)
+				st.Validators[9].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				st.Validators[12].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				st.Validators[13].ExitEpoch = 10
+				st.Validators[16].ExitEpoch = 10
+				s, err := state_native.InitializeFromProtoElectra(st)
 				require.NoError(t, err)
-				val.ActivationEpoch = params.BeaconConfig().FarFutureEpoch
-				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
-				return st
+				return s
 			}(),
-			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)
+			reqs: []*enginev1.ConsolidationRequest{
+				// Source doesn't have withdrawal credentials.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_3"),
+					TargetPubkey:  []byte("val_4"),
+				},
+				// Source withdrawal credentials don't match the consolidation address.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)), // Should be 5
+					SourcePubkey:  []byte("val_5"),
+					TargetPubkey:  []byte("val_6"),
+				},
+				// Target does not have their withdrawal credentials set appropriately.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(7)),
+					SourcePubkey:  []byte("val_7"),
+					TargetPubkey:  []byte("val_8"),
+				},
+				// Source is inactive.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(9)),
+					SourcePubkey:  []byte("val_9"),
+					TargetPubkey:  []byte("val_10"),
+				},
+				// Target is inactive.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(11)),
+					SourcePubkey:  []byte("val_11"),
+					TargetPubkey:  []byte("val_12"),
+				},
+				// Source is exiting.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(13)),
+					SourcePubkey:  []byte("val_13"),
+					TargetPubkey:  []byte("val_14"),
+				},
+				// Target is exiting.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(15)),
+					SourcePubkey:  []byte("val_15"),
+					TargetPubkey:  []byte("val_16"),
+				},
+				// Source doesn't exist
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("INVALID"),
+					TargetPubkey:  []byte("val_0"),
+				},
+				// Target doesn't exist
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("val_0"),
+					TargetPubkey:  []byte("INVALID"),
+				},
+				// Source == target
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("val_0"),
+					TargetPubkey:  []byte("val_0"),
+				},
+				// Valid consolidation request. This should be last to ensure invalid requests do
+				// not end the processing early.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify a pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
 				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.Equal(t, uint64(1), numPC)
+				pcs, err := st.PendingConsolidations()
 				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}}
+				require.Equal(t, primitives.ValidatorIndex(1), pcs[0].SourceIndex)
+				require.Equal(t, primitives.ValidatorIndex(2), pcs[0].TargetIndex)
 
-				domain, err := signing.ComputeDomain(
-					params.BeaconConfig().DomainConsolidation,
-					nil,
-					genesisValidatorRoot,
-				)
+				// Verify the source validator is exiting.
+				src, err := st.ValidatorAtIndex(1)
 				require.NoError(t, err)
-				sr, err := signing.ComputeSigningRoot(sc.Message, domain)
+				require.NotEqual(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch not updated")
+				require.Equal(t, params.BeaconConfig().MinValidatorWithdrawabilityDelay, src.WithdrawableEpoch-src.ExitEpoch, "source validator withdrawable epoch not set correctly")
+			},
+		},
+		{
+			name: "pending consolidations limit reached",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit),
+				}
+				s, err := state_native.InitializeFromProtoElectra(st)
 				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}
+				return s
 			}(),
-			check: func(t *testing.T, st state.BeaconState) {
-				source, err := st.ValidatorAtIndex(100)
+			reqs: []*enginev1.ConsolidationRequest{
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify no pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
 				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)
+				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
+
+				// Verify the source validator is not exiting.
+				src, err := st.ValidatorAtIndex(1)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
+			},
+		},
+		{
+			name: "pending consolidations limit reached during processing",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit-1),
+				}
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(3)),
+					SourcePubkey:  []byte("val_3"),
+					TargetPubkey:  []byte("val_4"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify a pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
+
+				// The first consolidation was appended.
+				pcs, err := st.PendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, primitives.ValidatorIndex(1), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].SourceIndex)
+				require.Equal(t, primitives.ValidatorIndex(2), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].TargetIndex)
+
+				// Verify the second source validator is not exiting.
+				src, err := st.ValidatorAtIndex(3)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
 			},
 		},
 	}
 
 	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)
+			err := electra.ProcessConsolidationRequests(context.TODO(), tt.state, tt.reqs)
+			require.NoError(t, err)
+			if tt.validate != nil {
+				tt.validate(t, tt.state)
 			}
 		})
 	}

beacon-chain/core/electra/deposit_fuzz_test.go

@@ -0,0 +1,48 @@
+package electra_test
+
+import (
+	"context"
+	"testing"
+
+	fuzz "github.com/google/gofuzz"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestFuzzProcessDeposits_10000(t *testing.T) {
+	fuzzer := fuzz.NewWithSeed(0)
+	state := &ethpb.BeaconStateElectra{}
+	deposits := make([]*ethpb.Deposit, 100)
+	ctx := context.Background()
+	for i := 0; i < 10000; i++ {
+		fuzzer.Fuzz(state)
+		for i := range deposits {
+			fuzzer.Fuzz(deposits[i])
+		}
+		s, err := state_native.InitializeFromProtoUnsafeElectra(state)
+		require.NoError(t, err)
+		r, err := electra.ProcessDeposits(ctx, s, deposits)
+		if err != nil && r != nil {
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposits)
+		}
+	}
+}
+
+func TestFuzzProcessDeposit_10000(t *testing.T) {
+	fuzzer := fuzz.NewWithSeed(0)
+	state := &ethpb.BeaconStateElectra{}
+	deposit := &ethpb.Deposit{}
+
+	for i := 0; i < 10000; i++ {
+		fuzzer.Fuzz(state)
+		fuzzer.Fuzz(deposit)
+		s, err := state_native.InitializeFromProtoUnsafeElectra(state)
+		require.NoError(t, err)
+		r, err := electra.ProcessDeposit(s, deposit, true)
+		if err != nil && r != nil {
+			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
+		}
+	}
+}

beacon-chain/core/electra/deposits.go

@@ -2,15 +2,189 @@ package electra
 
 import (
 	"context"
-	"errors"
+	"fmt"
 
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"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/contracts/deposit"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	log "github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
+// ProcessDeposits is one of the operations performed on each processed
+// beacon block to verify queued validators from the Ethereum 1.0 Deposit Contract
+// into the beacon chain.
+//
+// Spec pseudocode definition:
+//
+//	For each deposit in block.body.deposits:
+//	  process_deposit(state, deposit)
+func ProcessDeposits(
+	ctx context.Context,
+	beaconState state.BeaconState,
+	deposits []*ethpb.Deposit,
+) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "electra.ProcessDeposits")
+	defer span.End()
+	// Attempt to verify all deposit signatures at once, if this fails then fall back to processing
+	// individual deposits with signature verification enabled.
+	batchVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not verify deposit signatures in batch")
+	}
+
+	for _, d := range deposits {
+		if d == nil || d.Data == nil {
+			return nil, errors.New("got a nil deposit in block")
+		}
+		beaconState, err = ProcessDeposit(beaconState, d, batchVerified)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(d.Data.PublicKey))
+		}
+	}
+	return beaconState, nil
+}
+
+// ProcessDeposit takes in a deposit object and inserts it
+// into the registry as a new validator or balance change.
+// Returns the resulting state, a boolean to indicate whether or not the deposit
+// resulted in a new validator entry into the beacon state, and any error.
+//
+// Spec pseudocode definition:
+// def process_deposit(state: BeaconState, deposit: Deposit) -> None:
+//
+//	# Verify the Merkle branch
+//	assert is_valid_merkle_branch(
+//		leaf=hash_tree_root(deposit.data),
+//		branch=deposit.proof,
+//		depth=DEPOSIT_CONTRACT_TREE_DEPTH + 1,  # Add 1 for the List length mix-in
+//		index=state.eth1_deposit_index,
+//		root=state.eth1_data.deposit_root,
+//	)
+//
+//	 # Deposits must be processed in order
+//	 state.eth1_deposit_index += 1
+//
+//	 apply_deposit(
+//	  state=state,
+//	  pubkey=deposit.data.pubkey,
+//	  withdrawal_credentials=deposit.data.withdrawal_credentials,
+//	  amount=deposit.data.amount,
+//	  signature=deposit.data.signature,
+//	 )
+func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
+	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
+		if deposit == nil || deposit.Data == nil {
+			return nil, err
+		}
+		return nil, errors.Wrapf(err, "could not verify deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
+	}
+	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
+		return nil, err
+	}
+	return ApplyDeposit(beaconState, deposit.Data, verifySignature)
+}
+
+// ApplyDeposit
+// def apply_deposit(state: BeaconState, pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> None:
+// validator_pubkeys = [v.pubkey for v in state.validators]
+// if pubkey not in validator_pubkeys:
+//
+//	# Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//	if is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature):
+//	  add_validator_to_registry(state, pubkey, withdrawal_credentials, amount)
+//
+// else:
+//
+//	# Increase balance by deposit amount
+//	index = ValidatorIndex(validator_pubkeys.index(pubkey))
+//	state.pending_balance_deposits.append(PendingBalanceDeposit(index=index, amount=amount))  # [Modified in Electra:EIP-7251]
+//	# Check if valid deposit switch to compounding credentials
+//
+// if ( is_compounding_withdrawal_credential(withdrawal_credentials) and has_eth1_withdrawal_credential(state.validators[index])
+//
+//	 and is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature)
+//	):
+//	 switch_to_compounding_validator(state, index)
+func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
+	pubKey := data.PublicKey
+	amount := data.Amount
+	withdrawalCredentials := data.WithdrawalCredentials
+	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
+	if !ok {
+		if verifySignature {
+			valid, err := IsValidDepositSignature(data)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not verify deposit signature")
+			}
+			if !valid {
+				return beaconState, nil
+			}
+		}
+		if err := AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, amount); err != nil {
+			return nil, errors.Wrap(err, "could not add validator to registry")
+		}
+	} else {
+		// no validation on top-ups (phase0 feature). no validation before state change
+		if err := beaconState.AppendPendingBalanceDeposit(index, amount); err != nil {
+			return nil, err
+		}
+		val, err := beaconState.ValidatorAtIndex(index)
+		if err != nil {
+			return nil, err
+		}
+		if helpers.IsCompoundingWithdrawalCredential(withdrawalCredentials) && helpers.HasETH1WithdrawalCredential(val) {
+			if verifySignature {
+				valid, err := IsValidDepositSignature(data)
+				if err != nil {
+					return nil, errors.Wrap(err, "could not verify deposit signature")
+				}
+				if !valid {
+					return beaconState, nil
+				}
+			}
+			if err := SwitchToCompoundingValidator(beaconState, index); err != nil {
+				return nil, errors.Wrap(err, "could not switch to compound validator")
+			}
+		}
+	}
+	return beaconState, nil
+}
+
+// IsValidDepositSignature returns whether deposit_data is valid
+// def is_valid_deposit_signature(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> bool:
+//
+//	deposit_message = DepositMessage( pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount, )
+//	domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
+//	signing_root = compute_signing_root(deposit_message, domain)
+//	return bls.Verify(pubkey, signing_root, signature)
+func IsValidDepositSignature(data *ethpb.Deposit_Data) (bool, error) {
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	if err != nil {
+		return false, err
+	}
+	if err := verifyDepositDataSigningRoot(data, domain); err != nil {
+		// Ignore this error as in the spec pseudo code.
+		log.WithError(err).Debug("Skipping deposit: could not verify deposit data signature")
+		return false, nil
+	}
+	return true, nil
+}
+
+func verifyDepositDataSigningRoot(obj *ethpb.Deposit_Data, domain []byte) error {
+	return deposit.VerifyDepositSignature(obj, domain)
+}
+
 // ProcessPendingBalanceDeposits implements the spec definition below. This method mutates the state.
 //
 // Spec definition:
@@ -19,12 +193,27 @@ import (
 //	    available_for_processing = state.deposit_balance_to_consume + get_activation_exit_churn_limit(state)
 //	    processed_amount = 0
 //	    next_deposit_index = 0
+//	    deposits_to_postpone = []
 //
 //	    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
+//	        validator = state.validators[deposit.index]
+//	        # Validator is exiting, postpone the deposit until after withdrawable epoch
+//	        if validator.exit_epoch < FAR_FUTURE_EPOCH:
+//	            if get_current_epoch(state) <= validator.withdrawable_epoch:
+//	                deposits_to_postpone.append(deposit)
+//	            # Deposited balance will never become active. Increase balance but do not consume churn
+//	            else:
+//	                increase_balance(state, deposit.index, deposit.amount)
+//	        # Validator is not exiting, attempt to process deposit
+//	        else:
+//	            # Deposit does not fit in the churn, no more deposit processing in this epoch.
+//	            if processed_amount + deposit.amount > available_for_processing:
+//	                break
+//	            # Deposit fits in the churn, process it. Increase balance and consume churn.
+//	            else:
+//	                increase_balance(state, deposit.index, deposit.amount)
+//	                processed_amount += deposit.amount
+//	        # Regardless of how the deposit was handled, we move on in the queue.
 //	        next_deposit_index += 1
 //
 //	    state.pending_balance_deposits = state.pending_balance_deposits[next_deposit_index:]
@@ -33,6 +222,8 @@ import (
 //	        state.deposit_balance_to_consume = Gwei(0)
 //	    else:
 //	        state.deposit_balance_to_consume = available_for_processing - processed_amount
+//
+//	    state.pending_balance_deposits += deposits_to_postpone
 func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, activeBalance primitives.Gwei) error {
 	_, span := trace.StartSpan(ctx, "electra.ProcessPendingBalanceDeposits")
 	defer span.End()
@@ -45,43 +236,137 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 	if err != nil {
 		return err
 	}
-
 	availableForProcessing := depBalToConsume + helpers.ActivationExitChurnLimit(activeBalance)
+	processedAmount := uint64(0)
 	nextDepositIndex := 0
+	var depositsToPostpone []*eth.PendingBalanceDeposit
 
 	deposits, err := st.PendingBalanceDeposits()
 	if err != nil {
 		return err
 	}
 
-	for _, deposit := range deposits {
-		if primitives.Gwei(deposit.Amount) > availableForProcessing {
-			break
+	// constants
+	ffe := params.BeaconConfig().FarFutureEpoch
+	curEpoch := slots.ToEpoch(st.Slot())
+
+	for _, balanceDeposit := range deposits {
+		v, err := st.ValidatorAtIndexReadOnly(balanceDeposit.Index)
+		if err != nil {
+			return fmt.Errorf("failed to fetch validator at index: %w", err)
 		}
-		if err := helpers.IncreaseBalance(st, deposit.Index, deposit.Amount); err != nil {
-			return err
+
+		// If the validator is currently exiting, postpone the deposit until after the withdrawable
+		// epoch.
+		if v.ExitEpoch() < ffe {
+			if curEpoch <= v.WithdrawableEpoch() {
+				depositsToPostpone = append(depositsToPostpone, balanceDeposit)
+			} else {
+				// The deposited balance will never become active. Therefore, we increase the balance but do
+				// not consume the churn.
+				if err := helpers.IncreaseBalance(st, balanceDeposit.Index, balanceDeposit.Amount); err != nil {
+					return err
+				}
+			}
+		} else {
+			// Validator is not exiting, attempt to process deposit.
+			if primitives.Gwei(processedAmount+balanceDeposit.Amount) > availableForProcessing {
+				break
+			}
+			// Deposit fits in churn, process it. Increase balance and consume churn.
+			if err := helpers.IncreaseBalance(st, balanceDeposit.Index, balanceDeposit.Amount); err != nil {
+				return err
+			}
+			processedAmount += balanceDeposit.Amount
 		}
-		availableForProcessing -= primitives.Gwei(deposit.Amount)
+
+		// Regardless of how the deposit was handled, we move on in the queue.
 		nextDepositIndex++
 	}
 
-	deposits = deposits[nextDepositIndex:]
+	// Combined operation:
+	// - state.pending_balance_deposits = state.pending_balance_deposits[next_deposit_index:]
+	// - state.pending_balance_deposits += deposits_to_postpone
+	// However, the number of remaining deposits must be maintained to properly update the deposit
+	// balance to consume.
+	numRemainingDeposits := len(deposits[nextDepositIndex:])
+	deposits = append(deposits[nextDepositIndex:], depositsToPostpone...)
 	if err := st.SetPendingBalanceDeposits(deposits); err != nil {
 		return err
 	}
 
-	if len(deposits) == 0 {
+	if numRemainingDeposits == 0 {
 		return st.SetDepositBalanceToConsume(0)
 	} else {
-		return st.SetDepositBalanceToConsume(availableForProcessing)
+		return st.SetDepositBalanceToConsume(availableForProcessing - primitives.Gwei(processedAmount))
 	}
 }
 
 // ProcessDepositRequests is a function as part of electra to process execution layer deposits
 func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState, requests []*enginev1.DepositRequest) (state.BeaconState, error) {
-	_, span := trace.StartSpan(ctx, "electra.ProcessDepositRequests")
+	ctx, span := trace.StartSpan(ctx, "electra.ProcessDepositRequests")
 	defer span.End()
-	// TODO: replace with 6110 logic
-	// return b.ProcessDepositRequests(beaconState, requests)
+
+	if len(requests) == 0 {
+		log.Debug("ProcessDepositRequests: no deposit requests found")
+		return beaconState, nil
+	}
+
+	deposits := make([]*ethpb.Deposit, 0)
+	for _, req := range requests {
+		if req == nil {
+			return nil, errors.New("got a nil DepositRequest")
+		}
+		deposits = append(deposits, &ethpb.Deposit{
+			Data: &ethpb.Deposit_Data{
+				PublicKey:             req.Pubkey,
+				WithdrawalCredentials: req.WithdrawalCredentials,
+				Amount:                req.Amount,
+				Signature:             req.Signature,
+			},
+		})
+	}
+	batchVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not verify deposit signatures in batch")
+	}
+	for _, receipt := range requests {
+		beaconState, err = processDepositRequest(beaconState, receipt, batchVerified)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not apply deposit request")
+		}
+	}
 	return beaconState, nil
 }
+
+// processDepositRequest processes the specific deposit receipt
+// def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
+//
+//	# Set deposit request start index
+//	if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUEST_START_INDEX:
+//	    state.deposit_requests_start_index = deposit_request.index
+//
+//	apply_deposit(
+//	    state=state,
+//	    pubkey=deposit_request.pubkey,
+//	    withdrawal_credentials=deposit_request.withdrawal_credentials,
+//	    amount=deposit_request.amount,
+//	    signature=deposit_request.signature,
+//	)
+func processDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest, verifySignature bool) (state.BeaconState, error) {
+	requestsStartIndex, err := beaconState.DepositRequestsStartIndex()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get deposit requests start index")
+	}
+	if requestsStartIndex == params.BeaconConfig().UnsetDepositRequestsStartIndex {
+		if err := beaconState.SetDepositRequestsStartIndex(request.Index); err != nil {
+			return nil, errors.Wrap(err, "could not set deposit requests start index")
+		}
+	}
+	return ApplyDeposit(beaconState, &ethpb.Deposit_Data{
+		PublicKey:             bytesutil.SafeCopyBytes(request.Pubkey),
+		Amount:                request.Amount,
+		WithdrawalCredentials: bytesutil.SafeCopyBytes(request.WithdrawalCredentials),
+		Signature:             bytesutil.SafeCopyBytes(request.Signature),
+	}, verifySignature)
+}

beacon-chain/core/electra/deposits_test.go

@@ -6,11 +6,18 @@ import (
 
 	"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/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"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
 func TestProcessPendingBalanceDeposits(t *testing.T) {
@@ -100,6 +107,80 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 					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))
+			},
+		},
+		{
+			name: "exiting validator deposit postponed",
+			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))
+				v, err := st.ValidatorAtIndex(0)
+				require.NoError(t, err)
+				v.ExitEpoch = 10
+				v.WithdrawableEpoch = 20
+				require.NoError(t, st.UpdateValidatorAtIndex(0, v))
+				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 1..4 should have their balance increased
+				for i := primitives.ValidatorIndex(1); 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, except validator index 0 was
+				// added back to the pending deposits queue.
+				remaining, err := st.PendingBalanceDeposits()
+				require.NoError(t, err)
+				require.Equal(t, 1, len(remaining))
+			},
+		},
+		{
+			name: "exited validator balance increased",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 1_000)
+				deps := make([]*eth.PendingBalanceDeposit, 1)
+				for i := 0; i < len(deps); i += 1 {
+					deps[i] = &eth.PendingBalanceDeposit{
+						Amount: 1_000_000,
+						Index:  primitives.ValidatorIndex(i),
+					}
+				}
+				require.NoError(t, st.SetPendingBalanceDeposits(deps))
+				v, err := st.ValidatorAtIndex(0)
+				require.NoError(t, err)
+				v.ExitEpoch = 2
+				v.WithdrawableEpoch = 8
+				require.NoError(t, st.UpdateValidatorAtIndex(0, v))
+				require.NoError(t, st.UpdateBalancesAtIndex(0, 100_000))
+				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)
+				b, err := st.BalanceAtIndex(0)
+				require.NoError(t, err)
+				require.Equal(t, uint64(1_100_000), b)
+
 				// All of the balance deposits should have been processed.
 				remaining, err := st.PendingBalanceDeposits()
 				require.NoError(t, err)
@@ -126,3 +207,194 @@ func TestProcessPendingBalanceDeposits(t *testing.T) {
 		})
 	}
 }
+
+func TestProcessDepositRequests(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, 1)
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+
+	t.Run("empty requests continues", func(t *testing.T) {
+		newSt, err := electra.ProcessDepositRequests(context.Background(), st, []*enginev1.DepositRequest{})
+		require.NoError(t, err)
+		require.DeepEqual(t, newSt, st)
+	})
+	t.Run("nil request errors", func(t *testing.T) {
+		_, err = electra.ProcessDepositRequests(context.Background(), st, []*enginev1.DepositRequest{nil})
+		require.ErrorContains(t, "got a nil DepositRequest", err)
+	})
+
+	vals := st.Validators()
+	vals[0].PublicKey = sk.PublicKey().Marshal()
+	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	require.NoError(t, st.SetValidators(vals))
+	bals := st.Balances()
+	bals[0] = params.BeaconConfig().MinActivationBalance + 2000
+	require.NoError(t, st.SetBalances(bals))
+	require.NoError(t, st.SetPendingBalanceDeposits(make([]*eth.PendingBalanceDeposit, 0))) // reset pbd as the determinitstic state populates this already
+	withdrawalCred := make([]byte, 32)
+	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	depositMessage := &eth.DepositMessage{
+		PublicKey:             sk.PublicKey().Marshal(),
+		Amount:                1000,
+		WithdrawalCredentials: withdrawalCred,
+	}
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	require.NoError(t, err)
+	sr, err := signing.ComputeSigningRoot(depositMessage, domain)
+	require.NoError(t, err)
+	sig := sk.Sign(sr[:])
+	requests := []*enginev1.DepositRequest{
+		{
+			Pubkey:                depositMessage.PublicKey,
+			Index:                 0,
+			WithdrawalCredentials: depositMessage.WithdrawalCredentials,
+			Amount:                depositMessage.Amount,
+			Signature:             sig.Marshal(),
+		},
+	}
+	st, err = electra.ProcessDepositRequests(context.Background(), st, requests)
+	require.NoError(t, err)
+
+	pbd, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 2, len(pbd))
+	require.Equal(t, uint64(1000), pbd[0].Amount)
+	require.Equal(t, uint64(2000), pbd[1].Amount)
+}
+
+func TestProcessDeposit_Electra_Simple(t *testing.T) {
+	deps, _, err := util.DeterministicDepositsAndKeysSameValidator(3)
+	require.NoError(t, err)
+	eth1Data, err := util.DeterministicEth1Data(len(deps))
+	require.NoError(t, err)
+	registry := []*eth.Validator{
+		{
+			PublicKey:             []byte{1},
+			WithdrawalCredentials: []byte{1, 2, 3},
+		},
+	}
+	balances := []uint64{0}
+	st, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data:   eth1Data,
+		Fork: &eth.Fork{
+			PreviousVersion: params.BeaconConfig().ElectraForkVersion,
+			CurrentVersion:  params.BeaconConfig().ElectraForkVersion,
+		},
+	})
+	require.NoError(t, err)
+	pdSt, err := electra.ProcessDeposits(context.Background(), st, deps)
+	require.NoError(t, err)
+	pbd, err := pdSt.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MinActivationBalance, pbd[2].Amount)
+	require.Equal(t, 3, len(pbd))
+}
+
+func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
+	// Same test settings as in TestProcessDeposit_AddsNewValidatorDeposit, except that we use an invalid signature
+	dep, _, err := util.DeterministicDepositsAndKeys(1)
+	require.NoError(t, err)
+	dep[0].Data.Signature = make([]byte, 96)
+	dt, _, err := util.DepositTrieFromDeposits(dep)
+	require.NoError(t, err)
+	root, err := dt.HashTreeRoot()
+	require.NoError(t, err)
+	eth1Data := &eth.Eth1Data{
+		DepositRoot:  root[:],
+		DepositCount: 1,
+	}
+	registry := []*eth.Validator{
+		{
+			PublicKey:             []byte{1},
+			WithdrawalCredentials: []byte{1, 2, 3},
+		},
+	}
+	balances := []uint64{0}
+	beaconState, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{
+		Validators: registry,
+		Balances:   balances,
+		Eth1Data:   eth1Data,
+		Fork: &eth.Fork{
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+		},
+	})
+	require.NoError(t, err)
+	newState, err := electra.ProcessDeposit(beaconState, dep[0], true)
+	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
+
+	if newState.Eth1DepositIndex() != 1 {
+		t.Errorf(
+			"Expected Eth1DepositIndex to be increased by 1 after processing an invalid deposit, received change: %v",
+			newState.Eth1DepositIndex(),
+		)
+	}
+	if len(newState.Validators()) != 1 {
+		t.Errorf("Expected validator list to have length 1, received: %v", len(newState.Validators()))
+	}
+	if len(newState.Balances()) != 1 {
+		t.Errorf("Expected validator balances list to have length 1, received: %v", len(newState.Balances()))
+	}
+	if newState.Balances()[0] != 0 {
+		t.Errorf("Expected validator balance at index 0 to stay 0, received: %v", newState.Balances()[0])
+	}
+}
+
+func TestApplyDeposit_TopUps_WithBadSignature(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, 3)
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	withdrawalCred := make([]byte, 32)
+	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	topUpAmount := uint64(1234)
+	depositData := &eth.Deposit_Data{
+		PublicKey:             sk.PublicKey().Marshal(),
+		Amount:                topUpAmount,
+		WithdrawalCredentials: withdrawalCred,
+		Signature:             make([]byte, fieldparams.BLSSignatureLength),
+	}
+	vals := st.Validators()
+	vals[0].PublicKey = sk.PublicKey().Marshal()
+	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	require.NoError(t, st.SetValidators(vals))
+	adSt, err := electra.ApplyDeposit(st, depositData, true)
+	require.NoError(t, err)
+	pbd, err := adSt.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(pbd))
+	require.Equal(t, topUpAmount, pbd[0].Amount)
+}
+
+func TestApplyDeposit_Electra_SwitchToCompoundingValidator(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, 3)
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	withdrawalCred := make([]byte, 32)
+	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	depositData := &eth.Deposit_Data{
+		PublicKey:             sk.PublicKey().Marshal(),
+		Amount:                1000,
+		WithdrawalCredentials: withdrawalCred,
+		Signature:             make([]byte, fieldparams.BLSSignatureLength),
+	}
+	vals := st.Validators()
+	vals[0].PublicKey = sk.PublicKey().Marshal()
+	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	require.NoError(t, st.SetValidators(vals))
+	bals := st.Balances()
+	bals[0] = params.BeaconConfig().MinActivationBalance + 2000
+	require.NoError(t, st.SetBalances(bals))
+	sr, err := signing.ComputeSigningRoot(depositData, bytesutil.ToBytes(3, 32))
+	require.NoError(t, err)
+	sig := sk.Sign(sr[:])
+	depositData.Signature = sig.Marshal()
+	adSt, err := electra.ApplyDeposit(st, depositData, false)
+	require.NoError(t, err)
+	pbd, err := adSt.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 2, len(pbd))
+	require.Equal(t, uint64(1000), pbd[0].Amount)
+	require.Equal(t, uint64(2000), pbd[1].Amount)
+}

beacon-chain/core/electra/effective_balance_updates.go

@@ -56,7 +56,7 @@ func ProcessEffectiveBalanceUpdates(state state.BeaconState) error {
 		if balance+downwardThreshold < val.EffectiveBalance || val.EffectiveBalance+upwardThreshold < balance {
 			effectiveBal := min(balance-balance%effBalanceInc, effectiveBalanceLimit)
 			val.EffectiveBalance = effectiveBal
-			return false, val, nil
+			return true, val, nil
 		}
 		return false, val, nil
 	}

beacon-chain/core/electra/registry_updates.go

@@ -2,12 +2,19 @@ package electra
 
 import (
 	"context"
+	"errors"
+	"fmt"
 
+	"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"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
-// ProcessRegistryUpdates rotates validators in and out of active pool.
-// the amount to rotate is determined churn limit.
+// ProcessRegistryUpdates processes all validators eligible for the activation queue, all validators
+// which should be ejected, and all validators which are eligible for activation from the queue.
 //
 // Spec pseudocode definition:
 //
@@ -28,7 +35,72 @@ import (
 //	         for validator in state.validators:
 //	             if is_eligible_for_activation(state, validator):
 //	                 validator.activation_epoch = activation_epoch
-func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
-	// TODO: replace with real implementation
-	return state, nil
+func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) error {
+	currentEpoch := time.CurrentEpoch(st)
+	ejectionBal := params.BeaconConfig().EjectionBalance
+	activationEpoch := helpers.ActivationExitEpoch(currentEpoch)
+
+	// To avoid copying the state validator set via st.Validators(), we will perform a read only pass
+	// over the validator set while collecting validator indices where the validator copy is actually
+	// necessary, then we will process these operations.
+	eligibleForActivationQ := make([]primitives.ValidatorIndex, 0)
+	eligibleForEjection := make([]primitives.ValidatorIndex, 0)
+	eligibleForActivation := make([]primitives.ValidatorIndex, 0)
+
+	if err := st.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
+		// Collect validators eligible to enter the activation queue.
+		if helpers.IsEligibleForActivationQueue(val, currentEpoch) {
+			eligibleForActivationQ = append(eligibleForActivationQ, primitives.ValidatorIndex(idx))
+		}
+
+		// Collect validators to eject.
+		if val.EffectiveBalance() <= ejectionBal && helpers.IsActiveValidatorUsingTrie(val, currentEpoch) {
+			eligibleForEjection = append(eligibleForEjection, primitives.ValidatorIndex(idx))
+		}
+
+		// Collect validators eligible for activation and not yet dequeued for activation.
+		if helpers.IsEligibleForActivationUsingROVal(st, val) {
+			eligibleForActivation = append(eligibleForActivation, primitives.ValidatorIndex(idx))
+		}
+
+		return nil
+	}); err != nil {
+		return fmt.Errorf("failed to read validators: %w", err)
+	}
+
+	// Handle validators eligible to join the activation queue.
+	for _, idx := range eligibleForActivationQ {
+		v, err := st.ValidatorAtIndex(idx)
+		if err != nil {
+			return err
+		}
+		v.ActivationEligibilityEpoch = currentEpoch + 1
+		if err := st.UpdateValidatorAtIndex(idx, v); err != nil {
+			return fmt.Errorf("failed to updated eligible validator at index %d: %w", idx, err)
+		}
+	}
+
+	// Handle validator ejections.
+	for _, idx := range eligibleForEjection {
+		var err error
+		// exitQueueEpoch and churn arguments are not used in electra.
+		st, _, err = validators.InitiateValidatorExit(ctx, st, idx, 0 /*exitQueueEpoch*/, 0 /*churn*/)
+		if err != nil && !errors.Is(err, validators.ErrValidatorAlreadyExited) {
+			return fmt.Errorf("failed to initiate validator exit at index %d: %w", idx, err)
+		}
+	}
+
+	for _, idx := range eligibleForActivation {
+		// Activate all eligible validators.
+		v, err := st.ValidatorAtIndex(idx)
+		if err != nil {
+			return err
+		}
+		v.ActivationEpoch = activationEpoch
+		if err := st.UpdateValidatorAtIndex(idx, v); err != nil {
+			return fmt.Errorf("failed to activate validator at index %d: %w", idx, err)
+		}
+	}
+
+	return nil
 }

beacon-chain/core/electra/registry_updates_test.go

@@ -0,0 +1,171 @@
+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"
+	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"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func TestProcessRegistryUpdates(t *testing.T) {
+	finalizedEpoch := primitives.Epoch(4)
+
+	tests := []struct {
+		name  string
+		state state.BeaconState
+		check func(*testing.T, state.BeaconState)
+	}{
+		{
+			name: "No rotation",
+			state: func() state.BeaconState {
+				base := &eth.BeaconStateElectra{
+					Slot: 5 * params.BeaconConfig().SlotsPerEpoch,
+					Validators: []*eth.Validator{
+						{ExitEpoch: params.BeaconConfig().MaxSeedLookahead},
+						{ExitEpoch: params.BeaconConfig().MaxSeedLookahead},
+					},
+					Balances: []uint64{
+						params.BeaconConfig().MaxEffectiveBalance,
+						params.BeaconConfig().MaxEffectiveBalance,
+					},
+					FinalizedCheckpoint: &eth.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
+				}
+				st, err := state_native.InitializeFromProtoElectra(base)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				for i, val := range st.Validators() {
+					require.Equal(t, params.BeaconConfig().MaxSeedLookahead, val.ExitEpoch, "validator updated unexpectedly at index %d", i)
+				}
+			},
+		},
+		{
+			name: "Validators are activated",
+			state: func() state.BeaconState {
+				base := &eth.BeaconStateElectra{
+					Slot:                5 * params.BeaconConfig().SlotsPerEpoch,
+					FinalizedCheckpoint: &eth.Checkpoint{Epoch: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
+				}
+				for i := uint64(0); i < 10; i++ {
+					base.Validators = append(base.Validators, &eth.Validator{
+						ActivationEligibilityEpoch: finalizedEpoch,
+						EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
+						ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
+					})
+				}
+				st, err := state_native.InitializeFromProtoElectra(base)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				activationEpoch := helpers.ActivationExitEpoch(5)
+				// All validators should be activated.
+				for i, val := range st.Validators() {
+					require.Equal(t, activationEpoch, val.ActivationEpoch, "failed to update validator at index %d", i)
+				}
+			},
+		},
+		{
+			name: "Validators are exited",
+			state: func() state.BeaconState {
+				base := &eth.BeaconStateElectra{
+					Slot:                5 * params.BeaconConfig().SlotsPerEpoch,
+					FinalizedCheckpoint: &eth.Checkpoint{Epoch: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
+				}
+				for i := uint64(0); i < 10; i++ {
+					base.Validators = append(base.Validators, &eth.Validator{
+						EffectiveBalance:  params.BeaconConfig().EjectionBalance - 1,
+						ExitEpoch:         params.BeaconConfig().FarFutureEpoch,
+						WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
+					})
+				}
+				st, err := state_native.InitializeFromProtoElectra(base)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				// All validators should be exited
+				for i, val := range st.Validators() {
+					require.NotEqual(t, params.BeaconConfig().FarFutureEpoch, val.ExitEpoch, "failed to update exit epoch on validator %d", i)
+					require.NotEqual(t, params.BeaconConfig().FarFutureEpoch, val.WithdrawableEpoch, "failed to update withdrawable epoch on validator %d", i)
+				}
+			},
+		},
+		{
+			name: "Validators are exiting",
+			state: func() state.BeaconState {
+				base := &eth.BeaconStateElectra{
+					Slot:                5 * params.BeaconConfig().SlotsPerEpoch,
+					FinalizedCheckpoint: &eth.Checkpoint{Epoch: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
+				}
+				for i := uint64(0); i < 10; i++ {
+					base.Validators = append(base.Validators, &eth.Validator{
+						EffectiveBalance:  params.BeaconConfig().EjectionBalance - 1,
+						ExitEpoch:         10,
+						WithdrawableEpoch: 20,
+					})
+				}
+				st, err := state_native.InitializeFromProtoElectra(base)
+				require.NoError(t, err)
+				return st
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				// All validators should be exited
+				for i, val := range st.Validators() {
+					require.NotEqual(t, params.BeaconConfig().FarFutureEpoch, val.ExitEpoch, "failed to update exit epoch on validator %d", i)
+					require.NotEqual(t, params.BeaconConfig().FarFutureEpoch, val.WithdrawableEpoch, "failed to update withdrawable epoch on validator %d", i)
+				}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := electra.ProcessRegistryUpdates(context.TODO(), tt.state)
+			require.NoError(t, err)
+			if tt.check != nil {
+				tt.check(t, tt.state)
+			}
+		})
+	}
+}
+
+func Benchmark_ProcessRegistryUpdates_MassEjection(b *testing.B) {
+	bal := params.BeaconConfig().EjectionBalance - 1
+	ffe := params.BeaconConfig().FarFutureEpoch
+	genValidators := func(num uint64) []*eth.Validator {
+		vals := make([]*eth.Validator, num)
+		for i := range vals {
+			vals[i] = &eth.Validator{
+				EffectiveBalance: bal,
+				ExitEpoch:        ffe,
+			}
+		}
+		return vals
+	}
+
+	st, err := util.NewBeaconStateElectra()
+	require.NoError(b, err)
+
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		if err := st.SetValidators(genValidators(100000)); err != nil {
+			panic(err)
+		}
+		b.StartTimer()
+
+		if err := electra.ProcessRegistryUpdates(context.TODO(), st); err != nil {
+			panic(err)
+		}
+	}
+}

beacon-chain/core/electra/transition.go

@@ -2,12 +2,15 @@ package electra
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	e "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"go.opencensus.io/trace"
 )
@@ -74,8 +77,7 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 		return errors.Wrap(err, "could not process rewards and penalties")
 	}
 
-	state, err = ProcessRegistryUpdates(ctx, state)
-	if err != nil {
+	if err := ProcessRegistryUpdates(ctx, state); err != nil {
 		return errors.Wrap(err, "could not process registry updates")
 	}
 
@@ -127,3 +129,33 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 
 	return nil
 }
+
+// VerifyBlockDepositLength
+//
+// Spec definition:
+//
+//	# [Modified in Electra:EIP6110]
+//	  # Disable former deposit mechanism once all prior deposits are processed
+//	  eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_requests_start_index)
+//	  if state.eth1_deposit_index < eth1_deposit_index_limit:
+//	      assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
+//	  else:
+//	      assert len(body.deposits) == 0
+func VerifyBlockDepositLength(body interfaces.ReadOnlyBeaconBlockBody, state state.BeaconState) error {
+	eth1Data := state.Eth1Data()
+	requestsStartIndex, err := state.DepositRequestsStartIndex()
+	if err != nil {
+		return errors.Wrap(err, "failed to get requests start index")
+	}
+	eth1DepositIndexLimit := min(eth1Data.DepositCount, requestsStartIndex)
+	if state.Eth1DepositIndex() < eth1DepositIndexLimit {
+		if uint64(len(body.Deposits())) != min(params.BeaconConfig().MaxDeposits, eth1DepositIndexLimit-state.Eth1DepositIndex()) {
+			return fmt.Errorf("incorrect outstanding deposits in block body, wanted: %d, got: %d", min(params.BeaconConfig().MaxDeposits, eth1DepositIndexLimit-state.Eth1DepositIndex()), len(body.Deposits()))
+		}
+	} else {
+		if len(body.Deposits()) != 0 {
+			return fmt.Errorf("incorrect outstanding deposits in block body, wanted: %d, got: %d", 0, len(body.Deposits()))
+		}
+	}
+	return nil
+}

beacon-chain/core/electra/transition_no_verify_sig.go

@@ -0,0 +1,101 @@
+package electra
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+)
+
+var (
+	ProcessBLSToExecutionChanges = blocks.ProcessBLSToExecutionChanges
+	ProcessVoluntaryExits        = blocks.ProcessVoluntaryExits
+	ProcessAttesterSlashings     = blocks.ProcessAttesterSlashings
+	ProcessProposerSlashings     = blocks.ProcessProposerSlashings
+)
+
+// ProcessOperations
+//
+// Spec definition:
+//
+//	def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
+//	    # [Modified in Electra:EIP6110]
+//	    # Disable former deposit mechanism once all prior deposits are processed
+//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_requests_start_index)
+//	    if state.eth1_deposit_index < eth1_deposit_index_limit:
+//	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
+//	    else:
+//	        assert len(body.deposits) == 0
+//
+//	    def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
+//	        for operation in operations:
+//	            fn(state, operation)
+//
+//	    for_ops(body.proposer_slashings, process_proposer_slashing)
+//	    for_ops(body.attester_slashings, process_attester_slashing)
+//	    for_ops(body.attestations, process_attestation)  # [Modified in Electra:EIP7549]
+//	    for_ops(body.deposits, process_deposit)  # [Modified in Electra:EIP7251]
+//	    for_ops(body.voluntary_exits, process_voluntary_exit)  # [Modified in Electra:EIP7251]
+//	    for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
+//	    # [New in Electra:EIP7002:EIP7251]
+//	    for_ops(body.execution_payload.withdrawal_requests, process_execution_layer_withdrawal_request)
+//	    for_ops(body.execution_payload.deposit_requests, process_deposit_requests)  # [New in Electra:EIP6110]
+//	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
+func ProcessOperations(
+	ctx context.Context,
+	st state.BeaconState,
+	block interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
+	// 6110 validations are in VerifyOperationLengths
+	bb := block.Body()
+	// Electra extends the altair operations.
+	st, err := ProcessProposerSlashings(ctx, st, bb.ProposerSlashings(), v.SlashValidator)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process altair proposer slashing")
+	}
+	st, err = ProcessAttesterSlashings(ctx, st, bb.AttesterSlashings(), v.SlashValidator)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process altair attester slashing")
+	}
+	st, err = ProcessAttestationsNoVerifySignature(ctx, st, block)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process altair attestation")
+	}
+	if _, err := ProcessDeposits(ctx, st, bb.Deposits()); err != nil { // new in electra
+		return nil, errors.Wrap(err, "could not process altair deposit")
+	}
+	st, err = ProcessVoluntaryExits(ctx, st, bb.VoluntaryExits())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process voluntary exits")
+	}
+	st, err = ProcessBLSToExecutionChanges(st, block)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process bls-to-execution changes")
+	}
+	// new in electra
+	e, err := bb.Execution()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution data from block")
+	}
+	exe, ok := e.(interfaces.ExecutionDataElectra)
+	if !ok {
+		return nil, errors.New("could not cast execution data to electra execution data")
+	}
+	st, err = ProcessWithdrawalRequests(ctx, st, exe.WithdrawalRequests())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process execution layer withdrawal requests")
+	}
+
+	st, err = ProcessDepositRequests(ctx, st, exe.DepositRequests()) // TODO: EIP-6110 deposit changes.
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process deposit receipts")
+	}
+
+	if err := ProcessConsolidationRequests(ctx, st, exe.ConsolidationRequests()); err != nil {
+		return nil, fmt.Errorf("could not process consolidation requests: %w", err)
+	}
+	return st, nil
+}

beacon-chain/core/electra/transition_test.go

@@ -0,0 +1,49 @@
+package electra_test
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+)
+
+func TestVerifyOperationLengths_Electra(t *testing.T) {
+	t.Run("happy path", func(t *testing.T) {
+		s, _ := util.DeterministicGenesisStateElectra(t, 1)
+		sb, err := consensusblocks.NewSignedBeaconBlock(util.NewBeaconBlockElectra())
+		require.NoError(t, err)
+		require.NoError(t, electra.VerifyBlockDepositLength(sb.Block().Body(), s))
+	})
+	t.Run("eth1depositIndex less than eth1depositIndexLimit & number of deposits incorrect", func(t *testing.T) {
+		s, _ := util.DeterministicGenesisStateElectra(t, 1)
+		sb, err := consensusblocks.NewSignedBeaconBlock(util.NewBeaconBlockElectra())
+		require.NoError(t, err)
+		require.NoError(t, s.SetEth1DepositIndex(0))
+		require.NoError(t, s.SetDepositRequestsStartIndex(1))
+		err = electra.VerifyBlockDepositLength(sb.Block().Body(), s)
+		require.ErrorContains(t, "incorrect outstanding deposits in block body", err)
+	})
+	t.Run("eth1depositIndex more than eth1depositIndexLimit & number of deposits is not 0", func(t *testing.T) {
+		s, _ := util.DeterministicGenesisStateElectra(t, 1)
+		sb, err := consensusblocks.NewSignedBeaconBlock(util.NewBeaconBlockElectra())
+		require.NoError(t, err)
+		sb.SetDeposits([]*ethpb.Deposit{
+			{
+				Data: &ethpb.Deposit_Data{
+					PublicKey:             []byte{1, 2, 3},
+					Amount:                1000,
+					WithdrawalCredentials: make([]byte, common.AddressLength),
+					Signature:             []byte{4, 5, 6},
+				},
+			},
+		})
+		require.NoError(t, s.SetEth1DepositIndex(1))
+		require.NoError(t, s.SetDepositRequestsStartIndex(1))
+		err = electra.VerifyBlockDepositLength(sb.Block().Body(), s)
+		require.ErrorContains(t, "incorrect outstanding deposits in block body", err)
+	})
+}

beacon-chain/core/electra/upgrade.go

@@ -244,25 +244,26 @@ func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 		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,
-			DepositRequestsRoot:    bytesutil.Bytes32(0), // [New in Electra:EIP6110]
-			WithdrawalRequestsRoot: bytesutil.Bytes32(0), // [New in Electra:EIP7002]
+			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,
+			DepositRequestsRoot:       bytesutil.Bytes32(0), // [New in Electra:EIP6110]
+			WithdrawalRequestsRoot:    bytesutil.Bytes32(0), // [New in Electra:EIP7002]
+			ConsolidationRequestsRoot: bytesutil.Bytes32(0), // [New in Electra:EIP7251]
 		},
 		NextWithdrawalIndex:          wi,
 		NextWithdrawalValidatorIndex: vi,
@@ -295,14 +296,14 @@ func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 	}
 
 	for _, index := range preActivationIndices {
-		if err := helpers.QueueEntireBalanceAndResetValidator(post, index); err != nil {
+		if err := 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 {
+		if err := QueueExcessActiveBalance(post, index); err != nil {
 			return nil, errors.Wrap(err, "failed to queue excess active balance")
 		}
 	}

beacon-chain/core/electra/upgrade_test.go

@@ -113,23 +113,24 @@ func TestUpgradeToElectra(t *testing.T) {
 	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,
-		DepositRequestsRoot:    bytesutil.Bytes32(0),
-		WithdrawalRequestsRoot: bytesutil.Bytes32(0),
+		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,
+		DepositRequestsRoot:       bytesutil.Bytes32(0),
+		WithdrawalRequestsRoot:    bytesutil.Bytes32(0),
+		ConsolidationRequestsRoot: bytesutil.Bytes32(0),
 	}
 	require.DeepEqual(t, wanted, protoHeader)
 

beacon-chain/core/electra/validator.go

@@ -1,15 +1,80 @@
 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"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
+// AddValidatorToRegistry updates the beacon state with validator information
+// def add_validator_to_registry(state: BeaconState,
+//
+//	                          pubkey: BLSPubkey,
+//	                          withdrawal_credentials: Bytes32,
+//	                          amount: uint64) -> None:
+//	index = get_index_for_new_validator(state)
+//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials)
+//	set_or_append_list(state.validators, index, validator)
+//	set_or_append_list(state.balances, index, 0)  # [Modified in Electra:EIP7251]
+//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000))
+//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000))
+//	set_or_append_list(state.inactivity_scores, index, uint64(0))
+//	state.pending_balance_deposits.append(PendingBalanceDeposit(index=index, amount=amount))  # [New in Electra:EIP7251]
+func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
+	val := ValidatorFromDeposit(pubKey, withdrawalCredentials)
+	if err := beaconState.AppendValidator(val); err != nil {
+		return err
+	}
+	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
+	if !ok {
+		return errors.New("could not find validator in registry")
+	}
+	if err := beaconState.AppendBalance(0); err != nil {
+		return err
+	}
+	if err := beaconState.AppendPendingBalanceDeposit(index, amount); err != nil {
+		return err
+	}
+	if err := beaconState.AppendInactivityScore(0); err != nil {
+		return err
+	}
+	if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
+		return err
+	}
+	return beaconState.AppendCurrentParticipationBits(0)
+}
+
+// ValidatorFromDeposit gets a new validator object with provided parameters
+//
+// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32) -> Validator:
+//
+//	return Validator(
+//	pubkey=pubkey,
+//	withdrawal_credentials=withdrawal_credentials,
+//	activation_eligibility_epoch=FAR_FUTURE_EPOCH,
+//	activation_epoch=FAR_FUTURE_EPOCH,
+//	exit_epoch=FAR_FUTURE_EPOCH,
+//	withdrawable_epoch=FAR_FUTURE_EPOCH,
+//	effective_balance=0,  # [Modified in Electra:EIP7251]
+//
+// )
+func ValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte) *ethpb.Validator {
+	return &ethpb.Validator{
+		PublicKey:                  pubKey,
+		WithdrawalCredentials:      withdrawalCredentials,
+		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
+		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+		EffectiveBalance:           0, // [Modified in Electra:EIP7251]
+	}
+}
+
 // SwitchToCompoundingValidator
 //
 // Spec definition:
@@ -19,7 +84,7 @@ import (
 //		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 {
+func SwitchToCompoundingValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
 	v, err := s.ValidatorAtIndex(idx)
 	if err != nil {
 		return err
@@ -32,12 +97,12 @@ func SwitchToCompoundingValidator(ctx context.Context, s state.BeaconState, idx
 		if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
 			return err
 		}
-		return queueExcessActiveBalance(ctx, s, idx)
+		return QueueExcessActiveBalance(s, idx)
 	}
 	return nil
 }
 
-// queueExcessActiveBalance
+// QueueExcessActiveBalance queues validators with balances above the min activation balance and adds to pending balance deposit.
 //
 // Spec definition:
 //
@@ -49,7 +114,7 @@ func SwitchToCompoundingValidator(ctx context.Context, s state.BeaconState, idx
 //	        state.pending_balance_deposits.append(
 //	            PendingBalanceDeposit(index=index, amount=excess_balance)
 //	        )
-func queueExcessActiveBalance(ctx context.Context, s state.BeaconState, idx primitives.ValidatorIndex) error {
+func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex) error {
 	bal, err := s.BalanceAtIndex(idx)
 	if err != nil {
 		return err
@@ -80,7 +145,7 @@ func queueExcessActiveBalance(ctx context.Context, s state.BeaconState, idx prim
 //	    )
 //
 //nolint:dupword
-func QueueEntireBalanceAndResetValidator(ctx context.Context, s state.BeaconState, idx primitives.ValidatorIndex) error {
+func QueueEntireBalanceAndResetValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
 	bal, err := s.BalanceAtIndex(idx)
 	if err != nil {
 		return err

beacon-chain/core/electra/validator_test.go

@@ -2,17 +2,32 @@ 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"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"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/testing/util"
 )
 
+func TestAddValidatorToRegistry(t *testing.T) {
+	st, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{})
+	require.NoError(t, err)
+	require.NoError(t, electra.AddValidatorToRegistry(st, make([]byte, fieldparams.BLSPubkeyLength), make([]byte, fieldparams.RootLength), 100))
+	balances := st.Balances()
+	require.Equal(t, 1, len(balances))
+	require.Equal(t, uint64(0), balances[0])
+	pbds, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(pbds))
+	require.Equal(t, uint64(100), pbds[0].Amount)
+	require.Equal(t, primitives.ValidatorIndex(0), pbds[0].Index)
+}
+
 func TestSwitchToCompoundingValidator(t *testing.T) {
 	s, err := state_native.InitializeFromProtoElectra(&eth.BeaconStateElectra{
 		Validators: []*eth.Validator{
@@ -34,10 +49,10 @@ func TestSwitchToCompoundingValidator(t *testing.T) {
 	})
 	// 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))
+	require.ErrorContains(t, "validator has no withdrawal credentials", electra.SwitchToCompoundingValidator(s, 0))
 
 	// Test that a validator with withdrawal credentials can be switched to compounding.
-	require.NoError(t, electra.SwitchToCompoundingValidator(context.TODO(), s, 1))
+	require.NoError(t, electra.SwitchToCompoundingValidator(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")
@@ -50,7 +65,7 @@ func TestSwitchToCompoundingValidator(t *testing.T) {
 	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))
+	require.NoError(t, electra.SwitchToCompoundingValidator(s, 2))
 	b, err = s.BalanceAtIndex(2)
 	require.NoError(t, err)
 	require.Equal(t, params.BeaconConfig().MinActivationBalance, b, "balance was not changed")
@@ -74,7 +89,7 @@ func TestQueueEntireBalanceAndResetValidator(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	require.NoError(t, electra.QueueEntireBalanceAndResetValidator(context.TODO(), s, 0))
+	require.NoError(t, electra.QueueEntireBalanceAndResetValidator(s, 0))
 	b, err := s.BalanceAtIndex(0)
 	require.NoError(t, err)
 	require.Equal(t, uint64(0), b, "balance was not changed")
@@ -88,3 +103,57 @@ func TestQueueEntireBalanceAndResetValidator(t *testing.T) {
 	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")
 }
+
+func TestSwitchToCompoundingValidator_Ok(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	vals := st.Validators()
+	vals[0].WithdrawalCredentials = []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte}
+	require.NoError(t, st.SetValidators(vals))
+	bals := st.Balances()
+	bals[0] = params.BeaconConfig().MinActivationBalance + 1010
+	require.NoError(t, st.SetBalances(bals))
+	require.NoError(t, electra.SwitchToCompoundingValidator(st, 0))
+
+	pbd, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, uint64(1010), pbd[0].Amount) // appends it at the end
+	val, err := st.ValidatorAtIndex(0)
+	require.NoError(t, err)
+
+	bytes.HasPrefix(val.WithdrawalCredentials, []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte})
+}
+
+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 := electra.QueueExcessActiveBalance(st, 0)
+	require.NoError(t, err)
+
+	pbd, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, uint64(1000), pbd[0].Amount) // appends it at the end
+
+	bals = st.Balances()
+	require.Equal(t, params.BeaconConfig().MinActivationBalance, bals[0])
+}
+
+func TestQueueEntireBalanceAndResetValidator_Ok(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	// need to manually set this to 0 as after 6110 these balances are now 0 and instead populates pending balance deposits
+	bals := st.Balances()
+	bals[0] = params.BeaconConfig().MinActivationBalance - 1000
+	require.NoError(t, st.SetBalances(bals))
+	err := electra.QueueEntireBalanceAndResetValidator(st, 0)
+	require.NoError(t, err)
+
+	pbd, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(pbd))
+	require.Equal(t, params.BeaconConfig().MinActivationBalance-1000, pbd[0].Amount)
+	bal, err := st.BalanceAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), bal)
+}

beacon-chain/core/electra/withdrawals.go

@@ -26,66 +26,67 @@ import (
 //
 // def process_withdrawal_request(
 //
-//		state: BeaconState,
-//		withdrawal_request: WithdrawalRequest
+//	state: BeaconState,
+//	withdrawal_request: WithdrawalRequest
 //
-//	 ) -> None:
-//	   amount = execution_layer_withdrawal_request.amount
-//	   is_full_exit_request = amount == FULL_EXIT_REQUEST_AMOUNT
+// ) -> None:
 //
-//	   # If partial withdrawal queue is full, only full exits are processed
-//	   if len(state.pending_partial_withdrawals) == PENDING_PARTIAL_WITHDRAWALS_LIMIT and not is_full_exit_request:
-//	   return
+//	amount = withdrawal_request.amount
+//	is_full_exit_request = amount == FULL_EXIT_REQUEST_AMOUNT
 //
-//	   validator_pubkeys = [v.pubkey for v in state.validators]
-//	   # Verify pubkey exists
-//	   request_pubkey = execution_layer_withdrawal_request.validator_pubkey
-//	   if request_pubkey not in validator_pubkeys:
-//	   return
-//	   index = ValidatorIndex(validator_pubkeys.index(request_pubkey))
-//	   validator = state.validators[index]
+//	# If partial withdrawal queue is full, only full exits are processed
+//	if len(state.pending_partial_withdrawals) == PENDING_PARTIAL_WITHDRAWALS_LIMIT and not is_full_exit_request:
+//	    return
 //
-//	   # Verify withdrawal credentials
-//	   has_correct_credential = has_execution_withdrawal_credential(validator)
-//	   is_correct_source_address = (
-//	    validator.withdrawal_credentials[12:] == execution_layer_withdrawal_request.source_address
-//	   )
-//	   if not (has_correct_credential and is_correct_source_address):
-//	   return
-//	   # Verify the validator is active
-//	   if not is_active_validator(validator, get_current_epoch(state)):
-//	   return
-//	   # Verify exit has not been initiated
-//	   if validator.exit_epoch != FAR_FUTURE_EPOCH:
-//	   return
-//	   # Verify the validator has been active long enough
-//	   if get_current_epoch(state) < validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
-//	   return
+//	validator_pubkeys = [v.pubkey for v in state.validators]
+//	# Verify pubkey exists
+//	request_pubkey = withdrawal_request.validator_pubkey
+//	if request_pubkey not in validator_pubkeys:
+//	    return
+//	index = ValidatorIndex(validator_pubkeys.index(request_pubkey))
+//	validator = state.validators[index]
 //
-//	   pending_balance_to_withdraw = get_pending_balance_to_withdraw(state, index)
+//	# Verify withdrawal credentials
+//	has_correct_credential = has_execution_withdrawal_credential(validator)
+//	is_correct_source_address = (
+//	    validator.withdrawal_credentials[12:] == withdrawal_request.source_address
+//	)
+//	if not (has_correct_credential and is_correct_source_address):
+//	    return
+//	# Verify the validator is active
+//	if not is_active_validator(validator, get_current_epoch(state)):
+//	    return
+//	# Verify exit has not been initiated
+//	if validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	    return
+//	# Verify the validator has been active long enough
+//	if get_current_epoch(state) < validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
+//	    return
 //
-//	   if is_full_exit_request:
-//	   # Only exit validator if it has no pending withdrawals in the queue
-//	   if pending_balance_to_withdraw == 0:
-//	   initiate_validator_exit(state, index)
-//	   return
+//	pending_balance_to_withdraw = get_pending_balance_to_withdraw(state, index)
 //
-//	   has_sufficient_effective_balance = validator.effective_balance >= MIN_ACTIVATION_BALANCE
-//	   has_excess_balance = state.balances[index] > MIN_ACTIVATION_BALANCE + pending_balance_to_withdraw
+//	if is_full_exit_request:
+//	    # Only exit validator if it has no pending withdrawals in the queue
+//	    if pending_balance_to_withdraw == 0:
+//	        initiate_validator_exit(state, index)
+//	    return
 //
-//	   # Only allow partial withdrawals with compounding withdrawal credentials
-//	   if has_compounding_withdrawal_credential(validator) and has_sufficient_effective_balance and has_excess_balance:
-//	   to_withdraw = min(
-//	   state.balances[index] - MIN_ACTIVATION_BALANCE - pending_balance_to_withdraw,
-//	    amount
-//	   )
-//	   exit_queue_epoch = compute_exit_epoch_and_update_churn(state, to_withdraw)
-//	   withdrawable_epoch = Epoch(exit_queue_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY)
-//	   state.pending_partial_withdrawals.append(PendingPartialWithdrawal(
-//	   index=index,
-//	   amount=to_withdraw,
-//	   withdrawable_epoch=withdrawable_epoch,
-//	   ))
+//	has_sufficient_effective_balance = validator.effective_balance >= MIN_ACTIVATION_BALANCE
+//	has_excess_balance = state.balances[index] > MIN_ACTIVATION_BALANCE + pending_balance_to_withdraw
+//
+//	# Only allow partial withdrawals with compounding withdrawal credentials
+//	if has_compounding_withdrawal_credential(validator) and has_sufficient_effective_balance and has_excess_balance:
+//	    to_withdraw = min(
+//	        state.balances[index] - MIN_ACTIVATION_BALANCE - pending_balance_to_withdraw,
+//	        amount
+//	    )
+//	    exit_queue_epoch = compute_exit_epoch_and_update_churn(state, to_withdraw)
+//	    withdrawable_epoch = Epoch(exit_queue_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY)
+//	    state.pending_partial_withdrawals.append(PendingPartialWithdrawal(
+//	        index=index,
+//	        amount=to_withdraw,
+//	        withdrawable_epoch=withdrawable_epoch,
+//	    ))
 func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.WithdrawalRequest) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "electra.ProcessWithdrawalRequests")
 	defer span.End()

beacon-chain/core/electra/withdrawals_test.go

@@ -81,7 +81,6 @@ func TestProcessWithdrawRequests(t *testing.T) {
 				}))
 				_, err = wantPostSt.ExitEpochAndUpdateChurn(primitives.Gwei(v.EffectiveBalance))
 				require.NoError(t, err)
-				require.DeepEqual(t, wantPostSt.Validators(), got.Validators())
 				webc, err := wantPostSt.ExitBalanceToConsume()
 				require.NoError(t, err)
 				gebc, err := got.ExitBalanceToConsume()
@@ -110,10 +109,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					prefix[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
 					v.WithdrawalCredentials = append(prefix, source...)
 					require.NoError(t, preSt.SetValidators([]*eth.Validator{v}))
-					bal, err := preSt.BalanceAtIndex(0)
-					require.NoError(t, err)
-					bal += 200
-					require.NoError(t, preSt.SetBalances([]uint64{bal}))
+					require.NoError(t, preSt.SetBalances([]uint64{params.BeaconConfig().MinActivationBalance + 200}))
 					require.NoError(t, preSt.AppendPendingPartialWithdrawal(&eth.PendingPartialWithdrawal{
 						Index:             0,
 						Amount:            100,
@@ -168,7 +164,6 @@ func TestProcessWithdrawRequests(t *testing.T) {
 				require.Equal(t, wece, gece)
 				_, err = wantPostSt.ExitEpochAndUpdateChurn(primitives.Gwei(100))
 				require.NoError(t, err)
-				require.DeepEqual(t, wantPostSt.Validators(), got.Validators())
 				webc, err := wantPostSt.ExitBalanceToConsume()
 				require.NoError(t, err)
 				gebc, err := got.ExitBalanceToConsume()

beacon-chain/core/epoch/BUILD.bazel

@@ -2,7 +2,10 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = ["epoch_processing.go"],
+    srcs = [
+        "epoch_processing.go",
+        "sortable_indices.go",
+    ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch",
     visibility = [
         "//beacon-chain:__subpackages__",
@@ -31,6 +34,7 @@ go_test(
     srcs = [
         "epoch_processing_fuzz_test.go",
         "epoch_processing_test.go",
+        "sortable_indices_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
@@ -47,6 +51,7 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "@com_github_google_go_cmp//cmp:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",

beacon-chain/core/epoch/epoch_processing.go

@@ -24,27 +24,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
-// sortableIndices implements the Sort interface to sort newly activated validator indices
-// by activation epoch and by index number.
-type sortableIndices struct {
-	indices    []primitives.ValidatorIndex
-	validators []*ethpb.Validator
-}
-
-// Len is the number of elements in the collection.
-func (s sortableIndices) Len() int { return len(s.indices) }
-
-// Swap swaps the elements with indexes i and j.
-func (s sortableIndices) Swap(i, j int) { s.indices[i], s.indices[j] = s.indices[j], s.indices[i] }
-
-// Less reports whether the element with index i must sort before the element with index j.
-func (s sortableIndices) Less(i, j int) bool {
-	if s.validators[s.indices[i]].ActivationEligibilityEpoch == s.validators[s.indices[j]].ActivationEligibilityEpoch {
-		return s.indices[i] < s.indices[j]
-	}
-	return s.validators[s.indices[i]].ActivationEligibilityEpoch < s.validators[s.indices[j]].ActivationEligibilityEpoch
-}
-
 // AttestingBalance returns the total balance from all the attesting indices.
 //
 // WARNING: This method allocates a new copy of the attesting validator indices set and is
@@ -91,55 +70,78 @@ func AttestingBalance(ctx context.Context, state state.ReadOnlyBeaconState, atts
 //	 for index in activation_queue[:get_validator_churn_limit(state)]:
 //	     validator = state.validators[index]
 //	     validator.activation_epoch = compute_activation_exit_epoch(get_current_epoch(state))
-func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
-	currentEpoch := time.CurrentEpoch(state)
-	vals := state.Validators()
+func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) (state.BeaconState, error) {
+	currentEpoch := time.CurrentEpoch(st)
 	var err error
 	ejectionBal := params.BeaconConfig().EjectionBalance
-	activationEligibilityEpoch := time.CurrentEpoch(state) + 1
-	for idx, validator := range vals {
-		// Process the validators for activation eligibility.
-		if helpers.IsEligibleForActivationQueue(validator, currentEpoch) {
-			validator.ActivationEligibilityEpoch = activationEligibilityEpoch
-			if err := state.UpdateValidatorAtIndex(primitives.ValidatorIndex(idx), validator); err != nil {
-				return nil, err
-			}
+
+	// To avoid copying the state validator set via st.Validators(), we will perform a read only pass
+	// over the validator set while collecting validator indices where the validator copy is actually
+	// necessary, then we will process these operations.
+	eligibleForActivationQ := make([]primitives.ValidatorIndex, 0)
+	eligibleForActivation := make([]primitives.ValidatorIndex, 0)
+	eligibleForEjection := make([]primitives.ValidatorIndex, 0)
+
+	if err := st.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
+		// Collect validators eligible to enter the activation queue.
+		if helpers.IsEligibleForActivationQueue(val, currentEpoch) {
+			eligibleForActivationQ = append(eligibleForActivationQ, primitives.ValidatorIndex(idx))
 		}
 
-		// Process the validators for ejection.
-		isActive := helpers.IsActiveValidator(validator, currentEpoch)
-		belowEjectionBalance := validator.EffectiveBalance <= ejectionBal
+		// Collect validators to eject.
+		isActive := helpers.IsActiveValidatorUsingTrie(val, currentEpoch)
+		belowEjectionBalance := val.EffectiveBalance() <= ejectionBal
 		if isActive && belowEjectionBalance {
-			// Here is fine to do a quadratic loop since this should
-			// barely happen
-			maxExitEpoch, churn := validators.MaxExitEpochAndChurn(state)
-			state, _, err = validators.InitiateValidatorExit(ctx, state, primitives.ValidatorIndex(idx), maxExitEpoch, churn)
-			if err != nil && !errors.Is(err, validators.ErrValidatorAlreadyExited) {
-				return nil, errors.Wrapf(err, "could not initiate exit for validator %d", idx)
-			}
+			eligibleForEjection = append(eligibleForEjection, primitives.ValidatorIndex(idx))
+		}
+
+		// Collect validators eligible for activation and not yet dequeued for activation.
+		if helpers.IsEligibleForActivationUsingROVal(st, val) {
+			eligibleForActivation = append(eligibleForActivation, primitives.ValidatorIndex(idx))
+		}
+
+		return nil
+	}); err != nil {
+		return st, fmt.Errorf("failed to read validators: %w", err)
+	}
+
+	// Process validators for activation eligibility.
+	activationEligibilityEpoch := time.CurrentEpoch(st) + 1
+	for _, idx := range eligibleForActivationQ {
+		v, err := st.ValidatorAtIndex(idx)
+		if err != nil {
+			return nil, err
+		}
+		v.ActivationEligibilityEpoch = activationEligibilityEpoch
+		if err := st.UpdateValidatorAtIndex(idx, v); err != nil {
+			return nil, err
+		}
+	}
+
+	// Process validators eligible for ejection.
+	for _, idx := range eligibleForEjection {
+		// Here is fine to do a quadratic loop since this should
+		// barely happen
+		maxExitEpoch, churn := validators.MaxExitEpochAndChurn(st)
+		st, _, err = validators.InitiateValidatorExit(ctx, st, idx, maxExitEpoch, churn)
+		if err != nil && !errors.Is(err, validators.ErrValidatorAlreadyExited) {
+			return nil, errors.Wrapf(err, "could not initiate exit for validator %d", idx)
 		}
 	}
 
 	// Queue validators eligible for activation and not yet dequeued for activation.
-	var activationQ []primitives.ValidatorIndex
-	for idx, validator := range vals {
-		if helpers.IsEligibleForActivation(state, validator) {
-			activationQ = append(activationQ, primitives.ValidatorIndex(idx))
-		}
-	}
-
-	sort.Sort(sortableIndices{indices: activationQ, validators: vals})
+	sort.Sort(sortableIndices{indices: eligibleForActivation, state: st})
 
 	// Only activate just enough validators according to the activation churn limit.
-	limit := uint64(len(activationQ))
-	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, state, currentEpoch)
+	limit := uint64(len(eligibleForActivation))
+	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, st, currentEpoch)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get active validator count")
 	}
 
 	churnLimit := helpers.ValidatorActivationChurnLimit(activeValidatorCount)
 
-	if state.Version() >= version.Deneb {
+	if st.Version() >= version.Deneb {
 		churnLimit = helpers.ValidatorActivationChurnLimitDeneb(activeValidatorCount)
 	}
 
@@ -149,17 +151,17 @@ func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state
 	}
 
 	activationExitEpoch := helpers.ActivationExitEpoch(currentEpoch)
-	for _, index := range activationQ[:limit] {
-		validator, err := state.ValidatorAtIndex(index)
+	for _, index := range eligibleForActivation[:limit] {
+		validator, err := st.ValidatorAtIndex(index)
 		if err != nil {
 			return nil, err
 		}
 		validator.ActivationEpoch = activationExitEpoch
-		if err := state.UpdateValidatorAtIndex(index, validator); err != nil {
+		if err := st.UpdateValidatorAtIndex(index, validator); err != nil {
 			return nil, err
 		}
 	}
-	return state, nil
+	return st, nil
 }
 
 // ProcessSlashings processes the slashed validators during epoch processing,

beacon-chain/core/epoch/epoch_processing_test.go

@@ -307,14 +307,15 @@ func TestProcessRegistryUpdates_NoRotation(t *testing.T) {
 }
 
 func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
+	finalizedEpoch := primitives.Epoch(4)
 	base := &ethpb.BeaconState{
 		Slot:                5 * params.BeaconConfig().SlotsPerEpoch,
-		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 6, Root: make([]byte, fieldparams.RootLength)},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
 	}
 	limit := helpers.ValidatorActivationChurnLimit(0)
 	for i := uint64(0); i < limit+10; i++ {
 		base.Validators = append(base.Validators, &ethpb.Validator{
-			ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+			ActivationEligibilityEpoch: finalizedEpoch,
 			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
 			ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
 		})
@@ -325,7 +326,6 @@ func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
 	newState, err := epoch.ProcessRegistryUpdates(context.Background(), beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
-		assert.Equal(t, currentEpoch+1, validator.ActivationEligibilityEpoch, "Could not update registry %d, unexpected activation eligibility epoch", i)
 		if uint64(i) < limit && validator.ActivationEpoch != helpers.ActivationExitEpoch(currentEpoch) {
 			t.Errorf("Could not update registry %d, validators failed to activate: wanted activation epoch %d, got %d",
 				i, helpers.ActivationExitEpoch(currentEpoch), validator.ActivationEpoch)
@@ -338,9 +338,10 @@ func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
 }
 
 func TestProcessRegistryUpdates_EligibleToActivate_Cancun(t *testing.T) {
+	finalizedEpoch := primitives.Epoch(4)
 	base := &ethpb.BeaconStateDeneb{
 		Slot:                5 * params.BeaconConfig().SlotsPerEpoch,
-		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 6, Root: make([]byte, fieldparams.RootLength)},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
 	}
 	cfg := params.BeaconConfig()
 	cfg.MinPerEpochChurnLimit = 10
@@ -349,7 +350,7 @@ func TestProcessRegistryUpdates_EligibleToActivate_Cancun(t *testing.T) {
 
 	for i := uint64(0); i < 10; i++ {
 		base.Validators = append(base.Validators, &ethpb.Validator{
-			ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+			ActivationEligibilityEpoch: finalizedEpoch,
 			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
 			ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
 		})
@@ -360,7 +361,6 @@ func TestProcessRegistryUpdates_EligibleToActivate_Cancun(t *testing.T) {
 	newState, err := epoch.ProcessRegistryUpdates(context.Background(), beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
-		assert.Equal(t, currentEpoch+1, validator.ActivationEligibilityEpoch, "Could not update registry %d, unexpected activation eligibility epoch", i)
 		// Note: In Deneb, only validators indices before `MaxPerEpochActivationChurnLimit` should be activated.
 		if uint64(i) < params.BeaconConfig().MaxPerEpochActivationChurnLimit && validator.ActivationEpoch != helpers.ActivationExitEpoch(currentEpoch) {
 			t.Errorf("Could not update registry %d, validators failed to activate: wanted activation epoch %d, got %d",

beacon-chain/core/epoch/sortable_indices.go

@@ -0,0 +1,35 @@
+package epoch
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+)
+
+// sortableIndices implements the Sort interface to sort newly activated validator indices
+// by activation epoch and by index number.
+type sortableIndices struct {
+	indices []primitives.ValidatorIndex
+	state   state.ReadOnlyValidators
+}
+
+// Len is the number of elements in the collection.
+func (s sortableIndices) Len() int { return len(s.indices) }
+
+// Swap swaps the elements with indexes i and j.
+func (s sortableIndices) Swap(i, j int) { s.indices[i], s.indices[j] = s.indices[j], s.indices[i] }
+
+// Less reports whether the element with index i must sort before the element with index j.
+func (s sortableIndices) Less(i, j int) bool {
+	vi, erri := s.state.ValidatorAtIndexReadOnly(s.indices[i])
+	vj, errj := s.state.ValidatorAtIndexReadOnly(s.indices[j])
+
+	if erri != nil || errj != nil {
+		return false
+	}
+
+	a, b := vi.ActivationEligibilityEpoch(), vj.ActivationEligibilityEpoch()
+	if a == b {
+		return s.indices[i] < s.indices[j]
+	}
+	return a < b
+}

beacon-chain/core/epoch/sortable_indices_test.go

@@ -0,0 +1,53 @@
+package epoch
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	"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 TestSortableIndices(t *testing.T) {
+	st, err := state_native.InitializeFromProtoPhase0(&eth.BeaconState{
+		Validators: []*eth.Validator{
+			{ActivationEligibilityEpoch: 0},
+			{ActivationEligibilityEpoch: 5},
+			{ActivationEligibilityEpoch: 4},
+			{ActivationEligibilityEpoch: 4},
+			{ActivationEligibilityEpoch: 2},
+			{ActivationEligibilityEpoch: 1},
+		},
+	})
+	require.NoError(t, err)
+
+	s := sortableIndices{
+		indices: []primitives.ValidatorIndex{
+			4,
+			2,
+			5,
+			3,
+			1,
+			0,
+		},
+		state: st,
+	}
+
+	sort.Sort(s)
+
+	want := []primitives.ValidatorIndex{
+		0,
+		5,
+		4,
+		2, // Validators with the same ActivationEligibilityEpoch are sorted by index, ascending.
+		3,
+		1,
+	}
+
+	if !cmp.Equal(s.indices, want) {
+		t.Errorf("Failed to sort indices correctly, wanted %v, got %v", want, s.indices)
+	}
+}

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

@@ -32,6 +32,9 @@ const (
 
 	// AttesterSlashingReceived is sent after an attester slashing is received from gossip or rpc
 	AttesterSlashingReceived = 8
+
+	// DataColumnSidecarReceived is sent after a data column sidecar is received from gossip or rpc.
+	DataColumnSidecarReceived = 9
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -77,3 +80,7 @@ type ProposerSlashingReceivedData struct {
 type AttesterSlashingReceivedData struct {
 	AttesterSlashing ethpb.AttSlashing
 }
+
+type DataColumnSidecarReceivedData struct {
+	DataColumn *blocks.VerifiedRODataColumn
+}

beacon-chain/core/helpers/BUILD.bazel

@@ -79,6 +79,7 @@ go_test(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1: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/core/helpers/sync_committee.go

@@ -31,7 +31,7 @@ func IsCurrentPeriodSyncCommittee(st state.BeaconState, valIdx primitives.Valida
 		return false, err
 	}
 	indices, err := syncCommitteeCache.CurrentPeriodIndexPosition(root, valIdx)
-	if err == cache.ErrNonExistingSyncCommitteeKey {
+	if errors.Is(err, cache.ErrNonExistingSyncCommitteeKey) {
 		val, err := st.ValidatorAtIndex(valIdx)
 		if err != nil {
 			return false, err
@@ -68,7 +68,7 @@ func IsNextPeriodSyncCommittee(
 		return false, err
 	}
 	indices, err := syncCommitteeCache.NextPeriodIndexPosition(root, valIdx)
-	if err == cache.ErrNonExistingSyncCommitteeKey {
+	if errors.Is(err, cache.ErrNonExistingSyncCommitteeKey) {
 		val, err := st.ValidatorAtIndex(valIdx)
 		if err != nil {
 			return false, err
@@ -95,7 +95,7 @@ func CurrentPeriodSyncSubcommitteeIndices(
 		return nil, err
 	}
 	indices, err := syncCommitteeCache.CurrentPeriodIndexPosition(root, valIdx)
-	if err == cache.ErrNonExistingSyncCommitteeKey {
+	if errors.Is(err, cache.ErrNonExistingSyncCommitteeKey) {
 		val, err := st.ValidatorAtIndex(valIdx)
 		if err != nil {
 			return nil, err
@@ -129,7 +129,7 @@ func NextPeriodSyncSubcommitteeIndices(
 		return nil, err
 	}
 	indices, err := syncCommitteeCache.NextPeriodIndexPosition(root, valIdx)
-	if err == cache.ErrNonExistingSyncCommitteeKey {
+	if errors.Is(err, cache.ErrNonExistingSyncCommitteeKey) {
 		val, err := st.ValidatorAtIndex(valIdx)
 		if err != nil {
 			return nil, err

beacon-chain/core/helpers/validators.go

@@ -17,6 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	"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/time/slots"
 	log "github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -357,10 +358,10 @@ func BeaconProposerIndexAtSlot(ctx context.Context, state state.ReadOnlyBeaconSt
 //	      candidate_index = indices[compute_shuffled_index(i % total, total, seed)]
 //	      random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32]
 //	      effective_balance = state.validators[candidate_index].effective_balance
-//	      if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte:
+//	      if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_byte: #[Modified in Electra:EIP7251]
 //	          return candidate_index
 //	      i += 1
-func ComputeProposerIndex(bState state.ReadOnlyValidators, activeIndices []primitives.ValidatorIndex, seed [32]byte) (primitives.ValidatorIndex, error) {
+func ComputeProposerIndex(bState state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex, seed [32]byte) (primitives.ValidatorIndex, error) {
 	length := uint64(len(activeIndices))
 	if length == 0 {
 		return 0, errors.New("empty active indices list")
@@ -385,7 +386,12 @@ func ComputeProposerIndex(bState state.ReadOnlyValidators, activeIndices []primi
 		}
 		effectiveBal := v.EffectiveBalance()
 
-		if effectiveBal*maxRandomByte >= params.BeaconConfig().MaxEffectiveBalance*uint64(randomByte) {
+		maxEB := params.BeaconConfig().MaxEffectiveBalance
+		if bState.Version() >= version.Electra {
+			maxEB = params.BeaconConfig().MaxEffectiveBalanceElectra
+		}
+
+		if effectiveBal*maxRandomByte >= maxEB*uint64(randomByte) {
 			return candidateIndex, nil
 		}
 	}
@@ -404,11 +410,11 @@ func ComputeProposerIndex(bState state.ReadOnlyValidators, activeIndices []primi
 //	        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 {
+func IsEligibleForActivationQueue(validator state.ReadOnlyValidator, currentEpoch primitives.Epoch) bool {
 	if currentEpoch >= params.BeaconConfig().ElectraForkEpoch {
-		return isEligibleForActivationQueueElectra(validator.ActivationEligibilityEpoch, validator.EffectiveBalance)
+		return isEligibleForActivationQueueElectra(validator.ActivationEligibilityEpoch(), validator.EffectiveBalance())
 	}
-	return isEligibleForActivationQueue(validator.ActivationEligibilityEpoch, validator.EffectiveBalance)
+	return isEligibleForActivationQueue(validator.ActivationEligibilityEpoch(), validator.EffectiveBalance())
 }
 
 // isEligibleForActivationQueue carries out the logic for IsEligibleForActivationQueue
@@ -464,13 +470,9 @@ func IsEligibleForActivation(state state.ReadOnlyCheckpoint, validator *ethpb.Va
 	return isEligibleForActivation(validator.ActivationEligibilityEpoch, validator.ActivationEpoch, finalizedEpoch)
 }
 
-// IsEligibleForActivationUsingTrie checks if the validator is eligible for activation.
-func IsEligibleForActivationUsingTrie(state state.ReadOnlyCheckpoint, validator state.ReadOnlyValidator) bool {
-	cpt := state.FinalizedCheckpoint()
-	if cpt == nil {
-		return false
-	}
-	return isEligibleForActivation(validator.ActivationEligibilityEpoch(), validator.ActivationEpoch(), cpt.Epoch)
+// IsEligibleForActivationUsingROVal checks if the validator is eligible for activation using the provided read only validator.
+func IsEligibleForActivationUsingROVal(state state.ReadOnlyCheckpoint, validator state.ReadOnlyValidator) bool {
+	return isEligibleForActivation(validator.ActivationEligibilityEpoch(), validator.ActivationEpoch(), state.FinalizedCheckpointEpoch())
 }
 
 // isEligibleForActivation carries out the logic for IsEligibleForActivation*
@@ -525,16 +527,16 @@ func HasCompoundingWithdrawalCredential(v interfaces.WithWithdrawalCredentials)
 	if v == nil {
 		return false
 	}
-	return isCompoundingWithdrawalCredential(v.GetWithdrawalCredentials())
+	return IsCompoundingWithdrawalCredential(v.GetWithdrawalCredentials())
 }
 
-// isCompoundingWithdrawalCredential checks if the credentials are a compounding withdrawal credential.
+// 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 {
+func IsCompoundingWithdrawalCredential(creds []byte) bool {
 	return bytes.HasPrefix(creds, []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte})
 }
 
@@ -548,7 +550,7 @@ func isCompoundingWithdrawalCredential(creds []byte) 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 {
+func HasExecutionWithdrawalCredentials(v interfaces.WithWithdrawalCredentials) bool {
 	if v == nil {
 		return false
 	}
@@ -582,13 +584,13 @@ func IsSameWithdrawalCredentials(a, b *ethpb.Validator) bool {
 //	        and validator.withdrawable_epoch <= epoch
 //	        and balance > 0
 //	    )
-func IsFullyWithdrawableValidator(val *ethpb.Validator, balance uint64, epoch primitives.Epoch) bool {
+func IsFullyWithdrawableValidator(val *ethpb.Validator, balance uint64, epoch primitives.Epoch, fork int) bool {
 	if val == nil || balance <= 0 {
 		return false
 	}
 
 	// Electra / EIP-7251 logic
-	if epoch >= params.BeaconConfig().ElectraForkEpoch {
+	if fork >= version.Electra {
 		return HasExecutionWithdrawalCredentials(val) && val.WithdrawableEpoch <= epoch
 	}
 
@@ -598,12 +600,12 @@ func IsFullyWithdrawableValidator(val *ethpb.Validator, balance uint64, epoch pr
 // 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 {
+func IsPartiallyWithdrawableValidator(val *ethpb.Validator, balance uint64, epoch primitives.Epoch, fork int) bool {
 	if val == nil {
 		return false
 	}
 
-	if epoch < params.BeaconConfig().ElectraForkEpoch {
+	if fork < version.Electra {
 		return isPartiallyWithdrawableValidatorCapella(val, balance, epoch)
 	}
 
@@ -674,68 +676,3 @@ func ValidatorMaxEffectiveBalance(val *ethpb.Validator) uint64 {
 	}
 	return params.BeaconConfig().MinActivationBalance
 }
-
-// QueueExcessActiveBalance queues validators with balances above the min activation balance and adds to pending balance deposit.
-//
-// Spec definition:
-//
-//	def queue_excess_active_balance(state: BeaconState, index: ValidatorIndex) -> None:
-//	    balance = state.balances[index]
-//	    if balance > MIN_ACTIVATION_BALANCE:
-//	        excess_balance = balance - MIN_ACTIVATION_BALANCE
-//	        state.balances[index] = MIN_ACTIVATION_BALANCE
-//	        state.pending_balance_deposits.append(
-//	            PendingBalanceDeposit(index=index, amount=excess_balance)
-//	        )
-func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex) error {
-	bal, err := s.BalanceAtIndex(idx)
-	if err != nil {
-		return err
-	}
-
-	if bal > params.BeaconConfig().MinActivationBalance {
-		excessBalance := bal - params.BeaconConfig().MinActivationBalance
-		if err := s.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
-			return err
-		}
-		return s.AppendPendingBalanceDeposit(idx, excessBalance)
-	}
-	return nil
-}
-
-// QueueEntireBalanceAndResetValidator queues the entire balance and resets the validator. This is used in electra fork logic.
-//
-// Spec definition:
-//
-//	def queue_entire_balance_and_reset_validator(state: BeaconState, index: ValidatorIndex) -> None:
-//	    balance = state.balances[index]
-//	    validator = state.validators[index]
-//		state.balances[index] = 0
-//	    validator.effective_balance = 0
-//	    validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
-//	    state.pending_balance_deposits.append(
-//	        PendingBalanceDeposit(index=index, amount=balance)
-//	    )
-func QueueEntireBalanceAndResetValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
-	bal, err := s.BalanceAtIndex(idx)
-	if err != nil {
-		return err
-	}
-
-	if err := s.UpdateBalancesAtIndex(idx, 0); err != nil {
-		return err
-	}
-
-	v, err := s.ValidatorAtIndex(idx)
-	if err != nil {
-		return err
-	}
-
-	v.EffectiveBalance = 0
-	v.ActivationEligibilityEpoch = params.BeaconConfig().FarFutureEpoch
-	if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
-		return err
-	}
-
-	return s.AppendPendingBalanceDeposit(idx, bal)
-}

beacon-chain/core/helpers/validators_test.go

@@ -16,9 +16,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	"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"
 )
 
 func TestIsActiveValidator_OK(t *testing.T) {
@@ -598,10 +598,11 @@ func TestComputeProposerIndex(t *testing.T) {
 		seed       [32]byte
 	}
 	tests := []struct {
-		name      string
-		args      args
-		want      primitives.ValidatorIndex
-		wantedErr string
+		name             string
+		isElectraOrAbove bool
+		args             args
+		want             primitives.ValidatorIndex
+		wantedErr        string
 	}{
 		{
 			name: "all_active_indices",
@@ -683,6 +684,54 @@ func TestComputeProposerIndex(t *testing.T) {
 			},
 			want: 7,
 		},
+		{
+			name:             "electra_probability_changes",
+			isElectraOrAbove: true,
+			args: args{
+				validators: []*ethpb.Validator{
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+				},
+				indices: []primitives.ValidatorIndex{3},
+				seed:    seed,
+			},
+			want: 3,
+		},
+		{
+			name:             "electra_probability_changes_all_active",
+			isElectraOrAbove: true,
+			args: args{
+				validators: []*ethpb.Validator{
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance}, // skip this one
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
+				},
+				indices: []primitives.ValidatorIndex{0, 1, 2, 3, 4},
+				seed:    seed,
+			},
+			want: 4,
+		},
+		{
+			name:             "electra_probability_returns_first_validator_with_criteria",
+			isElectraOrAbove: true,
+			args: args{
+				validators: []*ethpb.Validator{
+					{EffectiveBalance: 1},
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
+					{EffectiveBalance: 1},
+					{EffectiveBalance: 1},
+					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
+				},
+				indices: []primitives.ValidatorIndex{1},
+				seed:    seed,
+			},
+			want: 1,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -691,6 +740,11 @@ func TestComputeProposerIndex(t *testing.T) {
 			bState := &ethpb.BeaconState{Validators: tt.args.validators}
 			stTrie, err := state_native.InitializeFromProtoUnsafePhase0(bState)
 			require.NoError(t, err)
+			if tt.isElectraOrAbove {
+				stTrie, err = state_native.InitializeFromProtoUnsafeElectra(&ethpb.BeaconStateElectra{Validators: tt.args.validators})
+				require.NoError(t, err)
+			}
+
 			got, err := helpers.ComputeProposerIndex(stTrie, tt.args.indices, tt.args.seed)
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
@@ -744,7 +798,9 @@ func TestIsEligibleForActivationQueue(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			helpers.ClearCache()
 
-			assert.Equal(t, tt.want, helpers.IsEligibleForActivationQueue(tt.validator, tt.currentEpoch), "IsEligibleForActivationQueue()")
+			v, err := state_native.NewValidator(tt.validator)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want, helpers.IsEligibleForActivationQueue(v, tt.currentEpoch), "IsEligibleForActivationQueue()")
 		})
 	}
 }
@@ -915,6 +971,7 @@ func TestIsFullyWithdrawableValidator(t *testing.T) {
 		validator *ethpb.Validator
 		balance   uint64
 		epoch     primitives.Epoch
+		fork      int
 		want      bool
 	}{
 		{
@@ -972,13 +1029,14 @@ func TestIsFullyWithdrawableValidator(t *testing.T) {
 			},
 			balance: params.BeaconConfig().MaxEffectiveBalance,
 			epoch:   params.BeaconConfig().ElectraForkEpoch,
+			fork:    version.Electra,
 			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))
+			assert.Equal(t, tt.want, helpers.IsFullyWithdrawableValidator(tt.validator, tt.balance, tt.epoch, tt.fork))
 		})
 	}
 }
@@ -989,6 +1047,7 @@ func TestIsPartiallyWithdrawableValidator(t *testing.T) {
 		validator *ethpb.Validator
 		balance   uint64
 		epoch     primitives.Epoch
+		fork      int
 		want      bool
 	}{
 		{
@@ -1036,6 +1095,7 @@ func TestIsPartiallyWithdrawableValidator(t *testing.T) {
 			},
 			balance: params.BeaconConfig().MinActivationBalance * 2,
 			epoch:   params.BeaconConfig().ElectraForkEpoch,
+			fork:    version.Electra,
 			want:    true,
 		},
 		{
@@ -1046,13 +1106,14 @@ func TestIsPartiallyWithdrawableValidator(t *testing.T) {
 			},
 			balance: params.BeaconConfig().MaxEffectiveBalanceElectra * 2,
 			epoch:   params.BeaconConfig().ElectraForkEpoch,
+			fork:    version.Electra,
 			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))
+			assert.Equal(t, tt.want, helpers.IsPartiallyWithdrawableValidator(tt.validator, tt.balance, tt.epoch, tt.fork))
 		})
 	}
 }
@@ -1120,40 +1181,3 @@ func TestValidatorMaxEffectiveBalance(t *testing.T) {
 	// Sanity check that MinActivationBalance equals (pre-electra) MaxEffectiveBalance
 	assert.Equal(t, params.BeaconConfig().MinActivationBalance, params.BeaconConfig().MaxEffectiveBalance)
 }
-
-func TestQueueExcessActiveBalance_Ok(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	bals := st.Balances()
-	bals[0] = params.BeaconConfig().MinActivationBalance + 1000
-	require.NoError(t, st.SetBalances(bals))
-
-	err := helpers.QueueExcessActiveBalance(st, 0)
-	require.NoError(t, err)
-
-	pbd, err := st.PendingBalanceDeposits()
-	require.NoError(t, err)
-	require.Equal(t, uint64(1000), pbd[0].Amount)
-
-	bals = st.Balances()
-	require.Equal(t, params.BeaconConfig().MinActivationBalance, bals[0])
-}
-
-func TestQueueEntireBalanceAndResetValidator_Ok(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	val, err := st.ValidatorAtIndex(0)
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, val.EffectiveBalance)
-	pbd, err := st.PendingBalanceDeposits()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(pbd))
-	err = helpers.QueueEntireBalanceAndResetValidator(st, 0)
-	require.NoError(t, err)
-
-	pbd, err = st.PendingBalanceDeposits()
-	require.NoError(t, err)
-	require.Equal(t, 1, len(pbd))
-
-	val, err = st.ValidatorAtIndex(0)
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), val.EffectiveBalance)
-}

beacon-chain/core/peerdas/BUILD.bazel

@@ -0,0 +1,38 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["helpers.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/blockchain/kzg:go_default_library",
+        "//cmd/beacon-chain/flags:go_default_library",
+        "//config/fieldparams:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//crypto/hash:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
+        "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
+        "@com_github_holiman_uint256//:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["helpers_test.go"],
+    deps = [
+        ":go_default_library",
+        "//beacon-chain/blockchain/kzg:go_default_library",
+        "//consensus-types/blocks:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+        "@com_github_consensys_gnark_crypto//ecc/bls12-381/fr:go_default_library",
+        "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)

beacon-chain/core/peerdas/helpers.go

@@ -0,0 +1,359 @@
+package peerdas
+
+import (
+	"encoding/binary"
+	"math"
+	"math/big"
+
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+
+	"github.com/ethereum/go-ethereum/p2p/enode"
+	"github.com/ethereum/go-ethereum/p2p/enr"
+	"github.com/holiman/uint256"
+	errors "github.com/pkg/errors"
+
+	kzg "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
+
+	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
+	"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/crypto/hash"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+)
+
+const (
+	CustodySubnetCountEnrKey = "csc"
+)
+
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/p2p-interface.md#the-discovery-domain-discv5
+type Csc uint64
+
+func (Csc) ENRKey() string { return CustodySubnetCountEnrKey }
+
+var (
+	// Custom errors
+	errCustodySubnetCountTooLarge   = errors.New("custody subnet count larger than data column sidecar subnet count")
+	errIndexTooLarge                = errors.New("column index is larger than the specified columns count")
+	errMismatchLength               = errors.New("mismatch in the length of the commitments and proofs")
+	errRecordNil                    = errors.New("record is nil")
+	errCannotLoadCustodySubnetCount = errors.New("cannot load the custody subnet count from peer")
+
+	// maxUint256 is the maximum value of a uint256.
+	maxUint256 = &uint256.Int{math.MaxUint64, math.MaxUint64, math.MaxUint64, math.MaxUint64}
+)
+
+// CustodyColumnSubnets computes the subnets the node should participate in for custody.
+func CustodyColumnSubnets(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool, error) {
+	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
+
+	// Check if the custody subnet count is larger than the data column sidecar subnet count.
+	if custodySubnetCount > dataColumnSidecarSubnetCount {
+		return nil, errCustodySubnetCountTooLarge
+	}
+
+	// First, compute the subnet IDs that the node should participate in.
+	subnetIds := make(map[uint64]bool, custodySubnetCount)
+
+	one := uint256.NewInt(1)
+
+	for currentId := new(uint256.Int).SetBytes(nodeId.Bytes()); uint64(len(subnetIds)) < custodySubnetCount; currentId.Add(currentId, one) {
+		// Convert to big endian bytes.
+		currentIdBytesBigEndian := currentId.Bytes32()
+
+		// Convert to little endian.
+		currentIdBytesLittleEndian := bytesutil.ReverseByteOrder(currentIdBytesBigEndian[:])
+
+		// Hash the result.
+		hashedCurrentId := hash.Hash(currentIdBytesLittleEndian)
+
+		// Get the subnet ID.
+		subnetId := binary.LittleEndian.Uint64(hashedCurrentId[:8]) % dataColumnSidecarSubnetCount
+
+		// Add the subnet to the map.
+		subnetIds[subnetId] = true
+
+		// Overflow prevention.
+		if currentId.Cmp(maxUint256) == 0 {
+			currentId = uint256.NewInt(0)
+		}
+	}
+
+	return subnetIds, nil
+}
+
+// CustodyColumns computes the columns the node should custody.
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#helper-functions
+func CustodyColumns(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool, error) {
+	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
+
+	// Compute the custodied subnets.
+	subnetIds, err := CustodyColumnSubnets(nodeId, custodySubnetCount)
+	if err != nil {
+		return nil, errors.Wrap(err, "custody subnets")
+	}
+
+	columnsPerSubnet := fieldparams.NumberOfColumns / dataColumnSidecarSubnetCount
+
+	// Knowing the subnet ID and the number of columns per subnet, select all the columns the node should custody.
+	// Columns belonging to the same subnet are contiguous.
+	columnIndices := make(map[uint64]bool, custodySubnetCount*columnsPerSubnet)
+	for i := uint64(0); i < columnsPerSubnet; i++ {
+		for subnetId := range subnetIds {
+			columnIndex := dataColumnSidecarSubnetCount*i + subnetId
+			columnIndices[columnIndex] = true
+		}
+	}
+
+	return columnIndices, nil
+}
+
+// DataColumnSidecars computes the data column sidecars from the signed block and blobs.
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#recover_matrix
+func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs []kzg.Blob) ([]*ethpb.DataColumnSidecar, error) {
+	blobsCount := len(blobs)
+	if blobsCount == 0 {
+		return nil, nil
+	}
+
+	// Get the signed block header.
+	signedBlockHeader, err := signedBlock.Header()
+	if err != nil {
+		return nil, errors.Wrap(err, "signed block header")
+	}
+
+	// Get the block body.
+	block := signedBlock.Block()
+	blockBody := block.Body()
+
+	// Get the blob KZG commitments.
+	blobKzgCommitments, err := blockBody.BlobKzgCommitments()
+	if err != nil {
+		return nil, errors.Wrap(err, "blob KZG commitments")
+	}
+
+	// Compute the KZG commitments inclusion proof.
+	kzgCommitmentsInclusionProof, err := blocks.MerkleProofKZGCommitments(blockBody)
+	if err != nil {
+		return nil, errors.Wrap(err, "merkle proof ZKG commitments")
+	}
+
+	// Compute cells and proofs.
+	cellsAndProofs := make([]kzg.CellsAndProofs, 0, blobsCount)
+
+	for i := range blobs {
+		blob := &blobs[i]
+		blobCellsAndProofs, err := kzg.ComputeCellsAndKZGProofs(blob)
+		if err != nil {
+			return nil, errors.Wrap(err, "compute cells and KZG proofs")
+		}
+
+		cellsAndProofs = append(cellsAndProofs, blobCellsAndProofs)
+	}
+
+	// Get the column sidecars.
+	sidecars := make([]*ethpb.DataColumnSidecar, 0, fieldparams.NumberOfColumns)
+	for columnIndex := uint64(0); columnIndex < fieldparams.NumberOfColumns; columnIndex++ {
+		column := make([]kzg.Cell, 0, blobsCount)
+		kzgProofOfColumn := make([]kzg.Proof, 0, blobsCount)
+
+		for rowIndex := 0; rowIndex < blobsCount; rowIndex++ {
+			cellsForRow := cellsAndProofs[rowIndex].Cells
+			proofsForRow := cellsAndProofs[rowIndex].Proofs
+
+			cell := cellsForRow[columnIndex]
+			column = append(column, cell)
+
+			kzgProof := proofsForRow[columnIndex]
+			kzgProofOfColumn = append(kzgProofOfColumn, kzgProof)
+		}
+
+		columnBytes := make([][]byte, 0, blobsCount)
+		for i := range column {
+			columnBytes = append(columnBytes, column[i][:])
+		}
+
+		kzgProofOfColumnBytes := make([][]byte, 0, blobsCount)
+		for _, kzgProof := range kzgProofOfColumn {
+			copiedProof := kzgProof
+			kzgProofOfColumnBytes = append(kzgProofOfColumnBytes, copiedProof[:])
+		}
+
+		sidecar := &ethpb.DataColumnSidecar{
+			ColumnIndex:                  columnIndex,
+			DataColumn:                   columnBytes,
+			KzgCommitments:               blobKzgCommitments,
+			KzgProof:                     kzgProofOfColumnBytes,
+			SignedBlockHeader:            signedBlockHeader,
+			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
+		}
+
+		sidecars = append(sidecars, sidecar)
+	}
+
+	return sidecars, nil
+}
+
+// DataColumnSidecarsForReconstruct is a TEMPORARY function until there is an official specification for it.
+// It is scheduled for deletion.
+func DataColumnSidecarsForReconstruct(
+	blobKzgCommitments [][]byte,
+	signedBlockHeader *ethpb.SignedBeaconBlockHeader,
+	kzgCommitmentsInclusionProof [][]byte,
+	cellsAndProofs []kzg.CellsAndProofs,
+) ([]*ethpb.DataColumnSidecar, error) {
+	// Each CellsAndProofs corresponds to a Blob
+	// So we can get the BlobCount by checking the length of CellsAndProofs
+	blobsCount := len(cellsAndProofs)
+	if blobsCount == 0 {
+		return nil, nil
+	}
+
+	// Get the column sidecars.
+	sidecars := make([]*ethpb.DataColumnSidecar, 0, fieldparams.NumberOfColumns)
+	for columnIndex := uint64(0); columnIndex < fieldparams.NumberOfColumns; columnIndex++ {
+		column := make([]kzg.Cell, 0, blobsCount)
+		kzgProofOfColumn := make([]kzg.Proof, 0, blobsCount)
+
+		for rowIndex := 0; rowIndex < blobsCount; rowIndex++ {
+			cellsForRow := cellsAndProofs[rowIndex].Cells
+			proofsForRow := cellsAndProofs[rowIndex].Proofs
+
+			cell := cellsForRow[columnIndex]
+			column = append(column, cell)
+
+			kzgProof := proofsForRow[columnIndex]
+			kzgProofOfColumn = append(kzgProofOfColumn, kzgProof)
+		}
+
+		columnBytes := make([][]byte, 0, blobsCount)
+		for i := range column {
+			columnBytes = append(columnBytes, column[i][:])
+		}
+
+		kzgProofOfColumnBytes := make([][]byte, 0, blobsCount)
+		for _, kzgProof := range kzgProofOfColumn {
+			copiedProof := kzgProof
+			kzgProofOfColumnBytes = append(kzgProofOfColumnBytes, copiedProof[:])
+		}
+
+		sidecar := &ethpb.DataColumnSidecar{
+			ColumnIndex:                  columnIndex,
+			DataColumn:                   columnBytes,
+			KzgCommitments:               blobKzgCommitments,
+			KzgProof:                     kzgProofOfColumnBytes,
+			SignedBlockHeader:            signedBlockHeader,
+			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
+		}
+
+		sidecars = append(sidecars, sidecar)
+	}
+
+	return sidecars, nil
+}
+
+// VerifyDataColumnSidecarKZGProofs verifies the provided KZG Proofs for the particular
+// data column.
+func VerifyDataColumnSidecarKZGProofs(sc *ethpb.DataColumnSidecar) (bool, error) {
+	if sc.ColumnIndex >= params.BeaconConfig().NumberOfColumns {
+		return false, errIndexTooLarge
+	}
+	if len(sc.DataColumn) != len(sc.KzgCommitments) || len(sc.KzgCommitments) != len(sc.KzgProof) {
+		return false, errMismatchLength
+	}
+
+	var commitments []kzg.Bytes48
+	var indices []uint64
+	var cells []kzg.Cell
+	var proofs []kzg.Bytes48
+	for i := range sc.DataColumn {
+		commitments = append(commitments, kzg.Bytes48(sc.KzgCommitments[i]))
+		indices = append(indices, sc.ColumnIndex)
+		cells = append(cells, kzg.Cell(sc.DataColumn[i]))
+		proofs = append(proofs, kzg.Bytes48(sc.KzgProof[i]))
+	}
+
+	return kzg.VerifyCellKZGProofBatch(commitments, indices, cells, proofs)
+}
+
+// CustodySubnetCount returns the number of subnets the node should participate in for custody.
+func CustodySubnetCount() uint64 {
+	count := params.BeaconConfig().CustodyRequirement
+	if flags.Get().SubscribeToAllSubnets {
+		count = params.BeaconConfig().DataColumnSidecarSubnetCount
+	}
+	return count
+}
+
+// HypergeomCDF computes the hypergeometric cumulative distribution function.
+// https://en.wikipedia.org/wiki/Hypergeometric_distribution
+func HypergeomCDF(k, M, n, N uint64) float64 {
+	denominatorInt := new(big.Int).Binomial(int64(M), int64(N)) // lint:ignore uintcast
+	denominator := new(big.Float).SetInt(denominatorInt)
+
+	rBig := big.NewFloat(0)
+
+	for i := uint64(0); i < k+1; i++ {
+		a := new(big.Int).Binomial(int64(n), int64(i)) // lint:ignore uintcast
+		b := new(big.Int).Binomial(int64(M-n), int64(N-i))
+		numeratorInt := new(big.Int).Mul(a, b)
+		numerator := new(big.Float).SetInt(numeratorInt)
+		item := new(big.Float).Quo(numerator, denominator)
+		rBig.Add(rBig, item)
+	}
+
+	r, _ := rBig.Float64()
+
+	return r
+}
+
+// ExtendedSampleCount computes, for a given number of samples per slot and allowed failures the
+// number of samples we should actually query from peers.
+// TODO: Add link to the specification once it is available.
+func ExtendedSampleCount(samplesPerSlot, allowedFailures uint64) uint64 {
+	// Retrieve the columns count
+	columnsCount := params.BeaconConfig().NumberOfColumns
+
+	// If half of the columns are missing, we are able to reconstruct the data.
+	// If half of the columns + 1 are missing, we are not able to reconstruct the data.
+	// This is the smallest worst case.
+	worstCaseMissing := columnsCount/2 + 1
+
+	// Compute the false positive threshold.
+	falsePositiveThreshold := HypergeomCDF(0, columnsCount, worstCaseMissing, samplesPerSlot)
+
+	var sampleCount uint64
+
+	// Finally, compute the extended sample count.
+	for sampleCount = samplesPerSlot; sampleCount < columnsCount+1; sampleCount++ {
+		if HypergeomCDF(allowedFailures, columnsCount, worstCaseMissing, sampleCount) <= falsePositiveThreshold {
+			break
+		}
+	}
+
+	return sampleCount
+}
+
+func CustodyCountFromRecord(record *enr.Record) (uint64, error) {
+	// By default, we assume the peer custodies the minimum number of subnets.
+	if record == nil {
+		return 0, errRecordNil
+	}
+
+	// Load the `custody_subnet_count`
+	var csc Csc
+	if err := record.Load(&csc); err != nil {
+		return 0, errCannotLoadCustodySubnetCount
+	}
+
+	return uint64(csc), nil
+}
+
+func CanSelfReconstruct(numCol uint64) bool {
+	total := params.BeaconConfig().NumberOfColumns
+	// if total is odd, then we need total / 2 + 1 columns to reconstruct
+	// if total is even, then we need total / 2 columns to reconstruct
+	columnsNeeded := total/2 + total%2
+	return numCol >= columnsNeeded
+}

beacon-chain/core/peerdas/helpers_test.go

@@ -0,0 +1,144 @@
+package peerdas_test
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
+	"testing"
+
+	"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
+	GoKZG "github.com/crate-crypto/go-kzg-4844"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/sirupsen/logrus"
+)
+
+func deterministicRandomness(seed int64) [32]byte {
+	// Converts an int64 to a byte slice
+	buf := new(bytes.Buffer)
+	err := binary.Write(buf, binary.BigEndian, seed)
+	if err != nil {
+		logrus.WithError(err).Error("Failed to write int64 to bytes buffer")
+		return [32]byte{}
+	}
+	bytes := buf.Bytes()
+
+	return sha256.Sum256(bytes)
+}
+
+// Returns a serialized random field element in big-endian
+func GetRandFieldElement(seed int64) [32]byte {
+	bytes := deterministicRandomness(seed)
+	var r fr.Element
+	r.SetBytes(bytes[:])
+
+	return GoKZG.SerializeScalar(r)
+}
+
+// Returns a random blob using the passed seed as entropy
+func GetRandBlob(seed int64) kzg.Blob {
+	var blob kzg.Blob
+	bytesPerBlob := GoKZG.ScalarsPerBlob * GoKZG.SerializedScalarSize
+	for i := 0; i < bytesPerBlob; i += GoKZG.SerializedScalarSize {
+		fieldElementBytes := GetRandFieldElement(seed + int64(i))
+		copy(blob[i:i+GoKZG.SerializedScalarSize], fieldElementBytes[:])
+	}
+	return blob
+}
+
+func GenerateCommitmentAndProof(blob kzg.Blob) (*kzg.Commitment, *kzg.Proof, error) {
+	commitment, err := kzg.BlobToKZGCommitment(&blob)
+	if err != nil {
+		return nil, nil, err
+	}
+	proof, err := kzg.ComputeBlobKZGProof(&blob, commitment)
+	if err != nil {
+		return nil, nil, err
+	}
+	return &commitment, &proof, err
+}
+
+func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
+	dbBlock := util.NewBeaconBlockDeneb()
+	require.NoError(t, kzg.Start())
+
+	var (
+		comms [][]byte
+		blobs []kzg.Blob
+	)
+	for i := int64(0); i < 6; i++ {
+		blob := GetRandBlob(i)
+		commitment, _, err := GenerateCommitmentAndProof(blob)
+		require.NoError(t, err)
+		comms = append(comms, commitment[:])
+		blobs = append(blobs, blob)
+	}
+
+	dbBlock.Block.Body.BlobKzgCommitments = comms
+	sBlock, err := blocks.NewSignedBeaconBlock(dbBlock)
+	require.NoError(t, err)
+	sCars, err := peerdas.DataColumnSidecars(sBlock, blobs)
+	require.NoError(t, err)
+
+	for i, sidecar := range sCars {
+		verified, err := peerdas.VerifyDataColumnSidecarKZGProofs(sidecar)
+		require.NoError(t, err)
+		require.Equal(t, true, verified, fmt.Sprintf("sidecar %d failed", i))
+	}
+}
+
+func TestHypergeomCDF(t *testing.T) {
+	// Test case from https://en.wikipedia.org/wiki/Hypergeometric_distribution
+	// Population size: 1000, number of successes in population: 500, sample size: 10, number of successes in sample: 5
+	// Expected result: 0.072
+	const (
+		expected = 0.0796665913283742
+		margin   = 0.000001
+	)
+
+	actual := peerdas.HypergeomCDF(5, 128, 65, 16)
+	require.Equal(t, true, expected-margin <= actual && actual <= expected+margin)
+}
+
+func TestExtendedSampleCount(t *testing.T) {
+	const samplesPerSlot = 16
+
+	testCases := []struct {
+		name                string
+		allowedMissings     uint64
+		extendedSampleCount uint64
+	}{
+		{name: "allowedMissings=0", allowedMissings: 0, extendedSampleCount: 16},
+		{name: "allowedMissings=1", allowedMissings: 1, extendedSampleCount: 20},
+		{name: "allowedMissings=2", allowedMissings: 2, extendedSampleCount: 24},
+		{name: "allowedMissings=3", allowedMissings: 3, extendedSampleCount: 27},
+		{name: "allowedMissings=4", allowedMissings: 4, extendedSampleCount: 29},
+		{name: "allowedMissings=5", allowedMissings: 5, extendedSampleCount: 32},
+		{name: "allowedMissings=6", allowedMissings: 6, extendedSampleCount: 35},
+		{name: "allowedMissings=7", allowedMissings: 7, extendedSampleCount: 37},
+		{name: "allowedMissings=8", allowedMissings: 8, extendedSampleCount: 40},
+		{name: "allowedMissings=9", allowedMissings: 9, extendedSampleCount: 42},
+		{name: "allowedMissings=10", allowedMissings: 10, extendedSampleCount: 44},
+		{name: "allowedMissings=11", allowedMissings: 11, extendedSampleCount: 47},
+		{name: "allowedMissings=12", allowedMissings: 12, extendedSampleCount: 49},
+		{name: "allowedMissings=13", allowedMissings: 13, extendedSampleCount: 51},
+		{name: "allowedMissings=14", allowedMissings: 14, extendedSampleCount: 53},
+		{name: "allowedMissings=15", allowedMissings: 15, extendedSampleCount: 55},
+		{name: "allowedMissings=16", allowedMissings: 16, extendedSampleCount: 57},
+		{name: "allowedMissings=17", allowedMissings: 17, extendedSampleCount: 59},
+		{name: "allowedMissings=18", allowedMissings: 18, extendedSampleCount: 61},
+		{name: "allowedMissings=19", allowedMissings: 19, extendedSampleCount: 63},
+		{name: "allowedMissings=20", allowedMissings: 20, extendedSampleCount: 65},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := peerdas.ExtendedSampleCount(samplesPerSlot, tc.allowedMissings)
+			require.Equal(t, tc.extendedSampleCount, result)
+		})
+	}
+}

beacon-chain/core/time/slot_epoch.go

@@ -53,6 +53,11 @@ func HigherEqualThanAltairVersionAndEpoch(s state.BeaconState, e primitives.Epoc
 	return s.Version() >= version.Altair && e >= params.BeaconConfig().AltairForkEpoch
 }
 
+// PeerDASIsActive checks whether peerDAS is active at the provided slot.
+func PeerDASIsActive(slot primitives.Slot) bool {
+	return params.PeerDASEnabled() && slots.ToEpoch(slot) >= params.BeaconConfig().Eip7594ForkEpoch
+}
+
 // CanUpgradeToAltair returns true if the input `slot` can upgrade to Altair.
 // Spec code:
 // If state.slot % SLOTS_PER_EPOCH == 0 and compute_epoch_at_slot(state.slot) == ALTAIR_FORK_EPOCH

beacon-chain/core/transition/BUILD.bazel

@@ -40,7 +40,6 @@ go_library(
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/core/transition/state-bellatrix.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-	b "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
@@ -71,7 +70,7 @@ func GenesisBeaconStateBellatrix(ctx context.Context, deposits []*ethpb.Deposit,
 		return nil, err
 	}
 
-	st, err = b.ProcessPreGenesisDeposits(ctx, st, deposits)
+	st, err = altair.ProcessPreGenesisDeposits(ctx, st, deposits)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process validator deposits")
 	}

beacon-chain/core/transition/state.go

@@ -4,7 +4,7 @@ import (
 	"context"
 
 	"github.com/pkg/errors"
-	b "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
@@ -69,7 +69,7 @@ func GenesisBeaconState(ctx context.Context, deposits []*ethpb.Deposit, genesisT
 		return nil, err
 	}
 
-	st, err = b.ProcessPreGenesisDeposits(ctx, st, deposits)
+	st, err = altair.ProcessPreGenesisDeposits(ctx, st, deposits)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process validator deposits")
 	}
@@ -92,7 +92,7 @@ func PreminedGenesisBeaconState(ctx context.Context, deposits []*ethpb.Deposit,
 	if err != nil {
 		return nil, err
 	}
-	st, err = b.ProcessPreGenesisDeposits(ctx, st, deposits)
+	st, err = altair.ProcessPreGenesisDeposits(ctx, st, deposits)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process validator deposits")
 	}

beacon-chain/core/transition/transition.go

@@ -24,7 +24,6 @@ import (
 	"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/math"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"go.opencensus.io/trace"
@@ -376,14 +375,25 @@ func VerifyOperationLengths(_ context.Context, state state.BeaconState, b interf
 	if eth1Data == nil {
 		return nil, errors.New("nil eth1data in state")
 	}
-	if state.Eth1DepositIndex() > eth1Data.DepositCount {
-		return nil, fmt.Errorf("expected state.deposit_index %d <= eth1data.deposit_count %d", state.Eth1DepositIndex(), eth1Data.DepositCount)
-	}
-	maxDeposits := math.Min(params.BeaconConfig().MaxDeposits, eth1Data.DepositCount-state.Eth1DepositIndex())
-	// Verify outstanding deposits are processed up to max number of deposits
-	if uint64(len(body.Deposits())) != maxDeposits {
-		return nil, fmt.Errorf("incorrect outstanding deposits in block body, wanted: %d, got: %d",
-			maxDeposits, len(body.Deposits()))
+
+	if state.Version() < version.Electra {
+		// Deneb specs
+		//  # Verify that outstanding deposits are processed up to the maximum number of deposits
+		//    assert len(body.deposits) == min(MAX_DEPOSITS, state.eth1_data.deposit_count - state.eth1_deposit_index)
+		if state.Eth1DepositIndex() > eth1Data.DepositCount {
+			return nil, fmt.Errorf("expected state.deposit_index %d <= eth1data.deposit_count %d", state.Eth1DepositIndex(), eth1Data.DepositCount)
+		}
+		maxDeposits := min(params.BeaconConfig().MaxDeposits, eth1Data.DepositCount-state.Eth1DepositIndex())
+		// Verify outstanding deposits are processed up to max number of deposits
+		if uint64(len(body.Deposits())) != maxDeposits {
+			return nil, fmt.Errorf("incorrect outstanding deposits in block body, wanted: %d, got: %d",
+				maxDeposits, len(body.Deposits()))
+		}
+	} else {
+		// Electra
+		if err := electra.VerifyBlockDepositLength(body, state); err != nil {
+			return nil, errors.Wrap(err, "failed to verify block deposit length")
+		}
 	}
 
 	return state, nil

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -262,24 +262,21 @@ func ProcessOperationsNoVerifyAttsSigs(
 	}
 
 	var err error
-	switch beaconBlock.Version() {
-	case version.Phase0:
+	if beaconBlock.Version() == version.Phase0 {
 		state, err = phase0Operations(ctx, state, beaconBlock)
 		if err != nil {
 			return nil, err
 		}
-	case version.Altair, version.Bellatrix, version.Capella, version.Deneb:
+	} else if beaconBlock.Version() < version.Electra {
 		state, err = altairOperations(ctx, state, beaconBlock)
 		if err != nil {
 			return nil, err
 		}
-	case version.Electra:
-		state, err = electraOperations(ctx, state, beaconBlock)
+	} else {
+		state, err = electra.ProcessOperations(ctx, state, beaconBlock)
 		if err != nil {
 			return nil, err
 		}
-	default:
-		return nil, errors.New("block does not have correct version")
 	}
 
 	return state, nil
@@ -394,73 +391,6 @@ func VerifyBlobCommitmentCount(blk interfaces.ReadOnlyBeaconBlock) error {
 	return nil
 }
 
-// electraOperations
-//
-// Spec definition:
-//
-//	def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
-//	    # [Modified in Electra:EIP6110]
-//	    # Disable former deposit mechanism once all prior deposits are processed
-//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_requests_start_index)
-//	    if state.eth1_deposit_index < eth1_deposit_index_limit:
-//	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
-//	    else:
-//	        assert len(body.deposits) == 0
-//
-//	    def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
-//	        for operation in operations:
-//	            fn(state, operation)
-//
-//	    for_ops(body.proposer_slashings, process_proposer_slashing)
-//	    for_ops(body.attester_slashings, process_attester_slashing)
-//	    for_ops(body.attestations, process_attestation)  # [Modified in Electra:EIP7549]
-//	    for_ops(body.deposits, process_deposit)  # [Modified in Electra:EIP7251]
-//	    for_ops(body.voluntary_exits, process_voluntary_exit)  # [Modified in Electra:EIP7251]
-//	    for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
-//	    # [New in Electra:EIP7002:EIP7251]
-//	    for_ops(body.execution_payload.withdrawal_requests, process_execution_layer_withdrawal_request)
-//	    for_ops(body.execution_payload.deposit_requests, process_deposit_requests)  # [New in Electra:EIP6110]
-//	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
-func electraOperations(
-	ctx context.Context,
-	st state.BeaconState,
-	block interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
-	// 6110 validations are in VerifyOperationLengths
-
-	// Electra extends the altair operations.
-	st, err := altairOperations(ctx, st, block)
-	if err != nil {
-		return nil, err
-	}
-	b := block.Body()
-	bod, ok := b.(interfaces.ROBlockBodyElectra)
-	if !ok {
-		return nil, errors.New("could not cast block body to electra block body")
-	}
-	e, err := bod.Execution()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution data from block")
-	}
-	exe, ok := e.(interfaces.ExecutionDataElectra)
-	if !ok {
-		return nil, errors.New("could not cast execution data to electra execution data")
-	}
-	st, err = electra.ProcessWithdrawalRequests(ctx, st, exe.WithdrawalRequests())
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process execution layer withdrawal requests")
-	}
-
-	st, err = electra.ProcessDepositRequests(ctx, st, exe.DepositRequests()) // TODO: EIP-6110 deposit changes.
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process deposit receipts")
-	}
-
-	if err := electra.ProcessConsolidations(ctx, st, bod.Consolidations()); err != nil {
-		return nil, errors.Wrap(err, "could not process consolidations")
-	}
-	return st, nil
-}
-
 // This calls altair block operations.
 func altairOperations(
 	ctx context.Context,
@@ -505,7 +435,7 @@ func phase0Operations(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process block attestations")
 	}
-	if _, err := b.ProcessDeposits(ctx, st, beaconBlock.Body().Deposits()); err != nil {
+	if _, err := altair.ProcessDeposits(ctx, st, beaconBlock.Body().Deposits()); err != nil {
 		return nil, errors.Wrap(err, "could not process deposits")
 	}
 	return b.ProcessVoluntaryExits(ctx, st, beaconBlock.Body().VoluntaryExits())

beacon-chain/das/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "availability.go",
+        "availability_columns.go",
         "cache.go",
         "iface.go",
         "mock.go",
@@ -20,6 +21,7 @@ go_library(
         "//runtime/logging:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],

beacon-chain/das/availability_columns.go

@@ -0,0 +1,151 @@
+package das
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/p2p/enode"
+	errors "github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	log "github.com/sirupsen/logrus"
+)
+
+// LazilyPersistentStoreColumn is an implementation of AvailabilityStore to be used when batch syncing data columns.
+// This implementation will hold any blobs passed to Persist until the IsDataAvailable is called for their
+// block, at which time they will undergo full verification and be saved to the disk.
+type LazilyPersistentStoreColumn struct {
+	store    *filesystem.BlobStorage
+	cache    *cache
+	verifier ColumnBatchVerifier
+	nodeID   enode.ID
+}
+
+type ColumnBatchVerifier interface {
+	VerifiedRODataColumns(ctx context.Context, blk blocks.ROBlock, sc []blocks.RODataColumn) ([]blocks.VerifiedRODataColumn, error)
+}
+
+func NewLazilyPersistentStoreColumn(store *filesystem.BlobStorage, verifier ColumnBatchVerifier, id enode.ID) *LazilyPersistentStoreColumn {
+	return &LazilyPersistentStoreColumn{
+		store:    store,
+		cache:    newCache(),
+		verifier: verifier,
+		nodeID:   id,
+	}
+}
+
+// TODO: Very Ugly, change interface to allow for columns and blobs
+func (s *LazilyPersistentStoreColumn) Persist(current primitives.Slot, sc ...blocks.ROBlob) error {
+	return nil
+}
+
+// PersistColumns adds columns to the working column cache. columns stored in this cache will be persisted
+// for at least as long as the node is running. Once IsDataAvailable succeeds, all blobs referenced
+// by the given block are guaranteed to be persisted for the remainder of the retention period.
+func (s *LazilyPersistentStoreColumn) PersistColumns(current primitives.Slot, sc ...blocks.RODataColumn) error {
+	if len(sc) == 0 {
+		return nil
+	}
+	if len(sc) > 1 {
+		first := sc[0].BlockRoot()
+		for i := 1; i < len(sc); i++ {
+			if first != sc[i].BlockRoot() {
+				return errMixedRoots
+			}
+		}
+	}
+	if !params.WithinDAPeriod(slots.ToEpoch(sc[0].Slot()), slots.ToEpoch(current)) {
+		return nil
+	}
+	key := keyFromColumn(sc[0])
+	entry := s.cache.ensure(key)
+	for i := range sc {
+		if err := entry.stashColumns(&sc[i]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// IsDataAvailable returns nil if all the commitments in the given block are persisted to the db and have been verified.
+// BlobSidecars already in the db are assumed to have been previously verified against the block.
+func (s *LazilyPersistentStoreColumn) IsDataAvailable(ctx context.Context, current primitives.Slot, b blocks.ROBlock) error {
+	blockCommitments, err := fullCommitmentsToCheck(b, current)
+	if err != nil {
+		return errors.Wrapf(err, "could check data availability for block %#x", b.Root())
+	}
+	// Return early for blocks that are pre-deneb or which do not have any commitments.
+	if blockCommitments.count() == 0 {
+		return nil
+	}
+
+	key := keyFromBlock(b)
+	entry := s.cache.ensure(key)
+	defer s.cache.delete(key)
+	root := b.Root()
+	sumz, err := s.store.WaitForSummarizer(ctx)
+	if err != nil {
+		log.WithField("root", fmt.Sprintf("%#x", b.Root())).
+			WithError(err).
+			Debug("Failed to receive BlobStorageSummarizer within IsDataAvailable")
+	} else {
+		entry.setDiskSummary(sumz.Summary(root))
+	}
+
+	// Verify we have all the expected sidecars, and fail fast if any are missing or inconsistent.
+	// We don't try to salvage problematic batches because this indicates a misbehaving peer and we'd rather
+	// ignore their response and decrease their peer score.
+	sidecars, err := entry.filterColumns(root, blockCommitments)
+	if err != nil {
+		return errors.Wrap(err, "incomplete BlobSidecar batch")
+	}
+	// Do thorough verifications of each BlobSidecar for the block.
+	// Same as above, we don't save BlobSidecars if there are any problems with the batch.
+	vscs, err := s.verifier.VerifiedRODataColumns(ctx, b, sidecars)
+	if err != nil {
+		var me verification.VerificationMultiError
+		ok := errors.As(err, &me)
+		if ok {
+			fails := me.Failures()
+			lf := make(log.Fields, len(fails))
+			for i := range fails {
+				lf[fmt.Sprintf("fail_%d", i)] = fails[i].Error()
+			}
+			log.WithFields(lf).
+				Debug("invalid ColumnSidecars received")
+		}
+		return errors.Wrapf(err, "invalid ColumnSidecars received for block %#x", root)
+	}
+	// Ensure that each column sidecar is written to disk.
+	for i := range vscs {
+		if err := s.store.SaveDataColumn(vscs[i]); err != nil {
+			return errors.Wrapf(err, "failed to save ColumnSidecar index %d for block %#x", vscs[i].ColumnIndex, root)
+		}
+	}
+	// All ColumnSidecars are persisted - da check succeeds.
+	return nil
+}
+
+func fullCommitmentsToCheck(b blocks.ROBlock, current primitives.Slot) (safeCommitmentsArray, error) {
+	var ar safeCommitmentsArray
+	if b.Version() < version.Deneb {
+		return ar, nil
+	}
+	// We are only required to check within MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS
+	if !params.WithinDAPeriod(slots.ToEpoch(b.Block().Slot()), slots.ToEpoch(current)) {
+		return ar, nil
+	}
+	kc, err := b.Block().Body().BlobKzgCommitments()
+	if err != nil {
+		return ar, err
+	}
+	for i := range ar {
+		copy(ar[i], kc)
+	}
+	return ar, nil
+}

beacon-chain/das/cache.go

@@ -2,6 +2,7 @@ package das
 
 import (
 	"bytes"
+	"reflect"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
@@ -38,6 +39,10 @@ func keyFromSidecar(sc blocks.ROBlob) cacheKey {
 	return cacheKey{slot: sc.Slot(), root: sc.BlockRoot()}
 }
 
+func keyFromColumn(sc blocks.RODataColumn) cacheKey {
+	return cacheKey{slot: sc.Slot(), root: sc.BlockRoot()}
+}
+
 // keyFromBlock is a convenience method for constructing a cacheKey from a ROBlock value.
 func keyFromBlock(b blocks.ROBlock) cacheKey {
 	return cacheKey{slot: b.Block().Slot(), root: b.Root()}
@@ -61,6 +66,7 @@ func (c *cache) delete(key cacheKey) {
 // cacheEntry holds a fixed-length cache of BlobSidecars.
 type cacheEntry struct {
 	scs         [fieldparams.MaxBlobsPerBlock]*blocks.ROBlob
+	colScs      [fieldparams.NumberOfColumns]*blocks.RODataColumn
 	diskSummary filesystem.BlobStorageSummary
 }
 
@@ -82,6 +88,17 @@ func (e *cacheEntry) stash(sc *blocks.ROBlob) error {
 	return nil
 }
 
+func (e *cacheEntry) stashColumns(sc *blocks.RODataColumn) error {
+	if sc.ColumnIndex >= fieldparams.NumberOfColumns {
+		return errors.Wrapf(errIndexOutOfBounds, "index=%d", sc.ColumnIndex)
+	}
+	if e.colScs[sc.ColumnIndex] != nil {
+		return errors.Wrapf(ErrDuplicateSidecar, "root=%#x, index=%d, commitment=%#x", sc.BlockRoot(), sc.ColumnIndex, sc.KzgCommitments)
+	}
+	e.colScs[sc.ColumnIndex] = sc
+	return nil
+}
+
 // filter evicts sidecars that are not committed to by the block and returns custom
 // errors if the cache is missing any of the commitments, or if the commitments in
 // the cache do not match those found in the block. If err is nil, then all expected
@@ -117,6 +134,35 @@ func (e *cacheEntry) filter(root [32]byte, kc safeCommitmentArray) ([]blocks.ROB
 	return scs, nil
 }
 
+func (e *cacheEntry) filterColumns(root [32]byte, kc safeCommitmentsArray) ([]blocks.RODataColumn, error) {
+	if e.diskSummary.AllAvailable(kc.count()) {
+		return nil, nil
+	}
+	scs := make([]blocks.RODataColumn, 0, kc.count())
+	for i := uint64(0); i < fieldparams.NumberOfColumns; i++ {
+		// We already have this blob, we don't need to write it or validate it.
+		if e.diskSummary.HasIndex(i) {
+			continue
+		}
+		if kc[i] == nil {
+			if e.colScs[i] != nil {
+				return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, no block commitment", root, i, e.scs[i].KzgCommitment)
+			}
+			continue
+		}
+
+		if e.colScs[i] == nil {
+			return nil, errors.Wrapf(errMissingSidecar, "root=%#x, index=%#x", root, i)
+		}
+		if !reflect.DeepEqual(kc[i], e.colScs[i].KzgCommitments) {
+			return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, block commitment=%#x", root, i, e.colScs[i].KzgCommitments, kc[i])
+		}
+		scs = append(scs, *e.colScs[i])
+	}
+
+	return scs, nil
+}
+
 // safeCommitmentArray is a fixed size array of commitment byte slices. This is helpful for avoiding
 // gratuitous bounds checks.
 type safeCommitmentArray [fieldparams.MaxBlobsPerBlock][]byte
@@ -129,3 +175,14 @@ func (s safeCommitmentArray) count() int {
 	}
 	return fieldparams.MaxBlobsPerBlock
 }
+
+type safeCommitmentsArray [fieldparams.NumberOfColumns][][]byte
+
+func (s safeCommitmentsArray) count() int {
+	for i := range s {
+		if s[i] == nil {
+			return i
+		}
+	}
+	return fieldparams.NumberOfColumns
+}

beacon-chain/db/filesystem/BUILD.bazel

@@ -13,6 +13,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem",
     visibility = ["//visibility:public"],
     deps = [
+        "//async/event:go_default_library",
         "//beacon-chain/verification:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

beacon-chain/db/filesystem/blob.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -39,8 +40,15 @@ const (
 	directoryPermissions = 0700
 )
 
-// BlobStorageOption is a functional option for configuring a BlobStorage.
-type BlobStorageOption func(*BlobStorage) error
+type (
+	// BlobStorageOption is a functional option for configuring a BlobStorage.
+	BlobStorageOption func(*BlobStorage) error
+
+	RootIndexPair struct {
+		Root  [fieldparams.RootLength]byte
+		Index uint64
+	}
+)
 
 // WithBasePath is a required option that sets the base path of blob storage.
 func WithBasePath(base string) BlobStorageOption {
@@ -70,7 +78,10 @@ func WithSaveFsync(fsync bool) BlobStorageOption {
 // attempt to hold a file lock to guarantee exclusive control of the blob storage directory, so this should only be
 // initialized once per beacon node.
 func NewBlobStorage(opts ...BlobStorageOption) (*BlobStorage, error) {
-	b := &BlobStorage{}
+	b := &BlobStorage{
+		DataColumnFeed: new(event.Feed),
+	}
+
 	for _, o := range opts {
 		if err := o(b); err != nil {
 			return nil, errors.Wrap(err, "failed to create blob storage")
@@ -99,6 +110,7 @@ type BlobStorage struct {
 	fsync           bool
 	fs              afero.Fs
 	pruner          *blobPruner
+	DataColumnFeed  *event.Feed
 }
 
 // WarmCache runs the prune routine with an expiration of slot of 0, so nothing will be pruned, but the pruner's cache
@@ -221,6 +233,110 @@ func (bs *BlobStorage) Save(sidecar blocks.VerifiedROBlob) error {
 	return nil
 }
 
+// SaveDataColumn saves a data column to our local filesystem.
+func (bs *BlobStorage) SaveDataColumn(column blocks.VerifiedRODataColumn) error {
+	startTime := time.Now()
+	fname := namerForDataColumn(column)
+	sszPath := fname.path()
+	exists, err := afero.Exists(bs.fs, sszPath)
+	if err != nil {
+		return err
+	}
+
+	if exists {
+		log.Trace("Ignoring a duplicate data column sidecar save attempt")
+		return nil
+	}
+
+	if bs.pruner != nil {
+		hRoot, err := column.SignedBlockHeader.Header.HashTreeRoot()
+		if err != nil {
+			return err
+		}
+		if err := bs.pruner.notify(hRoot, column.SignedBlockHeader.Header.Slot, column.ColumnIndex); err != nil {
+			return errors.Wrapf(err, "problem maintaining pruning cache/metrics for sidecar with root=%#x", hRoot)
+		}
+	}
+
+	// Serialize the ethpb.DataColumnSidecar to binary data using SSZ.
+	sidecarData, err := column.MarshalSSZ()
+	if err != nil {
+		return errors.Wrap(err, "failed to serialize sidecar data")
+	} else if len(sidecarData) == 0 {
+		return errSidecarEmptySSZData
+	}
+
+	if err := bs.fs.MkdirAll(fname.dir(), directoryPermissions); err != nil {
+		return err
+	}
+	partPath := fname.partPath(fmt.Sprintf("%p", sidecarData))
+
+	partialMoved := false
+	// Ensure the partial file is deleted.
+	defer func() {
+		if partialMoved {
+			return
+		}
+		// It's expected to error if the save is successful.
+		err = bs.fs.Remove(partPath)
+		if err == nil {
+			log.WithFields(logrus.Fields{
+				"partPath": partPath,
+			}).Debugf("Removed partial file")
+		}
+	}()
+
+	// Create a partial file and write the serialized data to it.
+	partialFile, err := bs.fs.Create(partPath)
+	if err != nil {
+		return errors.Wrap(err, "failed to create partial file")
+	}
+
+	n, err := partialFile.Write(sidecarData)
+	if err != nil {
+		closeErr := partialFile.Close()
+		if closeErr != nil {
+			return closeErr
+		}
+		return errors.Wrap(err, "failed to write to partial file")
+	}
+	if bs.fsync {
+		if err := partialFile.Sync(); err != nil {
+			return err
+		}
+	}
+
+	if err := partialFile.Close(); err != nil {
+		return err
+	}
+
+	if n != len(sidecarData) {
+		return fmt.Errorf("failed to write the full bytes of sidecarData, wrote only %d of %d bytes", n, len(sidecarData))
+	}
+
+	if n == 0 {
+		return errEmptyBlobWritten
+	}
+
+	// Atomically rename the partial file to its final name.
+	err = bs.fs.Rename(partPath, sszPath)
+	if err != nil {
+		return errors.Wrap(err, "failed to rename partial file to final name")
+	}
+	partialMoved = true
+
+	// Notify the data column notifier that a new data column has been saved.
+	bs.DataColumnFeed.Send(RootIndexPair{
+		Root:  column.BlockRoot(),
+		Index: column.ColumnIndex,
+	})
+
+	// TODO: Use new metrics for data columns
+	blobsWrittenCounter.Inc()
+	blobSaveLatency.Observe(float64(time.Since(startTime).Milliseconds()))
+	return nil
+}
+
 // Get retrieves a single BlobSidecar by its root and index.
 // Since BlobStorage only writes blobs that have undergone full verification, the return
 // value is always a VerifiedROBlob.
@@ -246,6 +362,20 @@ func (bs *BlobStorage) Get(root [32]byte, idx uint64) (blocks.VerifiedROBlob, er
 	return verification.BlobSidecarNoop(ro)
 }
 
+// GetColumn retrieves a single DataColumnSidecar by its root and index.
+func (bs *BlobStorage) GetColumn(root [32]byte, idx uint64) (*ethpb.DataColumnSidecar, error) {
+	expected := blobNamer{root: root, index: idx}
+	encoded, err := afero.ReadFile(bs.fs, expected.path())
+	if err != nil {
+		return nil, err
+	}
+	s := &ethpb.DataColumnSidecar{}
+	if err := s.UnmarshalSSZ(encoded); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
 // Remove removes all blobs for a given root.
 func (bs *BlobStorage) Remove(root [32]byte) error {
 	rootDir := blobNamer{root: root}.dir()
@@ -289,6 +419,61 @@ func (bs *BlobStorage) Indices(root [32]byte) ([fieldparams.MaxBlobsPerBlock]boo
 	return mask, nil
 }
 
+// ColumnIndices retrieve the stored column indexes from our filesystem.
+func (bs *BlobStorage) ColumnIndices(root [32]byte) (map[uint64]bool, error) {
+	custody := make(map[uint64]bool, fieldparams.NumberOfColumns)
+
+	// Get all the files in the directory.
+	rootDir := blobNamer{root: root}.dir()
+	entries, err := afero.ReadDir(bs.fs, rootDir)
+	if err != nil {
+		// If the directory does not exist, we do not custody any columns.
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+
+		return nil, errors.Wrap(err, "read directory")
+	}
+
+	// Iterate over all the entries in the directory.
+	for _, entry := range entries {
+		// If the entry is a directory, skip it.
+		if entry.IsDir() {
+			continue
+		}
+
+		// If the entry does not have the correct extension, skip it.
+		name := entry.Name()
+		if !strings.HasSuffix(name, sszExt) {
+			continue
+		}
+
+		// The file should be in the `<index>.<extension>` format.
+		// Skip the file if it does not match the format.
+		parts := strings.Split(name, ".")
+		if len(parts) != 2 {
+			continue
+		}
+
+		// Get the column index from the file name.
+		columnIndexStr := parts[0]
+		columnIndex, err := strconv.ParseUint(columnIndexStr, 10, 64)
+		if err != nil {
+			return nil, errors.Wrapf(err, "unexpected directory entry breaks listing, %s", parts[0])
+		}
+
+		// If the column index is out of bounds, return an error.
+		if columnIndex >= fieldparams.NumberOfColumns {
+			return nil, errors.Wrapf(errIndexOutOfBounds, "invalid index %d", columnIndex)
+		}
+
+		// Mark the column index as in custody.
+		custody[columnIndex] = true
+	}
+
+	return custody, nil
+}
+
 // Clear deletes all files on the filesystem.
 func (bs *BlobStorage) Clear() error {
 	dirs, err := listDir(bs.fs, ".")
@@ -321,6 +506,10 @@ func namerForSidecar(sc blocks.VerifiedROBlob) blobNamer {
 	return blobNamer{root: sc.BlockRoot(), index: sc.Index}
 }
 
+func namerForDataColumn(col blocks.VerifiedRODataColumn) blobNamer {
+	return blobNamer{root: col.BlockRoot(), index: col.ColumnIndex}
+}
+
 func (p blobNamer) dir() string {
 	return rootString(p.root)
 }

beacon-chain/db/filesystem/cache.go

@@ -9,7 +9,7 @@ import (
 )
 
 // blobIndexMask is a bitmask representing the set of blob indices that are currently set.
-type blobIndexMask [fieldparams.MaxBlobsPerBlock]bool
+type blobIndexMask [fieldparams.NumberOfColumns]bool
 
 // BlobStorageSummary represents cached information about the BlobSidecars on disk for each root the cache knows about.
 type BlobStorageSummary struct {
@@ -68,9 +68,12 @@ func (s *blobStorageCache) Summary(root [32]byte) BlobStorageSummary {
 }
 
 func (s *blobStorageCache) ensure(key [32]byte, slot primitives.Slot, idx uint64) error {
-	if idx >= fieldparams.MaxBlobsPerBlock {
-		return errIndexOutOfBounds
-	}
+	// TODO: Separate blob index checks from data column index checks
+	/*
+		if idx >= fieldparams.MaxBlobsPerBlock {
+			return errIndexOutOfBounds
+		}
+	*/
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	v := s.cache[key]

beacon-chain/db/filesystem/cache_test.go

@@ -9,6 +9,7 @@ import (
 )
 
 func TestSlotByRoot_Summary(t *testing.T) {
+	t.Skip("Use new test for data columns")
 	var noneSet, allSet, firstSet, lastSet, oneSet blobIndexMask
 	firstSet[0] = true
 	lastSet[len(lastSet)-1] = true

beacon-chain/db/iface/interface.go

@@ -161,6 +161,7 @@ type SlasherDatabase interface {
 	) ([]*ethpb.HighestAttestation, error)
 	DatabasePath() string
 	ClearDB() error
+	Migrate(ctx context.Context, headEpoch, maxPruningEpoch primitives.Epoch, batchSize int) error
 }
 
 // Database interface with full access.

beacon-chain/db/kv/blocks.go

@@ -23,10 +23,10 @@ import (
 	"go.opencensus.io/trace"
 )
 
-// used to represent errors for inconsistent slot ranges.
+// Used to represent errors for inconsistent slot ranges.
 var errInvalidSlotRange = errors.New("invalid end slot and start slot provided")
 
-// Block retrieval by root.
+// Block retrieval by root. Return nil if block is not found.
 func (s *Store) Block(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.Block")
 	defer span.End()

beacon-chain/db/kv/blocks_test.go

@@ -132,16 +132,6 @@ var blockTests = []struct {
 			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)
 		},
@@ -153,16 +143,6 @@ var blockTests = []struct {
 			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)
 		}},

beacon-chain/db/kv/encoding.go

@@ -68,11 +68,11 @@ func isSSZStorageFormat(obj interface{}) bool {
 		return true
 	case *ethpb.BeaconBlock:
 		return true
-	case *ethpb.Attestation:
+	case *ethpb.Attestation, *ethpb.AttestationElectra:
 		return true
 	case *ethpb.Deposit:
 		return true
-	case *ethpb.AttesterSlashing:
+	case *ethpb.AttesterSlashing, *ethpb.AttesterSlashingElectra:
 		return true
 	case *ethpb.ProposerSlashing:
 		return true

beacon-chain/db/kv/state_test.go

@@ -138,19 +138,20 @@ func TestState_CanSaveRetrieve(t *testing.T) {
 				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),
-					DepositRequestsRoot:    make([]byte, 32),
-					WithdrawalRequestsRoot: make([]byte, 32),
+					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),
+					DepositRequestsRoot:       make([]byte, 32),
+					WithdrawalRequestsRoot:    make([]byte, 32),
+					ConsolidationRequestsRoot: make([]byte, 32),
 				})
 				require.NoError(t, err)
 				require.NoError(t, st.SetLatestExecutionPayloadHeader(p))

beacon-chain/db/slasherkv/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
         "kv.go",
         "log.go",
         "metrics.go",
+        "migrate.go",
         "pruning.go",
         "schema.go",
         "slasher.go",
@@ -37,6 +38,7 @@ go_test(
     name = "go_default_test",
     srcs = [
         "kv_test.go",
+        "migrate_test.go",
         "pruning_test.go",
         "slasher_test.go",
         "slasherkv_test.go",

beacon-chain/db/slasherkv/migrate.go

@@ -0,0 +1,231 @@
+package slasherkv
+
+import (
+	"context"
+	"encoding/binary"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"github.com/sirupsen/logrus"
+	bolt "go.etcd.io/bbolt"
+)
+
+// Migrate , its corresponding usage and tests can be totally removed once Electra is on mainnet.
+// Previously, the first 8 bytes of keys of `attestation-data-roots` and `proposal-records` buckets
+// were stored as little-endian respectively epoch and slots. It was the source of
+// https://github.com/prysmaticlabs/prysm/issues/14142 and potentially
+// https://github.com/prysmaticlabs/prysm/issues/13658.
+// To solve this (or these) issue(s), we decided to store the first 8 bytes of keys as big-endian.
+// See https://github.com/prysmaticlabs/prysm/pull/14151.
+// However, not to break the backward compatibility, we need to migrate the existing data.
+// The strategy is quite simple: If, for these bucket keys in the store, we detect
+// a slot (resp. epoch) higher, than the current slot (resp. epoch), then we consider that the data
+// is stored in little-endian. We create a new entry with the same value, but with the slot (resp. epoch)
+// part in the key stored as a big-endian.
+// We start the iterate by the highest key and iterate down until we reach the current slot (resp. epoch).
+func (s *Store) Migrate(ctx context.Context, headEpoch, maxPruningEpoch primitives.Epoch, batchSize int) error {
+	// Migrate attestations.
+	log.Info("Starting migration of attestations. This may take a while.")
+	start := time.Now()
+
+	if err := s.migrateAttestations(ctx, headEpoch, maxPruningEpoch, batchSize); err != nil {
+		return errors.Wrap(err, "migrate attestations")
+	}
+
+	log.WithField("duration", time.Since(start)).Info("Migration of attestations completed successfully")
+
+	// Migrate proposals.
+	log.Info("Starting migration of proposals. This may take a while.")
+	start = time.Now()
+
+	if err := s.migrateProposals(ctx, headEpoch, maxPruningEpoch, batchSize); err != nil {
+		return errors.Wrap(err, "migrate proposals")
+	}
+
+	log.WithField("duration", time.Since(start)).Info("Migration of proposals completed successfully")
+
+	return nil
+}
+
+func (s *Store) migrateAttestations(ctx context.Context, headEpoch, maxPruningEpoch primitives.Epoch, batchSize int) error {
+	done := false
+	var epochLittleEndian uint64
+
+	for !done {
+		count := 0
+
+		if err := s.db.Update(func(tx *bolt.Tx) error {
+			signingRootsBkt := tx.Bucket(attestationDataRootsBucket)
+			attRecordsBkt := tx.Bucket(attestationRecordsBucket)
+
+			// We begin a migrating iteration starting from the last item in the bucket.
+			c := signingRootsBkt.Cursor()
+			for k, v := c.Last(); k != nil; k, v = c.Prev() {
+				if count >= batchSize {
+					log.WithField("epoch", epochLittleEndian).Info("Migrated attestations")
+
+					return nil
+				}
+
+				// Check if the context is done.
+				if ctx.Err() != nil {
+					return ctx.Err()
+				}
+
+				// Extract the epoch encoded in the first 8 bytes of the key.
+				encodedEpoch := k[:8]
+
+				// Convert it to an uint64, considering it is stored as big-endian.
+				epochBigEndian := binary.BigEndian.Uint64(encodedEpoch)
+
+				// If the epoch is smaller or equal to the current epoch, we are done.
+				if epochBigEndian <= uint64(headEpoch) {
+					break
+				}
+
+				// Otherwise, we consider that the epoch is stored as little-endian.
+				epochLittleEndian = binary.LittleEndian.Uint64(encodedEpoch)
+
+				// Increment the count of migrated items.
+				count++
+
+				// If the epoch is still higher than the current epoch, then it is an issue.
+				// This should never happen.
+				if epochLittleEndian > uint64(headEpoch) {
+					log.WithFields(logrus.Fields{
+						"epochLittleEndian": epochLittleEndian,
+						"epochBigEndian":    epochBigEndian,
+						"headEpoch":         headEpoch,
+					}).Error("Epoch is higher than the current epoch both if stored as little-endian or as big-endian")
+
+					continue
+				}
+
+				epoch := primitives.Epoch(epochLittleEndian)
+				if err := signingRootsBkt.Delete(k); err != nil {
+					return err
+				}
+
+				// We don't bother migrating data that is going to be pruned by the pruning routine.
+				if epoch <= maxPruningEpoch {
+					if err := attRecordsBkt.Delete(v); err != nil {
+						return err
+					}
+
+					continue
+				}
+
+				// Create a new key with the epoch stored as big-endian.
+				newK := make([]byte, 8)
+				binary.BigEndian.PutUint64(newK, uint64(epoch))
+				newK = append(newK, k[8:]...)
+
+				// Store the same value with the new key.
+				if err := signingRootsBkt.Put(newK, v); err != nil {
+					return err
+				}
+			}
+
+			done = true
+
+			return nil
+		}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *Store) migrateProposals(ctx context.Context, headEpoch, maxPruningEpoch primitives.Epoch, batchSize int) error {
+	done := false
+
+	if !done {
+		count := 0
+
+		// Compute the max pruning slot.
+		maxPruningSlot, err := slots.EpochEnd(maxPruningEpoch)
+		if err != nil {
+			return errors.Wrap(err, "compute max pruning slot")
+		}
+
+		// Compute the head slot.
+		headSlot, err := slots.EpochEnd(headEpoch)
+		if err != nil {
+			return errors.Wrap(err, "compute head slot")
+		}
+
+		if err := s.db.Update(func(tx *bolt.Tx) error {
+			proposalBkt := tx.Bucket(proposalRecordsBucket)
+
+			// We begin a migrating iteration starting from the last item in the bucket.
+			c := proposalBkt.Cursor()
+			for k, v := c.Last(); k != nil; k, v = c.Prev() {
+				if count >= batchSize {
+					return nil
+				}
+
+				// Check if the context is done.
+				if ctx.Err() != nil {
+					return ctx.Err()
+				}
+
+				// Extract the slot encoded in the first 8 bytes of the key.
+				encodedSlot := k[:8]
+
+				// Convert it to an uint64, considering it is stored as big-endian.
+				slotBigEndian := binary.BigEndian.Uint64(encodedSlot)
+
+				// If the epoch is smaller or equal to the current epoch, we are done.
+				if slotBigEndian <= uint64(headSlot) {
+					break
+				}
+
+				// Otherwise, we consider that the epoch is stored as little-endian.
+				slotLittleEndian := binary.LittleEndian.Uint64(encodedSlot)
+
+				// If the slot is still higher than the current slot, then it is an issue.
+				// This should never happen.
+				if slotLittleEndian > uint64(headSlot) {
+					log.WithFields(logrus.Fields{
+						"slotLittleEndian": slotLittleEndian,
+						"slotBigEndian":    slotBigEndian,
+						"headSlot":         headSlot,
+					}).Error("Slot is higher than the current slot both if stored as little-endian or as big-endian")
+
+					continue
+				}
+
+				slot := primitives.Slot(slotLittleEndian)
+				if err := proposalBkt.Delete(k); err != nil {
+					return err
+				}
+
+				// We don't bother migrating data that is going to be pruned by the pruning routine.
+				if slot <= maxPruningSlot {
+					continue
+				}
+
+				// Create a new key with the epoch stored as big-endian.
+				newK := make([]byte, 8)
+				binary.BigEndian.PutUint64(newK, uint64(slot))
+				newK = append(newK, k[8:]...)
+
+				// Store the same value with the new key.
+				if err := proposalBkt.Put(newK, v); err != nil {
+					return err
+				}
+			}
+
+			done = true
+
+			return nil
+		}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}