Merge branch 'develop' into deflake-evaluator

api/failover/BUILD.bazel

@@ -1,19 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "failover.go",
-        "log.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/api/failover",
-    visibility = ["//visibility:public"],
-    deps = ["@com_github_sirupsen_logrus//:go_default_library"],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["failover_test.go"],
-    embed = [":go_default_library"],
-    deps = ["//testing/assert:go_default_library"],
-)

api/failover/failover.go

@@ -1,75 +0,0 @@
-package failover
-
-import (
-	"context"
-
-	"github.com/sirupsen/logrus"
-)
-
-// HostProvider is the subset of connection-provider methods that EnsureReady
-// needs. Both grpc.GrpcConnectionProvider and rest.RestConnectionProvider
-// satisfy this interface.
-type HostProvider interface {
-	Hosts() []string
-	CurrentHost() string
-	SwitchHost(index int) error
-}
-
-// ReadyChecker can report whether the current endpoint is ready.
-// iface.NodeClient satisfies this implicitly.
-type ReadyChecker interface {
-	IsReady(ctx context.Context) bool
-}
-
-// EnsureReady iterates through the configured hosts and returns true as soon as
-// one responds as ready. It starts from the provider's current host and wraps
-// around using modular arithmetic, performing failover when a host is not ready.
-func EnsureReady(ctx context.Context, provider HostProvider, checker ReadyChecker) bool {
-	hosts := provider.Hosts()
-	numHosts := len(hosts)
-	startingHost := provider.CurrentHost()
-	var attemptedHosts []string
-
-	// Find current index
-	currentIdx := 0
-	for i, h := range hosts {
-		if h == startingHost {
-			currentIdx = i
-			break
-		}
-	}
-
-	for i := range numHosts {
-		if checker.IsReady(ctx) {
-			if len(attemptedHosts) > 0 {
-				log.WithFields(logrus.Fields{
-					"previousHost":   startingHost,
-					"newHost":        provider.CurrentHost(),
-					"failedAttempts": attemptedHosts,
-				}).Info("Failover succeeded: connected to healthy beacon node")
-			}
-			return true
-		}
-		log.WithField("host", provider.CurrentHost()).Debug("Beacon node not fully synced")
-		attemptedHosts = append(attemptedHosts, provider.CurrentHost())
-
-		// Try next host if not the last iteration
-		if i < numHosts-1 {
-			nextIdx := (currentIdx + i + 1) % numHosts
-			log.WithFields(logrus.Fields{
-				"currentHost": hosts[currentIdx],
-				"nextHost":    hosts[nextIdx],
-			}).Warn("Beacon node is not responding, switching host")
-			if err := provider.SwitchHost(nextIdx); err != nil {
-				log.WithError(err).Error("Failed to switch host")
-			}
-		}
-	}
-
-	if numHosts == 1 {
-		log.WithField("host", provider.CurrentHost()).Warn("Beacon node is not fully synced, no backup node configured")
-	} else {
-		log.Warn("No fully synced beacon node found")
-	}
-	return false
-}

api/failover/failover_test.go

@@ -1,94 +0,0 @@
-package failover
-
-import (
-	"context"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/testing/assert"
-)
-
-// mockHostProvider is a minimal HostProvider for unit tests.
-type mockHostProvider struct {
-	hosts     []string
-	hostIndex int
-}
-
-func (m *mockHostProvider) Hosts() []string { return m.hosts }
-func (m *mockHostProvider) CurrentHost() string {
-	return m.hosts[m.hostIndex%len(m.hosts)]
-}
-func (m *mockHostProvider) SwitchHost(index int) error { m.hostIndex = index; return nil }
-
-// mockReadyChecker records per-call IsReady results in sequence.
-type mockReadyChecker struct {
-	results []bool
-	idx     int
-}
-
-func (m *mockReadyChecker) IsReady(_ context.Context) bool {
-	if m.idx >= len(m.results) {
-		return false
-	}
-	r := m.results[m.idx]
-	m.idx++
-	return r
-}
-
-func TestEnsureReady_SingleHostReady(t *testing.T) {
-	provider := &mockHostProvider{hosts: []string{"http://host1:3500"}, hostIndex: 0}
-	checker := &mockReadyChecker{results: []bool{true}}
-	assert.Equal(t, true, EnsureReady(t.Context(), provider, checker))
-	assert.Equal(t, 0, provider.hostIndex)
-}
-
-func TestEnsureReady_SingleHostNotReady(t *testing.T) {
-	provider := &mockHostProvider{hosts: []string{"http://host1:3500"}, hostIndex: 0}
-	checker := &mockReadyChecker{results: []bool{false}}
-	assert.Equal(t, false, EnsureReady(t.Context(), provider, checker))
-}
-
-func TestEnsureReady_SingleHostError(t *testing.T) {
-	provider := &mockHostProvider{hosts: []string{"http://host1:3500"}, hostIndex: 0}
-	checker := &mockReadyChecker{results: []bool{false}}
-	assert.Equal(t, false, EnsureReady(t.Context(), provider, checker))
-}
-
-func TestEnsureReady_MultipleHostsFirstReady(t *testing.T) {
-	provider := &mockHostProvider{
-		hosts:     []string{"http://host1:3500", "http://host2:3500"},
-		hostIndex: 0,
-	}
-	checker := &mockReadyChecker{results: []bool{true}}
-	assert.Equal(t, true, EnsureReady(t.Context(), provider, checker))
-	assert.Equal(t, 0, provider.hostIndex)
-}
-
-func TestEnsureReady_MultipleHostsFailoverToSecond(t *testing.T) {
-	provider := &mockHostProvider{
-		hosts:     []string{"http://host1:3500", "http://host2:3500"},
-		hostIndex: 0,
-	}
-	checker := &mockReadyChecker{results: []bool{false, true}}
-	assert.Equal(t, true, EnsureReady(t.Context(), provider, checker))
-	assert.Equal(t, 1, provider.hostIndex)
-}
-
-func TestEnsureReady_MultipleHostsNoneReady(t *testing.T) {
-	provider := &mockHostProvider{
-		hosts:     []string{"http://host1:3500", "http://host2:3500", "http://host3:3500"},
-		hostIndex: 0,
-	}
-	checker := &mockReadyChecker{results: []bool{false, false, false}}
-	assert.Equal(t, false, EnsureReady(t.Context(), provider, checker))
-}
-
-func TestEnsureReady_WrapAroundFromNonZeroIndex(t *testing.T) {
-	provider := &mockHostProvider{
-		hosts:     []string{"http://host0:3500", "http://host1:3500", "http://host2:3500"},
-		hostIndex: 1,
-	}
-	// host1 (start) fails, host2 fails, host0 succeeds
-	checker := &mockReadyChecker{results: []bool{false, false, true}}
-	assert.Equal(t, true, EnsureReady(t.Context(), provider, checker))
-	assert.Equal(t, 0, provider.hostIndex)
-}

api/failover/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package failover
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "api/failover")

api/grpc/grpc_connection_provider.go

@@ -25,11 +25,6 @@ type GrpcConnectionProvider interface {
 	// SwitchHost switches to the endpoint at the given index.
 	// The new connection is created lazily on next CurrentConn() call.
 	SwitchHost(index int) error
-	// ConnectionCounter returns a monotonically increasing counter that increments
-	// each time SwitchHost changes the active endpoint. This allows consumers to
-	// detect connection changes even when the host string returns to a previous value
-	// (e.g., host0 → host1 → host0).
-	ConnectionCounter() uint64
 	// Close closes the current connection.
 	Close()
 }
