REST VC metrics (#13588)

* REST VC metrics

* validator status is not used

* refactor

* remove test

* server-side

* server-side per endpoint

* cleanup

* add config endpoints

* add proper HTTP methods to endpoints

* initialize missing fields

beacon-chain/rpc/BUILD.bazel

@@ -3,6 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "endpoints.go",
         "log.go",
         "service.go",
     ],
@@ -58,6 +59,9 @@ 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",
@@ -70,23 +74,14 @@ go_library(
 go_test(
     name = "go_default_test",
     size = "medium",
-    srcs = ["service_test.go"],
+    srcs = [
+        "endpoints_test.go",
+        "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/endpoints.go

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

@@ -0,0 +1,150 @@
+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/service.go

@@ -6,7 +6,6 @@ import (
 	"context"
 	"fmt"
 	"net"
-	"net/http"
 	"sync"
 
 	"github.com/gorilla/mux"
@@ -15,6 +14,9 @@ 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"
@@ -32,24 +34,12 @@ 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"
@@ -68,6 +58,24 @@ 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
@@ -208,25 +216,6 @@ 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,
@@ -240,7 +229,6 @@ 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,
@@ -280,26 +268,6 @@ 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.
@@ -314,19 +282,6 @@ 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,
@@ -352,52 +307,23 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		CoreService:                 coreService,
 	}
 
-	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,
-	})
+	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...)
+	}
 
 	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{
@@ -409,47 +335,12 @@ 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
 }
 
