wip fixing tests

.bazelrc

@@ -6,12 +6,6 @@ import %workspace%/build/bazelrc/debug.bazelrc
 import %workspace%/build/bazelrc/hermetic-cc.bazelrc
 import %workspace%/build/bazelrc/performance.bazelrc
 
-# hermetic_cc_toolchain v3.0.1 required changes.
-common --enable_platform_specific_config
-build:linux --sandbox_add_mount_pair=/tmp
-build:macos --sandbox_add_mount_pair=/var/tmp
-build:windows --sandbox_add_mount_pair=C:\Temp
-
 # E2E run with debug gotag
 test:e2e --define gotags=debug
 

.bazelversion

@@ -1 +1 @@
-7.1.0
+7.0.0

WORKSPACE

@@ -16,14 +16,12 @@ load("@rules_pkg//:deps.bzl", "rules_pkg_dependencies")
 
 rules_pkg_dependencies()
 
-HERMETIC_CC_TOOLCHAIN_VERSION = "v3.0.1"
-
 http_archive(
     name = "hermetic_cc_toolchain",
-    sha256 = "3bc6ec127622fdceb4129cb06b6f7ab098c4d539124dde96a6318e7c32a53f7a",
+    sha256 = "973ab22945b921ef45b8e1d6ce01ca7ce1b8a462167449a36e297438c4ec2755",
+    strip_prefix = "hermetic_cc_toolchain-5098046bccc15d2962f3cc8e7e53d6a2a26072dc",
     urls = [
-        "https://mirror.bazel.build/github.com/uber/hermetic_cc_toolchain/releases/download/{0}/hermetic_cc_toolchain-{0}.tar.gz".format(HERMETIC_CC_TOOLCHAIN_VERSION),
-        "https://github.com/uber/hermetic_cc_toolchain/releases/download/{0}/hermetic_cc_toolchain-{0}.tar.gz".format(HERMETIC_CC_TOOLCHAIN_VERSION),
+        "https://github.com/uber/hermetic_cc_toolchain/archive/5098046bccc15d2962f3cc8e7e53d6a2a26072dc.tar.gz",  # 2023-06-28
     ],
 )
 
@@ -83,10 +81,10 @@ bazel_skylib_workspace()
 
 http_archive(
     name = "bazel_gazelle",
-    integrity = "sha256-MpOL2hbmcABjA1R5Bj2dJMYO2o15/Uc5Vj9Q0zHLMgk=",
+    sha256 = "d3fa66a39028e97d76f9e2db8f1b0c11c099e8e01bf363a923074784e451f809",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.35.0/bazel-gazelle-v0.35.0.tar.gz",
-        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.35.0/bazel-gazelle-v0.35.0.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.33.0/bazel-gazelle-v0.33.0.tar.gz",
+        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.33.0/bazel-gazelle-v0.33.0.tar.gz",
     ],
 )
 
@@ -153,13 +151,17 @@ http_archive(
         # Expose internals of go_test for custom build transitions.
         "//third_party:io_bazel_rules_go_test.patch",
     ],
-    sha256 = "80a98277ad1311dacd837f9b16db62887702e9f1d1c4c9f796d0121a46c8e184",
+    sha256 = "d6ab6b57e48c09523e93050f13698f708428cfd5e619252e369d377af6597707",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.46.0/rules_go-v0.46.0.zip",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.46.0/rules_go-v0.46.0.zip",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.43.0/rules_go-v0.43.0.zip",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.43.0/rules_go-v0.43.0.zip",
     ],
 )
 
+load("//:distroless_deps.bzl", "distroless_deps")
+
+distroless_deps()
+
 # Override default import in rules_go with special patch until
 # https://github.com/gogo/protobuf/pull/582 is merged.
 git_repository(
@@ -198,14 +200,10 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.21.8",
+    go_version = "1.21.6",
     nogo = "@//:nogo",
 )
 