@@ -43,7 +38,6 @@ type grpcConnectionProvider struct {
 	// Current connection state (protected by mutex)
 	currentIndex uint64
 	conn         *grpc.ClientConn
-	connCounter  uint64
 
 	mu     sync.Mutex
 	closed bool
@@ -144,7 +138,6 @@ func (p *grpcConnectionProvider) SwitchHost(index int) error {
 
 	p.conn = nil // Clear immediately - new connection created lazily
 	p.currentIndex = uint64(index)
-	p.connCounter++
 
 	// Close old connection asynchronously to avoid blocking the caller
 	if oldConn != nil {
@@ -162,12 +155,6 @@ func (p *grpcConnectionProvider) SwitchHost(index int) error {
 	return nil
 }
 
-func (p *grpcConnectionProvider) ConnectionCounter() uint64 {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	return p.connCounter
-}
-
 func (p *grpcConnectionProvider) Close() {
 	p.mu.Lock()
 	defer p.mu.Unlock()

api/grpc/mock_grpc_provider.go

@@ -4,24 +4,17 @@ import "google.golang.org/grpc"
 
 // MockGrpcProvider implements GrpcConnectionProvider for testing.
 type MockGrpcProvider struct {
-	MockConn     *grpc.ClientConn
-	MockHosts    []string
-	CurrentIndex int
-	ConnCounter  uint64
+	MockConn  *grpc.ClientConn
+	MockHosts []string
 }
 
 func (m *MockGrpcProvider) CurrentConn() *grpc.ClientConn { return m.MockConn }
 func (m *MockGrpcProvider) CurrentHost() string {
 	if len(m.MockHosts) > 0 {
-		return m.MockHosts[m.CurrentIndex]
+		return m.MockHosts[0]
 	}
 	return ""
 }
-func (m *MockGrpcProvider) Hosts() []string { return m.MockHosts }
-func (m *MockGrpcProvider) SwitchHost(idx int) error {
-	m.CurrentIndex = idx
-	m.ConnCounter++
-	return nil
-}
-func (m *MockGrpcProvider) ConnectionCounter() uint64 { return m.ConnCounter }
-func (m *MockGrpcProvider) Close()                    {}
+func (m *MockGrpcProvider) Hosts() []string      { return m.MockHosts }
+func (m *MockGrpcProvider) SwitchHost(int) error { return nil }
+func (m *MockGrpcProvider) Close()               {}

api/rest/mock_rest_provider.go

@@ -9,13 +9,13 @@ import (
 // MockRestProvider implements RestConnectionProvider for testing.
 type MockRestProvider struct {
 	MockClient  *http.Client
-	MockHandler Handler
+	MockHandler RestHandler
 	MockHosts   []string
 	HostIndex   int
 }
 
 func (m *MockRestProvider) HttpClient() *http.Client { return m.MockClient }
-func (m *MockRestProvider) Handler() Handler         { return m.MockHandler }
+func (m *MockRestProvider) RestHandler() RestHandler { return m.MockHandler }
 func (m *MockRestProvider) CurrentHost() string {
 	if len(m.MockHosts) > 0 {
 		return m.MockHosts[m.HostIndex%len(m.MockHosts)]
@@ -25,22 +25,25 @@ func (m *MockRestProvider) CurrentHost() string {
 func (m *MockRestProvider) Hosts() []string            { return m.MockHosts }
 func (m *MockRestProvider) SwitchHost(index int) error { m.HostIndex = index; return nil }
 
-// MockHandler implements Handler for testing.
-type MockHandler struct {
-	MockHost string
+// MockRestHandler implements RestHandler for testing.
+type MockRestHandler struct {
+	MockHost   string
+	MockClient *http.Client
 }
 
-func (m *MockHandler) Get(_ context.Context, _ string, _ any) error { return nil }
-func (m *MockHandler) GetStatusCode(_ context.Context, _ string) (int, error) {
+func (m *MockRestHandler) Get(_ context.Context, _ string, _ any) error { return nil }
+func (m *MockRestHandler) GetStatusCode(_ context.Context, _ string) (int, error) {
 	return http.StatusOK, nil
 }
-func (m *MockHandler) GetSSZ(_ context.Context, _ string) ([]byte, http.Header, error) {
+func (m *MockRestHandler) GetSSZ(_ context.Context, _ string) ([]byte, http.Header, error) {
 	return nil, nil, nil
 }
-func (m *MockHandler) Post(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer, _ any) error {
+func (m *MockRestHandler) Post(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer, _ any) error {
 	return nil
 }
-func (m *MockHandler) PostSSZ(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer) ([]byte, http.Header, error) {
+func (m *MockRestHandler) PostSSZ(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer) ([]byte, http.Header, error) {
 	return nil, nil, nil
 }
-func (m *MockHandler) Host() string { return m.MockHost }
+func (m *MockRestHandler) HttpClient() *http.Client { return m.MockClient }
+func (m *MockRestHandler) Host() string             { return m.MockHost }
+func (m *MockRestHandler) SwitchHost(host string)   { m.MockHost = host }

api/rest/rest_connection_provider.go

@@ -17,8 +17,8 @@ import (
 type RestConnectionProvider interface {
 	// HttpClient returns the configured HTTP client with headers, timeout, and optional tracing.
 	HttpClient() *http.Client
-	// Handler returns the REST handler for making API requests.
-	Handler() Handler
+	// RestHandler returns the REST handler for making API requests.
+	RestHandler() RestHandler
 	// CurrentHost returns the current REST API endpoint URL.
 	CurrentHost() string
 	// Hosts returns all configured REST API endpoint URLs.
@@ -54,7 +54,7 @@ func WithTracing() RestConnectionProviderOption {
 type restConnectionProvider struct {
 	endpoints     []string
 	httpClient    *http.Client
-	restHandler   *handler
+	restHandler   RestHandler
 	currentIndex  atomic.Uint64
 	timeout       time.Duration
 	headers       map[string][]string
@@ -96,7 +96,7 @@ func NewRestConnectionProvider(endpoint string, opts ...RestConnectionProviderOp
 	}
 
 	// Create the REST handler with the HTTP client and initial host
-	p.restHandler = newHandler(*p.httpClient, endpoints[0])
+	p.restHandler = newRestHandler(*p.httpClient, endpoints[0])
 
 	log.WithFields(logrus.Fields{
 		"endpoints": endpoints,
@@ -124,7 +124,7 @@ func (p *restConnectionProvider) HttpClient() *http.Client {
 	return p.httpClient
 }
 
-func (p *restConnectionProvider) Handler() Handler {
+func (p *restConnectionProvider) RestHandler() RestHandler {
 	return p.restHandler
 }
 

api/rest/rest_handler.go

@@ -21,35 +21,32 @@ import (
 
 type reqOption func(*http.Request)
 
-// Handler defines the interface for making REST API requests.
-type Handler interface {
+// RestHandler defines the interface for making REST API requests.
+type RestHandler interface {
 	Get(ctx context.Context, endpoint string, resp any) error
 	GetStatusCode(ctx context.Context, endpoint string) (int, error)
 	GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error)
 	Post(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer, resp any) error
 	PostSSZ(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer) ([]byte, http.Header, error)
+	HttpClient() *http.Client
 	Host() string
+	SwitchHost(host string)
 }
 
-type handler struct {
+type restHandler struct {
 	client       http.Client
 	host         string
 	reqOverrides []reqOption
 }
 
-// newHandler returns a *handler for internal use within the rest package.
-func newHandler(client http.Client, host string) *handler {
-	rh := &handler{
-		client: client,
-		host:   host,
-	}
-	rh.appendAcceptOverride()
-	return rh
+// newRestHandler returns a RestHandler (internal use)
+func newRestHandler(client http.Client, host string) RestHandler {
+	return NewRestHandler(client, host)
 }
 
-// NewHandler returns a Handler
-func NewHandler(client http.Client, host string) Handler {
-	rh := &handler{
+// NewRestHandler returns a RestHandler
+func NewRestHandler(client http.Client, host string) RestHandler {
+	rh := &restHandler{
 		client: client,
 		host:   host,
 	}
@@ -60,7 +57,7 @@ func NewHandler(client http.Client, host string) Handler {
 // appendAcceptOverride enables the Accept header to be customized at runtime via an environment variable.
 // This is specified as an env var because it is a niche option that prysm may use for performance testing or debugging
 // bug which users are unlikely to need. Using an env var keeps the set of user-facing flags cleaner.
-func (c *handler) appendAcceptOverride() {
+func (c *restHandler) appendAcceptOverride() {
 	if accept := os.Getenv(params.EnvNameOverrideAccept); accept != "" {
 		c.reqOverrides = append(c.reqOverrides, func(req *http.Request) {
 			req.Header.Set("Accept", accept)
@@ -69,18 +66,18 @@ func (c *handler) appendAcceptOverride() {
 }
 
 // HttpClient returns the underlying HTTP client of the handler
-func (c *handler) HttpClient() *http.Client {
+func (c *restHandler) HttpClient() *http.Client {
 	return &c.client
 }
 
 // Host returns the underlying HTTP host
-func (c *handler) Host() string {
+func (c *restHandler) Host() string {
 	return c.host
 }
 
 // Get sends a GET request and decodes the response body as a JSON object into the passed in object.
 // If an HTTP error is returned, the body is decoded as a DefaultJsonError JSON object and returned as the first return value.
-func (c *handler) Get(ctx context.Context, endpoint string, resp any) error {
+func (c *restHandler) Get(ctx context.Context, endpoint string, resp any) error {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -103,7 +100,7 @@ func (c *handler) Get(ctx context.Context, endpoint string, resp any) error {
 // GetStatusCode sends a GET request and returns only the HTTP status code.
 // This is useful for endpoints like /eth/v1/node/health that communicate status via HTTP codes
 // (200 = ready, 206 = syncing, 503 = unavailable) rather than response bodies.
-func (c *handler) GetStatusCode(ctx context.Context, endpoint string) (int, error) {
+func (c *restHandler) GetStatusCode(ctx context.Context, endpoint string) (int, error) {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -122,7 +119,7 @@ func (c *handler) GetStatusCode(ctx context.Context, endpoint string) (int, erro
 	return httpResp.StatusCode, nil
 }
 
-func (c *handler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
+func (c *restHandler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -177,7 +174,7 @@ func (c *handler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Hea
 
 // Post sends a POST request and decodes the response body as a JSON object into the passed in object.
 // If an HTTP error is returned, the body is decoded as a DefaultJsonError JSON object and returned as the first return value.
-func (c *handler) Post(
+func (c *restHandler) Post(
 	ctx context.Context,
 	apiEndpoint string,
 	headers map[string]string,
@@ -213,7 +210,7 @@ func (c *handler) Post(
 }
 
 // PostSSZ sends a POST request and prefers an SSZ (application/octet-stream) response body.
-func (c *handler) PostSSZ(
+func (c *restHandler) PostSSZ(
 	ctx context.Context,
 	apiEndpoint string,
 	headers map[string]string,
@@ -314,6 +311,6 @@ func decodeResp(httpResp *http.Response, resp any) error {
 	return nil
 }
 
-func (c *handler) SwitchHost(host string) {
+func (c *restHandler) SwitchHost(host string) {
 	c.host = host
 }

changelog/james-prysm_deflake-evaluator.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- adding some short retries for some end to end evaluators in an attempt to deflake tests.

changelog/james-prysm_host-fallback-cleanup.md

@@ -1,11 +0,0 @@
-### Ignored 
-
-- moved finding healthy node logic to connection provider and other various cleanup on naming.
-
-### Changed
-
-- Improved node fallback logs.
-
-### Fixed
-
-- a potential race condition when switching hosts quickly and reconnecting to same host on an old connection.

testing/endtoend/components/eth1/transactions.go

@@ -40,6 +40,7 @@ type TransactionGenerator struct {
 	cancel        context.CancelFunc
 	paused        bool
 	useLargeBlobs bool // Use large blob transactions (6 blobs per tx) for BPO testing
+	blobTxCount   int  // Number of blob transactions per slot (0 means default of 5)
 }
 
 func (t *TransactionGenerator) UnderlyingProcess() *os.Process {
@@ -48,8 +49,8 @@ func (t *TransactionGenerator) UnderlyingProcess() *os.Process {
 	return &os.Process{}
 }
 
-func NewTransactionGenerator(keystore string, seed int64, useLargeBlobs bool) *TransactionGenerator {
-	return &TransactionGenerator{keystore: keystore, seed: seed, useLargeBlobs: useLargeBlobs}
+func NewTransactionGenerator(keystore string, seed int64, useLargeBlobs bool, blobTxCount int) *TransactionGenerator {
+	return &TransactionGenerator{keystore: keystore, seed: seed, useLargeBlobs: useLargeBlobs, blobTxCount: blobTxCount}
 }
 
 func (t *TransactionGenerator) Start(ctx context.Context) error {
@@ -114,7 +115,7 @@ func (t *TransactionGenerator) Start(ctx context.Context) error {
 				continue
 			}
 			backend := ethclient.NewClient(client)
-			err = SendTransaction(client, mineKey.PrivateKey, gasPrice, mineKey.Address.String(), txCount, backend, false, t.useLargeBlobs)
+			err = SendTransaction(client, mineKey.PrivateKey, gasPrice, mineKey.Address.String(), txCount, backend, false, t.useLargeBlobs, t.blobTxCount)
 			if err != nil {
 				return err
 			}
@@ -128,7 +129,7 @@ func (s *TransactionGenerator) Started() <-chan struct{} {
 	return s.started
 }
 
-func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.Int, addr string, txCount uint64, backend *ethclient.Client, al bool, useLargeBlobs bool) error {
+func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.Int, addr string, txCount uint64, backend *ethclient.Client, al bool, useLargeBlobs bool, blobTxCount int) error {
 	sender := common.HexToAddress(addr)
 	nonce, err := backend.PendingNonceAt(context.Background(), fundedAccount.Address)
 	if err != nil {
@@ -150,14 +151,19 @@ func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.In
 	clock := startup.NewClock(e2e.TestParams.CLGenesisTime, [32]byte{})
 	isPostFulu := clock.CurrentEpoch() >= params.BeaconConfig().FuluForkEpoch
 
+	// Default to 5 blob transactions per slot if not configured.
+	numBlobTxs := blobTxCount
+	if numBlobTxs <= 0 {
+		numBlobTxs = 5
+	}
+
 	g, _ := errgroup.WithContext(context.Background())
-	txs := make([]*types.Transaction, 10)
+	txs := make([]*types.Transaction, numBlobTxs)
 
 	// Send blob transactions - use different versions pre/post Fulu
 	if isPostFulu {
 		logrus.Info("Sending blob transactions with cell proofs")
-		// Reduced from 10 to 5 to reduce load and prevent builder/EL timeouts
-		for index := range uint64(5) {
+		for index := range uint64(numBlobTxs) {
 
 			g.Go(func() error {
 				tx, err := RandomBlobCellTx(client, fundedAccount.Address, nonce+index, gasPrice, chainid, al, useLargeBlobs)
@@ -176,8 +182,7 @@ func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.In
 		}
 	} else {
 		logrus.Info("Sending blob transactions with sidecars")
-		// Reduced from 10 to 5 to reduce load and prevent builder/EL timeouts
-		for index := range uint64(5) {
+		for index := range uint64(numBlobTxs) {
 
 			g.Go(func() error {
 				tx, err := RandomBlobTx(client, fundedAccount.Address, nonce+index, gasPrice, chainid, al, useLargeBlobs)

testing/endtoend/endtoend_test.go

@@ -252,7 +252,7 @@ func (r *testRunner) testDepositsAndTx(ctx context.Context, g *errgroup.Group,
 }
 
 func (r *testRunner) testTxGeneration(ctx context.Context, g *errgroup.Group, keystorePath string, requiredNodes []e2etypes.ComponentRunner) {
-	txGenerator := eth1.NewTransactionGenerator(keystorePath, r.config.Seed, r.config.UseLargeBlobs)
+	txGenerator := eth1.NewTransactionGenerator(keystorePath, r.config.Seed, r.config.UseLargeBlobs, r.config.BlobTxCount)
 	r.comHandler.txGen = txGenerator
 	g.Go(func() error {
 		if err := helpers.ComponentsStarted(ctx, requiredNodes); err != nil {

testing/endtoend/evaluators/node.go

@@ -156,19 +156,9 @@ func waitForMidEpoch(conn *grpc.ClientConn) error {
 	}
 }
 
-func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) error {
-	// Wait until we're at least halfway into the epoch to avoid race conditions
-	// at epoch boundaries where nodes may report different epochs.
-	if err := waitForMidEpoch(conns[0]); err != nil {
-		return errors.Wrap(err, "failed waiting for mid-epoch")
-	}
-
-	headEpochs := make([]primitives.Epoch, len(conns))
-	headBlockRoots := make([][]byte, len(conns))
-	justifiedRoots := make([][]byte, len(conns))
-	prevJustifiedRoots := make([][]byte, len(conns))
-	finalizedRoots := make([][]byte, len(conns))
-	chainHeads := make([]*eth.ChainHead, len(conns))
+// getHeadEpochs fetches the head epoch from all beacon nodes concurrently.
+func getHeadEpochs(conns []*grpc.ClientConn) ([]primitives.Epoch, error) {
+	epochs := make([]primitives.Epoch, len(conns))
 	g, _ := errgroup.WithContext(context.Background())
 
 	for i, conn := range conns {
@@ -180,63 +170,145 @@ func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientCo
 			if err != nil {
 				return errors.Wrapf(err, "connection number=%d", conIdx)
 			}
-			headEpochs[conIdx] = chainHead.HeadEpoch
-			headBlockRoots[conIdx] = chainHead.HeadBlockRoot
-			justifiedRoots[conIdx] = chainHead.JustifiedBlockRoot
-			prevJustifiedRoots[conIdx] = chainHead.PreviousJustifiedBlockRoot
-			finalizedRoots[conIdx] = chainHead.FinalizedBlockRoot
-			chainHeads[conIdx] = chainHead
+			epochs[conIdx] = chainHead.HeadEpoch
 			return nil
 		})
 	}
 	if err := g.Wait(); err != nil {
-		return err
+		return nil, err
 	}
-
-	for i := range conns {
-		if headEpochs[0] != headEpochs[i] {
-			return fmt.Errorf(
-				"received conflicting head epochs on node %d, expected %d, received %d",
-				i,
-				headEpochs[0],
-				headEpochs[i],
-			)
-		}
-		if !bytes.Equal(headBlockRoots[0], headBlockRoots[i]) {
-			return fmt.Errorf(
-				"received conflicting head block roots on node %d, expected %#x, received %#x",
-				i,
-				headBlockRoots[0],
-				headBlockRoots[i],
-			)
-		}
-		if !bytes.Equal(justifiedRoots[0], justifiedRoots[i]) {
-			return fmt.Errorf(
-				"received conflicting justified block roots on node %d, expected %#x, received %#x: %s and %s",
-				i,
-				justifiedRoots[0],
-				justifiedRoots[i],
-				chainHeads[0].String(),
-				chainHeads[i].String(),
-			)
-		}
-		if !bytes.Equal(prevJustifiedRoots[0], prevJustifiedRoots[i]) {
-			return fmt.Errorf(
-				"received conflicting previous justified block roots on node %d, expected %#x, received %#x",
-				i,
-				prevJustifiedRoots[0],
-				prevJustifiedRoots[i],
-			)
-		}
-		if !bytes.Equal(finalizedRoots[0], finalizedRoots[i]) {
-			return fmt.Errorf(
-				"received conflicting finalized epoch roots on node %d, expected %#x, received %#x",
-				i,
-				finalizedRoots[0],
-				finalizedRoots[i],
-			)
-		}
-	}
-
-	return nil
+	return epochs, nil
+}
+
+func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) error {
+	// Wait until we're at least halfway into the epoch to avoid race conditions
+	// at epoch boundaries where nodes may report different epochs.
+	if err := waitForMidEpoch(conns[0]); err != nil {
+		return errors.Wrap(err, "failed waiting for mid-epoch")
+	}
+
+	// First, wait for all nodes to reach the same epoch. Sync nodes may be
+	// behind and need time to catch up. We poll every 2 seconds with a
+	// 60 second timeout - this adapts to actual sync progress rather than
+	// using fixed delays.
+	const epochTimeout = 60 * time.Second
+	const epochPollInterval = 2 * time.Second
+	epochDeadline := time.Now().Add(epochTimeout)
+
+	for time.Now().Before(epochDeadline) {
+		epochs, err := getHeadEpochs(conns)
+		if err != nil {
+			return err
+		}
+		allSame := true
+		for i := 1; i < len(epochs); i++ {
+			if epochs[0] != epochs[i] {
+				allSame = false
+				break
+			}
+		}
+		if allSame {
+			break
+		}
+		time.Sleep(epochPollInterval)
+	}
+
+	// Now that epochs match (or timeout reached), do detailed head comparison
+	// with a few retries to handle block propagation delays.
+	const maxRetries = 5
+	const retryDelay = 1 * time.Second
+	var lastErr error
+
+	for attempt := range maxRetries {
+		if attempt > 0 {
+			time.Sleep(retryDelay)
+		}
+
+		headEpochs := make([]primitives.Epoch, len(conns))
+		headBlockRoots := make([][]byte, len(conns))
+		justifiedRoots := make([][]byte, len(conns))
+		prevJustifiedRoots := make([][]byte, len(conns))
+		finalizedRoots := make([][]byte, len(conns))
+		chainHeads := make([]*eth.ChainHead, len(conns))
+		g, _ := errgroup.WithContext(context.Background())
+
+		for i, conn := range conns {
+			conIdx := i
+			currConn := conn
+			g.Go(func() error {
+				beaconClient := eth.NewBeaconChainClient(currConn)
+				chainHead, err := beaconClient.GetChainHead(context.Background(), &emptypb.Empty{})
+				if err != nil {
+					return errors.Wrapf(err, "connection number=%d", conIdx)
+				}
+				headEpochs[conIdx] = chainHead.HeadEpoch
+				headBlockRoots[conIdx] = chainHead.HeadBlockRoot
+				justifiedRoots[conIdx] = chainHead.JustifiedBlockRoot
+				prevJustifiedRoots[conIdx] = chainHead.PreviousJustifiedBlockRoot
+				finalizedRoots[conIdx] = chainHead.FinalizedBlockRoot
+				chainHeads[conIdx] = chainHead
+				return nil
+			})
+		}
+		if err := g.Wait(); err != nil {
+			return err
+		}
+
+		lastErr = nil
+		for i := range conns {
+			if headEpochs[0] != headEpochs[i] {
+				lastErr = fmt.Errorf(
+					"received conflicting head epochs on node %d, expected %d, received %d",
+					i,
+					headEpochs[0],
+					headEpochs[i],
+				)
+				break
+			}
+			if !bytes.Equal(headBlockRoots[0], headBlockRoots[i]) {
+				lastErr = fmt.Errorf(
+					"received conflicting head block roots on node %d, expected %#x, received %#x",
+					i,
+					headBlockRoots[0],
+					headBlockRoots[i],
+				)
+				break
+			}
+			if !bytes.Equal(justifiedRoots[0], justifiedRoots[i]) {
+				lastErr = fmt.Errorf(
+					"received conflicting justified block roots on node %d, expected %#x, received %#x: %s and %s",
+					i,
+					justifiedRoots[0],
+					justifiedRoots[i],
+					chainHeads[0].String(),
+					chainHeads[i].String(),
+				)
+				break
+			}
+			if !bytes.Equal(prevJustifiedRoots[0], prevJustifiedRoots[i]) {
+				lastErr = fmt.Errorf(
+					"received conflicting previous justified block roots on node %d, expected %#x, received %#x",
+					i,
+					prevJustifiedRoots[0],
+					prevJustifiedRoots[i],
+				)
+				break
+			}
+			if !bytes.Equal(finalizedRoots[0], finalizedRoots[i]) {
+				lastErr = fmt.Errorf(
+					"received conflicting finalized epoch roots on node %d, expected %#x, received %#x",
+					i,
+					finalizedRoots[0],
+					finalizedRoots[i],
+				)
+				break
+			}
+		}
+
+		if lastErr == nil {
+			return nil
+		}
+	}
+
+	return lastErr
 }

testing/endtoend/evaluators/validator.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net/http"
 	"strconv"
+	"time"
 
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/altair"
@@ -123,6 +124,25 @@ func validatorsAreActive(ec *types.EvaluationContext, conns ...*grpc.ClientConn)
 
 // validatorsParticipating ensures the validators have an acceptable participation rate.
 func validatorsParticipating(_ *types.EvaluationContext, conns ...*grpc.ClientConn) error {
+	// Retry up to 3 times with 2 second delays to handle timing flakes where
+	// attestations haven't been fully processed yet due to block propagation delays.
+	const maxRetries = 3
+	const retryDelay = 2 * time.Second
+	var lastErr error
+
+	for attempt := range maxRetries {
+		if attempt > 0 {
+			time.Sleep(retryDelay)
+		}
+		lastErr = checkValidatorsParticipating(conns)
+		if lastErr == nil {
+			return nil
+		}
+	}
+	return lastErr
+}
+
+func checkValidatorsParticipating(conns []*grpc.ClientConn) error {
 	conn := conns[0]
 	client := ethpb.NewBeaconChainClient(conn)
 	validatorRequest := &ethpb.GetValidatorParticipationRequest{}
@@ -234,6 +254,25 @@ func validatorsParticipating(_ *types.EvaluationContext, conns ...*grpc.ClientCo
 // validatorsSyncParticipation ensures the validators have an acceptable participation rate for
 // sync committee assignments.
 func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.ClientConn) error {
+	// Retry up to 3 times with 2 second delays to handle timing flakes where
+	// sync committee messages haven't fully propagated yet.
+	const maxRetries = 3
+	const retryDelay = 2 * time.Second
+	var lastErr error
+
+	for attempt := range maxRetries {
+		if attempt > 0 {
+			time.Sleep(retryDelay)
+		}
+		lastErr = checkSyncParticipation(conns)
+		if lastErr == nil {
+			return nil
+		}
+	}
+	return lastErr
+}
+
+func checkSyncParticipation(conns []*grpc.ClientConn) error {
 	conn := conns[0]
 	client := ethpb.NewNodeClient(conn)
 	altairClient := ethpb.NewBeaconChainClient(conn)
@@ -272,9 +311,9 @@ func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.Clie
 			// Skip fork slot.
 			continue
 		}
-		// Skip slots 1-2 at genesis - validators need time to ramp up after chain start
+		// Skip early slots at genesis - validators need time to ramp up after chain start
 		// due to doppelganger protection. This is a startup timing issue, not a fork transition issue.
-		if b.Block().Slot() < 3 {
+		if b.Block().Slot() < 5 {
 			continue
 		}
 		expectedParticipation := expectedSyncParticipation
@@ -289,6 +328,11 @@ func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.Clie
 		if err != nil {
 			return err
 		}
+		// Skip blocks with zero sync bits - these are typically empty/anomalous blocks
+		// where the proposer didn't receive sync committee contributions in time.
+		if syncAgg.SyncCommitteeBits.Count() == 0 {
+			continue
+		}
 		threshold := uint64(float64(syncAgg.SyncCommitteeBits.Len()) * expectedParticipation)
 		if syncAgg.SyncCommitteeBits.Count() < threshold {
 			return errors.Errorf("In block of slot %d ,the aggregate bitvector with length of %d only got a count of %d", b.Block().Slot(), threshold, syncAgg.SyncCommitteeBits.Count())
@@ -343,6 +387,11 @@ func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.Clie
 		if err != nil {
 			return err
 		}
+		// Skip blocks with zero sync bits - these are typically empty/anomalous blocks
+		// where the proposer didn't receive sync committee contributions in time.
+		if syncAgg.SyncCommitteeBits.Count() == 0 {
+			continue
+		}
 		threshold := uint64(float64(syncAgg.SyncCommitteeBits.Len()) * expectedSyncParticipation)
 		if syncAgg.SyncCommitteeBits.Count() < threshold {
 			return errors.Errorf("In block of slot %d ,the aggregate bitvector with length of %d only got a count of %d", b.Block().Slot(), threshold, syncAgg.SyncCommitteeBits.Count())

testing/endtoend/minimal_builder_e2e_test.go

@@ -9,11 +9,11 @@ import (
 )
 
 func TestEndToEnd_MinimalConfig_WithBuilder(t *testing.T) {
-	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder())
+	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithBlobTxCount(2))
 	r.run()
 }
 
 func TestEndToEnd_MinimalConfig_WithBuilder_ValidatorRESTApi(t *testing.T) {
-	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithValidatorRESTApi())
+	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithValidatorRESTApi(), types.WithBlobTxCount(2))
 	r.run()
 }

testing/endtoend/types/types.go

@@ -68,6 +68,14 @@ func WithLargeBlobs() E2EConfigOpt {
 	}
 }
 
+// WithBlobTxCount sets the number of blob transactions sent per slot.
+// Default is 5 when not specified.
+func WithBlobTxCount(n int) E2EConfigOpt {
+	return func(cfg *E2EConfig) {
+		cfg.BlobTxCount = n
+	}
+}
+
 func WithSSZOnly() E2EConfigOpt {
 	return func(cfg *E2EConfig) {
 		if err := os.Setenv(params.EnvNameOverrideAccept, api.OctetStreamMediaType); err != nil {
@@ -108,6 +116,7 @@ type E2EConfig struct {
 	UseBeaconRestApi        bool
 	UseBuilder              bool
 	UseLargeBlobs           bool // Use large blob transactions (6 blobs per tx) for BPO testing
+	BlobTxCount             int  // Number of blob transactions per slot (0 means default of 5)
 	EpochsToRun             uint64
 	ExitEpoch               primitives.Epoch // Custom epoch for voluntary exit submission (0 means use default)
 	Seed                    int64

testing/validator-mock/validator_client_mock.go

@@ -283,18 +283,16 @@ func (mr *MockValidatorClientMockRecorder) ProposeExit(ctx, in any) *gomock.Call
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeExit", reflect.TypeOf((*MockValidatorClient)(nil).ProposeExit), ctx, in)
 }
 
-// EnsureReady mocks base method.
-func (m *MockValidatorClient) EnsureReady(ctx context.Context) bool {
+// SwitchHost mocks base method.
+func (m *MockValidatorClient) SwitchHost(host string) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnsureReady", ctx)
-	ret0, _ := ret[0].(bool)
-	return ret0
+	m.ctrl.Call(m, "SwitchHost", host)
 }
 
-// EnsureReady indicates an expected call of EnsureReady.
-func (mr *MockValidatorClientMockRecorder) EnsureReady(ctx any) *gomock.Call {
+// SwitchHost indicates an expected call of SwitchHost.
+func (mr *MockValidatorClientMockRecorder) SwitchHost(host any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureReady", reflect.TypeOf((*MockValidatorClient)(nil).EnsureReady), ctx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwitchHost", reflect.TypeOf((*MockValidatorClient)(nil).SwitchHost), host)
 }
 
 // StartEventStream mocks base method.

testing/validator-mock/validator_mock.go

@@ -128,18 +128,18 @@ func (mr *MockValidatorMockRecorder) EventsChan() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsChan", reflect.TypeOf((*MockValidator)(nil).EventsChan))
 }
 
-// EnsureReady mocks base method.
-func (m *MockValidator) EnsureReady(arg0 context.Context) bool {
+// FindHealthyHost mocks base method.
+func (m *MockValidator) FindHealthyHost(arg0 context.Context) bool {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnsureReady", arg0)
+	ret := m.ctrl.Call(m, "FindHealthyHost", arg0)
 	ret0, _ := ret[0].(bool)
 	return ret0
 }
 
-// EnsureReady indicates an expected call of EnsureReady.
-func (mr *MockValidatorMockRecorder) EnsureReady(arg0 any) *gomock.Call {
+// FindHealthyHost indicates an expected call of FindHealthyHost.
+func (mr *MockValidatorMockRecorder) FindHealthyHost(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureReady", reflect.TypeOf((*MockValidator)(nil).EnsureReady), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindHealthyHost", reflect.TypeOf((*MockValidator)(nil).FindHealthyHost), arg0)
 }
 
 // GenesisTime mocks base method.

validator/client/BUILD.bazel

@@ -122,6 +122,7 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//api/grpc:go_default_library",
+        "//api/rest:go_default_library",
         "//api/server/structs:go_default_library",
         "//async/event:go_default_library",
         "//beacon-chain/core/signing:go_default_library",

validator/client/beacon-api/BUILD.bazel

@@ -42,7 +42,6 @@ go_library(
         "//api:go_default_library",
         "//api/apiutil:go_default_library",
         "//api/client/event:go_default_library",
-        "//api/failover:go_default_library",
         "//api/rest:go_default_library",
         "//api/server/structs:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",

validator/client/beacon-api/attestation_data.go

@@ -26,7 +26,7 @@ func (c *beaconApiValidatorClient) attestationData(
 	query := apiutil.BuildURL("/eth/v1/validator/attestation_data", params)
 	produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
 
-	if err := c.handler.Get(ctx, query, &produceAttestationDataResponseJson); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, query, &produceAttestationDataResponseJson); err != nil {
 		return nil, err
 	}
 

validator/client/beacon-api/attestation_data_test.go

@@ -28,10 +28,10 @@ func TestGetAttestationData_ValidAttestation(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 	produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v1/validator/attestation_data?committee_index=%d&slot=%d", expectedCommitteeIndex, expectedSlot),
 		&produceAttestationDataResponseJson,
@@ -56,7 +56,7 @@ func TestGetAttestationData_ValidAttestation(t *testing.T) {
 		},
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	resp, err := validatorClient.attestationData(ctx, primitives.Slot(expectedSlot), primitives.CommitteeIndex(expectedCommitteeIndex))
 	assert.NoError(t, err)
 
@@ -180,8 +180,8 @@ func TestGetAttestationData_InvalidData(t *testing.T) {
 			defer ctrl.Finish()
 
 			produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
-			handler.EXPECT().Get(
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v1/validator/attestation_data?committee_index=2&slot=1",
 				&produceAttestationDataResponseJson,
@@ -192,7 +192,7 @@ func TestGetAttestationData_InvalidData(t *testing.T) {
 				testCase.generateData(),
 			).Times(1)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			_, err := validatorClient.attestationData(ctx, 1, 2)
 			assert.ErrorContains(t, testCase.expectedErrorMessage, err)
 		})
@@ -208,9 +208,9 @@ func TestGetAttestationData_JsonResponseError(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 	produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v1/validator/attestation_data?committee_index=%d&slot=%d", committeeIndex, slot),
 		&produceAttestationDataResponseJson,
@@ -218,7 +218,7 @@ func TestGetAttestationData_JsonResponseError(t *testing.T) {
 		errors.New("some specific json response error"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err := validatorClient.attestationData(ctx, slot, committeeIndex)
 	assert.ErrorContains(t, "some specific json response error", err)
 }

validator/client/beacon-api/beacon_api_beacon_chain_client.go

@@ -18,13 +18,13 @@ import (
 
 type beaconApiChainClient struct {
 	fallbackClient          iface.ChainClient
-	handler                 rest.Handler
+	jsonRestHandler         rest.RestHandler
 	stateValidatorsProvider StateValidatorsProvider
 }
 
 func (c beaconApiChainClient) headBlockHeaders(ctx context.Context) (*structs.GetBlockHeaderResponse, error) {
 	blockHeader := structs.GetBlockHeaderResponse{}
-	err := c.handler.Get(ctx, "/eth/v1/beacon/headers/head", &blockHeader)
+	err := c.jsonRestHandler.Get(ctx, "/eth/v1/beacon/headers/head", &blockHeader)
 	if err != nil {
 		return nil, err
 	}
@@ -44,7 +44,7 @@ func (c beaconApiChainClient) ChainHead(ctx context.Context, _ *empty.Empty) (*e
 	const endpoint = "/eth/v1/beacon/states/head/finality_checkpoints"
 
 	finalityCheckpoints := structs.GetFinalityCheckpointsResponse{}
-	if err := c.handler.Get(ctx, endpoint, &finalityCheckpoints); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, endpoint, &finalityCheckpoints); err != nil {
 		return nil, err
 	}
 
@@ -328,10 +328,10 @@ func (c beaconApiChainClient) ValidatorParticipation(ctx context.Context, in *et
 	return nil, errors.New("beaconApiChainClient.ValidatorParticipation is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiChainClientWithFallback.")
 }
 
-func NewBeaconApiChainClientWithFallback(handler rest.Handler, fallbackClient iface.ChainClient) iface.ChainClient {
+func NewBeaconApiChainClientWithFallback(jsonRestHandler rest.RestHandler, fallbackClient iface.ChainClient) iface.ChainClient {
 	return &beaconApiChainClient{
-		handler:                 handler,
+		jsonRestHandler:         jsonRestHandler,
 		fallbackClient:          fallbackClient,
-		stateValidatorsProvider: beaconApiStateValidatorsProvider{handler: handler},
+		stateValidatorsProvider: beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler},
 	}
 }

validator/client/beacon-api/beacon_api_beacon_chain_client_test.go

@@ -115,12 +115,12 @@ func TestListValidators(t *testing.T) {
 			nil,
 		)
 
-		handler := mock.NewMockJsonRestHandler(ctrl)
-		handler.EXPECT().Get(gomock.Any(), blockHeaderEndpoint, gomock.Any()).Return(errors.New("bar error"))
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+		jsonRestHandler.EXPECT().Get(gomock.Any(), blockHeaderEndpoint, gomock.Any()).Return(errors.New("bar error"))
 
 		beaconChainClient := beaconApiChainClient{
 			stateValidatorsProvider: stateValidatorsProvider,
-			handler:                 handler,
+			jsonRestHandler:         jsonRestHandler,
 		}
 		_, err := beaconChainClient.Validators(ctx, &ethpb.ListValidatorsRequest{
 			QueryFilter: nil,
@@ -188,8 +188,8 @@ func TestListValidators(t *testing.T) {
 					nil,
 				)
 
-				handler := mock.NewMockJsonRestHandler(ctrl)
-				handler.EXPECT().Get(gomock.Any(), blockHeaderEndpoint, gomock.Any()).Return(
+				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+				jsonRestHandler.EXPECT().Get(gomock.Any(), blockHeaderEndpoint, gomock.Any()).Return(
 					nil,
 				).SetArg(
 					2,
@@ -198,7 +198,7 @@ func TestListValidators(t *testing.T) {
 
 				beaconChainClient := beaconApiChainClient{
 					stateValidatorsProvider: stateValidatorsProvider,
-					handler:                 handler,
+					jsonRestHandler:         jsonRestHandler,
 				}
 				_, err := beaconChainClient.Validators(ctx, &ethpb.ListValidatorsRequest{
 					QueryFilter: nil,
@@ -740,15 +740,15 @@ func TestGetChainHead(t *testing.T) {
 				ctx := t.Context()
 
 				finalityCheckpointsResponse := structs.GetFinalityCheckpointsResponse{}
-				handler := mock.NewMockJsonRestHandler(ctrl)
-				handler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
+				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+				jsonRestHandler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
 					testCase.finalityCheckpointsError,
 				).SetArg(
 					2,
 					testCase.generateFinalityCheckpointsResponse(),
 				)
 
-				beaconChainClient := beaconApiChainClient{handler: handler}
+				beaconChainClient := beaconApiChainClient{jsonRestHandler: jsonRestHandler}
 				_, err := beaconChainClient.ChainHead(ctx, &emptypb.Empty{})
 				assert.ErrorContains(t, testCase.expectedError, err)
 			})
@@ -837,10 +837,10 @@ func TestGetChainHead(t *testing.T) {
 				defer ctrl.Finish()
 				ctx := t.Context()
 
-				handler := mock.NewMockJsonRestHandler(ctrl)
+				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 				finalityCheckpointsResponse := structs.GetFinalityCheckpointsResponse{}
-				handler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
+				jsonRestHandler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
 					nil,
 				).SetArg(
 					2,
@@ -848,14 +848,14 @@ func TestGetChainHead(t *testing.T) {
 				)
 
 				headBlockHeadersResponse := structs.GetBlockHeaderResponse{}
-				handler.EXPECT().Get(gomock.Any(), headBlockHeadersEndpoint, &headBlockHeadersResponse).Return(
+				jsonRestHandler.EXPECT().Get(gomock.Any(), headBlockHeadersEndpoint, &headBlockHeadersResponse).Return(
 					testCase.headBlockHeadersError,
 				).SetArg(
 					2,
 					testCase.generateHeadBlockHeadersResponse(),
 				)
 
-				beaconChainClient := beaconApiChainClient{handler: handler}
+				beaconChainClient := beaconApiChainClient{jsonRestHandler: jsonRestHandler}
 				_, err := beaconChainClient.ChainHead(ctx, &emptypb.Empty{})
 				assert.ErrorContains(t, testCase.expectedError, err)
 			})
@@ -867,10 +867,10 @@ func TestGetChainHead(t *testing.T) {
 		defer ctrl.Finish()
 		ctx := t.Context()
 
-		handler := mock.NewMockJsonRestHandler(ctrl)
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 		finalityCheckpointsResponse := structs.GetFinalityCheckpointsResponse{}
-		handler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
+		jsonRestHandler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
 			nil,
 		).SetArg(
 			2,
@@ -878,7 +878,7 @@ func TestGetChainHead(t *testing.T) {
 		)
 
 		headBlockHeadersResponse := structs.GetBlockHeaderResponse{}
-		handler.EXPECT().Get(gomock.Any(), headBlockHeadersEndpoint, &headBlockHeadersResponse).Return(
+		jsonRestHandler.EXPECT().Get(gomock.Any(), headBlockHeadersEndpoint, &headBlockHeadersResponse).Return(
 			nil,
 		).SetArg(
 			2,
@@ -909,7 +909,7 @@ func TestGetChainHead(t *testing.T) {
 			HeadEpoch:                  slots.ToEpoch(8),
 		}
 
-		beaconChainClient := beaconApiChainClient{handler: handler}
+		beaconChainClient := beaconApiChainClient{jsonRestHandler: jsonRestHandler}
 		chainHead, err := beaconChainClient.ChainHead(ctx, &emptypb.Empty{})
 		require.NoError(t, err)
 		assert.DeepEqual(t, expectedChainHead, chainHead)

validator/client/beacon-api/beacon_api_helpers.go

@@ -29,7 +29,7 @@ func (c *beaconApiValidatorClient) fork(ctx context.Context) (*structs.GetStateF
 
 	stateForkResponseJson := &structs.GetStateForkResponse{}
 
-	if err := c.handler.Get(ctx, endpoint, stateForkResponseJson); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, endpoint, stateForkResponseJson); err != nil {
 		return nil, err
 	}
 
@@ -41,7 +41,7 @@ func (c *beaconApiValidatorClient) headers(ctx context.Context) (*structs.GetBlo
 
 	blockHeadersResponseJson := &structs.GetBlockHeadersResponse{}
 
-	if err := c.handler.Get(ctx, endpoint, blockHeadersResponseJson); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, endpoint, blockHeadersResponseJson); err != nil {
 		return nil, err
 	}
 
@@ -59,7 +59,7 @@ func (c *beaconApiValidatorClient) liveness(ctx context.Context, epoch primitive
 		return nil, errors.Wrapf(err, "failed to marshal validator indexes")
 	}
 
-	if err = c.handler.Post(ctx, url, nil, bytes.NewBuffer(marshalledJsonValidatorIndexes), livenessResponseJson); err != nil {
+	if err = c.jsonRestHandler.Post(ctx, url, nil, bytes.NewBuffer(marshalledJsonValidatorIndexes), livenessResponseJson); err != nil {
 		return nil, err
 	}
 
@@ -71,7 +71,7 @@ func (c *beaconApiValidatorClient) syncing(ctx context.Context) (*structs.SyncSt
 
 	syncingResponseJson := &structs.SyncStatusResponse{}
 
-	if err := c.handler.Get(ctx, endpoint, syncingResponseJson); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, endpoint, syncingResponseJson); err != nil {
 		return nil, err
 	}
 

validator/client/beacon-api/beacon_api_helpers_test.go

@@ -20,7 +20,7 @@ func TestGetFork_Nominal(t *testing.T) {
 	defer ctrl.Finish()
 
 	stateForkResponseJson := structs.GetStateForkResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	expected := structs.GetStateForkResponse{
 		Data: &structs.Fork{
@@ -32,7 +32,7 @@ func TestGetFork_Nominal(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		forkEndpoint,
 		&stateForkResponseJson,
@@ -44,7 +44,7 @@ func TestGetFork_Nominal(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		handler: handler,
+		jsonRestHandler: jsonRestHandler,
 	}
 
 	fork, err := validatorClient.fork(ctx)
@@ -56,11 +56,11 @@ func TestGetFork_Invalid(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	ctx := t.Context()
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		forkEndpoint,
 		gomock.Any(),
@@ -69,7 +69,7 @@ func TestGetFork_Invalid(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		handler: handler,
+		jsonRestHandler: jsonRestHandler,
 	}
 
 	_, err := validatorClient.fork(ctx)
@@ -83,7 +83,7 @@ func TestGetHeaders_Nominal(t *testing.T) {
 	defer ctrl.Finish()
 
 	blockHeadersResponseJson := structs.GetBlockHeadersResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	expected := structs.GetBlockHeadersResponse{
 		Data: []*structs.SignedBeaconBlockHeaderContainer{
@@ -99,7 +99,7 @@ func TestGetHeaders_Nominal(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		headersEndpoint,
 		&blockHeadersResponseJson,
@@ -111,7 +111,7 @@ func TestGetHeaders_Nominal(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		handler: handler,
+		jsonRestHandler: jsonRestHandler,
 	}
 
 	headers, err := validatorClient.headers(ctx)
@@ -123,11 +123,11 @@ func TestGetHeaders_Invalid(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	ctx := t.Context()
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		headersEndpoint,
 		gomock.Any(),
@@ -136,7 +136,7 @@ func TestGetHeaders_Invalid(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		handler: handler,
+		jsonRestHandler: jsonRestHandler,
 	}
 
 	_, err := validatorClient.headers(ctx)
@@ -170,8 +170,8 @@ func TestGetLiveness_Nominal(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		livenessEndpoint,
 		nil,
@@ -184,7 +184,7 @@ func TestGetLiveness_Nominal(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	liveness, err := validatorClient.liveness(ctx, 42, indexes)
 
 	require.NoError(t, err)
@@ -197,8 +197,8 @@ func TestGetLiveness_Invalid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		livenessEndpoint,
 		nil,
@@ -208,7 +208,7 @@ func TestGetLiveness_Invalid(t *testing.T) {
 		errors.New("custom error"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err := validatorClient.liveness(ctx, 42, nil)
 
 	require.ErrorContains(t, "custom error", err)
@@ -237,7 +237,7 @@ func TestGetIsSyncing_Nominal(t *testing.T) {
 			defer ctrl.Finish()
 
 			syncingResponseJson := structs.SyncStatusResponse{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			expected := structs.SyncStatusResponse{
 				Data: &structs.SyncStatusResponseData{
@@ -247,7 +247,7 @@ func TestGetIsSyncing_Nominal(t *testing.T) {
 
 			ctx := t.Context()
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				syncingEndpoint,
 				&syncingResponseJson,
@@ -259,7 +259,7 @@ func TestGetIsSyncing_Nominal(t *testing.T) {
 			).Times(1)
 
 			validatorClient := beaconApiValidatorClient{
-				handler: handler,
+				jsonRestHandler: jsonRestHandler,
 			}
 
 			isSyncing, err := validatorClient.isSyncing(ctx)
@@ -274,11 +274,11 @@ func TestGetIsSyncing_Invalid(t *testing.T) {
 	defer ctrl.Finish()
 
 	syncingResponseJson := structs.SyncStatusResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	ctx := t.Context()
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		syncingEndpoint,
 		&syncingResponseJson,
@@ -287,7 +287,7 @@ func TestGetIsSyncing_Invalid(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		handler: handler,
+		jsonRestHandler: jsonRestHandler,
 	}
 
 	isSyncing, err := validatorClient.isSyncing(ctx)

validator/client/beacon-api/beacon_api_node_client.go

@@ -21,13 +21,13 @@ var (
 
 type beaconApiNodeClient struct {
 	fallbackClient  iface.NodeClient
-	handler         rest.Handler
+	jsonRestHandler rest.RestHandler
 	genesisProvider GenesisProvider
 }
 
 func (c *beaconApiNodeClient) SyncStatus(ctx context.Context, _ *empty.Empty) (*ethpb.SyncStatus, error) {
 	syncingResponse := structs.SyncStatusResponse{}
-	if err := c.handler.Get(ctx, "/eth/v1/node/syncing", &syncingResponse); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, "/eth/v1/node/syncing", &syncingResponse); err != nil {
 		return nil, err
 	}
 
@@ -57,7 +57,7 @@ func (c *beaconApiNodeClient) Genesis(ctx context.Context, _ *empty.Empty) (*eth
 	}
 
 	depositContractJson := structs.GetDepositContractResponse{}
-	if err = c.handler.Get(ctx, "/eth/v1/config/deposit_contract", &depositContractJson); err != nil {
+	if err = c.jsonRestHandler.Get(ctx, "/eth/v1/config/deposit_contract", &depositContractJson); err != nil {
 		return nil, err
 	}
 
@@ -81,7 +81,7 @@ func (c *beaconApiNodeClient) Genesis(ctx context.Context, _ *empty.Empty) (*eth
 
 func (c *beaconApiNodeClient) Version(ctx context.Context, _ *empty.Empty) (*ethpb.Version, error) {
 	var versionResponse structs.GetVersionResponse
-	if err := c.handler.Get(ctx, "/eth/v1/node/version", &versionResponse); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, "/eth/v1/node/version", &versionResponse); err != nil {
 		return nil, err
 	}
 
@@ -106,9 +106,9 @@ func (c *beaconApiNodeClient) Peers(ctx context.Context, in *empty.Empty) (*ethp
 // IsReady returns true only if the node is fully synced (200 OK).
 // A 206 Partial Content response indicates the node is syncing and not ready.
 func (c *beaconApiNodeClient) IsReady(ctx context.Context) bool {
-	statusCode, err := c.handler.GetStatusCode(ctx, "/eth/v1/node/health")
+	statusCode, err := c.jsonRestHandler.GetStatusCode(ctx, "/eth/v1/node/health")
 	if err != nil {
-		log.WithError(err).WithField("beaconNodeUrl", c.handler.Host()).Error("failed to get health of node")
+		log.WithError(err).Error("failed to get health of node")
 		return false
 	}
 	// Only 200 OK means the node is fully synced and ready.
@@ -116,11 +116,11 @@ func (c *beaconApiNodeClient) IsReady(ctx context.Context) bool {
 	return statusCode == http.StatusOK
 }
 
-func NewNodeClientWithFallback(handler rest.Handler, fallbackClient iface.NodeClient) iface.NodeClient {
+func NewNodeClientWithFallback(jsonRestHandler rest.RestHandler, fallbackClient iface.NodeClient) iface.NodeClient {
 	b := &beaconApiNodeClient{
-		handler:         handler,
+		jsonRestHandler: jsonRestHandler,
 		fallbackClient:  fallbackClient,
-		genesisProvider: &beaconApiGenesisProvider{handler: handler},
+		genesisProvider: &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler},
 	}
 	return b
 }

validator/client/beacon-api/beacon_api_node_client_test.go

@@ -120,10 +120,10 @@ func TestGetGenesis(t *testing.T) {
 			)
 
 			depositContractJson := structs.GetDepositContractResponse{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			if testCase.queriesDepositContract {
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					"/eth/v1/config/deposit_contract",
 					&depositContractJson,
@@ -137,7 +137,7 @@ func TestGetGenesis(t *testing.T) {
 
 			nodeClient := &beaconApiNodeClient{
 				genesisProvider: genesisProvider,
-				handler:         handler,
+				jsonRestHandler: jsonRestHandler,
 			}
 			response, err := nodeClient.Genesis(ctx, &emptypb.Empty{})
 
@@ -201,8 +201,8 @@ func TestGetSyncStatus(t *testing.T) {
 			ctx := t.Context()
 
 			syncingResponse := structs.SyncStatusResponse{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
-			handler.EXPECT().Get(
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				syncingEndpoint,
 				&syncingResponse,
@@ -213,7 +213,7 @@ func TestGetSyncStatus(t *testing.T) {
 				testCase.restEndpointResponse,
 			)
 
-			nodeClient := &beaconApiNodeClient{handler: handler}
+			nodeClient := &beaconApiNodeClient{jsonRestHandler: jsonRestHandler}
 			syncStatus, err := nodeClient.SyncStatus(ctx, &emptypb.Empty{})
 
 			if testCase.expectedResponse == nil {
@@ -265,8 +265,8 @@ func TestGetVersion(t *testing.T) {
 			ctx := t.Context()
 
 			var versionResponse structs.GetVersionResponse
-			handler := mock.NewMockJsonRestHandler(ctrl)
-			handler.EXPECT().Get(
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				versionEndpoint,
 				&versionResponse,
@@ -277,7 +277,7 @@ func TestGetVersion(t *testing.T) {
 				testCase.restEndpointResponse,
 			)
 
-			nodeClient := &beaconApiNodeClient{handler: handler}
+			nodeClient := &beaconApiNodeClient{jsonRestHandler: jsonRestHandler}
 			version, err := nodeClient.Version(ctx, &emptypb.Empty{})
 
 			if testCase.expectedResponse == nil {
@@ -331,14 +331,13 @@ func TestIsReady(t *testing.T) {
 			defer ctrl.Finish()
 			ctx := t.Context()
 
-			handler := mock.NewMockJsonRestHandler(ctrl)
-			handler.EXPECT().GetStatusCode(
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler.EXPECT().GetStatusCode(
 				gomock.Any(),
 				healthEndpoint,
 			).Return(tc.statusCode, tc.err)
-			handler.EXPECT().Host().Return("http://localhost:3500").AnyTimes()
 
-			nodeClient := &beaconApiNodeClient{handler: handler}
+			nodeClient := &beaconApiNodeClient{jsonRestHandler: jsonRestHandler}
 			result := nodeClient.IsReady(ctx)
 
 			assert.Equal(t, tc.expectedResult, result)

validator/client/beacon-api/beacon_api_validator_client.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/api/client/event"
-	"github.com/OffchainLabs/prysm/v7/api/failover"
 	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
@@ -24,28 +23,22 @@ type beaconApiValidatorClient struct {
 	genesisProvider         GenesisProvider
 	dutiesProvider          dutiesProvider
 	stateValidatorsProvider StateValidatorsProvider
-	restProvider            rest.RestConnectionProvider
-	handler                 rest.Handler
-	nodeClient              *beaconApiNodeClient
+	jsonRestHandler         rest.RestHandler
 	beaconBlockConverter    BeaconBlockConverter
 	prysmChainClient        iface.PrysmChainClient
 	isEventStreamRunning    bool
 }
 
-func NewBeaconApiValidatorClient(provider rest.RestConnectionProvider, opts ...ValidatorClientOpt) iface.ValidatorClient {
-	handler := provider.Handler()
-	nc := &beaconApiNodeClient{handler: handler}
+func NewBeaconApiValidatorClient(jsonRestHandler rest.RestHandler, opts ...ValidatorClientOpt) iface.ValidatorClient {
 	c := &beaconApiValidatorClient{
-		genesisProvider:         &beaconApiGenesisProvider{handler: handler},
-		dutiesProvider:          beaconApiDutiesProvider{handler: handler},
-		stateValidatorsProvider: beaconApiStateValidatorsProvider{handler: handler},
-		restProvider:            provider,
-		handler:                 handler,
-		nodeClient:              nc,
+		genesisProvider:         &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler},
+		dutiesProvider:          beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler},
+		stateValidatorsProvider: beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler},
+		jsonRestHandler:         jsonRestHandler,
 		beaconBlockConverter:    beaconApiBeaconBlockConverter{},
 		prysmChainClient: prysmChainClient{
-			nodeClient: nc,
-			handler:    handler,
+			nodeClient:      &beaconApiNodeClient{jsonRestHandler: jsonRestHandler},
+			jsonRestHandler: jsonRestHandler,
 		},
 		isEventStreamRunning: false,
 	}
@@ -287,8 +280,8 @@ func (c *beaconApiValidatorClient) WaitForChainStart(ctx context.Context, _ *emp
 }
 
 func (c *beaconApiValidatorClient) StartEventStream(ctx context.Context, topics []string, eventsChannel chan<- *event.Event) {
-	client := &http.Client{} // event stream should not be subject to the same settings as other api calls
-	eventStream, err := event.NewEventStream(ctx, client, c.handler.Host(), topics)
+	client := &http.Client{} // event stream should not be subject to the same settings as other api calls, so we won't use c.jsonRestHandler.HttpClient()
+	eventStream, err := event.NewEventStream(ctx, client, c.jsonRestHandler.Host(), topics)
 	if err != nil {
 		eventsChannel <- &event.Event{
 			EventType: event.EventError,
@@ -336,9 +329,9 @@ func wrapInMetrics[Resp any](action string, f func() (Resp, error)) (Resp, error
 }
 
 func (c *beaconApiValidatorClient) Host() string {
-	return c.handler.Host()
+	return c.jsonRestHandler.Host()
 }
 
-func (c *beaconApiValidatorClient) EnsureReady(ctx context.Context) bool {
-	return failover.EnsureReady(ctx, c.restProvider, c.nodeClient)
+func (c *beaconApiValidatorClient) SwitchHost(host string) {
+	c.jsonRestHandler.SwitchHost(host)
 }

validator/client/beacon-api/beacon_api_validator_client_test.go

@@ -31,9 +31,9 @@ func TestBeaconApiValidatorClient_GetAttestationDataValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 	produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v1/validator/attestation_data?committee_index=%d&slot=%d", committeeIndex, slot),
 		&produceAttestationDataResponseJson,
@@ -44,7 +44,7 @@ func TestBeaconApiValidatorClient_GetAttestationDataValid(t *testing.T) {
 		generateValidAttestation(uint64(slot), uint64(committeeIndex)),
 	).Times(2)
 
-	validatorClient := beaconApiValidatorClient{handler: handler}
+	validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	expectedResp, expectedErr := validatorClient.attestationData(ctx, slot, committeeIndex)
 
 	resp, err := validatorClient.AttestationData(
@@ -65,9 +65,9 @@ func TestBeaconApiValidatorClient_GetAttestationDataError(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 	produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v1/validator/attestation_data?committee_index=%d&slot=%d", committeeIndex, slot),
 		&produceAttestationDataResponseJson,
@@ -78,7 +78,7 @@ func TestBeaconApiValidatorClient_GetAttestationDataError(t *testing.T) {
 		generateValidAttestation(uint64(slot), uint64(committeeIndex)),
 	).Times(2)
 
-	validatorClient := beaconApiValidatorClient{handler: handler}
+	validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	expectedResp, expectedErr := validatorClient.attestationData(ctx, slot, committeeIndex)
 
 	resp, err := validatorClient.AttestationData(
@@ -139,8 +139,8 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().PostSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().PostSSZ(
 		gomock.Any(),
 		"/eth/v2/beacon/blocks",
 		gomock.Any(),
@@ -149,7 +149,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockValid(t *testing.T) {
 		nil, nil, nil,
 	).Times(1)
 
-	validatorClient := beaconApiValidatorClient{handler: handler}
+	validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	expectedResp, expectedErr := validatorClient.proposeBeaconBlock(
 		ctx,
 		&ethpb.GenericSignedBeaconBlock{
@@ -166,8 +166,8 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockError_ThenPass(t *testing.T)
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().PostSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().PostSSZ(
 		gomock.Any(),
 		"/eth/v2/beacon/blocks",
 		gomock.Any(),
@@ -179,7 +179,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockError_ThenPass(t *testing.T)
 		},
 	).Times(1)
 
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v2/beacon/blocks",
 		gomock.Any(),
@@ -189,7 +189,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockError_ThenPass(t *testing.T)
 		nil,
 	).Times(1)
 
-	validatorClient := beaconApiValidatorClient{handler: handler}
+	validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	expectedResp, expectedErr := validatorClient.proposeBeaconBlock(
 		ctx,
 		&ethpb.GenericSignedBeaconBlock{
@@ -308,10 +308,10 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockAllTypes(t *testing.T) {
 			defer ctrl.Finish()
 
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			if !tt.wantErr {
-				handler.EXPECT().PostSSZ(
+				jsonRestHandler.EXPECT().PostSSZ(
 					gomock.Any(),
 					tt.expectedPath,
 					gomock.Any(),
@@ -319,7 +319,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockAllTypes(t *testing.T) {
 				).Return(nil, nil, nil).Times(1)
 			}
 
-			validatorClient := beaconApiValidatorClient{handler: handler}
+			validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			resp, err := validatorClient.proposeBeaconBlock(ctx, tt.block)
 
 			if tt.wantErr {
@@ -366,9 +366,9 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockHTTPErrors(t *testing.T) {
 			defer ctrl.Finish()
 
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
-			handler.EXPECT().PostSSZ(
+			jsonRestHandler.EXPECT().PostSSZ(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks",
 				gomock.Any(),
@@ -377,7 +377,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockHTTPErrors(t *testing.T) {
 
 			if tt.expectJSON {
 				// When SSZ fails, it falls back to JSON
-				handler.EXPECT().Post(
+				jsonRestHandler.EXPECT().Post(
 					gomock.Any(),
 					"/eth/v2/beacon/blocks",
 					gomock.Any(),
@@ -386,7 +386,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockHTTPErrors(t *testing.T) {
 				).Return(tt.sszError).Times(1)
 			}
 
-			validatorClient := beaconApiValidatorClient{handler: handler}
+			validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			_, err := validatorClient.proposeBeaconBlock(
 				ctx,
 				&ethpb.GenericSignedBeaconBlock{
@@ -507,10 +507,10 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockJSONFallback(t *testing.T) {
 			defer ctrl.Finish()
 
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			// SSZ call fails with 406 to trigger JSON fallback
-			handler.EXPECT().PostSSZ(
+			jsonRestHandler.EXPECT().PostSSZ(
 				gomock.Any(),
 				tt.expectedPath,
 				gomock.Any(),
@@ -521,7 +521,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockJSONFallback(t *testing.T) {
 			}).Times(1)
 
 			// JSON fallback
-			handler.EXPECT().Post(
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				tt.expectedPath,
 				gomock.Any(),
@@ -529,7 +529,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockJSONFallback(t *testing.T) {
 				gomock.Any(),
 			).Return(tt.jsonError).Times(1)
 
-			validatorClient := beaconApiValidatorClient{handler: handler}
+			validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			resp, err := validatorClient.proposeBeaconBlock(ctx, tt.block)
 
 			if tt.wantErr {
@@ -547,12 +547,29 @@ func TestBeaconApiValidatorClient_Host(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Host().Return("http://localhost:8080").Times(1)
+	hosts := []string{"http://localhost:8080", "http://localhost:8081"}
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().SwitchHost(
+		hosts[0],
+	).Times(1)
+	jsonRestHandler.EXPECT().Host().Return(
+		hosts[0],
+	).Times(1)
 
-	validatorClient := beaconApiValidatorClient{handler: handler}
+	validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	validatorClient.SwitchHost(hosts[0])
 	host := validatorClient.Host()
-	require.Equal(t, "http://localhost:8080", host)
+	require.Equal(t, hosts[0], host)
+
+	jsonRestHandler.EXPECT().SwitchHost(
+		hosts[1],
+	).Times(1)
+	jsonRestHandler.EXPECT().Host().Return(
+		hosts[1],
+	).Times(1)
+	validatorClient.SwitchHost(hosts[1])
+	host = validatorClient.Host()
+	require.Equal(t, hosts[1], host)
 }
 
 // Helper functions for generating test blocks for newer consensus versions

validator/client/beacon-api/beacon_committee_selections.go

@@ -20,7 +20,7 @@ func (c *beaconApiValidatorClient) aggregatedSelection(ctx context.Context, sele
 	}
 
 	var resp aggregatedSelectionResponse
-	err = c.handler.Post(ctx, "/eth/v1/validator/beacon_committee_selections", nil, bytes.NewBuffer(body), &resp)
+	err = c.jsonRestHandler.Post(ctx, "/eth/v1/validator/beacon_committee_selections", nil, bytes.NewBuffer(body), &resp)
 	if err != nil {
 		return nil, errors.Wrap(err, "error calling post endpoint")
 	}

validator/client/beacon-api/beacon_committee_selections_test.go

@@ -89,13 +89,13 @@ func TestGetAggregatedSelections(t *testing.T) {
 	for _, test := range testcases {
 		t.Run(test.name, func(t *testing.T) {
 			ctrl := gomock.NewController(t)
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			reqBody, err := json.Marshal(test.req)
 			require.NoError(t, err)
 
 			ctx := t.Context()
-			handler.EXPECT().Post(
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				"/eth/v1/validator/beacon_committee_selections",
 				nil,
@@ -108,7 +108,7 @@ func TestGetAggregatedSelections(t *testing.T) {
 				test.endpointError,
 			).Times(1)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			res, err := validatorClient.AggregatedSelections(ctx, test.req)
 			if test.expectedErrorMessage != "" {
 				require.ErrorContains(t, test.expectedErrorMessage, err)

validator/client/beacon-api/doppelganger_test.go

@@ -288,12 +288,12 @@ func TestCheckDoppelGanger_Nominal(t *testing.T) {
 			ctrl := gomock.NewController(t)
 			defer ctrl.Finish()
 
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			if testCase.getSyncingOutput != nil {
 				syncingResponseJson := structs.SyncStatusResponse{}
 
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					syncingEndpoint,
 					&syncingResponseJson,
@@ -308,7 +308,7 @@ func TestCheckDoppelGanger_Nominal(t *testing.T) {
 			if testCase.getForkOutput != nil {
 				stateForkResponseJson := structs.GetStateForkResponse{}
 
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					forkEndpoint,
 					&stateForkResponseJson,
@@ -323,7 +323,7 @@ func TestCheckDoppelGanger_Nominal(t *testing.T) {
 			if testCase.getHeadersOutput != nil {
 				blockHeadersResponseJson := structs.GetBlockHeadersResponse{}
 
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					headersEndpoint,
 					&blockHeadersResponseJson,
@@ -342,7 +342,7 @@ func TestCheckDoppelGanger_Nominal(t *testing.T) {
 					marshalledIndexes, err := json.Marshal(iface.inputStringIndexes)
 					require.NoError(t, err)
 
-					handler.EXPECT().Post(
+					jsonRestHandler.EXPECT().Post(
 						gomock.Any(),
 						iface.inputUrl,
 						nil,
@@ -372,7 +372,7 @@ func TestCheckDoppelGanger_Nominal(t *testing.T) {
 			}
 
 			validatorClient := beaconApiValidatorClient{
-				handler:                 handler,
+				jsonRestHandler:         jsonRestHandler,
 				stateValidatorsProvider: stateValidatorsProvider,
 			}
 
@@ -722,12 +722,12 @@ func TestCheckDoppelGanger_Errors(t *testing.T) {
 			ctrl := gomock.NewController(t)
 			defer ctrl.Finish()
 
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			if testCase.getSyncingOutput != nil {
 				syncingResponseJson := structs.SyncStatusResponse{}
 
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					syncingEndpoint,
 					&syncingResponseJson,
@@ -742,7 +742,7 @@ func TestCheckDoppelGanger_Errors(t *testing.T) {
 			if testCase.getForkOutput != nil {
 				stateForkResponseJson := structs.GetStateForkResponse{}
 
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					forkEndpoint,
 					&stateForkResponseJson,
@@ -757,7 +757,7 @@ func TestCheckDoppelGanger_Errors(t *testing.T) {
 			if testCase.getHeadersOutput != nil {
 				blockHeadersResponseJson := structs.GetBlockHeadersResponse{}
 
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					headersEndpoint,
 					&blockHeadersResponseJson,
@@ -790,7 +790,7 @@ func TestCheckDoppelGanger_Errors(t *testing.T) {
 					marshalledIndexes, err := json.Marshal(iface.inputStringIndexes)
 					require.NoError(t, err)
 
-					handler.EXPECT().Post(
+					jsonRestHandler.EXPECT().Post(
 						gomock.Any(),
 						iface.inputUrl,
 						nil,
@@ -806,7 +806,7 @@ func TestCheckDoppelGanger_Errors(t *testing.T) {
 			}
 
 			validatorClient := beaconApiValidatorClient{
-				handler:                 handler,
+				jsonRestHandler:         jsonRestHandler,
 				stateValidatorsProvider: stateValidatorsProvider,
 			}
 

validator/client/beacon-api/duties.go

@@ -28,7 +28,7 @@ type dutiesProvider interface {
 }
 
 type beaconApiDutiesProvider struct {
-	handler rest.Handler
+	jsonRestHandler rest.RestHandler
 }
 
 type attesterDuty struct {
@@ -279,7 +279,7 @@ func (c beaconApiDutiesProvider) Committees(ctx context.Context, epoch primitive
 	committeesRequest := apiutil.BuildURL("/eth/v1/beacon/states/head/committees", committeeParams)
 
 	var stateCommittees structs.GetCommitteesResponse
-	if err := c.handler.Get(ctx, committeesRequest, &stateCommittees); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, committeesRequest, &stateCommittees); err != nil {
 		return nil, err
 	}
 
@@ -309,7 +309,7 @@ func (c beaconApiDutiesProvider) AttesterDuties(ctx context.Context, epoch primi
 	}
 
 	attesterDuties := &structs.GetAttesterDutiesResponse{}
-	if err = c.handler.Post(
+	if err = c.jsonRestHandler.Post(
 		ctx,
 		fmt.Sprintf("/eth/v1/validator/duties/attester/%d", epoch),
 		nil,
@@ -331,7 +331,7 @@ func (c beaconApiDutiesProvider) AttesterDuties(ctx context.Context, epoch primi
 // ProposerDuties retrieves the proposer duties for the given epoch
 func (c beaconApiDutiesProvider) ProposerDuties(ctx context.Context, epoch primitives.Epoch) (*structs.GetProposerDutiesResponse, error) {
 	proposerDuties := &structs.GetProposerDutiesResponse{}
-	if err := c.handler.Get(ctx, fmt.Sprintf("/eth/v1/validator/duties/proposer/%d", epoch), proposerDuties); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, fmt.Sprintf("/eth/v1/validator/duties/proposer/%d", epoch), proposerDuties); err != nil {
 		return nil, err
 	}
 
@@ -361,7 +361,7 @@ func (c beaconApiDutiesProvider) SyncDuties(ctx context.Context, epoch primitive
 	}
 
 	syncDuties := structs.GetSyncCommitteeDutiesResponse{}
-	if err = c.handler.Post(
+	if err = c.jsonRestHandler.Post(
 		ctx,
 		fmt.Sprintf("/eth/v1/validator/duties/sync/%d", epoch),
 		nil,

validator/client/beacon-api/duties_test.go

@@ -60,8 +60,8 @@ func TestGetAttesterDuties_Valid(t *testing.T) {
 	ctx := t.Context()
 
 	validatorIndices := []primitives.ValidatorIndex{2, 9}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getAttesterDutiesTestEndpoint, epoch),
 		nil,
@@ -74,7 +74,7 @@ func TestGetAttesterDuties_Valid(t *testing.T) {
 		expectedAttesterDuties,
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	attesterDuties, err := dutiesProvider.AttesterDuties(ctx, epoch, validatorIndices)
 	require.NoError(t, err)
 	assert.DeepEqual(t, expectedAttesterDuties.Data, attesterDuties.Data)
@@ -88,8 +88,8 @@ func TestGetAttesterDuties_HttpError(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getAttesterDutiesTestEndpoint, epoch),
 		gomock.Any(),
@@ -99,7 +99,7 @@ func TestGetAttesterDuties_HttpError(t *testing.T) {
 		errors.New("foo error"),
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.AttesterDuties(ctx, epoch, nil)
 	assert.ErrorContains(t, "foo error", err)
 }
@@ -112,8 +112,8 @@ func TestGetAttesterDuties_NilAttesterDuty(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getAttesterDutiesTestEndpoint, epoch),
 		gomock.Any(),
@@ -128,7 +128,7 @@ func TestGetAttesterDuties_NilAttesterDuty(t *testing.T) {
 		},
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.AttesterDuties(ctx, epoch, nil)
 	assert.ErrorContains(t, "attester duty at index `0` is nil", err)
 }
@@ -156,8 +156,8 @@ func TestGetProposerDuties_Valid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getProposerDutiesTestEndpoint, epoch),
 		&structs.GetProposerDutiesResponse{},
@@ -168,7 +168,7 @@ func TestGetProposerDuties_Valid(t *testing.T) {
 		expectedProposerDuties,
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	proposerDuties, err := dutiesProvider.ProposerDuties(ctx, epoch)
 	require.NoError(t, err)
 	assert.DeepEqual(t, expectedProposerDuties.Data, proposerDuties.Data)
@@ -182,8 +182,8 @@ func TestGetProposerDuties_HttpError(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getProposerDutiesTestEndpoint, epoch),
 		gomock.Any(),
@@ -191,7 +191,7 @@ func TestGetProposerDuties_HttpError(t *testing.T) {
 		errors.New("foo error"),
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.ProposerDuties(ctx, epoch)
 	assert.ErrorContains(t, "foo error", err)
 }
@@ -204,8 +204,8 @@ func TestGetProposerDuties_NilData(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getProposerDutiesTestEndpoint, epoch),
 		gomock.Any(),
@@ -218,7 +218,7 @@ func TestGetProposerDuties_NilData(t *testing.T) {
 		},
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.ProposerDuties(ctx, epoch)
 	assert.ErrorContains(t, "proposer duties data is nil", err)
 }
@@ -231,8 +231,8 @@ func TestGetProposerDuties_NilProposerDuty(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getProposerDutiesTestEndpoint, epoch),
 		gomock.Any(),
@@ -245,7 +245,7 @@ func TestGetProposerDuties_NilProposerDuty(t *testing.T) {
 		},
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.ProposerDuties(ctx, epoch)
 	assert.ErrorContains(t, "proposer duty at index `0` is nil", err)
 }
@@ -284,8 +284,8 @@ func TestGetSyncDuties_Valid(t *testing.T) {
 	ctx := t.Context()
 
 	validatorIndices := []primitives.ValidatorIndex{2, 6}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getSyncDutiesTestEndpoint, epoch),
 		nil,
@@ -298,7 +298,7 @@ func TestGetSyncDuties_Valid(t *testing.T) {
 		expectedSyncDuties,
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	syncDuties, err := dutiesProvider.SyncDuties(ctx, epoch, validatorIndices)
 	require.NoError(t, err)
 	assert.DeepEqual(t, expectedSyncDuties.Data, syncDuties)
@@ -312,8 +312,8 @@ func TestGetSyncDuties_HttpError(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getSyncDutiesTestEndpoint, epoch),
 		gomock.Any(),
@@ -323,7 +323,7 @@ func TestGetSyncDuties_HttpError(t *testing.T) {
 		errors.New("foo error"),
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.SyncDuties(ctx, epoch, nil)
 	assert.ErrorContains(t, "foo error", err)
 }
@@ -336,8 +336,8 @@ func TestGetSyncDuties_NilData(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getSyncDutiesTestEndpoint, epoch),
 		gomock.Any(),
@@ -352,7 +352,7 @@ func TestGetSyncDuties_NilData(t *testing.T) {
 		},
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.SyncDuties(ctx, epoch, nil)
 	assert.ErrorContains(t, "sync duties data is nil", err)
 }
@@ -365,8 +365,8 @@ func TestGetSyncDuties_NilSyncDuty(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		fmt.Sprintf("%s/%d", getSyncDutiesTestEndpoint, epoch),
 		gomock.Any(),
@@ -381,7 +381,7 @@ func TestGetSyncDuties_NilSyncDuty(t *testing.T) {
 		},
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.SyncDuties(ctx, epoch, nil)
 	assert.ErrorContains(t, "sync duty at index `0` is nil", err)
 }
@@ -415,8 +415,8 @@ func TestGetCommittees_Valid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("%s?epoch=%d", getCommitteesTestEndpoint, epoch),
 		&structs.GetCommitteesResponse{},
@@ -427,7 +427,7 @@ func TestGetCommittees_Valid(t *testing.T) {
 		expectedCommittees,
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	committees, err := dutiesProvider.Committees(ctx, epoch)
 	require.NoError(t, err)
 	assert.DeepEqual(t, expectedCommittees.Data, committees)
@@ -441,8 +441,8 @@ func TestGetCommittees_HttpError(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("%s?epoch=%d", getCommitteesTestEndpoint, epoch),
 		gomock.Any(),
@@ -450,7 +450,7 @@ func TestGetCommittees_HttpError(t *testing.T) {
 		errors.New("foo error"),
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.Committees(ctx, epoch)
 	assert.ErrorContains(t, "foo error", err)
 }
@@ -463,8 +463,8 @@ func TestGetCommittees_NilData(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("%s?epoch=%d", getCommitteesTestEndpoint, epoch),
 		gomock.Any(),
@@ -477,7 +477,7 @@ func TestGetCommittees_NilData(t *testing.T) {
 		},
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.Committees(ctx, epoch)
 	assert.ErrorContains(t, "state committees data is nil", err)
 }
@@ -490,8 +490,8 @@ func TestGetCommittees_NilCommittee(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		fmt.Sprintf("%s?epoch=%d", getCommitteesTestEndpoint, epoch),
 		gomock.Any(),
@@ -504,7 +504,7 @@ func TestGetCommittees_NilCommittee(t *testing.T) {
 		},
 	).Times(1)
 
-	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
+	dutiesProvider := &beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler}
 	_, err := dutiesProvider.Committees(ctx, epoch)
 	assert.ErrorContains(t, "committee at index `0` is nil", err)
 }

validator/client/beacon-api/genesis.go

@@ -21,9 +21,9 @@ type GenesisProvider interface {
 }
 
 type beaconApiGenesisProvider struct {
-	handler rest.Handler
-	genesis *structs.Genesis
-	once    sync.Once
+	jsonRestHandler rest.RestHandler
+	genesis         *structs.Genesis
+	once            sync.Once
 }
 
 func (c *beaconApiValidatorClient) waitForChainStart(ctx context.Context) (*ethpb.ChainStartResponse, error) {
@@ -69,7 +69,7 @@ func (c *beaconApiGenesisProvider) Genesis(ctx context.Context) (*structs.Genesi
 	genesisJson := &structs.GetGenesisResponse{}
 	var doErr error
 	c.once.Do(func() {
-		if err := c.handler.Get(ctx, "/eth/v1/beacon/genesis", genesisJson); err != nil {
+		if err := c.jsonRestHandler.Get(ctx, "/eth/v1/beacon/genesis", genesisJson); err != nil {
 			doErr = err
 			return
 		}

validator/client/beacon-api/genesis_test.go

@@ -18,8 +18,8 @@ func TestGetGenesis_ValidGenesis(t *testing.T) {
 	ctx := t.Context()
 
 	genesisResponseJson := structs.GetGenesisResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -35,7 +35,7 @@ func TestGetGenesis_ValidGenesis(t *testing.T) {
 		},
 	).Times(1)
 
-	genesisProvider := &beaconApiGenesisProvider{handler: handler}
+	genesisProvider := &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
 	resp, err := genesisProvider.Genesis(ctx)
 	assert.NoError(t, err)
 	require.NotNil(t, resp)
@@ -50,8 +50,8 @@ func TestGetGenesis_NilData(t *testing.T) {
 	ctx := t.Context()
 
 	genesisResponseJson := structs.GetGenesisResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -62,7 +62,7 @@ func TestGetGenesis_NilData(t *testing.T) {
 		structs.GetGenesisResponse{Data: nil},
 	).Times(1)
 
-	genesisProvider := &beaconApiGenesisProvider{handler: handler}
+	genesisProvider := &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
 	_, err := genesisProvider.Genesis(ctx)
 	assert.ErrorContains(t, "genesis data is nil", err)
 }
@@ -74,8 +74,8 @@ func TestGetGenesis_EndpointCalledOnlyOnce(t *testing.T) {
 	ctx := t.Context()
 
 	genesisResponseJson := structs.GetGenesisResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -91,7 +91,7 @@ func TestGetGenesis_EndpointCalledOnlyOnce(t *testing.T) {
 		},
 	).Times(1)
 
-	genesisProvider := &beaconApiGenesisProvider{handler: handler}
+	genesisProvider := &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
 	_, err := genesisProvider.Genesis(ctx)
 	assert.NoError(t, err)
 	resp, err := genesisProvider.Genesis(ctx)
@@ -108,15 +108,15 @@ func TestGetGenesis_EndpointCanBeCalledAgainAfterError(t *testing.T) {
 	ctx := t.Context()
 
 	genesisResponseJson := structs.GetGenesisResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
 	).Return(
 		errors.New("foo"),
 	).Times(1)
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -132,7 +132,7 @@ func TestGetGenesis_EndpointCanBeCalledAgainAfterError(t *testing.T) {
 		},
 	).Times(1)
 
-	genesisProvider := &beaconApiGenesisProvider{handler: handler}
+	genesisProvider := &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
 	_, err := genesisProvider.Genesis(ctx)
 	require.ErrorContains(t, "foo", err)
 	resp, err := genesisProvider.Genesis(ctx)

validator/client/beacon-api/get_beacon_block.go

@@ -26,7 +26,7 @@ func (c *beaconApiValidatorClient) beaconBlock(ctx context.Context, slot primiti
 		queryParams.Add("graffiti", hexutil.Encode(graffiti))
 	}
 	queryUrl := apiutil.BuildURL(fmt.Sprintf("/eth/v3/validator/blocks/%d", slot), queryParams)
-	data, header, err := c.handler.GetSSZ(ctx, queryUrl)
+	data, header, err := c.jsonRestHandler.GetSSZ(ctx, queryUrl)
 	if err != nil {
 		return nil, err
 	}

validator/client/beacon-api/get_beacon_block_test.go

@@ -25,8 +25,8 @@ func TestGetBeaconBlock_RequestFailed(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		gomock.Any(),
 	).Return(
@@ -35,7 +35,7 @@ func TestGetBeaconBlock_RequestFailed(t *testing.T) {
 		errors.New("foo error"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err := validatorClient.beaconBlock(ctx, 1, []byte{1}, []byte{2})
 	assert.ErrorContains(t, "foo error", err)
 }
@@ -149,8 +149,8 @@ func TestGetBeaconBlock_Error(t *testing.T) {
 
 			b, err := json.Marshal(resp)
 			require.NoError(t, err)
-			handler := mock.NewMockJsonRestHandler(ctrl)
-			handler.EXPECT().GetSSZ(
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler.EXPECT().GetSSZ(
 				gomock.Any(),
 				gomock.Any(),
 			).Return(
@@ -159,7 +159,7 @@ func TestGetBeaconBlock_Error(t *testing.T) {
 				nil,
 			).Times(1)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			_, err = validatorClient.beaconBlock(ctx, 1, []byte{1}, []byte{2})
 			assert.ErrorContains(t, testCase.expectedErrorMessage, err)
 		})
@@ -185,8 +185,8 @@ func TestGetBeaconBlock_Phase0Valid(t *testing.T) {
 		Data:    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -195,7 +195,7 @@ func TestGetBeaconBlock_Phase0Valid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -224,8 +224,8 @@ func TestGetBeaconBlock_SSZ_BellatrixValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -238,7 +238,7 @@ func TestGetBeaconBlock_SSZ_BellatrixValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -266,8 +266,8 @@ func TestGetBeaconBlock_SSZ_BlindedBellatrixValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -280,7 +280,7 @@ func TestGetBeaconBlock_SSZ_BlindedBellatrixValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -308,8 +308,8 @@ func TestGetBeaconBlock_SSZ_CapellaValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -322,7 +322,7 @@ func TestGetBeaconBlock_SSZ_CapellaValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -350,8 +350,8 @@ func TestGetBeaconBlock_SSZ_BlindedCapellaValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -364,7 +364,7 @@ func TestGetBeaconBlock_SSZ_BlindedCapellaValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -392,8 +392,8 @@ func TestGetBeaconBlock_SSZ_DenebValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -406,7 +406,7 @@ func TestGetBeaconBlock_SSZ_DenebValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -434,8 +434,8 @@ func TestGetBeaconBlock_SSZ_BlindedDenebValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -448,7 +448,7 @@ func TestGetBeaconBlock_SSZ_BlindedDenebValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -476,8 +476,8 @@ func TestGetBeaconBlock_SSZ_ElectraValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -490,7 +490,7 @@ func TestGetBeaconBlock_SSZ_ElectraValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -518,8 +518,8 @@ func TestGetBeaconBlock_SSZ_BlindedElectraValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -532,7 +532,7 @@ func TestGetBeaconBlock_SSZ_BlindedElectraValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -556,8 +556,8 @@ func TestGetBeaconBlock_SSZ_UnsupportedVersion(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -570,7 +570,7 @@ func TestGetBeaconBlock_SSZ_UnsupportedVersion(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	assert.ErrorContains(t, "version name doesn't map to a known value in the enum", err)
 }
@@ -589,8 +589,8 @@ func TestGetBeaconBlock_SSZ_InvalidBlindedHeader(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -603,7 +603,7 @@ func TestGetBeaconBlock_SSZ_InvalidBlindedHeader(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err = validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	assert.ErrorContains(t, "strconv.ParseBool: parsing \"invalid\": invalid syntax", err)
 }
@@ -622,8 +622,8 @@ func TestGetBeaconBlock_SSZ_InvalidVersionHeader(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -636,7 +636,7 @@ func TestGetBeaconBlock_SSZ_InvalidVersionHeader(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err = validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	assert.ErrorContains(t, "unsupported header version invalid", err)
 }
@@ -651,8 +651,8 @@ func TestGetBeaconBlock_SSZ_GetSSZError(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -661,7 +661,7 @@ func TestGetBeaconBlock_SSZ_GetSSZError(t *testing.T) {
 		errors.New("get ssz error"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	assert.ErrorContains(t, "get ssz error", err)
 }
@@ -680,8 +680,8 @@ func TestGetBeaconBlock_SSZ_Phase0Valid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -694,7 +694,7 @@ func TestGetBeaconBlock_SSZ_Phase0Valid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -722,8 +722,8 @@ func TestGetBeaconBlock_SSZ_AltairValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -736,7 +736,7 @@ func TestGetBeaconBlock_SSZ_AltairValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -770,8 +770,8 @@ func TestGetBeaconBlock_AltairValid(t *testing.T) {
 		Data:    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -780,7 +780,7 @@ func TestGetBeaconBlock_AltairValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -814,8 +814,8 @@ func TestGetBeaconBlock_BellatrixValid(t *testing.T) {
 		Data:                    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -824,7 +824,7 @@ func TestGetBeaconBlock_BellatrixValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -859,8 +859,8 @@ func TestGetBeaconBlock_BlindedBellatrixValid(t *testing.T) {
 		Data:                    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -869,7 +869,7 @@ func TestGetBeaconBlock_BlindedBellatrixValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -904,8 +904,8 @@ func TestGetBeaconBlock_CapellaValid(t *testing.T) {
 		Data:                    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -914,7 +914,7 @@ func TestGetBeaconBlock_CapellaValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -949,8 +949,8 @@ func TestGetBeaconBlock_BlindedCapellaValid(t *testing.T) {
 		Data:                    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -959,7 +959,7 @@ func TestGetBeaconBlock_BlindedCapellaValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -994,8 +994,8 @@ func TestGetBeaconBlock_DenebValid(t *testing.T) {
 		Data:                    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -1004,7 +1004,7 @@ func TestGetBeaconBlock_DenebValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -1039,8 +1039,8 @@ func TestGetBeaconBlock_BlindedDenebValid(t *testing.T) {
 		Data:                    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -1049,7 +1049,7 @@ func TestGetBeaconBlock_BlindedDenebValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -1084,8 +1084,8 @@ func TestGetBeaconBlock_ElectraValid(t *testing.T) {
 		Data:                    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -1094,7 +1094,7 @@ func TestGetBeaconBlock_ElectraValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 
@@ -1129,8 +1129,8 @@ func TestGetBeaconBlock_BlindedElectraValid(t *testing.T) {
 		Data:                    bytes,
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().GetSSZ(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().GetSSZ(
 		gomock.Any(),
 		fmt.Sprintf("/eth/v3/validator/blocks/%d?graffiti=%s&randao_reveal=%s", slot, hexutil.Encode(graffiti), hexutil.Encode(randaoReveal)),
 	).Return(
@@ -1139,7 +1139,7 @@ func TestGetBeaconBlock_BlindedElectraValid(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	beaconBlock, err := validatorClient.beaconBlock(ctx, slot, randaoReveal, graffiti)
 	require.NoError(t, err)
 

validator/client/beacon-api/index_test.go

@@ -41,9 +41,9 @@ func TestIndex_Nominal(t *testing.T) {
 	ctx := t.Context()
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validators",
 		nil,
@@ -68,7 +68,7 @@ func TestIndex_Nominal(t *testing.T) {
 
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: beaconApiStateValidatorsProvider{
-			handler: handler,
+			jsonRestHandler: jsonRestHandler,
 		},
 	}
 
@@ -91,9 +91,9 @@ func TestIndex_UnexistingValidator(t *testing.T) {
 	ctx := t.Context()
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validators",
 		nil,
@@ -110,7 +110,7 @@ func TestIndex_UnexistingValidator(t *testing.T) {
 
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: beaconApiStateValidatorsProvider{
-			handler: handler,
+			jsonRestHandler: jsonRestHandler,
 		},
 	}
 
@@ -133,9 +133,9 @@ func TestIndex_BadIndexError(t *testing.T) {
 	ctx := t.Context()
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validators",
 		nil,
@@ -160,7 +160,7 @@ func TestIndex_BadIndexError(t *testing.T) {
 
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: beaconApiStateValidatorsProvider{
-			handler: handler,
+			jsonRestHandler: jsonRestHandler,
 		},
 	}
 
@@ -182,9 +182,9 @@ func TestIndex_JsonResponseError(t *testing.T) {
 	ctx := t.Context()
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validators",
 		nil,
@@ -207,7 +207,7 @@ func TestIndex_JsonResponseError(t *testing.T) {
 		queryParams.Add("status", st)
 	}
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		apiutil.BuildURL("/eth/v1/beacon/states/head/validators", queryParams),
 		&stateValidatorsResponseJson,
@@ -217,7 +217,7 @@ func TestIndex_JsonResponseError(t *testing.T) {
 
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: beaconApiStateValidatorsProvider{
-			handler: handler,
+			jsonRestHandler: jsonRestHandler,
 		},
 	}
 

validator/client/beacon-api/mock/json_rest_handler_mock.go

@@ -1,9 +1,9 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: api/rest/rest_handler.go
+// Source: validator/client/beacon-api/rest_handler_client.go
 //
 // Generated by this command:
 //
-//	mockgen -package=mock -source=api/rest/rest_handler.go -destination=validator/client/beacon-api/mock/json_rest_handler_mock.go Handler
+//	mockgen -package=mock -source=validator/client/beacon-api/rest_handler_client.go -destination=validator/client/beacon-api/mock/json_rest_handler_mock.go RestHandler
 //
 
 // Package mock is a generated GoMock package.
@@ -19,39 +19,36 @@ import (
 )
 
 // Backward compatibility aliases for the renamed mock type.
-type MockJsonRestHandler = MockHandler
-type MockJsonRestHandlerMockRecorder = MockHandlerMockRecorder
-type MockRestHandler = MockHandler
-type MockRestHandlerMockRecorder = MockHandlerMockRecorder
+type MockJsonRestHandler = MockRestHandler
+type MockJsonRestHandlerMockRecorder = MockRestHandlerMockRecorder
 
-var NewMockJsonRestHandler = NewMockHandler
-var NewMockRestHandler = NewMockHandler
+var NewMockJsonRestHandler = NewMockRestHandler
 
-// MockHandler is a mock of Handler interface.
-type MockHandler struct {
+// MockRestHandler is a mock of RestHandler interface.
+type MockRestHandler struct {
 	ctrl     *gomock.Controller
-	recorder *MockHandlerMockRecorder
+	recorder *MockRestHandlerMockRecorder
 }
 
-// MockHandlerMockRecorder is the mock recorder for MockHandler.
-type MockHandlerMockRecorder struct {
-	mock *MockHandler
+// MockRestHandlerMockRecorder is the mock recorder for MockRestHandler.
+type MockRestHandlerMockRecorder struct {
+	mock *MockRestHandler
 }
 
-// NewMockHandler creates a new mock instance.
-func NewMockHandler(ctrl *gomock.Controller) *MockHandler {
-	mock := &MockHandler{ctrl: ctrl}
-	mock.recorder = &MockHandlerMockRecorder{mock}
+// NewMockRestHandler creates a new mock instance.
+func NewMockRestHandler(ctrl *gomock.Controller) *MockRestHandler {
+	mock := &MockRestHandler{ctrl: ctrl}
+	mock.recorder = &MockRestHandlerMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockHandler) EXPECT() *MockHandlerMockRecorder {
+func (m *MockRestHandler) EXPECT() *MockRestHandlerMockRecorder {
 	return m.recorder
 }
 
 // Get mocks base method.
-func (m *MockHandler) Get(ctx context.Context, endpoint string, resp any) error {
+func (m *MockRestHandler) Get(ctx context.Context, endpoint string, resp any) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get", ctx, endpoint, resp)
 	ret0, _ := ret[0].(error)
@@ -59,13 +56,13 @@ func (m *MockHandler) Get(ctx context.Context, endpoint string, resp any) error
 }
 
 // Get indicates an expected call of Get.
-func (mr *MockHandlerMockRecorder) Get(ctx, endpoint, resp any) *gomock.Call {
+func (mr *MockRestHandlerMockRecorder) Get(ctx, endpoint, resp any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockHandler)(nil).Get), ctx, endpoint, resp)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRestHandler)(nil).Get), ctx, endpoint, resp)
 }
 
 // GetSSZ mocks base method.
-func (m *MockHandler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
+func (m *MockRestHandler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSSZ", ctx, endpoint)
 	ret0, _ := ret[0].([]byte)
@@ -75,13 +72,13 @@ func (m *MockHandler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http
 }
 
 // GetSSZ indicates an expected call of GetSSZ.
-func (mr *MockHandlerMockRecorder) GetSSZ(ctx, endpoint any) *gomock.Call {
+func (mr *MockRestHandlerMockRecorder) GetSSZ(ctx, endpoint any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSSZ", reflect.TypeOf((*MockHandler)(nil).GetSSZ), ctx, endpoint)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSSZ", reflect.TypeOf((*MockRestHandler)(nil).GetSSZ), ctx, endpoint)
 }
 
 // GetStatusCode mocks base method.
-func (m *MockHandler) GetStatusCode(ctx context.Context, endpoint string) (int, error) {
+func (m *MockRestHandler) GetStatusCode(ctx context.Context, endpoint string) (int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetStatusCode", ctx, endpoint)
 	ret0, _ := ret[0].(int)
@@ -90,13 +87,13 @@ func (m *MockHandler) GetStatusCode(ctx context.Context, endpoint string) (int,
 }
 
 // GetStatusCode indicates an expected call of GetStatusCode.
-func (mr *MockHandlerMockRecorder) GetStatusCode(ctx, endpoint any) *gomock.Call {
+func (mr *MockRestHandlerMockRecorder) GetStatusCode(ctx, endpoint any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatusCode", reflect.TypeOf((*MockHandler)(nil).GetStatusCode), ctx, endpoint)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatusCode", reflect.TypeOf((*MockRestHandler)(nil).GetStatusCode), ctx, endpoint)
 }
 
 // Host mocks base method.
-func (m *MockHandler) Host() string {
+func (m *MockRestHandler) Host() string {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Host")
 	ret0, _ := ret[0].(string)
@@ -104,13 +101,27 @@ func (m *MockHandler) Host() string {
 }
 
 // Host indicates an expected call of Host.
-func (mr *MockHandlerMockRecorder) Host() *gomock.Call {
+func (mr *MockRestHandlerMockRecorder) Host() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Host", reflect.TypeOf((*MockHandler)(nil).Host))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Host", reflect.TypeOf((*MockRestHandler)(nil).Host))
+}
+
+// HttpClient mocks base method.
+func (m *MockRestHandler) HttpClient() *http.Client {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HttpClient")
+	ret0, _ := ret[0].(*http.Client)
+	return ret0
+}
+
+// HttpClient indicates an expected call of HttpClient.
+func (mr *MockRestHandlerMockRecorder) HttpClient() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HttpClient", reflect.TypeOf((*MockRestHandler)(nil).HttpClient))
 }
 
 // Post mocks base method.
-func (m *MockHandler) Post(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer, resp any) error {
+func (m *MockRestHandler) Post(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer, resp any) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Post", ctx, endpoint, headers, data, resp)
 	ret0, _ := ret[0].(error)
@@ -118,13 +129,13 @@ func (m *MockHandler) Post(ctx context.Context, endpoint string, headers map[str
 }
 
 // Post indicates an expected call of Post.
-func (mr *MockHandlerMockRecorder) Post(ctx, endpoint, headers, data, resp any) *gomock.Call {
+func (mr *MockRestHandlerMockRecorder) Post(ctx, endpoint, headers, data, resp any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockHandler)(nil).Post), ctx, endpoint, headers, data, resp)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockRestHandler)(nil).Post), ctx, endpoint, headers, data, resp)
 }
 
 // PostSSZ mocks base method.
-func (m *MockHandler) PostSSZ(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer) ([]byte, http.Header, error) {
+func (m *MockRestHandler) PostSSZ(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer) ([]byte, http.Header, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PostSSZ", ctx, endpoint, headers, data)
 	ret0, _ := ret[0].([]byte)
@@ -134,7 +145,19 @@ func (m *MockHandler) PostSSZ(ctx context.Context, endpoint string, headers map[
 }
 
 // PostSSZ indicates an expected call of PostSSZ.
-func (mr *MockHandlerMockRecorder) PostSSZ(ctx, endpoint, headers, data any) *gomock.Call {
+func (mr *MockRestHandlerMockRecorder) PostSSZ(ctx, endpoint, headers, data any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSSZ", reflect.TypeOf((*MockHandler)(nil).PostSSZ), ctx, endpoint, headers, data)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSSZ", reflect.TypeOf((*MockRestHandler)(nil).PostSSZ), ctx, endpoint, headers, data)
+}
+
+// SwitchHost mocks base method.
+func (m *MockRestHandler) SwitchHost(host string) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "SwitchHost", host)
+}
+
+// SwitchHost indicates an expected call of SwitchHost.
+func (mr *MockRestHandlerMockRecorder) SwitchHost(host any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwitchHost", reflect.TypeOf((*MockRestHandler)(nil).SwitchHost), host)
 }

validator/client/beacon-api/prepare_beacon_proposer.go

@@ -26,5 +26,5 @@ func (c *beaconApiValidatorClient) prepareBeaconProposer(ctx context.Context, re
 		return errors.Wrap(err, "failed to marshal recipients")
 	}
 
-	return c.handler.Post(ctx, "/eth/v1/validator/prepare_beacon_proposer", nil, bytes.NewBuffer(marshalledJsonRecipients), nil)
+	return c.jsonRestHandler.Post(ctx, "/eth/v1/validator/prepare_beacon_proposer", nil, bytes.NewBuffer(marshalledJsonRecipients), nil)
 }

validator/client/beacon-api/prepare_beacon_proposer_test.go

@@ -45,8 +45,8 @@ func TestPrepareBeaconProposer_Valid(t *testing.T) {
 	marshalledJsonRecipients, err := json.Marshal(jsonRecipients)
 	require.NoError(t, err)
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		prepareBeaconProposerTestEndpoint,
 		nil,
@@ -78,7 +78,7 @@ func TestPrepareBeaconProposer_Valid(t *testing.T) {
 		},
 	}
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	err = validatorClient.prepareBeaconProposer(ctx, protoRecipients)
 	require.NoError(t, err)
 }
@@ -89,8 +89,8 @@ func TestPrepareBeaconProposer_BadRequest(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		prepareBeaconProposerTestEndpoint,
 		nil,
@@ -100,7 +100,7 @@ func TestPrepareBeaconProposer_BadRequest(t *testing.T) {
 		errors.New("foo error"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	err := validatorClient.prepareBeaconProposer(ctx, nil)
 	assert.ErrorContains(t, "foo error", err)
 }

validator/client/beacon-api/propose_attestation.go

@@ -22,7 +22,7 @@ func (c *beaconApiValidatorClient) proposeAttestation(ctx context.Context, attes
 	}
 
 	headers := map[string]string{"Eth-Consensus-Version": version.String(attestation.Version())}
-	err = c.handler.Post(
+	err = c.jsonRestHandler.Post(
 		ctx,
 		"/eth/v2/beacon/pool/attestations",
 		headers,
@@ -51,7 +51,7 @@ func (c *beaconApiValidatorClient) proposeAttestationElectra(ctx context.Context
 	}
 	consensusVersion := version.String(slots.ToForkVersion(attestation.Data.Slot))
 	headers := map[string]string{"Eth-Consensus-Version": consensusVersion}
-	if err = c.handler.Post(
+	if err = c.jsonRestHandler.Post(
 		ctx,
 		"/eth/v2/beacon/pool/attestations",
 		headers,

validator/client/beacon-api/propose_attestation_test.go

@@ -107,7 +107,7 @@ func TestProposeAttestation(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ctrl := gomock.NewController(t)
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			var marshalledAttestations []byte
 			if helpers.ValidateNilAttestation(test.attestation) == nil {
@@ -119,7 +119,7 @@ func TestProposeAttestation(t *testing.T) {
 			ctx := t.Context()
 
 			headers := map[string]string{"Eth-Consensus-Version": version.String(test.attestation.Version())}
-			handler.EXPECT().Post(
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				"/eth/v2/beacon/pool/attestations",
 				headers,
@@ -129,7 +129,7 @@ func TestProposeAttestation(t *testing.T) {
 				test.endpointError,
 			).Times(test.endpointCall)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			proposeResponse, err := validatorClient.proposeAttestation(ctx, test.attestation)
 			if test.expectedErrorMessage != "" {
 				require.ErrorContains(t, test.expectedErrorMessage, err)
@@ -254,7 +254,7 @@ func TestProposeAttestationElectra(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ctrl := gomock.NewController(t)
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			var marshalledAttestations []byte
 			if helpers.ValidateNilAttestation(test.attestation) == nil {
@@ -268,7 +268,7 @@ func TestProposeAttestationElectra(t *testing.T) {
 			if test.expectedConsensusVersion != "" {
 				headerMatcher = gomock.Eq(map[string]string{"Eth-Consensus-Version": test.expectedConsensusVersion})
 			}
-			handler.EXPECT().Post(
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				"/eth/v2/beacon/pool/attestations",
 				headerMatcher,
@@ -278,7 +278,7 @@ func TestProposeAttestationElectra(t *testing.T) {
 				test.endpointError,
 			).Times(test.endpointCall)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			proposeResponse, err := validatorClient.proposeAttestationElectra(ctx, test.attestation)
 			if test.expectedErrorMessage != "" {
 				require.ErrorContains(t, test.expectedErrorMessage, err)

validator/client/beacon-api/propose_beacon_block.go

@@ -67,7 +67,7 @@ func (c *beaconApiValidatorClient) proposeBeaconBlock(ctx context.Context, in *e
 
 	// Try PostSSZ first with SSZ data
 	if res.marshalledSSZ != nil {
-		_, _, err = c.handler.PostSSZ(ctx, endpoint, headers, bytes.NewBuffer(res.marshalledSSZ))
+		_, _, err = c.jsonRestHandler.PostSSZ(ctx, endpoint, headers, bytes.NewBuffer(res.marshalledSSZ))
 		if err != nil {
 			errJson := &httputil.DefaultJsonError{}
 			// If PostSSZ fails with 406 (Not Acceptable), fall back to JSON
@@ -81,7 +81,7 @@ func (c *beaconApiValidatorClient) proposeBeaconBlock(ctx context.Context, in *e
 					return nil, errors.Wrap(jsonErr, "failed to marshal JSON")
 				}
 				// Reset headers for JSON
-				err = c.handler.Post(ctx, endpoint, headers, bytes.NewBuffer(jsonData), nil)
+				err = c.jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(jsonData), nil)
 				// If JSON also fails, return that error
 				if err != nil {
 					return nil, errors.Wrap(err, "failed to submit block via JSON fallback")
@@ -100,7 +100,7 @@ func (c *beaconApiValidatorClient) proposeBeaconBlock(ctx context.Context, in *e
 			return nil, errors.Wrap(jsonErr, "failed to marshal JSON")
 		}
 		// Reset headers for JSON
-		err = c.handler.Post(ctx, endpoint, headers, bytes.NewBuffer(jsonData), nil)
+		err = c.jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(jsonData), nil)
 		errJson := &httputil.DefaultJsonError{}
 		if err != nil {
 			if !errors.As(err, &errJson) {

validator/client/beacon-api/propose_beacon_block_test.go

@@ -103,13 +103,13 @@ func TestProposeBeaconBlock_SSZ_Error(t *testing.T) {
 				defer ctrl.Finish()
 
 				ctx := t.Context()
-				handler := mock.NewMockJsonRestHandler(ctrl)
+				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 				// Expect PostSSZ to be called first with SSZ data
 				headers := map[string]string{
 					"Eth-Consensus-Version": testCase.consensusVersion,
 				}
-				handler.EXPECT().PostSSZ(
+				jsonRestHandler.EXPECT().PostSSZ(
 					gomock.Any(),
 					testCase.endpoint,
 					headers,
@@ -120,7 +120,7 @@ func TestProposeBeaconBlock_SSZ_Error(t *testing.T) {
 
 				// No JSON fallback expected for non-406 errors
 
-				validatorClient := &beaconApiValidatorClient{handler: handler}
+				validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 				_, err := validatorClient.proposeBeaconBlock(ctx, testCase.block)
 				assert.ErrorContains(t, testSuite.expectedErrorMessage, err)
 			})
@@ -165,13 +165,13 @@ func TestProposeBeaconBlock_SSZSuccess_NoFallback(t *testing.T) {
 			defer ctrl.Finish()
 
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Expect PostSSZ to be called and succeed
 			headers := map[string]string{
 				"Eth-Consensus-Version": testCase.consensusVersion,
 			}
-			handler.EXPECT().PostSSZ(
+			jsonRestHandler.EXPECT().PostSSZ(
 				gomock.Any(),
 				testCase.endpoint,
 				headers,
@@ -181,7 +181,7 @@ func TestProposeBeaconBlock_SSZSuccess_NoFallback(t *testing.T) {
 			).Times(1)
 
 			// Post should NOT be called when PostSSZ succeeds
-			handler.EXPECT().Post(
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				gomock.Any(),
 				gomock.Any(),
@@ -189,7 +189,7 @@ func TestProposeBeaconBlock_SSZSuccess_NoFallback(t *testing.T) {
 				gomock.Any(),
 			).Times(0)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			_, err := validatorClient.proposeBeaconBlock(ctx, testCase.block)
 			assert.NoError(t, err)
 		})
@@ -200,7 +200,7 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 	t.Run("deneb", func(t *testing.T) {
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
-		handler := mock.NewMockJsonRestHandler(ctrl)
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 		var blockContents structs.SignedBeaconBlockContentsDeneb
 		err := json.Unmarshal([]byte(rpctesting.DenebBlockContents), &blockContents)
@@ -211,14 +211,14 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 		denebBytes, err := genericSignedBlock.GetDeneb().MarshalSSZ()
 		require.NoError(t, err)
 
-		handler.EXPECT().PostSSZ(
+		jsonRestHandler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blocks",
 			gomock.Any(),
 			bytes.NewBuffer(denebBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{handler: handler}
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
 		assert.NoError(t, err)
 		require.NotNil(t, proposeResponse)
@@ -231,7 +231,7 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 	t.Run("blinded_deneb", func(t *testing.T) {
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
-		handler := mock.NewMockJsonRestHandler(ctrl)
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 		var blindedBlock structs.SignedBlindedBeaconBlockDeneb
 		err := json.Unmarshal([]byte(rpctesting.BlindedDenebBlock), &blindedBlock)
@@ -242,14 +242,14 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 		blindedDenebBytes, err := genericSignedBlock.GetBlindedDeneb().MarshalSSZ()
 		require.NoError(t, err)
 
-		handler.EXPECT().PostSSZ(
+		jsonRestHandler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blinded_blocks",
 			gomock.Any(),
 			bytes.NewBuffer(blindedDenebBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{handler: handler}
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
 		assert.NoError(t, err)
 		require.NotNil(t, proposeResponse)
@@ -262,7 +262,7 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 	t.Run("electra", func(t *testing.T) {
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
-		handler := mock.NewMockJsonRestHandler(ctrl)
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 		var blockContents structs.SignedBeaconBlockContentsElectra
 		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blockContents)
@@ -273,14 +273,14 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 		electraBytes, err := genericSignedBlock.GetElectra().MarshalSSZ()
 		require.NoError(t, err)
 
-		handler.EXPECT().PostSSZ(
+		jsonRestHandler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blocks",
 			gomock.Any(),
 			bytes.NewBuffer(electraBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{handler: handler}
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
 		assert.NoError(t, err)
 		require.NotNil(t, proposeResponse)
@@ -293,7 +293,7 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 	t.Run("blinded_electra", func(t *testing.T) {
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
-		handler := mock.NewMockJsonRestHandler(ctrl)
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 		var blindedBlock structs.SignedBlindedBeaconBlockElectra
 		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blindedBlock)
@@ -304,14 +304,14 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 		blindedElectraBytes, err := genericSignedBlock.GetBlindedElectra().MarshalSSZ()
 		require.NoError(t, err)
 
-		handler.EXPECT().PostSSZ(
+		jsonRestHandler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blinded_blocks",
 			gomock.Any(),
 			bytes.NewBuffer(blindedElectraBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{handler: handler}
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
 		assert.NoError(t, err)
 		require.NotNil(t, proposeResponse)
@@ -324,7 +324,7 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 	t.Run("fulu", func(t *testing.T) {
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
-		handler := mock.NewMockJsonRestHandler(ctrl)
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 		var blockContents structs.SignedBeaconBlockContentsFulu
 		err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blockContents)
@@ -335,14 +335,14 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 		fuluBytes, err := genericSignedBlock.GetFulu().MarshalSSZ()
 		require.NoError(t, err)
 
-		handler.EXPECT().PostSSZ(
+		jsonRestHandler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blocks",
 			gomock.Any(),
 			bytes.NewBuffer(fuluBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{handler: handler}
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
 		assert.NoError(t, err)
 		require.NotNil(t, proposeResponse)
@@ -355,7 +355,7 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 	t.Run("blinded_fulu", func(t *testing.T) {
 		ctrl := gomock.NewController(t)
 		defer ctrl.Finish()
-		handler := mock.NewMockJsonRestHandler(ctrl)
+		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 		var blindedBlock structs.SignedBlindedBeaconBlockFulu
 		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blindedBlock)
@@ -366,14 +366,14 @@ func TestProposeBeaconBlock_NewerTypes_SSZMarshal(t *testing.T) {
 		blindedFuluBytes, err := genericSignedBlock.GetBlindedFulu().MarshalSSZ()
 		require.NoError(t, err)
 
-		handler.EXPECT().PostSSZ(
+		jsonRestHandler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blinded_blocks",
 			gomock.Any(),
 			bytes.NewBuffer(blindedFuluBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{handler: handler}
+		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 		proposeResponse, err := validatorClient.proposeBeaconBlock(t.Context(), genericSignedBlock)
 		assert.NoError(t, err)
 		require.NotNil(t, proposeResponse)
@@ -588,10 +588,10 @@ func TestProposeBeaconBlock_SSZFails_406_FallbackToJSON(t *testing.T) {
 			defer ctrl.Finish()
 
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Expect PostSSZ to be called first and fail
-			handler.EXPECT().PostSSZ(
+			jsonRestHandler.EXPECT().PostSSZ(
 				gomock.Any(),
 				testCase.endpoint,
 				gomock.Any(),
@@ -603,7 +603,7 @@ func TestProposeBeaconBlock_SSZFails_406_FallbackToJSON(t *testing.T) {
 				},
 			).Times(1)
 
-			handler.EXPECT().Post(
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				testCase.endpoint,
 				gomock.Any(),
@@ -613,7 +613,7 @@ func TestProposeBeaconBlock_SSZFails_406_FallbackToJSON(t *testing.T) {
 				nil,
 			).Times(1)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			_, err := validatorClient.proposeBeaconBlock(ctx, testCase.block)
 			assert.NoError(t, err)
 		})
@@ -643,13 +643,13 @@ func TestProposeBeaconBlock_SSZFails_Non406_NoFallback(t *testing.T) {
 			defer ctrl.Finish()
 
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Expect PostSSZ to be called first and fail with non-406 error
 			sszHeaders := map[string]string{
 				"Eth-Consensus-Version": testCase.consensusVersion,
 			}
-			handler.EXPECT().PostSSZ(
+			jsonRestHandler.EXPECT().PostSSZ(
 				gomock.Any(),
 				testCase.endpoint,
 				sszHeaders,
@@ -662,7 +662,7 @@ func TestProposeBeaconBlock_SSZFails_Non406_NoFallback(t *testing.T) {
 			).Times(1)
 
 			// Post should NOT be called for non-406 errors
-			handler.EXPECT().Post(
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				gomock.Any(),
 				gomock.Any(),
@@ -670,7 +670,7 @@ func TestProposeBeaconBlock_SSZFails_Non406_NoFallback(t *testing.T) {
 				gomock.Any(),
 			).Times(0)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			_, err := validatorClient.proposeBeaconBlock(ctx, testCase.block)
 			require.ErrorContains(t, "Internal server error", err)
 		})

validator/client/beacon-api/propose_exit.go

@@ -34,7 +34,7 @@ func (c *beaconApiValidatorClient) proposeExit(ctx context.Context, signedVolunt
 		return nil, errors.Wrap(err, "failed to marshal signed voluntary exit")
 	}
 
-	if err = c.handler.Post(
+	if err = c.jsonRestHandler.Post(
 		ctx,
 		"/eth/v1/beacon/pool/voluntary_exits",
 		nil,

validator/client/beacon-api/propose_exit_test.go

@@ -36,8 +36,8 @@ func TestProposeExit_Valid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		proposeExitTestEndpoint,
 		nil,
@@ -61,7 +61,7 @@ func TestProposeExit_Valid(t *testing.T) {
 	expectedExitRoot, err := protoSignedVoluntaryExit.Exit.HashTreeRoot()
 	require.NoError(t, err)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	exitResponse, err := validatorClient.proposeExit(ctx, protoSignedVoluntaryExit)
 	require.NoError(t, err)
 	assert.DeepEqual(t, expectedExitRoot[:], exitResponse.ExitRoot)
@@ -85,8 +85,8 @@ func TestProposeExit_BadRequest(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		proposeExitTestEndpoint,
 		nil,
@@ -104,7 +104,7 @@ func TestProposeExit_BadRequest(t *testing.T) {
 		Signature: []byte{3},
 	}
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err := validatorClient.proposeExit(ctx, protoSignedVoluntaryExit)
 	assert.ErrorContains(t, "foo error", err)
 }

validator/client/beacon-api/prysm_beacon_chain_client.go

@@ -19,16 +19,16 @@ import (
 )
 
 // NewPrysmChainClient returns implementation of iface.PrysmChainClient.
-func NewPrysmChainClient(handler rest.Handler, nodeClient iface.NodeClient) iface.PrysmChainClient {
+func NewPrysmChainClient(jsonRestHandler rest.RestHandler, nodeClient iface.NodeClient) iface.PrysmChainClient {
 	return prysmChainClient{
-		handler:    handler,
-		nodeClient: nodeClient,
+		jsonRestHandler: jsonRestHandler,
+		nodeClient:      nodeClient,
 	}
 }
 
 type prysmChainClient struct {
-	handler    rest.Handler
-	nodeClient iface.NodeClient
+	jsonRestHandler rest.RestHandler
+	nodeClient      iface.NodeClient
 }
 
 func (c prysmChainClient) ValidatorCount(ctx context.Context, stateID string, statuses []validator2.Status) ([]iface.ValidatorCount, error) {
@@ -50,7 +50,7 @@ func (c prysmChainClient) ValidatorCount(ctx context.Context, stateID string, st
 	queryUrl := apiutil.BuildURL(fmt.Sprintf("/eth/v1/beacon/states/%s/validator_count", stateID), queryParams)
 
 	var validatorCountResponse structs.GetValidatorCountResponse
-	if err = c.handler.Get(ctx, queryUrl, &validatorCountResponse); err != nil {
+	if err = c.jsonRestHandler.Get(ctx, queryUrl, &validatorCountResponse); err != nil {
 		return nil, err
 	}
 
@@ -97,7 +97,7 @@ func (c prysmChainClient) ValidatorPerformance(ctx context.Context, in *ethpb.Va
 		return nil, errors.Wrap(err, "failed to marshal request")
 	}
 	resp := &structs.GetValidatorPerformanceResponse{}
-	if err = c.handler.Post(ctx, "/prysm/validators/performance", nil, bytes.NewBuffer(request), resp); err != nil {
+	if err = c.jsonRestHandler.Post(ctx, "/prysm/validators/performance", nil, bytes.NewBuffer(request), resp); err != nil {
 		return nil, err
 	}
 

validator/client/beacon-api/prysm_beacon_chain_client_test.go

@@ -116,11 +116,11 @@ func TestGetValidatorCount(t *testing.T) {
 			defer ctrl.Finish()
 
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Expect node version endpoint call.
 			var nodeVersionResponse structs.GetVersionResponse
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v1/node/version",
 				&nodeVersionResponse,
@@ -132,7 +132,7 @@ func TestGetValidatorCount(t *testing.T) {
 			)
 
 			var validatorCountResponse structs.GetValidatorCountResponse
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v1/beacon/states/head/validator_count?status=active",
 				&validatorCountResponse,
@@ -145,8 +145,8 @@ func TestGetValidatorCount(t *testing.T) {
 
 			// Type assertion.
 			var client iface.PrysmChainClient = &prysmChainClient{
-				nodeClient: &beaconApiNodeClient{handler: handler},
-				handler:    handler,
+				nodeClient:      &beaconApiNodeClient{jsonRestHandler: jsonRestHandler},
+				jsonRestHandler: jsonRestHandler,
 			}
 
 			countResponse, err := client.ValidatorCount(ctx, "head", []validator.Status{validator.Active})
@@ -177,10 +177,10 @@ func Test_beaconApiBeaconChainClient_GetValidatorPerformance(t *testing.T) {
 		PublicKeys: [][]byte{publicKeys[0][:], publicKeys[2][:], publicKeys[1][:]},
 	})
 	require.NoError(t, err)
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/node/version",
 		&nodeVersionResponse,
@@ -196,7 +196,7 @@ func Test_beaconApiBeaconChainClient_GetValidatorPerformance(t *testing.T) {
 	wantResponse := &structs.GetValidatorPerformanceResponse{}
 	want := &ethpb.ValidatorPerformanceResponse{}
 
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/prysm/validators/performance",
 		nil,
@@ -207,8 +207,8 @@ func Test_beaconApiBeaconChainClient_GetValidatorPerformance(t *testing.T) {
 	)
 
 	var client iface.PrysmChainClient = &prysmChainClient{
-		nodeClient: &beaconApiNodeClient{handler: handler},
-		handler:    handler,
+		nodeClient:      &beaconApiNodeClient{jsonRestHandler: jsonRestHandler},
+		jsonRestHandler: jsonRestHandler,
 	}
 
 	got, err := client.ValidatorPerformance(ctx, &ethpb.ValidatorPerformanceRequest{

validator/client/beacon-api/registration.go

@@ -24,5 +24,5 @@ func (c *beaconApiValidatorClient) submitValidatorRegistrations(ctx context.Cont
 		return errors.Wrap(err, "failed to marshal registration")
 	}
 
-	return c.handler.Post(ctx, endpoint, nil, bytes.NewBuffer(marshalledJsonRegistration), nil)
+	return c.jsonRestHandler.Post(ctx, endpoint, nil, bytes.NewBuffer(marshalledJsonRegistration), nil)
 }

validator/client/beacon-api/registration_test.go

@@ -65,8 +65,8 @@ func TestRegistration_Valid(t *testing.T) {
 	marshalledJsonRegistrations, err := json.Marshal(jsonRegistrations)
 	require.NoError(t, err)
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/validator/register_validator",
 		nil,
@@ -129,7 +129,7 @@ func TestRegistration_Valid(t *testing.T) {
 		},
 	}
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	res, err := validatorClient.SubmitValidatorRegistrations(t.Context(), &protoRegistrations)
 
 	assert.DeepEqual(t, new(empty.Empty), res)
@@ -140,8 +140,8 @@ func TestRegistration_BadRequest(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/validator/register_validator",
 		nil,
@@ -151,7 +151,7 @@ func TestRegistration_BadRequest(t *testing.T) {
 		errors.New("foo error"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err := validatorClient.SubmitValidatorRegistrations(t.Context(), &ethpb.SignedValidatorRegistrationsV1{})
 	assert.ErrorContains(t, "foo error", err)
 }

validator/client/beacon-api/rest_handler_client_test.go

@@ -44,9 +44,9 @@ func TestGet(t *testing.T) {
 	server := httptest.NewServer(mux)
 	defer server.Close()
 
-	handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
+	jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 	resp := &structs.GetGenesisResponse{}
-	require.NoError(t, handler.Get(ctx, endpoint+"?arg1=abc&arg2=def", resp))
+	require.NoError(t, jsonRestHandler.Get(ctx, endpoint+"?arg1=abc&arg2=def", resp))
 	assert.DeepEqual(t, genesisJson, resp)
 }
 
@@ -75,9 +75,9 @@ func TestGetSSZ(t *testing.T) {
 		server := httptest.NewServer(mux)
 		defer server.Close()
 
-		handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
+		jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
-		body, header, err := handler.GetSSZ(ctx, endpoint)
+		body, header, err := jsonRestHandler.GetSSZ(ctx, endpoint)
 		require.NoError(t, err)
 		assert.DeepEqual(t, expectedBody, body)
 		require.StringContains(t, api.OctetStreamMediaType, header.Get("Content-Type"))
@@ -101,9 +101,9 @@ func TestGetSSZ(t *testing.T) {
 		server := httptest.NewServer(mux)
 		defer server.Close()
 
-		handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
+		jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
-		body, header, err := handler.GetSSZ(ctx, endpoint)
+		body, header, err := jsonRestHandler.GetSSZ(ctx, endpoint)
 		require.NoError(t, err)
 		assert.LogsContain(t, logHook, "Server responded with non primary accept type")
 		require.Equal(t, api.JsonMediaType, header.Get("Content-Type"))
@@ -126,9 +126,9 @@ func TestGetSSZ(t *testing.T) {
 		server := httptest.NewServer(mux)
 		defer server.Close()
 
-		handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
+		jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
-		_, _, err := handler.GetSSZ(ctx, endpoint)
+		_, _, err := jsonRestHandler.GetSSZ(ctx, endpoint)
 		require.NoError(t, err)
 		assert.LogsContain(t, logHook, "Server responded with non primary accept type")
 	})
@@ -148,7 +148,7 @@ func TestAcceptOverrideSSZ(t *testing.T) {
 		require.NoError(t, err)
 	}))
 	defer srv.Close()
-	c := rest.NewHandler(http.Client{Timeout: time.Second * 5}, srv.URL)
+	c := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, srv.URL)
 	_, _, err := c.GetSSZ(t.Context(), "/test")
 	require.NoError(t, err)
 }
@@ -191,9 +191,9 @@ func TestPost(t *testing.T) {
 	server := httptest.NewServer(mux)
 	defer server.Close()
 
-	handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
+	jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 	resp := &structs.GetGenesisResponse{}
-	require.NoError(t, handler.Post(ctx, endpoint, headers, bytes.NewBuffer(dataBytes), resp))
+	require.NoError(t, jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(dataBytes), resp))
 	assert.DeepEqual(t, genesisJson, resp)
 }
 
@@ -238,18 +238,18 @@ func TestGetStatusCode(t *testing.T) {
 			server := httptest.NewServer(mux)
 			defer server.Close()
 
-			handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
+			jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
-			statusCode, err := handler.GetStatusCode(ctx, endpoint)
+			statusCode, err := jsonRestHandler.GetStatusCode(ctx, endpoint)
 			require.NoError(t, err)
 			assert.Equal(t, tc.expectedStatusCode, statusCode)
 		})
 	}
 
 	t.Run("returns error on connection failure", func(t *testing.T) {
-		handler := rest.NewHandler(http.Client{Timeout: time.Millisecond * 100}, "http://localhost:99999")
+		jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Millisecond * 100}, "http://localhost:99999")
 
-		_, err := handler.GetStatusCode(ctx, endpoint)
+		_, err := jsonRestHandler.GetStatusCode(ctx, endpoint)
 		require.ErrorContains(t, "failed to perform request", err)
 	})
 }

validator/client/beacon-api/state_validators.go

@@ -22,7 +22,7 @@ type StateValidatorsProvider interface {
 }
 
 type beaconApiStateValidatorsProvider struct {
-	handler rest.Handler
+	jsonRestHandler rest.RestHandler
 }
 
 func (c beaconApiStateValidatorsProvider) StateValidators(
@@ -94,7 +94,7 @@ func (c beaconApiStateValidatorsProvider) getStateValidatorsHelper(
 	}
 	stateValidatorsJson := &structs.GetValidatorsResponse{}
 	// First try POST endpoint to check whether it is supported by the beacon node.
-	if err = c.handler.Post(ctx, endpoint, nil, bytes.NewBuffer(reqBytes), stateValidatorsJson); err == nil {
+	if err = c.jsonRestHandler.Post(ctx, endpoint, nil, bytes.NewBuffer(reqBytes), stateValidatorsJson); err == nil {
 		if stateValidatorsJson.Data == nil {
 			return nil, errors.New("stateValidatorsJson.Data is nil")
 		}
@@ -116,7 +116,7 @@ func (c beaconApiStateValidatorsProvider) getStateValidatorsHelper(
 
 	query := apiutil.BuildURL(endpoint, queryParams)
 
-	err = c.handler.Get(ctx, query, stateValidatorsJson)
+	err = c.jsonRestHandler.Get(ctx, query, stateValidatorsJson)
 	if err != nil {
 		return nil, err
 	}

validator/client/beacon-api/state_validators_test.go

@@ -34,7 +34,7 @@ func TestGetStateValidators_Nominal_POST(t *testing.T) {
 	require.NoError(t, err)
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	wanted := []*structs.ValidatorContainer{
 		{
@@ -69,7 +69,7 @@ func TestGetStateValidators_Nominal_POST(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validators",
 		nil,
@@ -84,7 +84,7 @@ func TestGetStateValidators_Nominal_POST(t *testing.T) {
 		},
 	).Times(1)
 
-	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler}
 	actual, err := stateValidatorsProvider.StateValidators(ctx, []string{
 		"0x8000091c2ae64ee414a54c1cc1fc67dec663408bc636cb86756e0200e41a75c8f86603f104f02c856983d2783116be13", // active_ongoing
 		"0x80000e851c0f53c3246ff726d7ff7766661ca5e12a07c45c114d208d54f0f8233d4380b2e9aff759d69795d1df905526", // active_exiting
@@ -120,7 +120,7 @@ func TestGetStateValidators_Nominal_GET(t *testing.T) {
 	require.NoError(t, err)
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	wanted := []*structs.ValidatorContainer{
 		{
@@ -156,7 +156,7 @@ func TestGetStateValidators_Nominal_GET(t *testing.T) {
 	ctx := t.Context()
 
 	// First return an error from POST call.
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validators",
 		nil,
@@ -177,7 +177,7 @@ func TestGetStateValidators_Nominal_GET(t *testing.T) {
 
 	query := apiutil.BuildURL("/eth/v1/beacon/states/head/validators", queryParams)
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		query,
 		&stateValidatorsResponseJson,
@@ -190,7 +190,7 @@ func TestGetStateValidators_Nominal_GET(t *testing.T) {
 		},
 	).Times(1)
 
-	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler}
 	actual, err := stateValidatorsProvider.StateValidators(ctx, []string{
 		"0x8000091c2ae64ee414a54c1cc1fc67dec663408bc636cb86756e0200e41a75c8f86603f104f02c856983d2783116be13", // active_ongoing
 		"0x80000e851c0f53c3246ff726d7ff7766661ca5e12a07c45c114d208d54f0f8233d4380b2e9aff759d69795d1df905526", // active_exiting
@@ -220,12 +220,12 @@ func TestGetStateValidators_GetRestJsonResponseOnError(t *testing.T) {
 	require.NoError(t, err)
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	ctx := t.Context()
 
 	// First call POST.
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validators",
 		nil,
@@ -246,7 +246,7 @@ func TestGetStateValidators_GetRestJsonResponseOnError(t *testing.T) {
 
 	query := apiutil.BuildURL("/eth/v1/beacon/states/head/validators", queryParams)
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		query,
 		&stateValidatorsResponseJson,
@@ -254,7 +254,7 @@ func TestGetStateValidators_GetRestJsonResponseOnError(t *testing.T) {
 		errors.New("an error"),
 	).Times(1)
 
-	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler}
 	_, err = stateValidatorsProvider.StateValidators(ctx, []string{
 		"0x8000091c2ae64ee414a54c1cc1fc67dec663408bc636cb86756e0200e41a75c8f86603f104f02c856983d2783116be13", // active_ongoing
 	},
@@ -277,9 +277,9 @@ func TestGetStateValidators_DataIsNil_POST(t *testing.T) {
 
 	ctx := t.Context()
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validators",
 		nil, bytes.NewBuffer(reqBytes),
@@ -293,7 +293,7 @@ func TestGetStateValidators_DataIsNil_POST(t *testing.T) {
 		},
 	).Times(1)
 
-	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler}
 	_, err = stateValidatorsProvider.StateValidators(ctx, []string{
 		"0x8000091c2ae64ee414a54c1cc1fc67dec663408bc636cb86756e0200e41a75c8f86603f104f02c856983d2783116be13", // active_ongoing
 	},
@@ -316,10 +316,10 @@ func TestGetStateValidators_DataIsNil_GET(t *testing.T) {
 
 	ctx := t.Context()
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	// First call POST which will return an error.
-	handler.EXPECT().Post(
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validators",
 		nil,
@@ -340,7 +340,7 @@ func TestGetStateValidators_DataIsNil_GET(t *testing.T) {
 
 	query := apiutil.BuildURL("/eth/v1/beacon/states/head/validators", queryParams)
 
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		query,
 		&stateValidatorsResponseJson,
@@ -353,7 +353,7 @@ func TestGetStateValidators_DataIsNil_GET(t *testing.T) {
 		},
 	).Times(1)
 
-	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler}
 	_, err = stateValidatorsProvider.StateValidators(ctx, []string{
 		"0x8000091c2ae64ee414a54c1cc1fc67dec663408bc636cb86756e0200e41a75c8f86603f104f02c856983d2783116be13", // active_ongoing
 	},

validator/client/beacon-api/status_test.go

@@ -50,19 +50,19 @@ func TestValidatorStatus_Nominal(t *testing.T) {
 		nil,
 	).Times(1)
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: stateValidatorsProvider,
 		prysmChainClient: prysmChainClient{
 			nodeClient: &beaconApiNodeClient{
-				handler: handler,
+				jsonRestHandler: jsonRestHandler,
 			},
 		},
 	}
 
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/node/version",
 		&nodeVersionResponse,
@@ -165,11 +165,11 @@ func TestMultipleValidatorStatus_Nominal(t *testing.T) {
 		nil,
 	).Times(1)
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/node/version",
 		&nodeVersionResponse,
@@ -181,7 +181,7 @@ func TestMultipleValidatorStatus_Nominal(t *testing.T) {
 		stateValidatorsProvider: stateValidatorsProvider,
 		prysmChainClient: prysmChainClient{
 			nodeClient: &beaconApiNodeClient{
-				handler: handler,
+				jsonRestHandler: jsonRestHandler,
 			},
 		},
 	}
@@ -317,11 +317,11 @@ func TestGetValidatorsStatusResponse_Nominal_SomeActiveValidators(t *testing.T)
 		nil,
 	).Times(1)
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/node/version",
 		&nodeVersionResponse,
@@ -333,7 +333,7 @@ func TestGetValidatorsStatusResponse_Nominal_SomeActiveValidators(t *testing.T)
 	).Times(1)
 
 	var validatorCountResponse structs.GetValidatorCountResponse
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/states/head/validator_count?",
 		&validatorCountResponse,
@@ -420,9 +420,9 @@ func TestGetValidatorsStatusResponse_Nominal_SomeActiveValidators(t *testing.T)
 		stateValidatorsProvider: stateValidatorsProvider,
 		prysmChainClient: prysmChainClient{
 			nodeClient: &beaconApiNodeClient{
-				handler: handler,
+				jsonRestHandler: jsonRestHandler,
 			},
-			handler: handler,
+			jsonRestHandler: jsonRestHandler,
 		},
 	}
 	actualValidatorsPubKey, actualValidatorsIndex, actualValidatorsStatusResponse, err := validatorClient.validatorsStatusResponse(ctx, validatorsPubKey, validatorsIndex)
@@ -465,11 +465,11 @@ func TestGetValidatorsStatusResponse_Nominal_NoActiveValidators(t *testing.T) {
 		nil,
 	).Times(1)
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/node/version",
 		&nodeVersionResponse,
@@ -490,9 +490,9 @@ func TestGetValidatorsStatusResponse_Nominal_NoActiveValidators(t *testing.T) {
 		stateValidatorsProvider: stateValidatorsProvider,
 		prysmChainClient: prysmChainClient{
 			nodeClient: &beaconApiNodeClient{
-				handler: handler,
+				jsonRestHandler: jsonRestHandler,
 			},
-			handler: handler,
+			jsonRestHandler: jsonRestHandler,
 		},
 	}
 	actualValidatorsPubKey, actualValidatorsIndex, actualValidatorsStatusResponse, err := validatorClient.validatorsStatusResponse(ctx, wantedValidatorsPubKey, nil)
@@ -704,11 +704,11 @@ func TestValidatorStatusResponse_InvalidData(t *testing.T) {
 					testCase.inputGetStateValidatorsInterface.outputErr,
 				).Times(1)
 
-				handler := mock.NewMockJsonRestHandler(ctrl)
+				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 				// Expect node version endpoint call.
 				var nodeVersionResponse structs.GetVersionResponse
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					"/eth/v1/node/version",
 					&nodeVersionResponse,
@@ -720,9 +720,9 @@ func TestValidatorStatusResponse_InvalidData(t *testing.T) {
 					stateValidatorsProvider: stateValidatorsProvider,
 					prysmChainClient: prysmChainClient{
 						nodeClient: &beaconApiNodeClient{
-							handler: handler,
+							jsonRestHandler: jsonRestHandler,
 						},
-						handler: handler,
+						jsonRestHandler: jsonRestHandler,
 					},
 				}
 

validator/client/beacon-api/stream_blocks.go

@@ -72,7 +72,7 @@ func (c *beaconApiValidatorClient) headSignedBeaconBlock(ctx context.Context) (*
 	// Since we don't know yet what the json looks like, we unmarshal into an abstract structure that has only a version
 	// and a blob of data
 	signedBlockResponseJson := abstractSignedBlockResponseJson{}
-	if err := c.handler.Get(ctx, "/eth/v2/beacon/blocks/head", &signedBlockResponseJson); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, "/eth/v2/beacon/blocks/head", &signedBlockResponseJson); err != nil {
 		return nil, err
 	}
 

validator/client/beacon-api/stream_blocks_test.go

@@ -24,8 +24,8 @@ func TestStreamBlocks_UnsupportedConsensusVersion(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		gomock.Any(),
 		&abstractSignedBlockResponseJson{},
@@ -36,7 +36,7 @@ func TestStreamBlocks_UnsupportedConsensusVersion(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	streamBlocksClient := validatorClient.streamBlocks(ctx, &eth.StreamBlocksRequest{}, time.Millisecond*100)
 	_, err := streamBlocksClient.Recv()
 	assert.ErrorContains(t, "unsupported consensus version `foo`", err)
@@ -146,8 +146,8 @@ func TestStreamBlocks_Error(t *testing.T) {
 
 					ctx := t.Context()
 
-					handler := mock.NewMockJsonRestHandler(ctrl)
-					handler.EXPECT().Get(
+					jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+					jsonRestHandler.EXPECT().Get(
 						gomock.Any(),
 						gomock.Any(),
 						&abstractSignedBlockResponseJson{},
@@ -162,7 +162,7 @@ func TestStreamBlocks_Error(t *testing.T) {
 					).Times(1)
 
 					beaconBlockConverter := testSuite.generateBeaconBlockConverter(ctrl, testCase.conversionError)
-					validatorClient := &beaconApiValidatorClient{handler: handler, beaconBlockConverter: beaconBlockConverter}
+					validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler, beaconBlockConverter: beaconBlockConverter}
 					streamBlocksClient := validatorClient.streamBlocks(ctx, &eth.StreamBlocksRequest{}, time.Millisecond*100)
 
 					_, err := streamBlocksClient.Recv()
@@ -197,7 +197,7 @@ func TestStreamBlocks_Phase0Valid(t *testing.T) {
 			ctx := t.Context()
 
 			signedBlockResponseJson := abstractSignedBlockResponseJson{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 			beaconBlockConverter := mock.NewMockBeaconBlockConverter(ctrl)
 
 			// For the first call, return a block that satisfies the verifiedOnly condition. This block should be returned by the first Recv().
@@ -212,7 +212,7 @@ func TestStreamBlocks_Phase0Valid(t *testing.T) {
 			marshalledSignedBeaconBlockContainer1, err := json.Marshal(signedBeaconBlockContainer1)
 			require.NoError(t, err)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -249,7 +249,7 @@ func TestStreamBlocks_Phase0Valid(t *testing.T) {
 			marshalledSignedBeaconBlockContainer2, err := json.Marshal(signedBeaconBlockContainer2)
 			require.NoError(t, err)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -276,7 +276,7 @@ func TestStreamBlocks_Phase0Valid(t *testing.T) {
 
 			// The fourth call is only necessary when verifiedOnly == true since the previous block was optimistic
 			if testCase.verifiedOnly {
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					"/eth/v2/beacon/blocks/head",
 					&signedBlockResponseJson,
@@ -299,7 +299,7 @@ func TestStreamBlocks_Phase0Valid(t *testing.T) {
 				).Times(1)
 			}
 
-			validatorClient := &beaconApiValidatorClient{handler: handler, beaconBlockConverter: beaconBlockConverter}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler, beaconBlockConverter: beaconBlockConverter}
 			streamBlocksClient := validatorClient.streamBlocks(ctx, &eth.StreamBlocksRequest{VerifiedOnly: testCase.verifiedOnly}, time.Millisecond*100)
 
 			// Get the first block
@@ -358,7 +358,7 @@ func TestStreamBlocks_AltairValid(t *testing.T) {
 			ctx := t.Context()
 
 			signedBlockResponseJson := abstractSignedBlockResponseJson{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 			beaconBlockConverter := mock.NewMockBeaconBlockConverter(ctrl)
 
 			// For the first call, return a block that satisfies the verifiedOnly condition. This block should be returned by the first Recv().
@@ -373,7 +373,7 @@ func TestStreamBlocks_AltairValid(t *testing.T) {
 			marshalledSignedBeaconBlockContainer1, err := json.Marshal(signedBeaconBlockContainer1)
 			require.NoError(t, err)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -410,7 +410,7 @@ func TestStreamBlocks_AltairValid(t *testing.T) {
 			marshalledSignedBeaconBlockContainer2, err := json.Marshal(signedBeaconBlockContainer2)
 			require.NoError(t, err)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -437,7 +437,7 @@ func TestStreamBlocks_AltairValid(t *testing.T) {
 
 			// The fourth call is only necessary when verifiedOnly == true since the previous block was optimistic
 			if testCase.verifiedOnly {
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					"/eth/v2/beacon/blocks/head",
 					&signedBlockResponseJson,
@@ -460,7 +460,7 @@ func TestStreamBlocks_AltairValid(t *testing.T) {
 				).Times(1)
 			}
 
-			validatorClient := &beaconApiValidatorClient{handler: handler, beaconBlockConverter: beaconBlockConverter}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler, beaconBlockConverter: beaconBlockConverter}
 			streamBlocksClient := validatorClient.streamBlocks(ctx, &eth.StreamBlocksRequest{VerifiedOnly: testCase.verifiedOnly}, time.Millisecond*100)
 
 			// Get the first block
@@ -519,7 +519,7 @@ func TestStreamBlocks_BellatrixValid(t *testing.T) {
 			ctx := t.Context()
 
 			signedBlockResponseJson := abstractSignedBlockResponseJson{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 			beaconBlockConverter := mock.NewMockBeaconBlockConverter(ctrl)
 
 			// For the first call, return a block that satisfies the verifiedOnly condition. This block should be returned by the first Recv().
@@ -534,7 +534,7 @@ func TestStreamBlocks_BellatrixValid(t *testing.T) {
 			marshalledSignedBeaconBlockContainer1, err := json.Marshal(signedBeaconBlockContainer1)
 			require.NoError(t, err)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -571,7 +571,7 @@ func TestStreamBlocks_BellatrixValid(t *testing.T) {
 			marshalledSignedBeaconBlockContainer2, err := json.Marshal(signedBeaconBlockContainer2)
 			require.NoError(t, err)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -598,7 +598,7 @@ func TestStreamBlocks_BellatrixValid(t *testing.T) {
 
 			// The fourth call is only necessary when verifiedOnly == true since the previous block was optimistic
 			if testCase.verifiedOnly {
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					"/eth/v2/beacon/blocks/head",
 					&signedBlockResponseJson,
@@ -621,7 +621,7 @@ func TestStreamBlocks_BellatrixValid(t *testing.T) {
 				).Times(1)
 			}
 
-			validatorClient := &beaconApiValidatorClient{handler: handler, beaconBlockConverter: beaconBlockConverter}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler, beaconBlockConverter: beaconBlockConverter}
 			streamBlocksClient := validatorClient.streamBlocks(ctx, &eth.StreamBlocksRequest{VerifiedOnly: testCase.verifiedOnly}, time.Millisecond*100)
 
 			// Get the first block
@@ -680,7 +680,7 @@ func TestStreamBlocks_CapellaValid(t *testing.T) {
 			ctx := t.Context()
 
 			signedBlockResponseJson := abstractSignedBlockResponseJson{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 			beaconBlockConverter := mock.NewMockBeaconBlockConverter(ctrl)
 
 			// For the first call, return a block that satisfies the verifiedOnly condition. This block should be returned by the first Recv().
@@ -695,7 +695,7 @@ func TestStreamBlocks_CapellaValid(t *testing.T) {
 			marshalledSignedBeaconBlockContainer1, err := json.Marshal(signedBeaconBlockContainer1)
 			require.NoError(t, err)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -732,7 +732,7 @@ func TestStreamBlocks_CapellaValid(t *testing.T) {
 			marshalledSignedBeaconBlockContainer2, err := json.Marshal(signedBeaconBlockContainer2)
 			require.NoError(t, err)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -759,7 +759,7 @@ func TestStreamBlocks_CapellaValid(t *testing.T) {
 
 			// The fourth call is only necessary when verifiedOnly == true since the previous block was optimistic
 			if testCase.verifiedOnly {
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					"/eth/v2/beacon/blocks/head",
 					&signedBlockResponseJson,
@@ -782,7 +782,7 @@ func TestStreamBlocks_CapellaValid(t *testing.T) {
 				).Times(1)
 			}
 
-			validatorClient := &beaconApiValidatorClient{handler: handler, beaconBlockConverter: beaconBlockConverter}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler, beaconBlockConverter: beaconBlockConverter}
 			streamBlocksClient := validatorClient.streamBlocks(ctx, &eth.StreamBlocksRequest{VerifiedOnly: testCase.verifiedOnly}, time.Millisecond*100)
 
 			// Get the first block
@@ -841,7 +841,7 @@ func TestStreamBlocks_DenebValid(t *testing.T) {
 			ctx := t.Context()
 
 			signedBlockResponseJson := abstractSignedBlockResponseJson{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 			beaconBlockConverter := mock.NewMockBeaconBlockConverter(ctrl)
 
 			// For the first call, return a block that satisfies the verifiedOnly condition. This block should be returned by the first Recv().
@@ -856,7 +856,7 @@ func TestStreamBlocks_DenebValid(t *testing.T) {
 
 			marshalledSignedBeaconBlockContainer1, err := json.Marshal(denebBlock)
 			require.NoError(t, err)
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -885,7 +885,7 @@ func TestStreamBlocks_DenebValid(t *testing.T) {
 			marshalledSignedBeaconBlockContainer2, err := json.Marshal(denebBlock2)
 			require.NoError(t, err)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v2/beacon/blocks/head",
 				&signedBlockResponseJson,
@@ -902,7 +902,7 @@ func TestStreamBlocks_DenebValid(t *testing.T) {
 
 			// The fourth call is only necessary when verifiedOnly == true since the previous block was optimistic
 			if testCase.verifiedOnly {
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					"/eth/v2/beacon/blocks/head",
 					&signedBlockResponseJson,
@@ -918,7 +918,7 @@ func TestStreamBlocks_DenebValid(t *testing.T) {
 				).Times(1)
 			}
 
-			validatorClient := &beaconApiValidatorClient{handler: handler, beaconBlockConverter: beaconBlockConverter}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler, beaconBlockConverter: beaconBlockConverter}
 			streamBlocksClient := validatorClient.streamBlocks(ctx, &eth.StreamBlocksRequest{VerifiedOnly: testCase.verifiedOnly}, time.Millisecond*100)
 
 			// Get the first block

validator/client/beacon-api/submit_aggregate_selection_proof.go

@@ -129,7 +129,7 @@ func (c *beaconApiValidatorClient) aggregateAttestation(
 	endpoint := apiutil.BuildURL("/eth/v2/validator/aggregate_attestation", params)
 
 	var aggregateAttestationResponse structs.AggregateAttestationResponse
-	err := c.handler.Get(ctx, endpoint, &aggregateAttestationResponse)
+	err := c.jsonRestHandler.Get(ctx, endpoint, &aggregateAttestationResponse)
 	if err != nil {
 		return nil, err
 	}
@@ -150,7 +150,7 @@ func (c *beaconApiValidatorClient) aggregateAttestationElectra(
 	endpoint := apiutil.BuildURL("/eth/v2/validator/aggregate_attestation", params)
 
 	var aggregateAttestationResponse structs.AggregateAttestationResponse
-	if err := c.handler.Get(ctx, endpoint, &aggregateAttestationResponse); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, endpoint, &aggregateAttestationResponse); err != nil {
 		return nil, err
 	}
 

validator/client/beacon-api/submit_aggregate_selection_proof_test.go

@@ -94,10 +94,10 @@ func TestSubmitAggregateSelectionProof(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Call node syncing endpoint to check if head is optimistic.
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				syncingEndpoint,
 				&structs.SyncStatusResponse{},
@@ -113,7 +113,7 @@ func TestSubmitAggregateSelectionProof(t *testing.T) {
 			).Times(1)
 
 			// Call attestation data to get attestation data root to query aggregate attestation.
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				fmt.Sprintf("%s?committee_index=%d&slot=%d", attestationDataEndpoint, committeeIndex, slot),
 				&structs.GetAttestationDataResponse{},
@@ -128,7 +128,7 @@ func TestSubmitAggregateSelectionProof(t *testing.T) {
 			require.NoError(t, err)
 
 			// Call attestation data to get attestation data root to query aggregate attestation.
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				fmt.Sprintf("%s?attestation_data_root=%s&committee_index=%d&slot=%d", aggregateAttestationEndpoint, hexutil.Encode(attestationDataRootBytes[:]), committeeIndex, slot),
 				&structs.AggregateAttestationResponse{},
@@ -156,12 +156,12 @@ func TestSubmitAggregateSelectionProof(t *testing.T) {
 			}
 
 			validatorClient := &beaconApiValidatorClient{
-				handler: handler,
+				jsonRestHandler: jsonRestHandler,
 				stateValidatorsProvider: beaconApiStateValidatorsProvider{
-					handler: handler,
+					jsonRestHandler: jsonRestHandler,
 				},
 				dutiesProvider: beaconApiDutiesProvider{
-					handler: handler,
+					jsonRestHandler: jsonRestHandler,
 				},
 			}
 
@@ -263,10 +263,10 @@ func TestSubmitAggregateSelectionProofElectra(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Call node syncing endpoint to check if head is optimistic.
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				syncingEndpoint,
 				&structs.SyncStatusResponse{},
@@ -282,7 +282,7 @@ func TestSubmitAggregateSelectionProofElectra(t *testing.T) {
 			).Times(1)
 
 			// Call attestation data to get attestation data root to query aggregate attestation.
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				fmt.Sprintf("%s?committee_index=%d&slot=%d", attestationDataEndpoint, committeeIndex, slot),
 				&structs.GetAttestationDataResponse{},
@@ -297,7 +297,7 @@ func TestSubmitAggregateSelectionProofElectra(t *testing.T) {
 			require.NoError(t, err)
 
 			// Call attestation data to get attestation data root to query aggregate attestation.
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				fmt.Sprintf("%s?attestation_data_root=%s&committee_index=%d&slot=%d", aggregateAttestationEndpoint, hexutil.Encode(attestationDataRootBytes[:]), committeeIndex, slot),
 				&structs.AggregateAttestationResponse{},
@@ -325,12 +325,12 @@ func TestSubmitAggregateSelectionProofElectra(t *testing.T) {
 			}
 
 			validatorClient := &beaconApiValidatorClient{
-				handler: handler,
+				jsonRestHandler: jsonRestHandler,
 				stateValidatorsProvider: beaconApiStateValidatorsProvider{
-					handler: handler,
+					jsonRestHandler: jsonRestHandler,
 				},
 				dutiesProvider: beaconApiDutiesProvider{
-					handler: handler,
+					jsonRestHandler: jsonRestHandler,
 				},
 			}
 

validator/client/beacon-api/submit_signed_aggregate_proof.go

@@ -18,7 +18,7 @@ func (c *beaconApiValidatorClient) submitSignedAggregateSelectionProof(ctx conte
 		return nil, errors.Wrap(err, "failed to marshal SignedAggregateAttestationAndProof")
 	}
 	headers := map[string]string{"Eth-Consensus-Version": version.String(in.SignedAggregateAndProof.Version())}
-	err = c.handler.Post(ctx, "/eth/v2/validator/aggregate_and_proofs", headers, bytes.NewBuffer(body), nil)
+	err = c.jsonRestHandler.Post(ctx, "/eth/v2/validator/aggregate_and_proofs", headers, bytes.NewBuffer(body), nil)
 	if err != nil {
 		return nil, err
 	}
@@ -39,7 +39,7 @@ func (c *beaconApiValidatorClient) submitSignedAggregateSelectionProofElectra(ct
 	dataSlot := in.SignedAggregateAndProof.Message.Aggregate.Data.Slot
 	consensusVersion := version.String(slots.ToForkVersion(dataSlot))
 	headers := map[string]string{"Eth-Consensus-Version": consensusVersion}
-	if err = c.handler.Post(ctx, "/eth/v2/validator/aggregate_and_proofs", headers, bytes.NewBuffer(body), nil); err != nil {
+	if err = c.jsonRestHandler.Post(ctx, "/eth/v2/validator/aggregate_and_proofs", headers, bytes.NewBuffer(body), nil); err != nil {
 		return nil, err
 	}
 

validator/client/beacon-api/submit_signed_aggregate_proof_test.go

@@ -28,8 +28,8 @@ func TestSubmitSignedAggregateSelectionProof_Valid(t *testing.T) {
 
 	ctx := t.Context()
 	headers := map[string]string{"Eth-Consensus-Version": version.String(signedAggregateAndProof.Message.Version())}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v2/validator/aggregate_and_proofs",
 		headers,
@@ -42,7 +42,7 @@ func TestSubmitSignedAggregateSelectionProof_Valid(t *testing.T) {
 	attestationDataRoot, err := signedAggregateAndProof.Message.Aggregate.Data.HashTreeRoot()
 	require.NoError(t, err)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	resp, err := validatorClient.submitSignedAggregateSelectionProof(ctx, &ethpb.SignedAggregateSubmitRequest{
 		SignedAggregateAndProof: signedAggregateAndProof,
 	})
@@ -60,8 +60,8 @@ func TestSubmitSignedAggregateSelectionProof_BadRequest(t *testing.T) {
 
 	ctx := t.Context()
 	headers := map[string]string{"Eth-Consensus-Version": version.String(signedAggregateAndProof.Message.Version())}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v2/validator/aggregate_and_proofs",
 		headers,
@@ -71,7 +71,7 @@ func TestSubmitSignedAggregateSelectionProof_BadRequest(t *testing.T) {
 		errors.New("bad request"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err = validatorClient.submitSignedAggregateSelectionProof(ctx, &ethpb.SignedAggregateSubmitRequest{
 		SignedAggregateAndProof: signedAggregateAndProof,
 	})
@@ -93,8 +93,8 @@ func TestSubmitSignedAggregateSelectionProofElectra_Valid(t *testing.T) {
 	ctx := t.Context()
 	expectedVersion := version.String(slots.ToForkVersion(signedAggregateAndProofElectra.Message.Aggregate.Data.Slot))
 	headers := map[string]string{"Eth-Consensus-Version": expectedVersion}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v2/validator/aggregate_and_proofs",
 		headers,
@@ -107,7 +107,7 @@ func TestSubmitSignedAggregateSelectionProofElectra_Valid(t *testing.T) {
 	attestationDataRoot, err := signedAggregateAndProofElectra.Message.Aggregate.Data.HashTreeRoot()
 	require.NoError(t, err)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	resp, err := validatorClient.submitSignedAggregateSelectionProofElectra(ctx, &ethpb.SignedAggregateSubmitElectraRequest{
 		SignedAggregateAndProof: signedAggregateAndProofElectra,
 	})
@@ -130,8 +130,8 @@ func TestSubmitSignedAggregateSelectionProofElectra_BadRequest(t *testing.T) {
 	ctx := t.Context()
 	expectedVersion := version.String(slots.ToForkVersion(signedAggregateAndProofElectra.Message.Aggregate.Data.Slot))
 	headers := map[string]string{"Eth-Consensus-Version": expectedVersion}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v2/validator/aggregate_and_proofs",
 		headers,
@@ -141,7 +141,7 @@ func TestSubmitSignedAggregateSelectionProofElectra_BadRequest(t *testing.T) {
 		errors.New("bad request"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err = validatorClient.submitSignedAggregateSelectionProofElectra(ctx, &ethpb.SignedAggregateSubmitElectraRequest{
 		SignedAggregateAndProof: signedAggregateAndProofElectra,
 	})
@@ -163,8 +163,8 @@ func TestSubmitSignedAggregateSelectionProofElectra_FuluVersion(t *testing.T) {
 	ctx := t.Context()
 	expectedVersion := version.String(slots.ToForkVersion(signedAggregateAndProofElectra.Message.Aggregate.Data.Slot))
 	headers := map[string]string{"Eth-Consensus-Version": expectedVersion}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v2/validator/aggregate_and_proofs",
 		headers,
@@ -177,7 +177,7 @@ func TestSubmitSignedAggregateSelectionProofElectra_FuluVersion(t *testing.T) {
 	attestationDataRoot, err := signedAggregateAndProofElectra.Message.Aggregate.Data.HashTreeRoot()
 	require.NoError(t, err)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	resp, err := validatorClient.submitSignedAggregateSelectionProofElectra(ctx, &ethpb.SignedAggregateSubmitElectraRequest{
 		SignedAggregateAndProof: signedAggregateAndProofElectra,
 	})

validator/client/beacon-api/submit_signed_contribution_and_proof.go

@@ -47,7 +47,7 @@ func (c *beaconApiValidatorClient) submitSignedContributionAndProof(ctx context.
 		return errors.Wrap(err, "failed to marshall signed contribution and proof")
 	}
 
-	return c.handler.Post(
+	return c.jsonRestHandler.Post(
 		ctx,
 		"/eth/v1/validator/contribution_and_proofs",
 		nil,

validator/client/beacon-api/submit_signed_contribution_and_proof_test.go

@@ -43,8 +43,8 @@ func TestSubmitSignedContributionAndProof_Valid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		submitSignedContributionAndProofTestEndpoint,
 		nil,
@@ -69,7 +69,7 @@ func TestSubmitSignedContributionAndProof_Valid(t *testing.T) {
 		Signature: []byte{8},
 	}
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	err = validatorClient.submitSignedContributionAndProof(ctx, contributionAndProof)
 	require.NoError(t, err)
 }
@@ -117,9 +117,9 @@ func TestSubmitSignedContributionAndProof_Error(t *testing.T) {
 
 			ctx := t.Context()
 
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 			if testCase.httpRequestExpected {
-				handler.EXPECT().Post(
+				jsonRestHandler.EXPECT().Post(
 					gomock.Any(),
 					submitSignedContributionAndProofTestEndpoint,
 					gomock.Any(),
@@ -130,7 +130,7 @@ func TestSubmitSignedContributionAndProof_Error(t *testing.T) {
 				).Times(1)
 			}
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			err := validatorClient.submitSignedContributionAndProof(ctx, testCase.data)
 			assert.ErrorContains(t, testCase.expectedErrorMessage, err)
 		})

validator/client/beacon-api/subscribe_committee_subnets.go

@@ -36,7 +36,7 @@ func (c *beaconApiValidatorClient) subscribeCommitteeSubnets(ctx context.Context
 		return errors.Wrap(err, "failed to marshal committees subscriptions")
 	}
 
-	return c.handler.Post(
+	return c.jsonRestHandler.Post(
 		ctx,
 		"/eth/v1/validator/beacon_committee_subscriptions",
 		nil,

validator/client/beacon-api/subscribe_committee_subnets_test.go

@@ -44,8 +44,8 @@ func TestSubscribeCommitteeSubnets_Valid(t *testing.T) {
 
 	ctx := t.Context()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		subscribeCommitteeSubnetsTestEndpoint,
 		nil,
@@ -66,7 +66,7 @@ func TestSubscribeCommitteeSubnets_Valid(t *testing.T) {
 	}
 
 	validatorClient := &beaconApiValidatorClient{
-		handler: handler,
+		jsonRestHandler: jsonRestHandler,
 	}
 	err = validatorClient.subscribeCommitteeSubnets(
 		ctx,
@@ -205,9 +205,9 @@ func TestSubscribeCommitteeSubnets_Error(t *testing.T) {
 
 			ctx := t.Context()
 
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 			if testCase.expectSubscribeRestCall {
-				handler.EXPECT().Post(
+				jsonRestHandler.EXPECT().Post(
 					gomock.Any(),
 					subscribeCommitteeSubnetsTestEndpoint,
 					gomock.Any(),
@@ -219,7 +219,7 @@ func TestSubscribeCommitteeSubnets_Error(t *testing.T) {
 			}
 
 			validatorClient := &beaconApiValidatorClient{
-				handler: handler,
+				jsonRestHandler: jsonRestHandler,
 			}
 			err := validatorClient.subscribeCommitteeSubnets(ctx, testCase.subscribeRequest, testCase.duties)
 			assert.ErrorContains(t, testCase.expectedErrorMessage, err)

validator/client/beacon-api/sync_committee.go

@@ -31,13 +31,13 @@ func (c *beaconApiValidatorClient) submitSyncMessage(ctx context.Context, syncMe
 		return errors.Wrap(err, "failed to marshal sync committee message")
 	}
 
-	return c.handler.Post(ctx, endpoint, nil, bytes.NewBuffer(marshalledJsonSyncCommitteeMessage), nil)
+	return c.jsonRestHandler.Post(ctx, endpoint, nil, bytes.NewBuffer(marshalledJsonSyncCommitteeMessage), nil)
 }
 
 func (c *beaconApiValidatorClient) syncMessageBlockRoot(ctx context.Context) (*ethpb.SyncMessageBlockRootResponse, error) {
 	// Get head beacon block root.
 	var resp structs.BlockRootResponse
-	if err := c.handler.Get(ctx, "/eth/v1/beacon/blocks/head/root", &resp); err != nil {
+	if err := c.jsonRestHandler.Get(ctx, "/eth/v1/beacon/blocks/head/root", &resp); err != nil {
 		return nil, err
 	}
 
@@ -82,7 +82,7 @@ func (c *beaconApiValidatorClient) syncCommitteeContribution(
 	params.Add("beacon_block_root", blockRoot)
 
 	var resp structs.ProduceSyncCommitteeContributionResponse
-	if err = c.handler.Get(ctx, apiutil.BuildURL("/eth/v1/validator/sync_committee_contribution", params), &resp); err != nil {
+	if err = c.jsonRestHandler.Get(ctx, apiutil.BuildURL("/eth/v1/validator/sync_committee_contribution", params), &resp); err != nil {
 		return nil, err
 	}
 

validator/client/beacon-api/sync_committee_selections.go

@@ -20,7 +20,7 @@ func (c *beaconApiValidatorClient) aggregatedSyncSelections(ctx context.Context,
 	}
 
 	var resp aggregatedSyncSelectionResponse
-	err = c.handler.Post(ctx, "/eth/v1/validator/sync_committee_selections", nil, bytes.NewBuffer(body), &resp)
+	err = c.jsonRestHandler.Post(ctx, "/eth/v1/validator/sync_committee_selections", nil, bytes.NewBuffer(body), &resp)
 	if err != nil {
 		return nil, errors.Wrap(err, "error calling post endpoint")
 	}

validator/client/beacon-api/sync_committee_selections_test.go

@@ -96,13 +96,13 @@ func TestGetAggregatedSyncSelections(t *testing.T) {
 	for _, test := range testcases {
 		t.Run(test.name, func(t *testing.T) {
 			ctrl := gomock.NewController(t)
-			handler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 			reqBody, err := json.Marshal(test.req)
 			require.NoError(t, err)
 
 			ctx := t.Context()
-			handler.EXPECT().Post(
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				"/eth/v1/validator/sync_committee_selections",
 				nil,
@@ -115,7 +115,7 @@ func TestGetAggregatedSyncSelections(t *testing.T) {
 				test.endpointError,
 			).Times(1)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			res, err := validatorClient.AggregatedSyncSelections(ctx, test.req)
 			if test.expectedErrorMessage != "" {
 				require.ErrorContains(t, test.expectedErrorMessage, err)

validator/client/beacon-api/sync_committee_test.go

@@ -44,8 +44,8 @@ func TestSubmitSyncMessage_Valid(t *testing.T) {
 	marshalledJsonRegistrations, err := json.Marshal([]*structs.SyncCommitteeMessage{jsonSyncCommitteeMessage})
 	require.NoError(t, err)
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/pool/sync_committees",
 		nil,
@@ -62,7 +62,7 @@ func TestSubmitSyncMessage_Valid(t *testing.T) {
 		Signature:      decodedSignature,
 	}
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	res, err := validatorClient.SubmitSyncMessage(t.Context(), &protoSyncCommitteeMessage)
 
 	assert.DeepEqual(t, new(empty.Empty), res)
@@ -73,8 +73,8 @@ func TestSubmitSyncMessage_BadRequest(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Post(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/beacon/pool/sync_committees",
 		nil,
@@ -84,7 +84,7 @@ func TestSubmitSyncMessage_BadRequest(t *testing.T) {
 		errors.New("foo error"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{handler: handler}
+	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 	_, err := validatorClient.SubmitSyncMessage(t.Context(), &ethpb.SyncCommitteeMessage{})
 	assert.ErrorContains(t, "foo error", err)
 }
@@ -137,8 +137,8 @@ func TestGetSyncMessageBlockRoot(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
-			handler.EXPECT().Get(
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v1/beacon/blocks/head/root",
 				&structs.BlockRootResponse{},
@@ -149,7 +149,7 @@ func TestGetSyncMessageBlockRoot(t *testing.T) {
 				test.endpointError,
 			).Times(1)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			actualResponse, err := validatorClient.syncMessageBlockRoot(ctx)
 			if test.expectedErrorMessage != "" {
 				require.ErrorContains(t, test.expectedErrorMessage, err)
@@ -207,8 +207,8 @@ func TestGetSyncCommitteeContribution(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ctx := t.Context()
-			handler := mock.NewMockJsonRestHandler(ctrl)
-			handler.EXPECT().Get(
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v1/beacon/blocks/head/root",
 				&structs.BlockRootResponse{},
@@ -223,7 +223,7 @@ func TestGetSyncCommitteeContribution(t *testing.T) {
 				nil,
 			).Times(1)
 
-			handler.EXPECT().Get(
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				fmt.Sprintf("/eth/v1/validator/sync_committee_contribution?beacon_block_root=%s&slot=%d&subcommittee_index=%d",
 					blockRoot, uint64(request.Slot), request.SubnetId),
@@ -235,7 +235,7 @@ func TestGetSyncCommitteeContribution(t *testing.T) {
 				test.endpointErr,
 			).Times(1)
 
-			validatorClient := &beaconApiValidatorClient{handler: handler}
+			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
 			actualResponse, err := validatorClient.syncCommitteeContribution(ctx, request)
 			if test.expectedErrMsg != "" {
 				require.ErrorContains(t, test.expectedErrMsg, err)
@@ -314,8 +314,8 @@ func TestGetSyncSubCommitteeIndex(t *testing.T) {
 			}
 			valsReqBytes, err := json.Marshal(valsReq)
 			require.NoError(t, err)
-			handler := mock.NewMockJsonRestHandler(ctrl)
-			handler.EXPECT().Post(
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				validatorsEndpoint,
 				nil,
@@ -350,7 +350,7 @@ func TestGetSyncSubCommitteeIndex(t *testing.T) {
 
 				query := apiutil.BuildURL("/eth/v1/beacon/states/head/validators", queryParams)
 
-				handler.EXPECT().Get(
+				jsonRestHandler.EXPECT().Get(
 					gomock.Any(),
 					query,
 					&structs.GetValidatorsResponse{},
@@ -367,7 +367,7 @@ func TestGetSyncSubCommitteeIndex(t *testing.T) {
 				syncDutiesCalled = 1
 			}
 
-			handler.EXPECT().Post(
+			jsonRestHandler.EXPECT().Post(
 				gomock.Any(),
 				fmt.Sprintf("%s/%d", syncDutiesEndpoint, slots.ToEpoch(slot)),
 				nil,
@@ -386,12 +386,12 @@ func TestGetSyncSubCommitteeIndex(t *testing.T) {
 			require.NoError(t, err)
 
 			validatorClient := &beaconApiValidatorClient{
-				handler: handler,
+				jsonRestHandler: jsonRestHandler,
 				stateValidatorsProvider: beaconApiStateValidatorsProvider{
-					handler: handler,
+					jsonRestHandler: jsonRestHandler,
 				},
 				dutiesProvider: beaconApiDutiesProvider{
-					handler: handler,
+					jsonRestHandler: jsonRestHandler,
 				},
 			}
 			actualResponse, err := validatorClient.syncSubcommitteeIndex(ctx, &ethpb.SyncSubcommitteeIndexRequest{

validator/client/beacon-api/wait_for_chain_start_test.go

@@ -21,8 +21,8 @@ func TestWaitForChainStart_ValidGenesis(t *testing.T) {
 
 	ctx := t.Context()
 	genesisResponseJson := structs.GetGenesisResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -38,7 +38,7 @@ func TestWaitForChainStart_ValidGenesis(t *testing.T) {
 		},
 	).Times(1)
 
-	genesisProvider := beaconApiGenesisProvider{handler: handler}
+	genesisProvider := beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
 	validatorClient := beaconApiValidatorClient{genesisProvider: &genesisProvider}
 	resp, err := validatorClient.WaitForChainStart(ctx, &emptypb.Empty{})
 	assert.NoError(t, err)
@@ -88,8 +88,8 @@ func TestWaitForChainStart_BadGenesis(t *testing.T) {
 
 			ctx := t.Context()
 			genesisResponseJson := structs.GetGenesisResponse{}
-			handler := mock.NewMockJsonRestHandler(ctrl)
-			handler.EXPECT().Get(
+			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			jsonRestHandler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v1/beacon/genesis",
 				&genesisResponseJson,
@@ -102,7 +102,7 @@ func TestWaitForChainStart_BadGenesis(t *testing.T) {
 				},
 			).Times(1)
 
-			genesisProvider := beaconApiGenesisProvider{handler: handler}
+			genesisProvider := beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
 			validatorClient := beaconApiValidatorClient{genesisProvider: &genesisProvider}
 			_, err := validatorClient.WaitForChainStart(ctx, &emptypb.Empty{})
 			assert.ErrorContains(t, testCase.errorMessage, err)
@@ -116,8 +116,8 @@ func TestWaitForChainStart_JsonResponseError(t *testing.T) {
 
 	ctx := t.Context()
 	genesisResponseJson := structs.GetGenesisResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
-	handler.EXPECT().Get(
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -125,7 +125,7 @@ func TestWaitForChainStart_JsonResponseError(t *testing.T) {
 		errors.New("some specific json error"),
 	).Times(1)
 
-	genesisProvider := beaconApiGenesisProvider{handler: handler}
+	genesisProvider := beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
 	validatorClient := beaconApiValidatorClient{genesisProvider: &genesisProvider}
 	_, err := validatorClient.WaitForChainStart(ctx, &emptypb.Empty{})
 	assert.ErrorContains(t, "failed to get genesis data", err)
@@ -139,10 +139,10 @@ func TestWaitForChainStart_JsonResponseError404(t *testing.T) {
 
 	ctx := t.Context()
 	genesisResponseJson := structs.GetGenesisResponse{}
-	handler := mock.NewMockJsonRestHandler(ctrl)
+	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 
 	// First, mock a request that receives a 404 error (which means that the genesis data is not available yet)
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -154,7 +154,7 @@ func TestWaitForChainStart_JsonResponseError404(t *testing.T) {
 	).Times(1)
 
 	// After receiving a 404 error, mock a request that actually has genesis data available
-	handler.EXPECT().Get(
+	jsonRestHandler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -170,7 +170,7 @@ func TestWaitForChainStart_JsonResponseError404(t *testing.T) {
 		},
 	).Times(1)
 
-	genesisProvider := beaconApiGenesisProvider{handler: handler}
+	genesisProvider := beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
 	validatorClient := beaconApiValidatorClient{genesisProvider: &genesisProvider}
 	resp, err := validatorClient.WaitForChainStart(ctx, &emptypb.Empty{})
 	assert.NoError(t, err)

validator/client/grpc-api/BUILD.bazel

@@ -15,7 +15,6 @@ go_library(
     deps = [
         "//api/client:go_default_library",
         "//api/client/event:go_default_library",
-        "//api/failover:go_default_library",
         "//api/server/structs:go_default_library",
         "//beacon-chain/rpc/eth/helpers:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
@@ -50,7 +49,6 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//api/client/event:go_default_library",
-        "//api/grpc:go_default_library",
         "//api/server/structs:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",

validator/client/grpc-api/grpc_client_manager.go

@@ -10,11 +10,11 @@ import (
 // grpcClientManager handles dynamic gRPC client recreation when the connection changes.
 // It uses generics to work with any gRPC client type.
 type grpcClientManager[T any] struct {
-	mu              sync.Mutex
-	conn            validatorHelpers.NodeConnection
-	client          T
-	lastConnCounter uint64 // connection counter when client was last created; compared to detect host switches
-	newClient       func(grpc.ClientConnInterface) T
+	mu        sync.Mutex
+	conn      validatorHelpers.NodeConnection
+	client    T
+	lastHost  string
+	newClient func(grpc.ClientConnInterface) T
 }
 
 // newGrpcClientManager creates a new client manager with the given connection and client constructor.
@@ -23,25 +23,22 @@ func newGrpcClientManager[T any](
 	newClient func(grpc.ClientConnInterface) T,
 ) *grpcClientManager[T] {
 	return &grpcClientManager[T]{
-		conn:            conn,
-		newClient:       newClient,
-		client:          newClient(conn.GetGrpcClientConn()),
-		lastConnCounter: conn.GetGrpcConnectionProvider().ConnectionCounter(),
+		conn:      conn,
+		newClient: newClient,
+		client:    newClient(conn.GetGrpcClientConn()),
+		lastHost:  conn.GetGrpcConnectionProvider().CurrentHost(),
 	}
 }
 
 // getClient returns the current client, recreating it if the connection has changed.
-// It uses the provider's connection counter rather than the host string to detect changes,
-// which correctly handles host bounces (e.g., host0 → host1 → host0) where the host
-// string returns to its original value but the underlying connection has been replaced.
 func (m *grpcClientManager[T]) getClient() T {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	currentCounter := m.conn.GetGrpcConnectionProvider().ConnectionCounter()
-	if m.lastConnCounter != currentCounter {
+	currentHost := m.conn.GetGrpcConnectionProvider().CurrentHost()
+	if m.lastHost != currentHost {
 		m.client = m.newClient(m.conn.GetGrpcClientConn())
-		m.lastConnCounter = currentCounter
+		m.lastHost = currentHost
 	}
 	return m.client
 }

validator/client/grpc-api/grpc_client_manager_test.go

@@ -14,7 +14,6 @@ import (
 type mockProvider struct {
 	hosts        []string
 	currentIndex int
-	connCounter  uint64
 	mu           sync.Mutex
 }
 
@@ -32,22 +31,14 @@ func (m *mockProvider) SwitchHost(index int) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.currentIndex = index
-	m.connCounter++
 	return nil
 }
 
-func (m *mockProvider) ConnectionCounter() uint64 {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.connCounter
-}
-
 // nextHost is a test helper for round-robin simulation (not part of the interface).
 func (m *mockProvider) nextHost() {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.currentIndex = (m.currentIndex + 1) % len(m.hosts)
-	m.connCounter++
 }
 
 // testClient is a simple type for testing the generic client manager.
@@ -70,11 +61,11 @@ func testManager(t *testing.T, provider *mockProvider) (*grpcClientManager[*test
 }
 
 func TestGrpcClientManager(t *testing.T) {
-	t.Run("tracks connection counter", func(t *testing.T) {
+	t.Run("tracks host", func(t *testing.T) {
 		provider := &mockProvider{hosts: []string{"host1:4000", "host2:4000"}}
 		manager, count := testManager(t, provider)
 		assert.Equal(t, 1, *count)
-		assert.Equal(t, uint64(0), manager.lastConnCounter)
+		assert.Equal(t, "host1:4000", manager.lastHost)
 	})
 
 	t.Run("same host returns same client", func(t *testing.T) {
@@ -105,30 +96,6 @@ func TestGrpcClientManager(t *testing.T) {
 		assert.Equal(t, c2, c3)
 	})
 
-	t.Run("host bounce recreates client", func(t *testing.T) {
-		// Regression test: when host bounces (host0 → host1 → host0), the client
-		// must be recreated even though the host string returns to its original value,
-		// because the underlying *grpc.ClientConn was destroyed and replaced.
-		provider := &mockProvider{hosts: []string{"host1:4000", "host2:4000"}}
-		manager, count := testManager(t, provider)
-
-		c1 := manager.getClient()
-		assert.Equal(t, 1, c1.id)
-
-		// Switch to host2
-		provider.nextHost()
-		c2 := manager.getClient()
-		assert.Equal(t, 2, *count)
-		assert.Equal(t, 2, c2.id)
-
-		// Switch back to host1 — same host string but new connection
-		provider.nextHost()
-		assert.Equal(t, "host1:4000", provider.CurrentHost())
-		c3 := manager.getClient()
-		assert.Equal(t, 3, *count, "client should be recreated on host bounce")
-		assert.Equal(t, 3, c3.id)
-	})
-
 	t.Run("multiple host switches", func(t *testing.T) {
 		provider := &mockProvider{hosts: []string{"host1:4000", "host2:4000", "host3:4000"}}
 		manager, count := testManager(t, provider)

validator/client/grpc-api/grpc_node_client.go

@@ -38,7 +38,7 @@ func (c *grpcNodeClient) IsReady(ctx context.Context) bool {
 	// otherwise it will throw an error
 	_, err := c.getClient().GetHealth(ctx, &ethpb.HealthRequest{})
 	if err != nil {
-		log.WithError(err).WithField("beaconNodeUrl", c.conn.GetGrpcConnectionProvider().CurrentHost()).Debug("Node is not ready")
+		log.WithError(err).Debug("Node is not ready")
 		return false
 	}
 	return true

validator/client/grpc-api/grpc_node_client_test.go

@@ -58,10 +58,10 @@ func TestGrpcNodeClient_IsReady(t *testing.T) {
 			// Create client with injected mock
 			client := &grpcNodeClient{
 				grpcClientManager: &grpcClientManager[ethpb.NodeClient]{
-					conn:            conn,
-					client:          mockNodeClient,
-					lastConnCounter: 0,
-					newClient:       func(grpc.ClientConnInterface) ethpb.NodeClient { return mockNodeClient },
+					conn:      conn,
+					client:    mockNodeClient,
+					lastHost:  "host1:4000",
+					newClient: func(grpc.ClientConnInterface) ethpb.NodeClient { return mockNodeClient },
 				},
 			}
 

validator/client/grpc-api/grpc_validator_client.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/api/client"
 	eventClient "github.com/OffchainLabs/prysm/v7/api/client/event"
-	"github.com/OffchainLabs/prysm/v7/api/failover"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -25,7 +24,6 @@ import (
 
 type grpcValidatorClient struct {
 	*grpcClientManager[ethpb.BeaconNodeValidatorClient]
-	nodeClient           *grpcNodeClient
 	isEventStreamRunning bool
 }
 
@@ -284,9 +282,6 @@ func (*grpcValidatorClient) AggregatedSyncSelections(context.Context, []iface.Sy
 func NewGrpcValidatorClient(conn validatorHelpers.NodeConnection) iface.ValidatorClient {
 	return &grpcValidatorClient{
 		grpcClientManager: newGrpcClientManager(conn, ethpb.NewBeaconNodeValidatorClient),
-		nodeClient: &grpcNodeClient{
-			grpcClientManager: newGrpcClientManager(conn, ethpb.NewNodeClient),
-		},
 	}
 }
 
@@ -387,7 +382,16 @@ func (c *grpcValidatorClient) Host() string {
 	return c.grpcClientManager.conn.GetGrpcConnectionProvider().CurrentHost()
 }
 
-func (c *grpcValidatorClient) EnsureReady(ctx context.Context) bool {
+func (c *grpcValidatorClient) SwitchHost(host string) {
 	provider := c.grpcClientManager.conn.GetGrpcConnectionProvider()
-	return failover.EnsureReady(ctx, provider, c.nodeClient)
+	// Find the index of the requested host and switch to it
+	for i, h := range provider.Hosts() {
+		if h == host {
+			if err := provider.SwitchHost(i); err != nil {
+				log.WithError(err).WithField("host", host).Error("Failed to set gRPC host")
+			}
+			return
+		}
+	}
+	log.WithField("host", host).Warn("Requested gRPC host not found in configured endpoints")
 }

validator/client/grpc-api/grpc_validator_client_test.go

@@ -8,14 +8,12 @@ import (
 	"time"
 
 	eventClient "github.com/OffchainLabs/prysm/v7/api/client/event"
-	grpcutil "github.com/OffchainLabs/prysm/v7/api/grpc"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/assert"
 	mock2 "github.com/OffchainLabs/prysm/v7/testing/mock"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
-	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	validatorTesting "github.com/OffchainLabs/prysm/v7/validator/testing"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 	"go.uber.org/mock/gomock"
@@ -255,94 +253,3 @@ func TestStartEventStream(t *testing.T) {
 		})
 	}
 }
-
-func TestEnsureReady(t *testing.T) {
-	tests := []struct {
-		name           string
-		hosts          []string
-		healthResults  []error // one per GetHealth call in order
-		expectedResult bool
-		expectedIndex  int // expected provider index after EnsureReady
-	}{
-		{
-			name:           "Single host ready",
-			hosts:          []string{"host1:4000"},
-			healthResults:  []error{nil},
-			expectedResult: true,
-			expectedIndex:  0,
-		},
-		{
-			name:           "Single host not ready",
-			hosts:          []string{"host1:4000"},
-			healthResults:  []error{errors.New("not synced")},
-			expectedResult: false,
-			expectedIndex:  0,
-		},
-		{
-			name:           "Multiple hosts first ready",
-			hosts:          []string{"host1:4000", "host2:4000", "host3:4000"},
-			healthResults:  []error{nil},
-			expectedResult: true,
-			expectedIndex:  0,
-		},
-		{
-			name:           "Failover to second host",
-			hosts:          []string{"host1:4000", "host2:4000", "host3:4000"},
-			healthResults:  []error{errors.New("not synced"), nil},
-			expectedResult: true,
-			expectedIndex:  1,
-		},
-		{
-			name:           "Failover to third host",
-			hosts:          []string{"host1:4000", "host2:4000", "host3:4000"},
-			healthResults:  []error{errors.New("not synced"), errors.New("not synced"), nil},
-			expectedResult: true,
-			expectedIndex:  2,
-		},
-		{
-			name:           "All hosts down",
-			hosts:          []string{"host1:4000", "host2:4000", "host3:4000"},
-			healthResults:  []error{errors.New("not synced"), errors.New("not synced"), errors.New("not synced")},
-			expectedResult: false,
-			expectedIndex:  2,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ctrl := gomock.NewController(t)
-
-			mockProvider := &grpcutil.MockGrpcProvider{
-				MockHosts: tt.hosts,
-			}
-			conn, err := validatorHelpers.NewNodeConnection(
-				validatorHelpers.WithGRPCProvider(mockProvider),
-			)
-			require.NoError(t, err)
-
-			mockNodeClient := mock2.NewMockNodeClient(ctrl)
-			for _, healthErr := range tt.healthResults {
-				if healthErr != nil {
-					mockNodeClient.EXPECT().GetHealth(gomock.Any(), gomock.Any()).Return(nil, healthErr)
-				} else {
-					mockNodeClient.EXPECT().GetHealth(gomock.Any(), gomock.Any()).Return(&emptypb.Empty{}, nil)
-				}
-			}
-
-			client := &grpcValidatorClient{
-				grpcClientManager: newGrpcClientManager(conn, func(_ grpc.ClientConnInterface) eth.BeaconNodeValidatorClient {
-					return mock2.NewMockBeaconNodeValidatorClient(ctrl)
-				}),
-				nodeClient: &grpcNodeClient{
-					grpcClientManager: newGrpcClientManager(conn, func(_ grpc.ClientConnInterface) eth.NodeClient {
-						return mockNodeClient
-					}),
-				},
-			}
-
-			result := client.EnsureReady(t.Context())
-			assert.Equal(t, tt.expectedResult, result)
-			assert.Equal(t, tt.expectedIndex, mockProvider.CurrentIndex)
-		})
-	}
-}

validator/client/health_monitor.go

@@ -49,39 +49,31 @@ func (m *healthMonitor) IsHealthy() bool {
 }
 
 func (m *healthMonitor) performHealthCheck() {
-	ishealthy := m.v.EnsureReady(m.ctx)
+	ishealthy := m.v.FindHealthyHost(m.ctx)
 	m.Lock()
 	defer m.Unlock()
 	if ishealthy {
 		m.fails = 0
 	} else if m.maxFails > 0 && m.fails < m.maxFails {
 		log.WithFields(logrus.Fields{
-			"fails":         m.fails,
-			"maxFails":      m.maxFails,
-			"beaconNodeUrl": m.v.Host(),
+			"fails":    m.fails,
+			"maxFails": m.maxFails,
 		}).Warn("Failed health check, beacon node is unresponsive")
 		m.fails++
 	} else if m.maxFails > 0 && m.fails >= m.maxFails {
-		log.WithFields(logrus.Fields{
-			"maxFails":      m.maxFails,
-			"beaconNodeUrl": m.v.Host(),
-		}).Warn("Maximum health checks reached. Stopping health check routine")
+		log.WithField("maxFails", m.maxFails).Warn("Maximum health checks reached. Stopping health check routine")
 		m.isHealthy = ishealthy
 		m.cancel()
 		return
 	}
 	if ishealthy == m.isHealthy {
 		// is not a new status so skip update
-		log.WithFields(logrus.Fields{
-			"isHealthy":     m.isHealthy,
-			"beaconNodeUrl": m.v.Host(),
-		}).Debug("Health status did not change")
+		log.WithField("isHealthy", m.isHealthy).Debug("Health status did not change")
 		return
 	}
 	log.WithFields(logrus.Fields{
-		"current":       ishealthy,
-		"previous":      m.isHealthy,
-		"beaconNodeUrl": m.v.Host(),
+		"healthy":    ishealthy,
+		"previously": m.isHealthy,
 	}).Info("Health status changed")
 	m.isHealthy = ishealthy
 	go m.healthEventFeed.Send(ishealthy) // non blocking send

validator/client/health_monitor_test.go

@@ -25,9 +25,8 @@ func TestHealthMonitor_IsHealthy_Concurrency(t *testing.T) {
 	parentCtx, parentCancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
 	t.Cleanup(parentCancel)
 
-	// Expectation for newHealthMonitor's EnsureReady call
-	mockValidator.EXPECT().EnsureReady(gomock.Any()).Return(true).Times(1)
-	mockValidator.EXPECT().Host().Return("http://localhost:3500").AnyTimes()
+	// Expectation for newHealthMonitor's FindHealthyHost call
+	mockValidator.EXPECT().FindHealthyHost(gomock.Any()).Return(true).Times(1)
 
 	monitor := newHealthMonitor(parentCtx, parentCancel, 3, mockValidator)
 	require.NotNil(t, monitor)
@@ -65,81 +64,81 @@ func TestHealthMonitor_PerformHealthCheck(t *testing.T) {
 	mockValidator := validatormock.NewMockValidator(ctrl)
 
 	tests := []struct {
-		expectStatusUpdate bool // true if healthyCh should receive a new, different status
-		expectCancelCalled bool
-		expectedIsHealthy  bool
-		ensureReadyReturns bool
-		initialIsHealthy   bool
-		expectedFails      int
-		maxFails           int
-		initialFails       int
-		name               string
+		expectStatusUpdate     bool // true if healthyCh should receive a new, different status
+		expectCancelCalled     bool
+		expectedIsHealthy      bool
+		findHealthyHostReturns bool
+		initialIsHealthy       bool
+		expectedFails          int
+		maxFails               int
+		initialFails           int
+		name                   string
 	}{
 		{
-			name:               "Becomes Unhealthy",
-			initialIsHealthy:   true,
-			initialFails:       0,
-			maxFails:           3,
-			ensureReadyReturns: false,
-			expectedIsHealthy:  false,
-			expectedFails:      1,
-			expectCancelCalled: false,
-			expectStatusUpdate: true,
+			name:                   "Becomes Unhealthy",
+			initialIsHealthy:       true,
+			initialFails:           0,
+			maxFails:               3,
+			findHealthyHostReturns: false,
+			expectedIsHealthy:      false,
+			expectedFails:          1,
+			expectCancelCalled:     false,
+			expectStatusUpdate:     true,
 		},
 		{
-			name:               "Becomes Healthy",
-			initialIsHealthy:   false,
-			initialFails:       1,
-			maxFails:           3,
-			ensureReadyReturns: true,
-			expectedIsHealthy:  true,
-			expectedFails:      0,
-			expectCancelCalled: false,
-			expectStatusUpdate: true,
+			name:                   "Becomes Healthy",
+			initialIsHealthy:       false,
+			initialFails:           1,
+			maxFails:               3,
+			findHealthyHostReturns: true,
+			expectedIsHealthy:      true,
+			expectedFails:          0,
+			expectCancelCalled:     false,
+			expectStatusUpdate:     true,
 		},
 		{
-			name:               "Remains Healthy",
-			initialIsHealthy:   true,
-			initialFails:       0,
-			maxFails:           3,
-			ensureReadyReturns: true,
-			expectedIsHealthy:  true,
-			expectedFails:      0,
-			expectCancelCalled: false,
-			expectStatusUpdate: false, // Status did not change
+			name:                   "Remains Healthy",
+			initialIsHealthy:       true,
+			initialFails:           0,
+			maxFails:               3,
+			findHealthyHostReturns: true,
+			expectedIsHealthy:      true,
+			expectedFails:          0,
+			expectCancelCalled:     false,
+			expectStatusUpdate:     false, // Status did not change
 		},
 		{
-			name:               "Remains Unhealthy",
-			initialIsHealthy:   false,
-			initialFails:       1,
-			maxFails:           3,
-			ensureReadyReturns: false,
-			expectedIsHealthy:  false,
-			expectedFails:      2,
-			expectCancelCalled: false,
-			expectStatusUpdate: false, // Status did not change
+			name:                   "Remains Unhealthy",
+			initialIsHealthy:       false,
+			initialFails:           1,
+			maxFails:               3,
+			findHealthyHostReturns: false,
+			expectedIsHealthy:      false,
+			expectedFails:          2,
+			expectCancelCalled:     false,
+			expectStatusUpdate:     false, // Status did not change
 		},
 		{
-			name:               "Max Fails Reached - Stays Unhealthy and Cancels",
-			initialIsHealthy:   false,
-			initialFails:       2, // One fail away from maxFails
-			maxFails:           2,
-			ensureReadyReturns: false,
-			expectedIsHealthy:  false,
-			expectedFails:      2,
-			expectCancelCalled: true,
-			expectStatusUpdate: false, // Status was already false, no new update sent before cancel
+			name:                   "Max Fails Reached - Stays Unhealthy and Cancels",
+			initialIsHealthy:       false,
+			initialFails:           2, // One fail away from maxFails
+			maxFails:               2,
+			findHealthyHostReturns: false,
+			expectedIsHealthy:      false,
+			expectedFails:          2,
+			expectCancelCalled:     true,
+			expectStatusUpdate:     false, // Status was already false, no new update sent before cancel
 		},
 		{
-			name:               "MaxFails is 0 - Remains Unhealthy, No Cancel",
-			initialIsHealthy:   false,
-			initialFails:       100, // Arbitrarily high
-			maxFails:           0,   // Infinite
-			ensureReadyReturns: false,
-			expectedIsHealthy:  false,
-			expectedFails:      100,
-			expectCancelCalled: false,
-			expectStatusUpdate: false,
+			name:                   "MaxFails is 0 - Remains Unhealthy, No Cancel",
+			initialIsHealthy:       false,
+			initialFails:           100, // Arbitrarily high
+			maxFails:               0,   // Infinite
+			findHealthyHostReturns: false,
+			expectedIsHealthy:      false,
+			expectedFails:          100,
+			expectCancelCalled:     false,
+			expectStatusUpdate:     false,
 		},
 	}
 
@@ -164,8 +163,7 @@ func TestHealthMonitor_PerformHealthCheck(t *testing.T) {
 			}
 			monitor.healthEventFeed.Subscribe(monitor.healthyCh)
 
-			mockValidator.EXPECT().EnsureReady(gomock.Any()).Return(tt.ensureReadyReturns)
-			mockValidator.EXPECT().Host().Return("http://localhost:3500").AnyTimes()
+			mockValidator.EXPECT().FindHealthyHost(gomock.Any()).Return(tt.findHealthyHostReturns)
 
 			monitor.performHealthCheck()
 
@@ -220,14 +218,12 @@ func TestHealthMonitor_HealthyChan_ReceivesUpdates(t *testing.T) {
 	ch := monitor.HealthyChan()
 	require.NotNil(t, ch)
 
-	mockValidator.EXPECT().Host().Return("http://localhost:3500").AnyTimes()
-
 	first := mockValidator.EXPECT().
-		EnsureReady(gomock.Any()).
+		FindHealthyHost(gomock.Any()).
 		Return(true).Times(1)
 
 	mockValidator.EXPECT().
-		EnsureReady(gomock.Any()).
+		FindHealthyHost(gomock.Any()).
 		Return(false).
 		AnyTimes().
 		After(first)

validator/client/iface/validator.go

@@ -69,7 +69,7 @@ type Validator interface {
 	SetGraffiti(ctx context.Context, pubKey [fieldparams.BLSPubkeyLength]byte, graffiti []byte) error
 	DeleteGraffiti(ctx context.Context, pubKey [fieldparams.BLSPubkeyLength]byte) error
 	Host() string
-	EnsureReady(ctx context.Context) bool
+	FindHealthyHost(ctx context.Context) bool
 	SetTicker()
 }
 

validator/client/iface/validator_client.go

@@ -152,5 +152,5 @@ type ValidatorClient interface {
 	AggregatedSelections(ctx context.Context, selections []BeaconCommitteeSelection) ([]BeaconCommitteeSelection, error)
 	AggregatedSyncSelections(ctx context.Context, selections []SyncCommitteeSelection) ([]SyncCommitteeSelection, error)
 	Host() string
-	EnsureReady(ctx context.Context) bool
+	SwitchHost(host string)
 }

validator/client/runner.go

@@ -94,7 +94,7 @@ func (r *runner) run(ctx context.Context) {
 			return // Exit if context is canceled.
 		case slot := <-v.NextSlot():
 			if !r.healthMonitor.IsHealthy() {
-				log.WithField("beaconNodeUrl", r.validator.Host()).Warn("Beacon node unhealthy, stopping runner")
+				log.Warn("Beacon node unhealthy, stopping runner")
 				return
 			}
 

validator/client/service.go

@@ -207,6 +207,7 @@ func (v *ValidatorService) Start() {
 		graffitiStruct:                 v.graffitiStruct,
 		graffitiOrderedIndex:           graffitiOrderedIndex,
 		conn:                           v.conn,
+		currentHostIndex:               0,
 		validatorClient:                validatorClient,
 		chainClient:                    beaconChainClientFactory.NewChainClient(v.conn),
 		nodeClient:                     nodeclientfactory.NewNodeClient(v.conn),
@@ -246,7 +247,7 @@ func (v *ValidatorService) Start() {
 		case isHealthy := <-hm.HealthyChan():
 			if !isHealthy {
 				// wait until the next health tracker update
-				log.WithField("beaconNodeUrl", v.validator.Host()).Warn("Validator service health check failed, waiting for healthy beacon node...")
+				log.Warn("Validator service health check failed, waiting for healthy beacon node...")
 				continue
 			}
 

validator/client/testutil/mock_validator.go

@@ -23,7 +23,7 @@ var _ iface.Validator = (*FakeValidator)(nil)
 
 // FakeValidator for mocking.
 type FakeValidator struct {
-	IsReady                           bool
+	CanChangeHost                     bool
 	LogValidatorGainsAndLossesCalled  bool
 	SaveProtectionsCalled             bool
 	DeleteProtectionCalled            bool
@@ -330,8 +330,8 @@ func (*FakeValidator) Host() string {
 	return "127.0.0.1:0"
 }
 
-func (fv *FakeValidator) EnsureReady(_ context.Context) bool {
-	return fv.IsReady
+func (fv *FakeValidator) FindHealthyHost(_ context.Context) bool {
+	return fv.CanChangeHost
 }
 
 func (fv *FakeValidator) SetTicker() {

validator/client/validator-client-factory/validator_client_factory.go

@@ -13,7 +13,7 @@ func NewValidatorClient(
 	opt ...beaconApi.ValidatorClientOpt,
 ) iface.ValidatorClient {
 	if features.Get().EnableBeaconRESTApi {
-		return beaconApi.NewBeaconApiValidatorClient(validatorConn.GetRestConnectionProvider(), opt...)
+		return beaconApi.NewBeaconApiValidatorClient(validatorConn.GetRestHandler(), opt...)
 	}
 	return grpcApi.NewGrpcValidatorClient(validatorConn)
 }

validator/client/validator.go

@@ -115,6 +115,7 @@ type validator struct {
 	km                                 keymanager.IKeymanager
 	accountChangedSub                  event.Subscription
 	ticker                             slots.Ticker
+	currentHostIndex                   uint64
 	genesisTime                        time.Time
 	graffiti                           []byte
 	voteStats                          voteStats
@@ -1310,8 +1311,65 @@ func (v *validator) Host() string {
 	return v.validatorClient.Host()
 }
 
-func (v *validator) EnsureReady(ctx context.Context) bool {
-	return v.validatorClient.EnsureReady(ctx)
+func (v *validator) changeHost() {
+	hosts := v.hosts()
+	if len(hosts) <= 1 {
+		return
+	}
+	next := (v.currentHostIndex + 1) % uint64(len(hosts))
+	log.WithFields(logrus.Fields{
+		"currentHost": hosts[v.currentHostIndex],
+		"nextHost":    hosts[next],
+	}).Warn("Beacon node is not responding, switching host")
+	v.validatorClient.SwitchHost(hosts[next])
+	v.currentHostIndex = next
+}
+
+// hosts returns the list of configured beacon node hosts.
+func (v *validator) hosts() []string {
+	if features.Get().EnableBeaconRESTApi {
+		return v.conn.GetRestConnectionProvider().Hosts()
+	}
+	return v.conn.GetGrpcConnectionProvider().Hosts()
+}
+
+// numHosts returns the number of configured beacon node hosts.
+func (v *validator) numHosts() int {
+	return len(v.hosts())
+}
+
+func (v *validator) FindHealthyHost(ctx context.Context) bool {
+	numHosts := v.numHosts()
+	startingHost := v.Host()
+	attemptedHosts := []string{}
+
+	// Check all hosts for a fully synced node
+	for i := range numHosts {
+		if v.nodeClient.IsReady(ctx) {
+			if len(attemptedHosts) > 0 {
+				log.WithFields(logrus.Fields{
+					"previousHost":   startingHost,
+					"newHost":        v.Host(),
+					"failedAttempts": attemptedHosts,
+				}).Info("Failover succeeded: connected to healthy beacon node")
+			}
+			return true
+		}
+		log.WithField("host", v.Host()).Debug("Beacon node not fully synced")
+		attemptedHosts = append(attemptedHosts, v.Host())
+
+		// Try next host if not the last iteration
+		if i < numHosts-1 {
+			v.changeHost()
+		}
+	}
+
+	if numHosts == 1 {
+		log.WithField("host", v.Host()).Warn("Beacon node is not fully synced, no backup node configured")
+	} else {
+		log.Warn("No fully synced beacon node found")
+	}
+	return false
 }
 
 func (v *validator) filterAndCacheActiveKeys(ctx context.Context, pubkeys [][fieldparams.BLSPubkeyLength]byte, slot primitives.Slot) ([][fieldparams.BLSPubkeyLength]byte, error) {

validator/client/validator_test.go

@@ -17,6 +17,7 @@ import (
 	"time"
 
 	grpcutil "github.com/OffchainLabs/prysm/v7/api/grpc"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/async/event"
 	"github.com/OffchainLabs/prysm/v7/cmd/validator/flags"
@@ -2793,6 +2794,34 @@ func TestValidator_Host(t *testing.T) {
 	require.Equal(t, "host", v.Host())
 }
 
+func TestValidator_ChangeHost(t *testing.T) {
+	// Enable REST API mode for this test since changeHost only calls SwitchHost in REST API mode
+	resetCfg := features.InitWithReset(&features.Flags{EnableBeaconRESTApi: true})
+	defer resetCfg()
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	hosts := []string{"http://localhost:8080", "http://localhost:8081"}
+	restProvider := &rest.MockRestProvider{MockHosts: hosts}
+	conn, err := validatorHelpers.NewNodeConnection(validatorHelpers.WithRestProvider(restProvider))
+	require.NoError(t, err)
+
+	client := validatormock.NewMockValidatorClient(ctrl)
+	v := validator{
+		validatorClient:  client,
+		conn:             conn,
+		currentHostIndex: 0,
+	}
+
+	client.EXPECT().SwitchHost(hosts[1])
+	client.EXPECT().SwitchHost(hosts[0])
+	v.changeHost()
+	assert.Equal(t, uint64(1), v.currentHostIndex)
+	v.changeHost()
+	assert.Equal(t, uint64(0), v.currentHostIndex)
+}
+
 func TestUpdateValidatorStatusCache(t *testing.T) {
 	ctx := t.Context()
 	ctrl := gomock.NewController(t)
@@ -2826,8 +2855,9 @@ func TestUpdateValidatorStatusCache(t *testing.T) {
 	require.NoError(t, err)
 
 	v := &validator{
-		validatorClient: client,
-		conn:            conn,
+		validatorClient:  client,
+		conn:             conn,
+		currentHostIndex: 0,
 		pubkeyToStatus: map[[fieldparams.BLSPubkeyLength]byte]*validatorStatus{
 			[fieldparams.BLSPubkeyLength]byte{0x03}: { // add non existent key and status to cache, should be fully removed on update
 				publicKey: []byte{0x03},

validator/helpers/node_connection.go

@@ -20,7 +20,7 @@ type NodeConnection interface {
 	GetRestConnectionProvider() rest.RestConnectionProvider
 	// GetRestHandler returns the REST handler for making API requests.
 	// Returns nil if no REST provider is configured.
-	GetRestHandler() rest.Handler
+	GetRestHandler() rest.RestHandler
 }
 
 type nodeConnection struct {
@@ -43,11 +43,11 @@ func (c *nodeConnection) GetRestConnectionProvider() rest.RestConnectionProvider
 	return c.restConnectionProvider
 }
 
-func (c *nodeConnection) GetRestHandler() rest.Handler {
+func (c *nodeConnection) GetRestHandler() rest.RestHandler {
 	if c.restConnectionProvider == nil {
 		return nil
 	}
-	return c.restConnectionProvider.Handler()
+	return c.restConnectionProvider.RestHandler()
 }
 
 // NodeConnectionOption is a functional option for configuring a NodeConnection.

validator/helpers/node_connection_test.go

@@ -42,7 +42,7 @@ func TestNewNodeConnection(t *testing.T) {
 
 		assert.Equal(t, grpcProvider, conn.GetGrpcConnectionProvider())
 		assert.Equal(t, (rest.RestConnectionProvider)(nil), conn.GetRestConnectionProvider())
-		assert.Equal(t, (rest.Handler)(nil), conn.GetRestHandler())
+		assert.Equal(t, (rest.RestHandler)(nil), conn.GetRestHandler())
 	})
 
 	t.Run("with no providers returns error", func(t *testing.T) {
@@ -84,7 +84,7 @@ func TestNodeConnection_GetGrpcClientConn(t *testing.T) {
 
 func TestNodeConnection_GetRestHandler(t *testing.T) {
 	t.Run("delegates to provider", func(t *testing.T) {
-		mockHandler := &rest.MockHandler{}
+		mockHandler := &rest.MockRestHandler{}
 		restProvider := &rest.MockRestProvider{MockHandler: mockHandler, MockHosts: []string{"http://localhost:3500"}}
 		conn, err := NewNodeConnection(WithRestProvider(restProvider))
 		require.NoError(t, err)
@@ -96,6 +96,6 @@ func TestNodeConnection_GetRestHandler(t *testing.T) {
 		grpcProvider := &grpcutil.MockGrpcProvider{MockHosts: []string{"localhost:4000"}}
 		conn, err := NewNodeConnection(WithGRPCProvider(grpcProvider))
 		require.NoError(t, err)
-		assert.Equal(t, (rest.Handler)(nil), conn.GetRestHandler())
+		assert.Equal(t, (rest.RestHandler)(nil), conn.GetRestHandler())
 	})
 }