@@ -457,130 +348,6 @@ 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,25 +4,12 @@ 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"
@@ -48,148 +35,6 @@ 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{

validator/client/beacon-api/BUILD.bazel

@@ -22,6 +22,7 @@ go_library(
         "index.go",
         "json_rest_handler.go",
         "log.go",
+        "metrics.go",
         "prepare_beacon_proposer.go",
         "propose_attestation.go",
         "propose_beacon_block.go",
@@ -60,6 +61,8 @@ 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,32 +50,38 @@ func NewBeaconApiValidatorClient(jsonRestHandler JsonRestHandler, opts ...Valida
 }
 
 func (c *beaconApiValidatorClient) GetDuties(ctx context.Context, in *ethpb.DutiesRequest) (*ethpb.DutiesResponse, error) {
-	return c.getDuties(ctx, in)
+	return wrapInMetrics[*ethpb.DutiesResponse]("GetDuties", func() (*ethpb.DutiesResponse, error) {
+		return c.getDuties(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) CheckDoppelGanger(ctx context.Context, in *ethpb.DoppelGangerRequest) (*ethpb.DoppelGangerResponse, error) {
-	return c.checkDoppelGanger(ctx, in)
+	return wrapInMetrics[*ethpb.DoppelGangerResponse]("CheckDoppelGanger", func() (*ethpb.DoppelGangerResponse, error) {
+		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 c.getDomainData(ctx, in.Epoch, domainType)
+
+	return wrapInMetrics[*ethpb.DomainResponse]("DomainData", func() (*ethpb.DomainResponse, error) {
+		return c.getDomainData(ctx, in.Epoch, domainType)
+	})
 }
 
 func (c *beaconApiValidatorClient) GetAttestationData(ctx context.Context, in *ethpb.AttestationDataRequest) (*ethpb.AttestationData, error) {
-	if in == nil {
-		return nil, errors.New("GetAttestationData received nil argument `in`")
-	}
-
-	return c.getAttestationData(ctx, in.Slot, in.CommitteeIndex)
+	return wrapInMetrics[*ethpb.AttestationData]("GetAttestationData", func() (*ethpb.AttestationData, error) {
+		return c.getAttestationData(ctx, in.Slot, in.CommitteeIndex)
+	})
 }
 
 func (c *beaconApiValidatorClient) GetBeaconBlock(ctx context.Context, in *ethpb.BlockRequest) (*ethpb.GenericBeaconBlock, error) {
-	return c.getBeaconBlock(ctx, in.Slot, in.RandaoReveal, in.Graffiti)
+	return wrapInMetrics[*ethpb.GenericBeaconBlock]("GetBeaconBlock", func() (*ethpb.GenericBeaconBlock, error) {
+		return c.getBeaconBlock(ctx, in.Slot, in.RandaoReveal, in.Graffiti)
+	})
 }
 
 func (c *beaconApiValidatorClient) GetFeeRecipientByPubKey(_ context.Context, _ *ethpb.FeeRecipientByPubKeyRequest) (*ethpb.FeeRecipientByPubKeyResponse, error) {
@@ -83,35 +89,51 @@ func (c *beaconApiValidatorClient) GetFeeRecipientByPubKey(_ context.Context, _
 }
 
 func (c *beaconApiValidatorClient) GetSyncCommitteeContribution(ctx context.Context, in *ethpb.SyncCommitteeContributionRequest) (*ethpb.SyncCommitteeContribution, error) {
-	return c.getSyncCommitteeContribution(ctx, in)
+	return wrapInMetrics[*ethpb.SyncCommitteeContribution]("GetSyncCommitteeContribution", func() (*ethpb.SyncCommitteeContribution, error) {
+		return c.getSyncCommitteeContribution(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) GetSyncMessageBlockRoot(ctx context.Context, _ *empty.Empty) (*ethpb.SyncMessageBlockRootResponse, error) {
-	return c.getSyncMessageBlockRoot(ctx)
+	return wrapInMetrics[*ethpb.SyncMessageBlockRootResponse]("GetSyncMessageBlockRoot", func() (*ethpb.SyncMessageBlockRootResponse, error) {
+		return c.getSyncMessageBlockRoot(ctx)
+	})
 }
 
 func (c *beaconApiValidatorClient) GetSyncSubcommitteeIndex(ctx context.Context, in *ethpb.SyncSubcommitteeIndexRequest) (*ethpb.SyncSubcommitteeIndexResponse, error) {
-	return c.getSyncSubcommitteeIndex(ctx, in)
+	return wrapInMetrics[*ethpb.SyncSubcommitteeIndexResponse]("GetSyncSubcommitteeIndex", func() (*ethpb.SyncSubcommitteeIndexResponse, error) {
+		return c.getSyncSubcommitteeIndex(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) MultipleValidatorStatus(ctx context.Context, in *ethpb.MultipleValidatorStatusRequest) (*ethpb.MultipleValidatorStatusResponse, error) {
-	return c.multipleValidatorStatus(ctx, in)
+	return wrapInMetrics[*ethpb.MultipleValidatorStatusResponse]("MultipleValidatorStatus", func() (*ethpb.MultipleValidatorStatusResponse, error) {
+		return c.multipleValidatorStatus(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) PrepareBeaconProposer(ctx context.Context, in *ethpb.PrepareBeaconProposerRequest) (*empty.Empty, error) {
-	return new(empty.Empty), c.prepareBeaconProposer(ctx, in.Recipients)
+	return wrapInMetrics[*empty.Empty]("PrepareBeaconProposer", func() (*empty.Empty, error) {
+		return new(empty.Empty), c.prepareBeaconProposer(ctx, in.Recipients)
+	})
 }
 
 func (c *beaconApiValidatorClient) ProposeAttestation(ctx context.Context, in *ethpb.Attestation) (*ethpb.AttestResponse, error) {
-	return c.proposeAttestation(ctx, in)
+	return wrapInMetrics[*ethpb.AttestResponse]("ProposeAttestation", func() (*ethpb.AttestResponse, error) {
+		return c.proposeAttestation(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) ProposeBeaconBlock(ctx context.Context, in *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
-	return c.proposeBeaconBlock(ctx, in)
+	return wrapInMetrics[*ethpb.ProposeResponse]("ProposeBeaconBlock", func() (*ethpb.ProposeResponse, error) {
+		return c.proposeBeaconBlock(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) ProposeExit(ctx context.Context, in *ethpb.SignedVoluntaryExit) (*ethpb.ProposeExitResponse, error) {
-	return c.proposeExit(ctx, in)
+	return wrapInMetrics[*ethpb.ProposeExitResponse]("ProposeExit", func() (*ethpb.ProposeExitResponse, error) {
+		return c.proposeExit(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) StreamSlots(ctx context.Context, in *ethpb.StreamSlotsRequest) (ethpb.BeaconNodeValidator_StreamSlotsClient, error) {
@@ -123,31 +145,45 @@ func (c *beaconApiValidatorClient) StreamBlocksAltair(ctx context.Context, in *e
 }
 
 func (c *beaconApiValidatorClient) SubmitAggregateSelectionProof(ctx context.Context, in *ethpb.AggregateSelectionRequest) (*ethpb.AggregateSelectionResponse, error) {
-	return c.submitAggregateSelectionProof(ctx, in)
+	return wrapInMetrics[*ethpb.AggregateSelectionResponse]("SubmitAggregateSelectionProof", func() (*ethpb.AggregateSelectionResponse, error) {
+		return c.submitAggregateSelectionProof(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedAggregateSelectionProof(ctx context.Context, in *ethpb.SignedAggregateSubmitRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
-	return c.submitSignedAggregateSelectionProof(ctx, in)
+	return wrapInMetrics[*ethpb.SignedAggregateSubmitResponse]("SubmitSignedAggregateSelectionProof", func() (*ethpb.SignedAggregateSubmitResponse, error) {
+		return c.submitSignedAggregateSelectionProof(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) SubmitSignedContributionAndProof(ctx context.Context, in *ethpb.SignedContributionAndProof) (*empty.Empty, error) {
-	return new(empty.Empty), c.submitSignedContributionAndProof(ctx, in)
+	return wrapInMetrics[*empty.Empty]("SubmitSignedContributionAndProof", func() (*empty.Empty, error) {
+		return new(empty.Empty), c.submitSignedContributionAndProof(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) SubmitSyncMessage(ctx context.Context, in *ethpb.SyncCommitteeMessage) (*empty.Empty, error) {
-	return new(empty.Empty), c.submitSyncMessage(ctx, in)
+	return wrapInMetrics[*empty.Empty]("SubmitSyncMessage", func() (*empty.Empty, error) {
+		return new(empty.Empty), c.submitSyncMessage(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) SubmitValidatorRegistrations(ctx context.Context, in *ethpb.SignedValidatorRegistrationsV1) (*empty.Empty, error) {
-	return new(empty.Empty), c.submitValidatorRegistrations(ctx, in.Messages)
+	return wrapInMetrics[*empty.Empty]("SubmitValidatorRegistrations", func() (*empty.Empty, error) {
+		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 new(empty.Empty), c.subscribeCommitteeSubnets(ctx, in, validatorIndices)
+	return wrapInMetrics[*empty.Empty]("SubscribeCommitteeSubnets", func() (*empty.Empty, error) {
+		return new(empty.Empty), c.subscribeCommitteeSubnets(ctx, in, validatorIndices)
+	})
 }
 
 func (c *beaconApiValidatorClient) ValidatorIndex(ctx context.Context, in *ethpb.ValidatorIndexRequest) (*ethpb.ValidatorIndexResponse, error) {
-	return c.validatorIndex(ctx, in)
+	return wrapInMetrics[*ethpb.ValidatorIndexResponse]("ValidatorIndex", func() (*ethpb.ValidatorIndexResponse, error) {
+		return c.validatorIndex(ctx, in)
+	})
 }
 
 func (c *beaconApiValidatorClient) ValidatorStatus(ctx context.Context, in *ethpb.ValidatorStatusRequest) (*ethpb.ValidatorStatusResponse, error) {
@@ -183,3 +219,15 @@ 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,12 +54,6 @@ 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

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