-load("//:distroless_deps.bzl", "distroless_deps")
-
-distroless_deps()
-
 http_archive(
     name = "io_kubernetes_build",
     sha256 = "b84fbd1173acee9d02a7d3698ad269fdf4f7aa081e9cecd40e012ad0ad8cfa2a",

api/client/beacon/BUILD.bazel

@@ -6,14 +6,11 @@ go_library(
         "checkpoint.go",
         "client.go",
         "doc.go",
-        "health.go",
-        "log.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/api/client/beacon",
     visibility = ["//visibility:public"],
     deps = [
         "//api/client:go_default_library",
-        "//api/client/beacon/iface:go_default_library",
         "//api/server:go_default_library",
         "//api/server/structs:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -39,12 +36,10 @@ go_test(
     srcs = [
         "checkpoint_test.go",
         "client_test.go",
-        "health_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
         "//api/client:go_default_library",
-        "//api/client/beacon/testing:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -58,6 +53,5 @@ go_test(
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
-        "@org_uber_go_mock//gomock:go_default_library",
     ],
 )

api/client/beacon/checkpoint.go

@@ -17,7 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/io/file"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 	"golang.org/x/mod/semver"
 )
 
@@ -74,12 +74,7 @@ func DownloadFinalizedData(ctx context.Context, client *Client) (*OriginData, er
 	if err != nil {
 		return nil, errors.Wrap(err, "error detecting chain config for finalized state")
 	}
-
-	log.WithFields(logrus.Fields{
-		"name": vu.Config.ConfigName,
-		"fork": version.String(vu.Fork),
-	}).Info("Detected supported config in remote finalized state")
-
+	log.Printf("detected supported config in remote finalized state, name=%s, fork=%s", vu.Config.ConfigName, version.String(vu.Fork))
 	s, err := vu.UnmarshalBeaconState(sb)
 	if err != nil {
 		return nil, errors.Wrap(err, "error unmarshaling finalized state to correct version")

api/client/beacon/client.go

@@ -22,7 +22,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/network/forks"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 )
 
 const (
@@ -309,7 +309,7 @@ func (c *Client) SubmitChangeBLStoExecution(ctx context.Context, request []*stru
 		}
 		for _, failure := range errorJson.Failures {
 			w := request[failure.Index].Message
-			log.WithFields(logrus.Fields{
+			log.WithFields(log.Fields{
 				"validatorIndex":    w.ValidatorIndex,
 				"withdrawalAddress": w.ToExecutionAddress,
 			}).Error(failure.Message)
@@ -341,9 +341,9 @@ type forkScheduleResponse struct {
 func (fsr *forkScheduleResponse) OrderedForkSchedule() (forks.OrderedSchedule, error) {
 	ofs := make(forks.OrderedSchedule, 0)
 	for _, d := range fsr.Data {
-		epoch, err := strconv.ParseUint(d.Epoch, 10, 64)
+		epoch, err := strconv.Atoi(d.Epoch)
 		if err != nil {
-			return nil, errors.Wrapf(err, "error parsing epoch %s", d.Epoch)
+			return nil, err
 		}
 		vSlice, err := hexutil.Decode(d.CurrentVersion)
 		if err != nil {
@@ -355,7 +355,7 @@ func (fsr *forkScheduleResponse) OrderedForkSchedule() (forks.OrderedSchedule, e
 		version := bytesutil.ToBytes4(vSlice)
 		ofs = append(ofs, forks.ForkScheduleEntry{
 			Version: version,
-			Epoch:   primitives.Epoch(epoch),
+			Epoch:   primitives.Epoch(uint64(epoch)),
 		})
 	}
 	sort.Sort(ofs)

api/client/beacon/health.go

@@ -1,55 +0,0 @@
-package beacon
-
-import (
-	"context"
-	"sync"
-
-	"github.com/prysmaticlabs/prysm/v5/api/client/beacon/iface"
-)
-
-type NodeHealthTracker struct {
-	isHealthy  *bool
-	healthChan chan bool
-	node       iface.HealthNode
-	sync.RWMutex
-}
-
-func NewNodeHealthTracker(node iface.HealthNode) *NodeHealthTracker {
-	return &NodeHealthTracker{
-		node:       node,
-		healthChan: make(chan bool, 1),
-	}
-}
-
-// HealthUpdates provides a read-only channel for health updates.
-func (n *NodeHealthTracker) HealthUpdates() <-chan bool {
-	return n.healthChan
-}
-
-func (n *NodeHealthTracker) IsHealthy() bool {
-	n.RLock()
-	defer n.RUnlock()
-	if n.isHealthy == nil {
-		return false
-	}
-	return *n.isHealthy
-}
-
-func (n *NodeHealthTracker) CheckHealth(ctx context.Context) bool {
-	n.RLock()
-	newStatus := n.node.IsHealthy(ctx)
-	if n.isHealthy == nil {
-		n.isHealthy = &newStatus
-	}
-	isStatusChanged := newStatus != *n.isHealthy
-	n.RUnlock()
-
-	if isStatusChanged {
-		n.Lock()
-		// Double-check the condition to ensure it hasn't changed since the first check.
-		n.isHealthy = &newStatus
-		n.Unlock() // It's better to unlock as soon as the protected section is over.
-		n.healthChan <- newStatus
-	}
-	return newStatus
-}

api/client/beacon/health_test.go

@@ -1,118 +0,0 @@
-package beacon
-
-import (
-	"context"
-	"sync"
-	"testing"
-
-	healthTesting "github.com/prysmaticlabs/prysm/v5/api/client/beacon/testing"
-	"go.uber.org/mock/gomock"
-)
-
-func TestNodeHealth_IsHealthy(t *testing.T) {
-	tests := []struct {
-		name      string
-		isHealthy bool
-		want      bool
-	}{
-		{"initially healthy", true, true},
-		{"initially unhealthy", false, false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			n := &NodeHealthTracker{
-				isHealthy:  &tt.isHealthy,
-				healthChan: make(chan bool, 1),
-			}
-			if got := n.IsHealthy(); got != tt.want {
-				t.Errorf("IsHealthy() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestNodeHealth_UpdateNodeHealth(t *testing.T) {
-	tests := []struct {
-		name       string
-		initial    bool // Initial health status
-		newStatus  bool // Status to update to
-		shouldSend bool // Should a message be sent through the channel
-	}{
-		{"healthy to unhealthy", true, false, true},
-		{"unhealthy to healthy", false, true, true},
-		{"remain healthy", true, true, false},
-		{"remain unhealthy", false, false, false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ctrl := gomock.NewController(t)
-			defer ctrl.Finish()
-			client := healthTesting.NewMockHealthClient(ctrl)
-			client.EXPECT().IsHealthy(gomock.Any()).Return(tt.newStatus)
-			n := &NodeHealthTracker{
-				isHealthy:  &tt.initial,
-				node:       client,
-				healthChan: make(chan bool, 1),
-			}
-
-			s := n.CheckHealth(context.Background())
-			// Check if health status was updated
-			if s != tt.newStatus {
-				t.Errorf("UpdateNodeHealth() failed to update isHealthy from %v to %v", tt.initial, tt.newStatus)
-			}
-
-			select {
-			case status := <-n.HealthUpdates():
-				if !tt.shouldSend {
-					t.Errorf("UpdateNodeHealth() unexpectedly sent status %v to HealthCh", status)
-				} else if status != tt.newStatus {
-					t.Errorf("UpdateNodeHealth() sent wrong status %v, want %v", status, tt.newStatus)
-				}
-			default:
-				if tt.shouldSend {
-					t.Error("UpdateNodeHealth() did not send any status to HealthCh when expected")
-				}
-			}
-		})
-	}
-}
-
-func TestNodeHealth_Concurrency(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	client := healthTesting.NewMockHealthClient(ctrl)
-	n := NewNodeHealthTracker(client)
-	var wg sync.WaitGroup
-
-	// 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
-	for i := 0; i < numGoroutines; i++ {
-		go func() {
-			defer wg.Done()
-			client.EXPECT().IsHealthy(gomock.Any()).Return(false)
-			n.CheckHealth(context.Background())
-			client.EXPECT().IsHealthy(gomock.Any()).Return(true)
-			n.CheckHealth(context.Background())
-		}()
-	}
-
-	// Concurrently read health status
-	for i := 0; i < numGoroutines; i++ {
-		go func() {
-			defer wg.Done()
-			_ = n.IsHealthy() // Just read the value
-		}()
-	}
-
-	wg.Wait() // Wait for all goroutines to finish
-}

api/client/beacon/iface/BUILD.bazel

@@ -1,8 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["health.go"],
-    importpath = "github.com/prysmaticlabs/prysm/v5/api/client/beacon/iface",
-    visibility = ["//visibility:public"],
-)

api/client/beacon/iface/health.go

@@ -1,13 +0,0 @@
-package iface
-
-import "context"
-
-type HealthTracker interface {
-	HealthUpdates() <-chan bool
-	IsHealthy() bool
-	CheckHealth(ctx context.Context) bool
-}
-
-type HealthNode interface {
-	IsHealthy(ctx context.Context) bool
-}

api/client/beacon/log.go

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

api/client/beacon/testing/BUILD.bazel

@@ -1,12 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["mock.go"],
-    importpath = "github.com/prysmaticlabs/prysm/v5/api/client/beacon/testing",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//api/client/beacon/iface:go_default_library",
-        "@org_uber_go_mock//gomock:go_default_library",
-    ],
-)

api/client/beacon/testing/mock.go

@@ -1,53 +0,0 @@
-package testing
-
-import (
-	"context"
-	"reflect"
-
-	"github.com/prysmaticlabs/prysm/v5/api/client/beacon/iface"
-	"go.uber.org/mock/gomock"
-)
-
-var (
-	_ = iface.HealthNode(&MockHealthClient{})
-)
-
-// MockHealthClient is a mock of HealthClient interface.
-type MockHealthClient struct {
-	ctrl     *gomock.Controller
-	recorder *MockHealthClientMockRecorder
-}
-
-// MockHealthClientMockRecorder is the mock recorder for MockHealthClient.
-type MockHealthClientMockRecorder struct {
-	mock *MockHealthClient
-}
-
-// IsHealthy mocks base method.
-func (m *MockHealthClient) IsHealthy(arg0 context.Context) bool {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IsHealthy", arg0)
-	ret0, ok := ret[0].(bool)
-	if !ok {
-		return false
-	}
-	return ret0
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockHealthClient) EXPECT() *MockHealthClientMockRecorder {
-	return m.recorder
-}
-
-// IsHealthy indicates an expected call of IsHealthy.
-func (mr *MockHealthClientMockRecorder) IsHealthy(arg0 any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHealthy", reflect.TypeOf((*MockHealthClient)(nil).IsHealthy), arg0)
-}
-
-// NewMockHealthClient creates a new mock instance.
-func NewMockHealthClient(ctrl *gomock.Controller) *MockHealthClient {
-	mock := &MockHealthClient{ctrl: ctrl}
-	mock.recorder = &MockHealthClientMockRecorder{mock}
-	return mock
-}

api/client/builder/client.go

@@ -304,8 +304,6 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 		}
 		versionOpt := func(r *http.Request) {
 			r.Header.Add("Eth-Consensus-Version", version.String(version.Bellatrix))
-			r.Header.Set("Content-Type", "application/json")
-			r.Header.Set("Accept", "application/json")
 		}
 		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
 
@@ -343,8 +341,6 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 		}
 		versionOpt := func(r *http.Request) {
 			r.Header.Add("Eth-Consensus-Version", version.String(version.Capella))
-			r.Header.Set("Content-Type", "application/json")
-			r.Header.Set("Accept", "application/json")
 		}
 		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
 
@@ -383,8 +379,6 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 
 		versionOpt := func(r *http.Request) {
 			r.Header.Add("Eth-Consensus-Version", version.String(version.Deneb))
-			r.Header.Set("Content-Type", "application/json")
-			r.Header.Set("Accept", "application/json")
 		}
 		rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
 		if err != nil {

api/client/builder/client_test.go

@@ -321,8 +321,6 @@ func TestSubmitBlindedBlock(t *testing.T) {
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
 				require.Equal(t, "bellatrix", r.Header.Get("Eth-Consensus-Version"))
-				require.Equal(t, "application/json", r.Header.Get("Content-Type"))
-				require.Equal(t, "application/json", r.Header.Get("Accept"))
 				return &http.Response{
 					StatusCode: http.StatusOK,
 					Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayload)),
@@ -349,8 +347,6 @@ func TestSubmitBlindedBlock(t *testing.T) {
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
 				require.Equal(t, "capella", r.Header.Get("Eth-Consensus-Version"))
-				require.Equal(t, "application/json", r.Header.Get("Content-Type"))
-				require.Equal(t, "application/json", r.Header.Get("Accept"))
 				return &http.Response{
 					StatusCode: http.StatusOK,
 					Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayloadCapella)),
@@ -380,8 +376,6 @@ func TestSubmitBlindedBlock(t *testing.T) {
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
 				require.Equal(t, "deneb", r.Header.Get("Eth-Consensus-Version"))
-				require.Equal(t, "application/json", r.Header.Get("Content-Type"))
-				require.Equal(t, "application/json", r.Header.Get("Accept"))
 				var req structs.SignedBlindedBeaconBlockDeneb
 				err := json.NewDecoder(r.Body).Decode(&req)
 				require.NoError(t, err)

api/client/errors.go

@@ -21,9 +21,6 @@ var ErrNotFound = errors.Wrap(ErrNotOK, "recv 404 NotFound response from API")
 // ErrInvalidNodeVersion indicates that the /eth/v1/node/version API response format was not recognized.
 var ErrInvalidNodeVersion = errors.New("invalid node version response")
 
-// ErrConnectionIssue represents a connection problem.
-var ErrConnectionIssue = errors.New("could not connect")
-
 // Non200Err is a function that parses an HTTP response to handle responses that are not 200 with a formatted error.
 func Non200Err(response *http.Response) error {
 	bodyBytes, err := io.ReadAll(response.Body)

api/client/event/BUILD.bazel

@@ -1,24 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["event_stream.go"],
-    importpath = "github.com/prysmaticlabs/prysm/v5/api/client/event",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//api:go_default_library",
-        "//api/client:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["event_stream_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//testing/require:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)

api/client/event/event_stream.go

@@ -1,148 +0,0 @@
-package event
-
-import (
-	"bufio"
-	"context"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/api"
-	"github.com/prysmaticlabs/prysm/v5/api/client"
-	log "github.com/sirupsen/logrus"
-)
-
-const (
-	EventHead                        = "head"
-	EventBlock                       = "block"
-	EventAttestation                 = "attestation"
-	EventVoluntaryExit               = "voluntary_exit"
-	EventBlsToExecutionChange        = "bls_to_execution_change"
-	EventProposerSlashing            = "proposer_slashing"
-	EventAttesterSlashing            = "attester_slashing"
-	EventFinalizedCheckpoint         = "finalized_checkpoint"
-	EventChainReorg                  = "chain_reorg"
-	EventContributionAndProof        = "contribution_and_proof"
-	EventLightClientFinalityUpdate   = "light_client_finality_update"
-	EventLightClientOptimisticUpdate = "light_client_optimistic_update"
-	EventPayloadAttributes           = "payload_attributes"
-	EventBlobSidecar                 = "blob_sidecar"
-	EventError                       = "error"
-	EventConnectionError             = "connection_error"
-)
-
-var (
-	_ = EventStreamClient(&EventStream{})
-)
-
-var DefaultEventTopics = []string{EventHead}
-
-type EventStreamClient interface {
-	Subscribe(eventsChannel chan<- *Event)
-}
-
-type Event struct {
-	EventType string
-	Data      []byte
-}
-
-// EventStream is responsible for subscribing to the Beacon API events endpoint
-// and dispatching received events to subscribers.
-type EventStream struct {
-	ctx        context.Context
-	httpClient *http.Client
-	host       string
-	topics     []string
-}
-
-func NewEventStream(ctx context.Context, httpClient *http.Client, host string, topics []string) (*EventStream, error) {
-	// Check if the host is a valid URL
-	_, err := url.ParseRequestURI(host)
-	if err != nil {
-		return nil, err
-	}
-	if len(topics) == 0 {
-		return nil, errors.New("no topics provided")
-	}
-
-	return &EventStream{
-		ctx:        ctx,
-		httpClient: httpClient,
-		host:       host,
-		topics:     topics,
-	}, nil
-}
-
-func (h *EventStream) Subscribe(eventsChannel chan<- *Event) {
-	allTopics := strings.Join(h.topics, ",")
-	log.WithField("topics", allTopics).Info("Listening to Beacon API events")
-	fullUrl := h.host + "/eth/v1/events?topics=" + allTopics
-	req, err := http.NewRequestWithContext(h.ctx, http.MethodGet, fullUrl, nil)
-	if err != nil {
-		eventsChannel <- &Event{
-			EventType: EventConnectionError,
-			Data:      []byte(errors.Wrap(err, "failed to create HTTP request").Error()),
-		}
-	}
-	req.Header.Set("Accept", api.EventStreamMediaType)
-	req.Header.Set("Connection", api.KeepAlive)
-	resp, err := h.httpClient.Do(req)
-	if err != nil {
-		eventsChannel <- &Event{
-			EventType: EventConnectionError,
-			Data:      []byte(errors.Wrap(err, client.ErrConnectionIssue.Error()).Error()),
-		}
-	}
-
-	defer func() {
-		if closeErr := resp.Body.Close(); closeErr != nil {
-			log.WithError(closeErr).Error("Failed to close events response body")
-		}
-	}()
-	// Create a new scanner to read lines from the response body
-	scanner := bufio.NewScanner(resp.Body)
-
-	var eventType, data string // Variables to store event type and data
-
-	// Iterate over lines of the event stream
-	for scanner.Scan() {
-		select {
-		case <-h.ctx.Done():
-			log.Info("Context canceled, stopping event stream")
-			close(eventsChannel)
-			return
-		default:
-			line := scanner.Text() // TODO(13730): scanner does not handle /r and does not fully adhere to https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
-			// Handle the event based on your specific format
-			if line == "" {
-				// Empty line indicates the end of an event
-				if eventType != "" && data != "" {
-					// Process the event when both eventType and data are set
-					eventsChannel <- &Event{EventType: eventType, Data: []byte(data)}
-				}
-
-				// Reset eventType and data for the next event
-				eventType, data = "", ""
-				continue
-			}
-			et, ok := strings.CutPrefix(line, "event: ")
-			if ok {
-				// Extract event type from the "event" field
-				eventType = et
-			}
-			d, ok := strings.CutPrefix(line, "data: ")
-			if ok {
-				// Extract data from the "data" field
-				data = d
-			}
-		}
-	}
-
-	if err := scanner.Err(); err != nil {
-		eventsChannel <- &Event{
-			EventType: EventConnectionError,
-			Data:      []byte(errors.Wrap(err, errors.Wrap(client.ErrConnectionIssue, "scanner failed").Error()).Error()),
-		}
-	}
-}

api/client/event/event_stream_test.go

@@ -1,80 +0,0 @@
-package event
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	log "github.com/sirupsen/logrus"
-)
-
-func TestNewEventStream(t *testing.T) {
-	validURL := "http://localhost:8080"
-	invalidURL := "://invalid"
-	topics := []string{"topic1", "topic2"}
-
-	tests := []struct {
-		name    string
-		host    string
-		topics  []string
-		wantErr bool
-	}{
-		{"Valid input", validURL, topics, false},
-		{"Invalid URL", invalidURL, topics, true},
-		{"No topics", validURL, []string{}, true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := NewEventStream(context.Background(), &http.Client{}, tt.host, tt.topics)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("NewEventStream() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestEventStream(t *testing.T) {
-	mux := http.NewServeMux()
-	mux.HandleFunc("/eth/v1/events", func(w http.ResponseWriter, r *http.Request) {
-		flusher, ok := w.(http.Flusher)
-		require.Equal(t, true, ok)
-		for i := 1; i <= 2; i++ {
-			_, err := fmt.Fprintf(w, "event: head\ndata: data%d\n\n", i)
-			require.NoError(t, err)
-			flusher.Flush()                    // Trigger flush to simulate streaming data
-			time.Sleep(100 * time.Millisecond) // Simulate delay between events
-		}
-	})
-	server := httptest.NewServer(mux)
-	defer server.Close()
-
-	topics := []string{"head"}
-	eventsChannel := make(chan *Event, 1)
-	stream, err := NewEventStream(context.Background(), http.DefaultClient, server.URL, topics)
-	require.NoError(t, err)
-	go stream.Subscribe(eventsChannel)
-
-	// Collect events
-	var events []*Event
-
-	for len(events) != 2 {
-		select {
-		case event := <-eventsChannel:
-			log.Info(event)
-			events = append(events, event)
-		}
-	}
-
-	// Assertions to verify the events content
-	expectedData := []string{"data1", "data2"}
-	for i, event := range events {
-		if string(event.Data) != expectedData[i] {
-			t.Errorf("Expected event data %q, got %q", expectedData[i], string(event.Data))
-		}
-	}
-}

beacon-chain/blockchain/chain_info.go

@@ -563,9 +563,3 @@ func (s *Service) RecentBlockSlot(root [32]byte) (primitives.Slot, error) {
 func (s *Service) inRegularSync() bool {
 	return s.cfg.SyncChecker.Synced()
 }
-
-// validating returns true if the beacon is tracking some validators that have
-// registered for proposing.
-func (s *Service) validating() bool {
-	return s.cfg.TrackedValidatorsCache.Validating()
-}

beacon-chain/blockchain/process_attestation_helpers.go

@@ -18,63 +18,17 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
-func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) state.ReadOnlyBeaconState {
-	headEpoch := slots.ToEpoch(s.HeadSlot())
-	if c.Epoch < headEpoch {
-		return nil
-	}
-	if !s.cfg.ForkChoiceStore.IsCanonical([32]byte(c.Root)) {
-		return nil
-	}
-	if c.Epoch == headEpoch {
-		targetSlot, err := s.cfg.ForkChoiceStore.Slot([32]byte(c.Root))
-		if err != nil {
-			return nil
-		}
-		if slots.ToEpoch(targetSlot)+1 < headEpoch {
-			return nil
-		}
-		st, err := s.HeadStateReadOnly(ctx)
-		if err != nil {
-			return nil
-		}
-		return st
-	}
-	slot, err := slots.EpochStart(c.Epoch)
-	if err != nil {
-		return nil
-	}
-	// Try if we have already set the checkpoint cache
-	epochKey := strconv.FormatUint(uint64(c.Epoch), 10 /* base 10 */)
-	lock := async.NewMultilock(string(c.Root) + epochKey)
-	lock.Lock()
-	defer lock.Unlock()
-	cachedState, err := s.checkpointStateCache.StateByCheckpoint(c)
-	if err != nil {
-		return nil
-	}
-	if cachedState != nil && !cachedState.IsNil() {
-		return cachedState
-	}
-	st, err := s.HeadState(ctx)
-	if err != nil {
-		return nil
-	}
-	st, err = transition.ProcessSlotsUsingNextSlotCache(ctx, st, c.Root, slot)
-	if err != nil {
-		return nil
-	}
-	if err := s.checkpointStateCache.AddCheckpointState(c, st); err != nil {
-		return nil
-	}
-	return st
-}
-
 // getAttPreState retrieves the att pre state by either from the cache or the DB.
 func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (state.ReadOnlyBeaconState, error) {
 	// If the attestation is recent and canonical we can use the head state to compute the shuffling.
-	if st := s.getRecentPreState(ctx, c); st != nil {
-		return st, nil
+	headEpoch := slots.ToEpoch(s.HeadSlot())
+	if c.Epoch == headEpoch {
+		targetSlot, err := s.cfg.ForkChoiceStore.Slot([32]byte(c.Root))
+		if err == nil && slots.ToEpoch(targetSlot)+1 >= headEpoch {
+			if s.cfg.ForkChoiceStore.IsCanonical([32]byte(c.Root)) {
+				return s.HeadStateReadOnly(ctx)
+			}
+		}
 	}
 	// Use a multilock to allow scoped holding of a mutex by a checkpoint root + epoch
 	// allowing us to behave smarter in terms of how this function is used concurrently.

beacon-chain/blockchain/process_attestation_test.go

@@ -146,28 +146,6 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, service.OnAttestation(ctx, att[0], 0))
 }
 
-func TestService_GetRecentPreState(t *testing.T) {
-	service, _ := minimalTestService(t)
-	ctx := context.Background()
-
-	s, err := util.NewBeaconState()
-	require.NoError(t, err)
-	ckRoot := bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)
-	cp0 := &ethpb.Checkpoint{Epoch: 0, Root: ckRoot}
-	err = s.SetFinalizedCheckpoint(cp0)
-	require.NoError(t, err)
-
-	st, root, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
-	service.head = &head{
-		root:  [32]byte(ckRoot),
-		state: s,
-		slot:  31,
-	}
-	require.NotNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{Epoch: 1, Root: ckRoot}))
-}
-
 func TestService_GetAttPreState_Concurrency(t *testing.T) {
 	service, _ := minimalTestService(t)
 	ctx := context.Background()

beacon-chain/blockchain/receive_attestation.go

@@ -95,9 +95,7 @@ func (s *Service) spawnProcessAttestationsRoutine() {
 				return
 			case slotInterval := <-ticker.C():
 				if slotInterval.Interval > 0 {
-					if s.validating() {
-						s.UpdateHead(s.ctx, slotInterval.Slot+1)
-					}
+					s.UpdateHead(s.ctx, slotInterval.Slot+1)
 				} else {
 					s.cfg.ForkChoiceStore.Lock()
 					if err := s.cfg.ForkChoiceStore.NewSlot(s.ctx, slotInterval.Slot); err != nil {

beacon-chain/blockchain/receive_block.go

@@ -97,7 +97,6 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	eg, _ := errgroup.WithContext(ctx)
 	var postState state.BeaconState
 	eg.Go(func() error {
-		var err error
 		postState, err = s.validateStateTransition(ctx, preState, blockCopy)
 		if err != nil {
 			return errors.Wrap(err, "failed to validate consensus state transition function")
@@ -106,7 +105,6 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	})
 	var isValidPayload bool
 	eg.Go(func() error {
-		var err error
 		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, blockCopy, blockRoot)
 		if err != nil {
 			return errors.Wrap(err, "could not notify the engine of the new payload")

beacon-chain/blockchain/service.go

@@ -290,18 +290,10 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	if params.BeaconConfig().ConfigName != params.PraterName {
-		if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(s.ctx, &forkchoicetypes.Checkpoint{Epoch: justified.Epoch,
-			Root: bytesutil.ToBytes32(justified.Root)}); err != nil {
-			return errors.Wrap(err, "could not update forkchoice's justified checkpoint")
-		}
-	} else {
-		if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(s.ctx, &forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,
-			Root: bytesutil.ToBytes32(finalized.Root)}); err != nil {
-			return errors.Wrap(err, "could not update forkchoice's justified checkpoint")
-		}
+	if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(s.ctx, &forkchoicetypes.Checkpoint{Epoch: justified.Epoch,
+		Root: bytesutil.ToBytes32(justified.Root)}); err != nil {
+		return errors.Wrap(err, "could not update forkchoice's justified checkpoint")
 	}
-
 	if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,
 		Root: bytesutil.ToBytes32(finalized.Root)}); err != nil {
 		return errors.Wrap(err, "could not update forkchoice's finalized checkpoint")

beacon-chain/cache/depositsnapshot/deposit_cache_test.go

@@ -1189,3 +1189,11 @@ func BenchmarkDepositTree_HashTreeRootOldImplementation(b *testing.B) {
 		require.NoError(b, err)
 	}
 }
+
+func emptyEth1data() *ethpb.Eth1Data {
+	return &ethpb.Eth1Data{
+		DepositRoot:  make([]byte, 32),
+		DepositCount: 0,
+		BlockHash:    make([]byte, 32),
+	}
+}

beacon-chain/cache/depositsnapshot/deposit_tree.go

@@ -15,6 +15,8 @@ import (
 )
 
 var (
+	// ErrEmptyExecutionBlock occurs when the execution block is nil.
+	ErrEmptyExecutionBlock = errors.New("empty execution block")
 	// ErrInvalidSnapshotRoot occurs when the snapshot root does not match the calculated root.
 	ErrInvalidSnapshotRoot = errors.New("snapshot root is invalid")
 	// ErrInvalidDepositCount occurs when the value for mix in length is 0.

beacon-chain/cache/proposer_indices_type.go

@@ -1,9 +1,15 @@
 package cache
 
 import (
+	"errors"
+
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
+// ErrNotProposerIndices will be returned when a cache object is not a pointer to
+// a ProposerIndices struct.
+var ErrNotProposerIndices = errors.New("object is not a proposer indices struct")
+
 // ProposerIndices defines the cached struct for proposer indices.
 type ProposerIndices struct {
 	BlockRoot       [32]byte

beacon-chain/cache/skip_slot_cache.go

@@ -109,6 +109,10 @@ func (c *SkipSlotCache) Get(ctx context.Context, r [32]byte) (state.BeaconState,
 // MarkInProgress a request so that any other similar requests will block on
 // Get until MarkNotInProgress is called.
 func (c *SkipSlotCache) MarkInProgress(r [32]byte) error {
+	if c.disabled {
+		return nil
+	}
+
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
@@ -122,6 +126,10 @@ func (c *SkipSlotCache) MarkInProgress(r [32]byte) error {
 // MarkNotInProgress will release the lock on a given request. This should be
 // called after put.
 func (c *SkipSlotCache) MarkNotInProgress(r [32]byte) {
+	if c.disabled {
+		return
+	}
+
 	c.lock.Lock()
 	defer c.lock.Unlock()
 

beacon-chain/cache/skip_slot_cache_test.go

@@ -2,7 +2,6 @@ package cache_test
 
 import (
 	"context"
-	"sync"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
@@ -36,28 +35,3 @@ func TestSkipSlotCache_RoundTrip(t *testing.T) {
 	require.NoError(t, err)
 	assert.DeepEqual(t, res.ToProto(), s.ToProto(), "Expected equal protos to return from cache")
 }
-
-func TestSkipSlotCache_DisabledAndEnabled(t *testing.T) {
-	ctx := context.Background()
-	c := cache.NewSkipSlotCache()
-
-	r := [32]byte{'a'}
-	c.Disable()
-
-	require.NoError(t, c.MarkInProgress(r))
-
-	c.Enable()
-	wg := new(sync.WaitGroup)
-	wg.Add(1)
-	go func() {
-		// Get call will only terminate when
-		// it is not longer in progress.
-		obj, err := c.Get(ctx, r)
-		require.NoError(t, err)
-		require.IsNil(t, obj)
-		wg.Done()
-	}()
-
-	c.MarkNotInProgress(r)
-	wg.Wait()
-}

beacon-chain/cache/tracked_validators.go

@@ -41,9 +41,3 @@ func (t *TrackedValidatorsCache) Prune() {
 	defer t.Unlock()
 	t.trackedValidators = make(map[primitives.ValidatorIndex]TrackedValidator)
 }
-
-func (t *TrackedValidatorsCache) Validating() bool {
-	t.Lock()
-	defer t.Unlock()
-	return len(t.trackedValidators) > 0
-}

beacon-chain/core/epoch/precompute/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
     visibility = [
         "//beacon-chain:__subpackages__",
         "//testing/spectest:__subpackages__",
-        "//tools:__subpackages__",
     ],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",

beacon-chain/das/BUILD.bazel

@@ -40,6 +40,7 @@ go_test(
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",

beacon-chain/das/availability_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"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/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -113,6 +114,16 @@ func Test_commitmentsToCheck(t *testing.T) {
 	}
 }
 
+func daAlwaysSucceeds(_ [][]byte, _ []*ethpb.BlobSidecar) error {
+	return nil
+}
+
+type mockDA struct {
+	t   *testing.T
+	scs []blocks.ROBlob
+	err error
+}
+
 func TestLazilyPersistent_Missing(t *testing.T) {
 	ctx := context.Background()
 	store := filesystem.NewEphemeralBlobStorage(t)

beacon-chain/db/errors.go

@@ -19,6 +19,9 @@ var ErrNotFoundState = kv.ErrNotFoundState
 // ErrNotFoundOriginBlockRoot wraps ErrNotFound for an error specific to the origin block root.
 var ErrNotFoundOriginBlockRoot = kv.ErrNotFoundOriginBlockRoot
 
+// ErrNotFoundBackfillBlockRoot wraps ErrNotFound for an error specific to the backfill block root.
+var ErrNotFoundBackfillBlockRoot = kv.ErrNotFoundBackfillBlockRoot
+
 // IsNotFound allows callers to treat errors from a flat-file database, where the file record is missing,
 // as equivalent to db.ErrNotFound.
 func IsNotFound(err error) bool {

beacon-chain/db/filesystem/BUILD.bazel

@@ -44,6 +44,7 @@ go_test(
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_spf13_afero//:go_default_library",
     ],

beacon-chain/db/filesystem/blob_test.go

@@ -6,7 +6,9 @@ import (
 	"path"
 	"sync"
 	"testing"
+	"time"
 
+	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
@@ -127,6 +129,29 @@ func TestBlobStorage_SaveBlobData(t *testing.T) {
 }
 
 // pollUntil polls a condition function until it returns true or a timeout is reached.
+func pollUntil(t *testing.T, fs afero.Fs, expected int) error {
+	var remainingFolders []os.FileInfo
+	var err error
+	// Define the condition function for polling
+	conditionFunc := func() bool {
+		remainingFolders, err = afero.ReadDir(fs, ".")
+		require.NoError(t, err)
+		return len(remainingFolders) == expected
+	}
+
+	startTime := time.Now()
+	for {
+		if conditionFunc() {
+			break // Condition met, exit the loop
+		}
+		if time.Since(startTime) > 30*time.Second {
+			return errors.New("timeout")
+		}
+		time.Sleep(1 * time.Second) // Adjust the sleep interval as needed
+	}
+	require.Equal(t, expected, len(remainingFolders))
+	return nil
+}
 
 func TestBlobIndicesBounds(t *testing.T) {
 	fs, bs, err := NewEphemeralBlobStorageWithFs(t)

beacon-chain/db/kv/finalized_block_roots.go

@@ -201,19 +201,20 @@ func (s *Store) BackfillFinalizedIndex(ctx context.Context, blocks []blocks.ROBl
 			return err
 		}
 		encs[i-1] = penc
-	}
 
-	// The final element is the parent of finalizedChildRoot. This is checked inside the db transaction using
-	// the parent_root value stored in the index data for finalizedChildRoot.
-	lastIdx := len(blocks) - 1
-	fbrs[lastIdx].ChildRoot = finalizedChildRoot[:]
-	// Final element is complete, so it is pre-encoded like the others.
-	enc, err := encode(ctx, fbrs[lastIdx])
-	if err != nil {
-		tracing.AnnotateError(span, err)
-		return err
+		// The final element is the parent of finalizedChildRoot. This is checked inside the db transaction using
+		// the parent_root value stored in the index data for finalizedChildRoot.
+		if i == len(blocks)-1 {
+			fbrs[i].ChildRoot = finalizedChildRoot[:]
+			// Final element is complete, so it is pre-encoded like the others.
+			enc, err := encode(ctx, fbrs[i])
+			if err != nil {
+				tracing.AnnotateError(span, err)
+				return err
+			}
+			encs[i] = enc
+		}
 	}
-	encs[lastIdx] = enc
 
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(finalizedBlockRootsIndexBucket)

beacon-chain/db/kv/finalized_block_roots_test.go

@@ -237,50 +237,6 @@ func makeBlocksAltair(t *testing.T, startIdx, num uint64, previousRoot [32]byte)
 	return ifaceBlocks
 }
 
-func TestStore_BackfillFinalizedIndexSingle(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	// we're making 4 blocks so we can test an element without a valid child at the end
-	blks, err := consensusblocks.NewROBlockSlice(makeBlocks(t, 0, 4, [32]byte{}))
-	require.NoError(t, err)
-
-	// existing is the child that we'll set up in the index by hand to seed the index.
-	existing := blks[3]
-
-	// toUpdate is a single item update, emulating a backfill batch size of 1. it is the parent of `existing`.
-	toUpdate := blks[2]
-
-	// set up existing finalized block
-	ebpr := existing.Block().ParentRoot()
-	ebr := existing.Root()
-	ebf := &ethpb.FinalizedBlockRootContainer{
-		ParentRoot: ebpr[:],
-		ChildRoot:  make([]byte, 32), // we're bypassing validation to seed the db, so we don't need a valid child.
-	}
-	enc, err := encode(ctx, ebf)
-	require.NoError(t, err)
-	// writing this to the index outside of the validating function to seed the test.
-	err = db.db.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(finalizedBlockRootsIndexBucket)
-		return bkt.Put(ebr[:], enc)
-	})
-	require.NoError(t, err)
-
-	require.NoError(t, db.BackfillFinalizedIndex(ctx, []consensusblocks.ROBlock{toUpdate}, ebr))
-
-	// make sure that we still correctly validate descendents in the single item case.
-	noChild := blks[0] // will fail to update because we don't have blks[1] in the db.
-	// test wrong child param
-	require.ErrorIs(t, db.BackfillFinalizedIndex(ctx, []consensusblocks.ROBlock{noChild}, ebr), errNotConnectedToFinalized)
-	// test parent of child that isn't finalized
-	require.ErrorIs(t, db.BackfillFinalizedIndex(ctx, []consensusblocks.ROBlock{noChild}, blks[1].Root()), errFinalizedChildNotFound)
-
-	// now make it work by writing the missing block
-	require.NoError(t, db.BackfillFinalizedIndex(ctx, []consensusblocks.ROBlock{blks[1]}, blks[2].Root()))
-	// since blks[1] is now in the index, we should be able to update blks[0]
-	require.NoError(t, db.BackfillFinalizedIndex(ctx, []consensusblocks.ROBlock{blks[0]}, blks[1].Root()))
-}
-
 func TestStore_BackfillFinalizedIndex(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
@@ -296,23 +252,23 @@ func TestStore_BackfillFinalizedIndex(t *testing.T) {
 		ParentRoot: ebpr[:],
 		ChildRoot:  chldr[:],
 	}
+	disjoint := []consensusblocks.ROBlock{
+		blks[0],
+		blks[2],
+	}
 	enc, err := encode(ctx, ebf)
 	require.NoError(t, err)
 	err = db.db.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(finalizedBlockRootsIndexBucket)
 		return bkt.Put(ebr[:], enc)
 	})
-	require.NoError(t, err)
 
 	// reslice to remove the existing blocks
 	blks = blks[0:64]
 	// check the other error conditions with a descendent root that really doesn't exist
-
-	disjoint := []consensusblocks.ROBlock{
-		blks[0],
-		blks[2],
-	}
+	require.NoError(t, err)
 	require.ErrorIs(t, db.BackfillFinalizedIndex(ctx, disjoint, [32]byte{}), errIncorrectBlockParent)
+	require.NoError(t, err)
 	require.ErrorIs(t, errFinalizedChildNotFound, db.BackfillFinalizedIndex(ctx, blks, [32]byte{}))
 
 	// use the real root so that it succeeds

beacon-chain/db/kv/kv.go

@@ -137,7 +137,7 @@ func NewKVStore(ctx context.Context, dirPath string, opts ...KVStoreOption) (*St
 		}
 	}
 	datafile := StoreDatafilePath(dirPath)
-	log.WithField("path", datafile).Info("Opening Bolt DB")
+	log.Infof("Opening Bolt DB at %s", datafile)
 	boltDB, err := bolt.Open(
 		datafile,
 		params.BeaconIoConfig().ReadWritePermissions,

beacon-chain/db/kv/wss.go

@@ -11,7 +11,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/proto/dbval"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	"github.com/sirupsen/logrus"
 )
 
 // SaveOrigin loads an ssz serialized Block & BeaconState from an io.Reader
@@ -28,11 +27,7 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 		return fmt.Errorf("config mismatch, beacon node configured to connect to %s, detected state is for %s", params.BeaconConfig().ConfigName, cf.Config.ConfigName)
 	}
 
-	log.WithFields(logrus.Fields{
-		"configName": cf.Config.ConfigName,
-		"forkName":   version.String(cf.Fork),
-	}).Info("Detected supported config for state & block version")
-
+	log.Infof("detected supported config for state & block version, config name=%s, fork name=%s", cf.Config.ConfigName, version.String(cf.Fork))
 	state, err := cf.UnmarshalBeaconState(serState)
 	if err != nil {
 		return errors.Wrap(err, "failed to initialize origin state w/ bytes + config+fork")
@@ -62,13 +57,13 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 		return errors.Wrap(err, "unable to save backfill status data to db for checkpoint sync")
 	}
 
-	log.WithField("root", fmt.Sprintf("%#x", blockRoot)).Info("Saving checkpoint block to db")
+	log.Infof("saving checkpoint block to db, w/ root=%#x", blockRoot)
 	if err := s.SaveBlock(ctx, wblk); err != nil {
 		return errors.Wrap(err, "could not save checkpoint block")
 	}
 
 	// save state
-	log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Info("Calling SaveState")
+	log.Infof("calling SaveState w/ blockRoot=%x", blockRoot)
 	if err = s.SaveState(ctx, state, blockRoot); err != nil {
 		return errors.Wrap(err, "could not save state")
 	}

beacon-chain/execution/block_reader.go

@@ -110,7 +110,7 @@ func (s *Service) BlockByTimestamp(ctx context.Context, time uint64) (*types.Hea
 		return nil, errors.Wrap(errBlockTimeTooLate, fmt.Sprintf("(%d > %d)", time, latestBlkTime))
 	}
 	// Initialize a pointer to eth1 chain's history to start our search from.
-	cursorNum := new(big.Int).SetUint64(latestBlkHeight)
+	cursorNum := big.NewInt(0).SetUint64(latestBlkHeight)
 	cursorTime := latestBlkTime
 
 	var numOfBlocks uint64
@@ -156,15 +156,15 @@ func (s *Service) BlockByTimestamp(ctx context.Context, time uint64) (*types.Hea
 		return s.retrieveHeaderInfo(ctx, cursorNum.Uint64())
 	}
 	if cursorTime > time {
-		return s.findMaxTargetEth1Block(ctx, new(big.Int).SetUint64(estimatedBlk), time)
+		return s.findMaxTargetEth1Block(ctx, big.NewInt(0).SetUint64(estimatedBlk), time)
 	}
-	return s.findMinTargetEth1Block(ctx, new(big.Int).SetUint64(estimatedBlk), time)
+	return s.findMinTargetEth1Block(ctx, big.NewInt(0).SetUint64(estimatedBlk), time)
 }
 
 // Performs a search to find a target eth1 block which is earlier than or equal to the
 // target time. This method is used when head.time > targetTime
 func (s *Service) findMaxTargetEth1Block(ctx context.Context, upperBoundBlk *big.Int, targetTime uint64) (*types.HeaderInfo, error) {
-	for bn := upperBoundBlk; ; bn = new(big.Int).Sub(bn, big.NewInt(1)) {
+	for bn := upperBoundBlk; ; bn = big.NewInt(0).Sub(bn, big.NewInt(1)) {
 		if ctx.Err() != nil {
 			return nil, ctx.Err()
 		}
@@ -181,7 +181,7 @@ func (s *Service) findMaxTargetEth1Block(ctx context.Context, upperBoundBlk *big
 // Performs a search to find a target eth1 block which is just earlier than or equal to the
 // target time. This method is used when head.time < targetTime
 func (s *Service) findMinTargetEth1Block(ctx context.Context, lowerBoundBlk *big.Int, targetTime uint64) (*types.HeaderInfo, error) {
-	for bn := lowerBoundBlk; ; bn = new(big.Int).Add(bn, big.NewInt(1)) {
+	for bn := lowerBoundBlk; ; bn = big.NewInt(0).Add(bn, big.NewInt(1)) {
 		if ctx.Err() != nil {
 			return nil, ctx.Err()
 		}
@@ -201,7 +201,7 @@ func (s *Service) findMinTargetEth1Block(ctx context.Context, lowerBoundBlk *big
 }
 
 func (s *Service) retrieveHeaderInfo(ctx context.Context, bNum uint64) (*types.HeaderInfo, error) {
-	bn := new(big.Int).SetUint64(bNum)
+	bn := big.NewInt(0).SetUint64(bNum)
 	exists, info, err := s.headerCache.HeaderInfoByHeight(bn)
 	if err != nil {
 		return nil, err

beacon-chain/execution/errors.go

@@ -23,6 +23,9 @@ var (
 	ErrInvalidPayloadAttributes = errors.New("payload attributes are invalid / inconsistent")
 	// ErrUnknownPayloadStatus when the payload status is unknown.
 	ErrUnknownPayloadStatus = errors.New("unknown payload status")
+	// ErrConfigMismatch when the execution node's terminal total difficulty or
+	// terminal block hash received via the API mismatches Prysm's configuration value.
+	ErrConfigMismatch = errors.New("execution client configuration mismatch")
 	// ErrAcceptedSyncingPayloadStatus when the status of the payload is syncing or accepted.
 	ErrAcceptedSyncingPayloadStatus = errors.New("payload status is SYNCING or ACCEPTED")
 	// ErrInvalidPayloadStatus when the status of the payload is invalid.

beacon-chain/execution/log_processing.go

@@ -298,7 +298,9 @@ func (s *Service) processPastLogs(ctx context.Context) error {
 	// Start from the deployment block if our last requested block
 	// is behind it. This is as the deposit logs can only start from the
 	// block of the deployment of the deposit contract.
-	currentBlockNum = max(currentBlockNum, deploymentBlock)
+	if deploymentBlock > currentBlockNum {
+		currentBlockNum = deploymentBlock
+	}
 	// To store all blocks.
 	headersMap := make(map[uint64]*types.HeaderInfo)
 	rawLogCount, err := s.depositContractCaller.GetDepositCount(&bind.CallOpts{})
@@ -382,13 +384,15 @@ func (s *Service) processBlockInBatch(ctx context.Context, currentBlockNum uint6
 	end := currentBlockNum + batchSize
 	// Appropriately bound the request, as we do not
 	// want request blocks beyond the current follow distance.
-	end = min(end, latestFollowHeight)
+	if end > latestFollowHeight {
+		end = latestFollowHeight
+	}
 	query := ethereum.FilterQuery{
 		Addresses: []common.Address{
 			s.cfg.depositContractAddr,
 		},
-		FromBlock: new(big.Int).SetUint64(start),
-		ToBlock:   new(big.Int).SetUint64(end),
+		FromBlock: big.NewInt(0).SetUint64(start),
+		ToBlock:   big.NewInt(0).SetUint64(end),
 	}
 	remainingLogs := logCount - uint64(s.lastReceivedMerkleIndex+1)
 	// only change the end block if the remaining logs are below the required log limit.
@@ -396,7 +400,7 @@ func (s *Service) processBlockInBatch(ctx context.Context, currentBlockNum uint6
 	withinLimit := remainingLogs < depositLogRequestLimit
 	aboveFollowHeight := end >= latestFollowHeight
 	if withinLimit && aboveFollowHeight {
-		query.ToBlock = new(big.Int).SetUint64(latestFollowHeight)
+		query.ToBlock = big.NewInt(0).SetUint64(latestFollowHeight)
 		end = latestFollowHeight
 	}
 	logs, err := s.httpLogger.FilterLogs(ctx, query)
@@ -478,11 +482,11 @@ func (s *Service) requestBatchedHeadersAndLogs(ctx context.Context) error {
 	}
 	for i := s.latestEth1Data.LastRequestedBlock + 1; i <= requestedBlock; i++ {
 		// Cache eth1 block header here.
-		_, err := s.BlockHashByHeight(ctx, new(big.Int).SetUint64(i))
+		_, err := s.BlockHashByHeight(ctx, big.NewInt(0).SetUint64(i))
 		if err != nil {
 			return err
 		}
-		err = s.ProcessETH1Block(ctx, new(big.Int).SetUint64(i))
+		err = s.ProcessETH1Block(ctx, big.NewInt(0).SetUint64(i))
 		if err != nil {
 			return err
 		}

beacon-chain/execution/rpc_connection.go

@@ -77,7 +77,7 @@ func (s *Service) pollConnectionStatus(ctx context.Context) {
 			if currClient != nil {
 				currClient.Close()
 			}
-			log.WithField("endpoint", logs.MaskCredentialsLogging(s.cfg.currHttpEndpoint.Url)).Info("Connected to new endpoint")
+			log.Infof("Connected to new endpoint: %s", logs.MaskCredentialsLogging(s.cfg.currHttpEndpoint.Url))
 			return
 		case <-s.ctx.Done():
 			log.Debug("Received cancelled context,closing existing powchain service")

beacon-chain/execution/service.go

@@ -415,11 +415,14 @@ func (s *Service) batchRequestHeaders(startBlock, endBlock uint64) ([]*types.Hea
 	requestRange := (endBlock - startBlock) + 1
 	elems := make([]gethRPC.BatchElem, 0, requestRange)
 	headers := make([]*types.HeaderInfo, 0, requestRange)
+	if requestRange == 0 {
+		return headers, nil
+	}
 	for i := startBlock; i <= endBlock; i++ {
 		header := &types.HeaderInfo{}
 		elems = append(elems, gethRPC.BatchElem{
 			Method: "eth_getBlockByNumber",
-			Args:   []interface{}{hexutil.EncodeBig(new(big.Int).SetUint64(i)), false},
+			Args:   []interface{}{hexutil.EncodeBig(big.NewInt(0).SetUint64(i)), false},
 			Result: header,
 			Error:  error(nil),
 		})
@@ -672,7 +675,9 @@ func (s *Service) cacheBlockHeaders(start, end uint64) error {
 			// the allotted limit.
 			endReq -= 1
 		}
-		endReq = min(endReq, end)
+		if endReq > end {
+			endReq = end
+		}
 		// We call batchRequestHeaders for its header caching side-effect, so we don't need the return value.
 		_, err := s.batchRequestHeaders(startReq, endReq)
 		if err != nil {

beacon-chain/node/node.go

@@ -7,11 +7,9 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"net"
 	"os"
 	"os/signal"
 	"path/filepath"
-	"strconv"
 	"strings"
 	"sync"
 	"syscall"
@@ -129,16 +127,51 @@ type BeaconNode struct {
 // New creates a new node instance, sets up configuration options, and registers
 // every required service to the node.
 func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*BeaconNode, error) {
-	if err := configureBeacon(cliCtx); err != nil {
-		return nil, errors.Wrap(err, "could not set beacon configuration options")
+	if err := configureTracing(cliCtx); err != nil {
+		return nil, err
 	}
+	prereqs.WarnIfPlatformNotSupported(cliCtx.Context)
+	if hasNetworkFlag(cliCtx) && cliCtx.IsSet(cmd.ChainConfigFileFlag.Name) {
+		return nil, fmt.Errorf("%s cannot be passed concurrently with network flag", cmd.ChainConfigFileFlag.Name)
+	}
+	if err := features.ConfigureBeaconChain(cliCtx); err != nil {
+		return nil, err
+	}
+	if err := cmd.ConfigureBeaconChain(cliCtx); err != nil {
+		return nil, err
+	}
+	flags.ConfigureGlobalFlags(cliCtx)
+	if err := configureChainConfig(cliCtx); err != nil {
+		return nil, err
+	}
+	if err := configureHistoricalSlasher(cliCtx); err != nil {
+		return nil, err
+	}
+	err := configureBuilderCircuitBreaker(cliCtx)
+	if err != nil {
+		return nil, err
+	}
+	if err := configureSlotsPerArchivedPoint(cliCtx); err != nil {
+		return nil, err
+	}
+	if err := configureEth1Config(cliCtx); err != nil {
+		return nil, err
+	}
+	configureNetwork(cliCtx)
+	if err := configureInteropConfig(cliCtx); err != nil {
+		return nil, err
+	}
+	if err := configureExecutionSetting(cliCtx); err != nil {
+		return nil, err
+	}
+	configureFastSSZHashingAlgorithm()
 
 	// Initializes any forks here.
 	params.BeaconConfig().InitializeForkSchedule()
 
 	registry := runtime.NewServiceRegistry()
-	ctx := cliCtx.Context
 
+	ctx := cliCtx.Context
 	beacon := &BeaconNode{
 		cliCtx:                  cliCtx,
 		ctx:                     ctx,
@@ -158,10 +191,10 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		slasherBlockHeadersFeed: new(event.Feed),
 		slasherAttestationsFeed: new(event.Feed),
 		serviceFlagOpts:         &serviceFlagOpts{},
-		initialSyncComplete:     make(chan struct{}),
-		syncChecker:             &initialsync.SyncChecker{},
 	}
 
+	beacon.initialSyncComplete = make(chan struct{})
+	beacon.syncChecker = &initialsync.SyncChecker{}
 	for _, opt := range opts {
 		if err := opt(beacon); err != nil {
 			return nil, err
@@ -170,8 +203,8 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 
 	synchronizer := startup.NewClockSynchronizer()
 	beacon.clockWaiter = synchronizer
-	beacon.forkChoicer = doublylinkedtree.New()
 
+	beacon.forkChoicer = doublylinkedtree.New()
 	depositAddress, err := execution.DepositContractAddress()
 	if err != nil {
 		return nil, err
@@ -187,29 +220,112 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		beacon.BlobStorage = blobs
 	}
 
-	bfs, err := startBaseServices(cliCtx, beacon, depositAddress)
+	log.Debugln("Starting DB")
+	if err := beacon.startDB(cliCtx, depositAddress); err != nil {
+		return nil, err
+	}
+	beacon.BlobStorage.WarmCache()
+
+	log.Debugln("Starting Slashing DB")
+	if err := beacon.startSlasherDB(cliCtx); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering P2P Service")
+	if err := beacon.registerP2P(cliCtx); err != nil {
+		return nil, err
+	}
+
+	bfs, err := backfill.NewUpdater(ctx, beacon.db)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not start modules")
+		return nil, errors.Wrap(err, "backfill status initialization error")
+	}
+
+	log.Debugln("Starting State Gen")
+	if err := beacon.startStateGen(ctx, bfs, beacon.forkChoicer); err != nil {
+		if errors.Is(err, stategen.ErrNoGenesisBlock) {
+			log.Errorf("No genesis block/state is found. Prysm only provides a mainnet genesis "+
+				"state bundled in the application. You must provide the --%s or --%s flag to load "+
+				"a genesis block/state for this network.", "genesis-state", "genesis-beacon-api-url")
+		}
+		return nil, err
 	}
 
 	beacon.verifyInitWaiter = verification.NewInitializerWaiter(
 		beacon.clockWaiter, forkchoice.NewROForkChoice(beacon.forkChoicer), beacon.stateGen)
 
 	pa := peers.NewAssigner(beacon.fetchP2P().Peers(), beacon.forkChoicer)
-
-	beacon.BackfillOpts = append(
-		beacon.BackfillOpts,
-		backfill.WithVerifierWaiter(beacon.verifyInitWaiter),
-		backfill.WithInitSyncWaiter(initSyncWaiter(ctx, beacon.initialSyncComplete)),
-	)
-
+	beacon.BackfillOpts = append(beacon.BackfillOpts, backfill.WithVerifierWaiter(beacon.verifyInitWaiter),
+		backfill.WithInitSyncWaiter(initSyncWaiter(ctx, beacon.initialSyncComplete)))
 	bf, err := backfill.NewService(ctx, bfs, beacon.BlobStorage, beacon.clockWaiter, beacon.fetchP2P(), pa, beacon.BackfillOpts...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error initializing backfill service")
 	}
+	if err := beacon.services.RegisterService(bf); err != nil {
+		return nil, errors.Wrap(err, "error registering backfill service")
+	}
 
-	if err := registerServices(cliCtx, beacon, synchronizer, bf, bfs); err != nil {
-		return nil, errors.Wrap(err, "could not register services")
+	log.Debugln("Registering POW Chain Service")
+	if err := beacon.registerPOWChainService(); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering Attestation Pool Service")
+	if err := beacon.registerAttestationPool(); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering Deterministic Genesis Service")
+	if err := beacon.registerDeterministicGenesisService(); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering Blockchain Service")
+	if err := beacon.registerBlockchainService(beacon.forkChoicer, synchronizer, beacon.initialSyncComplete); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering Initial Sync Service")
+	if err := beacon.registerInitialSyncService(beacon.initialSyncComplete); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering Sync Service")
+	if err := beacon.registerSyncService(beacon.initialSyncComplete, bfs); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering Slasher Service")
+	if err := beacon.registerSlasherService(); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering builder service")
+	if err := beacon.registerBuilderService(cliCtx); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering RPC Service")
+	router := newRouter(cliCtx)
+	if err := beacon.registerRPCService(router); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering GRPC Gateway Service")
+	if err := beacon.registerGRPCGateway(router); err != nil {
+		return nil, err
+	}
+
+	log.Debugln("Registering Validator Monitoring Service")
+	if err := beacon.registerValidatorMonitorService(beacon.initialSyncComplete); err != nil {
+		return nil, err
+	}
+
+	if !cliCtx.Bool(cmd.DisableMonitoringFlag.Name) {
+		log.Debugln("Registering Prometheus Service")
+		if err := beacon.registerPrometheusService(cliCtx); err != nil {
+			return nil, err
+		}
 	}
 
 	// db.DatabasePath is the path to the containing directory
@@ -227,170 +343,6 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 
 	return beacon, nil
 }
-
-func configureBeacon(cliCtx *cli.Context) error {
-	if err := configureTracing(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure tracing")
-	}
-
-	prereqs.WarnIfPlatformNotSupported(cliCtx.Context)
-
-	if hasNetworkFlag(cliCtx) && cliCtx.IsSet(cmd.ChainConfigFileFlag.Name) {
-		return fmt.Errorf("%s cannot be passed concurrently with network flag", cmd.ChainConfigFileFlag.Name)
-	}
-
-	if err := features.ConfigureBeaconChain(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure beacon chain")
-	}
-
-	if err := cmd.ConfigureBeaconChain(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure beacon chain")
-	}
-
-	flags.ConfigureGlobalFlags(cliCtx)
-
-	if err := configureChainConfig(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure chain config")
-	}
-
-	if err := configureHistoricalSlasher(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure historical slasher")
-	}
-
-	if err := configureBuilderCircuitBreaker(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure builder circuit breaker")
-	}
-
-	if err := configureSlotsPerArchivedPoint(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure slots per archived point")
-	}
-
-	if err := configureEth1Config(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure eth1 config")
-	}
-
-	configureNetwork(cliCtx)
-
-	if err := configureInteropConfig(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure interop config")
-	}
-
-	if err := configureExecutionSetting(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure execution setting")
-	}
-
-	configureFastSSZHashingAlgorithm()
-
-	return nil
-}
-
-func startBaseServices(cliCtx *cli.Context, beacon *BeaconNode, depositAddress string) (*backfill.Store, error) {
-	ctx := cliCtx.Context
-	log.Debugln("Starting DB")
-	if err := beacon.startDB(cliCtx, depositAddress); err != nil {
-		return nil, errors.Wrap(err, "could not start DB")
-	}
-	beacon.BlobStorage.WarmCache()
-
-	log.Debugln("Starting Slashing DB")
-	if err := beacon.startSlasherDB(cliCtx); err != nil {
-		return nil, errors.Wrap(err, "could not start slashing DB")
-	}
-
-	log.Debugln("Registering P2P Service")
-	if err := beacon.registerP2P(cliCtx); err != nil {
-		return nil, errors.Wrap(err, "could not register P2P service")
-	}
-
-	bfs, err := backfill.NewUpdater(ctx, beacon.db)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not create backfill updater")
-	}
-
-	log.Debugln("Starting State Gen")
-	if err := beacon.startStateGen(ctx, bfs, beacon.forkChoicer); err != nil {
-		if errors.Is(err, stategen.ErrNoGenesisBlock) {
-			log.Errorf("No genesis block/state is found. Prysm only provides a mainnet genesis "+
-				"state bundled in the application. You must provide the --%s or --%s flag to load "+
-				"a genesis block/state for this network.", "genesis-state", "genesis-beacon-api-url")
-		}
-		return nil, errors.Wrap(err, "could not start state generation")
-	}
-
-	return bfs, nil
-}
-
-func registerServices(cliCtx *cli.Context, beacon *BeaconNode, synchronizer *startup.ClockSynchronizer, bf *backfill.Service, bfs *backfill.Store) error {
-	if err := beacon.services.RegisterService(bf); err != nil {
-		return errors.Wrap(err, "could not register backfill service")
-	}
-
-	log.Debugln("Registering POW Chain Service")
-	if err := beacon.registerPOWChainService(); err != nil {
-		return errors.Wrap(err, "could not register POW chain service")
-	}
-
-	log.Debugln("Registering Attestation Pool Service")
-	if err := beacon.registerAttestationPool(); err != nil {
-		return errors.Wrap(err, "could not register attestation pool service")
-	}
-
-	log.Debugln("Registering Deterministic Genesis Service")
-	if err := beacon.registerDeterministicGenesisService(); err != nil {
-		return errors.Wrap(err, "could not register deterministic genesis service")
-	}
-
-	log.Debugln("Registering Blockchain Service")
-	if err := beacon.registerBlockchainService(beacon.forkChoicer, synchronizer, beacon.initialSyncComplete); err != nil {
-		return errors.Wrap(err, "could not register blockchain service")
-	}
-
-	log.Debugln("Registering Initial Sync Service")
-	if err := beacon.registerInitialSyncService(beacon.initialSyncComplete); err != nil {
-		return errors.Wrap(err, "could not register initial sync service")
-	}
-
-	log.Debugln("Registering Sync Service")
-	if err := beacon.registerSyncService(beacon.initialSyncComplete, bfs); err != nil {
-		return errors.Wrap(err, "could not register sync service")
-	}
-
-	log.Debugln("Registering Slasher Service")
-	if err := beacon.registerSlasherService(); err != nil {
-		return errors.Wrap(err, "could not register slasher service")
-	}
-
-	log.Debugln("Registering builder service")
-	if err := beacon.registerBuilderService(cliCtx); err != nil {
-		return errors.Wrap(err, "could not register builder service")
-	}
-
-	log.Debugln("Registering RPC Service")
-	router := newRouter(cliCtx)
-	if err := beacon.registerRPCService(router); err != nil {
-		return errors.Wrap(err, "could not register RPC service")
-	}
-
-	log.Debugln("Registering GRPC Gateway Service")
-	if err := beacon.registerGRPCGateway(router); err != nil {
-		return errors.Wrap(err, "could not register GRPC gateway service")
-	}
-
-	log.Debugln("Registering Validator Monitoring Service")
-	if err := beacon.registerValidatorMonitorService(beacon.initialSyncComplete); err != nil {
-		return errors.Wrap(err, "could not register validator monitoring service")
-	}
-
-	if !cliCtx.Bool(cmd.DisableMonitoringFlag.Name) {
-		log.Debugln("Registering Prometheus Service")
-		if err := beacon.registerPrometheusService(cliCtx); err != nil {
-			return errors.Wrap(err, "could not register prometheus service")
-		}
-	}
-
-	return nil
-}
-
 func initSyncWaiter(ctx context.Context, complete chan struct{}) func() error {
 	return func() error {
 		select {
@@ -479,86 +431,40 @@ func (b *BeaconNode) Close() {
 	close(b.stop)
 }
 
-func (b *BeaconNode) clearDB(clearDB, forceClearDB bool, d *kv.Store, dbPath string) (*kv.Store, error) {
-	var err error
-	clearDBConfirmed := false
-
-	if clearDB && !forceClearDB {
-		const (
-			actionText = "This will delete your beacon chain database stored in your data directory. " +
-				"Your database backups will not be removed - do you want to proceed? (Y/N)"
-
-			deniedText = "Database will not be deleted. No changes have been made."
-		)
-
-		clearDBConfirmed, err = cmd.ConfirmAction(actionText, deniedText)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not confirm action")
-		}
-	}
-
-	if clearDBConfirmed || forceClearDB {
-		log.Warning("Removing database")
-		if err := d.ClearDB(); err != nil {
-			return nil, errors.Wrap(err, "could not clear database")
-		}
-
-		if err := b.BlobStorage.Clear(); err != nil {
-			return nil, errors.Wrap(err, "could not clear blob storage")
-		}
-
-		d, err = kv.NewKVStore(b.ctx, dbPath)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not create new database")
-		}
-	}
-
-	return d, nil
-}
-
-func (b *BeaconNode) checkAndSaveDepositContract(depositAddress string) error {
-	knownContract, err := b.db.DepositContractAddress(b.ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get deposit contract address")
-	}
-
-	addr := common.HexToAddress(depositAddress)
-	if len(knownContract) == 0 {
-		if err := b.db.SaveDepositContractAddress(b.ctx, addr); err != nil {
-			return errors.Wrap(err, "could not save deposit contract")
-		}
-	}
-
-	if len(knownContract) > 0 && !bytes.Equal(addr.Bytes(), knownContract) {
-		return fmt.Errorf("database contract is %#x but tried to run with %#x. This likely means "+
-			"you are trying to run on a different network than what the database contains. You can run once with "+
-			"--%s to wipe the old database or use an alternative data directory with --%s",
-			knownContract, addr.Bytes(), cmd.ClearDB.Name, cmd.DataDirFlag.Name)
-	}
-
-	return nil
-}
-
 func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
-	var depositCache cache.DepositCache
-
 	baseDir := cliCtx.String(cmd.DataDirFlag.Name)
 	dbPath := filepath.Join(baseDir, kv.BeaconNodeDbDirName)
-	clearDBRequired := cliCtx.Bool(cmd.ClearDB.Name)
-	forceClearDBRequired := cliCtx.Bool(cmd.ForceClearDB.Name)
+	clearDB := cliCtx.Bool(cmd.ClearDB.Name)
+	forceClearDB := cliCtx.Bool(cmd.ForceClearDB.Name)
 
 	log.WithField("databasePath", dbPath).Info("Checking DB")
 
 	d, err := kv.NewKVStore(b.ctx, dbPath)
 	if err != nil {
-		return errors.Wrapf(err, "could not create database at %s", dbPath)
+		return err
 	}
-
-	if clearDBRequired || forceClearDBRequired {
-		d, err = b.clearDB(clearDBRequired, forceClearDBRequired, d, dbPath)
+	clearDBConfirmed := false
+	if clearDB && !forceClearDB {
+		actionText := "This will delete your beacon chain database stored in your data directory. " +
+			"Your database backups will not be removed - do you want to proceed? (Y/N)"
+		deniedText := "Database will not be deleted. No changes have been made."
+		clearDBConfirmed, err = cmd.ConfirmAction(actionText, deniedText)
 		if err != nil {
+			return err
+		}
+	}
+	if clearDBConfirmed || forceClearDB {
+		log.Warning("Removing database")
+		if err := d.ClearDB(); err != nil {
 			return errors.Wrap(err, "could not clear database")
 		}
+		if err := b.BlobStorage.Clear(); err != nil {
+			return errors.Wrap(err, "could not clear blob storage")
+		}
+		d, err = kv.NewKVStore(b.ctx, dbPath)
+		if err != nil {
+			return errors.Wrap(err, "could not create new database")
+		}
 	}
 
 	if err := d.RunMigrations(b.ctx); err != nil {
@@ -567,6 +473,7 @@ func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
 
 	b.db = d
 
+	var depositCache cache.DepositCache
 	if features.Get().EnableEIP4881 {
 		depositCache, err = depositsnapshot.New()
 	} else {
@@ -581,17 +488,16 @@ func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
 	if b.GenesisInitializer != nil {
 		if err := b.GenesisInitializer.Initialize(b.ctx, d); err != nil {
 			if err == db.ErrExistingGenesisState {
-				return errors.Errorf("Genesis state flag specified but a genesis state "+
-					"exists already. Run again with --%s and/or ensure you are using the "+
-					"appropriate testnet flag to load the given genesis state.", cmd.ClearDB.Name)
+				return errors.New("Genesis state flag specified but a genesis state " +
+					"exists already. Run again with --clear-db and/or ensure you are using the " +
+					"appropriate testnet flag to load the given genesis state.")
 			}
-
 			return errors.Wrap(err, "could not load genesis from file")
 		}
 	}
 
 	if err := b.db.EnsureEmbeddedGenesis(b.ctx); err != nil {
-		return errors.Wrap(err, "could not ensure embedded genesis")
+		return err
 	}
 
 	if b.CheckpointInitializer != nil {
@@ -600,11 +506,23 @@ func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
 		}
 	}
 
-	if err := b.checkAndSaveDepositContract(depositAddress); err != nil {
-		return errors.Wrap(err, "could not check and save deposit contract")
+	knownContract, err := b.db.DepositContractAddress(b.ctx)
+	if err != nil {
+		return err
 	}
-
-	log.WithField("address", depositAddress).Info("Deposit contract")
+	addr := common.HexToAddress(depositAddress)
+	if len(knownContract) == 0 {
+		if err := b.db.SaveDepositContractAddress(b.ctx, addr); err != nil {
+			return errors.Wrap(err, "could not save deposit contract")
+		}
+	}
+	if len(knownContract) > 0 && !bytes.Equal(addr.Bytes(), knownContract) {
+		return fmt.Errorf("database contract is %#x but tried to run with %#x. This likely means "+
+			"you are trying to run on a different network than what the database contains. You can run once with "+
+			"'--clear-db' to wipe the old database or use an alternative data directory with '--datadir'",
+			knownContract, addr.Bytes())
+	}
+	log.Infof("Deposit contract: %#x", addr.Bytes())
 	return nil
 }
 
@@ -692,31 +610,31 @@ func (b *BeaconNode) startStateGen(ctx context.Context, bfs coverage.AvailableBl
 func (b *BeaconNode) registerP2P(cliCtx *cli.Context) error {
 	bootstrapNodeAddrs, dataDir, err := registration.P2PPreregistration(cliCtx)
 	if err != nil {
-		return errors.Wrapf(err, "could not register p2p service")
+		return err
 	}
 
 	svc, err := p2p.NewService(b.ctx, &p2p.Config{
-		NoDiscovery:          cliCtx.Bool(cmd.NoDiscovery.Name),
-		StaticPeers:          slice.SplitCommaSeparated(cliCtx.StringSlice(cmd.StaticPeers.Name)),
-		Discv5BootStrapAddrs: p2p.ParseBootStrapAddrs(bootstrapNodeAddrs),
-		RelayNodeAddr:        cliCtx.String(cmd.RelayNode.Name),
-		DataDir:              dataDir,
-		LocalIP:              cliCtx.String(cmd.P2PIP.Name),
-		HostAddress:          cliCtx.String(cmd.P2PHost.Name),
-		HostDNS:              cliCtx.String(cmd.P2PHostDNS.Name),
-		PrivateKey:           cliCtx.String(cmd.P2PPrivKey.Name),
-		StaticPeerID:         cliCtx.Bool(cmd.P2PStaticID.Name),
-		MetaDataDir:          cliCtx.String(cmd.P2PMetadata.Name),
-		TCPPort:              cliCtx.Uint(cmd.P2PTCPPort.Name),
-		UDPPort:              cliCtx.Uint(cmd.P2PUDPPort.Name),
-		MaxPeers:             cliCtx.Uint(cmd.P2PMaxPeers.Name),
-		QueueSize:            cliCtx.Uint(cmd.PubsubQueueSize.Name),
-		AllowListCIDR:        cliCtx.String(cmd.P2PAllowList.Name),
-		DenyListCIDR:         slice.SplitCommaSeparated(cliCtx.StringSlice(cmd.P2PDenyList.Name)),
-		EnableUPnP:           cliCtx.Bool(cmd.EnableUPnPFlag.Name),
-		StateNotifier:        b,
-		DB:                   b.db,
-		ClockWaiter:          b.clockWaiter,
+		NoDiscovery:       cliCtx.Bool(cmd.NoDiscovery.Name),
+		StaticPeers:       slice.SplitCommaSeparated(cliCtx.StringSlice(cmd.StaticPeers.Name)),
+		BootstrapNodeAddr: bootstrapNodeAddrs,
+		RelayNodeAddr:     cliCtx.String(cmd.RelayNode.Name),
+		DataDir:           dataDir,
+		LocalIP:           cliCtx.String(cmd.P2PIP.Name),
+		HostAddress:       cliCtx.String(cmd.P2PHost.Name),
+		HostDNS:           cliCtx.String(cmd.P2PHostDNS.Name),
+		PrivateKey:        cliCtx.String(cmd.P2PPrivKey.Name),
+		StaticPeerID:      cliCtx.Bool(cmd.P2PStaticID.Name),
+		MetaDataDir:       cliCtx.String(cmd.P2PMetadata.Name),
+		TCPPort:           cliCtx.Uint(cmd.P2PTCPPort.Name),
+		UDPPort:           cliCtx.Uint(cmd.P2PUDPPort.Name),
+		MaxPeers:          cliCtx.Uint(cmd.P2PMaxPeers.Name),
+		QueueSize:         cliCtx.Uint(cmd.PubsubQueueSize.Name),
+		AllowListCIDR:     cliCtx.String(cmd.P2PAllowList.Name),
+		DenyListCIDR:      slice.SplitCommaSeparated(cliCtx.StringSlice(cmd.P2PDenyList.Name)),
+		EnableUPnP:        cliCtx.Bool(cmd.EnableUPnPFlag.Name),
+		StateNotifier:     b,
+		DB:                b.db,
+		ClockWaiter:       b.clockWaiter,
 	})
 	if err != nil {
 		return err
@@ -1058,13 +976,11 @@ func (b *BeaconNode) registerGRPCGateway(router *mux.Router) error {
 	if b.cliCtx.Bool(flags.DisableGRPCGateway.Name) {
 		return nil
 	}
-	gatewayHost := b.cliCtx.String(flags.GRPCGatewayHost.Name)
 	gatewayPort := b.cliCtx.Int(flags.GRPCGatewayPort.Name)
+	gatewayHost := b.cliCtx.String(flags.GRPCGatewayHost.Name)
 	rpcHost := b.cliCtx.String(flags.RPCHost.Name)
-	rpcPort := b.cliCtx.Int(flags.RPCPort.Name)
-
-	selfAddress := net.JoinHostPort(rpcHost, strconv.Itoa(rpcPort))
-	gatewayAddress := net.JoinHostPort(gatewayHost, strconv.Itoa(gatewayPort))
+	selfAddress := fmt.Sprintf("%s:%d", rpcHost, b.cliCtx.Int(flags.RPCPort.Name))
+	gatewayAddress := fmt.Sprintf("%s:%d", gatewayHost, gatewayPort)
 	allowedOrigins := strings.Split(b.cliCtx.String(flags.GPRCGatewayCorsDomain.Name), ",")
 	enableDebugRPCEndpoints := b.cliCtx.Bool(flags.EnableDebugRPCEndpoints.Name)
 	selfCert := b.cliCtx.String(flags.CertFlag.Name)
@@ -1158,9 +1074,9 @@ func (b *BeaconNode) registerBuilderService(cliCtx *cli.Context) error {
 		return err
 	}
 
-	opts := b.serviceFlagOpts.builderOpts
-	opts = append(opts, builder.WithHeadFetcher(chainService), builder.WithDatabase(b.db))
-
+	opts := append(b.serviceFlagOpts.builderOpts,
+		builder.WithHeadFetcher(chainService),
+		builder.WithDatabase(b.db))
 	// make cache the default.
 	if !cliCtx.Bool(features.DisableRegistrationCache.Name) {
 		opts = append(opts, builder.WithRegistrationCache())

beacon-chain/node/registration/BUILD.bazel

@@ -11,7 +11,6 @@ go_library(
     deps = [
         "//cmd:go_default_library",
         "//config/params:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
         "@in_gopkg_yaml_v2//:go_default_library",

beacon-chain/node/registration/p2p.go

@@ -4,7 +4,6 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/urfave/cli/v2"
@@ -32,9 +31,9 @@ func P2PPreregistration(cliCtx *cli.Context) (bootstrapNodeAddrs []string, dataD
 	if dataDir == "" {
 		dataDir = cmd.DefaultDataDir()
 		if dataDir == "" {
-			err = errors.Errorf(
-				"Could not determine your system's HOME path, please specify a --%s you wish to use for your chain data",
-				cmd.DataDirFlag.Name,
+			log.Fatal(
+				"Could not determine your system's HOME path, please specify a --datadir you wish " +
+					"to use for your chain data",
 			)
 		}
 	}

beacon-chain/p2p/broadcaster_test.go

@@ -240,8 +240,9 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 	var hosts []host.Host
 	// setup other nodes.
 	cfg = &Config{
-		Discv5BootStrapAddrs: []string{bootNode.String()},
-		MaxPeers:             30,
+		BootstrapNodeAddr:   []string{bootNode.String()},
+		Discv5BootStrapAddr: []string{bootNode.String()},
+		MaxPeers:            30,
 	}
 	// Setup 2 different hosts
 	for i := 1; i <= 2; i++ {

beacon-chain/p2p/config.go

@@ -12,27 +12,28 @@ const defaultPubsubQueueSize = 600
 // Config for the p2p service. These parameters are set from application level flags
 // to initialize the p2p service.
 type Config struct {
-	NoDiscovery          bool
-	EnableUPnP           bool
-	StaticPeerID         bool
-	StaticPeers          []string
-	Discv5BootStrapAddrs []string
-	RelayNodeAddr        string
-	LocalIP              string
-	HostAddress          string
-	HostDNS              string
-	PrivateKey           string
-	DataDir              string
-	MetaDataDir          string
-	TCPPort              uint
-	UDPPort              uint
-	MaxPeers             uint
-	QueueSize            uint
-	AllowListCIDR        string
-	DenyListCIDR         []string
-	StateNotifier        statefeed.Notifier
-	DB                   db.ReadOnlyDatabase
-	ClockWaiter          startup.ClockWaiter
+	NoDiscovery         bool
+	EnableUPnP          bool
+	StaticPeerID        bool
+	StaticPeers         []string
+	BootstrapNodeAddr   []string
+	Discv5BootStrapAddr []string
+	RelayNodeAddr       string
+	LocalIP             string
+	HostAddress         string
+	HostDNS             string
+	PrivateKey          string
+	DataDir             string
+	MetaDataDir         string
+	TCPPort             uint
+	UDPPort             uint
+	MaxPeers            uint
+	QueueSize           uint
+	AllowListCIDR       string
+	DenyListCIDR        []string
+	StateNotifier       statefeed.Notifier
+	DB                  db.ReadOnlyDatabase
+	ClockWaiter         startup.ClockWaiter
 }
 
 // validateConfig validates whether the values provided are accurate and will set

beacon-chain/p2p/connection_gater.go

@@ -25,7 +25,7 @@ const (
 )
 
 // InterceptPeerDial tests whether we're permitted to Dial the specified peer.
-func (*Service) InterceptPeerDial(_ peer.ID) (allow bool) {
+func (_ *Service) InterceptPeerDial(_ peer.ID) (allow bool) {
 	return true
 }
 
@@ -63,12 +63,12 @@ func (s *Service) InterceptAccept(n network.ConnMultiaddrs) (allow bool) {
 
 // InterceptSecured tests whether a given connection, now authenticated,
 // is allowed.
-func (*Service) InterceptSecured(_ network.Direction, _ peer.ID, _ network.ConnMultiaddrs) (allow bool) {
+func (_ *Service) InterceptSecured(_ network.Direction, _ peer.ID, _ network.ConnMultiaddrs) (allow bool) {
 	return true
 }
 
 // InterceptUpgraded tests whether a fully capable connection is allowed.
-func (*Service) InterceptUpgraded(_ network.Conn) (allow bool, reason control.DisconnectReason) {
+func (_ *Service) InterceptUpgraded(_ network.Conn) (allow bool, reason control.DisconnectReason) {
 	return true, 0
 }
 

beacon-chain/p2p/discovery.go

@@ -34,11 +34,6 @@ type Listener interface {
 	LocalNode() *enode.LocalNode
 }
 
-const (
-	udp4 = iota
-	udp6
-)
-
 // RefreshENR uses an epoch to refresh the enr entry for our node
 // with the tracked committee ids for the epoch, allowing our node
 // to be dynamically discoverable by others given our tracked committee ids.
@@ -67,14 +62,8 @@ func (s *Service) RefreshENR() {
 	// Compare current epoch with our fork epochs
 	altairForkEpoch := params.BeaconConfig().AltairForkEpoch
 	switch {
-	case currEpoch < altairForkEpoch:
-		// Phase 0 behaviour.
-		if bytes.Equal(bitV, currentBitV) {
-			// return early if bitfield hasn't changed
-			return
-		}
-		s.updateSubnetRecordWithMetadata(bitV)
-	default:
+	// Altair Behaviour
+	case currEpoch >= altairForkEpoch:
 		// Retrieve sync subnets from application level
 		// cache.
 		bitS := bitfield.Bitvector4{byte(0x00)}
@@ -93,6 +82,13 @@ func (s *Service) RefreshENR() {
 			return
 		}
 		s.updateSubnetRecordWithMetadataV2(bitV, bitS)
+	default:
+		// Phase 0 behaviour.
+		if bytes.Equal(bitV, currentBitV) {
+			// return early if bitfield hasn't changed
+			return
+		}
+		s.updateSubnetRecordWithMetadata(bitV)
 	}
 	// ping all peers to inform them of new metadata
 	s.pingPeers()
@@ -144,9 +140,9 @@ func (s *Service) createListener(
 	// by default we will listen to all interfaces.
 	var bindIP net.IP
 	switch udpVersionFromIP(ipAddr) {
-	case udp4:
+	case "udp4":
 		bindIP = net.IPv4zero
-	case udp6:
+	case "udp6":
 		bindIP = net.IPv6zero
 	default:
 		return nil, errors.New("invalid ip provided")
@@ -164,7 +160,6 @@ func (s *Service) createListener(
 		IP:   bindIP,
 		Port: int(s.cfg.UDPPort),
 	}
-
 	// Listen to all network interfaces
 	// for both ip protocols.
 	networkVersion := "udp"
@@ -182,27 +177,44 @@ func (s *Service) createListener(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not create local node")
 	}
-
-	bootNodes := make([]*enode.Node, 0, len(s.cfg.Discv5BootStrapAddrs))
-	for _, addr := range s.cfg.Discv5BootStrapAddrs {
+	if s.cfg.HostAddress != "" {
+		hostIP := net.ParseIP(s.cfg.HostAddress)
+		if hostIP.To4() == nil && hostIP.To16() == nil {
+			log.Errorf("Invalid host address given: %s", hostIP.String())
+		} else {
+			localNode.SetFallbackIP(hostIP)
+			localNode.SetStaticIP(hostIP)
+		}
+	}
+	if s.cfg.HostDNS != "" {
+		host := s.cfg.HostDNS
+		ips, err := net.LookupIP(host)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not resolve host address")
+		}
+		if len(ips) > 0 {
+			// Use first IP returned from the
+			// resolver.
+			firstIP := ips[0]
+			localNode.SetFallbackIP(firstIP)
+		}
+	}
+	dv5Cfg := discover.Config{
+		PrivateKey: privKey,
+	}
+	dv5Cfg.Bootnodes = []*enode.Node{}
+	for _, addr := range s.cfg.Discv5BootStrapAddr {
 		bootNode, err := enode.Parse(enode.ValidSchemes, addr)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not bootstrap addr")
 		}
-
-		bootNodes = append(bootNodes, bootNode)
-	}
-
-	dv5Cfg := discover.Config{
-		PrivateKey: privKey,
-		Bootnodes:  bootNodes,
+		dv5Cfg.Bootnodes = append(dv5Cfg.Bootnodes, bootNode)
 	}
 
 	listener, err := discover.ListenV5(conn, localNode, dv5Cfg)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not listen to discV5")
 	}
-
 	return listener, nil
 }
 
@@ -230,35 +242,8 @@ func (s *Service) createLocalNode(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not add eth2 fork version entry to enr")
 	}
-
 	localNode = initializeAttSubnets(localNode)
-	localNode = initializeSyncCommSubnets(localNode)
-
-	if s.cfg != nil && s.cfg.HostAddress != "" {
-		hostIP := net.ParseIP(s.cfg.HostAddress)
-		if hostIP.To4() == nil && hostIP.To16() == nil {
-			return nil, errors.Errorf("invalid host address: %s", s.cfg.HostAddress)
-		} else {
-			localNode.SetFallbackIP(hostIP)
-			localNode.SetStaticIP(hostIP)
-		}
-	}
-
-	if s.cfg != nil && s.cfg.HostDNS != "" {
-		host := s.cfg.HostDNS
-		ips, err := net.LookupIP(host)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not resolve host address: %s", host)
-		}
-		if len(ips) > 0 {
-			// Use first IP returned from the
-			// resolver.
-			firstIP := ips[0]
-			localNode.SetFallbackIP(firstIP)
-		}
-	}
-
-	return localNode, nil
+	return initializeSyncCommSubnets(localNode), nil
 }
 
 func (s *Service) startDiscoveryV5(
@@ -378,7 +363,7 @@ func PeersFromStringAddrs(addrs []string) ([]ma.Multiaddr, error) {
 	return allAddrs, nil
 }
 
-func ParseBootStrapAddrs(addrs []string) (discv5Nodes []string) {
+func parseBootStrapAddrs(addrs []string) (discv5Nodes []string) {
 	discv5Nodes, _ = parseGenericAddrs(addrs)
 	if len(discv5Nodes) == 0 {
 		log.Warn("No bootstrap addresses supplied")
@@ -498,9 +483,9 @@ func multiAddrFromString(address string) (ma.Multiaddr, error) {
 	return ma.NewMultiaddr(address)
 }
 
-func udpVersionFromIP(ipAddr net.IP) int {
+func udpVersionFromIP(ipAddr net.IP) string {
 	if ipAddr.To4() != nil {
-		return udp4
+		return "udp4"
 	}
-	return udp6
+	return "udp6"
 }

beacon-chain/p2p/discovery_test.go

@@ -42,6 +42,10 @@ import (
 
 var discoveryWaitTime = 1 * time.Second
 
+func init() {
+	rand.Seed(time.Now().Unix())
+}
+
 func createAddrAndPrivKey(t *testing.T) (net.IP, *ecdsa.PrivateKey) {
 	ip, err := prysmNetwork.ExternalIPv4()
 	require.NoError(t, err, "Could not get ip")
@@ -99,8 +103,8 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 	for i := 1; i <= 5; i++ {
 		port = 3000 + i
 		cfg := &Config{
-			Discv5BootStrapAddrs: []string{bootNode.String()},
-			UDPPort:              uint(port),
+			Discv5BootStrapAddr: []string{bootNode.String()},
+			UDPPort:             uint(port),
 		}
 		ipAddr, pkey := createAddrAndPrivKey(t)
 		s = &Service{
@@ -130,106 +134,6 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 	}
 }
 
-func TestCreateLocalNode(t *testing.T) {
-	testCases := []struct {
-		name          string
-		cfg           *Config
-		expectedError bool
-	}{
-		{
-			name:          "valid config",
-			cfg:           nil,
-			expectedError: false,
-		},
-		{
-			name:          "invalid host address",
-			cfg:           &Config{HostAddress: "invalid"},
-			expectedError: true,
-		},
-		{
-			name:          "valid host address",
-			cfg:           &Config{HostAddress: "192.168.0.1"},
-			expectedError: false,
-		},
-		{
-			name:          "invalid host DNS",
-			cfg:           &Config{HostDNS: "invalid"},
-			expectedError: true,
-		},
-		{
-			name:          "valid host DNS",
-			cfg:           &Config{HostDNS: "www.google.com"},
-			expectedError: false,
-		},
-	}
-	for _, tt := range testCases {
-		t.Run(tt.name, func(t *testing.T) {
-			// Define ports.
-			const (
-				udpPort = 2000
-				tcpPort = 3000
-			)
-
-			// Create a private key.
-			address, privKey := createAddrAndPrivKey(t)
-
-			// Create a service.
-			service := &Service{
-				genesisTime:           time.Now(),
-				genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
-				cfg:                   tt.cfg,
-			}
-
-			localNode, err := service.createLocalNode(privKey, address, udpPort, tcpPort)
-			if tt.expectedError {
-				require.NotNil(t, err)
-				return
-			}
-
-			require.NoError(t, err)
-
-			expectedAddress := address
-			if tt.cfg != nil && tt.cfg.HostAddress != "" {
-				expectedAddress = net.ParseIP(tt.cfg.HostAddress)
-			}
-
-			// Check IP.
-			// IP is not checked int case of DNS, since it can be resolved to different IPs.
-			if tt.cfg == nil || tt.cfg.HostDNS == "" {
-				ip := new(net.IP)
-				require.NoError(t, localNode.Node().Record().Load(enr.WithEntry("ip", ip)))
-				require.Equal(t, true, ip.Equal(expectedAddress))
-				require.Equal(t, true, localNode.Node().IP().Equal(expectedAddress))
-			}
-
-			// Check UDP.
-			udp := new(uint16)
-			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry("udp", udp)))
-			require.Equal(t, udpPort, localNode.Node().UDP())
-
-			// Check TCP.
-			tcp := new(uint16)
-			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry("tcp", tcp)))
-			require.Equal(t, tcpPort, localNode.Node().TCP())
-
-			// Check fork is set.
-			fork := new([]byte)
-			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(eth2ENRKey, fork)))
-			require.NotEmpty(t, *fork)
-
-			// Check att subnets.
-			attSubnets := new([]byte)
-			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(attSubnetEnrKey, attSubnets)))
-			require.DeepSSZEqual(t, []byte{0, 0, 0, 0, 0, 0, 0, 0}, *attSubnets)
-
-			// Check sync committees subnets.
-			syncSubnets := new([]byte)
-			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(syncCommsSubnetEnrKey, syncSubnets)))
-			require.DeepSSZEqual(t, []byte{0}, *syncSubnets)
-		})
-	}
-}
-
 func TestMultiAddrsConversion_InvalidIPAddr(t *testing.T) {
 	addr := net.ParseIP("invalidIP")
 	_, pkey := createAddrAndPrivKey(t)
@@ -406,12 +310,12 @@ func TestMultipleDiscoveryAddresses(t *testing.T) {
 }
 
 func TestCorrectUDPVersion(t *testing.T) {
-	assert.Equal(t, udp4, udpVersionFromIP(net.IPv4zero), "incorrect network version")
-	assert.Equal(t, udp6, udpVersionFromIP(net.IPv6zero), "incorrect network version")
-	assert.Equal(t, udp4, udpVersionFromIP(net.IP{200, 20, 12, 255}), "incorrect network version")
-	assert.Equal(t, udp6, udpVersionFromIP(net.IP{22, 23, 24, 251, 17, 18, 0, 0, 0, 0, 12, 14, 212, 213, 16, 22}), "incorrect network version")
+	assert.Equal(t, "udp4", udpVersionFromIP(net.IPv4zero), "incorrect network version")
+	assert.Equal(t, "udp6", udpVersionFromIP(net.IPv6zero), "incorrect network version")
+	assert.Equal(t, "udp4", udpVersionFromIP(net.IP{200, 20, 12, 255}), "incorrect network version")
+	assert.Equal(t, "udp6", udpVersionFromIP(net.IP{22, 23, 24, 251, 17, 18, 0, 0, 0, 0, 12, 14, 212, 213, 16, 22}), "incorrect network version")
 	// v4 in v6
-	assert.Equal(t, udp4, udpVersionFromIP(net.IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 212, 213, 16, 22}), "incorrect network version")
+	assert.Equal(t, "udp4", udpVersionFromIP(net.IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 212, 213, 16, 22}), "incorrect network version")
 }
 
 // addPeer is a helper to add a peer with a given connection state)

beacon-chain/p2p/fork_test.go

@@ -46,9 +46,9 @@ func TestStartDiscv5_DifferentForkDigests(t *testing.T) {
 
 	bootNode := bootListener.Self()
 	cfg := &Config{
-		Discv5BootStrapAddrs: []string{bootNode.String()},
-		UDPPort:              uint(port),
-		StateNotifier:        &mock.MockStateNotifier{},
+		Discv5BootStrapAddr: []string{bootNode.String()},
+		UDPPort:             uint(port),
+		StateNotifier:       &mock.MockStateNotifier{},
 	}
 
 	var listeners []*discover.UDPv5
@@ -132,8 +132,8 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) {
 
 	bootNode := bootListener.Self()
 	cfg := &Config{
-		Discv5BootStrapAddrs: []string{bootNode.String()},
-		UDPPort:              uint(port),
+		Discv5BootStrapAddr: []string{bootNode.String()},
+		UDPPort:             uint(port),
 	}
 
 	var listeners []*discover.UDPv5

beacon-chain/p2p/info.go

@@ -20,7 +20,7 @@ self=%s
 %d peers
 %v
 `,
-		s.cfg.Discv5BootStrapAddrs,
+		s.cfg.BootstrapNodeAddr,
 		s.selfAddresses(),
 		len(s.host.Network().Peers()),
 		formatPeers(s.host), // Must be last. Writes one entry per row.

beacon-chain/p2p/options.go

@@ -31,31 +31,29 @@ func MultiAddressBuilder(ipAddr string, port uint) (ma.Multiaddr, error) {
 }
 
 // buildOptions for the libp2p host.
-func (s *Service) buildOptions(ip net.IP, priKey *ecdsa.PrivateKey) ([]libp2p.Option, error) {
+func (s *Service) buildOptions(ip net.IP, priKey *ecdsa.PrivateKey) []libp2p.Option {
 	cfg := s.cfg
 	listen, err := MultiAddressBuilder(ip.String(), cfg.TCPPort)
 	if err != nil {
-		return nil, errors.Wrapf(err, "cannot produce multiaddr format from %s:%d", ip.String(), cfg.TCPPort)
+		log.WithError(err).Fatal("Failed to p2p listen")
 	}
 	if cfg.LocalIP != "" {
 		if net.ParseIP(cfg.LocalIP) == nil {
-			return nil, errors.Wrapf(err, "invalid local ip provided: %s:%d", cfg.LocalIP, cfg.TCPPort)
+			log.Fatalf("Invalid local ip provided: %s", cfg.LocalIP)
 		}
-
 		listen, err = MultiAddressBuilder(cfg.LocalIP, cfg.TCPPort)
 		if err != nil {
-			return nil, errors.Wrapf(err, "cannot produce multiaddr format from %s:%d", cfg.LocalIP, cfg.TCPPort)
+			log.WithError(err).Fatal("Failed to p2p listen")
 		}
 	}
 	ifaceKey, err := ecdsaprysm.ConvertToInterfacePrivkey(priKey)
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot convert private key to interface private key. (Private key not displayed in logs for security reasons)")
+		log.WithError(err).Fatal("Failed to retrieve private key")
 	}
 	id, err := peer.IDFromPublicKey(ifaceKey.GetPublic())
 	if err != nil {
-		return nil, errors.Wrapf(err, "cannot get ID from public key: %s", ifaceKey.GetPublic().Type().String())
+		log.WithError(err).Fatal("Failed to retrieve peer id")
 	}
-
 	log.Infof("Running node with peer id of %s ", id.String())
 
 	options := []libp2p.Option{
@@ -66,10 +64,10 @@ func (s *Service) buildOptions(ip net.IP, priKey *ecdsa.PrivateKey) ([]libp2p.Op
 		libp2p.Transport(tcp.NewTCPTransport),
 		libp2p.DefaultMuxers,
 		libp2p.Muxer("/mplex/6.7.0", mplex.DefaultTransport),
-		libp2p.Security(noise.ID, noise.New),
-		libp2p.Ping(false), // Disable Ping Service.
 	}
 
+	options = append(options, libp2p.Security(noise.ID, noise.New))
+
 	if cfg.EnableUPnP {
 		options = append(options, libp2p.NATPortMap()) // Allow to use UPnP
 	}
@@ -101,11 +99,12 @@ func (s *Service) buildOptions(ip net.IP, priKey *ecdsa.PrivateKey) ([]libp2p.Op
 			return addrs
 		}))
 	}
-
+	// Disable Ping Service.
+	options = append(options, libp2p.Ping(false))
 	if features.Get().DisableResourceManager {
 		options = append(options, libp2p.ResourceManager(&network.NullResourceManager{}))
 	}
-	return options, nil
+	return options
 }
 
 func multiAddressBuilderWithID(ipAddr, protocol string, port uint, id peer.ID) (ma.Multiaddr, error) {

beacon-chain/p2p/options_test.go

@@ -119,9 +119,7 @@ func TestDefaultMultiplexers(t *testing.T) {
 	svc.privKey, err = privKey(svc.cfg)
 	assert.NoError(t, err)
 	ipAddr := network.IPAddr()
-	opts, err := svc.buildOptions(ipAddr, svc.privKey)
-	assert.NoError(t, err)
-
+	opts := svc.buildOptions(ipAddr, svc.privKey)
 	err = cfg.Apply(append(opts, libp2p.FallbackDefaults)...)
 	assert.NoError(t, err)
 

beacon-chain/p2p/peers/peerdata/store_test.go

@@ -107,4 +107,5 @@ func TestStore_TrustedPeers(t *testing.T) {
 	assert.Equal(t, false, store.IsTrustedPeer(pid1))
 	assert.Equal(t, false, store.IsTrustedPeer(pid2))
 	assert.Equal(t, false, store.IsTrustedPeer(pid3))
+
 }

beacon-chain/p2p/peers/scorers/bad_responses.go

@@ -56,12 +56,12 @@ func newBadResponsesScorer(store *peerdata.Store, config *BadResponsesScorerConf
 func (s *BadResponsesScorer) Score(pid peer.ID) float64 {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.scoreNoLock(pid)
+	return s.score(pid)
 }
 
-// scoreNoLock is a lock-free version of Score.
-func (s *BadResponsesScorer) scoreNoLock(pid peer.ID) float64 {
-	if s.isBadPeerNoLock(pid) {
+// score is a lock-free version of Score.
+func (s *BadResponsesScorer) score(pid peer.ID) float64 {
+	if s.isBadPeer(pid) {
 		return BadPeerScore
 	}
 	score := float64(0)
@@ -87,11 +87,11 @@ func (s *BadResponsesScorer) Params() *BadResponsesScorerConfig {
 func (s *BadResponsesScorer) Count(pid peer.ID) (int, error) {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.countNoLock(pid)
+	return s.count(pid)
 }
 
-// countNoLock is a lock-free version of Count.
-func (s *BadResponsesScorer) countNoLock(pid peer.ID) (int, error) {
+// count is a lock-free version of Count.
+func (s *BadResponsesScorer) count(pid peer.ID) (int, error) {
 	if peerData, ok := s.store.PeerData(pid); ok {
 		return peerData.BadResponses, nil
 	}
@@ -119,11 +119,11 @@ func (s *BadResponsesScorer) Increment(pid peer.ID) {
 func (s *BadResponsesScorer) IsBadPeer(pid peer.ID) bool {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.isBadPeerNoLock(pid)
+	return s.isBadPeer(pid)
 }
 
-// isBadPeerNoLock is lock-free version of IsBadPeer.
-func (s *BadResponsesScorer) isBadPeerNoLock(pid peer.ID) bool {
+// isBadPeer is lock-free version of IsBadPeer.
+func (s *BadResponsesScorer) isBadPeer(pid peer.ID) bool {
 	if peerData, ok := s.store.PeerData(pid); ok {
 		return peerData.BadResponses >= s.config.Threshold
 	}
@@ -137,7 +137,7 @@ func (s *BadResponsesScorer) BadPeers() []peer.ID {
 
 	badPeers := make([]peer.ID, 0)
 	for pid := range s.store.Peers() {
-		if s.isBadPeerNoLock(pid) {
+		if s.isBadPeer(pid) {
 			badPeers = append(badPeers, pid)
 		}
 	}

beacon-chain/p2p/peers/scorers/bad_responses_test.go

@@ -15,8 +15,6 @@ import (
 )
 
 func TestScorers_BadResponses_Score(t *testing.T) {
-	const pid = "peer1"
-
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
@@ -30,23 +28,15 @@ func TestScorers_BadResponses_Score(t *testing.T) {
 	})
 	scorer := peerStatuses.Scorers().BadResponsesScorer()
 
-	assert.Equal(t, 0., scorer.Score(pid), "Unexpected score for unregistered peer")
-
-	scorer.Increment(pid)
-	assert.Equal(t, false, scorer.IsBadPeer(pid))
-	assert.Equal(t, -2.5, scorer.Score(pid))
-
-	scorer.Increment(pid)
-	assert.Equal(t, false, scorer.IsBadPeer(pid))
-	assert.Equal(t, float64(-5), scorer.Score(pid))
-
-	scorer.Increment(pid)
-	assert.Equal(t, false, scorer.IsBadPeer(pid))
-	assert.Equal(t, float64(-7.5), scorer.Score(pid))
-
-	scorer.Increment(pid)
-	assert.Equal(t, true, scorer.IsBadPeer(pid))
-	assert.Equal(t, -100.0, scorer.Score(pid))
+	assert.Equal(t, 0.0, scorer.Score("peer1"), "Unexpected score for unregistered peer")
+	scorer.Increment("peer1")
+	assert.Equal(t, -2.5, scorer.Score("peer1"))
+	scorer.Increment("peer1")
+	assert.Equal(t, float64(-5), scorer.Score("peer1"))
+	scorer.Increment("peer1")
+	scorer.Increment("peer1")
+	assert.Equal(t, -100.0, scorer.Score("peer1"))
+	assert.Equal(t, true, scorer.IsBadPeer("peer1"))
 }
 
 func TestScorers_BadResponses_ParamsThreshold(t *testing.T) {

beacon-chain/p2p/peers/scorers/block_providers.go

@@ -98,11 +98,11 @@ func newBlockProviderScorer(store *peerdata.Store, config *BlockProviderScorerCo
 func (s *BlockProviderScorer) Score(pid peer.ID) float64 {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.scoreNoLock(pid)
+	return s.score(pid)
 }
 
-// scoreNoLock is a lock-free version of Score.
-func (s *BlockProviderScorer) scoreNoLock(pid peer.ID) float64 {
+// score is a lock-free version of Score.
+func (s *BlockProviderScorer) score(pid peer.ID) float64 {
 	score := float64(0)
 	peerData, ok := s.store.PeerData(pid)
 	// Boost score of new peers or peers that haven't been accessed for too long.
@@ -126,7 +126,7 @@ func (s *BlockProviderScorer) Params() *BlockProviderScorerConfig {
 func (s *BlockProviderScorer) IncrementProcessedBlocks(pid peer.ID, cnt uint64) {
 	s.store.Lock()
 	defer s.store.Unlock()
-	defer s.touchNoLock(pid)
+	defer s.touch(pid)
 
 	if cnt <= 0 {
 		return
@@ -145,11 +145,11 @@ func (s *BlockProviderScorer) IncrementProcessedBlocks(pid peer.ID, cnt uint64)
 func (s *BlockProviderScorer) Touch(pid peer.ID, t ...time.Time) {
 	s.store.Lock()
 	defer s.store.Unlock()
-	s.touchNoLock(pid, t...)
+	s.touch(pid, t...)
 }
 
-// touchNoLock is a lock-free version of Touch.
-func (s *BlockProviderScorer) touchNoLock(pid peer.ID, t ...time.Time) {
+// touch is a lock-free version of Touch.
+func (s *BlockProviderScorer) touch(pid peer.ID, t ...time.Time) {
 	peerData := s.store.PeerDataGetOrCreate(pid)
 	if len(t) == 1 {
 		peerData.BlockProviderUpdated = t[0]
@@ -162,11 +162,11 @@ func (s *BlockProviderScorer) touchNoLock(pid peer.ID, t ...time.Time) {
 func (s *BlockProviderScorer) ProcessedBlocks(pid peer.ID) uint64 {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.processedBlocksNoLock(pid)
+	return s.processedBlocks(pid)
 }
 
-// processedBlocksNoLock is a lock-free version of ProcessedBlocks.
-func (s *BlockProviderScorer) processedBlocksNoLock(pid peer.ID) uint64 {
+// processedBlocks is a lock-free version of ProcessedBlocks.
+func (s *BlockProviderScorer) processedBlocks(pid peer.ID) uint64 {
 	if peerData, ok := s.store.PeerData(pid); ok {
 		return peerData.ProcessedBlocks
 	}
@@ -177,13 +177,13 @@ func (s *BlockProviderScorer) processedBlocksNoLock(pid peer.ID) uint64 {
 // Block provider scorer cannot guarantee that lower score of a peer is indeed a sign of a bad peer.
 // Therefore this scorer never marks peers as bad, and relies on scores to probabilistically sort
 // out low-scorers (see WeightSorted method).
-func (*BlockProviderScorer) IsBadPeer(_ peer.ID) bool {
+func (_ *BlockProviderScorer) IsBadPeer(_ peer.ID) bool {
 	return false
 }
 
 // BadPeers returns the peers that are considered bad.
 // No peers are considered bad by block providers scorer.
-func (*BlockProviderScorer) BadPeers() []peer.ID {
+func (_ *BlockProviderScorer) BadPeers() []peer.ID {
 	return []peer.ID{}
 }
 
@@ -277,9 +277,9 @@ func (s *BlockProviderScorer) mapScoresAndPeers(
 	peers := make([]peer.ID, len(pids))
 	for i, pid := range pids {
 		if scoreFn != nil {
-			scores[pid] = scoreFn(pid, s.scoreNoLock(pid))
+			scores[pid] = scoreFn(pid, s.score(pid))
 		} else {
-			scores[pid] = s.scoreNoLock(pid)
+			scores[pid] = s.score(pid)
 		}
 		peers[i] = pid
 	}
@@ -293,9 +293,9 @@ func (s *BlockProviderScorer) FormatScorePretty(pid peer.ID) string {
 	if !features.Get().EnablePeerScorer {
 		return "disabled"
 	}
-	score := s.scoreNoLock(pid)
+	score := s.score(pid)
 	return fmt.Sprintf("[%0.1f%%, raw: %0.2f,  blocks: %d/%d]",
-		(score/s.MaxScore())*100, score, s.processedBlocksNoLock(pid), s.config.ProcessedBlocksCap)
+		(score/s.MaxScore())*100, score, s.processedBlocks(pid), s.config.ProcessedBlocksCap)
 }
 
 // MaxScore exposes maximum score attainable by peers.

beacon-chain/p2p/peers/scorers/gossip_scorer.go

@@ -38,11 +38,11 @@ func newGossipScorer(store *peerdata.Store, config *GossipScorerConfig) *GossipS
 func (s *GossipScorer) Score(pid peer.ID) float64 {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.scoreNoLock(pid)
+	return s.score(pid)
 }
 
-// scoreNoLock is a lock-free version of Score.
-func (s *GossipScorer) scoreNoLock(pid peer.ID) float64 {
+// score is a lock-free version of Score.
+func (s *GossipScorer) score(pid peer.ID) float64 {
 	peerData, ok := s.store.PeerData(pid)
 	if !ok {
 		return 0
@@ -54,11 +54,11 @@ func (s *GossipScorer) scoreNoLock(pid peer.ID) float64 {
 func (s *GossipScorer) IsBadPeer(pid peer.ID) bool {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.isBadPeerNoLock(pid)
+	return s.isBadPeer(pid)
 }
 
-// isBadPeerNoLock is lock-free version of IsBadPeer.
-func (s *GossipScorer) isBadPeerNoLock(pid peer.ID) bool {
+// isBadPeer is lock-free version of IsBadPeer.
+func (s *GossipScorer) isBadPeer(pid peer.ID) bool {
 	peerData, ok := s.store.PeerData(pid)
 	if !ok {
 		return false
@@ -73,7 +73,7 @@ func (s *GossipScorer) BadPeers() []peer.ID {
 
 	badPeers := make([]peer.ID, 0)
 	for pid := range s.store.Peers() {
-		if s.isBadPeerNoLock(pid) {
+		if s.isBadPeer(pid) {
 			badPeers = append(badPeers, pid)
 		}
 	}
@@ -98,11 +98,11 @@ func (s *GossipScorer) SetGossipData(pid peer.ID, gScore float64,
 func (s *GossipScorer) GossipData(pid peer.ID) (float64, float64, map[string]*pbrpc.TopicScoreSnapshot, error) {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.gossipDataNoLock(pid)
+	return s.gossipData(pid)
 }
 
-// gossipDataNoLock lock-free version of GossipData.
-func (s *GossipScorer) gossipDataNoLock(pid peer.ID) (float64, float64, map[string]*pbrpc.TopicScoreSnapshot, error) {
+// gossipData lock-free version of GossipData.
+func (s *GossipScorer) gossipData(pid peer.ID) (float64, float64, map[string]*pbrpc.TopicScoreSnapshot, error) {
 	if peerData, ok := s.store.PeerData(pid); ok {
 		return peerData.GossipScore, peerData.BehaviourPenalty, peerData.TopicScores, nil
 	}

beacon-chain/p2p/peers/scorers/peer_status.go

@@ -41,12 +41,12 @@ func newPeerStatusScorer(store *peerdata.Store, config *PeerStatusScorerConfig)
 func (s *PeerStatusScorer) Score(pid peer.ID) float64 {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.scoreNoLock(pid)
+	return s.score(pid)
 }
 
-// scoreNoLock is a lock-free version of Score.
-func (s *PeerStatusScorer) scoreNoLock(pid peer.ID) float64 {
-	if s.isBadPeerNoLock(pid) {
+// score is a lock-free version of Score.
+func (s *PeerStatusScorer) score(pid peer.ID) float64 {
+	if s.isBadPeer(pid) {
 		return BadPeerScore
 	}
 	score := float64(0)
@@ -70,11 +70,11 @@ func (s *PeerStatusScorer) scoreNoLock(pid peer.ID) float64 {
 func (s *PeerStatusScorer) IsBadPeer(pid peer.ID) bool {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.isBadPeerNoLock(pid)
+	return s.isBadPeer(pid)
 }
 
-// isBadPeerNoLock is lock-free version of IsBadPeer.
-func (s *PeerStatusScorer) isBadPeerNoLock(pid peer.ID) bool {
+// isBadPeer is lock-free version of IsBadPeer.
+func (s *PeerStatusScorer) isBadPeer(pid peer.ID) bool {
 	peerData, ok := s.store.PeerData(pid)
 	if !ok {
 		return false
@@ -100,7 +100,7 @@ func (s *PeerStatusScorer) BadPeers() []peer.ID {
 
 	badPeers := make([]peer.ID, 0)
 	for pid := range s.store.Peers() {
-		if s.isBadPeerNoLock(pid) {
+		if s.isBadPeer(pid) {
 			badPeers = append(badPeers, pid)
 		}
 	}
@@ -129,11 +129,11 @@ func (s *PeerStatusScorer) SetPeerStatus(pid peer.ID, chainState *pb.Status, val
 func (s *PeerStatusScorer) PeerStatus(pid peer.ID) (*pb.Status, error) {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	return s.peerStatusNoLock(pid)
+	return s.peerStatus(pid)
 }
 
-// peerStatusNoLock lock-free version of PeerStatus.
-func (s *PeerStatusScorer) peerStatusNoLock(pid peer.ID) (*pb.Status, error) {
+// peerStatus lock-free version of PeerStatus.
+func (s *PeerStatusScorer) peerStatus(pid peer.ID) (*pb.Status, error) {
 	if peerData, ok := s.store.PeerData(pid); ok {
 		if peerData.ChainState == nil {
 			return nil, peerdata.ErrNoPeerStatus

beacon-chain/p2p/peers/scorers/service.go

@@ -116,10 +116,10 @@ func (s *Service) ScoreNoLock(pid peer.ID) float64 {
 	if _, ok := s.store.PeerData(pid); !ok {
 		return 0
 	}
-	score += s.scorers.badResponsesScorer.scoreNoLock(pid) * s.scorerWeight(s.scorers.badResponsesScorer)
-	score += s.scorers.blockProviderScorer.scoreNoLock(pid) * s.scorerWeight(s.scorers.blockProviderScorer)
-	score += s.scorers.peerStatusScorer.scoreNoLock(pid) * s.scorerWeight(s.scorers.peerStatusScorer)
-	score += s.scorers.gossipScorer.scoreNoLock(pid) * s.scorerWeight(s.scorers.gossipScorer)
+	score += s.scorers.badResponsesScorer.score(pid) * s.scorerWeight(s.scorers.badResponsesScorer)
+	score += s.scorers.blockProviderScorer.score(pid) * s.scorerWeight(s.scorers.blockProviderScorer)
+	score += s.scorers.peerStatusScorer.score(pid) * s.scorerWeight(s.scorers.peerStatusScorer)
+	score += s.scorers.gossipScorer.score(pid) * s.scorerWeight(s.scorers.gossipScorer)
 	return math.Round(score*ScoreRoundingFactor) / ScoreRoundingFactor
 }
 
@@ -132,14 +132,14 @@ func (s *Service) IsBadPeer(pid peer.ID) bool {
 
 // IsBadPeerNoLock is a lock-free version of IsBadPeer.
 func (s *Service) IsBadPeerNoLock(pid peer.ID) bool {
-	if s.scorers.badResponsesScorer.isBadPeerNoLock(pid) {
+	if s.scorers.badResponsesScorer.isBadPeer(pid) {
 		return true
 	}
-	if s.scorers.peerStatusScorer.isBadPeerNoLock(pid) {
+	if s.scorers.peerStatusScorer.isBadPeer(pid) {
 		return true
 	}
 	if features.Get().EnablePeerScorer {
-		if s.scorers.gossipScorer.isBadPeerNoLock(pid) {
+		if s.scorers.gossipScorer.isBadPeer(pid) {
 			return true
 		}
 	}

beacon-chain/p2p/service.go

@@ -56,7 +56,6 @@ type Service struct {
 	started               bool
 	isPreGenesis          bool
 	pingMethod            func(ctx context.Context, id peer.ID) error
-	pingMethodLock        sync.RWMutex
 	cancel                context.CancelFunc
 	cfg                   *Config
 	peers                 *peers.Status
@@ -82,49 +81,44 @@ type Service struct {
 // NewService initializes a new p2p service compatible with shared.Service interface. No
 // connections are made until the Start function is called during the service registry startup.
 func NewService(ctx context.Context, cfg *Config) (*Service, error) {
+	var err error
 	ctx, cancel := context.WithCancel(ctx)
 	_ = cancel // govet fix for lost cancel. Cancel is handled in service.Stop().
 
-	cfg = validateConfig(cfg)
-	privKey, err := privKey(cfg)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to generate p2p private key")
-	}
-
-	metaData, err := metaDataFromConfig(cfg)
-	if err != nil {
-		log.WithError(err).Error("Failed to create peer metadata")
-		return nil, err
-	}
-
-	addrFilter, err := configureFilter(cfg)
-	if err != nil {
-		log.WithError(err).Error("Failed to create address filter")
-		return nil, err
-	}
-
-	ipLimiter := leakybucket.NewCollector(ipLimit, ipBurst, 30*time.Second, true /* deleteEmptyBuckets */)
-
 	s := &Service{
 		ctx:          ctx,
 		cancel:       cancel,
 		cfg:          cfg,
-		addrFilter:   addrFilter,
-		ipLimiter:    ipLimiter,
-		privKey:      privKey,
-		metaData:     metaData,
 		isPreGenesis: true,
 		joinedTopics: make(map[string]*pubsub.Topic, len(gossipTopicMappings)),
 		subnetsLock:  make(map[uint64]*sync.RWMutex),
 	}
 
+	s.cfg = validateConfig(s.cfg)
+
+	dv5Nodes := parseBootStrapAddrs(s.cfg.BootstrapNodeAddr)
+
+	cfg.Discv5BootStrapAddr = dv5Nodes
+
 	ipAddr := prysmnetwork.IPAddr()
-
-	opts, err := s.buildOptions(ipAddr, s.privKey)
+	s.privKey, err = privKey(s.cfg)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to build p2p options")
+		log.WithError(err).Error("Failed to generate p2p private key")
+		return nil, err
 	}
+	s.metaData, err = metaDataFromConfig(s.cfg)
+	if err != nil {
+		log.WithError(err).Error("Failed to create peer metadata")
+		return nil, err
+	}
+	s.addrFilter, err = configureFilter(s.cfg)
+	if err != nil {
+		log.WithError(err).Error("Failed to create address filter")
+		return nil, err
+	}
+	s.ipLimiter = leakybucket.NewCollector(ipLimit, ipBurst, 30*time.Second, true /* deleteEmptyBuckets */)
 
+	opts := s.buildOptions(ipAddr, s.privKey)
 	h, err := libp2p.New(opts...)
 	if err != nil {
 		log.WithError(err).Error("Failed to create p2p host")
@@ -290,7 +284,7 @@ func (s *Service) Started() bool {
 }
 
 // Encoding returns the configured networking encoding.
-func (*Service) Encoding() encoder.NetworkEncoding {
+func (_ *Service) Encoding() encoder.NetworkEncoding {
 	return &encoder.SszNetworkEncoder{}
 }
 
@@ -360,14 +354,10 @@ func (s *Service) MetadataSeq() uint64 {
 // AddPingMethod adds the metadata ping rpc method to the p2p service, so that it can
 // be used to refresh ENR.
 func (s *Service) AddPingMethod(reqFunc func(ctx context.Context, id peer.ID) error) {
-	s.pingMethodLock.Lock()
 	s.pingMethod = reqFunc
-	s.pingMethodLock.Unlock()
 }
 
 func (s *Service) pingPeers() {
-	s.pingMethodLock.RLock()
-	defer s.pingMethodLock.RUnlock()
 	if s.pingMethod == nil {
 		return
 	}
@@ -456,8 +446,8 @@ func (s *Service) connectWithPeer(ctx context.Context, info peer.AddrInfo) error
 }
 
 func (s *Service) connectToBootnodes() error {
-	nodes := make([]*enode.Node, 0, len(s.cfg.Discv5BootStrapAddrs))
-	for _, addr := range s.cfg.Discv5BootStrapAddrs {
+	nodes := make([]*enode.Node, 0, len(s.cfg.Discv5BootStrapAddr))
+	for _, addr := range s.cfg.Discv5BootStrapAddr {
 		bootNode, err := enode.Parse(enode.ValidSchemes, addr)
 		if err != nil {
 			return err

beacon-chain/p2p/service_test.go

@@ -213,9 +213,10 @@ func TestListenForNewNodes(t *testing.T) {
 	// setup other nodes.
 	cs := startup.NewClockSynchronizer()
 	cfg = &Config{
-		Discv5BootStrapAddrs: []string{bootNode.String()},
-		MaxPeers:             30,
-		ClockWaiter:          cs,
+		BootstrapNodeAddr:   []string{bootNode.String()},
+		Discv5BootStrapAddr: []string{bootNode.String()},
+		MaxPeers:            30,
+		ClockWaiter:         cs,
 	}
 	for i := 1; i <= 5; i++ {
 		h, pkey, ipAddr := createHost(t, port+i)

beacon-chain/p2p/subnets_test.go

@@ -57,9 +57,10 @@ func TestStartDiscV5_DiscoverPeersWithSubnets(t *testing.T) {
 	for i := 1; i <= 3; i++ {
 		port = 3000 + i
 		cfg := &Config{
-			Discv5BootStrapAddrs: []string{bootNode.String()},
-			MaxPeers:             30,
-			UDPPort:              uint(port),
+			BootstrapNodeAddr:   []string{bootNode.String()},
+			Discv5BootStrapAddr: []string{bootNode.String()},
+			MaxPeers:            30,
+			UDPPort:             uint(port),
 		}
 		ipAddr, pkey := createAddrAndPrivKey(t)
 		s = &Service{
@@ -87,10 +88,11 @@ func TestStartDiscV5_DiscoverPeersWithSubnets(t *testing.T) {
 	port = 4001
 	gs := startup.NewClockSynchronizer()
 	cfg := &Config{
-		Discv5BootStrapAddrs: []string{bootNode.String()},
-		MaxPeers:             30,
-		UDPPort:              uint(port),
-		ClockWaiter:          gs,
+		BootstrapNodeAddr:   []string{bootNode.String()},
+		Discv5BootStrapAddr: []string{bootNode.String()},
+		MaxPeers:            30,
+		UDPPort:             uint(port),
+		ClockWaiter:         gs,
 	}
 	s, err = NewService(context.Background(), cfg)
 	require.NoError(t, err)

beacon-chain/p2p/types/rpc_errors.go

@@ -8,11 +8,11 @@ var (
 	ErrInvalidFinalizedRoot   = errors.New("invalid finalized root")
 	ErrInvalidSequenceNum     = errors.New("invalid sequence number provided")
 	ErrGeneric                = errors.New("internal service error")
-
-	ErrRateLimited         = errors.New("rate limited")
-	ErrIODeadline          = errors.New("i/o deadline exceeded")
-	ErrInvalidRequest      = errors.New("invalid range, step or count")
-	ErrBlobLTMinRequest    = errors.New("blob slot < minimum_request_epoch")
-	ErrMaxBlobReqExceeded  = errors.New("requested more than MAX_REQUEST_BLOB_SIDECARS")
-	ErrResourceUnavailable = errors.New("resource requested unavailable")
+	ErrInvalidParent          = errors.New("mismatched parent root")
+	ErrRateLimited            = errors.New("rate limited")
+	ErrIODeadline             = errors.New("i/o deadline exceeded")
+	ErrInvalidRequest         = errors.New("invalid range, step or count")
+	ErrBlobLTMinRequest       = errors.New("blob slot < minimum_request_epoch")
+	ErrMaxBlobReqExceeded     = errors.New("requested more than MAX_REQUEST_BLOB_SIDECARS")
+	ErrResourceUnavailable    = errors.New("resource requested unavailable")
 )

beacon-chain/p2p/utils.go

@@ -54,45 +54,38 @@ func privKey(cfg *Config) (*ecdsa.PrivateKey, error) {
 		return privKeyFromFile(cfg.PrivateKey)
 	}
 
-	// Default keys have the next highest precedence, if they exist.
 	_, err := os.Stat(defaultKeyPath)
 	defaultKeysExist := !os.IsNotExist(err)
 	if err != nil && defaultKeysExist {
 		return nil, err
 	}
-
+	// Default keys have the next highest precedence, if they exist.
 	if defaultKeysExist {
 		return privKeyFromFile(defaultKeyPath)
 	}
-
 	// There are no keys on the filesystem, so we need to generate one.
 	priv, _, err := crypto.GenerateSecp256k1Key(rand.Reader)
 	if err != nil {
 		return nil, err
 	}
-
-	// If the StaticPeerID flag is not set, return the private key.
-	if !cfg.StaticPeerID {
-		return ecdsaprysm.ConvertFromInterfacePrivKey(priv)
+	// If the StaticPeerID flag is set, save the generated key as the default
+	// key, so that it will be used by default on the next node start.
+	if cfg.StaticPeerID {
+		rawbytes, err := priv.Raw()
+		if err != nil {
+			return nil, err
+		}
+		dst := make([]byte, hex.EncodedLen(len(rawbytes)))
+		hex.Encode(dst, rawbytes)
+		if err := file.WriteFile(defaultKeyPath, dst); err != nil {
+			return nil, err
+		}
+		log.Infof("Wrote network key to file")
+		// Read the key from the defaultKeyPath file just written
+		// for the strongest guarantee that the next start will be the same as this one.
+		return privKeyFromFile(defaultKeyPath)
 	}
-
-	// Save the generated key as the default key, so that it will be used by
-	// default on the next node start.
-	rawbytes, err := priv.Raw()
-	if err != nil {
-		return nil, err
-	}
-
-	dst := make([]byte, hex.EncodedLen(len(rawbytes)))
-	hex.Encode(dst, rawbytes)
-	if err := file.WriteFile(defaultKeyPath, dst); err != nil {
-		return nil, err
-	}
-
-	log.Info("Wrote network key to file")
-	// Read the key from the defaultKeyPath file just written
-	// for the strongest guarantee that the next start will be the same as this one.
-	return privKeyFromFile(defaultKeyPath)
+	return ecdsaprysm.ConvertFromInterfacePrivKey(priv)
 }
 
 // Retrieves a p2p networking private key from a file path.

beacon-chain/rpc/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "endpoints.go",
         "log.go",
         "service.go",
     ],
@@ -59,9 +58,6 @@ go_library(
         "@com_github_grpc_ecosystem_go_grpc_middleware//tracing/opentracing:go_default_library",
         "@com_github_grpc_ecosystem_go_grpc_prometheus//: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_prometheus_client_golang//prometheus/promhttp:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//plugin/ocgrpc:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
@@ -74,14 +70,23 @@ go_library(
 go_test(
     name = "go_default_test",
     size = "medium",
-    srcs = [
-        "endpoints_test.go",
-        "service_test.go",
-    ],
+    srcs = ["service_test.go"],
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/execution/testing:go_default_library",
+        "//beacon-chain/rpc/eth/beacon:go_default_library",
+        "//beacon-chain/rpc/eth/blob:go_default_library",
+        "//beacon-chain/rpc/eth/builder:go_default_library",
+        "//beacon-chain/rpc/eth/debug:go_default_library",
+        "//beacon-chain/rpc/eth/events:go_default_library",
+        "//beacon-chain/rpc/eth/light-client:go_default_library",
+        "//beacon-chain/rpc/eth/node:go_default_library",
+        "//beacon-chain/rpc/eth/rewards:go_default_library",
+        "//beacon-chain/rpc/eth/validator:go_default_library",
+        "//beacon-chain/rpc/prysm/beacon:go_default_library",
+        "//beacon-chain/rpc/prysm/node:go_default_library",
+        "//beacon-chain/rpc/prysm/validator:go_default_library",
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/sync/initial-sync/testing:go_default_library",
         "//testing/assert:go_default_library",

beacon-chain/rpc/core/BUILD.bazel

@@ -26,6 +26,7 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/sync:go_default_library",
+        "//beacon-chain/verification:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",

beacon-chain/rpc/core/validator.go

@@ -18,6 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	beaconState "github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -222,6 +223,18 @@ func (s *Service) SubmitSignedContributionAndProof(
 
 	errs, ctx := errgroup.WithContext(ctx)
 
+	sigRoot, aggKey, msgErr := verification.SignedContributionAndProofValidationSetup(ctx, s.HeadFetcher, req)
+	if msgErr != nil {
+		return &RpcError{Err: msgErr.Err, Reason: BadRequest}
+	}
+	valid, err := bls.VerifySignature(req.Signature, sigRoot, aggKey)
+	if err != nil {
+		return &RpcError{Err: err, Reason: Internal}
+	}
+	if !valid {
+		return &RpcError{Err: errors.New("request signature invalid based on request message"), Reason: BadRequest}
+	}
+
 	// Broadcasting and saving contribution into the pool in parallel. As one fail should not affect another.
 	errs.Go(func() error {
 		return s.Broadcaster.Broadcast(ctx, req)
@@ -232,7 +245,7 @@ func (s *Service) SubmitSignedContributionAndProof(
 	}
 
 	// Wait for p2p broadcast to complete and return the first error (if any)
-	err := errs.Wait()
+	err = errs.Wait()
 	if err != nil {
 		return &RpcError{Err: err, Reason: Internal}
 	}
@@ -401,19 +414,7 @@ func (s *Service) GetAttestationData(
 	if err != nil {
 		return nil, &RpcError{Reason: Internal, Err: errors.Wrap(err, "could not get target root")}
 	}
-
-	headState, err := s.HeadFetcher.HeadState(ctx)
-	if err != nil {
-		return nil, &RpcError{Reason: Internal, Err: errors.Wrap(err, "could not get head state")}
-	}
-	if coreTime.CurrentEpoch(headState) < slots.ToEpoch(req.Slot) { // Ensure justified checkpoint safety by processing head state across the boundary.
-		headState, err = transition.ProcessSlotsUsingNextSlotCache(ctx, headState, headRoot, req.Slot)
-		if err != nil {
-			return nil, &RpcError{Reason: Internal, Err: errors.Errorf("could not process slots up to %d: %v", req.Slot, err)}
-		}
-	}
-	justifiedCheckpoint := headState.CurrentJustifiedCheckpoint()
-
+	justifiedCheckpoint := s.FinalizedFetcher.CurrentJustifiedCheckpt()
 	if err = s.AttestationCache.Put(&cache.AttestationConsensusData{
 		Slot:     req.Slot,
 		HeadRoot: headRoot,

beacon-chain/rpc/endpoints.go

@@ -1,780 +0,0 @@
-package rpc
-
-import (
-	"net/http"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/beacon"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/blob"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/builder"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/config"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/debug"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/events"
-	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/light-client"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/node"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/rewards"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/validator"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/lookup"
-	beaconprysm "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/beacon"
-	nodeprysm "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/node"
-	validatorv1alpha1 "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/v1alpha1/validator"
-	validatorprysm "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/validator"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
-)
-
-type endpoint struct {
-	template string
-	name     string
-	handler  http.HandlerFunc
-	methods  []string
-}
-
-func (s *Service) endpoints(
-	enableDebug bool,
-	blocker lookup.Blocker,
-	stater lookup.Stater,
-	rewardFetcher rewards.BlockRewardsFetcher,
-	validatorServer *validatorv1alpha1.Server,
-	coreService *core.Service,
-	ch *stategen.CanonicalHistory,
-) []endpoint {
-	endpoints := make([]endpoint, 0)
-	endpoints = append(endpoints, s.rewardsEndpoints(blocker, stater, rewardFetcher)...)
-	endpoints = append(endpoints, s.builderEndpoints(stater)...)
-	endpoints = append(endpoints, s.blobEndpoints(blocker)...)
-	endpoints = append(endpoints, s.validatorEndpoints(validatorServer, stater, coreService, rewardFetcher)...)
-	endpoints = append(endpoints, s.nodeEndpoints()...)
-	endpoints = append(endpoints, s.beaconEndpoints(ch, stater, blocker, validatorServer, coreService)...)
-	endpoints = append(endpoints, s.configEndpoints()...)
-	endpoints = append(endpoints, s.lightClientEndpoints(blocker, stater)...)
-	endpoints = append(endpoints, s.eventsEndpoints()...)
-	endpoints = append(endpoints, s.prysmBeaconEndpoints(ch, stater)...)
-	endpoints = append(endpoints, s.prysmNodeEndpoints()...)
-	endpoints = append(endpoints, s.prysmValidatorEndpoints(coreService, stater)...)
-	if enableDebug {
-		endpoints = append(endpoints, s.debugEndpoints(stater)...)
-	}
-	return endpoints
-}
-
-func (s *Service) rewardsEndpoints(blocker lookup.Blocker, stater lookup.Stater, rewardFetcher rewards.BlockRewardsFetcher) []endpoint {
-	server := &rewards.Server{
-		Blocker:               blocker,
-		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
-		FinalizationFetcher:   s.cfg.FinalizationFetcher,
-		TimeFetcher:           s.cfg.GenesisTimeFetcher,
-		Stater:                stater,
-		HeadFetcher:           s.cfg.HeadFetcher,
-		BlockRewardFetcher:    rewardFetcher,
-	}
-
-	const namespace = "rewards"
-	return []endpoint{
-		{
-			template: "/eth/v1/beacon/rewards/blocks/{block_id}",
-			name:     namespace + ".BlockRewards",
-			handler:  server.BlockRewards,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/rewards/attestations/{epoch}",
-			name:     namespace + ".AttestationRewards",
-			handler:  server.AttestationRewards,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/beacon/rewards/sync_committee/{block_id}",
-			name:     namespace + ".SyncCommitteeRewards",
-			handler:  server.SyncCommitteeRewards,
-			methods:  []string{http.MethodPost},
-		},
-	}
-}
-
-func (s *Service) builderEndpoints(stater lookup.Stater) []endpoint {
-	server := &builder.Server{
-		FinalizationFetcher:   s.cfg.FinalizationFetcher,
-		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
-		Stater:                stater,
-	}
-
-	const namespace = "builder"
-	return []endpoint{
-		{
-			template: "/eth/v1/builder/states/{state_id}/expected_withdrawals",
-			name:     namespace + ".ExpectedWithdrawals",
-			handler:  server.ExpectedWithdrawals,
-			methods:  []string{http.MethodGet},
-		},
-	}
-}
-
-func (s *Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
-	server := &blob.Server{
-		Blocker: blocker,
-	}
-
-	const namespace = "blob"
-	return []endpoint{
-		{
-			template: "/eth/v1/beacon/blob_sidecars/{block_id}",
-			name:     namespace + ".Blobs",
-			handler:  server.Blobs,
-			methods:  []string{http.MethodGet},
-		},
-	}
-}
-
-func (s *Service) validatorEndpoints(
-	validatorServer *validatorv1alpha1.Server,
-	stater lookup.Stater,
-	coreService *core.Service,
-	rewardFetcher rewards.BlockRewardsFetcher,
-) []endpoint {
-	server := &validator.Server{
-		HeadFetcher:            s.cfg.HeadFetcher,
-		TimeFetcher:            s.cfg.GenesisTimeFetcher,
-		SyncChecker:            s.cfg.SyncService,
-		OptimisticModeFetcher:  s.cfg.OptimisticModeFetcher,
-		AttestationsPool:       s.cfg.AttestationsPool,
-		PeerManager:            s.cfg.PeerManager,
-		Broadcaster:            s.cfg.Broadcaster,
-		V1Alpha1Server:         validatorServer,
-		Stater:                 stater,
-		SyncCommitteePool:      s.cfg.SyncCommitteeObjectPool,
-		ChainInfoFetcher:       s.cfg.ChainInfoFetcher,
-		BeaconDB:               s.cfg.BeaconDB,
-		BlockBuilder:           s.cfg.BlockBuilder,
-		OperationNotifier:      s.cfg.OperationNotifier,
-		TrackedValidatorsCache: s.cfg.TrackedValidatorsCache,
-		PayloadIDCache:         s.cfg.PayloadIDCache,
-		CoreService:            coreService,
-		BlockRewardFetcher:     rewardFetcher,
-	}
-
-	const namespace = "validator"
-	return []endpoint{
-		{
-			template: "/eth/v1/validator/aggregate_attestation",
-			name:     namespace + ".GetAggregateAttestation",
-			handler:  server.GetAggregateAttestation,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/validator/contribution_and_proofs",
-			name:     namespace + ".SubmitContributionAndProofs",
-			handler:  server.SubmitContributionAndProofs,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/validator/aggregate_and_proofs",
-			name:     namespace + ".SubmitAggregateAndProofs",
-			handler:  server.SubmitAggregateAndProofs,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/validator/sync_committee_contribution",
-			name:     namespace + ".ProduceSyncCommitteeContribution",
-			handler:  server.ProduceSyncCommitteeContribution,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/validator/sync_committee_subscriptions",
-			name:     namespace + ".SubmitSyncCommitteeSubscription",
-			handler:  server.SubmitSyncCommitteeSubscription,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/validator/beacon_committee_subscriptions",
-			name:     namespace + ".SubmitBeaconCommitteeSubscription",
-			handler:  server.SubmitBeaconCommitteeSubscription,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/validator/attestation_data",
-			name:     namespace + ".GetAttestationData",
-			handler:  server.GetAttestationData,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/validator/register_validator",
-			name:     namespace + ".RegisterValidator",
-			handler:  server.RegisterValidator,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/validator/duties/attester/{epoch}",
-			name:     namespace + ".GetAttesterDuties",
-			handler:  server.GetAttesterDuties,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/validator/duties/proposer/{epoch}",
-			name:     namespace + ".GetProposerDuties",
-			handler:  server.GetProposerDuties,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/validator/duties/sync/{epoch}",
-			name:     namespace + ".GetSyncCommitteeDuties",
-			handler:  server.GetSyncCommitteeDuties,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/validator/prepare_beacon_proposer",
-			name:     namespace + ".PrepareBeaconProposer",
-			handler:  server.PrepareBeaconProposer,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/validator/liveness/{epoch}",
-			name:     namespace + ".GetLiveness",
-			handler:  server.GetLiveness,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v2/validator/blocks/{slot}",
-			name:     namespace + ".ProduceBlockV2",
-			handler:  server.ProduceBlockV2,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/validator/blinded_blocks/{slot}",
-			name:     namespace + ".ProduceBlindedBlock",
-			handler:  server.ProduceBlindedBlock,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v3/validator/blocks/{slot}",
-			name:     namespace + ".ProduceBlockV3",
-			handler:  server.ProduceBlockV3,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/validator/beacon_committee_selections",
-			name:     namespace + ".BeaconCommitteeSelections",
-			handler:  server.BeaconCommitteeSelections,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/validator/sync_committee_selections",
-			name:     namespace + ".SyncCommittee Selections",
-			handler:  server.SyncCommitteeSelections,
-			methods:  []string{http.MethodPost},
-		},
-	}
-}
-
-func (s *Service) nodeEndpoints() []endpoint {
-	server := &node.Server{
-		BeaconDB:                  s.cfg.BeaconDB,
-		Server:                    s.grpcServer,
-		SyncChecker:               s.cfg.SyncService,
-		OptimisticModeFetcher:     s.cfg.OptimisticModeFetcher,
-		GenesisTimeFetcher:        s.cfg.GenesisTimeFetcher,
-		PeersFetcher:              s.cfg.PeersFetcher,
-		PeerManager:               s.cfg.PeerManager,
-		MetadataProvider:          s.cfg.MetadataProvider,
-		HeadFetcher:               s.cfg.HeadFetcher,
-		ExecutionChainInfoFetcher: s.cfg.ExecutionChainInfoFetcher,
-	}
-
-	const namespace = "node"
-	return []endpoint{
-		{
-			template: "/eth/v1/node/syncing",
-			name:     namespace + ".GetSyncStatus",
-			handler:  server.GetSyncStatus,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/node/identity",
-			name:     namespace + ".GetIdentity",
-			handler:  server.GetIdentity,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/node/peers/{peer_id}",
-			name:     namespace + ".GetPeer",
-			handler:  server.GetPeer,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/node/peers",
-			name:     namespace + ".GetPeers",
-			handler:  server.GetPeers,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/node/peer_count",
-			name:     namespace + ".GetPeerCount",
-			handler:  server.GetPeerCount,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/node/version",
-			name:     namespace + ".GetVersion",
-			handler:  server.GetVersion,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/node/health",
-			name:     namespace + ".GetHealth",
-			handler:  server.GetHealth,
-			methods:  []string{http.MethodGet},
-		},
-	}
-}
-
-func (s *Service) beaconEndpoints(
-	ch *stategen.CanonicalHistory,
-	stater lookup.Stater,
-	blocker lookup.Blocker,
-	validatorServer *validatorv1alpha1.Server,
-	coreService *core.Service,
-) []endpoint {
-	server := &beacon.Server{
-		CanonicalHistory:              ch,
-		BeaconDB:                      s.cfg.BeaconDB,
-		AttestationsPool:              s.cfg.AttestationsPool,
-		SlashingsPool:                 s.cfg.SlashingsPool,
-		ChainInfoFetcher:              s.cfg.ChainInfoFetcher,
-		GenesisTimeFetcher:            s.cfg.GenesisTimeFetcher,
-		BlockNotifier:                 s.cfg.BlockNotifier,
-		OperationNotifier:             s.cfg.OperationNotifier,
-		Broadcaster:                   s.cfg.Broadcaster,
-		BlockReceiver:                 s.cfg.BlockReceiver,
-		StateGenService:               s.cfg.StateGen,
-		Stater:                        stater,
-		Blocker:                       blocker,
-		OptimisticModeFetcher:         s.cfg.OptimisticModeFetcher,
-		HeadFetcher:                   s.cfg.HeadFetcher,
-		TimeFetcher:                   s.cfg.GenesisTimeFetcher,
-		VoluntaryExitsPool:            s.cfg.ExitPool,
-		V1Alpha1ValidatorServer:       validatorServer,
-		SyncChecker:                   s.cfg.SyncService,
-		ExecutionPayloadReconstructor: s.cfg.ExecutionPayloadReconstructor,
-		BLSChangesPool:                s.cfg.BLSChangesPool,
-		FinalizationFetcher:           s.cfg.FinalizationFetcher,
-		ForkchoiceFetcher:             s.cfg.ForkchoiceFetcher,
-		CoreService:                   coreService,
-	}
-
-	const namespace = "beacon"
-	return []endpoint{
-		{
-			template: "/eth/v1/beacon/states/{state_id}/committees",
-			name:     namespace + ".GetCommittees",
-			handler:  server.GetCommittees,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/states/{state_id}/fork",
-			name:     namespace + ".GetStateFork",
-			handler:  server.GetStateFork,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/states/{state_id}/root",
-			name:     namespace + ".GetStateRoot",
-			handler:  server.GetStateRoot,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/states/{state_id}/sync_committees",
-			name:     namespace + ".GetSyncCommittees",
-			handler:  server.GetSyncCommittees,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/states/{state_id}/randao",
-			name:     namespace + ".GetRandao",
-			handler:  server.GetRandao,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/blocks",
-			name:     namespace + ".PublishBlock",
-			handler:  server.PublishBlock,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/beacon/blinded_blocks",
-			name:     namespace + ".PublishBlindedBlock",
-			handler:  server.PublishBlindedBlock,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v2/beacon/blocks",
-			name:     namespace + ".PublishBlockV2",
-			handler:  server.PublishBlockV2,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v2/beacon/blinded_blocks",
-			name:     namespace + ".PublishBlindedBlockV2",
-			handler:  server.PublishBlindedBlockV2,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v2/beacon/blocks/{block_id}",
-			name:     namespace + ".GetBlockV2",
-			handler:  server.GetBlockV2,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/blocks/{block_id}/attestations",
-			name:     namespace + ".GetBlockAttestations",
-			handler:  server.GetBlockAttestations,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/blinded_blocks/{block_id}",
-			name:     namespace + ".GetBlindedBlock",
-			handler:  server.GetBlindedBlock,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/blocks/{block_id}/root",
-			name:     namespace + ".GetBlockRoot",
-			handler:  server.GetBlockRoot,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/pool/attestations",
-			name:     namespace + ".ListAttestations",
-			handler:  server.ListAttestations,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/pool/attestations",
-			name:     namespace + ".SubmitAttestations",
-			handler:  server.SubmitAttestations,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/beacon/pool/voluntary_exits",
-			name:     namespace + ".ListVoluntaryExits",
-			handler:  server.ListVoluntaryExits,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/pool/voluntary_exits",
-			name:     namespace + ".SubmitVoluntaryExit",
-			handler:  server.SubmitVoluntaryExit,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/beacon/pool/sync_committees",
-			name:     namespace + ".SubmitSyncCommitteeSignatures",
-			handler:  server.SubmitSyncCommitteeSignatures,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/beacon/pool/bls_to_execution_changes",
-			name:     namespace + ".ListBLSToExecutionChanges",
-			handler:  server.ListBLSToExecutionChanges,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/pool/bls_to_execution_changes",
-			name:     namespace + ".SubmitBLSToExecutionChanges",
-			handler:  server.SubmitBLSToExecutionChanges,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/beacon/pool/attester_slashings",
-			name:     namespace + ".GetAttesterSlashings",
-			handler:  server.GetAttesterSlashings,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/pool/attester_slashings",
-			name:     namespace + ".SubmitAttesterSlashing",
-			handler:  server.SubmitAttesterSlashing,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/beacon/pool/proposer_slashings",
-			name:     namespace + ".GetProposerSlashings",
-			handler:  server.GetProposerSlashings,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/pool/proposer_slashings",
-			name:     namespace + ".SubmitProposerSlashing",
-			handler:  server.SubmitProposerSlashing,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/eth/v1/beacon/headers",
-			name:     namespace + ".GetBlockHeaders",
-			handler:  server.GetBlockHeaders,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/headers/{block_id}",
-			name:     namespace + ".GetBlockHeader",
-			handler:  server.GetBlockHeader,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/genesis",
-			name:     namespace + ".GetGenesis",
-			handler:  server.GetGenesis,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/states/{state_id}/finality_checkpoints",
-			name:     namespace + ".GetFinalityCheckpoints",
-			handler:  server.GetFinalityCheckpoints,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/states/{state_id}/validators",
-			name:     namespace + ".GetValidators",
-			handler:  server.GetValidators,
-			methods:  []string{http.MethodGet, http.MethodPost},
-		},
-		{
-			template: "/eth/v1/beacon/states/{state_id}/validators/{validator_id}",
-			name:     namespace + ".GetValidator",
-			handler:  server.GetValidator,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/states/{state_id}/validator_balances",
-			name:     namespace + ".GetValidatorBalances",
-			handler:  server.GetValidatorBalances,
-			methods:  []string{http.MethodGet, http.MethodPost},
-		},
-	}
-}
-
-func (s *Service) configEndpoints() []endpoint {
-	const namespace = "config"
-	return []endpoint{
-		{
-			template: "/eth/v1/config/deposit_contract",
-			name:     namespace + ".GetDepositContract",
-			handler:  config.GetDepositContract,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/config/fork_schedule",
-			name:     namespace + ".GetForkSchedule",
-			handler:  config.GetForkSchedule,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/config/spec",
-			name:     namespace + ".GetSpec",
-			handler:  config.GetSpec,
-			methods:  []string{http.MethodGet},
-		},
-	}
-}
-
-func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Stater) []endpoint {
-	server := &lightclient.Server{
-		Blocker:     blocker,
-		Stater:      stater,
-		HeadFetcher: s.cfg.HeadFetcher,
-	}
-
-	const namespace = "lightclient"
-	return []endpoint{
-		{
-			template: "/eth/v1/beacon/light_client/bootstrap/{block_root}",
-			name:     namespace + ".GetLightClientBootstrap",
-			handler:  server.GetLightClientBootstrap,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/light_client/updates",
-			name:     namespace + ".GetLightClientUpdatesByRange",
-			handler:  server.GetLightClientUpdatesByRange,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/light_client/finality_update",
-			name:     namespace + ".GetLightClientFinalityUpdate",
-			handler:  server.GetLightClientFinalityUpdate,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/light_client/optimistic_update",
-			name:     namespace + ".GetLightClientOptimisticUpdate",
-			handler:  server.GetLightClientOptimisticUpdate,
-			methods:  []string{http.MethodGet},
-		},
-	}
-}
-
-func (s *Service) debugEndpoints(stater lookup.Stater) []endpoint {
-	server := &debug.Server{
-		BeaconDB:              s.cfg.BeaconDB,
-		HeadFetcher:           s.cfg.HeadFetcher,
-		Stater:                stater,
-		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
-		ForkFetcher:           s.cfg.ForkFetcher,
-		ForkchoiceFetcher:     s.cfg.ForkchoiceFetcher,
-		FinalizationFetcher:   s.cfg.FinalizationFetcher,
-		ChainInfoFetcher:      s.cfg.ChainInfoFetcher,
-	}
-
-	const namespace = "debug"
-	return []endpoint{
-		{
-			template: "/eth/v2/debug/beacon/states/{state_id}",
-			name:     namespace + ".GetBeaconStateV2",
-			handler:  server.GetBeaconStateV2,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v2/debug/beacon/heads",
-			name:     namespace + ".GetForkChoiceHeadsV2",
-			handler:  server.GetForkChoiceHeadsV2,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/debug/fork_choice",
-			name:     namespace + ".GetForkChoice",
-			handler:  server.GetForkChoice,
-			methods:  []string{http.MethodGet},
-		},
-	}
-}
-
-func (s *Service) eventsEndpoints() []endpoint {
-	server := &events.Server{
-		StateNotifier:     s.cfg.StateNotifier,
-		OperationNotifier: s.cfg.OperationNotifier,
-		HeadFetcher:       s.cfg.HeadFetcher,
-		ChainInfoFetcher:  s.cfg.ChainInfoFetcher,
-	}
-
-	const namespace = "events"
-	return []endpoint{
-		{
-			template: "/eth/v1/events",
-			name:     namespace + ".StreamEvents",
-			handler:  server.StreamEvents,
-			methods:  []string{http.MethodGet},
-		},
-	}
-}
-
-// Prysm custom endpoints
-
-func (s *Service) prysmBeaconEndpoints(ch *stategen.CanonicalHistory, stater lookup.Stater) []endpoint {
-	server := &beaconprysm.Server{
-		SyncChecker:           s.cfg.SyncService,
-		HeadFetcher:           s.cfg.HeadFetcher,
-		TimeFetcher:           s.cfg.GenesisTimeFetcher,
-		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
-		CanonicalHistory:      ch,
-		BeaconDB:              s.cfg.BeaconDB,
-		Stater:                stater,
-		ChainInfoFetcher:      s.cfg.ChainInfoFetcher,
-		FinalizationFetcher:   s.cfg.FinalizationFetcher,
-	}
-
-	const namespace = "prysm.beacon"
-	return []endpoint{
-		{
-			template: "/prysm/v1/beacon/weak_subjectivity",
-			name:     namespace + ".GetWeakSubjectivity",
-			handler:  server.GetWeakSubjectivity,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/states/{state_id}/validator_count",
-			name:     namespace + ".GetValidatorCount",
-			handler:  server.GetValidatorCount,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/prysm/v1/beacon/states/{state_id}/validator_count",
-			name:     namespace + ".GetValidatorCount",
-			handler:  server.GetValidatorCount,
-			methods:  []string{http.MethodGet},
-		},
-	}
-}
-
-func (s *Service) prysmNodeEndpoints() []endpoint {
-	server := &nodeprysm.Server{
-		BeaconDB:                  s.cfg.BeaconDB,
-		SyncChecker:               s.cfg.SyncService,
-		OptimisticModeFetcher:     s.cfg.OptimisticModeFetcher,
-		GenesisTimeFetcher:        s.cfg.GenesisTimeFetcher,
-		PeersFetcher:              s.cfg.PeersFetcher,
-		PeerManager:               s.cfg.PeerManager,
-		MetadataProvider:          s.cfg.MetadataProvider,
-		HeadFetcher:               s.cfg.HeadFetcher,
-		ExecutionChainInfoFetcher: s.cfg.ExecutionChainInfoFetcher,
-	}
-
-	const namespace = "prysm.node"
-	return []endpoint{
-		{
-			template: "/prysm/node/trusted_peers",
-			name:     namespace + ".ListTrustedPeer",
-			handler:  server.ListTrustedPeer,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/prysm/v1/node/trusted_peers",
-			name:     namespace + ".ListTrustedPeer",
-			handler:  server.ListTrustedPeer,
-			methods:  []string{http.MethodGet},
-		},
-		{
-			template: "/prysm/node/trusted_peers",
-			name:     namespace + ".AddTrustedPeer",
-			handler:  server.AddTrustedPeer,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/prysm/v1/node/trusted_peers",
-			name:     namespace + ".AddTrustedPeer",
-			handler:  server.AddTrustedPeer,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/prysm/node/trusted_peers/{peer_id}",
-			name:     namespace + ".RemoveTrustedPeer",
-			handler:  server.RemoveTrustedPeer,
-			methods:  []string{http.MethodDelete},
-		},
-		{
-			template: "/prysm/v1/node/trusted_peers/{peer_id}",
-			name:     namespace + ".RemoveTrustedPeer",
-			handler:  server.RemoveTrustedPeer,
-			methods:  []string{http.MethodDelete},
-		},
-	}
-}
-
-func (s *Service) prysmValidatorEndpoints(coreService *core.Service, stater lookup.Stater) []endpoint {
-	server := &validatorprysm.Server{
-		CoreService: coreService,
-	}
-
-	const namespace = "prysm.validator"
-	return []endpoint{
-		{
-			template: "/prysm/validators/performance",
-			name:     namespace + ".GetValidatorPerformance",
-			handler:  server.GetValidatorPerformance,
-			methods:  []string{http.MethodPost},
-		},
-		{
-			template: "/prysm/v1/validators/performance",
-			name:     namespace + ".GetValidatorPerformance",
-			handler:  server.GetValidatorPerformance,
-			methods:  []string{http.MethodPost},
-		},
-	}
-}

beacon-chain/rpc/endpoints_test.go

@@ -1,150 +0,0 @@
-package rpc
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-)
-
-func Test_endpoints(t *testing.T) {
-	rewardsRoutes := map[string][]string{
-		"/eth/v1/beacon/rewards/blocks/{block_id}":         {http.MethodGet},
-		"/eth/v1/beacon/rewards/attestations/{epoch}":      {http.MethodPost},
-		"/eth/v1/beacon/rewards/sync_committee/{block_id}": {http.MethodPost},
-	}
-
-	beaconRoutes := map[string][]string{
-		"/eth/v1/beacon/genesis":                                     {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/root":                      {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/fork":                      {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/finality_checkpoints":      {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/validators":                {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/states/{state_id}/validators/{validator_id}": {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/validator_balances":        {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/states/{state_id}/committees":                {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/sync_committees":           {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/randao":                    {http.MethodGet},
-		"/eth/v1/beacon/headers":                                     {http.MethodGet},
-		"/eth/v1/beacon/headers/{block_id}":                          {http.MethodGet},
-		"/eth/v1/beacon/blinded_blocks":                              {http.MethodPost},
-		"/eth/v2/beacon/blinded_blocks":                              {http.MethodPost},
-		"/eth/v1/beacon/blocks":                                      {http.MethodPost},
-		"/eth/v2/beacon/blocks":                                      {http.MethodPost},
-		"/eth/v1/beacon/blocks/{block_id}":                           {http.MethodGet},
-		"/eth/v2/beacon/blocks/{block_id}":                           {http.MethodGet},
-		"/eth/v1/beacon/blocks/{block_id}/root":                      {http.MethodGet},
-		"/eth/v1/beacon/blocks/{block_id}/attestations":              {http.MethodGet},
-		"/eth/v1/beacon/blob_sidecars/{block_id}":                    {http.MethodGet},
-		"/eth/v1/beacon/deposit_snapshot":                            {http.MethodGet},
-		"/eth/v1/beacon/blinded_blocks/{block_id}":                   {http.MethodGet},
-		"/eth/v1/beacon/pool/attestations":                           {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/pool/attester_slashings":                     {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/pool/proposer_slashings":                     {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/pool/sync_committees":                        {http.MethodPost},
-		"/eth/v1/beacon/pool/voluntary_exits":                        {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/pool/bls_to_execution_changes":               {http.MethodGet, http.MethodPost},
-	}
-
-	lightClientRoutes := map[string][]string{
-		"/eth/v1/beacon/light_client/bootstrap/{block_root}": {http.MethodGet},
-		"/eth/v1/beacon/light_client/updates":                {http.MethodGet},
-		"/eth/v1/beacon/light_client/finality_update":        {http.MethodGet},
-		"/eth/v1/beacon/light_client/optimistic_update":      {http.MethodGet},
-	}
-
-	builderRoutes := map[string][]string{
-		"/eth/v1/builder/states/{state_id}/expected_withdrawals": {http.MethodGet},
-	}
-
-	blobRoutes := map[string][]string{
-		"/eth/v1/beacon/blob_sidecars/{block_id}": {http.MethodGet},
-	}
-
-	configRoutes := map[string][]string{
-		"/eth/v1/config/fork_schedule":    {http.MethodGet},
-		"/eth/v1/config/spec":             {http.MethodGet},
-		"/eth/v1/config/deposit_contract": {http.MethodGet},
-	}
-
-	debugRoutes := map[string][]string{
-		"/eth/v1/debug/beacon/states/{state_id}": {http.MethodGet},
-		"/eth/v2/debug/beacon/states/{state_id}": {http.MethodGet},
-		"/eth/v2/debug/beacon/heads":             {http.MethodGet},
-		"/eth/v1/debug/fork_choice":              {http.MethodGet},
-	}
-
-	eventsRoutes := map[string][]string{
-		"/eth/v1/events": {http.MethodGet},
-	}
-
-	nodeRoutes := map[string][]string{
-		"/eth/v1/node/identity":        {http.MethodGet},
-		"/eth/v1/node/peers":           {http.MethodGet},
-		"/eth/v1/node/peers/{peer_id}": {http.MethodGet},
-		"/eth/v1/node/peer_count":      {http.MethodGet},
-		"/eth/v1/node/version":         {http.MethodGet},
-		"/eth/v1/node/syncing":         {http.MethodGet},
-		"/eth/v1/node/health":          {http.MethodGet},
-	}
-
-	validatorRoutes := map[string][]string{
-		"/eth/v1/validator/duties/attester/{epoch}":        {http.MethodPost},
-		"/eth/v1/validator/duties/proposer/{epoch}":        {http.MethodGet},
-		"/eth/v1/validator/duties/sync/{epoch}":            {http.MethodPost},
-		"/eth/v2/validator/blocks/{slot}":                  {http.MethodGet},
-		"/eth/v3/validator/blocks/{slot}":                  {http.MethodGet},
-		"/eth/v1/validator/blinded_blocks/{slot}":          {http.MethodGet},
-		"/eth/v1/validator/attestation_data":               {http.MethodGet},
-		"/eth/v1/validator/aggregate_attestation":          {http.MethodGet},
-		"/eth/v1/validator/aggregate_and_proofs":           {http.MethodPost},
-		"/eth/v1/validator/beacon_committee_subscriptions": {http.MethodPost},
-		"/eth/v1/validator/sync_committee_subscriptions":   {http.MethodPost},
-		"/eth/v1/validator/beacon_committee_selections":    {http.MethodPost},
-		"/eth/v1/validator/sync_committee_selections":      {http.MethodPost},
-		"/eth/v1/validator/sync_committee_contribution":    {http.MethodGet},
-		"/eth/v1/validator/contribution_and_proofs":        {http.MethodPost},
-		"/eth/v1/validator/prepare_beacon_proposer":        {http.MethodPost},
-		"/eth/v1/validator/register_validator":             {http.MethodPost},
-		"/eth/v1/validator/liveness/{epoch}":               {http.MethodPost},
-	}
-
-	prysmBeaconRoutes := map[string][]string{
-		"/prysm/v1/beacon/weak_subjectivity":                 {http.MethodGet},
-		"/eth/v1/beacon/states/{state_id}/validator_count":   {http.MethodGet},
-		"/prysm/v1/beacon/states/{state_id}/validator_count": {http.MethodGet},
-	}
-
-	prysmNodeRoutes := map[string][]string{
-		"/prysm/node/trusted_peers":              {http.MethodGet, http.MethodPost},
-		"/prysm/v1/node/trusted_peers":           {http.MethodGet, http.MethodPost},
-		"/prysm/node/trusted_peers/{peer_id}":    {http.MethodDelete},
-		"/prysm/v1/node/trusted_peers/{peer_id}": {http.MethodDelete},
-	}
-
-	prysmValidatorRoutes := map[string][]string{
-		"/prysm/validators/performance":    {http.MethodPost},
-		"/prysm/v1/validators/performance": {http.MethodPost},
-	}
-
-	s := &Service{cfg: &Config{}}
-
-	routesMap := combineMaps(beaconRoutes, builderRoutes, configRoutes, debugRoutes, eventsRoutes, nodeRoutes, validatorRoutes, rewardsRoutes, lightClientRoutes, blobRoutes, prysmValidatorRoutes, prysmNodeRoutes, prysmBeaconRoutes)
-	actual := s.endpoints(true, nil, nil, nil, nil, nil, nil)
-	for _, e := range actual {
-		methods, ok := routesMap[e.template]
-		assert.Equal(t, true, ok, "endpoint "+e.template+" not found")
-		if ok {
-			for _, em := range e.methods {
-				methodFound := false
-				for _, m := range methods {
-					if m == em {
-						methodFound = true
-						break
-					}
-				}
-				assert.Equal(t, true, methodFound, "method "+em+" for endpoint "+e.template+" not found")
-			}
-		}
-	}
-}

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

@@ -156,6 +156,9 @@ func TestGetSpec(t *testing.T) {
 	var dam [4]byte
 	copy(dam[:], []byte{'1', '0', '0', '0'})
 	config.DomainApplicationMask = dam
+	var dbs [4]byte
+	copy(dam[:], []byte{'2', '0', '0', '0'})
+	config.DomainBlobSidecar = dbs
 
 	params.OverrideBeaconConfig(config)
 
@@ -170,7 +173,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)
 
-	assert.Equal(t, 129, len(data))
+	assert.Equal(t, 130, len(data))
 	for k, v := range data {
 		switch k {
 		case "CONFIG_NAME":

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

@@ -336,11 +336,13 @@ func TestGetAggregateAttestation_SameSlotAndRoot_ReturnMostAggregationBits(t *te
 }
 
 func TestSubmitContributionAndProofs(t *testing.T) {
+	headFetcher := &mockChain.ChainService{}
 	c := &core.Service{
+		HeadFetcher:       headFetcher,
 		OperationNotifier: (&mockChain.ChainService{}).OperationNotifier(),
 	}
 
-	s := &Server{CoreService: c}
+	s := &Server{CoreService: c, HeadFetcher: headFetcher}
 
 	t.Run("single", func(t *testing.T) {
 		broadcaster := &p2pmock.MockBroadcaster{}
@@ -838,14 +840,10 @@ func TestGetAttestationData(t *testing.T) {
 		justifiedRoot, err := justifiedBlock.Block.HashTreeRoot()
 		require.NoError(t, err, "Could not get signing root for justified block")
 		slot := 3*params.BeaconConfig().SlotsPerEpoch + 1
-		beaconState, err := util.NewBeaconState()
-		require.NoError(t, err)
-		require.NoError(t, beaconState.SetSlot(slot))
 		justifiedCheckpoint := &ethpbalpha.Checkpoint{
 			Epoch: 2,
 			Root:  justifiedRoot[:],
 		}
-		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(justifiedCheckpoint))
 		offset := int64(slot.Mul(params.BeaconConfig().SecondsPerSlot))
 		chain := &mockChain.ChainService{
 			Optimistic:                 false,
@@ -853,7 +851,6 @@ func TestGetAttestationData(t *testing.T) {
 			Root:                       blockRoot[:],
 			CurrentJustifiedCheckPoint: justifiedCheckpoint,
 			TargetRoot:                 blockRoot,
-			State:                      beaconState,
 		}
 
 		s := &Server{
@@ -1081,14 +1078,10 @@ func TestGetAttestationData(t *testing.T) {
 		justifiedRoot, err := justifiedBlock.Block.HashTreeRoot()
 		require.NoError(t, err, "Could not get signing root for justified block")
 
-		beaconState, err := util.NewBeaconState()
-		require.NoError(t, err)
-		require.NoError(t, beaconState.SetSlot(slot))
 		justifiedCheckpt := &ethpbalpha.Checkpoint{
 			Epoch: 0,
 			Root:  justifiedRoot[:],
 		}
-		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(justifiedCheckpt))
 		require.NoError(t, err)
 		offset := int64(slot.Mul(params.BeaconConfig().SecondsPerSlot))
 		chain := &mockChain.ChainService{
@@ -1096,7 +1089,6 @@ func TestGetAttestationData(t *testing.T) {
 			Genesis:                    time.Now().Add(time.Duration(-1*offset) * time.Second),
 			CurrentJustifiedCheckPoint: justifiedCheckpt,
 			TargetRoot:                 blockRoot,
-			State:                      beaconState,
 		}
 
 		s := &Server{
@@ -1173,24 +1165,17 @@ func TestGetAttestationData(t *testing.T) {
 		require.NoError(t, err, "Could not hash beacon block")
 		justifiedBlockRoot, err := justifiedBlock.Block.HashTreeRoot()
 		require.NoError(t, err, "Could not hash justified block")
-
-		slot := primitives.Slot(10000)
-		beaconState, err := util.NewBeaconState()
-		require.NoError(t, err)
-		require.NoError(t, beaconState.SetSlot(slot))
 		justifiedCheckpt := &ethpbalpha.Checkpoint{
 			Epoch: slots.ToEpoch(1500),
 			Root:  justifiedBlockRoot[:],
 		}
-		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(justifiedCheckpt))
-
+		slot := primitives.Slot(10000)
 		offset := int64(slot.Mul(params.BeaconConfig().SecondsPerSlot))
 		chain := &mockChain.ChainService{
 			Root:                       blockRoot[:],
 			Genesis:                    time.Now().Add(time.Duration(-1*offset) * time.Second),
 			CurrentJustifiedCheckPoint: justifiedCheckpt,
 			TargetRoot:                 blockRoot,
-			State:                      beaconState,
 		}
 
 		s := &Server{

beacon-chain/rpc/prysm/v1alpha1/node/BUILD.bazel

@@ -18,10 +18,8 @@ go_library(
         "@com_github_golang_protobuf//ptypes/timestamp",
         "@com_github_libp2p_go_libp2p//core/network:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
-        "@org_golang_google_grpc//metadata:go_default_library",
         "@org_golang_google_grpc//status:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",
     ],
@@ -47,9 +45,7 @@ go_test(
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
-        "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_grpc//metadata:go_default_library",
         "@org_golang_google_grpc//reflection:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",

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

@@ -6,9 +6,7 @@ package node
 import (
 	"context"
 	"fmt"
-	"net/http"
 	"sort"
-	"strconv"
 	"time"
 
 	"github.com/golang/protobuf/ptypes/empty"
@@ -23,10 +21,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/io/logs"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	"go.opencensus.io/trace"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
@@ -49,35 +45,6 @@ type Server struct {
 	BeaconMonitoringPort int
 }
 
-// GetHealth checks the health of the node
-func (ns *Server) GetHealth(ctx context.Context, request *ethpb.HealthRequest) (*empty.Empty, error) {
-	ctx, span := trace.StartSpan(ctx, "node.GetHealth")
-	defer span.End()
-
-	// Set a timeout for the health check operation
-	timeoutDuration := 10 * time.Second
-	ctx, cancel := context.WithTimeout(ctx, timeoutDuration)
-	defer cancel() // Important to avoid a context leak
-
-	if ns.SyncChecker.Synced() {
-		return &empty.Empty{}, nil
-	}
-	if ns.SyncChecker.Syncing() || ns.SyncChecker.Initialized() {
-		if request.SyncingStatus != 0 {
-			// override the 200 success with the provided request status
-			if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(request.SyncingStatus, 10))); err != nil {
-				return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
-			}
-			return &empty.Empty{}, nil
-		}
-		if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(http.StatusPartialContent, 10))); err != nil {
-			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
-		}
-		return &empty.Empty{}, nil
-	}
-	return &empty.Empty{}, status.Errorf(codes.Unavailable, "service unavailable")
-}
-
 // GetSyncStatus checks the current network sync status of the node.
 func (ns *Server) GetSyncStatus(_ context.Context, _ *empty.Empty) (*ethpb.SyncStatus, error) {
 	return &ethpb.SyncStatus{

beacon-chain/rpc/prysm/v1alpha1/node/server_test.go

@@ -3,14 +3,12 @@ package node
 import (
 	"context"
 	"errors"
-	"fmt"
 	"testing"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	dbutil "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
@@ -24,7 +22,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/reflection"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -173,53 +170,3 @@ func TestNodeServer_GetETH1ConnectionStatus(t *testing.T) {
 	assert.Equal(t, ep, res.CurrentAddress)
 	assert.Equal(t, errStr, res.CurrentConnectionError)
 }
-
-func TestNodeServer_GetHealth(t *testing.T) {
-	tests := []struct {
-		name         string
-		input        *mockSync.Sync
-		customStatus uint64
-		wantedErr    string
-	}{
-		{
-			name:  "happy path",
-			input: &mockSync.Sync{IsSyncing: false, IsSynced: true},
-		},
-		{
-			name:      "syncing",
-			input:     &mockSync.Sync{IsSyncing: false},
-			wantedErr: "service unavailable",
-		},
-		{
-			name:         "custom sync status",
-			input:        &mockSync.Sync{IsSyncing: true},
-			customStatus: 206,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			server := grpc.NewServer()
-			ns := &Server{
-				SyncChecker: tt.input,
-			}
-			ethpb.RegisterNodeServer(server, ns)
-			reflection.Register(server)
-			ctx := grpc.NewContextWithServerTransportStream(context.Background(), &runtime.ServerTransportStream{})
-			_, err := ns.GetHealth(ctx, &ethpb.HealthRequest{SyncingStatus: tt.customStatus})
-			if tt.wantedErr == "" {
-				require.NoError(t, err)
-				return
-			}
-			if tt.customStatus != 0 {
-				// Assuming the call was successful, now extract the headers
-				headers, _ := metadata.FromIncomingContext(ctx)
-				// Check for the specific header
-				values, ok := headers["x-http-code"]
-				require.Equal(t, true, ok && len(values) > 0)
-				require.Equal(t, fmt.Sprintf("%d", tt.customStatus), values[0])
-
-			}
-			require.ErrorContains(t, tt.wantedErr, err)
-		})
-	}
-}

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

@@ -49,16 +49,12 @@ func TestAttestationDataAtSlot_HandlesFarAwayJustifiedEpoch(t *testing.T) {
 	justifiedBlockRoot, err := justifiedBlock.Block.HashTreeRoot()
 	require.NoError(t, err, "Could not hash justified block")
 
-	slot := primitives.Slot(10000)
-	beaconState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetSlot(slot))
 	justifiedCheckpoint := &ethpb.Checkpoint{
 		Epoch: slots.ToEpoch(1500),
 		Root:  justifiedBlockRoot[:],
 	}
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(justifiedCheckpoint))
-
+	require.NoError(t, err)
+	slot := primitives.Slot(10000)
 	offset := int64(slot.Mul(params.BeaconConfig().SecondsPerSlot))
 	attesterServer := &Server{
 		SyncChecker:           &mockSync.Sync{IsSyncing: false},
@@ -66,7 +62,7 @@ func TestAttestationDataAtSlot_HandlesFarAwayJustifiedEpoch(t *testing.T) {
 		TimeFetcher:           &mock.ChainService{Genesis: time.Now().Add(time.Duration(-1*offset) * time.Second)},
 		CoreService: &core.Service{
 			AttestationCache:      cache.NewAttestationCache(),
-			HeadFetcher:           &mock.ChainService{TargetRoot: blockRoot, Root: blockRoot[:], State: beaconState},
+			HeadFetcher:           &mock.ChainService{TargetRoot: blockRoot, Root: blockRoot[:]},
 			GenesisTimeFetcher:    &mock.ChainService{Genesis: time.Now().Add(time.Duration(-1*offset) * time.Second)},
 			FinalizedFetcher:      &mock.ChainService{CurrentJustifiedCheckPoint: justifiedCheckpoint},
 			OptimisticModeFetcher: &mock.ChainService{Optimistic: false},

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

@@ -102,21 +102,17 @@ func TestGetAttestationData_OK(t *testing.T) {
 	justifiedRoot, err := justifiedBlock.Block.HashTreeRoot()
 	require.NoError(t, err, "Could not get signing root for justified block")
 	slot := 3*params.BeaconConfig().SlotsPerEpoch + 1
-	beaconState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetSlot(slot))
 	justifiedCheckpoint := &ethpb.Checkpoint{
 		Epoch: 2,
 		Root:  justifiedRoot[:],
 	}
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(justifiedCheckpoint))
 	offset := int64(slot.Mul(params.BeaconConfig().SecondsPerSlot))
 	attesterServer := &Server{
 		SyncChecker:           &mockSync.Sync{IsSyncing: false},
 		OptimisticModeFetcher: &mock.ChainService{Optimistic: false},
 		TimeFetcher:           &mock.ChainService{Genesis: time.Now().Add(time.Duration(-1*offset) * time.Second)},
 		CoreService: &core.Service{
-			HeadFetcher: &mock.ChainService{TargetRoot: targetRoot, Root: blockRoot[:], State: beaconState},
+			HeadFetcher: &mock.ChainService{TargetRoot: targetRoot, Root: blockRoot[:]},
 			GenesisTimeFetcher: &mock.ChainService{
 				Genesis: time.Now().Add(time.Duration(-1*offset) * time.Second),
 			},
@@ -342,15 +338,10 @@ func TestGetAttestationData_SucceedsInFirstEpoch(t *testing.T) {
 	targetRoot, err := targetBlock.Block.HashTreeRoot()
 	require.NoError(t, err, "Could not get signing root for target block")
 
-	beaconState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetSlot(slot))
 	justifiedCheckpoint := &ethpb.Checkpoint{
 		Epoch: 0,
 		Root:  justifiedRoot[:],
 	}
-	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(justifiedCheckpoint))
-
 	offset := int64(slot.Mul(params.BeaconConfig().SecondsPerSlot))
 	attesterServer := &Server{
 		SyncChecker:           &mockSync.Sync{IsSyncing: false},
@@ -359,7 +350,7 @@ func TestGetAttestationData_SucceedsInFirstEpoch(t *testing.T) {
 		CoreService: &core.Service{
 			AttestationCache: cache.NewAttestationCache(),
 			HeadFetcher: &mock.ChainService{
-				TargetRoot: targetRoot, Root: blockRoot[:], State: beaconState,
+				TargetRoot: targetRoot, Root: blockRoot[:],
 			},
 			GenesisTimeFetcher:    &mock.ChainService{Genesis: prysmTime.Now().Add(time.Duration(-1*offset) * time.Second)},
 			FinalizedFetcher:      &mock.ChainService{CurrentJustifiedCheckPoint: justifiedCheckpoint},

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

@@ -2697,13 +2697,10 @@ func TestProposer_PrepareBeaconProposer(t *testing.T) {
 				BeaconDB:               db,
 				TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
 			}
-			require.Equal(t, false, proposerServer.TrackedValidatorsCache.Validating())
 			_, err := proposerServer.PrepareBeaconProposer(ctx, tt.args.request)
 			if tt.wantErr != "" {
 				require.ErrorContains(t, tt.wantErr, err)
 				return
-			} else {
-				require.Equal(t, true, proposerServer.TrackedValidatorsCache.Validating())
 			}
 			require.NoError(t, err)
 			val, tracked := proposerServer.TrackedValidatorsCache.Validator(1)

beacon-chain/rpc/service.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"fmt"
 	"net"
+	"net/http"
 	"sync"
 
 	"github.com/gorilla/mux"
@@ -14,9 +15,6 @@ import (
 	grpcopentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing"
 	grpcprometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
 	"github.com/pkg/errors"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/builder"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
@@ -34,12 +32,24 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/beacon"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/blob"
+	rpcBuilder "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/builder"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/config"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/debug"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/events"
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/light-client"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/node"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/rewards"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/validator"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/lookup"
+	beaconprysm "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/beacon"
+	nodeprysm "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/node"
 	beaconv1alpha1 "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/v1alpha1/beacon"
 	debugv1alpha1 "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/v1alpha1/debug"
 	nodev1alpha1 "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/v1alpha1/node"
 	validatorv1alpha1 "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/v1alpha1/validator"
+	validatorprysm "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/validator"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
 	chainSync "github.com/prysmaticlabs/prysm/v5/beacon-chain/sync"
@@ -58,24 +68,6 @@ import (
 
 const attestationBufferSize = 100
 
-var (
-	httpRequestLatency = promauto.NewHistogramVec(
-		prometheus.HistogramOpts{
-			Name:    "http_request_latency_seconds",
-			Help:    "Latency of HTTP requests in seconds",
-			Buckets: []float64{0.001, 0.01, 0.025, 0.1, 0.25, 1, 2.5, 10},
-		},
-		[]string{"endpoint", "code", "method"},
-	)
-	httpRequestCount = promauto.NewCounterVec(
-		prometheus.CounterOpts{
-			Name: "http_request_count",
-			Help: "Number of HTTP requests",
-		},
-		[]string{"endpoint", "code", "method"},
-	)
-)
-
 // Service defining an RPC server for a beacon node.
 type Service struct {
 	cfg                  *Config
@@ -216,6 +208,25 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		BlobStorage:        s.cfg.BlobStorage,
 	}
 	rewardFetcher := &rewards.BlockRewardService{Replayer: ch}
+
+	s.initializeRewardServerRoutes(&rewards.Server{
+		Blocker:               blocker,
+		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
+		FinalizationFetcher:   s.cfg.FinalizationFetcher,
+		TimeFetcher:           s.cfg.GenesisTimeFetcher,
+		Stater:                stater,
+		HeadFetcher:           s.cfg.HeadFetcher,
+		BlockRewardFetcher:    rewardFetcher,
+	})
+	s.initializeBuilderServerRoutes(&rpcBuilder.Server{
+		FinalizationFetcher:   s.cfg.FinalizationFetcher,
+		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
+		Stater:                stater,
+	})
+	s.initializeBlobServerRoutes(&blob.Server{
+		Blocker: blocker,
+	})
+
 	coreService := &core.Service{
 		HeadFetcher:           s.cfg.HeadFetcher,
 		GenesisTimeFetcher:    s.cfg.GenesisTimeFetcher,
@@ -229,6 +240,7 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		FinalizedFetcher:      s.cfg.FinalizationFetcher,
 		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
 	}
+
 	validatorServer := &validatorv1alpha1.Server{
 		Ctx:                    s.ctx,
 		AttPool:                s.cfg.AttestationsPool,
@@ -268,6 +280,26 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		PayloadIDCache:         s.cfg.PayloadIDCache,
 	}
 	s.validatorServer = validatorServer
+	s.initializeValidatorServerRoutes(&validator.Server{
+		HeadFetcher:            s.cfg.HeadFetcher,
+		TimeFetcher:            s.cfg.GenesisTimeFetcher,
+		SyncChecker:            s.cfg.SyncService,
+		OptimisticModeFetcher:  s.cfg.OptimisticModeFetcher,
+		AttestationsPool:       s.cfg.AttestationsPool,
+		PeerManager:            s.cfg.PeerManager,
+		Broadcaster:            s.cfg.Broadcaster,
+		V1Alpha1Server:         validatorServer,
+		Stater:                 stater,
+		SyncCommitteePool:      s.cfg.SyncCommitteeObjectPool,
+		ChainInfoFetcher:       s.cfg.ChainInfoFetcher,
+		BeaconDB:               s.cfg.BeaconDB,
+		BlockBuilder:           s.cfg.BlockBuilder,
+		OperationNotifier:      s.cfg.OperationNotifier,
+		TrackedValidatorsCache: s.cfg.TrackedValidatorsCache,
+		PayloadIDCache:         s.cfg.PayloadIDCache,
+		CoreService:            coreService,
+		BlockRewardFetcher:     rewardFetcher,
+	})
 	nodeServer := &nodev1alpha1.Server{
 		LogsStreamer:         logs.NewStreamServer(),
 		StreamLogsBufferSize: 1000, // Enough to handle bursts of beacon node logs for gRPC streaming.
@@ -282,6 +314,19 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		BeaconMonitoringHost: s.cfg.BeaconMonitoringHost,
 		BeaconMonitoringPort: s.cfg.BeaconMonitoringPort,
 	}
+	s.initializeNodeServerRoutes(&node.Server{
+		BeaconDB:                  s.cfg.BeaconDB,
+		Server:                    s.grpcServer,
+		SyncChecker:               s.cfg.SyncService,
+		OptimisticModeFetcher:     s.cfg.OptimisticModeFetcher,
+		GenesisTimeFetcher:        s.cfg.GenesisTimeFetcher,
+		PeersFetcher:              s.cfg.PeersFetcher,
+		PeerManager:               s.cfg.PeerManager,
+		MetadataProvider:          s.cfg.MetadataProvider,
+		HeadFetcher:               s.cfg.HeadFetcher,
+		ExecutionChainInfoFetcher: s.cfg.ExecutionChainInfoFetcher,
+	})
+
 	beaconChainServer := &beaconv1alpha1.Server{
 		Ctx:                         s.ctx,
 		BeaconDB:                    s.cfg.BeaconDB,
@@ -307,23 +352,52 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		CoreService:                 coreService,
 	}
 
-	endpoints := s.endpoints(s.cfg.EnableDebugRPCEndpoints, blocker, stater, rewardFetcher, validatorServer, coreService, ch)
-	for _, e := range endpoints {
-		s.cfg.Router.HandleFunc(
-			e.template,
-			promhttp.InstrumentHandlerDuration(
-				httpRequestLatency.MustCurryWith(prometheus.Labels{"endpoint": e.name}),
-				promhttp.InstrumentHandlerCounter(
-					httpRequestCount.MustCurryWith(prometheus.Labels{"endpoint": e.name}),
-					e.handler,
-				),
-			),
-		).Methods(e.methods...)
-	}
+	s.initializeBeaconServerRoutes(&beacon.Server{
+		CanonicalHistory:              ch,
+		BeaconDB:                      s.cfg.BeaconDB,
+		AttestationsPool:              s.cfg.AttestationsPool,
+		SlashingsPool:                 s.cfg.SlashingsPool,
+		ChainInfoFetcher:              s.cfg.ChainInfoFetcher,
+		GenesisTimeFetcher:            s.cfg.GenesisTimeFetcher,
+		BlockNotifier:                 s.cfg.BlockNotifier,
+		OperationNotifier:             s.cfg.OperationNotifier,
+		Broadcaster:                   s.cfg.Broadcaster,
+		BlockReceiver:                 s.cfg.BlockReceiver,
+		StateGenService:               s.cfg.StateGen,
+		Stater:                        stater,
+		Blocker:                       blocker,
+		OptimisticModeFetcher:         s.cfg.OptimisticModeFetcher,
+		HeadFetcher:                   s.cfg.HeadFetcher,
+		TimeFetcher:                   s.cfg.GenesisTimeFetcher,
+		VoluntaryExitsPool:            s.cfg.ExitPool,
+		V1Alpha1ValidatorServer:       validatorServer,
+		SyncChecker:                   s.cfg.SyncService,
+		ExecutionPayloadReconstructor: s.cfg.ExecutionPayloadReconstructor,
+		BLSChangesPool:                s.cfg.BLSChangesPool,
+		FinalizationFetcher:           s.cfg.FinalizationFetcher,
+		ForkchoiceFetcher:             s.cfg.ForkchoiceFetcher,
+		CoreService:                   coreService,
+	})
+
+	s.initializeConfigRoutes()
+
+	s.initializeEventsServerRoutes(&events.Server{
+		StateNotifier:     s.cfg.StateNotifier,
+		OperationNotifier: s.cfg.OperationNotifier,
+		HeadFetcher:       s.cfg.HeadFetcher,
+		ChainInfoFetcher:  s.cfg.ChainInfoFetcher,
+	})
+
+	s.initializeLightClientServerRoutes(&lightclient.Server{
+		Blocker:     blocker,
+		Stater:      stater,
+		HeadFetcher: s.cfg.HeadFetcher,
+	})
 
 	ethpbv1alpha1.RegisterNodeServer(s.grpcServer, nodeServer)
 	ethpbv1alpha1.RegisterHealthServer(s.grpcServer, nodeServer)
 	ethpbv1alpha1.RegisterBeaconChainServer(s.grpcServer, beaconChainServer)
+
 	if s.cfg.EnableDebugRPCEndpoints {
 		log.Info("Enabled debug gRPC endpoints")
 		debugServer := &debugv1alpha1.Server{
@@ -335,12 +409,47 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 			PeersFetcher:       s.cfg.PeersFetcher,
 			ReplayerBuilder:    ch,
 		}
+		s.initializeDebugServerRoutes(&debug.Server{
+			BeaconDB:              s.cfg.BeaconDB,
+			HeadFetcher:           s.cfg.HeadFetcher,
+			Stater:                stater,
+			OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
+			ForkFetcher:           s.cfg.ForkFetcher,
+			ForkchoiceFetcher:     s.cfg.ForkchoiceFetcher,
+			FinalizationFetcher:   s.cfg.FinalizationFetcher,
+			ChainInfoFetcher:      s.cfg.ChainInfoFetcher,
+		})
 		ethpbv1alpha1.RegisterDebugServer(s.grpcServer, debugServer)
 	}
 	ethpbv1alpha1.RegisterBeaconNodeValidatorServer(s.grpcServer, validatorServer)
 	// Register reflection service on gRPC server.
 	reflection.Register(s.grpcServer)
 
+	s.initializePrysmBeaconServerRoutes(&beaconprysm.Server{
+		SyncChecker:           s.cfg.SyncService,
+		HeadFetcher:           s.cfg.HeadFetcher,
+		TimeFetcher:           s.cfg.GenesisTimeFetcher,
+		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
+		CanonicalHistory:      ch,
+		BeaconDB:              s.cfg.BeaconDB,
+		Stater:                stater,
+		ChainInfoFetcher:      s.cfg.ChainInfoFetcher,
+		FinalizationFetcher:   s.cfg.FinalizationFetcher,
+	})
+
+	s.initializePrysmNodeServerRoutes(&nodeprysm.Server{
+		BeaconDB:                  s.cfg.BeaconDB,
+		SyncChecker:               s.cfg.SyncService,
+		OptimisticModeFetcher:     s.cfg.OptimisticModeFetcher,
+		GenesisTimeFetcher:        s.cfg.GenesisTimeFetcher,
+		PeersFetcher:              s.cfg.PeersFetcher,
+		PeerManager:               s.cfg.PeerManager,
+		MetadataProvider:          s.cfg.MetadataProvider,
+		HeadFetcher:               s.cfg.HeadFetcher,
+		ExecutionChainInfoFetcher: s.cfg.ExecutionChainInfoFetcher,
+	})
+	s.initializePrysmValidatorServerRoutes(&validatorprysm.Server{CoreService: coreService})
+
 	return s
 }
 
@@ -348,6 +457,130 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 var _ stategen.CanonicalChecker = blockchain.ChainInfoFetcher(nil)
 var _ stategen.CurrentSlotter = blockchain.ChainInfoFetcher(nil)
 
+func (s *Service) initializeRewardServerRoutes(rewardsServer *rewards.Server) {
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/rewards/blocks/{block_id}", rewardsServer.BlockRewards).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/rewards/attestations/{epoch}", rewardsServer.AttestationRewards).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/rewards/sync_committee/{block_id}", rewardsServer.SyncCommitteeRewards).Methods(http.MethodPost)
+}
+
+func (s *Service) initializeBuilderServerRoutes(builderServer *rpcBuilder.Server) {
+	s.cfg.Router.HandleFunc("/eth/v1/builder/states/{state_id}/expected_withdrawals", builderServer.ExpectedWithdrawals).Methods(http.MethodGet)
+}
+
+func (s *Service) initializeBlobServerRoutes(blobServer *blob.Server) {
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/blob_sidecars/{block_id}", blobServer.Blobs).Methods(http.MethodGet)
+}
+
+func (s *Service) initializeValidatorServerRoutes(validatorServer *validator.Server) {
+	s.cfg.Router.HandleFunc("/eth/v1/validator/aggregate_attestation", validatorServer.GetAggregateAttestation).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/contribution_and_proofs", validatorServer.SubmitContributionAndProofs).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/aggregate_and_proofs", validatorServer.SubmitAggregateAndProofs).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/sync_committee_contribution", validatorServer.ProduceSyncCommitteeContribution).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/sync_committee_subscriptions", validatorServer.SubmitSyncCommitteeSubscription).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/beacon_committee_subscriptions", validatorServer.SubmitBeaconCommitteeSubscription).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/attestation_data", validatorServer.GetAttestationData).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/register_validator", validatorServer.RegisterValidator).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/duties/attester/{epoch}", validatorServer.GetAttesterDuties).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/duties/proposer/{epoch}", validatorServer.GetProposerDuties).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/duties/sync/{epoch}", validatorServer.GetSyncCommitteeDuties).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/prepare_beacon_proposer", validatorServer.PrepareBeaconProposer).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/liveness/{epoch}", validatorServer.GetLiveness).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v2/validator/blocks/{slot}", validatorServer.ProduceBlockV2).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/blinded_blocks/{slot}", validatorServer.ProduceBlindedBlock).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v3/validator/blocks/{slot}", validatorServer.ProduceBlockV3).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/beacon_committee_selections", validatorServer.BeaconCommitteeSelections).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/validator/sync_committee_selections", validatorServer.SyncCommitteeSelections).Methods(http.MethodPost)
+}
+
+func (s *Service) initializeNodeServerRoutes(nodeServer *node.Server) {
+	s.cfg.Router.HandleFunc("/eth/v1/node/syncing", nodeServer.GetSyncStatus).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/node/identity", nodeServer.GetIdentity).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/node/peers/{peer_id}", nodeServer.GetPeer).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/node/peers", nodeServer.GetPeers).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/node/peer_count", nodeServer.GetPeerCount).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/node/version", nodeServer.GetVersion).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/node/health", nodeServer.GetHealth).Methods(http.MethodGet)
+}
+
+func (s *Service) initializeBeaconServerRoutes(beaconServer *beacon.Server) {
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/committees", beaconServer.GetCommittees).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/fork", beaconServer.GetStateFork).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/root", beaconServer.GetStateRoot).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/sync_committees", beaconServer.GetSyncCommittees).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/randao", beaconServer.GetRandao).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/blocks", beaconServer.PublishBlock).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/blinded_blocks", beaconServer.PublishBlindedBlock).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v2/beacon/blocks", beaconServer.PublishBlockV2).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v2/beacon/blinded_blocks", beaconServer.PublishBlindedBlockV2).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v2/beacon/blocks/{block_id}", beaconServer.GetBlockV2).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/blocks/{block_id}/attestations", beaconServer.GetBlockAttestations).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/blinded_blocks/{block_id}", beaconServer.GetBlindedBlock).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/blocks/{block_id}/root", beaconServer.GetBlockRoot).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/deposit_snapshot", beaconServer.GetDepositSnapshot).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/attestations", beaconServer.ListAttestations).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/attestations", beaconServer.SubmitAttestations).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/voluntary_exits", beaconServer.ListVoluntaryExits).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/voluntary_exits", beaconServer.SubmitVoluntaryExit).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/sync_committees", beaconServer.SubmitSyncCommitteeSignatures).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/bls_to_execution_changes", beaconServer.ListBLSToExecutionChanges).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/bls_to_execution_changes", beaconServer.SubmitBLSToExecutionChanges).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/attester_slashings", beaconServer.GetAttesterSlashings).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/attester_slashings", beaconServer.SubmitAttesterSlashing).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/proposer_slashings", beaconServer.GetProposerSlashings).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/pool/proposer_slashings", beaconServer.SubmitProposerSlashing).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/headers", beaconServer.GetBlockHeaders).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/headers/{block_id}", beaconServer.GetBlockHeader).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/genesis", beaconServer.GetGenesis).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/finality_checkpoints", beaconServer.GetFinalityCheckpoints).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/validators", beaconServer.GetValidators).Methods(http.MethodGet, http.MethodPost)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/validators/{validator_id}", beaconServer.GetValidator).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/validator_balances", beaconServer.GetValidatorBalances).Methods(http.MethodGet, http.MethodPost)
+}
+
+func (s *Service) initializeConfigRoutes() {
+	s.cfg.Router.HandleFunc("/eth/v1/config/deposit_contract", config.GetDepositContract).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/config/fork_schedule", config.GetForkSchedule).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/config/spec", config.GetSpec).Methods(http.MethodGet)
+}
+
+func (s *Service) initializeEventsServerRoutes(eventsServer *events.Server) {
+	s.cfg.Router.HandleFunc("/eth/v1/events", eventsServer.StreamEvents).Methods(http.MethodGet)
+}
+
+func (s *Service) initializeLightClientServerRoutes(lightClientServer *lightclient.Server) {
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/light_client/bootstrap/{block_root}", lightClientServer.GetLightClientBootstrap).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/light_client/updates", lightClientServer.GetLightClientUpdatesByRange).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/light_client/finality_update", lightClientServer.GetLightClientFinalityUpdate).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/light_client/optimistic_update", lightClientServer.GetLightClientOptimisticUpdate).Methods(http.MethodGet)
+}
+
+func (s *Service) initializeDebugServerRoutes(debugServer *debug.Server) {
+	s.cfg.Router.HandleFunc("/eth/v2/debug/beacon/states/{state_id}", debugServer.GetBeaconStateV2).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v2/debug/beacon/heads", debugServer.GetForkChoiceHeadsV2).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/debug/fork_choice", debugServer.GetForkChoice).Methods(http.MethodGet)
+}
+
+// prysm internal routes
+func (s *Service) initializePrysmBeaconServerRoutes(beaconServerPrysm *beaconprysm.Server) {
+	s.cfg.Router.HandleFunc("/prysm/v1/beacon/weak_subjectivity", beaconServerPrysm.GetWeakSubjectivity).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/eth/v1/beacon/states/{state_id}/validator_count", beaconServerPrysm.GetValidatorCount).Methods(http.MethodGet) // TODO: deprecate in Swagger, remove in v6
+	s.cfg.Router.HandleFunc("/prysm/v1/beacon/states/{state_id}/validator_count", beaconServerPrysm.GetValidatorCount).Methods(http.MethodGet)
+}
+
+func (s *Service) initializePrysmNodeServerRoutes(nodeServerPrysm *nodeprysm.Server) {
+	s.cfg.Router.HandleFunc("/prysm/node/trusted_peers", nodeServerPrysm.ListTrustedPeer).Methods(http.MethodGet) // TODO: deprecate in Swagger, remove in v6
+	s.cfg.Router.HandleFunc("/prysm/v1/node/trusted_peers", nodeServerPrysm.ListTrustedPeer).Methods(http.MethodGet)
+	s.cfg.Router.HandleFunc("/prysm/node/trusted_peers", nodeServerPrysm.AddTrustedPeer).Methods(http.MethodPost) // TODO: deprecate in Swagger, remove in v6
+	s.cfg.Router.HandleFunc("/prysm/v1/node/trusted_peers", nodeServerPrysm.AddTrustedPeer).Methods(http.MethodPost)
+	s.cfg.Router.HandleFunc("/prysm/node/trusted_peers/{peer_id}", nodeServerPrysm.RemoveTrustedPeer).Methods(http.MethodDelete) // TODO: deprecate in Swagger, remove in v6
+	s.cfg.Router.HandleFunc("/prysm/v1/node/trusted_peers/{peer_id}", nodeServerPrysm.RemoveTrustedPeer).Methods(http.MethodDelete)
+}
+
+func (s *Service) initializePrysmValidatorServerRoutes(validatorServerPrysm *validatorprysm.Server) {
+	s.cfg.Router.HandleFunc("/prysm/validator/performance", validatorServerPrysm.GetValidatorPerformance).Methods(http.MethodPost) // TODO: deprecate in Swagger, remove in v6
+	s.cfg.Router.HandleFunc("/prysm/v1/validator/performance", validatorServerPrysm.GetValidatorPerformance).Methods(http.MethodPost)
+}
+
 // Start the gRPC server.
 func (s *Service) Start() {
 	grpcprometheus.EnableHandlingTimeHistogram()

beacon-chain/rpc/service_test.go

@@ -4,12 +4,25 @@ import (
 	"context"
 	"errors"
 	"io"
+	"net/http"
 	"testing"
 	"time"
 
 	"github.com/gorilla/mux"
 	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/beacon"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/blob"
+	rpcBuilder "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/builder"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/debug"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/events"
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/light-client"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/node"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/rewards"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/validator"
+	beaconprysm "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/beacon"
+	nodeprysm "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/node"
+	validatorprysm "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/validator"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
 	mockSync "github.com/prysmaticlabs/prysm/v5/beacon-chain/sync/initial-sync/testing"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
@@ -35,6 +48,148 @@ func combineMaps(maps ...map[string][]string) map[string][]string {
 	return combinedMap
 }
 
+func TestServer_InitializeRoutes(t *testing.T) {
+	s := Service{
+		cfg: &Config{
+			Router: mux.NewRouter(),
+		},
+	}
+	s.initializeRewardServerRoutes(&rewards.Server{})
+	s.initializeBuilderServerRoutes(&rpcBuilder.Server{})
+	s.initializeBlobServerRoutes(&blob.Server{})
+	s.initializeValidatorServerRoutes(&validator.Server{})
+	s.initializeNodeServerRoutes(&node.Server{})
+	s.initializeBeaconServerRoutes(&beacon.Server{})
+	s.initializeConfigRoutes()
+	s.initializeEventsServerRoutes(&events.Server{})
+	s.initializeLightClientServerRoutes(&lightclient.Server{})
+	s.initializeDebugServerRoutes(&debug.Server{})
+
+	//prysm internal
+	s.initializePrysmBeaconServerRoutes(&beaconprysm.Server{})
+	s.initializePrysmNodeServerRoutes(&nodeprysm.Server{})
+	s.initializePrysmValidatorServerRoutes(&validatorprysm.Server{})
+
+	beaconRoutes := map[string][]string{
+		"/eth/v1/beacon/genesis":                                     {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/root":                      {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/fork":                      {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/finality_checkpoints":      {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/validators":                {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/states/{state_id}/validators/{validator_id}": {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/validator_balances":        {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/states/{state_id}/committees":                {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/sync_committees":           {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/randao":                    {http.MethodGet},
+		"/eth/v1/beacon/headers":                                     {http.MethodGet},
+		"/eth/v1/beacon/headers/{block_id}":                          {http.MethodGet},
+		"/eth/v1/beacon/blinded_blocks":                              {http.MethodPost},
+		"/eth/v2/beacon/blinded_blocks":                              {http.MethodPost},
+		"/eth/v1/beacon/blocks":                                      {http.MethodPost},
+		"/eth/v2/beacon/blocks":                                      {http.MethodPost},
+		"/eth/v2/beacon/blocks/{block_id}":                           {http.MethodGet},
+		"/eth/v1/beacon/blocks/{block_id}/root":                      {http.MethodGet},
+		"/eth/v1/beacon/blocks/{block_id}/attestations":              {http.MethodGet},
+		"/eth/v1/beacon/blob_sidecars/{block_id}":                    {http.MethodGet},
+		"/eth/v1/beacon/rewards/sync_committee/{block_id}":           {http.MethodPost},
+		"/eth/v1/beacon/deposit_snapshot":                            {http.MethodGet},
+		"/eth/v1/beacon/rewards/blocks/{block_id}":                   {http.MethodGet},
+		"/eth/v1/beacon/rewards/attestations/{epoch}":                {http.MethodPost},
+		"/eth/v1/beacon/blinded_blocks/{block_id}":                   {http.MethodGet},
+		"/eth/v1/beacon/light_client/bootstrap/{block_root}":         {http.MethodGet},
+		"/eth/v1/beacon/light_client/updates":                        {http.MethodGet},
+		"/eth/v1/beacon/light_client/finality_update":                {http.MethodGet},
+		"/eth/v1/beacon/light_client/optimistic_update":              {http.MethodGet},
+		"/eth/v1/beacon/pool/attestations":                           {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/pool/attester_slashings":                     {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/pool/proposer_slashings":                     {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/pool/sync_committees":                        {http.MethodPost},
+		"/eth/v1/beacon/pool/voluntary_exits":                        {http.MethodGet, http.MethodPost},
+		"/eth/v1/beacon/pool/bls_to_execution_changes":               {http.MethodGet, http.MethodPost},
+	}
+
+	builderRoutes := map[string][]string{
+		"/eth/v1/builder/states/{state_id}/expected_withdrawals": {http.MethodGet},
+	}
+
+	configRoutes := map[string][]string{
+		"/eth/v1/config/fork_schedule":    {http.MethodGet},
+		"/eth/v1/config/spec":             {http.MethodGet},
+		"/eth/v1/config/deposit_contract": {http.MethodGet},
+	}
+
+	debugRoutes := map[string][]string{
+		"/eth/v2/debug/beacon/states/{state_id}": {http.MethodGet},
+		"/eth/v2/debug/beacon/heads":             {http.MethodGet},
+		"/eth/v1/debug/fork_choice":              {http.MethodGet},
+	}
+
+	eventsRoutes := map[string][]string{
+		"/eth/v1/events": {http.MethodGet},
+	}
+
+	nodeRoutes := map[string][]string{
+		"/eth/v1/node/identity":        {http.MethodGet},
+		"/eth/v1/node/peers":           {http.MethodGet},
+		"/eth/v1/node/peers/{peer_id}": {http.MethodGet},
+		"/eth/v1/node/peer_count":      {http.MethodGet},
+		"/eth/v1/node/version":         {http.MethodGet},
+		"/eth/v1/node/syncing":         {http.MethodGet},
+		"/eth/v1/node/health":          {http.MethodGet},
+	}
+
+	validatorRoutes := map[string][]string{
+		"/eth/v1/validator/duties/attester/{epoch}":        {http.MethodPost},
+		"/eth/v1/validator/duties/proposer/{epoch}":        {http.MethodGet},
+		"/eth/v1/validator/duties/sync/{epoch}":            {http.MethodPost},
+		"/eth/v2/validator/blocks/{slot}":                  {http.MethodGet}, //deprecated
+		"/eth/v3/validator/blocks/{slot}":                  {http.MethodGet},
+		"/eth/v1/validator/blinded_blocks/{slot}":          {http.MethodGet}, //deprecated
+		"/eth/v1/validator/attestation_data":               {http.MethodGet},
+		"/eth/v1/validator/aggregate_attestation":          {http.MethodGet},
+		"/eth/v1/validator/aggregate_and_proofs":           {http.MethodPost},
+		"/eth/v1/validator/beacon_committee_subscriptions": {http.MethodPost},
+		"/eth/v1/validator/sync_committee_subscriptions":   {http.MethodPost},
+		"/eth/v1/validator/beacon_committee_selections":    {http.MethodPost},
+		"/eth/v1/validator/sync_committee_contribution":    {http.MethodGet},
+		"/eth/v1/validator/sync_committee_selections":      {http.MethodPost},
+		"/eth/v1/validator/contribution_and_proofs":        {http.MethodPost},
+		"/eth/v1/validator/prepare_beacon_proposer":        {http.MethodPost},
+		"/eth/v1/validator/register_validator":             {http.MethodPost},
+		"/eth/v1/validator/liveness/{epoch}":               {http.MethodPost},
+	}
+
+	prysmCustomRoutes := map[string][]string{
+		"/prysm/v1/beacon/weak_subjectivity":                 {http.MethodGet},
+		"/prysm/node/trusted_peers":                          {http.MethodGet, http.MethodPost},
+		"/prysm/v1/node/trusted_peers":                       {http.MethodGet, http.MethodPost},
+		"/prysm/node/trusted_peers/{peer_id}":                {http.MethodDelete},
+		"/prysm/v1/node/trusted_peers/{peer_id}":             {http.MethodDelete},
+		"/prysm/validator/performance":                       {http.MethodPost},
+		"/prysm/v1/validator/performance":                    {http.MethodPost},
+		"/eth/v1/beacon/states/{state_id}/validator_count":   {http.MethodGet},
+		"/prysm/v1/beacon/states/{state_id}/validator_count": {http.MethodGet},
+	}
+
+	wantRouteList := combineMaps(beaconRoutes, builderRoutes, configRoutes, debugRoutes, eventsRoutes, nodeRoutes, validatorRoutes, prysmCustomRoutes)
+	gotRouteList := make(map[string][]string)
+	err := s.cfg.Router.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
+		tpl, err1 := route.GetPathTemplate()
+		require.NoError(t, err1)
+		met, err2 := route.GetMethods()
+		require.NoError(t, err2)
+		methods, ok := gotRouteList[tpl]
+		if !ok {
+			gotRouteList[tpl] = met
+		} else {
+			gotRouteList[tpl] = append(methods, met...)
+		}
+		return nil
+	})
+	require.NoError(t, err)
+	require.DeepEqual(t, wantRouteList, gotRouteList)
+}
+
 func TestLifecycle_OK(t *testing.T) {
 	hook := logTest.NewGlobal()
 	chainService := &mock.ChainService{

beacon-chain/state/state-native/getters_participation_test.go

@@ -19,7 +19,7 @@ func TestState_UnrealizedCheckpointBalances(t *testing.T) {
 		balances[i] = params.BeaconConfig().MaxEffectiveBalance
 	}
 	base := &ethpb.BeaconStateAltair{
-		Slot:        66,
+		Slot:        2,
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 
 		Validators:                 validators,
@@ -35,8 +35,8 @@ func TestState_UnrealizedCheckpointBalances(t *testing.T) {
 	active, previous, current, err := state.UnrealizedCheckpointBalances()
 	require.NoError(t, err)
 	require.Equal(t, allActive, active)
-	require.Equal(t, params.BeaconConfig().EffectiveBalanceIncrement, current)
-	require.Equal(t, params.BeaconConfig().EffectiveBalanceIncrement, previous)
+	require.Equal(t, uint64(0), current)
+	require.Equal(t, uint64(0), previous)
 
 	// Add some votes in the last two epochs:
 	base.CurrentEpochParticipation[0] = 0xFF
@@ -57,8 +57,8 @@ func TestState_UnrealizedCheckpointBalances(t *testing.T) {
 	require.NoError(t, err)
 	active, previous, current, err = state.UnrealizedCheckpointBalances()
 	require.NoError(t, err)
-	require.Equal(t, allActive, active)
-	require.Equal(t, params.BeaconConfig().EffectiveBalanceIncrement, current)
+	require.Equal(t, allActive-params.BeaconConfig().MaxEffectiveBalance, active)
+	require.Equal(t, uint64(0), current)
 	require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, previous)
 
 }

beacon-chain/state/stateutil/unrealized_justification.go

@@ -27,44 +27,25 @@ func UnrealizedCheckpointBalances(cp, pp []byte, validators ValReader, currentEp
 		if err != nil {
 			return 0, 0, 0, err
 		}
-		activeCurrent := v.ActivationEpoch <= currentEpoch && currentEpoch < v.ExitEpoch
-		if activeCurrent {
+		active := v.ActivationEpoch <= currentEpoch && currentEpoch < v.ExitEpoch
+		if active && !v.Slashed {
 			activeBalance, err = math.Add64(activeBalance, v.EffectiveBalance)
 			if err != nil {
 				return 0, 0, 0, err
 			}
-		}
-		if v.Slashed {
-			continue
-		}
-		if activeCurrent && ((cp[i]>>targetIdx)&1) == 1 {
-			currentTarget, err = math.Add64(currentTarget, v.EffectiveBalance)
-			if err != nil {
-				return 0, 0, 0, err
+			if ((cp[i] >> targetIdx) & 1) == 1 {
+				currentTarget, err = math.Add64(currentTarget, v.EffectiveBalance)
+				if err != nil {
+					return 0, 0, 0, err
+				}
 			}
-		}
-		activePrevious := v.ActivationEpoch < currentEpoch && currentEpoch <= v.ExitEpoch
-		if activePrevious && ((pp[i]>>targetIdx)&1) == 1 {
-			prevTarget, err = math.Add64(prevTarget, v.EffectiveBalance)
-			if err != nil {
-				return 0, 0, 0, err
+			if ((pp[i] >> targetIdx) & 1) == 1 {
+				prevTarget, err = math.Add64(prevTarget, v.EffectiveBalance)
+				if err != nil {
+					return 0, 0, 0, err
+				}
 			}
 		}
 	}
-	activeBalance, prevTarget, currentTarget = ensureLowerBound(activeBalance, prevTarget, currentTarget)
 	return activeBalance, prevTarget, currentTarget, nil
 }
-
-func ensureLowerBound(activeCurrEpoch, prevTargetAttested, currTargetAttested uint64) (uint64, uint64, uint64) {
-	ebi := params.BeaconConfig().EffectiveBalanceIncrement
-	if ebi > activeCurrEpoch {
-		activeCurrEpoch = ebi
-	}
-	if ebi > prevTargetAttested {
-		prevTargetAttested = ebi
-	}
-	if ebi > currTargetAttested {
-		currTargetAttested = ebi
-	}
-	return activeCurrEpoch, prevTargetAttested, currTargetAttested
-}

beacon-chain/state/stateutil/unrealized_justification_test.go

@@ -29,8 +29,8 @@ func TestState_UnrealizedCheckpointBalances(t *testing.T) {
 		active, previous, current, err := UnrealizedCheckpointBalances(cp, pp, NewValSliceReader(validators), 0)
 		require.NoError(tt, err)
 		require.Equal(tt, expectedActive, active)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, current)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, previous)
+		require.Equal(tt, uint64(0), current)
+		require.Equal(tt, uint64(0), previous)
 	})
 
 	t.Run("bad votes in last two epochs", func(tt *testing.T) {
@@ -39,8 +39,8 @@ func TestState_UnrealizedCheckpointBalances(t *testing.T) {
 		active, previous, current, err := UnrealizedCheckpointBalances(cp, pp, NewValSliceReader(validators), 1)
 		require.NoError(tt, err)
 		require.Equal(tt, expectedActive, active)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, current)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, previous)
+		require.Equal(tt, uint64(0), current)
+		require.Equal(tt, uint64(0), previous)
 	})
 
 	t.Run("two votes in last epoch", func(tt *testing.T) {
@@ -50,7 +50,7 @@ func TestState_UnrealizedCheckpointBalances(t *testing.T) {
 		require.NoError(tt, err)
 		require.Equal(tt, expectedActive, active)
 		require.Equal(tt, 2*params.BeaconConfig().MaxEffectiveBalance, current)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, previous)
+		require.Equal(tt, uint64(0), previous)
 	})
 
 	t.Run("two votes in previous epoch", func(tt *testing.T) {
@@ -59,7 +59,7 @@ func TestState_UnrealizedCheckpointBalances(t *testing.T) {
 		active, previous, current, err := UnrealizedCheckpointBalances(cp, pp, NewValSliceReader(validators), 1)
 		require.NoError(tt, err)
 		require.Equal(tt, expectedActive, active)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, current)
+		require.Equal(tt, uint64(0), current)
 		require.Equal(tt, 2*params.BeaconConfig().MaxEffectiveBalance, previous)
 	})
 
@@ -79,6 +79,7 @@ func TestState_UnrealizedCheckpointBalances(t *testing.T) {
 		validators[1].Slashed = true
 		active, previous, current, err := UnrealizedCheckpointBalances(cp, pp, NewValSliceReader(validators), 1)
 		require.NoError(tt, err)
+		expectedActive -= params.BeaconConfig().MaxEffectiveBalance
 		require.Equal(tt, expectedActive, active)
 		require.Equal(tt, params.BeaconConfig().MaxEffectiveBalance-params.BeaconConfig().MinDepositAmount, current)
 		require.Equal(tt, 2*params.BeaconConfig().MaxEffectiveBalance, previous)
@@ -118,8 +119,8 @@ func TestState_MVSlice_UnrealizedCheckpointBalances(t *testing.T) {
 		active, previous, current, err := UnrealizedCheckpointBalances(cp, pp, NewValMultiValueSliceReader(mv, &testObject{id: 0}), 0)
 		require.NoError(tt, err)
 		require.Equal(tt, expectedActive, active)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, current)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, previous)
+		require.Equal(tt, uint64(0), current)
+		require.Equal(tt, uint64(0), previous)
 	})
 
 	t.Run("bad votes in last two epochs", func(tt *testing.T) {
@@ -128,8 +129,8 @@ func TestState_MVSlice_UnrealizedCheckpointBalances(t *testing.T) {
 		active, previous, current, err := UnrealizedCheckpointBalances(cp, pp, NewValMultiValueSliceReader(mv, &testObject{id: 0}), 1)
 		require.NoError(tt, err)
 		require.Equal(tt, expectedActive, active)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, current)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, previous)
+		require.Equal(tt, uint64(0), current)
+		require.Equal(tt, uint64(0), previous)
 	})
 
 	t.Run("two votes in last epoch", func(tt *testing.T) {
@@ -139,7 +140,7 @@ func TestState_MVSlice_UnrealizedCheckpointBalances(t *testing.T) {
 		require.NoError(tt, err)
 		require.Equal(tt, expectedActive, active)
 		require.Equal(tt, 2*params.BeaconConfig().MaxEffectiveBalance, current)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, previous)
+		require.Equal(tt, uint64(0), previous)
 	})
 
 	t.Run("two votes in previous epoch", func(tt *testing.T) {
@@ -148,7 +149,7 @@ func TestState_MVSlice_UnrealizedCheckpointBalances(t *testing.T) {
 		active, previous, current, err := UnrealizedCheckpointBalances(cp, pp, NewValMultiValueSliceReader(mv, &testObject{id: 0}), 1)
 		require.NoError(tt, err)
 		require.Equal(tt, expectedActive, active)
-		require.Equal(tt, params.BeaconConfig().EffectiveBalanceIncrement, current)
+		require.Equal(tt, uint64(0), current)
 		require.Equal(tt, 2*params.BeaconConfig().MaxEffectiveBalance, previous)
 	})
 
@@ -168,6 +169,7 @@ func TestState_MVSlice_UnrealizedCheckpointBalances(t *testing.T) {
 		validators[1].Slashed = true
 		active, previous, current, err := UnrealizedCheckpointBalances(cp, pp, NewValMultiValueSliceReader(mv, &testObject{id: 0}), 1)
 		require.NoError(tt, err)
+		expectedActive -= params.BeaconConfig().MaxEffectiveBalance
 		require.Equal(tt, expectedActive, active)
 		require.Equal(tt, params.BeaconConfig().MaxEffectiveBalance-params.BeaconConfig().MinDepositAmount, current)
 		require.Equal(tt, 2*params.BeaconConfig().MaxEffectiveBalance, previous)

beacon-chain/sync/BUILD.bazel

@@ -108,7 +108,6 @@ go_library(
         "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz/equality:go_default_library",
-        "//io/file:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//network/forks:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/sync/backfill/batcher.go

@@ -79,10 +79,6 @@ func (c *batchSequencer) update(b batch) {
 		// so we want to copy c to a, then on i=3, d to b, then on i=4 e to c.
 		c.seq[i-done] = c.seq[i]
 	}
-	if done == 1 && len(c.seq) == 1 {
-		c.seq[0] = c.batcher.beforeBatch(c.seq[0])
-		return
-	}
 	// Overwrite the moved batches with the next ones in the sequence.
 	// Continuing the example in the comment above, len(c.seq)==5, done=2, so i=3.
 	// We want to replace index 3 with the batch that should be processed after index 2,

beacon-chain/sync/backfill/batcher_test.go

@@ -64,35 +64,6 @@ func TestBatcherBefore(t *testing.T) {
 	}
 }
 
-func TestBatchSingleItem(t *testing.T) {
-	var min, max, size primitives.Slot
-	// seqLen = 1 means just one worker
-	seqLen := 1
-	min = 0
-	max = 11235
-	size = 64
-	seq := newBatchSequencer(seqLen, min, max, size)
-	got, err := seq.sequence()
-	require.NoError(t, err)
-	require.Equal(t, 1, len(got))
-	b := got[0]
-
-	//  calling sequence again should give you the next (earlier) batch
-	seq.update(b.withState(batchImportComplete))
-	next, err := seq.sequence()
-	require.NoError(t, err)
-	require.Equal(t, 1, len(next))
-	require.Equal(t, b.end, next[0].end+size)
-
-	// should get the same batch again when update is called with an error
-	seq.update(next[0].withState(batchErrRetryable))
-	same, err := seq.sequence()
-	require.NoError(t, err)
-	require.Equal(t, 1, len(same))
-	require.Equal(t, next[0].begin, same[0].begin)
-	require.Equal(t, next[0].end, same[0].end)
-}
-
 func TestBatchSequencer(t *testing.T) {
 	var min, max, size primitives.Slot
 	seqLen := 8

beacon-chain/sync/backfill/service.go

@@ -118,24 +118,6 @@ func WithVerifierWaiter(viw InitializerWaiter) ServiceOption {
 	}
 }
 
-// WithMinimumSlot allows the user to specify a different backfill minimum slot than the spec default of current - MIN_EPOCHS_FOR_BLOCK_REQUESTS.
-// If this value is greater than current - MIN_EPOCHS_FOR_BLOCK_REQUESTS, it will be ignored with a warning log.
-func WithMinimumSlot(s primitives.Slot) ServiceOption {
-	ms := func(current primitives.Slot) primitives.Slot {
-		specMin := minimumBackfillSlot(current)
-		if s < specMin {
-			return s
-		}
-		log.WithField("userSlot", s).WithField("specMinSlot", specMin).
-			Warn("Ignoring user-specified slot > MIN_EPOCHS_FOR_BLOCK_REQUESTS.")
-		return specMin
-	}
-	return func(s *Service) error {
-		s.ms = ms
-		return nil
-	}
-}
-
 // NewService initializes the backfill Service. Like all implementations of the Service interface,
 // the service won't begin its runloop until Start() is called.
 func NewService(ctx context.Context, su *Store, bStore *filesystem.BlobStorage, cw startup.ClockWaiter, p p2p.P2P, pa PeerAssigner, opts ...ServiceOption) (*Service, error) {
@@ -307,7 +289,7 @@ func (s *Service) Start() {
 		if ctx.Err() != nil {
 			return
 		}
-		if s.updateComplete() {
+		if allComplete := s.updateComplete(); allComplete {
 			return
 		}
 		s.importBatches(ctx)
@@ -334,11 +316,11 @@ func (s *Service) downscore(b batch) {
 	s.p2p.Peers().Scorers().BadResponsesScorer().Increment(b.blockPid)
 }
 
-func (*Service) Stop() error {
+func (s *Service) Stop() error {
 	return nil
 }
 
-func (*Service) Status() error {
+func (s *Service) Status() error {
 	return nil
 }
 

beacon-chain/sync/backfill/service_test.go

@@ -29,7 +29,7 @@ func (m mockMinimumSlotter) minimumSlot(_ primitives.Slot) primitives.Slot {
 type mockInitalizerWaiter struct {
 }
 
-func (*mockInitalizerWaiter) WaitForInitializer(_ context.Context) (*verification.Initializer, error) {
+func (mi *mockInitalizerWaiter) WaitForInitializer(ctx context.Context) (*verification.Initializer, error) {
 	return &verification.Initializer{}, nil
 }
 
@@ -67,7 +67,7 @@ func TestServiceInit(t *testing.T) {
 	}
 	go srv.Start()
 	todo := make([]batch, 0)
-	todo = testReadN(ctx, t, pool.todoChan, nWorkers, todo)
+	todo = testReadN(t, ctx, pool.todoChan, nWorkers, todo)
 	require.Equal(t, nWorkers, len(todo))
 	for i := 0; i < remaining; i++ {
 		b := todo[i]
@@ -75,7 +75,7 @@ func TestServiceInit(t *testing.T) {
 			b.state = batchImportable
 		}
 		pool.finishedChan <- b
-		todo = testReadN(ctx, t, pool.todoChan, 1, todo)
+		todo = testReadN(t, ctx, pool.todoChan, 1, todo)
 	}
 	require.Equal(t, remaining+nWorkers, len(todo))
 	for i := remaining; i < remaining+nWorkers; i++ {
@@ -90,12 +90,14 @@ func TestMinimumBackfillSlot(t *testing.T) {
 	minSlot := minimumBackfillSlot(primitives.Slot(currSlot))
 	require.Equal(t, 100*params.BeaconConfig().SlotsPerEpoch, minSlot)
 
+	oe = helpers.MinEpochsForBlockRequests()
+
 	currSlot = oe.Mul(uint64(params.BeaconConfig().SlotsPerEpoch))
 	minSlot = minimumBackfillSlot(primitives.Slot(currSlot))
 	require.Equal(t, primitives.Slot(1), minSlot)
 }
 
-func testReadN(ctx context.Context, t *testing.T, c chan batch, n int, into []batch) []batch {
+func testReadN(t *testing.T, ctx context.Context, c chan batch, n int, into []batch) []batch {
 	for i := 0; i < n; i++ {
 		select {
 		case b := <-c:
@@ -107,28 +109,3 @@ func testReadN(ctx context.Context, t *testing.T, c chan batch, n int, into []ba
 	}
 	return into
 }
-
-func TestBackfillMinSlotDefault(t *testing.T) {
-	oe := helpers.MinEpochsForBlockRequests()
-	current := primitives.Slot((oe + 100).Mul(uint64(params.BeaconConfig().SlotsPerEpoch)))
-	s := &Service{}
-	specMin := minimumBackfillSlot(current)
-
-	t.Run("equal to specMin", func(t *testing.T) {
-		opt := WithMinimumSlot(specMin)
-		require.NoError(t, opt(s))
-		require.Equal(t, specMin, s.ms(current))
-	})
-	t.Run("older than specMin", func(t *testing.T) {
-		opt := WithMinimumSlot(specMin - 1)
-		require.NoError(t, opt(s))
-		// if WithMinimumSlot is older than the spec minimum, we should use it.
-		require.Equal(t, specMin-1, s.ms(current))
-	})
-	t.Run("newer than specMin", func(t *testing.T) {
-		opt := WithMinimumSlot(specMin + 1)
-		require.NoError(t, opt(s))
-		// if WithMinimumSlot is newer than the spec minimum, we should use the spec minimum
-		require.Equal(t, specMin, s.ms(current))
-	})
-}

beacon-chain/sync/initial-sync/round_robin.go

@@ -243,13 +243,13 @@ func (s *Service) logBatchSyncStatus(genesis time.Time, firstBlk blocks.ROBlock,
 	firstRoot := firstBlk.Root()
 	timeRemaining := time.Duration(float64(slots.Since(genesis)-firstBlk.Block().Slot())/rate) * time.Second
 	log.WithFields(logrus.Fields{
-		"peers":                           len(s.cfg.P2P.Peers().Connected()),
-		"blocksPerSecond":                 fmt.Sprintf("%.1f", rate),
-		"batchSize":                       nBlocks,
-		"startingFrom":                    fmt.Sprintf("0x%s...", hex.EncodeToString(firstRoot[:])[:8]),
-		"latestProcessedSlot/currentSlot": fmt.Sprintf("%d/%d", firstBlk.Block().Slot(), slots.Since(genesis)),
-		"estimatedTimeRemaining":          timeRemaining,
-	}).Info("Processing blocks")
+		"peers":           len(s.cfg.P2P.Peers().Connected()),
+		"blocksPerSecond": fmt.Sprintf("%.1f", rate),
+	}).Infof(
+		"Processing block batch of size %d starting from  %s %d/%d - estimated time remaining %s",
+		nBlocks, fmt.Sprintf("0x%s...", hex.EncodeToString(firstRoot[:])[:8]),
+		firstBlk.Block().Slot(), slots.Since(genesis), timeRemaining,
+	)
 }
 
 // processBlock performs basic checks on incoming block, and triggers receiver function.

beacon-chain/sync/initial-sync/service.go

@@ -194,7 +194,7 @@ func (s *Service) Start() {
 		}
 		panic(err)
 	}
-	log.WithField("slot", s.cfg.Chain.HeadSlot()).Info("Synced up to")
+	log.Infof("Synced up to slot %d", s.cfg.Chain.HeadSlot())
 	s.markSynced()
 }
 

beacon-chain/sync/metrics.go

@@ -144,12 +144,6 @@ var (
 			Help: "Time for gossiped blob sidecars to arrive",
 		},
 	)
-	blobSidecarVerificationGossipSummary = promauto.NewSummary(
-		prometheus.SummaryOpts{
-			Name: "gossip_blob_sidecar_verification_milliseconds",
-			Help: "Time to verify gossiped blob sidecars",
-		},
-	)
 
 	// Sync committee verification performance.
 	syncMessagesForUnknownBlocks = promauto.NewCounter(

beacon-chain/sync/service.go

@@ -53,7 +53,7 @@ const rangeLimit uint64 = 1024
 const seenBlockSize = 1000
 const seenBlobSize = seenBlockSize * 4 // Each block can have max 4 blobs. Worst case 164kB for cache.
 const seenUnaggregatedAttSize = 20000
-const seenAggregatedAttSize = 16384
+const seenAggregatedAttSize = 1024
 const seenSyncMsgSize = 1000         // Maximum of 512 sync committee members, 1000 is a safe amount.
 const seenSyncContributionSize = 512 // Maximum of SYNC_COMMITTEE_SIZE as specified by the spec.
 const seenExitSize = 100

beacon-chain/sync/subscriber.go

@@ -248,7 +248,7 @@ func (s *Service) subscribeWithBase(topic string, validator wrappedVal, handle s
 	}
 
 	go messageLoop()
-	log.WithField("topic", topic).Info("Subscribed to")
+	log.WithField("topic", topic).Info("Subscribed to topic")
 	return sub
 }
 
@@ -286,11 +286,6 @@ func (s *Service) wrapAndReportValidation(topic string, v wrappedVal) (string, p
 			return pubsub.ValidationIgnore
 		}
 		b, err := v(ctx, pid, msg)
-		// We do not penalize peers if we are hitting pubsub timeouts
-		// trying to process those messages.
-		if b == pubsub.ValidationReject && ctx.Err() != nil {
-			b = pubsub.ValidationIgnore
-		}
 		if b == pubsub.ValidationReject {
 			fields := logrus.Fields{
 				"topic":        topic,
@@ -321,7 +316,7 @@ func (s *Service) wrapAndReportValidation(topic string, v wrappedVal) (string, p
 	}
 }
 
-// subscribe to a static subnet with the given topic and index. A given validator and subscription handler is
+// subscribe to a static subnet  with the given topic and index.A given validator and subscription handler is
 // used to handle messages from the subnet. The base protobuf message is used to initialize new messages for decoding.
 func (s *Service) subscribeStaticWithSubnets(topic string, validator wrappedVal, handle subHandler, digest [4]byte, subnetCount uint64) {
 	genRoot := s.cfg.clock.GenesisValidatorsRoot()
@@ -692,7 +687,7 @@ func (s *Service) retrievePersistentSubs(currSlot primitives.Slot) []uint64 {
 	return slice.SetUint64(append(persistentSubs, wantedSubs...))
 }
 
-func (*Service) retrieveActiveSyncSubnets(currEpoch primitives.Epoch) []uint64 {
+func (_ *Service) retrieveActiveSyncSubnets(currEpoch primitives.Epoch) []uint64 {
 	subs := cache.SyncSubnetIDs.GetAllSubnets(currEpoch)
 	return slice.SetUint64(subs)
 }
@@ -747,17 +742,17 @@ func (s *Service) filterNeededPeers(pids []peer.ID) []peer.ID {
 }
 
 // Add fork digest to topic.
-func (*Service) addDigestToTopic(topic string, digest [4]byte) string {
+func (_ *Service) addDigestToTopic(topic string, digest [4]byte) string {
 	if !strings.Contains(topic, "%x") {
-		log.Error("Topic does not have appropriate formatter for digest")
+		log.Fatal("Topic does not have appropriate formatter for digest")
 	}
 	return fmt.Sprintf(topic, digest)
 }
 
 // Add the digest and index to subnet topic.
-func (*Service) addDigestAndIndexToTopic(topic string, digest [4]byte, idx uint64) string {
+func (_ *Service) addDigestAndIndexToTopic(topic string, digest [4]byte, idx uint64) string {
 	if !strings.Contains(topic, "%x") {
-		log.Error("Topic does not have appropriate formatter for digest")
+		log.Fatal("Topic does not have appropriate formatter for digest")
 	}
 	return fmt.Sprintf(topic, digest, idx)
 }

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -2,16 +2,10 @@ package sync
 
 import (
 	"context"
-	"fmt"
-	"os"
-	"path"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition/interop"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v5/io/file"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -39,10 +33,7 @@ func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 			if r != [32]byte{} {
 				s.setBadBlock(ctx, r) // Setting head block as bad.
 			} else {
-				// TODO(13721): Remove this once we can deprecate the flag.
 				interop.WriteBlockToDisk(signed, true /*failed*/)
-
-				saveInvalidBlockToTemp(signed)
 				s.setBadBlock(ctx, root)
 			}
 		}
@@ -54,21 +45,3 @@ func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 	}
 	return err
 }
-
-// WriteInvalidBlockToDisk as a block ssz. Writes to temp directory.
-func saveInvalidBlockToTemp(block interfaces.ReadOnlySignedBeaconBlock) {
-	if !features.Get().SaveInvalidBlock {
-		return
-	}
-	filename := fmt.Sprintf("beacon_block_%d.ssz", block.Block().Slot())
-	fp := path.Join(os.TempDir(), filename)
-	log.Warnf("Writing invalid block to disk at %s", fp)
-	enc, err := block.MarshalSSZ()
-	if err != nil {
-		log.WithError(err).Error("Failed to ssz encode block")
-		return
-	}
-	if err := file.WriteFile(fp, enc); err != nil {
-		log.WithError(err).Error("Failed to write to disk")
-	}
-}