Add it in

BUILD.bazel

@@ -224,7 +224,6 @@ 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

@@ -332,14 +332,14 @@ http_archive(
 filegroup(
     name = "configs",
     srcs = [
-        "metadata/config.yaml",
+        "custom_config_data/config.yaml",
     ],
     visibility = ["//visibility:public"],
 )
 """,
-    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
+    sha256 = "5f4be6fd088683ea9db45c863b9c5a1884422449e5b59fd2d561d3ba0f73ffd9",
+    strip_prefix = "holesky-9d9aabf2d4de51334ee5fed6c79a4d55097d1a43",
+    url = "https://github.com/eth-clients/holesky/archive/9d9aabf2d4de51334ee5fed6c79a4d55097d1a43.tar.gz",  # 2024-01-22
 )
 
 http_archive(

api/client/beacon/health.go

@@ -48,13 +48,8 @@ func (n *NodeHealthTracker) CheckHealth(ctx context.Context) bool {
 	if isStatusChanged {
 		// Update the health status
 		n.isHealthy = &newStatus
-		// Send the new status to the health channel, potentially overwriting the existing value
-		select {
-		case <-n.healthChan:
-			n.healthChan <- newStatus
-		default:
-			n.healthChan <- newStatus
-		}
+		// Send the new status to the health channel
+		n.healthChan <- newStatus
 	}
 	return newStatus
 }

api/client/beacon/health_test.go

@@ -87,6 +87,12 @@ func TestNodeHealth_Concurrency(t *testing.T) {
 	// Number of goroutines to spawn for both reading and writing
 	numGoroutines := 6
 
+	go func() {
+		for range n.HealthUpdates() {
+			// Consume values to avoid blocking on channel send.
+		}
+	}()
+
 	wg.Add(numGoroutines * 2) // for readers and writers
 
 	// Concurrently update health status

api/client/beacon/testing/mock.go

@@ -3,7 +3,6 @@ package testing
 import (
 	"context"
 	"reflect"
-	"sync"
 
 	"github.com/prysmaticlabs/prysm/v5/api/client/beacon/iface"
 	"go.uber.org/mock/gomock"
@@ -17,7 +16,6 @@ var (
 type MockHealthClient struct {
 	ctrl     *gomock.Controller
 	recorder *MockHealthClientMockRecorder
-	sync.Mutex
 }
 
 // MockHealthClientMockRecorder is the mock recorder for MockHealthClient.
@@ -27,8 +25,6 @@ type MockHealthClientMockRecorder struct {
 
 // IsHealthy mocks base method.
 func (m *MockHealthClient) IsHealthy(arg0 context.Context) bool {
-	m.Lock()
-	defer m.Unlock()
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "IsHealthy", arg0)
 	ret0, ok := ret[0].(bool)
@@ -45,8 +41,6 @@ func (m *MockHealthClient) EXPECT() *MockHealthClientMockRecorder {
 
 // IsHealthy indicates an expected call of IsHealthy.
 func (mr *MockHealthClientMockRecorder) IsHealthy(arg0 any) *gomock.Call {
-	mr.mock.Lock()
-	defer mr.mock.Unlock()
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHealthy", reflect.TypeOf((*MockHealthClient)(nil).IsHealthy), arg0)
 }

api/gateway/BUILD.bazel

@@ -14,7 +14,7 @@ go_library(
         "//validator:__subpackages__",
     ],
     deps = [
-        "//api/server/middleware:go_default_library",
+        "//api/server:go_default_library",
         "//runtime:go_default_library",
         "@com_github_gorilla_mux//:go_default_library",
         "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",

api/gateway/gateway.go

@@ -11,7 +11,7 @@ import (
 	"github.com/gorilla/mux"
 	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
+	"github.com/prysmaticlabs/prysm/v5/api/server"
 	"github.com/prysmaticlabs/prysm/v5/runtime"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/connectivity"
@@ -104,7 +104,7 @@ func (g *Gateway) Start() {
 		}
 	}
 
-	corsMux := middleware.CorsHandler(g.cfg.allowedOrigins).Middleware(g.cfg.router)
+	corsMux := server.CorsHandler(g.cfg.allowedOrigins).Middleware(g.cfg.router)
 
 	if g.cfg.muxHandler != nil {
 		g.cfg.router.PathPrefix("/").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

api/server/BUILD.bazel

@@ -2,14 +2,29 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = ["error.go"],
+    srcs = [
+        "error.go",
+        "middleware.go",
+        "util.go",
+    ],
     importpath = "github.com/prysmaticlabs/prysm/v5/api/server",
     visibility = ["//visibility:public"],
+    deps = [
+        "@com_github_gorilla_mux//:go_default_library",
+        "@com_github_rs_cors//:go_default_library",
+    ],
 )
 
 go_test(
     name = "go_default_test",
-    srcs = ["error_test.go"],
+    srcs = [
+        "error_test.go",
+        "middleware_test.go",
+        "util_test.go",
+    ],
     embed = [":go_default_library"],
-    deps = ["//testing/assert:go_default_library"],
+    deps = [
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+    ],
 )

api/server/middleware.go

@@ -0,0 +1,32 @@
+package server
+
+import (
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/rs/cors"
+)
+
+// NormalizeQueryValuesHandler normalizes an input query of "key=value1,value2,value3" to "key=value1&key=value2&key=value3"
+func NormalizeQueryValuesHandler(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		query := r.URL.Query()
+		NormalizeQueryValues(query)
+		r.URL.RawQuery = query.Encode()
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+// CorsHandler sets the cors settings on api endpoints
+func CorsHandler(allowOrigins []string) mux.MiddlewareFunc {
+	c := cors.New(cors.Options{
+		AllowedOrigins:   allowOrigins,
+		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodOptions},
+		AllowCredentials: true,
+		MaxAge:           600,
+		AllowedHeaders:   []string{"*"},
+	})
+
+	return c.Handler
+}

api/server/middleware/BUILD.bazel

@@ -1,29 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "middleware.go",
-        "util.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/v5/api/server/middleware",
-    visibility = ["//visibility:public"],
-    deps = [
-        "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_rs_cors//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "middleware_test.go",
-        "util_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//api:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-    ],
-)

api/server/middleware/middleware.go

@@ -1,112 +0,0 @@
-package middleware
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/gorilla/mux"
-	"github.com/rs/cors"
-)
-
-// NormalizeQueryValuesHandler normalizes an input query of "key=value1,value2,value3" to "key=value1&key=value2&key=value3"
-func NormalizeQueryValuesHandler(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		query := r.URL.Query()
-		NormalizeQueryValues(query)
-		r.URL.RawQuery = query.Encode()
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// CorsHandler sets the cors settings on api endpoints
-func CorsHandler(allowOrigins []string) mux.MiddlewareFunc {
-	c := cors.New(cors.Options{
-		AllowedOrigins:   allowOrigins,
-		AllowedMethods:   []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodOptions},
-		AllowCredentials: true,
-		MaxAge:           600,
-		AllowedHeaders:   []string{"*"},
-	})
-
-	return c.Handler
-}
-
-// ContentTypeHandler checks request for the appropriate media types otherwise returning a http.StatusUnsupportedMediaType error
-func ContentTypeHandler(acceptedMediaTypes []string) mux.MiddlewareFunc {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			// skip the GET request
-			if r.Method == http.MethodGet {
-				next.ServeHTTP(w, r)
-				return
-			}
-			contentType := r.Header.Get("Content-Type")
-			if contentType == "" {
-				http.Error(w, "Content-Type header is missing", http.StatusUnsupportedMediaType)
-				return
-			}
-
-			accepted := false
-			for _, acceptedType := range acceptedMediaTypes {
-				if strings.Contains(strings.TrimSpace(contentType), strings.TrimSpace(acceptedType)) {
-					accepted = true
-					break
-				}
-			}
-
-			if !accepted {
-				http.Error(w, fmt.Sprintf("Unsupported media type: %s", contentType), http.StatusUnsupportedMediaType)
-				return
-			}
-
-			next.ServeHTTP(w, r)
-		})
-	}
-}
-
-// AcceptHeaderHandler checks if the client's response preference is handled
-func AcceptHeaderHandler(serverAcceptedTypes []string) mux.MiddlewareFunc {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			acceptHeader := r.Header.Get("Accept")
-			// header is optional and should skip if not provided
-			if acceptHeader == "" {
-				next.ServeHTTP(w, r)
-				return
-			}
-
-			accepted := false
-			acceptTypes := strings.Split(acceptHeader, ",")
-			// follows rules defined in https://datatracker.ietf.org/doc/html/rfc2616#section-14.1
-			for _, acceptType := range acceptTypes {
-				acceptType = strings.TrimSpace(acceptType)
-				if acceptType == "*/*" {
-					accepted = true
-					break
-				}
-				for _, serverAcceptedType := range serverAcceptedTypes {
-					if strings.HasPrefix(acceptType, serverAcceptedType) {
-						accepted = true
-						break
-					}
-					if acceptType != "/*" && strings.HasSuffix(acceptType, "/*") && strings.HasPrefix(serverAcceptedType, acceptType[:len(acceptType)-2]) {
-						accepted = true
-						break
-					}
-				}
-				if accepted {
-					break
-				}
-			}
-
-			if !accepted {
-				http.Error(w, fmt.Sprintf("Not Acceptable: %s", acceptHeader), http.StatusNotAcceptable)
-				return
-			}
-
-			next.ServeHTTP(w, r)
-		})
-	}
-}

api/server/middleware/middleware_test.go

@@ -1,204 +0,0 @@
-package middleware
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/api"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-)
-
-func TestNormalizeQueryValuesHandler(t *testing.T) {
-	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, err := w.Write([]byte("next handler"))
-		require.NoError(t, err)
-	})
-
-	handler := NormalizeQueryValuesHandler(nextHandler)
-
-	tests := []struct {
-		name          string
-		inputQuery    string
-		expectedQuery string
-	}{
-		{
-			name:          "3 values",
-			inputQuery:    "key=value1,value2,value3",
-			expectedQuery: "key=value1&key=value2&key=value3", // replace with expected normalized value
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			req, err := http.NewRequest("GET", "/test?"+test.inputQuery, http.NoBody)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			rr := httptest.NewRecorder()
-			handler.ServeHTTP(rr, req)
-
-			if rr.Code != http.StatusOK {
-				t.Errorf("handler returned wrong status code: got %v want %v", rr.Code, http.StatusOK)
-			}
-
-			if req.URL.RawQuery != test.expectedQuery {
-				t.Errorf("query not normalized: got %v want %v", req.URL.RawQuery, test.expectedQuery)
-			}
-
-			if rr.Body.String() != "next handler" {
-				t.Errorf("next handler was not executed")
-			}
-		})
-	}
-}
-
-func TestContentTypeHandler(t *testing.T) {
-	acceptedMediaTypes := []string{api.JsonMediaType, api.OctetStreamMediaType}
-
-	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, err := w.Write([]byte("next handler"))
-		require.NoError(t, err)
-	})
-
-	handler := ContentTypeHandler(acceptedMediaTypes)(nextHandler)
-
-	tests := []struct {
-		name               string
-		contentType        string
-		expectedStatusCode int
-		isGet              bool
-	}{
-		{
-			name:               "Accepted Content-Type - application/json",
-			contentType:        api.JsonMediaType,
-			expectedStatusCode: http.StatusOK,
-		},
-		{
-			name:               "Accepted Content-Type - ssz format",
-			contentType:        api.OctetStreamMediaType,
-			expectedStatusCode: http.StatusOK,
-		},
-		{
-			name:               "Unsupported Content-Type - text/plain",
-			contentType:        "text/plain",
-			expectedStatusCode: http.StatusUnsupportedMediaType,
-		},
-		{
-			name:               "Missing Content-Type",
-			contentType:        "",
-			expectedStatusCode: http.StatusUnsupportedMediaType,
-		},
-		{
-			name:               "GET request skips content type check",
-			contentType:        "",
-			expectedStatusCode: http.StatusOK,
-			isGet:              true,
-		},
-		{
-			name:               "Content type contains charset is ok",
-			contentType:        "application/json; charset=utf-8",
-			expectedStatusCode: http.StatusOK,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			httpMethod := http.MethodPost
-			if tt.isGet {
-				httpMethod = http.MethodGet
-			}
-			req := httptest.NewRequest(httpMethod, "/", nil)
-			if tt.contentType != "" {
-				req.Header.Set("Content-Type", tt.contentType)
-			}
-			rr := httptest.NewRecorder()
-
-			handler.ServeHTTP(rr, req)
-
-			if status := rr.Code; status != tt.expectedStatusCode {
-				t.Errorf("handler returned wrong status code: got %v want %v", status, tt.expectedStatusCode)
-			}
-		})
-	}
-}
-
-func TestAcceptHeaderHandler(t *testing.T) {
-	acceptedTypes := []string{"application/json", "application/octet-stream"}
-
-	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, err := w.Write([]byte("next handler"))
-		require.NoError(t, err)
-	})
-
-	handler := AcceptHeaderHandler(acceptedTypes)(nextHandler)
-
-	tests := []struct {
-		name               string
-		acceptHeader       string
-		expectedStatusCode int
-	}{
-		{
-			name:               "Accepted Accept-Type - application/json",
-			acceptHeader:       "application/json",
-			expectedStatusCode: http.StatusOK,
-		},
-		{
-			name:               "Accepted Accept-Type - application/octet-stream",
-			acceptHeader:       "application/octet-stream",
-			expectedStatusCode: http.StatusOK,
-		},
-		{
-			name:               "Accepted Accept-Type with parameters",
-			acceptHeader:       "application/json;q=0.9, application/octet-stream;q=0.8",
-			expectedStatusCode: http.StatusOK,
-		},
-		{
-			name:               "Unsupported Accept-Type - text/plain",
-			acceptHeader:       "text/plain",
-			expectedStatusCode: http.StatusNotAcceptable,
-		},
-		{
-			name:               "Missing Accept header",
-			acceptHeader:       "",
-			expectedStatusCode: http.StatusOK,
-		},
-		{
-			name:               "*/* is accepted",
-			acceptHeader:       "*/*",
-			expectedStatusCode: http.StatusOK,
-		},
-		{
-			name:               "application/* is accepted",
-			acceptHeader:       "application/*",
-			expectedStatusCode: http.StatusOK,
-		},
-		{
-			name:               "/* is unsupported",
-			acceptHeader:       "/*",
-			expectedStatusCode: http.StatusNotAcceptable,
-		},
-		{
-			name:               "application/ is unsupported",
-			acceptHeader:       "application/",
-			expectedStatusCode: http.StatusNotAcceptable,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			req := httptest.NewRequest("GET", "/", nil)
-			if tt.acceptHeader != "" {
-				req.Header.Set("Accept", tt.acceptHeader)
-			}
-			rr := httptest.NewRecorder()
-
-			handler.ServeHTTP(rr, req)
-
-			if status := rr.Code; status != tt.expectedStatusCode {
-				t.Errorf("handler returned wrong status code: got %v want %v", status, tt.expectedStatusCode)
-			}
-		})
-	}
-}

api/server/middleware_test.go

@@ -0,0 +1,54 @@
+package server
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestNormalizeQueryValuesHandler(t *testing.T) {
+	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, err := w.Write([]byte("next handler"))
+		require.NoError(t, err)
+	})
+
+	handler := NormalizeQueryValuesHandler(nextHandler)
+
+	tests := []struct {
+		name          string
+		inputQuery    string
+		expectedQuery string
+	}{
+		{
+			name:          "3 values",
+			inputQuery:    "key=value1,value2,value3",
+			expectedQuery: "key=value1&key=value2&key=value3", // replace with expected normalized value
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			req, err := http.NewRequest("GET", "/test?"+test.inputQuery, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			rr := httptest.NewRecorder()
+			handler.ServeHTTP(rr, req)
+
+			if rr.Code != http.StatusOK {
+				t.Errorf("handler returned wrong status code: got %v want %v", rr.Code, http.StatusOK)
+			}
+
+			if req.URL.RawQuery != test.expectedQuery {
+				t.Errorf("query not normalized: got %v want %v", req.URL.RawQuery, test.expectedQuery)
+			}
+
+			if rr.Body.String() != "next handler" {
+				t.Errorf("next handler was not executed")
+			}
+		})
+	}
+}

api/server/util.go

@@ -1,4 +1,4 @@
-package middleware
+package server
 
 import (
 	"net/url"

api/server/util_test.go

@@ -1,4 +1,4 @@
-package middleware
+package server
 
 import (
 	"testing"

beacon-chain/blockchain/BUILD.bazel

@@ -64,7 +64,6 @@ 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",
@@ -139,7 +138,6 @@ 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",
@@ -183,7 +181,6 @@ 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/receive_block.go

@@ -13,7 +13,6 @@ 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"
@@ -170,8 +169,13 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 	// Send finalized events and finalized deposits in the background
 	if newFinalized {
-		// hook to process all post state finalization tasks
-		s.executePostFinalizationTasks(ctx, postState)
+		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()
+		}()
 	}
 
 	// If slasher is configured, forward the attestations in the block via an event feed for processing.
@@ -220,19 +224,6 @@ 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.
@@ -498,7 +489,7 @@ func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySigne
 			log.WithError(err).Error("Could not convert to indexed attestation")
 			return
 		}
-		s.cfg.SlasherAttestationsFeed.Send(&types.WrappedIndexedAtt{IndexedAtt: indexedAtt})
+		s.cfg.SlasherAttestationsFeed.Send(indexedAtt)
 	}
 }
 

beacon-chain/blockchain/receive_block_test.go

@@ -6,14 +6,11 @@ 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"
@@ -23,7 +20,6 @@ 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"
 )
 
@@ -419,81 +415,3 @@ 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/service.go

@@ -330,8 +330,6 @@ 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
 }
 

beacon-chain/blockchain/service_test.go

@@ -8,10 +8,9 @@ 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/altair"
+	"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/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
@@ -30,7 +29,6 @@ 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"
@@ -205,7 +203,7 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 		BlockHash:    make([]byte, 32),
 	})
 	require.NoError(t, err)
-	genState, err = altair.ProcessPreGenesisDeposits(ctx, genState, deposits)
+	genState, err = blocks.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)})
@@ -501,66 +499,6 @@ 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 {

beacon-chain/core/altair/BUILD.bazel

@@ -36,7 +36,6 @@ 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",

beacon-chain/core/altair/deposit.go

@@ -5,32 +5,11 @@ 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,
@@ -54,158 +33,23 @@ func ProcessDeposits(
 	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,
-//	 )
+// ProcessDeposit processes validator deposit for beacon state Altair.
 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 {
+	beaconState, isNewValidator, err := blocks.ProcessDeposit(beaconState, deposit, verifySignature)
+	if err != nil {
 		return nil, err
 	}
-
-	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
-		}
-	} 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 isNewValidator {
 		if err := beaconState.AppendInactivityScore(0); err != nil {
-			return err
+			return nil, err
 		}
 		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
-			return err
+			return nil, err
 		}
 		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
-			return err
+			return nil, 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,
-	}
+	return beaconState, nil
 }

beacon-chain/core/altair/deposit_fuzz_test.go

@@ -30,59 +30,6 @@ 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,14 +7,11 @@ 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"
 )
@@ -47,6 +44,36 @@ 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)
@@ -218,158 +245,3 @@ 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/blocks/attestation_benchmark_test.go

@@ -0,0 +1,254 @@
+package blocks
+
+import (
+	"bytes"
+	"encoding/binary"
+	"sync"
+	"testing"
+
+	"github.com/prysmaticlabs/go-bitfield"
+	lruwrpr "github.com/prysmaticlabs/prysm/v5/cache/lru"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/assert"
+)
+
+func makeAtts(b *testing.B) []*ethpb.Attestation {
+	attData := make([]*ethpb.AttestationData, 0, 400)
+	for i := 0; i < 400; i++ {
+		bRoot := bytesutil.Bytes32(20)
+		sRoot := bytesutil.Bytes32(1000)
+		tRoot := bytesutil.Bytes32(2000)
+		ad := &ethpb.AttestationData{
+			Slot:            3600,
+			CommitteeIndex:  primitives.CommitteeIndex(i),
+			BeaconBlockRoot: bRoot,
+			Source: &ethpb.Checkpoint{
+				Epoch: primitives.Epoch(1000),
+				Root:  sRoot,
+			},
+			Target: &ethpb.Checkpoint{
+				Epoch: primitives.Epoch(2000),
+				Root:  tRoot,
+			},
+		}
+		attData = append(attData, ad)
+	}
+	allAtts := make([]*ethpb.Attestation, 0)
+
+	for _, ad := range attData {
+		copiedD := ad
+		for i := 0; i < 30; i++ {
+			att := &ethpb.Attestation{
+				AggregationBits: bitfield.NewBitlist(3),
+				Data:            copiedD,
+				Signature:       make([]byte, 96),
+			}
+			allAtts = append(allAtts, att)
+		}
+	}
+	return allAtts
+}
+
+func BenchmarkAttestationDataRoot(b *testing.B) {
+	allAtts := makeAtts(b)
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for i := 0; i < b.N; i++ {
+		for _, a := range allAtts {
+			_, err := a.Data.HashTreeRoot()
+			assert.NoError(b, err)
+		}
+	}
+}
+
+var lc = lruwrpr.New(100)
+
+func getRoot(attData *ethpb.AttestationData) ([32]byte, error) {
+	var key [128]byte
+
+	binary.LittleEndian.PutUint64(key[:8], uint64(attData.Slot))
+	binary.LittleEndian.PutUint64(key[8:16], uint64(attData.CommitteeIndex))
+	copy(key[16:48], attData.BeaconBlockRoot)
+	binary.LittleEndian.PutUint64(key[48:56], uint64(attData.Target.Epoch))
+	copy(key[56:88], attData.Target.Root)
+	binary.LittleEndian.PutUint64(key[88:96], uint64(attData.Source.Epoch))
+	copy(key[96:128], attData.Source.Root)
+
+	rt, ok := lc.Get(key)
+	if ok {
+		return rt.([32]byte), nil
+	}
+	htr, err := attData.HashTreeRoot()
+	if err != nil {
+		return [32]byte{}, err
+	}
+	lc.Add(key, htr)
+	return htr, nil
+}
+
+func BenchmarkAttestationDataRootWithCache(b *testing.B) {
+	allAtts := makeAtts(b)
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for i := 0; i < b.N; i++ {
+		for _, a := range allAtts {
+			rt, err := getRoot(a.Data)
+			_ = rt
+			assert.NoError(b, err)
+		}
+	}
+}
+
+var rtMap = map[uint64]map[uint64]map[[32]byte]map[uint64]map[[32]byte]map[uint64]map[[32]byte][32]byte{}
+var sltMap = map[uint64][]*ethpb.AttestationData{}
+var attMap = map[*ethpb.AttestationData][32]byte{}
+
+var mt = new(sync.RWMutex)
+
+func getRootInMap(attData *ethpb.AttestationData) ([32]byte, error) {
+	mt.RLock()
+	mpA, ok := rtMap[uint64(attData.Slot)]
+	mt.RUnlock()
+	if !ok {
+		return recoverRtInMap(attData)
+	}
+	mt.RLock()
+	mpB, ok := mpA[uint64(attData.CommitteeIndex)]
+	mt.RUnlock()
+	if !ok {
+		return recoverRtInMap(attData)
+
+	}
+	mt.RLock()
+	mpC, ok := mpB[[32]byte(attData.BeaconBlockRoot)]
+	mt.RUnlock()
+	if !ok {
+		return recoverRtInMap(attData)
+
+	}
+	mt.RLock()
+	mpD, ok := mpC[uint64(attData.Target.Epoch)]
+	mt.RUnlock()
+	if !ok {
+		return recoverRtInMap(attData)
+
+	}
+	mt.RLock()
+	mpE, ok := mpD[[32]byte(attData.Target.Root)]
+	mt.RUnlock()
+	if !ok {
+		return recoverRtInMap(attData)
+
+	}
+	mt.RLock()
+	mpF, ok := mpE[uint64(attData.Target.Epoch)]
+	mt.RUnlock()
+	if !ok {
+		return recoverRtInMap(attData)
+	}
+	mt.RLock()
+	htr, ok := mpF[[32]byte(attData.Target.Root)]
+	mt.RUnlock()
+	if !ok {
+		return recoverRtInMap(attData)
+	}
+	return htr, nil
+}
+
+func recoverRtInMap(attData *ethpb.AttestationData) ([32]byte, error) {
+	htr, err := attData.HashTreeRoot()
+	if err != nil {
+		return [32]byte{}, err
+	}
+	mt.Lock()
+	rtMap[uint64(attData.Slot)] = map[uint64]map[[32]byte]map[uint64]map[[32]byte]map[uint64]map[[32]byte][32]byte{}
+	rtMap[uint64(attData.Slot)][uint64(attData.CommitteeIndex)] = map[[32]byte]map[uint64]map[[32]byte]map[uint64]map[[32]byte][32]byte{}
+	rtMap[uint64(attData.Slot)][uint64(attData.CommitteeIndex)][[32]byte(attData.BeaconBlockRoot)] = map[uint64]map[[32]byte]map[uint64]map[[32]byte][32]byte{}
+	rtMap[uint64(attData.Slot)][uint64(attData.CommitteeIndex)][[32]byte(attData.BeaconBlockRoot)][uint64(attData.Target.Epoch)] = map[[32]byte]map[uint64]map[[32]byte][32]byte{}
+	rtMap[uint64(attData.Slot)][uint64(attData.CommitteeIndex)][[32]byte(attData.BeaconBlockRoot)][uint64(attData.Target.Epoch)][[32]byte(attData.Target.Root)] = map[uint64]map[[32]byte][32]byte{}
+	rtMap[uint64(attData.Slot)][uint64(attData.CommitteeIndex)][[32]byte(attData.BeaconBlockRoot)][uint64(attData.Target.Epoch)][[32]byte(attData.Target.Root)][uint64(attData.Source.Epoch)] = map[[32]byte][32]byte{}
+	rtMap[uint64(attData.Slot)][uint64(attData.CommitteeIndex)][[32]byte(attData.BeaconBlockRoot)][uint64(attData.Target.Epoch)][[32]byte(attData.Target.Root)][uint64(attData.Source.Epoch)][[32]byte(attData.Source.Root)] = htr
+	mt.Unlock()
+	return htr, nil
+}
+
+func BenchmarkAttestationDataRootWithMap(b *testing.B) {
+	allAtts := makeAtts(b)
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for i := 0; i < b.N; i++ {
+		for _, a := range allAtts {
+			rt, err := getRootInMap(a.Data)
+			_ = rt
+			assert.NoError(b, err)
+		}
+	}
+}
+
+func recoverRtInMapNew(attData *ethpb.AttestationData) ([32]byte, error) {
+	htr, err := attData.HashTreeRoot()
+	if err != nil {
+		return [32]byte{}, err
+	}
+	mt.Lock()
+	sltMap[uint64(attData.Slot)] = append(sltMap[uint64(attData.Slot)], attData)
+	attMap[attData] = htr
+	mt.Unlock()
+	return htr, nil
+}
+
+func getRootInMapNew(attData *ethpb.AttestationData) ([32]byte, error) {
+	mt.RLock()
+	attList, ok := sltMap[uint64(attData.Slot)]
+	mt.RUnlock()
+	if !ok {
+		return recoverRtInMapNew(attData)
+	}
+	for _, a := range attList {
+		if attData.CommitteeIndex != a.CommitteeIndex {
+			continue
+		}
+		if !bytes.Equal(attData.BeaconBlockRoot, a.BeaconBlockRoot) {
+			continue
+		}
+		if attData.Target.Epoch != a.Target.Epoch {
+			continue
+		}
+		if !bytes.Equal(attData.Target.Root, a.Target.Root) {
+			continue
+		}
+		if attData.Source.Epoch != a.Source.Epoch {
+			continue
+		}
+		if !bytes.Equal(attData.Source.Root, a.Source.Root) {
+			continue
+		}
+		mt.RLock()
+		val, ok := attMap[a]
+		mt.RUnlock()
+		if !ok {
+			return recoverRtInMapNew(attData)
+		}
+		return val, nil
+	}
+	return recoverRtInMapNew(attData)
+}
+
+func BenchmarkAttestationDataRootWithMapNew(b *testing.B) {
+	allAtts := makeAtts(b)
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for i := 0; i < b.N; i++ {
+		for _, a := range allAtts {
+			rt, err := getRootInMapNew(a.Data)
+			_ = rt
+			assert.NoError(b, err)
+		}
+	}
+}

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -297,6 +297,60 @@ 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{}
@@ -306,7 +360,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,6 +5,7 @@ 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"
@@ -16,6 +17,24 @@ 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 {
@@ -47,6 +66,38 @@ 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
@@ -63,28 +114,102 @@ func BatchVerifyDepositsSignatures(ctx context.Context, deposits []*ethpb.Deposi
 	return verified, nil
 }
 
-// IsValidDepositSignature returns whether deposit_data is valid
-// def is_valid_deposit_signature(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> bool:
+// 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.
 //
-//	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
+// 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))
 	}
-	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
+	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
+		return nil, newValidator, err
 	}
-	return true, 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
 }
 
-// VerifyDeposit verifies the deposit data and signature given the beacon state and deposit information
-func VerifyDeposit(beaconState state.ReadOnlyBeaconState, deposit *ethpb.Deposit) error {
+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,42 +9,59 @@ 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 TestBatchVerifyDepositsSignatures_Ok(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),
+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]},
 		},
 	}
-	leaf, err := deposit.Data.HashTreeRoot()
+	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)
-	// 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")
+	newState, err := blocks.ProcessDeposits(context.Background(), beaconState, b.Block.Body.Deposits)
+	require.NoError(t, err, "Expected block deposits to process correctly")
 
-	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)
+	assert.Equal(t, 2, len(newState.Validators()), "Incorrect validator count")
 }
 
-func TestVerifyDeposit_MerkleBranchFailsVerification(t *testing.T) {
+func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
 	deposit := &ethpb.Deposit{
 		Data: &ethpb.Deposit_Data{
-			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
+			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, fieldparams.BLSPubkeyLength),
 			WithdrawalCredentials: make([]byte, 32),
-			Signature:             make([]byte, 96),
+			Signature:             make([]byte, fieldparams.BLSSignatureLength),
 		},
 	}
 	leaf, err := deposit.Data.HashTreeRoot()
@@ -57,7 +74,13 @@ func TestVerifyDeposit_MerkleBranchFailsVerification(t *testing.T) {
 	require.NoError(t, err, "Could not generate proof")
 
 	deposit.Proof = proof
-	beaconState, err := state_native.InitializeFromProtoAltair(&ethpb.BeaconStateAltair{
+	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},
@@ -65,31 +88,312 @@ func TestVerifyDeposit_MerkleBranchFailsVerification(t *testing.T) {
 	})
 	require.NoError(t, err)
 	want := "deposit root did not verify"
-	err = blocks.VerifyDeposit(beaconState, deposit)
-	require.ErrorContains(t, want, err)
+	_, err = blocks.ProcessDeposits(context.Background(), beaconState, b.Block.Body.Deposits)
+	assert.ErrorContains(t, want, err)
 }
 
-func TestIsValidDepositSignature_Ok(t *testing.T) {
+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) {
 	sk, err := bls.RandKey()
 	require.NoError(t, err)
-	depositData := &ethpb.Deposit_Data{
-		PublicKey:             sk.PublicKey().Marshal(),
-		Amount:                0,
-		WithdrawalCredentials: make([]byte, 32),
-		Signature:             make([]byte, fieldparams.BLSSignatureLength),
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey:             sk.PublicKey().Marshal(),
+			Amount:                1000,
+			WithdrawalCredentials: make([]byte, 32),
+			Signature:             make([]byte, fieldparams.BLSSignatureLength),
+		},
 	}
-	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)
+	sr, err := signing.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 32))
 	require.NoError(t, err)
 	sig := sk.Sign(sr[:])
-	depositData.Signature = sig.Marshal()
-	valid, err := blocks.IsValidDepositSignature(depositData)
+	deposit.Data.Signature = sig.Marshal()
+	leaf, err := deposit.Data.HashTreeRoot()
 	require.NoError(t, err)
-	require.Equal(t, true, valid)
+
+	// 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")
 }

beacon-chain/core/electra/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "attestation.go",
         "churn.go",
         "consolidations.go",
         "deposits.go",
@@ -21,12 +20,14 @@ go_library(
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/engine/v1:go_default_library",
@@ -53,14 +54,19 @@ go_test(
     deps = [
         ":go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//crypto/bls/blst:go_default_library",
+        "//crypto/bls/common:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/interop:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

beacon-chain/core/electra/attestation.go

@@ -1,7 +0,0 @@
-package electra
-
-import "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-
-var (
-	ProcessAttestationsNoVerifySignature = altair.ProcessAttestationsNoVerifySignature
-)

beacon-chain/core/electra/consolidations.go

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

beacon-chain/core/electra/consolidations_test.go

@@ -5,11 +5,19 @@ 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"
 	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) {
@@ -229,3 +237,205 @@ 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
+
+	tests := []struct {
+		name    string
+		state   state.BeaconState
+		scs     []*eth.SignedConsolidation
+		check   func(*testing.T, state.BeaconState)
+		wantErr string
+	}{
+		{
+			name:    "nil state",
+			scs:     make([]*eth.SignedConsolidation, 10),
+			wantErr: "nil state",
+		},
+		{
+			name:    "nil consolidation in slice",
+			state:   stateWithActiveBalanceETH(t, 19_000_000),
+			scs:     []*eth.SignedConsolidation{nil, nil},
+			wantErr: "nil consolidation",
+		},
+		{
+			name: "state is 100% full of pending consolidations",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				pc := make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit)
+				require.NoError(t, st.SetPendingConsolidations(pc))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{}}},
+			wantErr: "pending consolidations queue is full",
+		},
+		{
+			name: "state has too little consolidation churn limit available to process a consolidation",
+			state: func() state.BeaconState {
+				st, _ := util.DeterministicGenesisStateElectra(t, 1)
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{}}},
+			wantErr: "too little available consolidation churn limit",
+		},
+		{
+			name:    "consolidation with source and target as the same index is rejected",
+			state:   stateWithActiveBalanceETH(t, 19_000_000),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 100}}},
+			wantErr: "source and target index are the same",
+		},
+		{
+			name: "consolidation with inactive source is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 25, TargetIndex: 100}}},
+			wantErr: "source is not active",
+		},
+		{
+			name: "consolidation with inactive target is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25}}},
+			wantErr: "target is not active",
+		},
+		{
+			name: "consolidation with exiting source is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.ExitEpoch = 256
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 25, TargetIndex: 100}}},
+			wantErr: "source exit epoch has been initiated",
+		},
+		{
+			name: "consolidation with exiting target is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.ExitEpoch = 256
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25}}},
+			wantErr: "target exit epoch has been initiated",
+		},
+		{
+			name:    "consolidation with future epoch is rejected",
+			state:   stateWithActiveBalanceETH(t, 19_000_000),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25, Epoch: 55}}},
+			wantErr: "consolidation is not valid yet",
+		},
+		{
+			name: "source validator without withdrawal credentials is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.WithdrawalCredentials = []byte{}
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 25, TargetIndex: 100}}},
+			wantErr: "source does not have execution withdrawal credentials",
+		},
+		{
+			name: "target validator without withdrawal credentials is rejected",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				val, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				val.WithdrawalCredentials = []byte{}
+				require.NoError(t, st.UpdateValidatorAtIndex(25, val))
+				return st
+			}(),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25}}},
+			wantErr: "target does not have execution withdrawal credentials",
+		},
+		{
+			name:    "source and target with different withdrawal credentials is rejected",
+			state:   stateWithActiveBalanceETH(t, 19_000_000),
+			scs:     []*eth.SignedConsolidation{{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25}}},
+			wantErr: "source and target have different withdrawal credentials",
+		},
+		{
+			name: "consolidation with valid signatures is OK",
+			state: func() state.BeaconState {
+				st := stateWithActiveBalanceETH(t, 19_000_000)
+				require.NoError(t, st.SetGenesisValidatorsRoot(genesisValidatorRoot))
+				source, err := st.ValidatorAtIndex(100)
+				require.NoError(t, err)
+				target, err := st.ValidatorAtIndex(25)
+				require.NoError(t, err)
+				source.PublicKey = publicKeys[0].Marshal()
+				source.WithdrawalCredentials = target.WithdrawalCredentials
+				require.NoError(t, st.UpdateValidatorAtIndex(100, source))
+				target.PublicKey = publicKeys[1].Marshal()
+				require.NoError(t, st.UpdateValidatorAtIndex(25, target))
+				return st
+			}(),
+			scs: func() []*eth.SignedConsolidation {
+				sc := &eth.SignedConsolidation{Message: &eth.Consolidation{SourceIndex: 100, TargetIndex: 25, Epoch: 8}}
+
+				domain, err := signing.ComputeDomain(
+					params.BeaconConfig().DomainConsolidation,
+					nil,
+					genesisValidatorRoot,
+				)
+				require.NoError(t, err)
+				sr, err := signing.ComputeSigningRoot(sc.Message, domain)
+				require.NoError(t, err)
+
+				sig0 := secretKeys[0].Sign(sr[:])
+				sig1 := secretKeys[1].Sign(sr[:])
+
+				sc.Signature = blst.AggregateSignatures([]common.Signature{sig0, sig1}).Marshal()
+
+				return []*eth.SignedConsolidation{sc}
+			}(),
+			check: func(t *testing.T, st state.BeaconState) {
+				source, err := st.ValidatorAtIndex(100)
+				require.NoError(t, err)
+				// The consolidated validator is exiting.
+				require.Equal(t, primitives.Epoch(15), source.ExitEpoch) // 15 = state.Epoch(10) + MIN_SEED_LOOKAHEAD(4) + 1
+				require.Equal(t, primitives.Epoch(15+params.BeaconConfig().MinValidatorWithdrawabilityDelay), source.WithdrawableEpoch)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := electra.ProcessConsolidations(context.TODO(), tt.state, tt.scs)
+			if len(tt.wantErr) > 0 {
+				require.ErrorContains(t, tt.wantErr, err)
+			} else {
+				require.NoError(t, err)
+			}
+			if tt.check != nil {
+				tt.check(t, tt.state)
+			}
+		})
+	}
+}

beacon-chain/core/electra/deposits.go

@@ -77,11 +77,11 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 	}
 }
 
-// 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")
+// ProcessDepositReceipts is a function as part of electra to process execution layer deposits
+func ProcessDepositReceipts(ctx context.Context, beaconState state.BeaconState, receipts []*enginev1.DepositReceipt) (state.BeaconState, error) {
+	_, span := trace.StartSpan(ctx, "electra.ProcessDepositReceipts")
 	defer span.End()
 	// TODO: replace with 6110 logic
-	// return b.ProcessDepositRequests(beaconState, requests)
+	// return b.ProcessDepositReceipts(beaconState, receipts)
 	return beaconState, nil
 }

beacon-chain/core/electra/upgrade.go

@@ -38,7 +38,7 @@ import (
 //	    withdrawals_root=pre.latest_execution_payload_header.withdrawals_root,
 //	    blob_gas_used=pre.latest_execution_payload_header.blob_gas_used,
 //	    excess_blob_gas=pre.latest_execution_payload_header.excess_blob_gas,
-//	    deposit_requests_root=Root(),  # [New in Electra:EIP6110]
+//	    deposit_receipts_root=Root(),  # [New in Electra:EIP6110]
 //	    withdrawal_requests_root=Root(),  # [New in Electra:EIP7002],
 //	)
 //
@@ -94,7 +94,7 @@ import (
 //	    # Deep history valid from Capella onwards
 //	    historical_summaries=pre.historical_summaries,
 //	    # [New in Electra:EIP6110]
-//	    deposit_requests_start_index=UNSET_DEPOSIT_REQUESTS_START_INDEX,
+//	    deposit_receipts_start_index=UNSET_DEPOSIT_RECEIPTS_START_INDEX,
 //	    # [New in Electra:EIP7251]
 //	    deposit_balance_to_consume=0,
 //	    exit_balance_to_consume=0,
@@ -244,32 +244,31 @@ 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]
-			ConsolidationRequestsRoot: bytesutil.Bytes32(0), // [New in Electra:EIP7251]
+			ParentHash:             payloadHeader.ParentHash(),
+			FeeRecipient:           payloadHeader.FeeRecipient(),
+			StateRoot:              payloadHeader.StateRoot(),
+			ReceiptsRoot:           payloadHeader.ReceiptsRoot(),
+			LogsBloom:              payloadHeader.LogsBloom(),
+			PrevRandao:             payloadHeader.PrevRandao(),
+			BlockNumber:            payloadHeader.BlockNumber(),
+			GasLimit:               payloadHeader.GasLimit(),
+			GasUsed:                payloadHeader.GasUsed(),
+			Timestamp:              payloadHeader.Timestamp(),
+			ExtraData:              payloadHeader.ExtraData(),
+			BaseFeePerGas:          payloadHeader.BaseFeePerGas(),
+			BlockHash:              payloadHeader.BlockHash(),
+			TransactionsRoot:       txRoot,
+			WithdrawalsRoot:        wdRoot,
+			ExcessBlobGas:          excessBlobGas,
+			BlobGasUsed:            blobGasUsed,
+			DepositReceiptsRoot:    bytesutil.Bytes32(0), // [New in Electra:EIP6110]
+			WithdrawalRequestsRoot: bytesutil.Bytes32(0), // [New in Electra:EIP7002]
 		},
 		NextWithdrawalIndex:          wi,
 		NextWithdrawalValidatorIndex: vi,
 		HistoricalSummaries:          summaries,
 
-		DepositRequestsStartIndex:     params.BeaconConfig().UnsetDepositRequestsStartIndex,
+		DepositReceiptsStartIndex:     params.BeaconConfig().UnsetDepositReceiptsStartIndex,
 		DepositBalanceToConsume:       0,
 		ExitBalanceToConsume:          helpers.ActivationExitChurnLimit(primitives.Gwei(tab)),
 		EarliestExitEpoch:             earliestExitEpoch,
@@ -296,14 +295,14 @@ func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 	}
 
 	for _, index := range preActivationIndices {
-		if err := QueueEntireBalanceAndResetValidator(post, index); err != nil {
+		if err := helpers.QueueEntireBalanceAndResetValidator(post, index); err != nil {
 			return nil, errors.Wrap(err, "failed to queue entire balance and reset validator")
 		}
 	}
 
 	// Ensure early adopters of compounding credentials go through the activation churn
 	for _, index := range compoundWithdrawalIndices {
-		if err := QueueExcessActiveBalance(post, index); err != nil {
+		if err := helpers.QueueExcessActiveBalance(post, index); err != nil {
 			return nil, errors.Wrap(err, "failed to queue excess active balance")
 		}
 	}

beacon-chain/core/electra/upgrade_test.go

@@ -113,24 +113,23 @@ 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),
-		ConsolidationRequestsRoot: 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,
+		DepositReceiptsRoot:    bytesutil.Bytes32(0),
+		WithdrawalRequestsRoot: bytesutil.Bytes32(0),
 	}
 	require.DeepEqual(t, wanted, protoHeader)
 
@@ -146,9 +145,9 @@ func TestUpgradeToElectra(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, 0, len(summaries))
 
-	startIndex, err := mSt.DepositRequestsStartIndex()
+	startIndex, err := mSt.DepositReceiptsStartIndex()
 	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().UnsetDepositRequestsStartIndex, startIndex)
+	require.Equal(t, params.BeaconConfig().UnsetDepositReceiptsStartIndex, startIndex)
 
 	balance, err := mSt.DepositBalanceToConsume()
 	require.NoError(t, err)

beacon-chain/core/electra/validator.go

@@ -1,6 +1,7 @@
 package electra
 
 import (
+	"context"
 	"errors"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
@@ -18,7 +19,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(s state.BeaconState, idx primitives.ValidatorIndex) error {
+func SwitchToCompoundingValidator(ctx context.Context, s state.BeaconState, idx primitives.ValidatorIndex) error {
 	v, err := s.ValidatorAtIndex(idx)
 	if err != nil {
 		return err
@@ -31,12 +32,12 @@ func SwitchToCompoundingValidator(s state.BeaconState, idx primitives.ValidatorI
 		if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
 			return err
 		}
-		return QueueExcessActiveBalance(s, idx)
+		return queueExcessActiveBalance(ctx, s, idx)
 	}
 	return nil
 }
 
-// QueueExcessActiveBalance
+// queueExcessActiveBalance
 //
 // Spec definition:
 //
@@ -48,7 +49,7 @@ func SwitchToCompoundingValidator(s state.BeaconState, idx primitives.ValidatorI
 //	        state.pending_balance_deposits.append(
 //	            PendingBalanceDeposit(index=index, amount=excess_balance)
 //	        )
-func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex) error {
+func queueExcessActiveBalance(ctx context.Context, s state.BeaconState, idx primitives.ValidatorIndex) error {
 	bal, err := s.BalanceAtIndex(idx)
 	if err != nil {
 		return err
@@ -79,7 +80,7 @@ func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex
 //	    )
 //
 //nolint:dupword
-func QueueEntireBalanceAndResetValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
+func QueueEntireBalanceAndResetValidator(ctx context.Context, 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,6 +2,7 @@ package electra_test
 
 import (
 	"bytes"
+	"context"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
@@ -10,7 +11,6 @@ import (
 	"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 TestSwitchToCompoundingValidator(t *testing.T) {
@@ -34,10 +34,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(s, 0))
+	require.ErrorContains(t, "validator has no withdrawal credentials", electra.SwitchToCompoundingValidator(context.TODO(), s, 0))
 
 	// Test that a validator with withdrawal credentials can be switched to compounding.
-	require.NoError(t, electra.SwitchToCompoundingValidator(s, 1))
+	require.NoError(t, electra.SwitchToCompoundingValidator(context.TODO(), s, 1))
 	v, err := s.ValidatorAtIndex(1)
 	require.NoError(t, err)
 	require.Equal(t, true, bytes.HasPrefix(v.WithdrawalCredentials, []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte}), "withdrawal credentials were not updated")
@@ -50,7 +50,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(s, 2))
+	require.NoError(t, electra.SwitchToCompoundingValidator(context.TODO(), s, 2))
 	b, err = s.BalanceAtIndex(2)
 	require.NoError(t, err)
 	require.Equal(t, params.BeaconConfig().MinActivationBalance, b, "balance was not changed")
@@ -74,7 +74,7 @@ func TestQueueEntireBalanceAndResetValidator(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	require.NoError(t, electra.QueueEntireBalanceAndResetValidator(s, 0))
+	require.NoError(t, electra.QueueEntireBalanceAndResetValidator(context.TODO(), s, 0))
 	b, err := s.BalanceAtIndex(0)
 	require.NoError(t, err)
 	require.Equal(t, uint64(0), b, "balance was not changed")
@@ -88,57 +88,3 @@ 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

@@ -19,15 +19,15 @@ import (
 	"go.opencensus.io/trace"
 )
 
-// ProcessWithdrawalRequests processes the validator withdrawals from the provided execution payload
+// ProcessExecutionLayerWithdrawalRequests processes the validator withdrawals from the provided execution payload
 // into the beacon state triggered by the execution layer.
 //
 // Spec pseudocode definition:
 //
-// def process_withdrawal_request(
+// def process_execution_layer_withdrawal_request(
 //
 //		state: BeaconState,
-//		withdrawal_request: WithdrawalRequest
+//		execution_layer_withdrawal_request: ExecutionLayerWithdrawalRequest
 //
 //	 ) -> None:
 //	   amount = execution_layer_withdrawal_request.amount
@@ -86,8 +86,8 @@ import (
 //	   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")
+func ProcessExecutionLayerWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.ExecutionLayerWithdrawalRequest) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "electra.ProcessExecutionLayerWithdrawalRequests")
 	defer span.End()
 	currentEpoch := slots.ToEpoch(st.Slot())
 	for _, wr := range wrs {

beacon-chain/core/electra/withdrawals_test.go

@@ -19,7 +19,7 @@ import (
 	"github.com/sirupsen/logrus/hooks/test"
 )
 
-func TestProcessWithdrawRequests(t *testing.T) {
+func TestProcessExecutionLayerWithdrawRequests(t *testing.T) {
 	logHook := test.NewGlobal()
 	source, err := hexutil.Decode("0xb20a608c624Ca5003905aA834De7156C68b2E1d0")
 	require.NoError(t, err)
@@ -30,7 +30,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 	require.NoError(t, err)
 	type args struct {
 		st  state.BeaconState
-		wrs []*enginev1.WithdrawalRequest
+		wrs []*enginev1.ExecutionLayerWithdrawalRequest
 	}
 	tests := []struct {
 		name    string
@@ -56,7 +56,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					require.NoError(t, preSt.SetValidators([]*eth.Validator{v}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -121,7 +121,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -190,7 +190,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					require.NoError(t, preSt.SetValidators([]*eth.Validator{v}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -227,7 +227,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					require.NoError(t, preSt.SetValidators([]*eth.Validator{v}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -266,7 +266,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -284,9 +284,9 @@ func TestProcessWithdrawRequests(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 
-			got, err := electra.ProcessWithdrawalRequests(context.Background(), tt.args.st, tt.args.wrs)
+			got, err := electra.ProcessExecutionLayerWithdrawalRequests(context.Background(), tt.args.st, tt.args.wrs)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("ProcessExecutionLayerWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			tt.wantFn(t, got)

beacon-chain/core/epoch/BUILD.bazel

@@ -2,10 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "epoch_processing.go",
-        "sortable_indices.go",
-    ],
+    srcs = ["epoch_processing.go"],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch",
     visibility = [
         "//beacon-chain:__subpackages__",
@@ -34,7 +31,6 @@ go_test(
     srcs = [
         "epoch_processing_fuzz_test.go",
         "epoch_processing_test.go",
-        "sortable_indices_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
@@ -51,7 +47,6 @@ 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,6 +24,27 @@ 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
@@ -70,78 +91,55 @@ 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, st state.BeaconState) (state.BeaconState, error) {
-	currentEpoch := time.CurrentEpoch(st)
+func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
+	currentEpoch := time.CurrentEpoch(state)
+	vals := state.Validators()
 	var err error
 	ejectionBal := params.BeaconConfig().EjectionBalance
-
-	// 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))
+	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
+			}
 		}
 
-		// Collect validators to eject.
-		isActive := helpers.IsActiveValidatorUsingTrie(val, currentEpoch)
-		belowEjectionBalance := val.EffectiveBalance() <= ejectionBal
+		// Process the validators for ejection.
+		isActive := helpers.IsActiveValidator(validator, currentEpoch)
+		belowEjectionBalance := validator.EffectiveBalance <= ejectionBal
 		if isActive && belowEjectionBalance {
-			eligibleForEjection = append(eligibleForEjection, primitives.ValidatorIndex(idx))
-		}
-
-		// Collect validators eligible for activation and not yet dequeued for activation.
-		if helpers.IsEligibleForActivationUsingTrie(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)
+			// 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)
+			}
 		}
 	}
 
 	// Queue validators eligible for activation and not yet dequeued for activation.
-	sort.Sort(sortableIndices{indices: eligibleForActivation, state: st})
+	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})
 
 	// Only activate just enough validators according to the activation churn limit.
-	limit := uint64(len(eligibleForActivation))
-	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, st, currentEpoch)
+	limit := uint64(len(activationQ))
+	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, state, currentEpoch)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get active validator count")
 	}
 
 	churnLimit := helpers.ValidatorActivationChurnLimit(activeValidatorCount)
 
-	if st.Version() >= version.Deneb {
+	if state.Version() >= version.Deneb {
 		churnLimit = helpers.ValidatorActivationChurnLimitDeneb(activeValidatorCount)
 	}
 
@@ -151,17 +149,17 @@ func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) (state.Be
 	}
 
 	activationExitEpoch := helpers.ActivationExitEpoch(currentEpoch)
-	for _, index := range eligibleForActivation[:limit] {
-		validator, err := st.ValidatorAtIndex(index)
+	for _, index := range activationQ[:limit] {
+		validator, err := state.ValidatorAtIndex(index)
 		if err != nil {
 			return nil, err
 		}
 		validator.ActivationEpoch = activationExitEpoch
-		if err := st.UpdateValidatorAtIndex(index, validator); err != nil {
+		if err := state.UpdateValidatorAtIndex(index, validator); err != nil {
 			return nil, err
 		}
 	}
-	return st, nil
+	return state, nil
 }
 
 // ProcessSlashings processes the slashed validators during epoch processing,

beacon-chain/core/epoch/epoch_processing_test.go

@@ -307,15 +307,14 @@ 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: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 6, 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: finalizedEpoch,
+			ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
 			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
 			ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
 		})
@@ -326,6 +325,7 @@ 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,10 +338,9 @@ 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: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
+		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 6, Root: make([]byte, fieldparams.RootLength)},
 	}
 	cfg := params.BeaconConfig()
 	cfg.MinPerEpochChurnLimit = 10
@@ -350,7 +349,7 @@ func TestProcessRegistryUpdates_EligibleToActivate_Cancun(t *testing.T) {
 
 	for i := uint64(0); i < 10; i++ {
 		base.Validators = append(base.Validators, &ethpb.Validator{
-			ActivationEligibilityEpoch: finalizedEpoch,
+			ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
 			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
 			ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
 		})
@@ -361,6 +360,7 @@ 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

@@ -1,35 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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/helpers/BUILD.bazel

@@ -79,7 +79,6 @@ 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/attestation.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
@@ -92,14 +91,6 @@ func IsAggregated(attestation ethpb.Att) bool {
 //
 //	return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
 func ComputeSubnetForAttestation(activeValCount uint64, att ethpb.Att) uint64 {
-	if att.Version() >= version.Electra {
-		committeeIndex := 0
-		committeeIndices := att.CommitteeBitsVal().BitIndices()
-		if len(committeeIndices) > 0 {
-			committeeIndex = committeeIndices[0]
-		}
-		return ComputeSubnetFromCommitteeAndSlot(activeValCount, primitives.CommitteeIndex(committeeIndex), att.GetData().Slot)
-	}
 	return ComputeSubnetFromCommitteeAndSlot(activeValCount, att.GetData().CommitteeIndex, att.GetData().Slot)
 }
 

beacon-chain/core/helpers/attestation_test.go

@@ -73,37 +73,21 @@ func TestAttestation_ComputeSubnetForAttestation(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	valCount, err := helpers.ActiveValidatorCount(context.Background(), state, slots.ToEpoch(34))
+	att := &ethpb.Attestation{
+		AggregationBits: []byte{'A'},
+		Data: &ethpb.AttestationData{
+			Slot:            34,
+			CommitteeIndex:  4,
+			BeaconBlockRoot: []byte{'C'},
+			Source:          nil,
+			Target:          nil,
+		},
+		Signature: []byte{'B'},
+	}
+	valCount, err := helpers.ActiveValidatorCount(context.Background(), state, slots.ToEpoch(att.Data.Slot))
 	require.NoError(t, err)
-
-	t.Run("Phase 0", func(t *testing.T) {
-		att := &ethpb.Attestation{
-			AggregationBits: []byte{'A'},
-			Data: &ethpb.AttestationData{
-				Slot:            34,
-				CommitteeIndex:  4,
-				BeaconBlockRoot: []byte{'C'},
-			},
-			Signature: []byte{'B'},
-		}
-		sub := helpers.ComputeSubnetForAttestation(valCount, att)
-		assert.Equal(t, uint64(6), sub, "Did not get correct subnet for attestation")
-	})
-	t.Run("Electra", func(t *testing.T) {
-		cb := primitives.NewAttestationCommitteeBits()
-		cb.SetBitAt(4, true)
-		att := &ethpb.AttestationElectra{
-			AggregationBits: []byte{'A'},
-			CommitteeBits:   cb,
-			Data: &ethpb.AttestationData{
-				Slot:            34,
-				BeaconBlockRoot: []byte{'C'},
-			},
-			Signature: []byte{'B'},
-		}
-		sub := helpers.ComputeSubnetForAttestation(valCount, att)
-		assert.Equal(t, uint64(6), sub, "Did not get correct subnet for attestation")
-	})
+	sub := helpers.ComputeSubnetForAttestation(valCount, att)
+	assert.Equal(t, uint64(6), sub, "Did not get correct subnet for attestation")
 }
 
 func Test_ValidateAttestationTime(t *testing.T) {

beacon-chain/core/helpers/validators.go

@@ -17,7 +17,6 @@ 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"
@@ -358,11 +357,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
-//	      # [Modified in Electra:EIP7251]
-//	      if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_byte:
+//	      if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte:
 //	          return candidate_index
 //	      i += 1
-func ComputeProposerIndex(bState state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex, seed [32]byte) (primitives.ValidatorIndex, error) {
+func ComputeProposerIndex(bState state.ReadOnlyValidators, activeIndices []primitives.ValidatorIndex, seed [32]byte) (primitives.ValidatorIndex, error) {
 	length := uint64(len(activeIndices))
 	if length == 0 {
 		return 0, errors.New("empty active indices list")
@@ -387,12 +385,7 @@ func ComputeProposerIndex(bState state.ReadOnlyBeaconState, activeIndices []prim
 		}
 		effectiveBal := v.EffectiveBalance()
 
-		maxEB := params.BeaconConfig().MaxEffectiveBalanceElectra
-		if bState.Version() < version.Electra {
-			maxEB = params.BeaconConfig().MaxEffectiveBalance
-		}
-
-		if effectiveBal*maxRandomByte >= maxEB*uint64(randomByte) {
+		if effectiveBal*maxRandomByte >= params.BeaconConfig().MaxEffectiveBalance*uint64(randomByte) {
 			return candidateIndex, nil
 		}
 	}
@@ -411,11 +404,11 @@ func ComputeProposerIndex(bState state.ReadOnlyBeaconState, activeIndices []prim
 //	        validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH
 //	        and validator.effective_balance >= MIN_ACTIVATION_BALANCE  # [Modified in Electra:EIP7251]
 //	    )
-func IsEligibleForActivationQueue(validator state.ReadOnlyValidator, currentEpoch primitives.Epoch) bool {
+func IsEligibleForActivationQueue(validator *ethpb.Validator, 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
@@ -681,3 +674,68 @@ func ValidatorMaxEffectiveBalance(val *ethpb.Validator) uint64 {
 	}
 	return params.BeaconConfig().MinActivationBalance
 }
+
+// QueueExcessActiveBalance queues validators with balances above the min activation balance and adds to pending balance deposit.
+//
+// Spec definition:
+//
+//	def queue_excess_active_balance(state: BeaconState, index: ValidatorIndex) -> None:
+//	    balance = state.balances[index]
+//	    if balance > MIN_ACTIVATION_BALANCE:
+//	        excess_balance = balance - MIN_ACTIVATION_BALANCE
+//	        state.balances[index] = MIN_ACTIVATION_BALANCE
+//	        state.pending_balance_deposits.append(
+//	            PendingBalanceDeposit(index=index, amount=excess_balance)
+//	        )
+func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex) error {
+	bal, err := s.BalanceAtIndex(idx)
+	if err != nil {
+		return err
+	}
+
+	if bal > params.BeaconConfig().MinActivationBalance {
+		excessBalance := bal - params.BeaconConfig().MinActivationBalance
+		if err := s.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
+			return err
+		}
+		return s.AppendPendingBalanceDeposit(idx, excessBalance)
+	}
+	return nil
+}
+
+// QueueEntireBalanceAndResetValidator queues the entire balance and resets the validator. This is used in electra fork logic.
+//
+// Spec definition:
+//
+//	def queue_entire_balance_and_reset_validator(state: BeaconState, index: ValidatorIndex) -> None:
+//	    balance = state.balances[index]
+//	    validator = state.validators[index]
+//		state.balances[index] = 0
+//	    validator.effective_balance = 0
+//	    validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
+//	    state.pending_balance_deposits.append(
+//	        PendingBalanceDeposit(index=index, amount=balance)
+//	    )
+func QueueEntireBalanceAndResetValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
+	bal, err := s.BalanceAtIndex(idx)
+	if err != nil {
+		return err
+	}
+
+	if err := s.UpdateBalancesAtIndex(idx, 0); err != nil {
+		return err
+	}
+
+	v, err := s.ValidatorAtIndex(idx)
+	if err != nil {
+		return err
+	}
+
+	v.EffectiveBalance = 0
+	v.ActivationEligibilityEpoch = params.BeaconConfig().FarFutureEpoch
+	if err := s.UpdateValidatorAtIndex(idx, v); err != nil {
+		return err
+	}
+
+	return s.AppendPendingBalanceDeposit(idx, bal)
+}

beacon-chain/core/helpers/validators_test.go

@@ -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) {
@@ -596,7 +596,6 @@ func TestComputeProposerIndex(t *testing.T) {
 		validators []*ethpb.Validator
 		indices    []primitives.ValidatorIndex
 		seed       [32]byte
-		minVersion int
 	}
 	tests := []struct {
 		name      string
@@ -684,81 +683,21 @@ func TestComputeProposerIndex(t *testing.T) {
 			},
 			want: 7,
 		},
-		{
-			name: "all_active_indices_above_min_activation_balance",
-			args: args{
-				validators: []*ethpb.Validator{
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-				},
-				indices:    []primitives.ValidatorIndex{0, 1, 2, 3, 4},
-				seed:       seed,
-				minVersion: version.Electra,
-			},
-			want: 2,
-		},
-		{
-			name: "second_half_active_above_min_activation_balance",
-			args: args{
-				validators: []*ethpb.Validator{
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-				},
-				indices:    []primitives.ValidatorIndex{5, 6, 7, 8, 9},
-				seed:       seed,
-				minVersion: version.Electra,
-			},
-			want: 7,
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			t.Run("phase0", func(t *testing.T) {
-				if tt.args.minVersion > version.Phase0 {
-					t.Skip("scenario does not apply to phase0")
-				}
-				helpers.ClearCache()
-				bState := &ethpb.BeaconState{Validators: tt.args.validators}
-				stTrie, err := state_native.InitializeFromProtoUnsafePhase0(bState)
-				require.NoError(t, err)
-				got, err := helpers.ComputeProposerIndex(stTrie, tt.args.indices, tt.args.seed)
-				if tt.wantedErr != "" {
-					assert.ErrorContains(t, tt.wantedErr, err)
-					return
-				}
-				assert.NoError(t, err, "received unexpected error")
-				assert.Equal(t, tt.want, got, "ComputeProposerIndex()")
-			})
-			t.Run("electra", func(t *testing.T) {
-				if tt.args.minVersion > version.Electra {
-					t.Skip("scenario does not apply to electra")
-				}
-				helpers.ClearCache()
-				bState := &ethpb.BeaconStateElectra{Validators: tt.args.validators}
-				stTrie, err := state_native.InitializeFromProtoUnsafeElectra(bState)
-				require.NoError(t, err)
+			helpers.ClearCache()
 
-				require.Equal(t, stTrie.Version(), version.Electra)
-
-				got, err := helpers.ComputeProposerIndex(stTrie, tt.args.indices, tt.args.seed)
-				if tt.wantedErr != "" {
-					assert.ErrorContains(t, tt.wantedErr, err)
-					return
-				}
-				assert.NoError(t, err, "received unexpected error")
-				assert.Equal(t, tt.want, got, "ComputeProposerIndex()")
-			})
+			bState := &ethpb.BeaconState{Validators: tt.args.validators}
+			stTrie, err := state_native.InitializeFromProtoUnsafePhase0(bState)
+			require.NoError(t, err)
+			got, err := helpers.ComputeProposerIndex(stTrie, tt.args.indices, tt.args.seed)
+			if tt.wantedErr != "" {
+				assert.ErrorContains(t, tt.wantedErr, err)
+				return
+			}
+			assert.NoError(t, err, "received unexpected error")
+			assert.Equal(t, tt.want, got, "ComputeProposerIndex()")
 		})
 	}
 }
@@ -805,9 +744,7 @@ func TestIsEligibleForActivationQueue(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			helpers.ClearCache()
 
-			v, err := state_native.NewValidator(tt.validator)
-			assert.NoError(t, err)
-			assert.Equal(t, tt.want, helpers.IsEligibleForActivationQueue(v, tt.currentEpoch), "IsEligibleForActivationQueue()")
+			assert.Equal(t, tt.want, helpers.IsEligibleForActivationQueue(tt.validator, tt.currentEpoch), "IsEligibleForActivationQueue()")
 		})
 	}
 }
@@ -1183,3 +1120,40 @@ func TestValidatorMaxEffectiveBalance(t *testing.T) {
 	// Sanity check that MinActivationBalance equals (pre-electra) MaxEffectiveBalance
 	assert.Equal(t, params.BeaconConfig().MinActivationBalance, params.BeaconConfig().MaxEffectiveBalance)
 }
+
+func TestQueueExcessActiveBalance_Ok(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	bals := st.Balances()
+	bals[0] = params.BeaconConfig().MinActivationBalance + 1000
+	require.NoError(t, st.SetBalances(bals))
+
+	err := helpers.QueueExcessActiveBalance(st, 0)
+	require.NoError(t, err)
+
+	pbd, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, uint64(1000), pbd[0].Amount)
+
+	bals = st.Balances()
+	require.Equal(t, params.BeaconConfig().MinActivationBalance, bals[0])
+}
+
+func TestQueueEntireBalanceAndResetValidator_Ok(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	val, err := st.ValidatorAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, val.EffectiveBalance)
+	pbd, err := st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(pbd))
+	err = helpers.QueueEntireBalanceAndResetValidator(st, 0)
+	require.NoError(t, err)
+
+	pbd, err = st.PendingBalanceDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(pbd))
+
+	val, err = st.ValidatorAtIndex(0)
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), val.EffectiveBalance)
+}

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

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

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -227,7 +227,7 @@ func ProcessBlockNoVerifyAnySig(
 //	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)
+//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_receipts_start_index)
 //	    if state.eth1_deposit_index < eth1_deposit_index_limit:
 //	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
 //	    else:
@@ -245,7 +245,7 @@ func ProcessBlockNoVerifyAnySig(
 //	    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.execution_payload.deposit_receipts, process_deposit_receipt)  # [New in Electra:EIP6110]
 //	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
 func ProcessOperationsNoVerifyAttsSigs(
 	ctx context.Context,
@@ -401,7 +401,7 @@ func VerifyBlobCommitmentCount(blk interfaces.ReadOnlyBeaconBlock) error {
 //	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)
+//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_receipts_start_index)
 //	    if state.eth1_deposit_index < eth1_deposit_index_limit:
 //	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
 //	    else:
@@ -419,7 +419,7 @@ func VerifyBlobCommitmentCount(blk interfaces.ReadOnlyBeaconBlock) error {
 //	    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.execution_payload.deposit_receipts, process_deposit_receipt)  # [New in Electra:EIP6110]
 //	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
 func electraOperations(
 	ctx context.Context,
@@ -432,7 +432,12 @@ func electraOperations(
 	if err != nil {
 		return nil, err
 	}
-	e, err := block.Body().Execution()
+	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")
 	}
@@ -440,18 +445,19 @@ func electraOperations(
 	if !ok {
 		return nil, errors.New("could not cast execution data to electra execution data")
 	}
-	st, err = electra.ProcessWithdrawalRequests(ctx, st, exe.WithdrawalRequests())
+	st, err = electra.ProcessExecutionLayerWithdrawalRequests(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.
+	st, err = electra.ProcessDepositReceipts(ctx, st, exe.DepositReceipts()) // TODO: EIP-6110 deposit changes.
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process deposit receipts")
 	}
 
-	// TODO: Process consolidations from execution header.
-
+	if err := electra.ProcessConsolidations(ctx, st, bod.Consolidations()); err != nil {
+		return nil, errors.Wrap(err, "could not process consolidations")
+	}
 	return st, nil
 }
 
@@ -499,7 +505,7 @@ func phase0Operations(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process block attestations")
 	}
-	if _, err := altair.ProcessDeposits(ctx, st, beaconBlock.Body().Deposits()); err != nil {
+	if _, err := b.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/db/filesystem/pruner.go

@@ -92,16 +92,14 @@ func windowMin(latest, offset primitives.Slot) primitives.Slot {
 
 func (p *blobPruner) warmCache() error {
 	p.Lock()
-	defer func() {
-		if !p.warmed {
-			p.warmed = true
-			close(p.cacheReady)
-		}
-		p.Unlock()
-	}()
+	defer p.Unlock()
 	if err := p.prune(0); err != nil {
 		return err
 	}
+	if !p.warmed {
+		p.warmed = true
+		close(p.cacheReady)
+	}
 	return nil
 }
 

beacon-chain/db/filesystem/pruner_test.go

@@ -2,19 +2,16 @@ package filesystem
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"math"
 	"os"
 	"path"
 	"sort"
 	"testing"
-	"time"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"github.com/spf13/afero"
@@ -37,34 +34,6 @@ func TestTryPruneDir_CachedNotExpired(t *testing.T) {
 	require.Equal(t, 0, pruned)
 }
 
-func TestCacheWarmFail(t *testing.T) {
-	fs := afero.NewMemMapFs()
-	n := blobNamer{root: bytesutil.ToBytes32([]byte("derp")), index: 0}
-	bp := n.path()
-	mkdir := path.Dir(bp)
-	require.NoError(t, fs.MkdirAll(mkdir, directoryPermissions))
-
-	// Create an empty blob index in the fs by touching the file at a seemingly valid path.
-	fi, err := fs.Create(bp)
-	require.NoError(t, err)
-	require.NoError(t, fi.Close())
-
-	// Cache warm should fail due to the unexpected EOF.
-	pr, err := newBlobPruner(fs, 0)
-	require.NoError(t, err)
-	require.ErrorIs(t, pr.warmCache(), errPruningFailures)
-
-	// The cache warm has finished, so calling waitForCache with a super short deadline
-	// should not block or hit the context deadline.
-	ctx := context.Background()
-	ctx, cancel := context.WithDeadline(ctx, time.Now().Add(1*time.Millisecond))
-	defer cancel()
-	c, err := pr.waitForCache(ctx)
-	// We will get an error and a nil value for the cache if we hit the deadline.
-	require.NoError(t, err)
-	require.NotNil(t, c)
-}
-
 func TestTryPruneDir_CachedExpired(t *testing.T) {
 	t.Run("empty directory", func(t *testing.T) {
 		fs := afero.NewMemMapFs()

beacon-chain/db/kv/blocks_test.go

@@ -132,6 +132,16 @@ 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)
 		},
@@ -143,6 +153,16 @@ 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/state_test.go

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

beacon-chain/execution/BUILD.bazel

@@ -27,7 +27,7 @@ go_library(
     deps = [
         "//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:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",

beacon-chain/execution/deposit.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
@@ -28,8 +28,7 @@ func (s *Service) processDeposit(ctx context.Context, eth1Data *ethpb.Eth1Data,
 	if err := s.preGenesisState.SetEth1Data(eth1Data); err != nil {
 		return err
 	}
-	// preGenesisState is always a genesis state ( phase 0 ) and so state version does not need to be checked here for post electra deposit processing
-	beaconState, err := altair.ProcessPreGenesisDeposits(ctx, s.preGenesisState, []*ethpb.Deposit{deposit})
+	beaconState, err := blocks.ProcessPreGenesisDeposits(ctx, s.preGenesisState, []*ethpb.Deposit{deposit})
 	if err != nil {
 		return errors.Wrap(err, "could not process pre-genesis deposits")
 	}

beacon-chain/execution/engine_client.go

@@ -631,7 +631,7 @@ func fullPayloadFromPayloadBody(
 				Withdrawals:        body.Withdrawals,
 				ExcessBlobGas:      ebg,
 				BlobGasUsed:        bgu,
-				DepositRequests:    dr,
+				DepositReceipts:    dr,
 				WithdrawalRequests: wr,
 			}) // We can't get the block value and don't care about the block value for this instance
 	default:
@@ -780,8 +780,8 @@ func buildEmptyExecutionPayload(v int) (proto.Message, error) {
 			BlockHash:          make([]byte, fieldparams.RootLength),
 			Transactions:       make([][]byte, 0),
 			Withdrawals:        make([]*pb.Withdrawal, 0),
-			WithdrawalRequests: make([]*pb.WithdrawalRequest, 0),
-			DepositRequests:    make([]*pb.DepositRequest, 0),
+			WithdrawalRequests: make([]*pb.ExecutionLayerWithdrawalRequest, 0),
+			DepositReceipts:    make([]*pb.DepositReceipt, 0),
 		}, nil
 	default:
 		return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))

beacon-chain/execution/engine_client_test.go

@@ -1559,7 +1559,7 @@ func fixturesStruct() *payloadFixtures {
 		Withdrawals:        []*pb.Withdrawal{},
 		BlobGasUsed:        2,
 		ExcessBlobGas:      3,
-		DepositRequests:    dr,
+		DepositReceipts:    dr,
 		WithdrawalRequests: wr,
 	}
 	hexUint := hexutil.Uint64(1)

beacon-chain/execution/payload_body_test.go

@@ -66,7 +66,7 @@ func payloadToBody(t *testing.T, ed interfaces.ExecutionData) *pb.ExecutionPaylo
 	}
 	eed, isElectra := ed.(interfaces.ExecutionDataElectra)
 	if isElectra {
-		body.DepositRequests = pb.ProtoDepositRequestsToJson(eed.DepositRequests())
+		body.DepositRequests = pb.ProtoDepositRequestsToJson(eed.DepositReceipts())
 		body.WithdrawalRequests = pb.ProtoWithdrawalRequestsToJson(eed.WithdrawalRequests())
 	}
 	return body

beacon-chain/node/BUILD.bazel

@@ -16,7 +16,7 @@ go_library(
     ],
     deps = [
         "//api/gateway:go_default_library",
-        "//api/server/middleware:go_default_library",
+        "//api/server:go_default_library",
         "//async/event:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/builder:go_default_library",
@@ -69,6 +69,7 @@ go_library(
         "@com_github_gorilla_mux//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
+        "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
     ],

beacon-chain/node/config.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
+	fastssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -196,3 +197,7 @@ func configureExecutionSetting(cliCtx *cli.Context) error {
 		" Default fee recipient will be used as a fall back", checksumAddress.Hex())
 	return params.SetActive(c)
 }
+
+func configureFastSSZHashingAlgorithm() {
+	fastssz.EnableVectorizedHTR = true
+}

beacon-chain/node/node.go

@@ -20,7 +20,7 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 	apigateway "github.com/prysmaticlabs/prysm/v5/api/gateway"
-	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
+	"github.com/prysmaticlabs/prysm/v5/api/server"
 	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/builder"
@@ -120,6 +120,7 @@ type BeaconNode struct {
 	initialSyncComplete     chan struct{}
 	BlobStorage             *filesystem.BlobStorage
 	BlobStorageOptions      []filesystem.BlobStorageOption
+	blobRetentionEpochs     primitives.Epoch
 	verifyInitWaiter        *verification.InitializerWaiter
 	syncChecker             *initialsync.SyncChecker
 }
@@ -277,6 +278,8 @@ func configureBeacon(cliCtx *cli.Context) error {
 		return errors.Wrap(err, "could not configure execution setting")
 	}
 
+	configureFastSSZHashingAlgorithm()
+
 	return nil
 }
 
@@ -406,8 +409,8 @@ func newRouter(cliCtx *cli.Context) *mux.Router {
 		allowedOrigins = strings.Split(flags.GPRCGatewayCorsDomain.Value, ",")
 	}
 	r := mux.NewRouter()
-	r.Use(middleware.NormalizeQueryValuesHandler)
-	r.Use(middleware.CorsHandler(allowedOrigins))
+	r.Use(server.NormalizeQueryValuesHandler)
+	r.Use(server.CorsHandler(allowedOrigins))
 	return r
 }
 
@@ -962,8 +965,9 @@ func (b *BeaconNode) registerRPCService(router *mux.Router) error {
 	cert := b.cliCtx.String(flags.CertFlag.Name)
 	key := b.cliCtx.String(flags.KeyFlag.Name)
 	mockEth1DataVotes := b.cliCtx.Bool(flags.InteropMockEth1DataVotesFlag.Name)
+
 	maxMsgSize := b.cliCtx.Int(cmd.GrpcMaxCallRecvMsgSizeFlag.Name)
-	enableDebugRPCEndpoints := !b.cliCtx.Bool(flags.DisableDebugRPCEndpoints.Name)
+	enableDebugRPCEndpoints := b.cliCtx.Bool(flags.EnableDebugRPCEndpoints.Name)
 
 	p2pService := b.fetchP2P()
 	rpcService := rpc.NewService(b.ctx, &rpc.Config{
@@ -1052,10 +1056,11 @@ func (b *BeaconNode) registerGRPCGateway(router *mux.Router) error {
 	gatewayPort := b.cliCtx.Int(flags.GRPCGatewayPort.Name)
 	rpcHost := b.cliCtx.String(flags.RPCHost.Name)
 	rpcPort := b.cliCtx.Int(flags.RPCPort.Name)
-	enableDebugRPCEndpoints := !b.cliCtx.Bool(flags.DisableDebugRPCEndpoints.Name)
+
 	selfAddress := net.JoinHostPort(rpcHost, strconv.Itoa(rpcPort))
 	gatewayAddress := net.JoinHostPort(gatewayHost, strconv.Itoa(gatewayPort))
 	allowedOrigins := strings.Split(b.cliCtx.String(flags.GPRCGatewayCorsDomain.Name), ",")
+	enableDebugRPCEndpoints := b.cliCtx.Bool(flags.EnableDebugRPCEndpoints.Name)
 	selfCert := b.cliCtx.String(flags.CertFlag.Name)
 	maxCallSize := b.cliCtx.Uint64(cmd.GrpcMaxCallRecvMsgSizeFlag.Name)
 	httpModules := b.cliCtx.String(flags.HTTPModules.Name)

beacon-chain/node/options.go

@@ -5,6 +5,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/builder"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
 // Option for beacon node configuration.
@@ -50,3 +51,11 @@ func WithBlobStorageOptions(opt ...filesystem.BlobStorageOption) Option {
 		return nil
 	}
 }
+
+// WithBlobRetentionEpochs sets the blobRetentionEpochs value, used in kv store initialization.
+func WithBlobRetentionEpochs(e primitives.Epoch) Option {
+	return func(bn *BeaconNode) error {
+		bn.blobRetentionEpochs = e
+		return nil
+	}
+}

beacon-chain/operations/attestations/BUILD.bazel

@@ -21,13 +21,12 @@ go_library(
         "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//crypto/hash:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/attestation/aggregation/attestations:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_hashicorp_golang_lru//:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

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

@@ -16,10 +16,9 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//crypto/hash:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/attestation/aggregation/attestations:go_default_library",
-        "//runtime/version:go_default_library",
         "@com_github_patrickmn_go_cache//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
@@ -40,15 +39,14 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//config/fieldparams:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_patrickmn_go_cache//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
 )

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

@@ -9,9 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	attaggregation "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation/aggregation/attestations"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	log "github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -34,28 +32,28 @@ func (c *AttCaches) aggregateUnaggregatedAtts(ctx context.Context, unaggregatedA
 	_, span := trace.StartSpan(ctx, "operations.attestations.kv.aggregateUnaggregatedAtts")
 	defer span.End()
 
-	attsByVerAndDataRoot := make(map[attestation.Id][]ethpb.Att, len(unaggregatedAtts))
+	attsByDataRoot := make(map[[32]byte][]ethpb.Att, len(unaggregatedAtts))
 	for _, att := range unaggregatedAtts {
-		id, err := attestation.NewId(att, attestation.Data)
+		attDataRoot, err := att.GetData().HashTreeRoot()
 		if err != nil {
-			return errors.Wrap(err, "could not create attestation ID")
+			return err
 		}
-		attsByVerAndDataRoot[id] = append(attsByVerAndDataRoot[id], att)
+		attsByDataRoot[attDataRoot] = append(attsByDataRoot[attDataRoot], att)
 	}
 
 	// Aggregate unaggregated attestations from the pool and save them in the pool.
 	// Track the unaggregated attestations that aren't able to aggregate.
-	leftOverUnaggregatedAtt := make(map[attestation.Id]bool)
+	leftOverUnaggregatedAtt := make(map[[32]byte]bool)
 
-	leftOverUnaggregatedAtt = c.aggregateParallel(attsByVerAndDataRoot, leftOverUnaggregatedAtt)
+	leftOverUnaggregatedAtt = c.aggregateParallel(attsByDataRoot, leftOverUnaggregatedAtt)
 
 	// Remove the unaggregated attestations from the pool that were successfully aggregated.
 	for _, att := range unaggregatedAtts {
-		id, err := attestation.NewId(att, attestation.Full)
+		h, err := hashFn(att)
 		if err != nil {
-			return errors.Wrap(err, "could not create attestation ID")
+			return err
 		}
-		if leftOverUnaggregatedAtt[id] {
+		if leftOverUnaggregatedAtt[h] {
 			continue
 		}
 		if err := c.DeleteUnaggregatedAttestation(att); err != nil {
@@ -68,7 +66,7 @@ func (c *AttCaches) aggregateUnaggregatedAtts(ctx context.Context, unaggregatedA
 // aggregateParallel aggregates attestations in parallel for `atts` and saves them in the pool,
 // returns the unaggregated attestations that weren't able to aggregate.
 // Given `n` CPU cores, it creates a channel of size `n` and spawns `n` goroutines to aggregate attestations
-func (c *AttCaches) aggregateParallel(atts map[attestation.Id][]ethpb.Att, leftOver map[attestation.Id]bool) map[attestation.Id]bool {
+func (c *AttCaches) aggregateParallel(atts map[[32]byte][]ethpb.Att, leftOver map[[32]byte]bool) map[[32]byte]bool {
 	var leftoverLock sync.Mutex
 	wg := sync.WaitGroup{}
 
@@ -94,13 +92,13 @@ func (c *AttCaches) aggregateParallel(atts map[attestation.Id][]ethpb.Att, leftO
 						continue
 					}
 				} else {
-					id, err := attestation.NewId(aggregated, attestation.Full)
+					h, err := hashFn(aggregated)
 					if err != nil {
-						log.WithError(err).Error("Could not create attestation ID")
+						log.WithError(err).Error("could not hash attestation")
 						continue
 					}
 					leftoverLock.Lock()
-					leftOver[id] = true
+					leftOver[h] = true
 					leftoverLock.Unlock()
 				}
 			}
@@ -141,18 +139,17 @@ func (c *AttCaches) SaveAggregatedAttestation(att ethpb.Att) error {
 		return nil
 	}
 
-	id, err := attestation.NewId(att, attestation.Data)
+	r, err := hashFn(att.GetData())
 	if err != nil {
-		return errors.Wrap(err, "could not create attestation ID")
+		return errors.Wrap(err, "could not tree hash attestation")
 	}
 	copiedAtt := att.Copy()
-
 	c.aggregatedAttLock.Lock()
 	defer c.aggregatedAttLock.Unlock()
-	atts, ok := c.aggregatedAtt[id]
+	atts, ok := c.aggregatedAtt[r]
 	if !ok {
 		atts := []ethpb.Att{copiedAtt}
-		c.aggregatedAtt[id] = atts
+		c.aggregatedAtt[r] = atts
 		return nil
 	}
 
@@ -160,7 +157,7 @@ func (c *AttCaches) SaveAggregatedAttestation(att ethpb.Att) error {
 	if err != nil {
 		return err
 	}
-	c.aggregatedAtt[id] = atts
+	c.aggregatedAtt[r] = atts
 
 	return nil
 }
@@ -194,56 +191,17 @@ func (c *AttCaches) AggregatedAttestations() []ethpb.Att {
 
 // AggregatedAttestationsBySlotIndex returns the aggregated attestations in cache,
 // filtered by committee index and slot.
-func (c *AttCaches) AggregatedAttestationsBySlotIndex(
-	ctx context.Context,
-	slot primitives.Slot,
-	committeeIndex primitives.CommitteeIndex,
-) []*ethpb.Attestation {
+func (c *AttCaches) AggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []ethpb.Att {
 	_, span := trace.StartSpan(ctx, "operations.attestations.kv.AggregatedAttestationsBySlotIndex")
 	defer span.End()
 
-	atts := make([]*ethpb.Attestation, 0)
+	atts := make([]ethpb.Att, 0)
 
 	c.aggregatedAttLock.RLock()
 	defer c.aggregatedAttLock.RUnlock()
-	for _, as := range c.aggregatedAtt {
-		if as[0].Version() == version.Phase0 && slot == as[0].GetData().Slot && committeeIndex == as[0].GetData().CommitteeIndex {
-			for _, a := range as {
-				att, ok := a.(*ethpb.Attestation)
-				// This will never fail in practice because we asserted the version
-				if ok {
-					atts = append(atts, att)
-				}
-			}
-		}
-	}
-
-	return atts
-}
-
-// AggregatedAttestationsBySlotIndexElectra returns the aggregated attestations in cache,
-// filtered by committee index and slot.
-func (c *AttCaches) AggregatedAttestationsBySlotIndexElectra(
-	ctx context.Context,
-	slot primitives.Slot,
-	committeeIndex primitives.CommitteeIndex,
-) []*ethpb.AttestationElectra {
-	_, span := trace.StartSpan(ctx, "operations.attestations.kv.AggregatedAttestationsBySlotIndexElectra")
-	defer span.End()
-
-	atts := make([]*ethpb.AttestationElectra, 0)
-
-	c.aggregatedAttLock.RLock()
-	defer c.aggregatedAttLock.RUnlock()
-	for _, as := range c.aggregatedAtt {
-		if as[0].Version() == version.Electra && slot == as[0].GetData().Slot && as[0].CommitteeBitsVal().BitAt(uint64(committeeIndex)) {
-			for _, a := range as {
-				att, ok := a.(*ethpb.AttestationElectra)
-				// This will never fail in practice because we asserted the version
-				if ok {
-					atts = append(atts, att)
-				}
-			}
+	for _, a := range c.aggregatedAtt {
+		if slot == a[0].GetData().Slot && committeeIndex == a[0].GetData().CommitteeIndex {
+			atts = append(atts, a...)
 		}
 	}
 
@@ -258,19 +216,18 @@ func (c *AttCaches) DeleteAggregatedAttestation(att ethpb.Att) error {
 	if !helpers.IsAggregated(att) {
 		return errors.New("attestation is not aggregated")
 	}
+	r, err := hashFn(att.GetData())
+	if err != nil {
+		return errors.Wrap(err, "could not tree hash attestation data")
+	}
 
 	if err := c.insertSeenBit(att); err != nil {
 		return err
 	}
 
-	id, err := attestation.NewId(att, attestation.Data)
-	if err != nil {
-		return errors.Wrap(err, "could not create attestation ID")
-	}
-
 	c.aggregatedAttLock.Lock()
 	defer c.aggregatedAttLock.Unlock()
-	attList, ok := c.aggregatedAtt[id]
+	attList, ok := c.aggregatedAtt[r]
 	if !ok {
 		return nil
 	}
@@ -284,9 +241,9 @@ func (c *AttCaches) DeleteAggregatedAttestation(att ethpb.Att) error {
 		}
 	}
 	if len(filtered) == 0 {
-		delete(c.aggregatedAtt, id)
+		delete(c.aggregatedAtt, r)
 	} else {
-		c.aggregatedAtt[id] = filtered
+		c.aggregatedAtt[r] = filtered
 	}
 
 	return nil
@@ -297,15 +254,14 @@ func (c *AttCaches) HasAggregatedAttestation(att ethpb.Att) (bool, error) {
 	if err := helpers.ValidateNilAttestation(att); err != nil {
 		return false, err
 	}
-
-	id, err := attestation.NewId(att, attestation.Data)
+	r, err := hashFn(att.GetData())
 	if err != nil {
-		return false, errors.Wrap(err, "could not create attestation ID")
+		return false, errors.Wrap(err, "could not tree hash attestation")
 	}
 
 	c.aggregatedAttLock.RLock()
 	defer c.aggregatedAttLock.RUnlock()
-	if atts, ok := c.aggregatedAtt[id]; ok {
+	if atts, ok := c.aggregatedAtt[r]; ok {
 		for _, a := range atts {
 			if c, err := a.GetAggregationBits().Contains(att.GetAggregationBits()); err != nil {
 				return false, err
@@ -317,7 +273,7 @@ func (c *AttCaches) HasAggregatedAttestation(att ethpb.Att) (bool, error) {
 
 	c.blockAttLock.RLock()
 	defer c.blockAttLock.RUnlock()
-	if atts, ok := c.blockAtt[id]; ok {
+	if atts, ok := c.blockAtt[r]; ok {
 		for _, a := range atts {
 			if c, err := a.GetAggregationBits().Contains(att.GetAggregationBits()); err != nil {
 				return false, err

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

@@ -7,11 +7,10 @@ import (
 
 	c "github.com/patrickmn/go-cache"
 	"github.com/pkg/errors"
+	fssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/go-bitfield"
-	"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/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
@@ -70,7 +69,7 @@ func TestKV_Aggregated_SaveAggregatedAttestation(t *testing.T) {
 				}),
 				AggregationBits: bitfield.Bitlist{0b10111},
 			},
-			wantErrString: "could not create attestation ID",
+			wantErrString: "could not tree hash attestation: --.BeaconBlockRoot (" + fssz.ErrBytesLength.Error() + ")",
 		},
 		{
 			name: "already seen",
@@ -93,13 +92,15 @@ func TestKV_Aggregated_SaveAggregatedAttestation(t *testing.T) {
 			count: 1,
 		},
 	}
-	id, err := attestation.NewId(util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100}}), attestation.Data)
+	r, err := hashFn(util.HydrateAttestationData(&ethpb.AttestationData{
+		Slot: 100,
+	}))
 	require.NoError(t, err)
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			cache := NewAttCaches()
-			cache.seenAtt.Set(id.String(), []bitfield.Bitlist{{0xff}}, c.DefaultExpiration)
+			cache.seenAtt.Set(string(r[:]), []bitfield.Bitlist{{0xff}}, c.DefaultExpiration)
 			assert.Equal(t, 0, len(cache.unAggregatedAtt), "Invalid start pool, atts: %d", len(cache.unAggregatedAtt))
 
 			err := cache.SaveAggregatedAttestation(tt.att)
@@ -229,7 +230,7 @@ func TestKV_Aggregated_DeleteAggregatedAttestation(t *testing.T) {
 			},
 		}
 		err := cache.DeleteAggregatedAttestation(att)
-		wantErr := "could not create attestation ID"
+		wantErr := "could not tree hash attestation data: --.BeaconBlockRoot (" + fssz.ErrBytesLength.Error() + ")"
 		assert.ErrorContains(t, wantErr, err)
 	})
 
@@ -499,49 +500,3 @@ func TestKV_Aggregated_DuplicateAggregatedAttestations(t *testing.T) {
 	assert.DeepSSZEqual(t, att2, returned[0], "Did not receive correct aggregated atts")
 	assert.Equal(t, 1, len(returned), "Did not receive correct aggregated atts")
 }
-
-func TestKV_Aggregated_AggregatedAttestationsBySlotIndex(t *testing.T) {
-	cache := NewAttCaches()
-
-	att1 := util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 1}, AggregationBits: bitfield.Bitlist{0b1011}})
-	att2 := util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 2}, AggregationBits: bitfield.Bitlist{0b1101}})
-	att3 := util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 1}, AggregationBits: bitfield.Bitlist{0b1101}})
-	atts := []*ethpb.Attestation{att1, att2, att3}
-
-	for _, att := range atts {
-		require.NoError(t, cache.SaveAggregatedAttestation(att))
-	}
-	ctx := context.Background()
-	returned := cache.AggregatedAttestationsBySlotIndex(ctx, 1, 1)
-	assert.DeepEqual(t, []*ethpb.Attestation{att1}, returned)
-	returned = cache.AggregatedAttestationsBySlotIndex(ctx, 1, 2)
-	assert.DeepEqual(t, []*ethpb.Attestation{att2}, returned)
-	returned = cache.AggregatedAttestationsBySlotIndex(ctx, 2, 1)
-	assert.DeepEqual(t, []*ethpb.Attestation{att3}, returned)
-}
-
-func TestKV_Aggregated_AggregatedAttestationsBySlotIndexElectra(t *testing.T) {
-	cache := NewAttCaches()
-
-	committeeBits := primitives.NewAttestationCommitteeBits()
-	committeeBits.SetBitAt(1, true)
-	att1 := util.HydrateAttestationElectra(&ethpb.AttestationElectra{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1011}, CommitteeBits: committeeBits})
-	committeeBits = primitives.NewAttestationCommitteeBits()
-	committeeBits.SetBitAt(2, true)
-	att2 := util.HydrateAttestationElectra(&ethpb.AttestationElectra{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}, CommitteeBits: committeeBits})
-	committeeBits = primitives.NewAttestationCommitteeBits()
-	committeeBits.SetBitAt(1, true)
-	att3 := util.HydrateAttestationElectra(&ethpb.AttestationElectra{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1101}, CommitteeBits: committeeBits})
-	atts := []*ethpb.AttestationElectra{att1, att2, att3}
-
-	for _, att := range atts {
-		require.NoError(t, cache.SaveAggregatedAttestation(att))
-	}
-	ctx := context.Background()
-	returned := cache.AggregatedAttestationsBySlotIndexElectra(ctx, 1, 1)
-	assert.DeepEqual(t, []*ethpb.AttestationElectra{att1}, returned)
-	returned = cache.AggregatedAttestationsBySlotIndexElectra(ctx, 1, 2)
-	assert.DeepEqual(t, []*ethpb.AttestationElectra{att2}, returned)
-	returned = cache.AggregatedAttestationsBySlotIndexElectra(ctx, 2, 1)
-	assert.DeepEqual(t, []*ethpb.AttestationElectra{att3}, returned)
-}

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

@@ -3,7 +3,6 @@ package kv
 import (
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 )
 
 // SaveBlockAttestation saves an block attestation in cache.
@@ -11,15 +10,14 @@ func (c *AttCaches) SaveBlockAttestation(att ethpb.Att) error {
 	if att == nil {
 		return nil
 	}
-
-	id, err := attestation.NewId(att, attestation.Data)
+	r, err := hashFn(att.GetData())
 	if err != nil {
-		return errors.Wrap(err, "could not create attestation ID")
+		return errors.Wrap(err, "could not tree hash attestation")
 	}
 
 	c.blockAttLock.Lock()
 	defer c.blockAttLock.Unlock()
-	atts, ok := c.blockAtt[id]
+	atts, ok := c.blockAtt[r]
 	if !ok {
 		atts = make([]ethpb.Att, 0, 1)
 	}
@@ -33,7 +31,7 @@ func (c *AttCaches) SaveBlockAttestation(att ethpb.Att) error {
 		}
 	}
 
-	c.blockAtt[id] = append(atts, att.Copy())
+	c.blockAtt[r] = append(atts, att.Copy())
 
 	return nil
 }
@@ -56,15 +54,14 @@ func (c *AttCaches) DeleteBlockAttestation(att ethpb.Att) error {
 	if att == nil {
 		return nil
 	}
-
-	id, err := attestation.NewId(att, attestation.Data)
+	r, err := hashFn(att.GetData())
 	if err != nil {
-		return errors.Wrap(err, "could not create attestation ID")
+		return errors.Wrap(err, "could not tree hash attestation")
 	}
 
 	c.blockAttLock.Lock()
 	defer c.blockAttLock.Unlock()
-	delete(c.blockAtt, id)
+	delete(c.blockAtt, r)
 
 	return nil
 }

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

@@ -3,7 +3,6 @@ package kv
 import (
 	"github.com/pkg/errors"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 )
 
 // SaveForkchoiceAttestation saves an forkchoice attestation in cache.
@@ -11,15 +10,14 @@ func (c *AttCaches) SaveForkchoiceAttestation(att ethpb.Att) error {
 	if att == nil {
 		return nil
 	}
-
-	id, err := attestation.NewId(att, attestation.Full)
+	r, err := hashFn(att)
 	if err != nil {
-		return errors.Wrap(err, "could not create attestation ID")
+		return errors.Wrap(err, "could not tree hash attestation")
 	}
 
 	c.forkchoiceAttLock.Lock()
 	defer c.forkchoiceAttLock.Unlock()
-	c.forkchoiceAtt[id] = att
+	c.forkchoiceAtt[r] = att.Copy()
 
 	return nil
 }
@@ -53,15 +51,14 @@ func (c *AttCaches) DeleteForkchoiceAttestation(att ethpb.Att) error {
 	if att == nil {
 		return nil
 	}
-
-	id, err := attestation.NewId(att, attestation.Full)
+	r, err := hashFn(att)
 	if err != nil {
-		return errors.Wrap(err, "could not create attestation ID")
+		return errors.Wrap(err, "could not tree hash attestation")
 	}
 
 	c.forkchoiceAttLock.Lock()
 	defer c.forkchoiceAttLock.Unlock()
-	delete(c.forkchoiceAtt, id)
+	delete(c.forkchoiceAtt, r)
 
 	return nil
 }

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

@@ -9,22 +9,24 @@ import (
 
 	"github.com/patrickmn/go-cache"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 )
 
+var hashFn = hash.Proto
+
 // AttCaches defines the caches used to satisfy attestation pool interface.
 // These caches are KV store for various attestations
 // such are unaggregated, aggregated or attestations within a block.
 type AttCaches struct {
 	aggregatedAttLock  sync.RWMutex
-	aggregatedAtt      map[attestation.Id][]ethpb.Att
+	aggregatedAtt      map[[32]byte][]ethpb.Att
 	unAggregateAttLock sync.RWMutex
-	unAggregatedAtt    map[attestation.Id]ethpb.Att
+	unAggregatedAtt    map[[32]byte]ethpb.Att
 	forkchoiceAttLock  sync.RWMutex
-	forkchoiceAtt      map[attestation.Id]ethpb.Att
+	forkchoiceAtt      map[[32]byte]ethpb.Att
 	blockAttLock       sync.RWMutex
-	blockAtt           map[attestation.Id][]ethpb.Att
+	blockAtt           map[[32]byte][]ethpb.Att
 	seenAtt            *cache.Cache
 }
 
@@ -32,12 +34,12 @@ type AttCaches struct {
 // various kind of attestations.
 func NewAttCaches() *AttCaches {
 	secsInEpoch := time.Duration(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
-	c := cache.New(2*secsInEpoch*time.Second, 2*secsInEpoch*time.Second)
+	c := cache.New(secsInEpoch*time.Second, 2*secsInEpoch*time.Second)
 	pool := &AttCaches{
-		unAggregatedAtt: make(map[attestation.Id]ethpb.Att),
-		aggregatedAtt:   make(map[attestation.Id][]ethpb.Att),
-		forkchoiceAtt:   make(map[attestation.Id]ethpb.Att),
-		blockAtt:        make(map[attestation.Id][]ethpb.Att),
+		unAggregatedAtt: make(map[[32]byte]ethpb.Att),
+		aggregatedAtt:   make(map[[32]byte][]ethpb.Att),
+		forkchoiceAtt:   make(map[[32]byte]ethpb.Att),
+		blockAtt:        make(map[[32]byte][]ethpb.Att),
 		seenAtt:         c,
 	}
 

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

@@ -1,20 +1,21 @@
 package kv
 
 import (
+	"fmt"
+
 	"github.com/patrickmn/go-cache"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 )
 
 func (c *AttCaches) insertSeenBit(att ethpb.Att) error {
-	id, err := attestation.NewId(att, attestation.Data)
+	r, err := hashFn(att.GetData())
 	if err != nil {
-		return errors.Wrap(err, "could not create attestation ID")
+		return err
 	}
 
-	v, ok := c.seenAtt.Get(id.String())
+	v, ok := c.seenAtt.Get(string(r[:]))
 	if ok {
 		seenBits, ok := v.([]bitfield.Bitlist)
 		if !ok {
@@ -23,7 +24,7 @@ func (c *AttCaches) insertSeenBit(att ethpb.Att) error {
 		alreadyExists := false
 		for _, bit := range seenBits {
 			if c, err := bit.Contains(att.GetAggregationBits()); err != nil {
-				return err
+				return fmt.Errorf("failed to check seen bits on attestation when inserting bit: %w", err)
 			} else if c {
 				alreadyExists = true
 				break
@@ -32,21 +33,21 @@ func (c *AttCaches) insertSeenBit(att ethpb.Att) error {
 		if !alreadyExists {
 			seenBits = append(seenBits, att.GetAggregationBits())
 		}
-		c.seenAtt.Set(id.String(), seenBits, cache.DefaultExpiration /* one epoch */)
+		c.seenAtt.Set(string(r[:]), seenBits, cache.DefaultExpiration /* one epoch */)
 		return nil
 	}
 
-	c.seenAtt.Set(id.String(), []bitfield.Bitlist{att.GetAggregationBits()}, cache.DefaultExpiration /* one epoch */)
+	c.seenAtt.Set(string(r[:]), []bitfield.Bitlist{att.GetAggregationBits()}, cache.DefaultExpiration /* one epoch */)
 	return nil
 }
 
 func (c *AttCaches) hasSeenBit(att ethpb.Att) (bool, error) {
-	id, err := attestation.NewId(att, attestation.Data)
+	r, err := hashFn(att.GetData())
 	if err != nil {
-		return false, errors.Wrap(err, "could not create attestation ID")
+		return false, err
 	}
 
-	v, ok := c.seenAtt.Get(id.String())
+	v, ok := c.seenAtt.Get(string(r[:]))
 	if ok {
 		seenBits, ok := v.([]bitfield.Bitlist)
 		if !ok {
@@ -54,7 +55,7 @@ func (c *AttCaches) hasSeenBit(att ethpb.Att) (bool, error) {
 		}
 		for _, bit := range seenBits {
 			if c, err := bit.Contains(att.GetAggregationBits()); err != nil {
-				return false, err
+				return false, fmt.Errorf("failed to check seen bits on attestation when reading bit: %w", err)
 			} else if c {
 				return true, nil
 			}

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

@@ -5,7 +5,6 @@ import (
 
 	"github.com/prysmaticlabs/go-bitfield"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
@@ -40,18 +39,18 @@ func TestAttCaches_hasSeenBit(t *testing.T) {
 func TestAttCaches_insertSeenBitDuplicates(t *testing.T) {
 	c := NewAttCaches()
 	att1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10000011}})
-	id, err := attestation.NewId(att1, attestation.Data)
+	r, err := hashFn(att1.Data)
 	require.NoError(t, err)
 	require.NoError(t, c.insertSeenBit(att1))
 	require.Equal(t, 1, c.seenAtt.ItemCount())
 
-	_, expirationTime1, ok := c.seenAtt.GetWithExpiration(id.String())
+	_, expirationTime1, ok := c.seenAtt.GetWithExpiration(string(r[:]))
 	require.Equal(t, true, ok)
 
 	// Make sure that duplicates are not inserted, but expiration time gets updated.
 	require.NoError(t, c.insertSeenBit(att1))
 	require.Equal(t, 1, c.seenAtt.ItemCount())
-	_, expirationprysmTime, ok := c.seenAtt.GetWithExpiration(id.String())
+	_, expirationprysmTime, ok := c.seenAtt.GetWithExpiration(string(r[:]))
 	require.Equal(t, true, ok)
 	require.Equal(t, true, expirationprysmTime.After(expirationTime1), "Expiration time is not updated")
 }

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

@@ -7,8 +7,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"go.opencensus.io/trace"
 )
 
@@ -29,14 +27,13 @@ func (c *AttCaches) SaveUnaggregatedAttestation(att ethpb.Att) error {
 		return nil
 	}
 
-	id, err := attestation.NewId(att, attestation.Full)
+	r, err := hashFn(att)
 	if err != nil {
-		return errors.Wrap(err, "could not create attestation ID")
+		return errors.Wrap(err, "could not tree hash attestation")
 	}
-
 	c.unAggregateAttLock.Lock()
 	defer c.unAggregateAttLock.Unlock()
-	c.unAggregatedAtt[id] = att
+	c.unAggregatedAtt[r] = att.Copy()
 
 	return nil
 }
@@ -72,56 +69,19 @@ func (c *AttCaches) UnaggregatedAttestations() ([]ethpb.Att, error) {
 
 // UnaggregatedAttestationsBySlotIndex returns the unaggregated attestations in cache,
 // filtered by committee index and slot.
-func (c *AttCaches) UnaggregatedAttestationsBySlotIndex(
-	ctx context.Context,
-	slot primitives.Slot,
-	committeeIndex primitives.CommitteeIndex,
-) []*ethpb.Attestation {
+func (c *AttCaches) UnaggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []ethpb.Att {
 	_, span := trace.StartSpan(ctx, "operations.attestations.kv.UnaggregatedAttestationsBySlotIndex")
 	defer span.End()
 
-	atts := make([]*ethpb.Attestation, 0)
+	atts := make([]ethpb.Att, 0)
 
 	c.unAggregateAttLock.RLock()
 	defer c.unAggregateAttLock.RUnlock()
 
 	unAggregatedAtts := c.unAggregatedAtt
 	for _, a := range unAggregatedAtts {
-		if a.Version() == version.Phase0 && slot == a.GetData().Slot && committeeIndex == a.GetData().CommitteeIndex {
-			att, ok := a.(*ethpb.Attestation)
-			// This will never fail in practice because we asserted the version
-			if ok {
-				atts = append(atts, att)
-			}
-		}
-	}
-
-	return atts
-}
-
-// UnaggregatedAttestationsBySlotIndexElectra returns the unaggregated attestations in cache,
-// filtered by committee index and slot.
-func (c *AttCaches) UnaggregatedAttestationsBySlotIndexElectra(
-	ctx context.Context,
-	slot primitives.Slot,
-	committeeIndex primitives.CommitteeIndex,
-) []*ethpb.AttestationElectra {
-	_, span := trace.StartSpan(ctx, "operations.attestations.kv.UnaggregatedAttestationsBySlotIndexElectra")
-	defer span.End()
-
-	atts := make([]*ethpb.AttestationElectra, 0)
-
-	c.unAggregateAttLock.RLock()
-	defer c.unAggregateAttLock.RUnlock()
-
-	unAggregatedAtts := c.unAggregatedAtt
-	for _, a := range unAggregatedAtts {
-		if a.Version() == version.Electra && slot == a.GetData().Slot && a.CommitteeBitsVal().BitAt(uint64(committeeIndex)) {
-			att, ok := a.(*ethpb.AttestationElectra)
-			// This will never fail in practice because we asserted the version
-			if ok {
-				atts = append(atts, att)
-			}
+		if slot == a.GetData().Slot && committeeIndex == a.GetData().CommitteeIndex {
+			atts = append(atts, a)
 		}
 	}
 
@@ -141,14 +101,14 @@ func (c *AttCaches) DeleteUnaggregatedAttestation(att ethpb.Att) error {
 		return err
 	}
 
-	id, err := attestation.NewId(att, attestation.Full)
+	r, err := hashFn(att)
 	if err != nil {
-		return errors.Wrap(err, "could not create attestation ID")
+		return errors.Wrap(err, "could not tree hash attestation")
 	}
 
 	c.unAggregateAttLock.Lock()
 	defer c.unAggregateAttLock.Unlock()
-	delete(c.unAggregatedAtt, id)
+	delete(c.unAggregatedAtt, r)
 
 	return nil
 }

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

@@ -7,11 +7,10 @@ import (
 	"testing"
 
 	c "github.com/patrickmn/go-cache"
+	fssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/go-bitfield"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
@@ -40,7 +39,7 @@ func TestKV_Unaggregated_SaveUnaggregatedAttestation(t *testing.T) {
 					BeaconBlockRoot: []byte{0b0},
 				},
 			},
-			wantErrString: "could not create attestation ID",
+			wantErrString: fssz.ErrBytesLength.Error(),
 		},
 		{
 			name:  "normal save",
@@ -58,13 +57,13 @@ func TestKV_Unaggregated_SaveUnaggregatedAttestation(t *testing.T) {
 			count: 0,
 		},
 	}
-	id, err := attestation.NewId(util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100}}), attestation.Data)
+	r, err := hashFn(util.HydrateAttestationData(&ethpb.AttestationData{Slot: 100}))
 	require.NoError(t, err)
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			cache := NewAttCaches()
-			cache.seenAtt.Set(id.String(), []bitfield.Bitlist{{0xff}}, c.DefaultExpiration)
+			cache.seenAtt.Set(string(r[:]), []bitfield.Bitlist{{0xff}}, c.DefaultExpiration)
 			assert.Equal(t, 0, len(cache.unAggregatedAtt), "Invalid start pool, atts: %d", len(cache.unAggregatedAtt))
 
 			if tt.att != nil && tt.att.GetSignature() == nil {
@@ -247,35 +246,9 @@ func TestKV_Unaggregated_UnaggregatedAttestationsBySlotIndex(t *testing.T) {
 	}
 	ctx := context.Background()
 	returned := cache.UnaggregatedAttestationsBySlotIndex(ctx, 1, 1)
-	assert.DeepEqual(t, []*ethpb.Attestation{att1}, returned)
+	assert.DeepEqual(t, []ethpb.Att{att1}, returned)
 	returned = cache.UnaggregatedAttestationsBySlotIndex(ctx, 1, 2)
-	assert.DeepEqual(t, []*ethpb.Attestation{att2}, returned)
+	assert.DeepEqual(t, []ethpb.Att{att2}, returned)
 	returned = cache.UnaggregatedAttestationsBySlotIndex(ctx, 2, 1)
-	assert.DeepEqual(t, []*ethpb.Attestation{att3}, returned)
-}
-
-func TestKV_Unaggregated_UnaggregatedAttestationsBySlotIndexElectra(t *testing.T) {
-	cache := NewAttCaches()
-
-	committeeBits := primitives.NewAttestationCommitteeBits()
-	committeeBits.SetBitAt(1, true)
-	att1 := util.HydrateAttestationElectra(&ethpb.AttestationElectra{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b101}, CommitteeBits: committeeBits})
-	committeeBits = primitives.NewAttestationCommitteeBits()
-	committeeBits.SetBitAt(2, true)
-	att2 := util.HydrateAttestationElectra(&ethpb.AttestationElectra{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b110}, CommitteeBits: committeeBits})
-	committeeBits = primitives.NewAttestationCommitteeBits()
-	committeeBits.SetBitAt(1, true)
-	att3 := util.HydrateAttestationElectra(&ethpb.AttestationElectra{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b110}, CommitteeBits: committeeBits})
-	atts := []*ethpb.AttestationElectra{att1, att2, att3}
-
-	for _, att := range atts {
-		require.NoError(t, cache.SaveUnaggregatedAttestation(att))
-	}
-	ctx := context.Background()
-	returned := cache.UnaggregatedAttestationsBySlotIndexElectra(ctx, 1, 1)
-	assert.DeepEqual(t, []*ethpb.AttestationElectra{att1}, returned)
-	returned = cache.UnaggregatedAttestationsBySlotIndexElectra(ctx, 1, 2)
-	assert.DeepEqual(t, []*ethpb.AttestationElectra{att2}, returned)
-	returned = cache.UnaggregatedAttestationsBySlotIndexElectra(ctx, 2, 1)
-	assert.DeepEqual(t, []*ethpb.AttestationElectra{att3}, returned)
+	assert.DeepEqual(t, []ethpb.Att{att3}, returned)
 }

beacon-chain/operations/attestations/pool.go

@@ -18,8 +18,7 @@ type Pool interface {
 	SaveAggregatedAttestation(att ethpb.Att) error
 	SaveAggregatedAttestations(atts []ethpb.Att) error
 	AggregatedAttestations() []ethpb.Att
-	AggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []*ethpb.Attestation
-	AggregatedAttestationsBySlotIndexElectra(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []*ethpb.AttestationElectra
+	AggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []ethpb.Att
 	DeleteAggregatedAttestation(att ethpb.Att) error
 	HasAggregatedAttestation(att ethpb.Att) (bool, error)
 	AggregatedAttestationCount() int
@@ -27,8 +26,7 @@ type Pool interface {
 	SaveUnaggregatedAttestation(att ethpb.Att) error
 	SaveUnaggregatedAttestations(atts []ethpb.Att) error
 	UnaggregatedAttestations() ([]ethpb.Att, error)
-	UnaggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []*ethpb.Attestation
-	UnaggregatedAttestationsBySlotIndexElectra(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []*ethpb.AttestationElectra
+	UnaggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []ethpb.Att
 	DeleteUnaggregatedAttestation(att ethpb.Att) error
 	DeleteSeenUnaggregatedAttestations() (int, error)
 	UnaggregatedAttestationCount() int

beacon-chain/operations/attestations/prepare_forkchoice.go

@@ -3,14 +3,14 @@ package attestations
 import (
 	"bytes"
 	"context"
+	"errors"
 	"time"
 
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	attaggregation "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation/aggregation/attestations"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"go.opencensus.io/trace"
@@ -67,7 +67,7 @@ func (s *Service) batchForkChoiceAtts(ctx context.Context) error {
 	atts := append(s.cfg.Pool.AggregatedAttestations(), s.cfg.Pool.BlockAttestations()...)
 	atts = append(atts, s.cfg.Pool.ForkchoiceAttestations()...)
 
-	attsByVerAndDataRoot := make(map[attestation.Id][]ethpb.Att, len(atts))
+	attsByDataRoot := make(map[[32]byte][]ethpb.Att, len(atts))
 
 	// Consolidate attestations by aggregating them by similar data root.
 	for _, att := range atts {
@@ -79,14 +79,14 @@ func (s *Service) batchForkChoiceAtts(ctx context.Context) error {
 			continue
 		}
 
-		id, err := attestation.NewId(att, attestation.Data)
+		attDataRoot, err := att.GetData().HashTreeRoot()
 		if err != nil {
-			return errors.Wrap(err, "could not create attestation ID")
+			return err
 		}
-		attsByVerAndDataRoot[id] = append(attsByVerAndDataRoot[id], att)
+		attsByDataRoot[attDataRoot] = append(attsByDataRoot[attDataRoot], att)
 	}
 
-	for _, atts := range attsByVerAndDataRoot {
+	for _, atts := range attsByDataRoot {
 		if err := s.aggregateAndSaveForkChoiceAtts(atts); err != nil {
 			return err
 		}
@@ -119,12 +119,12 @@ func (s *Service) aggregateAndSaveForkChoiceAtts(atts []ethpb.Att) error {
 // This checks if the attestation has previously been aggregated for fork choice
 // return true if yes, false if no.
 func (s *Service) seen(att ethpb.Att) (bool, error) {
-	id, err := attestation.NewId(att, attestation.Data)
+	attRoot, err := hash.Proto(att.GetData())
 	if err != nil {
-		return false, errors.Wrap(err, "could not create attestation ID")
+		return false, err
 	}
 	incomingBits := att.GetAggregationBits()
-	savedBits, ok := s.forkChoiceProcessedAtts.Get(id)
+	savedBits, ok := s.forkChoiceProcessedRoots.Get(attRoot)
 	if ok {
 		savedBitlist, ok := savedBits.(bitfield.Bitlist)
 		if !ok {
@@ -149,6 +149,6 @@ func (s *Service) seen(att ethpb.Att) (bool, error) {
 		}
 	}
 
-	s.forkChoiceProcessedAtts.Add(id, incomingBits)
+	s.forkChoiceProcessedRoots.Add(attRoot, incomingBits)
 	return false, nil
 }

beacon-chain/operations/attestations/service.go

@@ -13,16 +13,16 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 )
 
-var forkChoiceProcessedAttsSize = 1 << 16
+var forkChoiceProcessedRootsSize = 1 << 16
 
 // Service of attestation pool operations.
 type Service struct {
-	cfg                     *Config
-	ctx                     context.Context
-	cancel                  context.CancelFunc
-	err                     error
-	forkChoiceProcessedAtts *lru.Cache
-	genesisTime             uint64
+	cfg                      *Config
+	ctx                      context.Context
+	cancel                   context.CancelFunc
+	err                      error
+	forkChoiceProcessedRoots *lru.Cache
+	genesisTime              uint64
 }
 
 // Config options for the service.
@@ -35,7 +35,7 @@ type Config struct {
 // NewService instantiates a new attestation pool service instance that will
 // be registered into a running beacon node.
 func NewService(ctx context.Context, cfg *Config) (*Service, error) {
-	cache := lruwrpr.New(forkChoiceProcessedAttsSize)
+	cache := lruwrpr.New(forkChoiceProcessedRootsSize)
 
 	if cfg.pruneInterval == 0 {
 		// Prune expired attestations from the pool every slot interval.
@@ -44,10 +44,10 @@ func NewService(ctx context.Context, cfg *Config) (*Service, error) {
 
 	ctx, cancel := context.WithCancel(ctx)
 	return &Service{
-		cfg:                     cfg,
-		ctx:                     ctx,
-		cancel:                  cancel,
-		forkChoiceProcessedAtts: cache,
+		cfg:                      cfg,
+		ctx:                      ctx,
+		cancel:                   cancel,
+		forkChoiceProcessedRoots: cache,
 	}, nil
 }
 

beacon-chain/p2p/connection_gater_test.go

@@ -336,7 +336,7 @@ func TestService_InterceptAddrDial_Public(t *testing.T) {
 		}),
 	}
 	var err error
-	// test with public filter
+	//test with public filter
 	cidr := "public"
 	ip := "212.67.10.122"
 	s.addrFilter, err = configureFilter(&Config{AllowListCIDR: cidr})
@@ -348,7 +348,7 @@ func TestService_InterceptAddrDial_Public(t *testing.T) {
 		t.Errorf("Expected multiaddress with ip %s to not be rejected since we allow public addresses", ip)
 	}
 
-	ip = "192.168.1.0" // this is private and should fail
+	ip = "192.168.1.0" //this is private and should fail
 	multiAddress, err = ma.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ip, 3000))
 	require.NoError(t, err)
 	valid = s.InterceptAddrDial("", multiAddress)
@@ -356,7 +356,7 @@ func TestService_InterceptAddrDial_Public(t *testing.T) {
 		t.Errorf("Expected multiaddress with ip %s to be rejected since we are only allowing public addresses", ip)
 	}
 
-	// test with public allow filter, with a public address added to the deny list
+	//test with public allow filter, with a public address added to the deny list
 	invalidPublicIp := "212.67.10.122"
 	validPublicIp := "91.65.69.69"
 	s.addrFilter, err = configureFilter(&Config{AllowListCIDR: "public", DenyListCIDR: []string{"212.67.89.112/16"}})
@@ -384,7 +384,7 @@ func TestService_InterceptAddrDial_Private(t *testing.T) {
 		}),
 	}
 	var err error
-	// test with private filter
+	//test with private filter
 	cidr := "private"
 	s.addrFilter, err = configureFilter(&Config{DenyListCIDR: []string{cidr}})
 	require.NoError(t, err)
@@ -413,7 +413,7 @@ func TestService_InterceptAddrDial_AllowPrivate(t *testing.T) {
 		}),
 	}
 	var err error
-	// test with private filter
+	//test with private filter
 	cidr := "private"
 	s.addrFilter, err = configureFilter(&Config{AllowListCIDR: cidr})
 	require.NoError(t, err)
@@ -442,7 +442,7 @@ func TestService_InterceptAddrDial_DenyPublic(t *testing.T) {
 		}),
 	}
 	var err error
-	// test with private filter
+	//test with private filter
 	cidr := "public"
 	s.addrFilter, err = configureFilter(&Config{DenyListCIDR: []string{cidr}})
 	require.NoError(t, err)
@@ -471,7 +471,7 @@ func TestService_InterceptAddrDial_AllowConflict(t *testing.T) {
 		}),
 	}
 	var err error
-	// test with private filter
+	//test with private filter
 	cidr := "public"
 	s.addrFilter, err = configureFilter(&Config{DenyListCIDR: []string{cidr, "192.168.0.0/16"}})
 	require.NoError(t, err)

beacon-chain/p2p/discovery.go

@@ -51,7 +51,7 @@ func (quicProtocol) ENRKey() string { return "quic" }
 // with the tracked committee ids for the epoch, allowing our node
 // to be dynamically discoverable by others given our tracked committee ids.
 func (s *Service) RefreshENR() {
-	// return early if discv5 isn't running
+	// return early if discv5 isnt running
 	if s.dv5Listener == nil || !s.isInitialized() {
 		return
 	}

beacon-chain/p2p/encoder/ssz_test.go

@@ -112,6 +112,8 @@ type HistoricalSummaryCreator struct{}
 type BlobIdentifierCreator struct{}
 type PendingBalanceDepositCreator struct{}
 type PendingPartialWithdrawalCreator struct{}
+type ConsolidationCreator struct{}
+type SignedConsolidationCreator struct{}
 type PendingConsolidationCreator struct{}
 type StatusCreator struct{}
 type BeaconBlocksByRangeRequestCreator struct{}
@@ -285,6 +287,10 @@ func (PendingBalanceDepositCreator) Create() MarshalerProtoMessage {
 func (PendingPartialWithdrawalCreator) Create() MarshalerProtoMessage {
 	return &ethpb.PendingPartialWithdrawal{}
 }
+func (ConsolidationCreator) Create() MarshalerProtoMessage { return &ethpb.Consolidation{} }
+func (SignedConsolidationCreator) Create() MarshalerProtoMessage {
+	return &ethpb.SignedConsolidation{}
+}
 func (PendingConsolidationCreator) Create() MarshalerProtoMessage {
 	return &ethpb.PendingConsolidation{}
 }
@@ -399,6 +405,8 @@ var creators = []MarshalerProtoCreator{
 	BlobIdentifierCreator{},
 	PendingBalanceDepositCreator{},
 	PendingPartialWithdrawalCreator{},
+	ConsolidationCreator{},
+	SignedConsolidationCreator{},
 	PendingConsolidationCreator{},
 	StatusCreator{},
 	BeaconBlocksByRangeRequestCreator{},
@@ -545,6 +553,26 @@ func TestSszNetworkEncoder_RoundTrip_SignedVoluntaryExit(t *testing.T) {
 	assertProtoMessagesEqual(t, decoded, msg)
 }
 
+func TestSszNetworkEncoder_RoundTrip_Consolidation(t *testing.T) {
+	e := &encoder.SszNetworkEncoder{}
+	buf := new(bytes.Buffer)
+
+	data := []byte("\xc800")
+	msg := &ethpb.Consolidation{}
+
+	if err := proto.Unmarshal(data, msg); err != nil {
+		t.Logf("Failed to unmarshal: %v", err)
+		return
+	}
+
+	_, err := e.EncodeGossip(buf, msg)
+	require.NoError(t, err)
+	decoded := &ethpb.Consolidation{}
+	require.NoError(t, e.DecodeGossip(buf.Bytes(), decoded))
+
+	assertProtoMessagesEqual(t, decoded, msg)
+}
+
 func TestSszNetworkEncoder_RoundTrip(t *testing.T) {
 	e := &encoder.SszNetworkEncoder{}
 	testRoundTripWithLength(t, e)

beacon-chain/p2p/gossip_topic_mappings.go

@@ -27,8 +27,7 @@ var gossipTopicMappings = map[string]proto.Message{
 // GossipTopicMappings is a function to return the assigned data type
 // versioned by epoch.
 func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
-	switch topic {
-	case BlockSubnetTopicFormat:
+	if topic == BlockSubnetTopicFormat {
 		if epoch >= params.BeaconConfig().ElectraForkEpoch {
 			return &ethpb.SignedBeaconBlockElectra{}
 		}
@@ -44,25 +43,8 @@ func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
 		if epoch >= params.BeaconConfig().AltairForkEpoch {
 			return &ethpb.SignedBeaconBlockAltair{}
 		}
-		return gossipTopicMappings[topic]
-	case AttestationSubnetTopicFormat:
-		if epoch >= params.BeaconConfig().ElectraForkEpoch {
-			return &ethpb.AttestationElectra{}
-		}
-		return gossipTopicMappings[topic]
-	case AttesterSlashingSubnetTopicFormat:
-		if epoch >= params.BeaconConfig().ElectraForkEpoch {
-			return &ethpb.AttesterSlashingElectra{}
-		}
-		return gossipTopicMappings[topic]
-	case AggregateAndProofSubnetTopicFormat:
-		if epoch >= params.BeaconConfig().ElectraForkEpoch {
-			return &ethpb.SignedAggregateAttestationAndProofElectra{}
-		}
-		return gossipTopicMappings[topic]
-	default:
-		return gossipTopicMappings[topic]
 	}
+	return gossipTopicMappings[topic]
 }
 
 // AllTopics returns all topics stored in our
@@ -93,7 +75,4 @@ func init() {
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockDeneb{})] = BlockSubnetTopicFormat
 	// Specially handle Electra objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockElectra{})] = BlockSubnetTopicFormat
-	GossipTypeMapping[reflect.TypeOf(&ethpb.AttestationElectra{})] = AttestationSubnetTopicFormat
-	GossipTypeMapping[reflect.TypeOf(&ethpb.AttesterSlashingElectra{})] = AttesterSlashingSubnetTopicFormat
-	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedAggregateAttestationAndProofElectra{})] = AggregateAndProofSubnetTopicFormat
 }

beacon-chain/p2p/gossip_topic_mappings_test.go

@@ -22,20 +22,20 @@ func TestMappingHasNoDuplicates(t *testing.T) {
 	}
 }
 
-func TestGossipTopicMappings_CorrectType(t *testing.T) {
+func TestGossipTopicMappings_CorrectBlockType(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	bCfg := params.BeaconConfig().Copy()
 	altairForkEpoch := primitives.Epoch(100)
-	bellatrixForkEpoch := primitives.Epoch(200)
-	capellaForkEpoch := primitives.Epoch(300)
-	denebForkEpoch := primitives.Epoch(400)
-	electraForkEpoch := primitives.Epoch(500)
+	BellatrixForkEpoch := primitives.Epoch(200)
+	CapellaForkEpoch := primitives.Epoch(300)
+	DenebForkEpoch := primitives.Epoch(400)
+	ElectraForkEpoch := primitives.Epoch(500)
 
 	bCfg.AltairForkEpoch = altairForkEpoch
-	bCfg.BellatrixForkEpoch = bellatrixForkEpoch
-	bCfg.CapellaForkEpoch = capellaForkEpoch
-	bCfg.DenebForkEpoch = denebForkEpoch
-	bCfg.ElectraForkEpoch = electraForkEpoch
+	bCfg.BellatrixForkEpoch = BellatrixForkEpoch
+	bCfg.CapellaForkEpoch = CapellaForkEpoch
+	bCfg.DenebForkEpoch = DenebForkEpoch
+	bCfg.ElectraForkEpoch = ElectraForkEpoch
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.AltairForkVersion)] = primitives.Epoch(100)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.BellatrixForkVersion)] = primitives.Epoch(200)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.CapellaForkVersion)] = primitives.Epoch(300)
@@ -47,83 +47,29 @@ func TestGossipTopicMappings_CorrectType(t *testing.T) {
 	pMessage := GossipTopicMappings(BlockSubnetTopicFormat, 0)
 	_, ok := pMessage.(*ethpb.SignedBeaconBlock)
 	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, 0)
-	_, ok = pMessage.(*ethpb.Attestation)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, 0)
-	_, ok = pMessage.(*ethpb.AttesterSlashing)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, 0)
-	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
-	assert.Equal(t, true, ok)
 
 	// Altair Fork
 	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, altairForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockAltair)
 	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, altairForkEpoch)
-	_, ok = pMessage.(*ethpb.Attestation)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, altairForkEpoch)
-	_, ok = pMessage.(*ethpb.AttesterSlashing)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, altairForkEpoch)
-	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
-	assert.Equal(t, true, ok)
 
 	// Bellatrix Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, bellatrixForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, BellatrixForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockBellatrix)
 	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, bellatrixForkEpoch)
-	_, ok = pMessage.(*ethpb.Attestation)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, bellatrixForkEpoch)
-	_, ok = pMessage.(*ethpb.AttesterSlashing)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, bellatrixForkEpoch)
-	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
-	assert.Equal(t, true, ok)
 
 	// Capella Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, capellaForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, CapellaForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockCapella)
 	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, capellaForkEpoch)
-	_, ok = pMessage.(*ethpb.Attestation)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, capellaForkEpoch)
-	_, ok = pMessage.(*ethpb.AttesterSlashing)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, capellaForkEpoch)
-	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
-	assert.Equal(t, true, ok)
 
 	// Deneb Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, denebForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, DenebForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockDeneb)
 	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, denebForkEpoch)
-	_, ok = pMessage.(*ethpb.Attestation)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, denebForkEpoch)
-	_, ok = pMessage.(*ethpb.AttesterSlashing)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, denebForkEpoch)
-	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
-	assert.Equal(t, true, ok)
 
 	// Electra Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, electraForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, ElectraForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockElectra)
 	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, electraForkEpoch)
-	_, ok = pMessage.(*ethpb.AttestationElectra)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, electraForkEpoch)
-	_, ok = pMessage.(*ethpb.AttesterSlashingElectra)
-	assert.Equal(t, true, ok)
-	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, electraForkEpoch)
-	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProofElectra)
-	assert.Equal(t, true, ok)
 }

beacon-chain/p2p/iterator.go

@@ -2,10 +2,14 @@ package p2p
 
 import (
 	"context"
+	"runtime"
+	"time"
 
 	"github.com/ethereum/go-ethereum/p2p/enode"
 )
 
+const backOffCounter = 50
+
 // filterNodes wraps an iterator such that Next only returns nodes for which
 // the 'check' function returns true. This custom implementation also
 // checks for context deadlines so that in the event the parent context has
@@ -24,13 +28,21 @@ type filterIter struct {
 // Next looks up for the next valid node according to our
 // filter criteria.
 func (f *filterIter) Next() bool {
+	lookupCounter := 0
 	for f.Iterator.Next() {
+		// Do not excessively perform lookups if we constantly receive non-viable peers.
+		if lookupCounter > backOffCounter {
+			lookupCounter = 0
+			runtime.Gosched()
+			time.Sleep(pollingPeriod)
+		}
 		if f.Context.Err() != nil {
 			return false
 		}
 		if f.check(f.Node()) {
 			return true
 		}
+		lookupCounter++
 	}
 	return false
 }

beacon-chain/p2p/subnets_test.go

@@ -81,7 +81,7 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
 	bootNodeENR := bootListener.Self().String()
 
 	// Create 3 nodes, each subscribed to a different subnet.
-	// Each node is connected to the bootstrap node.
+	// Each node is connected to the boostrap node.
 	services := make([]*Service, 0, 3)
 
 	for i := 1; i <= 3; i++ {

beacon-chain/p2p/types/BUILD.bazel

@@ -43,7 +43,6 @@ go_test(
         "//consensus-types/primitives: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",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",

beacon-chain/p2p/types/object_mapping.go

@@ -26,13 +26,7 @@ var (
 	BlockMap map[[4]byte]func() (interfaces.ReadOnlySignedBeaconBlock, error)
 	// MetaDataMap maps the fork-version to the underlying data type for that
 	// particular fork period.
-	MetaDataMap map[[4]byte]func() (metadata.Metadata, error)
-	// AttestationMap maps the fork-version to the underlying data type for that
-	// particular fork period.
-	AttestationMap map[[4]byte]func() (ethpb.Att, error)
-	// AggregateAttestationMap maps the fork-version to the underlying data type for that
-	// particular fork period.
-	AggregateAttestationMap map[[4]byte]func() (ethpb.SignedAggregateAttAndProof, error)
+	MetaDataMap map[[4]byte]func() metadata.Metadata
 )
 
 // InitializeDataMaps initializes all the relevant object maps. This function is called to
@@ -73,68 +67,24 @@ func InitializeDataMaps() {
 	}
 
 	// Reset our metadata map.
-	MetaDataMap = map[[4]byte]func() (metadata.Metadata, error){
-		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (metadata.Metadata, error) {
-			return wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{}), nil
+	MetaDataMap = map[[4]byte]func() metadata.Metadata{
+		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() metadata.Metadata {
+			return wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{})
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (metadata.Metadata, error) {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() metadata.Metadata {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (metadata.Metadata, error) {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() metadata.Metadata {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (metadata.Metadata, error) {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() metadata.Metadata {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (metadata.Metadata, error) {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() metadata.Metadata {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (metadata.Metadata, error) {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
-		},
-	}
-
-	// Reset our attestation map.
-	AttestationMap = map[[4]byte]func() (ethpb.Att, error){
-		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (ethpb.Att, error) {
-			return &ethpb.Attestation{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (ethpb.Att, error) {
-			return &ethpb.Attestation{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (ethpb.Att, error) {
-			return &ethpb.Attestation{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (ethpb.Att, error) {
-			return &ethpb.Attestation{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (ethpb.Att, error) {
-			return &ethpb.Attestation{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.Att, error) {
-			return &ethpb.AttestationElectra{}, nil
-		},
-	}
-
-	// Reset our aggregate attestation map.
-	AggregateAttestationMap = map[[4]byte]func() (ethpb.SignedAggregateAttAndProof, error){
-		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
-			return &ethpb.SignedAggregateAttestationAndProof{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
-			return &ethpb.SignedAggregateAttestationAndProof{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
-			return &ethpb.SignedAggregateAttestationAndProof{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
-			return &ethpb.SignedAggregateAttestationAndProof{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
-			return &ethpb.SignedAggregateAttestationAndProof{}, nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
-			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() metadata.Metadata {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
 		},
 	}
 }

beacon-chain/p2p/types/object_mapping_test.go

@@ -5,9 +5,7 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
 func TestInitializeDataMaps(t *testing.T) {
@@ -46,36 +44,8 @@ func TestInitializeDataMaps(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			tt.action()
-			bFunc, ok := BlockMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			_, ok := BlockMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
 			assert.Equal(t, tt.exists, ok)
-			if tt.exists {
-				b, err := bFunc()
-				require.NoError(t, err)
-				generic, err := b.PbGenericBlock()
-				require.NoError(t, err)
-				assert.NotNil(t, generic.GetPhase0())
-			}
-			mdFunc, ok := MetaDataMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
-			if tt.exists {
-				md, err := mdFunc()
-				require.NoError(t, err)
-				assert.NotNil(t, md.MetadataObjV0())
-			}
-			assert.Equal(t, tt.exists, ok)
-			attFunc, ok := AttestationMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
-			if tt.exists {
-				att, err := attFunc()
-				require.NoError(t, err)
-				assert.Equal(t, version.Phase0, att.Version())
-			}
-			assert.Equal(t, tt.exists, ok)
-			aggFunc, ok := AggregateAttestationMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
-			assert.Equal(t, tt.exists, ok)
-			if tt.exists {
-				agg, err := aggFunc()
-				require.NoError(t, err)
-				assert.Equal(t, version.Phase0, agg.Version())
-			}
 		})
 	}
 }

beacon-chain/rpc/BUILD.bazel

@@ -10,8 +10,6 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
-        "//api:go_default_library",
-        "//api/server/middleware:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/builder:go_default_library",
         "//beacon-chain/cache:go_default_library",

beacon-chain/rpc/eth/config/handlers_test.go

@@ -149,8 +149,7 @@ func TestGetSpec(t *testing.T) {
 	config.MaxAttestationsElectra = 89
 	config.MaxWithdrawalRequestsPerPayload = 90
 	config.MaxCellsInExtendedMatrix = 91
-	config.UnsetDepositRequestsStartIndex = 92
-	config.MaxDepositRequestsPerPayload = 93
+	config.UnsetDepositReceiptsStartIndex = 92
 
 	var dbp [4]byte
 	copy(dbp[:], []byte{'0', '0', '0', '1'})
@@ -193,7 +192,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)
 
-	assert.Equal(t, 155, len(data))
+	assert.Equal(t, 154, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -526,10 +525,8 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "90", v)
 			case "MAX_CELLS_IN_EXTENDED_MATRIX":
 				assert.Equal(t, "91", v)
-			case "UNSET_DEPOSIT_REQUESTS_START_INDEX":
+			case "UNSET_DEPOSIT_RECEIPTS_START_INDEX":
 				assert.Equal(t, "92", v)
-			case "MAX_DEPOSIT_REQUESTS_PER_PAYLOAD":
-				assert.Equal(t, "93", v)
 			default:
 				t.Errorf("Incorrect key: %s", k)
 			}

beacon-chain/rpc/eth/validator/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "handlers.go",
         "handlers_block.go",
-        "log.go",
         "server.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/validator",

beacon-chain/rpc/eth/validator/handlers.go

@@ -31,7 +31,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -592,7 +592,7 @@ func (s *Server) PrepareBeaconProposer(w http.ResponseWriter, r *http.Request) {
 	if len(validatorIndices) == 0 {
 		return
 	}
-	log.WithFields(logrus.Fields{
+	log.WithFields(log.Fields{
 		"validatorIndices": validatorIndices,
 	}).Info("Updated fee recipient addresses")
 }

beacon-chain/rpc/eth/validator/handlers_block.go

@@ -220,9 +220,8 @@ func (s *Server) produceBlockV3(ctx context.Context, w http.ResponseWriter, r *h
 
 	consensusBlockValue, httpError := getConsensusBlockValue(ctx, s.BlockRewardFetcher, v1alpha1resp.Block)
 	if httpError != nil {
-		log.WithError(httpError).Debug("Failed to get consensus block value")
-		// Having the consensus block value is not critical to block production
-		consensusBlockValue = ""
+		httputil.WriteError(w, httpError)
+		return
 	}
 
 	w.Header().Set(api.ExecutionPayloadBlindedHeader, fmt.Sprintf("%v", v1alpha1resp.IsBlinded))
@@ -298,7 +297,7 @@ func getConsensusBlockValue(ctx context.Context, blockRewardsFetcher rewards.Blo
 		}
 	}
 	if bb.Version() == version.Phase0 {
-		// Getting the block value for Phase 0 is very hard, so we ignore it
+		// ignore for phase 0
 		return "", nil
 	}
 	// Get consensus payload value which is the same as the total from the block rewards api.

beacon-chain/rpc/eth/validator/log.go

@@ -1,5 +0,0 @@
-package validator
-
-import "github.com/sirupsen/logrus"
-
-var log = logrus.WithField("prefix", "beacon-api")

beacon-chain/rpc/prysm/v1alpha1/validator/aggregator.go

@@ -2,6 +2,7 @@ package validator
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
@@ -99,8 +100,12 @@ func (vs *Server) SubmitAggregateSelectionProof(ctx context.Context, req *ethpb.
 			best = aggregatedAtt
 		}
 	}
+	att, ok := best.(*ethpb.Attestation)
+	if !ok {
+		return nil, fmt.Errorf("best attestation has wrong type (expected %T, got %T)", &ethpb.Attestation{}, best)
+	}
 	a := &ethpb.AggregateAttestationAndProof{
-		Aggregate:       best,
+		Aggregate:       att,
 		SelectionProof:  req.SlotSignature,
 		AggregatorIndex: validatorIndex,
 	}

beacon-chain/rpc/prysm/v1alpha1/validator/construct_generic_block_test.go

@@ -25,6 +25,16 @@ func TestConstructGenericBeaconBlock(t *testing.T) {
 	// Test for Electra version
 	t.Run("electra block", func(t *testing.T) {
 		eb := util.NewBeaconBlockElectra()
+		eb.Block.Body.Consolidations = []*eth.SignedConsolidation{
+			{
+				Signature: make([]byte, 96),
+				Message: &eth.Consolidation{
+					SourceIndex: 1,
+					TargetIndex: 2,
+					Epoch:       3,
+				},
+			},
+		}
 		b, err := blocks.NewSignedBeaconBlock(eb)
 		require.NoError(t, err)
 		r1, err := eb.Block.HashTreeRoot()

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go

@@ -592,6 +592,16 @@ func TestServer_GetBeaconBlock_Electra(t *testing.T) {
 			ParentRoot: parentRoot[:],
 			StateRoot:  genesis.Block.StateRoot,
 			Body: &ethpb.BeaconBlockBodyElectra{
+				Consolidations: []*ethpb.SignedConsolidation{
+					{
+						Message: &ethpb.Consolidation{
+							SourceIndex: 1,
+							TargetIndex: 2,
+							Epoch:       3,
+						},
+						Signature: bytesutil.PadTo([]byte("sig"), 96),
+					},
+				},
 				RandaoReveal:  genesis.Block.Body.RandaoReveal,
 				Graffiti:      genesis.Block.Body.Graffiti,
 				Eth1Data:      genesis.Block.Body.Eth1Data,
@@ -620,40 +630,32 @@ func TestServer_GetBeaconBlock_Electra(t *testing.T) {
 	require.NoError(t, err)
 	timeStamp, err := slots.ToTime(beaconState.GenesisTime(), electraSlot+1)
 	require.NoError(t, err)
-	dr := []*enginev1.DepositRequest{{
+	dr := []*enginev1.DepositReceipt{{
 		Pubkey:                bytesutil.PadTo(privKeys[0].PublicKey().Marshal(), 48),
 		WithdrawalCredentials: bytesutil.PadTo([]byte("wc"), 32),
 		Amount:                123,
 		Signature:             bytesutil.PadTo([]byte("sig"), 96),
 		Index:                 456,
 	}}
-	wr := []*enginev1.WithdrawalRequest{
+	wr := []*enginev1.ExecutionLayerWithdrawalRequest{
 		{
 			SourceAddress:   bytesutil.PadTo([]byte("sa"), 20),
 			ValidatorPubkey: bytesutil.PadTo(privKeys[1].PublicKey().Marshal(), 48),
 			Amount:          789,
 		},
 	}
-	cr := []*enginev1.ConsolidationRequest{
-		{
-			SourceAddress: bytesutil.PadTo([]byte("sa"), 20),
-			SourcePubkey:  bytesutil.PadTo(privKeys[1].PublicKey().Marshal(), 48),
-			TargetPubkey:  bytesutil.PadTo(privKeys[2].PublicKey().Marshal(), 48),
-		},
-	}
 	payload := &enginev1.ExecutionPayloadElectra{
-		Timestamp:             uint64(timeStamp.Unix()),
-		ParentHash:            make([]byte, fieldparams.RootLength),
-		FeeRecipient:          make([]byte, fieldparams.FeeRecipientLength),
-		StateRoot:             make([]byte, fieldparams.RootLength),
-		ReceiptsRoot:          make([]byte, fieldparams.RootLength),
-		LogsBloom:             make([]byte, fieldparams.LogsBloomLength),
-		PrevRandao:            random,
-		BaseFeePerGas:         make([]byte, fieldparams.RootLength),
-		BlockHash:             make([]byte, fieldparams.RootLength),
-		DepositRequests:       dr,
-		WithdrawalRequests:    wr,
-		ConsolidationRequests: cr,
+		Timestamp:          uint64(timeStamp.Unix()),
+		ParentHash:         make([]byte, fieldparams.RootLength),
+		FeeRecipient:       make([]byte, fieldparams.FeeRecipientLength),
+		StateRoot:          make([]byte, fieldparams.RootLength),
+		ReceiptsRoot:       make([]byte, fieldparams.RootLength),
+		LogsBloom:          make([]byte, fieldparams.LogsBloomLength),
+		PrevRandao:         random,
+		BaseFeePerGas:      make([]byte, fieldparams.RootLength),
+		BlockHash:          make([]byte, fieldparams.RootLength),
+		DepositReceipts:    dr,
+		WithdrawalRequests: wr,
 	}
 
 	proposerServer := getProposerServer(db, beaconState, parentRoot[:])
@@ -678,7 +680,7 @@ func TestServer_GetBeaconBlock_Electra(t *testing.T) {
 	got, err := proposerServer.GetBeaconBlock(ctx, req)
 	require.NoError(t, err)
 	p := got.GetElectra().Block.Body.ExecutionPayload
-	require.DeepEqual(t, dr, p.DepositRequests)
+	require.DeepEqual(t, dr, p.DepositReceipts)
 	require.DeepEqual(t, wr, p.WithdrawalRequests)
 }
 

beacon-chain/rpc/prysm/v1alpha1/validator/server.go

@@ -100,13 +100,14 @@ func (vs *Server) WaitForActivation(req *ethpb.ValidatorActivationRequest, strea
 	}
 
 	waitTime := time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second
-	ticker := time.NewTicker(waitTime)
-	defer ticker.Stop()
+	timer := time.NewTimer(waitTime)
+	defer timer.Stop()
 
 	for {
+		timer.Reset(waitTime)
 		select {
 		// Pinging every slot for activation.
-		case <-ticker.C:
+		case <-timer.C:
 			activeValidatorExists, validatorStatuses, err := vs.activationStatus(stream.Context(), req.PublicKeys)
 			if err != nil {
 				return status.Errorf(codes.Internal, "Could not fetch validator status: %v", err)