wip fixing tests

beacon-chain/blockchain/error.go

@@ -13,6 +13,8 @@ var (
 	errNilFinalizedInStore = errors.New("nil finalized checkpoint returned from store")
 	// errNilFinalizedCheckpoint is returned when a nil finalized checkpt is returned from a state.
 	errNilFinalizedCheckpoint = errors.New("nil finalized checkpoint returned from state")
+	// errNilJustifiedCheckpoint is returned when a nil justified checkpt is returned from a state.
+	errNilJustifiedCheckpoint = errors.New("nil justified checkpoint returned from state")
 	// errBlockDoesNotExist is returned when a block does not exist for a particular state summary.
 	errBlockDoesNotExist = errors.New("could not find block in DB")
 	// errBlockNotFoundInCacheOrDB is returned when a block is not found in the cache or DB.

beacon-chain/blockchain/service.go

@@ -272,6 +272,13 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	}
 	spawnCountdownIfPreGenesis(s.ctx, s.genesisTime, s.cfg.BeaconDB)
 
+	justified, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get justified checkpoint")
+	}
+	if justified == nil {
+		return errNilJustifiedCheckpoint
+	}
 	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint")
@@ -283,8 +290,8 @@ 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 err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(s.ctx, &forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,
-		Root: bytesutil.ToBytes32(finalized.Root)}); err != nil {
+	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,

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

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/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{}

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/sync/validate_sync_contribution_proof.go

@@ -10,7 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	opfeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/operation"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
-	p2ptypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/types"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
@@ -249,41 +249,9 @@ func (s *Service) rejectInvalidSyncAggregateSignature(m *ethpb.SignedContributio
 	return func(ctx context.Context) (pubsub.ValidationResult, error) {
 		ctx, span := trace.StartSpan(ctx, "sync.rejectInvalidSyncAggregateSignature")
 		defer span.End()
-		// The aggregate signature is valid for the message `beacon_block_root` and aggregate pubkey
-		// derived from the participation info in `aggregation_bits` for the subcommittee specified by the `contribution.subcommittee_index`.
-		var activeRawPubkeys [][]byte
-		syncPubkeys, err := s.cfg.chain.HeadSyncCommitteePubKeys(ctx, m.Message.Contribution.Slot, primitives.CommitteeIndex(m.Message.Contribution.SubcommitteeIndex))
-		if err != nil {
-			return pubsub.ValidationIgnore, err
-		}
-		bVector := m.Message.Contribution.AggregationBits
-		// In the event no bit is set for the
-		// sync contribution, we reject the message.
-		if bVector.Count() == 0 {
-			return pubsub.ValidationReject, errors.New("bitvector count is 0")
-		}
-		for i, pk := range syncPubkeys {
-			if bVector.BitAt(uint64(i)) {
-				activeRawPubkeys = append(activeRawPubkeys, pk)
-			}
-		}
-		d, err := s.cfg.chain.HeadSyncCommitteeDomain(ctx, m.Message.Contribution.Slot)
-		if err != nil {
-			tracing.AnnotateError(span, err)
-			return pubsub.ValidationIgnore, err
-		}
-		rawBytes := p2ptypes.SSZBytes(m.Message.Contribution.BlockRoot)
-		sigRoot, err := signing.ComputeSigningRoot(&rawBytes, d)
-		if err != nil {
-			tracing.AnnotateError(span, err)
-			return pubsub.ValidationIgnore, err
-		}
-		// Aggregate pubkeys separately again to allow
-		// for signature sets to be created for batch verification.
-		aggKey, err := bls.AggregatePublicKeys(activeRawPubkeys)
-		if err != nil {
-			tracing.AnnotateError(span, err)
-			return pubsub.ValidationIgnore, err
+		sigRoot, aggKey, msgErr := verification.SignedContributionAndProofValidationSetup(ctx, s.cfg.chain, m)
+		if msgErr != nil {
+			return msgErr.PubsubResult, msgErr.Err
 		}
 		set := &bls.SignatureBatch{
 			Messages:     [][32]byte{sigRoot},

beacon-chain/verification/BUILD.bazel

@@ -9,6 +9,7 @@ go_library(
         "fake.go",
         "initializer.go",
         "interface.go",
+        "message.go",
         "mock.go",
         "result.go",
     ],
@@ -20,6 +21,7 @@ go_library(
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
+        "//beacon-chain/p2p/types:go_default_library",
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//cache/lru:go_default_library",
@@ -29,13 +31,16 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//monitoring/tracing:go_default_library",
         "//network/forks:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/logging:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_hashicorp_golang_lru//:go_default_library",
+        "@com_github_libp2p_go_libp2p_pubsub//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/verification/message.go

@@ -0,0 +1,72 @@
+package verification
+
+import (
+	"context"
+
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
+	p2ptypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/types"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"go.opencensus.io/trace"
+)
+
+// MsgVerifError is an error wrapper for the validation setup responses
+type MsgVerifError struct {
+	PubsubResult pubsub.ValidationResult
+	Err          error
+}
+
+type syncSigPrerequisiteFetcher interface {
+	HeadSyncCommitteePubKeys(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) ([][]byte, error)
+	HeadSyncCommitteeDomain(ctx context.Context, slot primitives.Slot) ([]byte, error)
+}
+
+// SignedContributionAndProofValidationSetup returns components used for a bls signature valuation
+func SignedContributionAndProofValidationSetup(ctx context.Context, headFetcher syncSigPrerequisiteFetcher, req *ethpb.SignedContributionAndProof) ([fieldparams.RootLength]byte, bls.PublicKey, *MsgVerifError) {
+	ctx, span := trace.StartSpan(ctx, "verification.SignedContributionAndProofValidationSetup")
+	defer span.End()
+	// The aggregate signature is valid for the message `beacon_block_root` and aggregate pubkey
+	// derived from the participation info in `aggregation_bits` for the subcommittee specified by the `contribution.subcommittee_index`.
+	var activeRawPubkeys [][]byte
+	syncPubkeys, err := headFetcher.HeadSyncCommitteePubKeys(ctx, req.Message.Contribution.Slot, primitives.CommitteeIndex(req.Message.Contribution.SubcommitteeIndex))
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return [fieldparams.RootLength]byte{}, nil, &MsgVerifError{PubsubResult: pubsub.ValidationIgnore, Err: err}
+	}
+	bVector := req.Message.Contribution.AggregationBits
+	// In the event no bit is set for the
+	// sync contribution, we reject the message.
+	if bVector.Count() == 0 {
+		tracing.AnnotateError(span, err)
+		return [fieldparams.RootLength]byte{}, nil, &MsgVerifError{PubsubResult: pubsub.ValidationReject, Err: errors.New("bitvector count is 0")}
+	}
+	for i, pk := range syncPubkeys {
+		if bVector.BitAt(uint64(i)) {
+			activeRawPubkeys = append(activeRawPubkeys, pk)
+		}
+	}
+	d, err := headFetcher.HeadSyncCommitteeDomain(ctx, req.Message.Contribution.Slot)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return [fieldparams.RootLength]byte{}, nil, &MsgVerifError{PubsubResult: pubsub.ValidationIgnore, Err: err}
+	}
+	rawBytes := p2ptypes.SSZBytes(req.Message.Contribution.BlockRoot)
+	sigRoot, err := signing.ComputeSigningRoot(&rawBytes, d)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return [fieldparams.RootLength]byte{}, nil, &MsgVerifError{PubsubResult: pubsub.ValidationIgnore, Err: err}
+	}
+	// Aggregate pubkeys separately again to allow
+	// for signature sets to be created for batch verification.
+	aggKey, err := bls.AggregatePublicKeys(activeRawPubkeys)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return [fieldparams.RootLength]byte{}, nil, &MsgVerifError{PubsubResult: pubsub.ValidationIgnore, Err: err}
+	}
+	return sigRoot, aggKey, nil
+}

validator/client/beacon-api/BUILD.bazel

@@ -22,7 +22,6 @@ go_library(
         "index.go",
         "json_rest_handler.go",
         "log.go",
-        "metrics.go",
         "prepare_beacon_proposer.go",
         "propose_attestation.go",
         "propose_beacon_block.go",
@@ -61,8 +60,6 @@ go_library(
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_golang_protobuf//ptypes/empty",
         "@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_sirupsen_logrus//:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",

validator/client/beacon-api/beacon_api_validator_client.go

@@ -50,38 +50,32 @@ func NewBeaconApiValidatorClient(jsonRestHandler JsonRestHandler, opts ...Valida
 }
 
 func (c *beaconApiValidatorClient) GetDuties(ctx context.Context, in *ethpb.DutiesRequest) (*ethpb.DutiesResponse, error) {
-	return wrapInMetrics[*ethpb.DutiesResponse]("GetDuties", func() (*ethpb.DutiesResponse, error) {
-		return c.getDuties(ctx, in)
-	})
+	return c.getDuties(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) CheckDoppelGanger(ctx context.Context, in *ethpb.DoppelGangerRequest) (*ethpb.DoppelGangerResponse, error) {
-	return wrapInMetrics[*ethpb.DoppelGangerResponse]("CheckDoppelGanger", func() (*ethpb.DoppelGangerResponse, error) {
-		return c.checkDoppelGanger(ctx, in)
-	})
+	return c.checkDoppelGanger(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) DomainData(ctx context.Context, in *ethpb.DomainRequest) (*ethpb.DomainResponse, error) {
 	if len(in.Domain) != 4 {
 		return nil, errors.Errorf("invalid domain type: %s", hexutil.Encode(in.Domain))
 	}
-	domainType := bytesutil.ToBytes4(in.Domain)
 
-	return wrapInMetrics[*ethpb.DomainResponse]("DomainData", func() (*ethpb.DomainResponse, error) {
-		return c.getDomainData(ctx, in.Epoch, domainType)
-	})
+	domainType := bytesutil.ToBytes4(in.Domain)
+	return c.getDomainData(ctx, in.Epoch, domainType)
 }
 
 func (c *beaconApiValidatorClient) GetAttestationData(ctx context.Context, in *ethpb.AttestationDataRequest) (*ethpb.AttestationData, error) {
-	return wrapInMetrics[*ethpb.AttestationData]("GetAttestationData", func() (*ethpb.AttestationData, error) {
-		return c.getAttestationData(ctx, in.Slot, in.CommitteeIndex)
-	})
+	if in == nil {
+		return nil, errors.New("GetAttestationData received nil argument `in`")
+	}
+
+	return c.getAttestationData(ctx, in.Slot, in.CommitteeIndex)
 }
 
 func (c *beaconApiValidatorClient) GetBeaconBlock(ctx context.Context, in *ethpb.BlockRequest) (*ethpb.GenericBeaconBlock, error) {
-	return wrapInMetrics[*ethpb.GenericBeaconBlock]("GetBeaconBlock", func() (*ethpb.GenericBeaconBlock, error) {
-		return c.getBeaconBlock(ctx, in.Slot, in.RandaoReveal, in.Graffiti)
-	})
+	return c.getBeaconBlock(ctx, in.Slot, in.RandaoReveal, in.Graffiti)
 }
 
 func (c *beaconApiValidatorClient) GetFeeRecipientByPubKey(_ context.Context, _ *ethpb.FeeRecipientByPubKeyRequest) (*ethpb.FeeRecipientByPubKeyResponse, error) {
@@ -89,51 +83,35 @@ func (c *beaconApiValidatorClient) GetFeeRecipientByPubKey(_ context.Context, _
 }
 
 func (c *beaconApiValidatorClient) GetSyncCommitteeContribution(ctx context.Context, in *ethpb.SyncCommitteeContributionRequest) (*ethpb.SyncCommitteeContribution, error) {
-	return wrapInMetrics[*ethpb.SyncCommitteeContribution]("GetSyncCommitteeContribution", func() (*ethpb.SyncCommitteeContribution, error) {
-		return c.getSyncCommitteeContribution(ctx, in)
-	})
+	return c.getSyncCommitteeContribution(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) GetSyncMessageBlockRoot(ctx context.Context, _ *empty.Empty) (*ethpb.SyncMessageBlockRootResponse, error) {
-	return wrapInMetrics[*ethpb.SyncMessageBlockRootResponse]("GetSyncMessageBlockRoot", func() (*ethpb.SyncMessageBlockRootResponse, error) {
-		return c.getSyncMessageBlockRoot(ctx)
-	})
+	return c.getSyncMessageBlockRoot(ctx)
 }
 
 func (c *beaconApiValidatorClient) GetSyncSubcommitteeIndex(ctx context.Context, in *ethpb.SyncSubcommitteeIndexRequest) (*ethpb.SyncSubcommitteeIndexResponse, error) {
-	return wrapInMetrics[*ethpb.SyncSubcommitteeIndexResponse]("GetSyncSubcommitteeIndex", func() (*ethpb.SyncSubcommitteeIndexResponse, error) {
-		return c.getSyncSubcommitteeIndex(ctx, in)
-	})
+	return c.getSyncSubcommitteeIndex(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) MultipleValidatorStatus(ctx context.Context, in *ethpb.MultipleValidatorStatusRequest) (*ethpb.MultipleValidatorStatusResponse, error) {
-	return wrapInMetrics[*ethpb.MultipleValidatorStatusResponse]("MultipleValidatorStatus", func() (*ethpb.MultipleValidatorStatusResponse, error) {
-		return c.multipleValidatorStatus(ctx, in)
-	})
+	return c.multipleValidatorStatus(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) PrepareBeaconProposer(ctx context.Context, in *ethpb.PrepareBeaconProposerRequest) (*empty.Empty, error) {
-	return wrapInMetrics[*empty.Empty]("PrepareBeaconProposer", func() (*empty.Empty, error) {
-		return new(empty.Empty), c.prepareBeaconProposer(ctx, in.Recipients)
-	})
+	return new(empty.Empty), c.prepareBeaconProposer(ctx, in.Recipients)
 }
 
 func (c *beaconApiValidatorClient) ProposeAttestation(ctx context.Context, in *ethpb.Attestation) (*ethpb.AttestResponse, error) {
-	return wrapInMetrics[*ethpb.AttestResponse]("ProposeAttestation", func() (*ethpb.AttestResponse, error) {
-		return c.proposeAttestation(ctx, in)
-	})
+	return c.proposeAttestation(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) ProposeBeaconBlock(ctx context.Context, in *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
-	return wrapInMetrics[*ethpb.ProposeResponse]("ProposeBeaconBlock", func() (*ethpb.ProposeResponse, error) {
-		return c.proposeBeaconBlock(ctx, in)
-	})
+	return c.proposeBeaconBlock(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) ProposeExit(ctx context.Context, in *ethpb.SignedVoluntaryExit) (*ethpb.ProposeExitResponse, error) {
-	return wrapInMetrics[*ethpb.ProposeExitResponse]("ProposeExit", func() (*ethpb.ProposeExitResponse, error) {
-		return c.proposeExit(ctx, in)
-	})
+	return c.proposeExit(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) StreamSlots(ctx context.Context, in *ethpb.StreamSlotsRequest) (ethpb.BeaconNodeValidator_StreamSlotsClient, error) {
@@ -145,45 +123,31 @@ func (c *beaconApiValidatorClient) StreamBlocksAltair(ctx context.Context, in *e
 }
 
 func (c *beaconApiValidatorClient) SubmitAggregateSelectionProof(ctx context.Context, in *ethpb.AggregateSelectionRequest) (*ethpb.AggregateSelectionResponse, error) {
-	return wrapInMetrics[*ethpb.AggregateSelectionResponse]("SubmitAggregateSelectionProof", func() (*ethpb.AggregateSelectionResponse, error) {
-		return c.submitAggregateSelectionProof(ctx, in)
-	})
+	return c.submitAggregateSelectionProof(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedAggregateSelectionProof(ctx context.Context, in *ethpb.SignedAggregateSubmitRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
-	return wrapInMetrics[*ethpb.SignedAggregateSubmitResponse]("SubmitSignedAggregateSelectionProof", func() (*ethpb.SignedAggregateSubmitResponse, error) {
-		return c.submitSignedAggregateSelectionProof(ctx, in)
-	})
+	return c.submitSignedAggregateSelectionProof(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedContributionAndProof(ctx context.Context, in *ethpb.SignedContributionAndProof) (*empty.Empty, error) {
-	return wrapInMetrics[*empty.Empty]("SubmitSignedContributionAndProof", func() (*empty.Empty, error) {
-		return new(empty.Empty), c.submitSignedContributionAndProof(ctx, in)
-	})
+	return new(empty.Empty), c.submitSignedContributionAndProof(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) SubmitSyncMessage(ctx context.Context, in *ethpb.SyncCommitteeMessage) (*empty.Empty, error) {
-	return wrapInMetrics[*empty.Empty]("SubmitSyncMessage", func() (*empty.Empty, error) {
-		return new(empty.Empty), c.submitSyncMessage(ctx, in)
-	})
+	return new(empty.Empty), c.submitSyncMessage(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) SubmitValidatorRegistrations(ctx context.Context, in *ethpb.SignedValidatorRegistrationsV1) (*empty.Empty, error) {
-	return wrapInMetrics[*empty.Empty]("SubmitValidatorRegistrations", func() (*empty.Empty, error) {
-		return new(empty.Empty), c.submitValidatorRegistrations(ctx, in.Messages)
-	})
+	return new(empty.Empty), c.submitValidatorRegistrations(ctx, in.Messages)
 }
 
 func (c *beaconApiValidatorClient) SubscribeCommitteeSubnets(ctx context.Context, in *ethpb.CommitteeSubnetsSubscribeRequest, validatorIndices []primitives.ValidatorIndex) (*empty.Empty, error) {
-	return wrapInMetrics[*empty.Empty]("SubscribeCommitteeSubnets", func() (*empty.Empty, error) {
-		return new(empty.Empty), c.subscribeCommitteeSubnets(ctx, in, validatorIndices)
-	})
+	return new(empty.Empty), c.subscribeCommitteeSubnets(ctx, in, validatorIndices)
 }
 
 func (c *beaconApiValidatorClient) ValidatorIndex(ctx context.Context, in *ethpb.ValidatorIndexRequest) (*ethpb.ValidatorIndexResponse, error) {
-	return wrapInMetrics[*ethpb.ValidatorIndexResponse]("ValidatorIndex", func() (*ethpb.ValidatorIndexResponse, error) {
-		return c.validatorIndex(ctx, in)
-	})
+	return c.validatorIndex(ctx, in)
 }
 
 func (c *beaconApiValidatorClient) ValidatorStatus(ctx context.Context, in *ethpb.ValidatorStatusRequest) (*ethpb.ValidatorStatusResponse, error) {
@@ -219,15 +183,3 @@ func (c *beaconApiValidatorClient) GetAggregatedSelections(ctx context.Context,
 func (c *beaconApiValidatorClient) GetAggregatedSyncSelections(ctx context.Context, selections []iface.SyncCommitteeSelection) ([]iface.SyncCommitteeSelection, error) {
 	return c.getAggregatedSyncSelections(ctx, selections)
 }
-
-func wrapInMetrics[Resp any](action string, f func() (Resp, error)) (Resp, error) {
-	now := time.Now()
-	resp, err := f()
-	httpActionCount.WithLabelValues(action).Inc()
-	if err == nil {
-		httpActionLatency.WithLabelValues(action).Observe(time.Since(now).Seconds())
-	} else {
-		failedHTTPActionCount.WithLabelValues(action).Inc()
-	}
-	return resp, err
-}

validator/client/beacon-api/beacon_api_validator_client_test.go

@@ -54,6 +54,12 @@ func TestBeaconApiValidatorClient_GetAttestationDataValid(t *testing.T) {
 	assert.DeepEqual(t, expectedResp, resp)
 }
 
+func TestBeaconApiValidatorClient_GetAttestationDataNilInput(t *testing.T) {
+	validatorClient := beaconApiValidatorClient{}
+	_, err := validatorClient.GetAttestationData(context.Background(), nil)
+	assert.ErrorContains(t, "GetAttestationData received nil argument `in`", err)
+}
+
 func TestBeaconApiValidatorClient_GetAttestationDataError(t *testing.T) {
 	const slot = primitives.Slot(1)
 	const committeeIndex = primitives.CommitteeIndex(2)

validator/client/beacon-api/metrics.go

@@ -1,34 +0,0 @@
-package beacon_api
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-var (
-	httpActionLatency = promauto.NewHistogramVec(
-		prometheus.HistogramOpts{
-			Namespace: "validator",
-			Name:      "http_action_latency_seconds",
-			Help:      "Latency of HTTP actions performed against the beacon node in seconds. This metric captures only actions that didn't result in an error.",
-			Buckets:   []float64{0.001, 0.01, 0.025, 0.1, 0.25, 1, 2.5, 10},
-		},
-		[]string{"action"},
-	)
-	httpActionCount = promauto.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: "validator",
-			Name:      "http_action_count",
-			Help:      "Number of all HTTP actions performed against the beacon node",
-		},
-		[]string{"action"},
-	)
-	failedHTTPActionCount = promauto.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: "validator",
-			Name:      "failed_http_action_count",
-			Help:      "Number of failed HTTP actions performed against the beacon node",
-		},
-		[]string{"action"},
-	)
-)