changelog

**What type of PR is this?**

> Other

**What does this PR do? Why is it needed?**

**Which issues(s) does this PR fix?**

Follow up to #16311

**Other notes for review**

**Acknowledgements**

- [x] I have read
[CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md).
- [x] I have included a uniquely named [changelog fragment
file](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md#maintaining-changelogmd).
- [x] I have added a description with sufficient context for reviewers
to understand this PR.
- [x] I have tested that my changes work as expected and I added a
testing plan to the PR description (if applicable).

.github/workflows/go.yml

@@ -2,7 +2,7 @@ name: Go
 
 on:
   push:
-    branches: [ master ]
+    branches: [ master, develop ]
   pull_request:
     branches: [ '*' ]
   merge_group:

.golangci.yml

@@ -33,9 +33,8 @@ formatters:
     generated: lax
     paths:
       - validator/web/site_data.go
-      - .*_test.go
       - proto
       - tools/analyzers
       - third_party$
       - builtin$
-      - examples$
+      - examples$

api/failover/BUILD.bazel

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

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

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

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

@@ -3,13 +3,16 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "grpc_connection_provider.go",
         "grpcutils.go",
         "log.go",
+        "mock_grpc_provider.go",
         "parameters.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/api/grpc",
     visibility = ["//visibility:public"],
     deps = [
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//metadata:go_default_library",
@@ -18,12 +21,17 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = ["grpcutils_test.go"],
+    srcs = [
+        "grpc_connection_provider_test.go",
+        "grpcutils_test.go",
+    ],
     embed = [":go_default_library"],
     deps = [
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
+        "@org_golang_google_grpc//credentials/insecure:go_default_library",
         "@org_golang_google_grpc//metadata:go_default_library",
     ],
 )

api/grpc/grpc_connection_provider.go

@@ -0,0 +1,186 @@
+package grpc
+
+import (
+	"context"
+	"strings"
+	"sync"
+
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"google.golang.org/grpc"
+)
+
+// GrpcConnectionProvider manages gRPC connections for failover support.
+// It allows switching between different beacon node endpoints when the current one becomes unavailable.
+// Only one connection is maintained at a time - when switching hosts, the old connection is closed.
+type GrpcConnectionProvider interface {
+	// CurrentConn returns the currently active gRPC connection.
+	// The connection is created lazily on first call.
+	// Returns nil if the provider has been closed.
+	CurrentConn() *grpc.ClientConn
+	// CurrentHost returns the address of the currently active endpoint.
+	CurrentHost() string
+	// Hosts returns all configured endpoint addresses.
+	Hosts() []string
+	// 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()
+}
+
+type grpcConnectionProvider struct {
+	// Immutable after construction - no lock needed for reads
+	endpoints []string
+	ctx       context.Context
+	dialOpts  []grpc.DialOption
+
+	// Current connection state (protected by mutex)
+	currentIndex uint64
+	conn         *grpc.ClientConn
+	connCounter  uint64
+
+	mu     sync.Mutex
+	closed bool
+}
+
+// NewGrpcConnectionProvider creates a new connection provider that manages gRPC connections.
+// The endpoint parameter can be a comma-separated list of addresses (e.g., "host1:4000,host2:4000").
+// Only one connection is maintained at a time, created lazily on first use.
+func NewGrpcConnectionProvider(
+	ctx context.Context,
+	endpoint string,
+	dialOpts []grpc.DialOption,
+) (GrpcConnectionProvider, error) {
+	endpoints := parseEndpoints(endpoint)
+	if len(endpoints) == 0 {
+		return nil, errors.New("no gRPC endpoints provided")
+	}
+
+	log.WithFields(logrus.Fields{
+		"endpoints": endpoints,
+		"count":     len(endpoints),
+	}).Info("Initialized gRPC connection provider")
+
+	return &grpcConnectionProvider{
+		endpoints: endpoints,
+		ctx:       ctx,
+		dialOpts:  dialOpts,
+	}, nil
+}
+
+// parseEndpoints splits a comma-separated endpoint string into individual endpoints.
+func parseEndpoints(endpoint string) []string {
+	if endpoint == "" {
+		return nil
+	}
+	endpoints := make([]string, 0, 1)
+	for p := range strings.SplitSeq(endpoint, ",") {
+		if p = strings.TrimSpace(p); p != "" {
+			endpoints = append(endpoints, p)
+		}
+	}
+	return endpoints
+}
+
+func (p *grpcConnectionProvider) CurrentConn() *grpc.ClientConn {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.closed {
+		return nil
+	}
+
+	// Return existing connection if available
+	if p.conn != nil {
+		return p.conn
+	}
+
+	// Create connection lazily
+	ep := p.endpoints[p.currentIndex]
+	conn, err := grpc.DialContext(p.ctx, ep, p.dialOpts...)
+	if err != nil {
+		log.WithError(err).WithField("endpoint", ep).Error("Failed to create gRPC connection")
+		return nil
+	}
+
+	p.conn = conn
+	log.WithField("endpoint", ep).Debug("Created gRPC connection")
+	return conn
+}
+
+func (p *grpcConnectionProvider) CurrentHost() string {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return p.endpoints[p.currentIndex]
+}
+
+func (p *grpcConnectionProvider) Hosts() []string {
+	// Return a copy to maintain immutability
+	hosts := make([]string, len(p.endpoints))
+	copy(hosts, p.endpoints)
+	return hosts
+}
+
+func (p *grpcConnectionProvider) SwitchHost(index int) error {
+	if index < 0 || index >= len(p.endpoints) {
+		return errors.Errorf("invalid host index %d, must be between 0 and %d", index, len(p.endpoints)-1)
+	}
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if uint64(index) == p.currentIndex {
+		return nil // Already on this host
+	}
+
+	oldHost := p.endpoints[p.currentIndex]
+	oldConn := p.conn
+
+	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 {
+		go func() {
+			if err := oldConn.Close(); err != nil {
+				log.WithError(err).WithField("endpoint", oldHost).Debug("Failed to close previous connection")
+			}
+		}()
+	}
+
+	log.WithFields(logrus.Fields{
+		"previousHost": oldHost,
+		"newHost":      p.endpoints[index],
+	}).Debug("Switched gRPC endpoint")
+	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()
+
+	if p.closed {
+		return
+	}
+	p.closed = true
+
+	if p.conn != nil {
+		if err := p.conn.Close(); err != nil {
+			log.WithError(err).WithField("endpoint", p.endpoints[p.currentIndex]).Debug("Failed to close gRPC connection")
+		}
+		p.conn = nil
+	}
+}

api/grpc/grpc_connection_provider_test.go

@@ -0,0 +1,207 @@
+package grpc
+
+import (
+	"context"
+	"net"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+func TestParseEndpoints(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{"single endpoint", "localhost:4000", []string{"localhost:4000"}},
+		{"multiple endpoints", "host1:4000,host2:4000,host3:4000", []string{"host1:4000", "host2:4000", "host3:4000"}},
+		{"endpoints with spaces", "host1:4000, host2:4000 , host3:4000", []string{"host1:4000", "host2:4000", "host3:4000"}},
+		{"empty string", "", nil},
+		{"only commas", ",,,", []string{}},
+		{"trailing comma", "host1:4000,host2:4000,", []string{"host1:4000", "host2:4000"}},
+		{"leading comma", ",host1:4000,host2:4000", []string{"host1:4000", "host2:4000"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseEndpoints(tt.input)
+			if !reflect.DeepEqual(tt.expected, got) {
+				t.Errorf("parseEndpoints(%q) = %v, want %v", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestNewGrpcConnectionProvider_Errors(t *testing.T) {
+	t.Run("no endpoints", func(t *testing.T) {
+		dialOpts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
+		_, err := NewGrpcConnectionProvider(context.Background(), "", dialOpts)
+		require.ErrorContains(t, "no gRPC endpoints provided", err)
+	})
+}
+
+func TestGrpcConnectionProvider_LazyConnection(t *testing.T) {
+	// Start only one server but configure provider with two endpoints
+	lis, err := net.Listen("tcp", "127.0.0.1:0")
+	require.NoError(t, err)
+	server := grpc.NewServer()
+	go func() { _ = server.Serve(lis) }()
+	defer server.Stop()
+
+	validAddr := lis.Addr().String()
+	invalidAddr := "127.0.0.1:1" // Port 1 is unlikely to be listening
+
+	// Provider should succeed even though second endpoint is invalid (lazy connections)
+	endpoint := validAddr + "," + invalidAddr
+	ctx := context.Background()
+	dialOpts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
+	provider, err := NewGrpcConnectionProvider(ctx, endpoint, dialOpts)
+	require.NoError(t, err, "Provider creation should succeed with lazy connections")
+	defer func() { provider.Close() }()
+
+	// First endpoint should work
+	conn := provider.CurrentConn()
+	assert.NotNil(t, conn, "First connection should be created lazily")
+}
+
+func TestGrpcConnectionProvider_SingleConnectionModel(t *testing.T) {
+	// Create provider with 3 endpoints
+	var addrs []string
+	var servers []*grpc.Server
+
+	for range 3 {
+		lis, err := net.Listen("tcp", "127.0.0.1:0")
+		require.NoError(t, err)
+		server := grpc.NewServer()
+		go func() { _ = server.Serve(lis) }()
+		addrs = append(addrs, lis.Addr().String())
+		servers = append(servers, server)
+	}
+	defer func() {
+		for _, s := range servers {
+			s.Stop()
+		}
+	}()
+
+	endpoint := strings.Join(addrs, ",")
+	ctx := context.Background()
+	dialOpts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
+	provider, err := NewGrpcConnectionProvider(ctx, endpoint, dialOpts)
+	require.NoError(t, err)
+	defer func() { provider.Close() }()
+
+	// Access the internal state to verify single connection behavior
+	p := provider.(*grpcConnectionProvider)
+
+	// Initially no connection
+	p.mu.Lock()
+	assert.Equal(t, (*grpc.ClientConn)(nil), p.conn, "Connection should be nil before access")
+	p.mu.Unlock()
+
+	// Access connection - should create one
+	conn0 := provider.CurrentConn()
+	assert.NotNil(t, conn0)
+
+	p.mu.Lock()
+	assert.NotNil(t, p.conn, "Connection should be created after CurrentConn()")
+	firstConn := p.conn
+	p.mu.Unlock()
+
+	// Call CurrentConn again - should return same connection
+	conn0Again := provider.CurrentConn()
+	assert.Equal(t, conn0, conn0Again, "Should return same connection")
+
+	// Switch to different host - old connection should be closed, new one created lazily
+	require.NoError(t, provider.SwitchHost(1))
+
+	p.mu.Lock()
+	assert.Equal(t, (*grpc.ClientConn)(nil), p.conn, "Connection should be nil after SwitchHost (lazy)")
+	p.mu.Unlock()
+
+	// Get new connection
+	conn1 := provider.CurrentConn()
+	assert.NotNil(t, conn1)
+	assert.NotEqual(t, firstConn, conn1, "Should be a different connection after switching hosts")
+}
+
+// testProvider creates a provider with n test servers and returns cleanup function.
+func testProvider(t *testing.T, n int) (GrpcConnectionProvider, []string, func()) {
+	var addrs []string
+	var cleanups []func()
+
+	for range n {
+		lis, err := net.Listen("tcp", "127.0.0.1:0")
+		require.NoError(t, err)
+		server := grpc.NewServer()
+		go func() { _ = server.Serve(lis) }()
+		addrs = append(addrs, lis.Addr().String())
+		cleanups = append(cleanups, server.Stop)
+	}
+
+	endpoint := strings.Join(addrs, ",")
+
+	ctx := context.Background()
+	dialOpts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
+	provider, err := NewGrpcConnectionProvider(ctx, endpoint, dialOpts)
+	require.NoError(t, err)
+
+	cleanup := func() {
+		provider.Close()
+		for _, c := range cleanups {
+			c()
+		}
+	}
+	return provider, addrs, cleanup
+}
+
+func TestGrpcConnectionProvider(t *testing.T) {
+	provider, addrs, cleanup := testProvider(t, 3)
+	defer cleanup()
+
+	t.Run("initial state", func(t *testing.T) {
+		assert.Equal(t, 3, len(provider.Hosts()))
+		assert.Equal(t, addrs[0], provider.CurrentHost())
+		assert.NotNil(t, provider.CurrentConn())
+	})
+
+	t.Run("SwitchHost", func(t *testing.T) {
+		require.NoError(t, provider.SwitchHost(1))
+		assert.Equal(t, addrs[1], provider.CurrentHost())
+		assert.NotNil(t, provider.CurrentConn()) // New connection created lazily
+		require.NoError(t, provider.SwitchHost(0))
+		assert.Equal(t, addrs[0], provider.CurrentHost())
+		require.ErrorContains(t, "invalid host index", provider.SwitchHost(-1))
+		require.ErrorContains(t, "invalid host index", provider.SwitchHost(3))
+	})
+
+	t.Run("SwitchHost circular", func(t *testing.T) {
+		// Test round-robin style switching using SwitchHost with manual index
+		indices := []int{1, 2, 0, 1} // Simulate circular switching
+		for i, idx := range indices {
+			require.NoError(t, provider.SwitchHost(idx))
+			assert.Equal(t, addrs[idx], provider.CurrentHost(), "iteration %d", i)
+		}
+	})
+
+	t.Run("Hosts returns copy", func(t *testing.T) {
+		hosts := provider.Hosts()
+		original := hosts[0]
+		hosts[0] = "modified"
+		assert.Equal(t, original, provider.Hosts()[0])
+	})
+}
+
+func TestGrpcConnectionProvider_Close(t *testing.T) {
+	provider, _, cleanup := testProvider(t, 1)
+	defer cleanup()
+
+	assert.NotNil(t, provider.CurrentConn())
+	provider.Close()
+	assert.Equal(t, (*grpc.ClientConn)(nil), provider.CurrentConn())
+	provider.Close() // Double close is safe
+}

api/grpc/mock_grpc_provider.go

@@ -0,0 +1,27 @@
+package grpc
+
+import "google.golang.org/grpc"
+
+// MockGrpcProvider implements GrpcConnectionProvider for testing.
+type MockGrpcProvider struct {
+	MockConn     *grpc.ClientConn
+	MockHosts    []string
+	CurrentIndex int
+	ConnCounter  uint64
+}
+
+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 ""
+}
+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()                    {}

api/rest/BUILD.bazel

@@ -0,0 +1,34 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "log.go",
+        "mock_rest_provider.go",
+        "rest_connection_provider.go",
+        "rest_handler.go",
+    ],
+    importpath = "github.com/OffchainLabs/prysm/v7/api/rest",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api:go_default_library",
+        "//api/apiutil:go_default_library",
+        "//api/client:go_default_library",
+        "//config/params:go_default_library",
+        "//network/httputil:go_default_library",
+        "//runtime/version:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opentelemetry_go_contrib_instrumentation_net_http_otelhttp//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["rest_connection_provider_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+    ],
+)

api/rest/log.go

@@ -0,0 +1,9 @@
+// Code generated by hack/gen-logs.sh; DO NOT EDIT.
+// This file is created and regenerated automatically. Anything added here might get removed.
+package rest
+
+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/rest")

api/rest/mock_rest_provider.go

@@ -0,0 +1,46 @@
+package rest
+
+import (
+	"bytes"
+	"context"
+	"net/http"
+)
+
+// MockRestProvider implements RestConnectionProvider for testing.
+type MockRestProvider struct {
+	MockClient  *http.Client
+	MockHandler Handler
+	MockHosts   []string
+	HostIndex   int
+}
+
+func (m *MockRestProvider) HttpClient() *http.Client { return m.MockClient }
+func (m *MockRestProvider) Handler() Handler         { return m.MockHandler }
+func (m *MockRestProvider) CurrentHost() string {
+	if len(m.MockHosts) > 0 {
+		return m.MockHosts[m.HostIndex%len(m.MockHosts)]
+	}
+	return ""
+}
+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
+}
+
+func (m *MockHandler) Get(_ context.Context, _ string, _ any) error { return nil }
+func (m *MockHandler) GetStatusCode(_ context.Context, _ string) (int, error) {
+	return http.StatusOK, nil
+}
+func (m *MockHandler) 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 {
+	return nil
+}
+func (m *MockHandler) 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 }

api/rest/rest_connection_provider.go

@@ -0,0 +1,158 @@
+package rest
+
+import (
+	"net/http"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v7/api/client"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+)
+
+// RestConnectionProvider manages HTTP client configuration for REST API with failover support.
+// It allows switching between different beacon node REST endpoints when the current one becomes unavailable.
+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
+	// CurrentHost returns the current REST API endpoint URL.
+	CurrentHost() string
+	// Hosts returns all configured REST API endpoint URLs.
+	Hosts() []string
+	// SwitchHost switches to the endpoint at the given index.
+	SwitchHost(index int) error
+}
+
+// RestConnectionProviderOption is a functional option for configuring the REST connection provider.
+type RestConnectionProviderOption func(*restConnectionProvider)
+
+// WithHttpTimeout sets the HTTP client timeout.
+func WithHttpTimeout(timeout time.Duration) RestConnectionProviderOption {
+	return func(p *restConnectionProvider) {
+		p.timeout = timeout
+	}
+}
+
+// WithHttpHeaders sets custom HTTP headers to include in all requests.
+func WithHttpHeaders(headers map[string][]string) RestConnectionProviderOption {
+	return func(p *restConnectionProvider) {
+		p.headers = headers
+	}
+}
+
+// WithTracing enables OpenTelemetry tracing for HTTP requests.
+func WithTracing() RestConnectionProviderOption {
+	return func(p *restConnectionProvider) {
+		p.enableTracing = true
+	}
+}
+
+type restConnectionProvider struct {
+	endpoints     []string
+	httpClient    *http.Client
+	restHandler   *handler
+	currentIndex  atomic.Uint64
+	timeout       time.Duration
+	headers       map[string][]string
+	enableTracing bool
+}
+
+// NewRestConnectionProvider creates a new REST connection provider that manages HTTP client configuration.
+// The endpoint parameter can be a comma-separated list of URLs (e.g., "http://host1:3500,http://host2:3500").
+func NewRestConnectionProvider(endpoint string, opts ...RestConnectionProviderOption) (RestConnectionProvider, error) {
+	endpoints := parseEndpoints(endpoint)
+	if len(endpoints) == 0 {
+		return nil, errors.New("no REST API endpoints provided")
+	}
+
+	p := &restConnectionProvider{
+		endpoints: endpoints,
+	}
+
+	for _, opt := range opts {
+		opt(p)
+	}
+
+	// Build the HTTP transport chain
+	var transport http.RoundTripper = http.DefaultTransport
+
+	// Add custom headers if configured
+	if len(p.headers) > 0 {
+		transport = client.NewCustomHeadersTransport(transport, p.headers)
+	}
+
+	// Add tracing if enabled
+	if p.enableTracing {
+		transport = otelhttp.NewTransport(transport)
+	}
+
+	p.httpClient = &http.Client{
+		Timeout:   p.timeout,
+		Transport: transport,
+	}
+
+	// Create the REST handler with the HTTP client and initial host
+	p.restHandler = newHandler(*p.httpClient, endpoints[0])
+
+	log.WithFields(logrus.Fields{
+		"endpoints": endpoints,
+		"count":     len(endpoints),
+	}).Info("Initialized REST connection provider")
+
+	return p, nil
+}
+
+// parseEndpoints splits a comma-separated endpoint string into individual endpoints.
+func parseEndpoints(endpoint string) []string {
+	if endpoint == "" {
+		return nil
+	}
+	endpoints := make([]string, 0, 1)
+	for p := range strings.SplitSeq(endpoint, ",") {
+		if p = strings.TrimSpace(p); p != "" {
+			endpoints = append(endpoints, p)
+		}
+	}
+	return endpoints
+}
+
+func (p *restConnectionProvider) HttpClient() *http.Client {
+	return p.httpClient
+}
+
+func (p *restConnectionProvider) Handler() Handler {
+	return p.restHandler
+}
+
+func (p *restConnectionProvider) CurrentHost() string {
+	return p.endpoints[p.currentIndex.Load()]
+}
+
+func (p *restConnectionProvider) Hosts() []string {
+	// Return a copy to maintain immutability
+	hosts := make([]string, len(p.endpoints))
+	copy(hosts, p.endpoints)
+	return hosts
+}
+
+func (p *restConnectionProvider) SwitchHost(index int) error {
+	if index < 0 || index >= len(p.endpoints) {
+		return errors.Errorf("invalid host index %d, must be between 0 and %d", index, len(p.endpoints)-1)
+	}
+
+	oldIdx := p.currentIndex.Load()
+	p.currentIndex.Store(uint64(index))
+
+	// Update the rest handler's host
+	p.restHandler.SwitchHost(p.endpoints[index])
+
+	log.WithFields(logrus.Fields{
+		"previousHost": p.endpoints[oldIdx],
+		"newHost":      p.endpoints[index],
+	}).Debug("Switched REST endpoint")
+	return nil
+}

api/rest/rest_connection_provider_test.go

@@ -0,0 +1,80 @@
+package rest
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func TestParseEndpoints(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{"single endpoint", "http://localhost:3500", []string{"http://localhost:3500"}},
+		{"multiple endpoints", "http://host1:3500,http://host2:3500,http://host3:3500", []string{"http://host1:3500", "http://host2:3500", "http://host3:3500"}},
+		{"endpoints with spaces", "http://host1:3500, http://host2:3500 , http://host3:3500", []string{"http://host1:3500", "http://host2:3500", "http://host3:3500"}},
+		{"empty string", "", nil},
+		{"only commas", ",,,", []string{}},
+		{"trailing comma", "http://host1:3500,http://host2:3500,", []string{"http://host1:3500", "http://host2:3500"}},
+		{"leading comma", ",http://host1:3500,http://host2:3500", []string{"http://host1:3500", "http://host2:3500"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseEndpoints(tt.input)
+			if !reflect.DeepEqual(tt.expected, got) {
+				t.Errorf("parseEndpoints(%q) = %v, want %v", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestNewRestConnectionProvider_Errors(t *testing.T) {
+	t.Run("no endpoints", func(t *testing.T) {
+		_, err := NewRestConnectionProvider("")
+		require.ErrorContains(t, "no REST API endpoints provided", err)
+	})
+}
+
+func TestRestConnectionProvider(t *testing.T) {
+	provider, err := NewRestConnectionProvider("http://host1:3500,http://host2:3500,http://host3:3500")
+	require.NoError(t, err)
+
+	t.Run("initial state", func(t *testing.T) {
+		assert.Equal(t, 3, len(provider.Hosts()))
+		assert.Equal(t, "http://host1:3500", provider.CurrentHost())
+		assert.NotNil(t, provider.HttpClient())
+	})
+
+	t.Run("SwitchHost", func(t *testing.T) {
+		require.NoError(t, provider.SwitchHost(1))
+		assert.Equal(t, "http://host2:3500", provider.CurrentHost())
+		require.NoError(t, provider.SwitchHost(0))
+		assert.Equal(t, "http://host1:3500", provider.CurrentHost())
+		require.ErrorContains(t, "invalid host index", provider.SwitchHost(-1))
+		require.ErrorContains(t, "invalid host index", provider.SwitchHost(3))
+	})
+
+	t.Run("Hosts returns copy", func(t *testing.T) {
+		hosts := provider.Hosts()
+		original := hosts[0]
+		hosts[0] = "modified"
+		assert.Equal(t, original, provider.Hosts()[0])
+	})
+}
+
+func TestRestConnectionProvider_WithOptions(t *testing.T) {
+	headers := map[string][]string{"Authorization": {"Bearer token"}}
+	provider, err := NewRestConnectionProvider(
+		"http://localhost:3500",
+		WithHttpHeaders(headers),
+		WithHttpTimeout(30000000000), // 30 seconds in nanoseconds
+		WithTracing(),
+	)
+	require.NoError(t, err)
+	assert.NotNil(t, provider.HttpClient())
+	assert.Equal(t, "http://localhost:3500", provider.CurrentHost())
+}

api/rest/rest_handler.go

@@ -1,4 +1,4 @@
-package beacon_api
+package rest
 
 import (
 	"bytes"
@@ -21,37 +21,46 @@ import (
 
 type reqOption func(*http.Request)
 
-type RestHandler interface {
+// Handler defines the interface for making REST API requests.
+type Handler 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
-	SetHost(host string)
 }
 
-type BeaconApiRestHandler struct {
+type handler struct {
 	client       http.Client
 	host         string
 	reqOverrides []reqOption
 }
 
-// NewBeaconApiRestHandler returns a RestHandler
-func NewBeaconApiRestHandler(client http.Client, host string) RestHandler {
-	brh := &BeaconApiRestHandler{
+// 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,
 	}
-	brh.appendAcceptOverride()
-	return brh
+	rh.appendAcceptOverride()
+	return rh
+}
+
+// NewHandler returns a Handler
+func NewHandler(client http.Client, host string) Handler {
+	rh := &handler{
+		client: client,
+		host:   host,
+	}
+	rh.appendAcceptOverride()
+	return rh
 }
 
 // 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 *BeaconApiRestHandler) appendAcceptOverride() {
+func (c *handler) appendAcceptOverride() {
 	if accept := os.Getenv(params.EnvNameOverrideAccept); accept != "" {
 		c.reqOverrides = append(c.reqOverrides, func(req *http.Request) {
 			req.Header.Set("Accept", accept)
@@ -60,18 +69,18 @@ func (c *BeaconApiRestHandler) appendAcceptOverride() {
 }
 
 // HttpClient returns the underlying HTTP client of the handler
-func (c *BeaconApiRestHandler) HttpClient() *http.Client {
+func (c *handler) HttpClient() *http.Client {
 	return &c.client
 }
 
 // Host returns the underlying HTTP host
-func (c *BeaconApiRestHandler) Host() string {
+func (c *handler) 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 *BeaconApiRestHandler) Get(ctx context.Context, endpoint string, resp any) error {
+func (c *handler) 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 {
@@ -94,7 +103,7 @@ func (c *BeaconApiRestHandler) Get(ctx context.Context, endpoint string, resp an
 // 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 *BeaconApiRestHandler) GetStatusCode(ctx context.Context, endpoint string) (int, error) {
+func (c *handler) GetStatusCode(ctx context.Context, endpoint string) (int, error) {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -113,7 +122,7 @@ func (c *BeaconApiRestHandler) GetStatusCode(ctx context.Context, endpoint strin
 	return httpResp.StatusCode, nil
 }
 
-func (c *BeaconApiRestHandler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
+func (c *handler) 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 {
@@ -168,7 +177,7 @@ func (c *BeaconApiRestHandler) GetSSZ(ctx context.Context, endpoint string) ([]b
 
 // 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 *BeaconApiRestHandler) Post(
+func (c *handler) Post(
 	ctx context.Context,
 	apiEndpoint string,
 	headers map[string]string,
@@ -204,7 +213,7 @@ func (c *BeaconApiRestHandler) Post(
 }
 
 // PostSSZ sends a POST request and prefers an SSZ (application/octet-stream) response body.
-func (c *BeaconApiRestHandler) PostSSZ(
+func (c *handler) PostSSZ(
 	ctx context.Context,
 	apiEndpoint string,
 	headers map[string]string,
@@ -305,6 +314,6 @@ func decodeResp(httpResp *http.Response, resp any) error {
 	return nil
 }
 
-func (c *BeaconApiRestHandler) SetHost(host string) {
+func (c *handler) SwitchHost(host string) {
 	c.host = host
 }

beacon-chain/core/gloas/payload_attestation.go

@@ -114,17 +114,32 @@ func payloadCommittee(ctx context.Context, st state.ReadOnlyBeaconState, slot pr
 	}
 
 	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
-	out := make([]primitives.ValidatorIndex, 0, activeCount/uint64(params.BeaconConfig().SlotsPerEpoch))
 
-	for i := primitives.CommitteeIndex(0); i < primitives.CommitteeIndex(committeesPerSlot); i++ {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, st, slot, i)
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to get beacon committee %d", i)
+	selected := make([]primitives.ValidatorIndex, 0, fieldparams.PTCSize)
+	var i uint64
+	for uint64(len(selected)) < fieldparams.PTCSize {
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
+
+		for committeeIndex := primitives.CommitteeIndex(0); committeeIndex < primitives.CommitteeIndex(committeesPerSlot); committeeIndex++ {
+			if uint64(len(selected)) >= fieldparams.PTCSize {
+				break
+			}
+
+			committee, err := helpers.BeaconCommitteeFromState(ctx, st, slot, committeeIndex)
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed to get beacon committee %d", committeeIndex)
+			}
+
+			selected, i, err = selectByBalanceFill(ctx, st, committee, seed, selected, i)
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed to sample beacon committee %d", committeeIndex)
+			}
 		}
-		out = append(out, committee...)
 	}
 
-	return selectByBalance(ctx, st, out, seed, fieldparams.PTCSize)
+	return selected, nil
 }
 
 // ptcSeed computes the seed for the payload timeliness committee.
@@ -148,33 +163,39 @@ func ptcSeed(st state.ReadOnlyBeaconState, epoch primitives.Epoch, slot primitiv
 //	  if compute_balance_weighted_acceptance(state, indices[next], seed, i):
 //	    selected.append(indices[next])
 //	  i += 1
-func selectByBalance(ctx context.Context, st state.ReadOnlyBeaconState, candidates []primitives.ValidatorIndex, seed [32]byte, count uint64) ([]primitives.ValidatorIndex, error) {
-	if len(candidates) == 0 {
-		return nil, errors.New("no candidates for balance weighted selection")
-	}
-
+func selectByBalanceFill(
+	ctx context.Context,
+	st state.ReadOnlyBeaconState,
+	candidates []primitives.ValidatorIndex,
+	seed [32]byte,
+	selected []primitives.ValidatorIndex,
+	i uint64,
+) ([]primitives.ValidatorIndex, uint64, error) {
 	hashFunc := hash.CustomSHA256Hasher()
 	// Pre-allocate buffer for hash input: seed (32 bytes) + round counter (8 bytes).
 	var buf [40]byte
 	copy(buf[:], seed[:])
 	maxBalance := params.BeaconConfig().MaxEffectiveBalanceElectra
 
-	selected := make([]primitives.ValidatorIndex, 0, count)
-	total := uint64(len(candidates))
-	for i := uint64(0); uint64(len(selected)) < count; i++ {
+	for _, idx := range candidates {
 		if ctx.Err() != nil {
-			return nil, ctx.Err()
+			return nil, i, ctx.Err()
 		}
-		idx := candidates[i%total]
+
 		ok, err := acceptByBalance(st, idx, buf[:], hashFunc, maxBalance, i)
 		if err != nil {
-			return nil, err
+			return nil, i, err
 		}
 		if ok {
 			selected = append(selected, idx)
 		}
+		if uint64(len(selected)) == fieldparams.PTCSize {
+			break
+		}
+		i++
 	}
-	return selected, nil
+
+	return selected, i, nil
 }
 
 // acceptByBalance determines if a validator is accepted based on its effective balance.

beacon-chain/rpc/endpoints.go

@@ -575,7 +575,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".PublishBlockV2",
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.PublishBlockV2,
@@ -586,7 +586,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".PublishBlindedBlockV2",
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
 				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.PublishBlindedBlockV2,

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

@@ -48,6 +48,7 @@ go_test(
         "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
+        "@org_golang_google_grpc//metadata:go_default_library",
         "@org_golang_google_grpc//reflection:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",

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

@@ -35,18 +35,19 @@ import (
 // providing RPC endpoints for verifying a beacon node's sync status, genesis and
 // version information, and services the node implements and runs.
 type Server struct {
-	LogsStreamer         logs.Streamer
-	StreamLogsBufferSize int
-	SyncChecker          sync.Checker
-	Server               *grpc.Server
-	BeaconDB             db.ReadOnlyDatabase
-	PeersFetcher         p2p.PeersProvider
-	PeerManager          p2p.PeerManager
-	GenesisTimeFetcher   blockchain.TimeFetcher
-	GenesisFetcher       blockchain.GenesisFetcher
-	POWChainInfoFetcher  execution.ChainInfoFetcher
-	BeaconMonitoringHost string
-	BeaconMonitoringPort int
+	LogsStreamer          logs.Streamer
+	StreamLogsBufferSize  int
+	SyncChecker           sync.Checker
+	Server                *grpc.Server
+	BeaconDB              db.ReadOnlyDatabase
+	PeersFetcher          p2p.PeersProvider
+	PeerManager           p2p.PeerManager
+	GenesisTimeFetcher    blockchain.TimeFetcher
+	GenesisFetcher        blockchain.GenesisFetcher
+	POWChainInfoFetcher   execution.ChainInfoFetcher
+	BeaconMonitoringHost  string
+	BeaconMonitoringPort  int
+	OptimisticModeFetcher blockchain.OptimisticModeFetcher
 }
 
 // Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
@@ -61,21 +62,28 @@ func (ns *Server) GetHealth(ctx context.Context, request *ethpb.HealthRequest) (
 	ctx, cancel := context.WithTimeout(ctx, timeoutDuration)
 	defer cancel() // Important to avoid a context leak
 
-	if ns.SyncChecker.Synced() {
+	// Check optimistic status - validators should not participate when optimistic
+	isOptimistic, err := ns.OptimisticModeFetcher.IsOptimistic(ctx)
+	if err != nil {
+		return &empty.Empty{}, status.Errorf(codes.Internal, "Could not check optimistic status: %v", err)
+	}
+
+	if ns.SyncChecker.Synced() && !isOptimistic {
 		return &empty.Empty{}, nil
 	}
 	if ns.SyncChecker.Syncing() || ns.SyncChecker.Initialized() {
-		if request.SyncingStatus != 0 {
-			// override the 200 success with the provided request status
-			if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(request.SyncingStatus, 10))); err != nil {
-				return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
-			}
-			return &empty.Empty{}, nil
-		}
+		// Set header for REST API clients (via gRPC-gateway)
 		if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(http.StatusPartialContent, 10))); err != nil {
-			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
+			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set status code header: %v", err)
 		}
-		return &empty.Empty{}, nil
+		return &empty.Empty{}, status.Error(codes.Unavailable, "node is syncing")
+	}
+	if isOptimistic {
+		// Set header for REST API clients (via gRPC-gateway)
+		if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(http.StatusPartialContent, 10))); err != nil {
+			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set status code header: %v", err)
+		}
+		return &empty.Empty{}, status.Error(codes.Unavailable, "node is optimistic")
 	}
 	return &empty.Empty{}, status.Errorf(codes.Unavailable, "service unavailable")
 }

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

@@ -2,6 +2,7 @@ package node
 
 import (
 	"errors"
+	"maps"
 	"testing"
 	"time"
 
@@ -21,6 +22,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/reflection"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -187,32 +189,71 @@ func TestNodeServer_GetETH1ConnectionStatus(t *testing.T) {
 	assert.Equal(t, errStr, res.CurrentConnectionError)
 }
 
+// mockServerTransportStream implements grpc.ServerTransportStream for testing
+type mockServerTransportStream struct {
+	headers map[string][]string
+}
+
+func (m *mockServerTransportStream) Method() string { return "" }
+func (m *mockServerTransportStream) SetHeader(md metadata.MD) error {
+	maps.Copy(m.headers, md)
+	return nil
+}
+func (m *mockServerTransportStream) SendHeader(metadata.MD) error { return nil }
+func (m *mockServerTransportStream) SetTrailer(metadata.MD) error { return nil }
+
 func TestNodeServer_GetHealth(t *testing.T) {
 	tests := []struct {
 		name         string
 		input        *mockSync.Sync
-		customStatus uint64
+		isOptimistic bool
 		wantedErr    string
 	}{
 		{
-			name:  "happy path",
-			input: &mockSync.Sync{IsSyncing: false, IsSynced: true},
+			name:         "happy path - synced and not optimistic",
+			input:        &mockSync.Sync{IsSyncing: false, IsSynced: true},
+			isOptimistic: false,
 		},
 		{
-			name:      "syncing",
-			input:     &mockSync.Sync{IsSyncing: false},
-			wantedErr: "service unavailable",
+			name:         "returns error when not synced and not syncing",
+			input:        &mockSync.Sync{IsSyncing: false, IsSynced: false},
+			isOptimistic: false,
+			wantedErr:    "service unavailable",
+		},
+		{
+			name:         "returns error when syncing",
+			input:        &mockSync.Sync{IsSyncing: true, IsSynced: false},
+			isOptimistic: false,
+			wantedErr:    "node is syncing",
+		},
+		{
+			name:         "returns error when synced but optimistic",
+			input:        &mockSync.Sync{IsSyncing: false, IsSynced: true},
+			isOptimistic: true,
+			wantedErr:    "node is optimistic",
+		},
+		{
+			name:         "returns error when syncing and optimistic",
+			input:        &mockSync.Sync{IsSyncing: true, IsSynced: false},
+			isOptimistic: true,
+			wantedErr:    "node is syncing",
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			server := grpc.NewServer()
 			ns := &Server{
-				SyncChecker: tt.input,
+				SyncChecker:           tt.input,
+				OptimisticModeFetcher: &mock.ChainService{Optimistic: tt.isOptimistic},
 			}
 			ethpb.RegisterNodeServer(server, ns)
 			reflection.Register(server)
-			_, err := ns.GetHealth(t.Context(), &ethpb.HealthRequest{SyncingStatus: tt.customStatus})
+
+			// Create context with mock transport stream so grpc.SetHeader works
+			stream := &mockServerTransportStream{headers: make(map[string][]string)}
+			ctx := grpc.NewContextWithServerTransportStream(t.Context(), stream)
+
+			_, err := ns.GetHealth(ctx, &ethpb.HealthRequest{})
 			if tt.wantedErr == "" {
 				require.NoError(t, err)
 				return

beacon-chain/rpc/service.go

@@ -259,18 +259,19 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 	}
 	s.validatorServer = validatorServer
 	nodeServer := &nodev1alpha1.Server{
-		LogsStreamer:         logs.NewStreamServer(),
-		StreamLogsBufferSize: 1000, // Enough to handle bursts of beacon node logs for gRPC streaming.
-		BeaconDB:             s.cfg.BeaconDB,
-		Server:               s.grpcServer,
-		SyncChecker:          s.cfg.SyncService,
-		GenesisTimeFetcher:   s.cfg.GenesisTimeFetcher,
-		PeersFetcher:         s.cfg.PeersFetcher,
-		PeerManager:          s.cfg.PeerManager,
-		GenesisFetcher:       s.cfg.GenesisFetcher,
-		POWChainInfoFetcher:  s.cfg.ExecutionChainInfoFetcher,
-		BeaconMonitoringHost: s.cfg.BeaconMonitoringHost,
-		BeaconMonitoringPort: s.cfg.BeaconMonitoringPort,
+		LogsStreamer:          logs.NewStreamServer(),
+		StreamLogsBufferSize:  1000, // Enough to handle bursts of beacon node logs for gRPC streaming.
+		BeaconDB:              s.cfg.BeaconDB,
+		Server:                s.grpcServer,
+		SyncChecker:           s.cfg.SyncService,
+		GenesisTimeFetcher:    s.cfg.GenesisTimeFetcher,
+		PeersFetcher:          s.cfg.PeersFetcher,
+		PeerManager:           s.cfg.PeerManager,
+		GenesisFetcher:        s.cfg.GenesisFetcher,
+		POWChainInfoFetcher:   s.cfg.ExecutionChainInfoFetcher,
+		BeaconMonitoringHost:  s.cfg.BeaconMonitoringHost,
+		BeaconMonitoringPort:  s.cfg.BeaconMonitoringPort,
+		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
 	}
 	beaconChainServer := &beaconv1alpha1.Server{
 		Ctx:                         s.ctx,

changelog/fernantho_connect-merkle-proofs-with-endpoint.md

@@ -0,0 +1,6 @@
+### Added
+
+- Added new proofCollector type to ssz-query
+
+### Ignored
+- Added testing covering the production of Merkle proof from Phase0 beacon state and benchmarked against real Hoodi beacon state (Fulu version)

changelog/james-prysm_grpc-fallback.md

@@ -0,0 +1,7 @@
+### Changed
+
+- gRPC fallback now matches rest api implementation and will also check and connect to only synced nodes.
+
+### Removed
+
+- gRPC resolver for load balancing, the new implementation matches rest api's so we should remove the resolver so it's handled the same way for consistency.

changelog/james-prysm_host-fallback-cleanup.md

@@ -0,0 +1,11 @@
+### 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.

changelog/james-prysm_update-health-endpoint.md

@@ -0,0 +1,3 @@
+### Changed
+
+- gRPC health endpoint will now return an error on syncing or optimistic status showing that it's unavailable.

changelog/jtraglia-add-specrefs-readme.md

@@ -0,0 +1,3 @@
+### Added
+
+- Added README for maintaining specrefs.

changelog/jtraglia-nightly-reftests-with-run-id.md

@@ -0,0 +1,3 @@
+### Added
+
+- The ability to download the nightly reference tests from a specific day.

changelog/pvl-golangci-tests.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Updated golangci to run lint on tests too.

changelog/syjn99_docs-ssz-ql.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Add handy documentation for SSZ Query package (`encoding/ssz/query`).

changelog/terencechain_gloas-ptc-sampling.md

@@ -0,0 +1,2 @@
+### Changed
+- Sample PTC per committee to reduce allocations.

changelog/tt_run-gofmt.md

@@ -0,0 +1,2 @@
+### Ignored
+- Run go fmt

encoding/bytesutil/integers.go

@@ -163,3 +163,18 @@ func Uint256ToSSZBytes(num string) ([]byte, error) {
 	}
 	return PadTo(ReverseByteOrder(uint256.Bytes()), 32), nil
 }
+
+// PutLittleEndian writes an unsigned integer value in little-endian format.
+// Supports sizes 1, 2, 4, or 8 bytes for uint8/16/32/64 respectively.
+func PutLittleEndian(dst []byte, val uint64, size int) {
+	switch size {
+	case 1:
+		dst[0] = byte(val)
+	case 2:
+		binary.LittleEndian.PutUint16(dst, uint16(val))
+	case 4:
+		binary.LittleEndian.PutUint32(dst, uint32(val))
+	case 8:
+		binary.LittleEndian.PutUint64(dst, val)
+	}
+}

encoding/ssz/query/BUILD.bazel

@@ -9,7 +9,9 @@ go_library(
         "container.go",
         "generalized_index.go",
         "list.go",
+        "merkle_proof.go",
         "path.go",
+        "proof_collector.go",
         "query.go",
         "ssz_info.go",
         "ssz_object.go",
@@ -20,7 +22,12 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/encoding/ssz/query",
     visibility = ["//visibility:public"],
     deps = [
+        "//container/trie:go_default_library",
+        "//crypto/hash/htr:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//encoding/ssz:go_default_library",
+        "//math:go_default_library",
+        "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
 )
@@ -29,15 +36,24 @@ go_test(
     name = "go_default_test",
     srcs = [
         "generalized_index_test.go",
+        "merkle_proof_test.go",
         "path_test.go",
+        "proof_collector_test.go",
         "query_test.go",
         "tag_parser_test.go",
     ],
+    embed = [":go_default_library"],
     deps = [
-        ":go_default_library",
+        "//beacon-chain/state/stateutil:go_default_library",
+        "//consensus-types/blocks:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//encoding/ssz:go_default_library",
         "//encoding/ssz/query/testutil:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
         "//proto/ssz_query/testing:go_default_library",
         "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+        "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
 )

encoding/ssz/query/doc.md

@@ -0,0 +1,190 @@
+# SSZ Query Package
+
+The `encoding/ssz/query` package provides a system for analyzing and querying SSZ ([Simple Serialize](https://github.com/ethereum/consensus-specs/blob/master/ssz/simple-serialize.md)) data structures, as well as generating Merkle proofs from them. It enables runtime analysis of SSZ-serialized Go objects with reflection, path-based queries through nested structures, generalized index calculation, and Merkle proof generation.
+
+This package is designed to be generic. It operates on arbitrary SSZ-serialized Go values at runtime, so the same query/proof machinery applies equally to any SSZ type, including the BeaconState/BeaconBlock.
+
+## Usage Example
+
+```go
+// 1. Analyze an SSZ object
+block := &ethpb.BeaconBlock{...}
+info, err := query.AnalyzeObject(block)
+
+// 2. Parse a path
+path, err := query.ParsePath(".body.attestations[0].data.slot")
+
+// 3. Get the generalized index
+gindex, err := query.GetGeneralizedIndexFromPath(info, path)
+
+// 4. Generate a Merkle proof
+proof, err := info.Prove(gindex)
+
+// 5. Get offset and length to slice the SSZ-encoded bytes
+sszBytes, _ := block.MarshalSSZ()
+_, offset, length, err := query.CalculateOffsetAndLength(info, path)
+// slotBytes contains the SSZ-encoded value at the queried path
+slotBytes := sszBytes[offset : offset+length]
+```
+
+## Exported API
+
+The main exported API consists of:
+
+```go
+// AnalyzeObject analyzes an SSZ object and returns its structural information
+func AnalyzeObject(obj SSZObject) (*SszInfo, error)
+
+// ParsePath parses a path string like ".field1.field2[0].field3"
+func ParsePath(rawPath string) (Path, error)
+
+// CalculateOffsetAndLength computes byte offset and length for a path within an SSZ object
+func CalculateOffsetAndLength(sszInfo *SszInfo, path Path) (*SszInfo, uint64, uint64, error)
+
+// GetGeneralizedIndexFromPath calculates the generalized index for a given path
+func GetGeneralizedIndexFromPath(info *SszInfo, path Path) (uint64, error)
+
+// Prove generates a Merkle proof for a target generalized index
+func (s *SszInfo) Prove(gindex uint64) (*fastssz.Proof, error)
+```
+
+## Type System
+
+### SSZ Types
+
+The package now supports [all standard SSZ types](https://github.com/ethereum/consensus-specs/blob/master/ssz/simple-serialize.md#typing) except `ProgressiveList`, `ProgressiveContainer`, `ProgressiveBitlist`, `Union`, and `CompatibleUnion`.
+
+### Core Data Structures
+
+#### `SszInfo`
+
+The `SszInfo` structure contains complete structural metadata for an SSZ type:
+
+```go
+type SszInfo struct {
+   sszType       SszType           // SSZ Type classification
+   typ           reflect.Type      // Go reflect.Type
+   source        SSZObject         // Original SSZObject reference. Mostly used for reusing SSZ methods like `HashTreeRoot`.
+   isVariable    bool              // True if contains variable-size fields
+
+   // Composite types have corresponding metadata. Other fields would be nil except for the current type.
+   containerInfo *containerInfo
+   listInfo      *listInfo
+   vectorInfo    *vectorInfo
+   bitlistInfo   *bitlistInfo
+   bitvectorInfo *bitvectorInfo
+}
+```
+
+#### `Path`
+
+The `Path` structure represents navigation paths through SSZ structures. It supports accessing a field by field name, accessing an element by index (list/vector type), and finding the length of homogenous collection types. The `ParsePath` function parses a raw string into a `Path` instance, which is commonly used in other APIs like `CalculateOffsetAndLength` and `GetGeneralizedIndexFromPath`.
+
+```go
+type Path struct {
+   Length   bool           // Flag for length queries (e.g., len(.field))
+   Elements []PathElement  // Sequence of field accesses and indices
+}
+
+type PathElement struct {
+   Name  string  // Field name
+   Index *uint64 // list/vector index (nil if not an index access)
+}
+```
+
+## Implementation Details
+
+### Type Analysis (`analyzer.go`)
+
+The `AnalyzeObject` function performs recursive type introspection using Go reflection:
+
+1. **Type Inspection** - Examines Go `reflect.Value` to determine SSZ type
+   - Basic types (`uint8`, `uint16`, `uint32`, `uint64`, `bool`): `SSZType` constants
+   - Slices: Determined from struct tags (`ssz-size` for vectors, `ssz-max` for lists). There is a related [write-up](https://hackmd.io/@junsong/H101DKnwxl) regarding struct tags.
+   - Structs: Analyzed as Containers with field ordering from JSON tags
+   - Pointers: Dereferenced automatically
+
+2. **Variable-Length Population** - Determines actual sizes at runtime
+   - For lists: Iterates elements, caches sizes for variable-element lists
+   - For containers: Recursively populates variable fields, adjusts offsets
+   - For bitlists: Decodes bit length from bitvector
+
+3. **Offset Calculation** - Computes byte positions within serialized data
+   - Fixed-size fields: Offset = sum of preceding field sizes
+   - Variable-size fields: Offset stored as 4-byte pointer entries
+
+### Path Parsing (`path.go`)
+
+The `ParsePath` function parses path strings with the following rules:
+
+- **Dot notation**: `.field1.field2` for field access
+- **Array indexing**: `[0]`, `[42]` for element access
+- **Length queries**: `len(.field)` for list/vector lengths
+- **Character set**: Only `[A-Za-z0-9._\[\]\(\)]` allowed
+
+Example:
+```go
+path, _ := ParsePath(".nested.array_field[5].inner_field")
+// Returns: Path{
+//   Elements: [
+//     PathElement{Name: "nested"},
+//     PathElement{Name: "array_field", Index: <Pointer to uint64(5)>},
+//     PathElement{Name: "inner_field"}
+//   ]
+// }
+```
+
+### Generalized Index Calculation (`generalized_index.go`)
+
+The generalized index is a tree position identifier. This package follows the [Ethereum consensus-specs](https://github.com/ethereum/consensus-specs/blob/master/ssz/merkle-proofs.md#generalized-merkle-tree-index) to calculate the generalized index.
+
+### Merkle Proof Generation (`merkle_proof.go`, `proof_collector.go`)
+
+The `Prove` method generates Merkle proofs using a single-sweep merkleization algorithm:
+
+#### Algorithm Overview
+
+**Key Terms:**
+
+- **Target gindex** (generalized index): The position of the SSZ element you want to prove, expressed as a generalized Merkle tree index. Stored in `Proof.Index`.
+  - Note: The generalized index for root is 1.
+- **Registered gindices**: The set of tree positions whose node hashes must be captured during merkleization in order to later assemble the proof.
+- **Sibling node**: The node that shares the same parent as another node.
+- **Leaf value**: The 32-byte hash of the target node (the node being proven). Stored in `Proof.Leaf`.
+
+**Phases:**
+
+1. **Registration Phase** (`addTarget`)
+> Goal: determine exactly which sibling hashes are needed for the proof.
+
+   - Record the target gindex as the proof target.
+   - Starting from the target node, walk the Merkle tree from the leaf (target gindex) to the root (gindex = 1).
+   - At each step:
+     - Compute and register the sibling gindex (`i XOR 1`) as “must collect”.
+     - Move to the parent (`i = i/2`).
+   - This produces the full set of registered gindices (the sibling nodes on the target-to-root path).
+
+2. **Merkleization Phase** (`merkleize`)
+> Goal: recursively merkleize the tree and capture the needed hashes.
+
+   - Recursively traverse the SSZ structure and compute Merkle tree node hashes from leaves to root.
+   - Whenever the traversal computes a node whose gindex is in registered gindices, store that node’s hash for later proof construction.
+
+3. **Proof Assembly Phase** (`toProof`)
+> Goal: create the final `fastssz.Proof` object in the correct format and order.
+
+```go
+// Proof represents a merkle proof against a general index.
+type Proof struct {
+	Index  int
+	Leaf   []byte
+	Hashes [][]byte
+}
+```
+
+   - Set `Proof.Index` to the target gindex.
+   - Set `Proof.Leaf` to the 32-byte hash of the target node.
+   - Build `Proof.Hashes` by walking from the target node up to (but not including) the root:
+     - At node `i`, append the stored hash for the sibling (`i XOR 1`).
+     - Move to the parent (`i = i/2`).
+   - The resulting `Proof.Hashes` is ordered from the target level upward, containing one sibling hash per tree level on the path to the root.

encoding/ssz/query/merkle_proof.go

@@ -0,0 +1,34 @@
+package query
+
+import (
+	"fmt"
+	"reflect"
+
+	fastssz "github.com/prysmaticlabs/fastssz"
+)
+
+// Prove is the entrypoint to generate an SSZ Merkle proof for the given generalized index.
+// Parameters:
+// - gindex: the generalized index of the node to prove inclusion for.
+// Returns:
+// - fastssz.Proof: the Merkle proof containing the leaf, index, and sibling hashes.
+// - error: any error encountered during proof generation.
+func (info *SszInfo) Prove(gindex uint64) (*fastssz.Proof, error) {
+	if info == nil {
+		return nil, fmt.Errorf("nil SszInfo")
+	}
+
+	collector := newProofCollector()
+	collector.addTarget(gindex)
+
+	// info.source is guaranteed to be valid and dereferenced by AnalyzeObject
+	v := reflect.ValueOf(info.source).Elem()
+
+	// Start the merkleization and proof collection process.
+	// In SSZ generalized indices, the root is always at index 1.
+	if _, err := collector.merkleize(info, v, 1); err != nil {
+		return nil, err
+	}
+
+	return collector.toProof()
+}

encoding/ssz/query/merkle_proof_test.go

@@ -0,0 +1,163 @@
+package query_test
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/go-bitfield"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/encoding/ssz/query"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	ssz "github.com/prysmaticlabs/fastssz"
+)
+
+func TestProve_FixedTestContainer(t *testing.T) {
+	obj := createFixedTestContainer()
+
+	tests := []string{
+		".field_uint32",
+		".nested.value2",
+		".vector_field[3]",
+		".bitvector64_field",
+		".trailing_field",
+	}
+
+	for _, tc := range tests {
+		t.Run(tc, func(t *testing.T) {
+			proveAndVerify(t, obj, tc)
+		})
+	}
+}
+
+func TestProve_VariableTestContainer(t *testing.T) {
+	obj := createVariableTestContainer()
+
+	tests := []string{
+		".leading_field",
+		".field_list_uint64[2]",
+		"len(field_list_uint64)",
+		".nested.nested_list_field[1]",
+		".variable_container_list[0].inner_1.field_list_uint64[1]",
+	}
+
+	for _, tc := range tests {
+		t.Run(tc, func(t *testing.T) {
+			proveAndVerify(t, obj, tc)
+		})
+	}
+}
+
+func TestProve_BeaconBlock(t *testing.T) {
+	randaoReveal := make([]byte, 96)
+	for i := range randaoReveal {
+		randaoReveal[i] = 0x42
+	}
+	root32 := make([]byte, 32)
+	for i := range root32 {
+		root32[i] = 0x24
+	}
+	sig := make([]byte, 96)
+	for i := range sig {
+		sig[i] = 0x99
+	}
+
+	att := &eth.Attestation{
+		AggregationBits: bitfield.Bitlist{0x01},
+		Data: &eth.AttestationData{
+			Slot:            1,
+			CommitteeIndex:  1,
+			BeaconBlockRoot: root32,
+			Source: &eth.Checkpoint{
+				Epoch: 1,
+				Root:  root32,
+			},
+			Target: &eth.Checkpoint{
+				Epoch: 1,
+				Root:  root32,
+			},
+		},
+		Signature: sig,
+	}
+
+	b := util.NewBeaconBlock()
+	b.Block.Slot = 123
+	b.Block.Body.RandaoReveal = randaoReveal
+	b.Block.Body.Attestations = []*eth.Attestation{att}
+
+	sb, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+
+	protoBlock, err := sb.Block().Proto()
+	require.NoError(t, err)
+
+	obj, ok := protoBlock.(query.SSZObject)
+	require.Equal(t, true, ok, "block proto does not implement query.SSZObject")
+
+	tests := []string{
+		".slot",
+		".body.randao_reveal",
+		".body.attestations[0].data.slot",
+		"len(body.attestations)",
+	}
+
+	for _, tc := range tests {
+		t.Run(tc, func(t *testing.T) {
+			proveAndVerify(t, obj, tc)
+		})
+	}
+}
+
+func TestProve_BeaconState(t *testing.T) {
+	st, _ := util.DeterministicGenesisState(t, 16)
+	require.NoError(t, st.SetSlot(primitives.Slot(42)))
+
+	sszObj, ok := st.ToProtoUnsafe().(query.SSZObject)
+	require.Equal(t, true, ok, "state proto does not implement query.SSZObject")
+
+	tests := []string{
+		".slot",
+		".latest_block_header",
+		".validators[0].effective_balance",
+		"len(validators)",
+	}
+
+	for _, tc := range tests {
+		t.Run(tc, func(t *testing.T) {
+			proveAndVerify(t, sszObj, tc)
+		})
+	}
+}
+
+// proveAndVerify helper to analyze an object, generate a merkle proof for the given path,
+// and verify the proof against the object's root.
+func proveAndVerify(t *testing.T, obj query.SSZObject, pathStr string) {
+	t.Helper()
+
+	info, err := query.AnalyzeObject(obj)
+	require.NoError(t, err)
+
+	path, err := query.ParsePath(pathStr)
+	require.NoError(t, err)
+
+	gi, err := query.GetGeneralizedIndexFromPath(info, path)
+	require.NoError(t, err)
+
+	proof, err := info.Prove(gi)
+	require.NoError(t, err)
+	require.Equal(t, int(gi), proof.Index)
+
+	root, err := obj.HashTreeRoot()
+	require.NoError(t, err)
+
+	ok, err := ssz.VerifyProof(root[:], proof)
+	require.NoError(t, err)
+	require.Equal(t, true, ok, "merkle proof verification failed")
+
+	require.Equal(t, 32, len(proof.Leaf))
+	for i, h := range proof.Hashes {
+		require.Equal(t, 32, len(h), "proof hash %d is not 32 bytes", i)
+	}
+
+}

encoding/ssz/query/proof_collector.go

@@ -0,0 +1,672 @@
+package query
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math/bits"
+	"reflect"
+	"runtime"
+	"slices"
+	"sync"
+
+	"github.com/OffchainLabs/go-bitfield"
+	"github.com/OffchainLabs/prysm/v7/container/trie"
+	"github.com/OffchainLabs/prysm/v7/crypto/hash/htr"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	ssz "github.com/OffchainLabs/prysm/v7/encoding/ssz"
+	"github.com/OffchainLabs/prysm/v7/math"
+	fastssz "github.com/prysmaticlabs/fastssz"
+)
+
+// proofCollector collects sibling hashes and leaves needed for Merkle proofs.
+//
+// Multiproof-ready design:
+// - requiredSiblings/requiredLeaves store which gindices we want to collect (registered before merkleization).
+// - siblings/leaves store the actual collected hashes.
+//
+// Concurrency:
+// - required* maps are read-only during merkleization.
+// - siblings/leaves writes are protected by mutex.
+type proofCollector struct {
+	sync.Mutex
+
+	// Required gindices (registered before merkleization)
+	requiredSiblings map[uint64]struct{}
+	requiredLeaves   map[uint64]struct{}
+
+	// Collected hashes
+	siblings map[uint64][32]byte
+	leaves   map[uint64][32]byte
+}
+
+func newProofCollector() *proofCollector {
+	return &proofCollector{
+		requiredSiblings: make(map[uint64]struct{}),
+		requiredLeaves:   make(map[uint64]struct{}),
+		siblings:         make(map[uint64][32]byte),
+		leaves:           make(map[uint64][32]byte),
+	}
+}
+
+func (pc *proofCollector) reset() {
+	pc.Lock()
+	defer pc.Unlock()
+
+	pc.requiredSiblings = make(map[uint64]struct{})
+	pc.requiredLeaves = make(map[uint64]struct{})
+	pc.siblings = make(map[uint64][32]byte)
+	pc.leaves = make(map[uint64][32]byte)
+}
+
+// addTarget register the target leaf and its required sibling nodes for proof construction.
+// Registration should happen before merkleization begins.
+func (pc *proofCollector) addTarget(gindex uint64) {
+	pc.Lock()
+	defer pc.Unlock()
+
+	pc.requiredLeaves[gindex] = struct{}{}
+
+	// Walk from the target leaf up to (but not including) the root (gindex=1).
+	// At each step, register the sibling node required to prove inclusion.
+	nodeGindex := gindex
+	for nodeGindex > 1 {
+		siblingGindex := nodeGindex ^ 1 // flip the last bit: left<->right sibling
+		pc.requiredSiblings[siblingGindex] = struct{}{}
+
+		// Move to parent
+		nodeGindex /= 2
+	}
+}
+
+// toProof converts the collected siblings and leaves into a fastssz.Proof structure.
+// Current behavior expects a single target leaf (single proof).
+func (pc *proofCollector) toProof() (*fastssz.Proof, error) {
+	pc.Lock()
+	defer pc.Unlock()
+
+	proof := &fastssz.Proof{}
+	if len(pc.leaves) == 0 {
+		return nil, errors.New("no leaves collected: add target leaves before merkleization")
+	}
+
+	leafGindices := make([]uint64, 0, len(pc.leaves))
+	for g := range pc.leaves {
+		leafGindices = append(leafGindices, g)
+	}
+	slices.Sort(leafGindices)
+
+	// single proof resides in leafGindices[0]
+	targetGindex := leafGindices[0]
+	proofIndex, err := math.Int(targetGindex)
+	if err != nil {
+		return nil, fmt.Errorf("gindex %d overflows int: %w", targetGindex, err)
+	}
+	proof.Index = proofIndex
+
+	// store the leaf
+	leaf := pc.leaves[targetGindex]
+	leafBuf := make([]byte, 32)
+	copy(leafBuf, leaf[:])
+	proof.Leaf = leafBuf
+
+	// Walk from target up to root, collecting siblings.
+	steps := bits.Len64(targetGindex) - 1
+	proof.Hashes = make([][]byte, 0, steps)
+
+	for targetGindex > 1 {
+		sib := targetGindex ^ 1
+		h, ok := pc.siblings[sib]
+		if !ok {
+			return nil, fmt.Errorf("missing sibling hash for gindex %d", sib)
+		}
+		proof.Hashes = append(proof.Hashes, h[:])
+		targetGindex /= 2
+	}
+
+	return proof, nil
+}
+
+// collectLeaf checks if the given gindex is a required leaf for the proof,
+// and if so, stores the provided leaf hash in the collector.
+func (pc *proofCollector) collectLeaf(gindex uint64, leaf [32]byte) {
+	if _, ok := pc.requiredLeaves[gindex]; !ok {
+		return
+	}
+	pc.Lock()
+	pc.leaves[gindex] = leaf
+	pc.Unlock()
+}
+
+// collectSibling stores the hash for a sibling node identified by gindex.
+// It only stores the hash if gindex was pre-registered via addTarget (present in requiredSiblings).
+// Writes to the collected siblings map are protected by the collector mutex.
+func (pc *proofCollector) collectSibling(gindex uint64, hash [32]byte) {
+	if _, ok := pc.requiredSiblings[gindex]; !ok {
+		return
+	}
+	pc.Lock()
+	pc.siblings[gindex] = hash
+	pc.Unlock()
+}
+
+// Merkleizers and proof collection methods
+
+// merkleize recursively traverses an SSZ info and computes the Merkle root of the subtree.
+//
+// Proof collection:
+//   - During traversal it calls collectLeaf/collectSibling with the SSZ generalized indices (gindices)
+//     of visited nodes.
+//   - The collector only stores hashes for gindices that were pre-registered via addTarget
+//     (requiredLeaves/requiredSiblings). This makes the traversal multiproof-ready: you can register
+//     multiple targets before calling merkleize.
+//
+// SSZ types handled: basic types, containers, lists, vectors, bitlists, and bitvectors.
+//
+// Parameters:
+// - info: SSZ type metadata for the current value.
+// - v: reflect.Value of the current value.
+// - currentGindex: generalized index of the current subtree root.
+//
+// Returns:
+// - [32]byte: Merkle root of the current subtree.
+// - error: any error encountered during traversal/merkleization.
+func (pc *proofCollector) merkleize(info *SszInfo, v reflect.Value, currentGindex uint64) ([32]byte, error) {
+	if info.sszType.isBasic() {
+		return pc.merkleizeBasicType(info.sszType, v, currentGindex)
+	}
+	switch info.sszType {
+	case Container:
+		return pc.merkleizeContainer(info, v, currentGindex)
+	case List:
+		return pc.merkleizeList(info, v, currentGindex)
+	case Vector:
+		return pc.merkleizeVector(info, v, currentGindex)
+	case Bitlist:
+		return pc.merkleizeBitlist(info, v, currentGindex)
+	case Bitvector:
+		return pc.merkleizeBitvector(info, v, currentGindex)
+	default:
+		return [32]byte{}, fmt.Errorf("unsupported SSZ type: %v", info.sszType)
+	}
+}
+
+// merkleizeBasicType serializes a basic SSZ value into a 32-byte leaf chunk (little-endian, zero-padded).
+//
+// Proof collection:
+// - It calls collectLeaf(currentGindex, leaf) and stores the leaf if currentGindex was pre-registered via addTarget.
+//
+// Parameters:
+// - t: the SSZType (basic).
+// - v: the reflect.Value of the basic value.
+// - currentGindex: the generalized index (gindex) of this leaf.
+//
+// Returns:
+// - [32]byte: the 32-byte SSZ leaf chunk.
+// - error: if the SSZType is not a supported basic type.
+func (pc *proofCollector) merkleizeBasicType(t SSZType, v reflect.Value, currentGindex uint64) ([32]byte, error) {
+	var leaf [32]byte
+
+	// Serialize the value into a 32-byte chunk (little-endian, zero-padded)
+	switch t {
+	case Uint8:
+		leaf[0] = uint8(v.Uint())
+	case Uint16:
+		binary.LittleEndian.PutUint16(leaf[:2], uint16(v.Uint()))
+	case Uint32:
+		binary.LittleEndian.PutUint32(leaf[:4], uint32(v.Uint()))
+	case Uint64:
+		binary.LittleEndian.PutUint64(leaf[:8], v.Uint())
+	case Boolean:
+		if v.Bool() {
+			leaf[0] = 1
+		}
+	default:
+		return [32]byte{}, fmt.Errorf("unexpected basic type: %v", t)
+	}
+
+	pc.collectLeaf(currentGindex, leaf)
+
+	return leaf, nil
+}
+
+// merkleizeContainer computes the Merkle root of an SSZ container by:
+//  1. Merkleizing each field into a 32-byte subtree root
+//  2. Merkleizing the field roots into the container root (padding to the next power-of-2)
+//
+// Generalized indices (gindices): depth = ssz.Depth(uint64(N)) and field i has gindex = (currentGindex << depth) + uint64(i).
+// Proof collection: merkleize() computes each field root, merkleizeVectorAndCollect collects required siblings, and collectLeaf stores the container root if registered.
+//
+// Parameters:
+// - info: SSZ type metadata for the container.
+// - v: reflect.Value of the container value.
+// - currentGindex: generalized index (gindex) of the container root.
+//
+// Returns:
+// - [32]byte: Merkle root of the container.
+// - error: any error encountered while merkleizing fields.
+func (pc *proofCollector) merkleizeContainer(info *SszInfo, v reflect.Value, currentGindex uint64) ([32]byte, error) {
+	// If the container root itself is the target, compute directly and return early.
+	// This avoids full subtree merkleization when we only need the root.
+	if _, ok := pc.requiredLeaves[currentGindex]; ok {
+		root, err := info.HashTreeRoot()
+		if err != nil {
+			return [32]byte{}, err
+		}
+		pc.collectLeaf(currentGindex, root)
+		return root, nil
+	}
+
+	ci, err := info.ContainerInfo()
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	v = dereferencePointer(v)
+
+	// Calculate depth: how many levels from container root to field leaves
+	numFields := len(ci.order)
+	depth := ssz.Depth(uint64(numFields))
+
+	// Step 1: Compute HTR for each subtree (field)
+	fieldRoots := make([][32]byte, numFields)
+
+	for i, name := range ci.order {
+		fieldInfo := ci.fields[name]
+		fieldVal := v.FieldByName(fieldInfo.goFieldName)
+
+		// Field i's gindex: shift currentGindex left by depth, then OR with field index
+		fieldGindex := currentGindex<<depth + uint64(i)
+
+		htr, err := pc.merkleize(fieldInfo.sszInfo, fieldVal, fieldGindex)
+		if err != nil {
+			return [32]byte{}, fmt.Errorf("field %s: %w", name, err)
+		}
+		fieldRoots[i] = htr
+	}
+
+	// Step 2: Merkleize the field hashes into the container root,
+	// collecting sibling hashes if target is within this subtree
+	root := pc.merkleizeVectorAndCollect(fieldRoots, currentGindex, uint64(depth))
+
+	return root, nil
+}
+
+// merkleizeVectorBody computes the Merkle root of the "data" subtree for vector-like SSZ types
+// (vectors and the data-part of lists/bitlists).
+//
+// Generalized indices (gindices): depth = ssz.Depth(limit); leafBase = subtreeRootGindex << depth; element/chunk i gindex = leafBase + uint64(i).
+// Proof collection: merkleize() is called for composite elements; merkleizeVectorAndCollect collects required siblings at this layer.
+// Padding: merkleizeVectorAndCollect uses trie.ZeroHashes as needed.
+//
+// Parameters:
+// - elemInfo: SSZ type metadata for the element.
+// - v: reflect.Value of the vector/list data.
+// - length: number of actual elements present.
+// - limit: virtual leaf capacity used for padding/Depth (fixed length for vectors, limit for lists).
+// - subtreeRootGindex: gindex of the data subtree root.
+//
+// Returns:
+// - [32]byte: Merkle root of the data subtree.
+// - error: any error encountered while merkleizing composite elements.
+func (pc *proofCollector) merkleizeVectorBody(elemInfo *SszInfo, v reflect.Value, length int, limit uint64, subtreeRootGindex uint64) ([32]byte, error) {
+	depth := uint64(ssz.Depth(limit))
+
+	var chunks [][32]byte
+	if elemInfo.sszType.isBasic() {
+		// Serialize basic elements and pack into 32-byte chunks using ssz.PackByChunk.
+		elemSize, err := math.Int(itemLength(elemInfo))
+		if err != nil {
+			return [32]byte{}, fmt.Errorf("element size %d overflows int: %w", itemLength(elemInfo), err)
+		}
+		serialized := make([][]byte, length)
+		// Single contiguous allocation for all element data
+		allData := make([]byte, length*elemSize)
+		for i := range length {
+			buf := allData[i*elemSize : (i+1)*elemSize]
+			elem := v.Index(i)
+			if elemInfo.sszType == Boolean && elem.Bool() {
+				buf[0] = 1
+			} else {
+				bytesutil.PutLittleEndian(buf, elem.Uint(), elemSize)
+			}
+			serialized[i] = buf
+		}
+		chunks, err = ssz.PackByChunk(serialized)
+		if err != nil {
+			return [32]byte{}, err
+		}
+	} else {
+		// Composite elements: compute each element root (no padding here; merkleizeVectorAndCollect pads).
+		chunks = make([][32]byte, length)
+
+		// Fall back to per-element merkleization with proper gindices for proof collection.
+		// Parallel execution
+		workerCount := min(runtime.GOMAXPROCS(0), length)
+
+		jobs := make(chan int, workerCount*16)
+		errCh := make(chan error, 1) // only need the first error
+		stopCh := make(chan struct{})
+		var stopOnce sync.Once
+		var wg sync.WaitGroup
+
+		worker := func() {
+			defer wg.Done()
+			for idx := range jobs {
+				select {
+				case <-stopCh:
+					return
+				default:
+				}
+
+				elemGindex := subtreeRootGindex<<depth + uint64(idx)
+				htr, err := pc.merkleize(elemInfo, v.Index(idx), elemGindex)
+				if err != nil {
+					stopOnce.Do(func() { close(stopCh) })
+					select {
+					case errCh <- fmt.Errorf("index %d: %w", idx, err):
+					default:
+					}
+					return
+				}
+				chunks[idx] = htr
+			}
+		}
+
+		wg.Add(workerCount)
+		for range workerCount {
+			go worker()
+		}
+
+		// Enqueue jobs; stop early if any worker reports an error.
+	enqueue:
+		for i := range length {
+			select {
+			case <-stopCh:
+				break enqueue
+			case jobs <- i:
+			}
+		}
+		close(jobs)
+
+		wg.Wait()
+
+		select {
+		case err := <-errCh:
+			return [32]byte{}, err
+		default:
+		}
+	}
+
+	root := pc.merkleizeVectorAndCollect(chunks, subtreeRootGindex, depth)
+	return root, nil
+}
+
+// merkleizeVector computes the Merkle root of an SSZ vector (fixed-length).
+//
+// Generalized indices (gindices): currentGindex is the gindex of the vector root; element/chunk gindices are derived
+// inside merkleizeVectorBody using leafBase = currentGindex << ssz.Depth(leaves).
+//
+// Proof collection: merkleizeVectorBody performs element/chunk merkleization and collects required siblings at the
+// vector layer; collectLeaf stores the vector root if currentGindex was registered via addTarget.
+//
+// Parameters:
+// - info: SSZ type metadata for the vector.
+// - v: reflect.Value of the vector value.
+// - currentGindex: generalized index (gindex) of the vector root.
+//
+// Returns:
+// - [32]byte: Merkle root of the vector.
+// - error: any error encountered while merkleizing composite elements.
+func (pc *proofCollector) merkleizeVector(info *SszInfo, v reflect.Value, currentGindex uint64) ([32]byte, error) {
+	vi, err := info.VectorInfo()
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	length, err := math.Int(vi.Length())
+	if err != nil {
+		return [32]byte{}, fmt.Errorf("vector length %d overflows int: %w", vi.Length(), err)
+	}
+	elemInfo := vi.element
+
+	// Determine the virtual leaf capacity for the vector.
+	leaves, err := getChunkCount(info)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	root, err := pc.merkleizeVectorBody(elemInfo, v, length, leaves, currentGindex)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	// If the vector root itself is the target
+	pc.collectLeaf(currentGindex, root)
+
+	return root, nil
+}
+
+// merkleizeList computes the Merkle root of an SSZ list by merkleizing its data subtree and mixing in the length.
+//
+// Generalized indices (gindices): dataRoot is the left child of the list root (dataRootGindex = currentGindex*2); the length mixin is the right child (currentGindex*2+1).
+// Proof collection: merkleizeVectorBody computes the data root (collecting required siblings in the data subtree), and mixinLengthAndCollect collects required siblings at the length-mixin level; collectLeaf stores the list root if registered.
+//
+// Parameters:
+// - info: SSZ type metadata for the list.
+// - v: reflect.Value of the list value.
+// - currentGindex: generalized index (gindex) of the list root.
+//
+// Returns:
+// - [32]byte: Merkle root of the list.
+// - error: any error encountered while merkleizing the data subtree.
+func (pc *proofCollector) merkleizeList(info *SszInfo, v reflect.Value, currentGindex uint64) ([32]byte, error) {
+	li, err := info.ListInfo()
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	length := v.Len()
+	elemInfo := li.element
+
+	chunks := make([][32]byte, 2)
+	// Compute the length hash (little-endian uint256)
+	binary.LittleEndian.PutUint64(chunks[1][:8], uint64(length))
+
+	// Data subtree root is the left child of the list root.
+	dataRootGindex := currentGindex * 2
+
+	// Compute virtual leaf capacity for the data subtree.
+	leaves, err := getChunkCount(info)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	chunks[0], err = pc.merkleizeVectorBody(elemInfo, v, length, leaves, dataRootGindex)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	// Handle the length mixin level (and proof bookkeeping at this level).
+	// Compute the final list root: hash(dataRoot || lengthHash)
+	root := pc.mixinLengthAndCollect(currentGindex, chunks)
+
+	// If the list root itself is the target
+	pc.collectLeaf(currentGindex, root)
+
+	return root, nil
+}
+
+// merkleizeBitvectorBody computes the Merkle root of a bitvector-like byte sequence by packing it into 32-byte chunks
+// and merkleizing those chunks as a fixed-capacity vector (padding with trie.ZeroHashes as needed).
+//
+// Generalized indices (gindices): depth = ssz.Depth(chunkLimit); leafBase = subtreeRootGindex << depth; chunk i uses gindex = leafBase + uint64(i).
+// Proof collection: merkleizeVectorAndCollect collects required sibling hashes at the chunk-merkleization layer.
+//
+// Parameters:
+// - data: raw byte sequence representing the bitvector payload.
+// - chunkLimit: fixed/limit number of 32-byte chunks (used for padding/Depth).
+// - subtreeRootGindex: gindex of the bitvector data subtree root.
+//
+// Returns:
+// - [32]byte: Merkle root of the bitvector data subtree.
+// - error: any error encountered while packing data into chunks.
+func (pc *proofCollector) merkleizeBitvectorBody(data []byte, chunkLimit uint64, subtreeRootGindex uint64) ([32]byte, error) {
+	depth := ssz.Depth(chunkLimit)
+	chunks, err := ssz.PackByChunk([][]byte{data})
+	if err != nil {
+		return [32]byte{}, err
+	}
+	root := pc.merkleizeVectorAndCollect(chunks, subtreeRootGindex, uint64(depth))
+	return root, nil
+}
+
+// merkleizeBitvector computes the Merkle root of a fixed-length SSZ bitvector and collects proof nodes for targets.
+//
+// Parameters:
+// - info: SSZ type metadata for the bitvector.
+// - v: reflect.Value of the bitvector value.
+// - currentGindex: generalized index (gindex) of the bitvector root.
+//
+// Returns:
+// - [32]byte: Merkle root of the bitvector.
+// - error: any error encountered during packing or merkleization.
+func (pc *proofCollector) merkleizeBitvector(info *SszInfo, v reflect.Value, currentGindex uint64) ([32]byte, error) {
+	bitvectorBytes := v.Bytes()
+	if len(bitvectorBytes) == 0 {
+		return [32]byte{}, fmt.Errorf("bitvector field is uninitialized (nil or empty slice)")
+	}
+
+	// Compute virtual leaf capacity for the bitvector.
+	numChunks, err := getChunkCount(info)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	root, err := pc.merkleizeBitvectorBody(bitvectorBytes, numChunks, currentGindex)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	pc.collectLeaf(currentGindex, root)
+
+	return root, nil
+}
+
+// merkleizeBitlist computes the Merkle root of an SSZ bitlist by merkleizing its data chunks and mixing in the bit length.
+//
+// Generalized indices (gindices): dataRoot is the left child (dataRootGindex = currentGindex*2) and the length mixin is the right child (currentGindex*2+1).
+// Proof collection: merkleizeBitvectorBody computes the data root (collecting required siblings under dataRootGindex), and mixinLengthAndCollect collects required siblings at the length-mixin level; collectLeaf stores the bitlist root if registered.
+//
+// Parameters:
+// - info: SSZ type metadata for the bitlist.
+// - v: reflect.Value of the bitlist value.
+// - currentGindex: generalized index (gindex) of the bitlist root.
+//
+// Returns:
+// - [32]byte: Merkle root of the bitlist.
+// - error: any error encountered while merkleizing the data subtree.
+func (pc *proofCollector) merkleizeBitlist(info *SszInfo, v reflect.Value, currentGindex uint64) ([32]byte, error) {
+	bi, err := info.BitlistInfo()
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	bitlistBytes := v.Bytes()
+
+	// Use go-bitfield to get bytes with termination bit cleared
+	bl := bitfield.Bitlist(bitlistBytes)
+	data := bl.BytesNoTrim()
+
+	// Get the bit length from bitlistInfo
+	bitLength := bi.Length()
+
+	// Get the chunk limit from getChunkCount
+	limitChunks, err := getChunkCount(info)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	chunks := make([][32]byte, 2)
+	// Compute the length hash (little-endian uint256)
+	binary.LittleEndian.PutUint64(chunks[1][:8], uint64(bitLength))
+
+	dataRootGindex := currentGindex * 2
+	chunks[0], err = pc.merkleizeBitvectorBody(data, limitChunks, dataRootGindex)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	// Handle the length mixin level (and proof bookkeeping at this level).
+	root := pc.mixinLengthAndCollect(currentGindex, chunks)
+
+	pc.collectLeaf(currentGindex, root)
+
+	return root, nil
+}
+
+// merkleizeVectorAndCollect merkleizes a slice of 32-byte leaf nodes into a subtree root, padding to a virtual size of 2^depth.
+//
+// Generalized indices (gindices): at layer i (0-based), nodes have gindices levelBase = subtreeGeneralizedIndex << (depth-i) and node gindex = levelBase + idx.
+// Proof collection: for each layer it calls collectSibling(nodeGindex, nodeHash) and stores only those gindices registered via addTarget.
+//
+// Parameters:
+// - elements: leaf-level hashes (may be shorter than 2^depth; padding is applied with trie.ZeroHashes).
+// - subtreeGeneralizedIndex: gindex of the subtree root.
+// - depth: number of merkleization layers from subtree root to leaves.
+//
+// Returns:
+// - [32]byte: Merkle root of the subtree.
+func (pc *proofCollector) merkleizeVectorAndCollect(elements [][32]byte, subtreeGeneralizedIndex uint64, depth uint64) [32]byte {
+	// Return zerohash at depth
+	if len(elements) == 0 {
+		return trie.ZeroHashes[depth]
+	}
+	for i := range depth {
+		layerLen := len(elements)
+		oddNodeLength := layerLen%2 == 1
+		if oddNodeLength {
+			zerohash := trie.ZeroHashes[i]
+			elements = append(elements, zerohash)
+		}
+
+		levelBaseGindex := subtreeGeneralizedIndex << (depth - i)
+		for idx := range elements {
+			gindex := levelBaseGindex + uint64(idx)
+			pc.collectSibling(gindex, elements[idx])
+			pc.collectLeaf(gindex, elements[idx])
+		}
+
+		elements = htr.VectorizedSha256(elements)
+	}
+	return elements[0]
+}
+
+// mixinLengthAndCollect computes the final mix-in root for list/bitlist values:
+//
+//	root = hash(dataRoot, lengthHash)
+//
+// where chunks[0] is dataRoot and chunks[1] is the 32-byte length hash.
+//
+// Generalized indices (gindices): dataRoot is the left child (dataRootGindex = currentGindex*2) and lengthHash is the right child (lengthHashGindex = currentGindex*2+1).
+// Proof collection: it calls collectSibling/collectLeaf for both child gindices; the collector stores them only if they were registered via addTarget.
+//
+// Parameters:
+// - currentGindex: gindex of the parent node (list/bitlist root).
+// - chunks: two 32-byte nodes: [dataRoot, lengthHash].
+//
+// Returns:
+// - [32]byte: mixed-in Merkle root (or zero value on hashing error).
+// - error: any error encountered during hashing.
+func (pc *proofCollector) mixinLengthAndCollect(currentGindex uint64, chunks [][32]byte) [32]byte {
+	dataRoot, lengthHash := chunks[0], chunks[1]
+	dataRootGindex, lengthHashGindex := currentGindex*2, currentGindex*2+1
+
+	pc.collectSibling(dataRootGindex, dataRoot)
+	pc.collectSibling(lengthHashGindex, lengthHash)
+
+	pc.collectLeaf(dataRootGindex, dataRoot)
+	pc.collectLeaf(lengthHashGindex, lengthHash)
+
+	return ssz.MixInLength(dataRoot, lengthHash[:])
+}

encoding/ssz/query/proof_collector_test.go

@@ -0,0 +1,531 @@
+package query
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"reflect"
+	"slices"
+	"testing"
+
+	"github.com/OffchainLabs/go-bitfield"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stateutil"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	ssz "github.com/OffchainLabs/prysm/v7/encoding/ssz"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	sszquerypb "github.com/OffchainLabs/prysm/v7/proto/ssz_query/testing"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func TestProofCollector_New(t *testing.T) {
+	pc := newProofCollector()
+
+	require.NotNil(t, pc)
+	require.Equal(t, 0, len(pc.requiredSiblings))
+	require.Equal(t, 0, len(pc.requiredLeaves))
+	require.Equal(t, 0, len(pc.siblings))
+	require.Equal(t, 0, len(pc.leaves))
+}
+
+func TestProofCollector_Reset(t *testing.T) {
+	pc := newProofCollector()
+	pc.requiredSiblings[3] = struct{}{}
+	pc.requiredLeaves[5] = struct{}{}
+	pc.siblings[3] = [32]byte{1}
+	pc.leaves[5] = [32]byte{2}
+
+	pc.reset()
+
+	require.Equal(t, 0, len(pc.requiredSiblings))
+	require.Equal(t, 0, len(pc.requiredLeaves))
+	require.Equal(t, 0, len(pc.siblings))
+	require.Equal(t, 0, len(pc.leaves))
+}
+
+func TestProofCollector_AddTarget(t *testing.T) {
+	pc := newProofCollector()
+	pc.addTarget(5)
+
+	_, hasLeaf := pc.requiredLeaves[5]
+	_, hasSibling4 := pc.requiredSiblings[4]
+	_, hasSibling3 := pc.requiredSiblings[3]
+	_, hasSibling1 := pc.requiredSiblings[1] // GI 1 is the root
+
+	require.Equal(t, true, hasLeaf)
+	require.Equal(t, true, hasSibling4)
+	require.Equal(t, true, hasSibling3)
+	require.Equal(t, false, hasSibling1)
+}
+
+func TestProofCollector_ToProof(t *testing.T) {
+	pc := newProofCollector()
+	pc.addTarget(5)
+
+	leaf := [32]byte{9}
+	sibling4 := [32]byte{4}
+	sibling3 := [32]byte{3}
+
+	pc.collectLeaf(5, leaf)
+	pc.collectSibling(4, sibling4)
+	pc.collectSibling(3, sibling3)
+
+	proof, err := pc.toProof()
+	require.NoError(t, err)
+
+	require.Equal(t, 5, proof.Index)
+	require.DeepEqual(t, leaf[:], proof.Leaf)
+	require.Equal(t, 2, len(proof.Hashes))
+	require.DeepEqual(t, sibling4[:], proof.Hashes[0])
+	require.DeepEqual(t, sibling3[:], proof.Hashes[1])
+}
+
+func TestProofCollector_ToProof_NoLeaves(t *testing.T) {
+	pc := newProofCollector()
+	_, err := pc.toProof()
+	require.NotNil(t, err)
+}
+
+func TestProofCollector_CollectLeaf(t *testing.T) {
+	pc := newProofCollector()
+	leaf := [32]byte{7}
+
+	pc.collectLeaf(10, leaf)
+	require.Equal(t, 0, len(pc.leaves))
+
+	pc.addTarget(10)
+	pc.collectLeaf(10, leaf)
+	stored, ok := pc.leaves[10]
+	require.Equal(t, true, ok)
+	require.Equal(t, leaf, stored)
+}
+
+func TestProofCollector_CollectSibling(t *testing.T) {
+	pc := newProofCollector()
+	hash := [32]byte{5}
+
+	pc.collectSibling(4, hash)
+	require.Equal(t, 0, len(pc.siblings))
+
+	pc.addTarget(5)
+	pc.collectSibling(4, hash)
+	stored, ok := pc.siblings[4]
+	require.Equal(t, true, ok)
+	require.Equal(t, hash, stored)
+}
+
+func TestProofCollector_Merkleize_BasicTypes(t *testing.T) {
+	testCases := []struct {
+		name     string
+		sszType  SSZType
+		value    any
+		expected [32]byte
+	}{
+		{
+			name:    "uint8",
+			sszType: Uint8,
+			value:   uint8(0x11),
+			expected: func() [32]byte {
+				var leaf [32]byte
+				leaf[0] = 0x11
+				return leaf
+			}(),
+		},
+		{
+			name:    "uint16",
+			sszType: Uint16,
+			value:   uint16(0x2211),
+			expected: func() [32]byte {
+				var leaf [32]byte
+				binary.LittleEndian.PutUint16(leaf[:2], 0x2211)
+				return leaf
+			}(),
+		},
+		{
+			name:    "uint32",
+			sszType: Uint32,
+			value:   uint32(0x44332211),
+			expected: func() [32]byte {
+				var leaf [32]byte
+				binary.LittleEndian.PutUint32(leaf[:4], 0x44332211)
+				return leaf
+			}(),
+		},
+		{
+			name:    "uint64",
+			sszType: Uint64,
+			value:   uint64(0x8877665544332211),
+			expected: func() [32]byte {
+				var leaf [32]byte
+				binary.LittleEndian.PutUint64(leaf[:8], 0x8877665544332211)
+				return leaf
+			}(),
+		},
+		{
+			name:    "bool",
+			sszType: Boolean,
+			value:   true,
+			expected: func() [32]byte {
+				var leaf [32]byte
+				leaf[0] = 1
+				return leaf
+			}(),
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			pc := newProofCollector()
+			gindex := uint64(3)
+			pc.addTarget(gindex)
+
+			leaf, err := pc.merkleizeBasicType(tc.sszType, reflect.ValueOf(tc.value), gindex)
+			require.NoError(t, err)
+			require.Equal(t, tc.expected, leaf)
+
+			stored, ok := pc.leaves[gindex]
+			require.Equal(t, true, ok)
+			require.Equal(t, tc.expected, stored)
+		})
+	}
+}
+
+func TestProofCollector_Merkleize_Container(t *testing.T) {
+	container := makeFixedTestContainer()
+
+	info, err := AnalyzeObject(container)
+	require.NoError(t, err)
+
+	pc := newProofCollector()
+	pc.addTarget(1)
+
+	root, err := pc.merkleize(info, reflect.ValueOf(container), 1)
+	require.NoError(t, err)
+
+	expected, err := container.HashTreeRoot()
+	require.NoError(t, err)
+	require.Equal(t, expected, root)
+
+	stored, ok := pc.leaves[1]
+	require.Equal(t, true, ok)
+	require.Equal(t, expected, stored)
+}
+
+func TestProofCollector_Merkleize_Vector(t *testing.T) {
+	container := makeFixedTestContainer()
+	info, err := AnalyzeObject(container)
+	require.NoError(t, err)
+
+	ci, err := info.ContainerInfo()
+	require.NoError(t, err)
+	field := ci.fields["vector_field"]
+
+	pc := newProofCollector()
+	root, err := pc.merkleizeVector(field.sszInfo, reflect.ValueOf(container.VectorField), 1)
+	require.NoError(t, err)
+
+	serialized := make([][]byte, len(container.VectorField))
+	for i, v := range container.VectorField {
+		buf := make([]byte, 8)
+		binary.LittleEndian.PutUint64(buf, v)
+		serialized[i] = buf
+	}
+	chunks, err := ssz.PackByChunk(serialized)
+	require.NoError(t, err)
+	limit, err := getChunkCount(field.sszInfo)
+	require.NoError(t, err)
+	expected := ssz.MerkleizeVector(chunks, limit)
+
+	require.Equal(t, expected, root)
+}
+
+func TestProofCollector_Merkleize_List(t *testing.T) {
+	list := []*sszquerypb.FixedNestedContainer{
+		makeFixedNestedContainer(1),
+		makeFixedNestedContainer(2),
+	}
+	container := makeVariableTestContainer(list, bitfield.NewBitlist(1))
+	info, err := AnalyzeObject(container)
+	require.NoError(t, err)
+
+	ci, err := info.ContainerInfo()
+	require.NoError(t, err)
+	field := ci.fields["field_list_container"]
+
+	pc := newProofCollector()
+	root, err := pc.merkleizeList(field.sszInfo, reflect.ValueOf(list), 1)
+	require.NoError(t, err)
+
+	listInfo, err := field.sszInfo.ListInfo()
+	require.NoError(t, err)
+	expected, err := ssz.MerkleizeListSSZ(list, listInfo.Limit())
+	require.NoError(t, err)
+
+	require.Equal(t, expected, root)
+}
+
+func TestProofCollector_Merkleize_Bitvector(t *testing.T) {
+	container := makeFixedTestContainer()
+	info, err := AnalyzeObject(container)
+	require.NoError(t, err)
+
+	ci, err := info.ContainerInfo()
+	require.NoError(t, err)
+	field := ci.fields["bitvector64_field"]
+
+	pc := newProofCollector()
+	root, err := pc.merkleizeBitvector(field.sszInfo, reflect.ValueOf(container.Bitvector64Field), 1)
+	require.NoError(t, err)
+
+	expected, err := ssz.MerkleizeByteSliceSSZ([]byte(container.Bitvector64Field))
+	require.NoError(t, err)
+	require.Equal(t, expected, root)
+}
+
+func TestProofCollector_Merkleize_Bitlist(t *testing.T) {
+	bitlist := bitfield.NewBitlist(16)
+	bitlist.SetBitAt(3, true)
+	bitlist.SetBitAt(8, true)
+
+	container := makeVariableTestContainer(nil, bitlist)
+	info, err := AnalyzeObject(container)
+	require.NoError(t, err)
+
+	ci, err := info.ContainerInfo()
+	require.NoError(t, err)
+	field := ci.fields["bitlist_field"]
+
+	pc := newProofCollector()
+	root, err := pc.merkleizeBitlist(field.sszInfo, reflect.ValueOf(container.BitlistField), 1)
+	require.NoError(t, err)
+
+	bitlistInfo, err := field.sszInfo.BitlistInfo()
+	require.NoError(t, err)
+	expected, err := ssz.BitlistRoot(bitfield.Bitlist(bitlist), bitlistInfo.Limit())
+	require.NoError(t, err)
+	require.Equal(t, expected, root)
+}
+
+func TestProofCollector_MerkleizeVectorBody_Basic(t *testing.T) {
+	container := makeFixedTestContainer()
+	info, err := AnalyzeObject(container)
+	require.NoError(t, err)
+
+	ci, err := info.ContainerInfo()
+	require.NoError(t, err)
+	field := ci.fields["vector_field"]
+	vectorInfo, err := field.sszInfo.VectorInfo()
+	require.NoError(t, err)
+	length := len(container.VectorField)
+	limit, err := getChunkCount(field.sszInfo)
+	require.NoError(t, err)
+
+	pc := newProofCollector()
+	root, err := pc.merkleizeVectorBody(vectorInfo.element, reflect.ValueOf(container.VectorField), length, limit, 2)
+	require.NoError(t, err)
+
+	serialized := make([][]byte, len(container.VectorField))
+	for i, v := range container.VectorField {
+		buf := make([]byte, 8)
+		binary.LittleEndian.PutUint64(buf, v)
+		serialized[i] = buf
+	}
+	chunks, err := ssz.PackByChunk(serialized)
+	require.NoError(t, err)
+	expected := ssz.MerkleizeVector(chunks, limit)
+
+	require.Equal(t, expected, root)
+}
+
+func TestProofCollector_MerkleizeVectorAndCollect(t *testing.T) {
+	pc := newProofCollector()
+	pc.addTarget(6)
+
+	elements := [][32]byte{{1}, {2}}
+	expected := ssz.MerkleizeVector(slices.Clone(elements), 2)
+	root := pc.merkleizeVectorAndCollect(elements, 3, 1)
+
+	storedLeaf, hasLeaf := pc.leaves[6]
+	storedSibling, hasSibling := pc.siblings[7]
+
+	require.Equal(t, true, hasLeaf)
+	require.Equal(t, true, hasSibling)
+	require.Equal(t, elements[0], storedLeaf)
+	require.Equal(t, elements[1], storedSibling)
+
+	require.Equal(t, expected, root)
+}
+
+func TestProofCollector_MixinLengthAndCollect(t *testing.T) {
+	list := []*sszquerypb.FixedNestedContainer{
+		makeFixedNestedContainer(1),
+		makeFixedNestedContainer(2),
+	}
+	container := makeVariableTestContainer(list, bitfield.NewBitlist(1))
+	info, err := AnalyzeObject(container)
+	require.NoError(t, err)
+
+	ci, err := info.ContainerInfo()
+	require.NoError(t, err)
+	field := ci.fields["field_list_container"]
+
+	// Target gindex 2 (data root) - sibling at gindex 3 (length hash) should be collected
+	pc := newProofCollector()
+	pc.addTarget(2)
+	root, err := pc.merkleizeList(field.sszInfo, reflect.ValueOf(list), 1)
+	require.NoError(t, err)
+
+	listInfo, err := field.sszInfo.ListInfo()
+	require.NoError(t, err)
+	expected, err := ssz.MerkleizeListSSZ(list, listInfo.Limit())
+	require.NoError(t, err)
+	require.Equal(t, expected, root)
+
+	// Verify data root is collected as leaf at gindex 2
+	storedLeaf, hasLeaf := pc.leaves[2]
+	require.Equal(t, true, hasLeaf)
+
+	// Verify length hash is collected as sibling at gindex 3
+	storedSibling, hasSibling := pc.siblings[3]
+	require.Equal(t, true, hasSibling)
+
+	// Verify the root is hash(dataRoot || lengthHash)
+	expectedBuf := append(storedLeaf[:], storedSibling[:]...)
+	expectedRoot := sha256.Sum256(expectedBuf)
+	require.Equal(t, expectedRoot, root)
+}
+
+func BenchmarkOptimizedValidatorRoots(b *testing.B) {
+	validators := make([]*ethpb.Validator, 1000)
+	for i := range validators {
+		validators[i] = makeTestValidator(i)
+	}
+
+	b.ResetTimer()
+	for b.Loop() {
+		_, err := stateutil.OptimizedValidatorRoots(validators)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkProofCollectorMerkleize(b *testing.B) {
+	validators := make([]*ethpb.Validator, 1000)
+	for i := range validators {
+		validators[i] = makeTestValidator(i)
+	}
+
+	info, err := AnalyzeObject(validators[0])
+	require.NoError(b, err)
+
+	b.ResetTimer()
+	for b.Loop() {
+		for _, val := range validators {
+			pc := newProofCollector()
+			v := reflect.ValueOf(val)
+			_, err := pc.merkleize(info, v, 1)
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	}
+}
+
+func makeTestValidator(i int) *ethpb.Validator {
+	pubkey := make([]byte, 48)
+	for j := range pubkey {
+		pubkey[j] = byte(i + j)
+	}
+
+	withdrawalCredentials := make([]byte, 32)
+	for j := range withdrawalCredentials {
+		withdrawalCredentials[j] = byte(255 - ((i + j) % 256))
+	}
+
+	return &ethpb.Validator{
+		PublicKey:                  pubkey,
+		WithdrawalCredentials:      withdrawalCredentials,
+		EffectiveBalance:           uint64(32000000000 + i),
+		Slashed:                    i%2 == 0,
+		ActivationEligibilityEpoch: primitives.Epoch(i),
+		ActivationEpoch:            primitives.Epoch(i + 1),
+		ExitEpoch:                  primitives.Epoch(i + 2),
+		WithdrawableEpoch:          primitives.Epoch(i + 3),
+	}
+}
+
+func makeFixedNestedContainer(value uint64) *sszquerypb.FixedNestedContainer {
+	value2 := make([]byte, 32)
+	for i := range value2 {
+		value2[i] = byte(i)
+	}
+	return &sszquerypb.FixedNestedContainer{
+		Value1: value,
+		Value2: value2,
+	}
+}
+
+func makeFixedTestContainer() *sszquerypb.FixedTestContainer {
+	fieldBytes32 := make([]byte, 32)
+	for i := range fieldBytes32 {
+		fieldBytes32[i] = byte(i)
+	}
+
+	vectorField := make([]uint64, 24)
+	for i := range vectorField {
+		vectorField[i] = uint64(i)
+	}
+
+	rows := make([][]byte, 5)
+	for i := range rows {
+		row := make([]byte, 32)
+		for j := range row {
+			row[j] = byte(i) + byte(j)
+		}
+		rows[i] = row
+	}
+
+	bitvector64 := bitfield.NewBitvector64()
+	bitvector64.SetBitAt(1, true)
+	bitvector512 := bitfield.NewBitvector512()
+	bitvector512.SetBitAt(10, true)
+
+	trailing := make([]byte, 56)
+	for i := range trailing {
+		trailing[i] = byte(i)
+	}
+
+	return &sszquerypb.FixedTestContainer{
+		FieldUint32:            1,
+		FieldUint64:            2,
+		FieldBool:              true,
+		FieldBytes32:           fieldBytes32,
+		Nested:                 makeFixedNestedContainer(3),
+		VectorField:            vectorField,
+		TwoDimensionBytesField: rows,
+		Bitvector64Field:       bitvector64,
+		Bitvector512Field:      bitvector512,
+		TrailingField:          trailing,
+	}
+}
+
+func makeVariableTestContainer(list []*sszquerypb.FixedNestedContainer, bitlist bitfield.Bitlist) *sszquerypb.VariableTestContainer {
+	leading := make([]byte, 32)
+	for i := range leading {
+		leading[i] = byte(i)
+	}
+	trailing := make([]byte, 56)
+	for i := range trailing {
+		trailing[i] = byte(255 - i)
+	}
+
+	if bitlist == nil {
+		bitlist = bitfield.NewBitlist(0)
+	}
+
+	return &sszquerypb.VariableTestContainer{
+		LeadingField:       leading,
+		FieldListContainer: list,
+		BitlistField:       bitlist,
+		TrailingField:      trailing,
+	}
+}

encoding/ssz/query/query_test.go

@@ -389,6 +389,7 @@ func TestHashTreeRoot(t *testing.T) {
 			require.NoError(t, err, "HashTreeRoot should not return an error")
 			expectedHashTreeRoot, err := tt.obj.HashTreeRoot()
 			require.NoError(t, err, "HashTreeRoot on original object should not return an error")
+			// Verify the Merkle tree root matches with the SSZ generated HashTreeRoot
 			require.Equal(t, expectedHashTreeRoot, hashTreeRoot, "HashTreeRoot from sszInfo should match original object's HashTreeRoot")
 		})
 	}

specrefs/README.md

@@ -0,0 +1,35 @@
+# Specification References
+
+This directory contains specification reference tracking files managed by
+[ethspecify](https://github.com/jtraglia/ethspecify).
+
+## Installation
+
+Install `ethspecify` with the following command:
+
+```bash
+pipx install ethspecify
+```
+
+> [!NOTE]
+> You can run `ethspecify <cmd>` in the `specrefs` directory or
+> `ethspecify <cmd> --path=specrefs` from the project's root directory.
+
+## Maintenance
+
+When adding support for a new specification version, follow these steps:
+
+0. Change directory into the `specrefs` directory.
+1. Update the version in `.ethspecify.yml` configuration.
+2. Run `ethspecify process` to update/populate specrefs.
+3. Run `ethspecify check` to check specrefs.
+4. If there are errors, use the error message as a guide to fix the issue. If
+   there are new specrefs with empty sources, implement/locate each item and
+   update each specref source list. If you choose not to implement an item,
+   add an exception to the appropriate section the the `.ethspecify.yml`
+   configuration.
+5. Repeat steps 3 and 4 until `ethspecify check` passes.
+6. Run `git diff` to view updated specrefs. If an object/function/etc has
+   changed, make the necessary updates to the implementation.
+7. Lastly, in the project's root directory, run `act -j check-specrefs` to
+   ensure everything is correct.

testing/endtoend/components/BUILD.bazel

@@ -47,7 +47,6 @@ go_library(
         "@in_gopkg_yaml_v2//:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
-        "@org_golang_x_sys//unix:go_default_library",
     ],
 )
 

testing/endtoend/components/beacon_node.go

@@ -11,7 +11,6 @@ import (
 	"strconv"
 	"strings"
 	"syscall"
-	"time"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	cmdshared "github.com/OffchainLabs/prysm/v7/cmd"
@@ -36,12 +35,11 @@ var _ e2etypes.BeaconNodeSet = (*BeaconNodeSet)(nil)
 // BeaconNodeSet represents set of beacon nodes.
 type BeaconNodeSet struct {
 	e2etypes.ComponentRunner
-	config     *e2etypes.E2EConfig
-	nodes      []e2etypes.ComponentRunner
-	enr        string
-	ids        []string
-	multiAddrs []string
-	started    chan struct{}
+	config  *e2etypes.E2EConfig
+	nodes   []e2etypes.ComponentRunner
+	enr     string
+	ids     []string
+	started chan struct{}
 }
 
 // SetENR assigns ENR to the set of beacon nodes.
@@ -76,10 +74,8 @@ func (s *BeaconNodeSet) Start(ctx context.Context) error {
 		if s.config.UseFixedPeerIDs {
 			for i := range nodes {
 				s.ids = append(s.ids, nodes[i].(*BeaconNode).peerID)
-				s.multiAddrs = append(s.multiAddrs, nodes[i].(*BeaconNode).multiAddr)
 			}
 			s.config.PeerIDs = s.ids
-			s.config.PeerMultiAddrs = s.multiAddrs
 		}
 		// All nodes started, close channel, so that all services waiting on a set, can proceed.
 		close(s.started)
@@ -145,14 +141,6 @@ func (s *BeaconNodeSet) StopAtIndex(i int) error {
 	return s.nodes[i].Stop()
 }
 
-// RestartAtIndex restarts the component at the desired index.
-func (s *BeaconNodeSet) RestartAtIndex(ctx context.Context, i int) error {
-	if i >= len(s.nodes) {
-		return errors.Errorf("provided index exceeds slice size: %d >= %d", i, len(s.nodes))
-	}
-	return s.nodes[i].(*BeaconNode).Restart(ctx)
-}
-
 // ComponentAtIndex returns the component at the provided index.
 func (s *BeaconNodeSet) ComponentAtIndex(i int) (e2etypes.ComponentRunner, error) {
 	if i >= len(s.nodes) {
@@ -164,14 +152,12 @@ func (s *BeaconNodeSet) ComponentAtIndex(i int) (e2etypes.ComponentRunner, error
 // BeaconNode represents beacon node.
 type BeaconNode struct {
 	e2etypes.ComponentRunner
-	config    *e2etypes.E2EConfig
-	started   chan struct{}
-	index     int
-	enr       string
-	peerID    string
-	multiAddr string
-	cmd       *exec.Cmd
-	args      []string
+	config  *e2etypes.E2EConfig
+	started chan struct{}
+	index   int
+	enr     string
+	peerID  string
+	cmd     *exec.Cmd
 }
 
 // NewBeaconNode creates and returns a beacon node.
@@ -304,7 +290,6 @@ func (node *BeaconNode) Start(ctx context.Context) error {
 		args = append(args, fmt.Sprintf("--%s=%s:%d", flags.MevRelayEndpoint.Name, "http://127.0.0.1", e2e.TestParams.Ports.Eth1ProxyPort+index))
 	}
 	args = append(args, config.BeaconFlags...)
-	node.args = args
 
 	cmd := exec.CommandContext(ctx, binaryPath, args...) // #nosec G204 -- Safe
 	// Write stderr to log files.
@@ -333,18 +318,6 @@ func (node *BeaconNode) Start(ctx context.Context) error {
 			return fmt.Errorf("could not find peer id: %w", err)
 		}
 		node.peerID = peerId
-
-		// Extract QUIC multiaddr for Lighthouse to connect to this node.
-		// Prysm logs: msg="Node started p2p server" multiAddr="/ip4/192.168.0.14/udp/4250/quic-v1/p2p/16Uiu2..."
-		// We prefer QUIC over TCP as it's more reliable in E2E tests.
-		multiAddr, err := helpers.FindFollowingTextInFile(stdOutFile, "multiAddr=\"/ip4/192.168.0.14/udp/")
-		if err != nil {
-			return fmt.Errorf("could not find QUIC multiaddr: %w", err)
-		}
-		// The extracted text will be like: 4250/quic-v1/p2p/16Uiu2..."
-		// We need to prepend "/ip4/192.168.0.14/udp/" and strip the trailing quote
-		multiAddr = strings.TrimSuffix(multiAddr, "\"")
-		node.multiAddr = "/ip4/192.168.0.14/udp/" + multiAddr
 	}
 
 	// Mark node as ready.
@@ -374,96 +347,6 @@ func (node *BeaconNode) Stop() error {
 	return node.cmd.Process.Kill()
 }
 
-// Restart gracefully stops the beacon node and starts a new process.
-// This is useful for testing resilience as it allows the P2P layer to reinitialize
-// and discover peers again (unlike SIGSTOP/SIGCONT which breaks QUIC connections permanently).
-func (node *BeaconNode) Restart(ctx context.Context) error {
-	binaryPath, found := bazel.FindBinary("cmd/beacon-chain", "beacon-chain")
-	if !found {
-		return errors.New("beacon chain binary not found")
-	}
-
-	// First, continue the process if it's stopped (from PauseAtIndex).
-	// A stopped process (SIGSTOP) cannot receive SIGTERM until continued.
-	_ = node.cmd.Process.Signal(syscall.SIGCONT)
-
-	if err := node.cmd.Process.Signal(syscall.SIGTERM); err != nil {
-		return fmt.Errorf("failed to send SIGTERM: %w", err)
-	}
-
-	// Wait for process to exit by polling. We can't call cmd.Wait() here because
-	// the Start() method's goroutine is already waiting on the command, and calling
-	// Wait() twice on the same process causes "waitid: no child processes" error.
-	// Instead, poll using Signal(0) which returns an error when the process no longer exists.
-	processExited := false
-	for range 100 {
-		if err := node.cmd.Process.Signal(syscall.Signal(0)); err != nil {
-			processExited = true
-			break
-		}
-		time.Sleep(100 * time.Millisecond)
-	}
-	if !processExited {
-		log.Warnf("Beacon node %d did not exit within 10 seconds after SIGTERM, proceeding with restart anyway", node.index)
-	}
-
-	restartArgs := make([]string, 0, len(node.args))
-	for _, arg := range node.args {
-		if !strings.Contains(arg, cmdshared.ForceClearDB.Name) {
-			restartArgs = append(restartArgs, arg)
-		}
-	}
-
-	stdOutFile, err := os.OpenFile(
-		path.Join(e2e.TestParams.LogPath, fmt.Sprintf(e2e.BeaconNodeLogFileName, node.index)),
-		os.O_APPEND|os.O_WRONLY,
-		0644,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to open log file: %w", err)
-	}
-	defer func() {
-		if err := stdOutFile.Close(); err != nil {
-			log.WithError(err).Error("Failed to close stdout file")
-		}
-	}()
-
-	cmd := exec.CommandContext(ctx, binaryPath, restartArgs...)
-	stderr, err := os.OpenFile(
-		path.Join(e2e.TestParams.LogPath, fmt.Sprintf("beacon_node_%d_stderr.log", node.index)),
-		os.O_APPEND|os.O_WRONLY|os.O_CREATE,
-		0644,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to open stderr file: %w", err)
-	}
-	cmd.Stderr = stderr
-
-	log.Infof("Restarting beacon chain %d with flags: %s", node.index, strings.Join(restartArgs, " "))
-	if err = cmd.Start(); err != nil {
-		if closeErr := stderr.Close(); closeErr != nil {
-			log.WithError(closeErr).Error("Failed to close stderr file")
-		}
-		return fmt.Errorf("failed to restart beacon node: %w", err)
-	}
-	// Close the parent's file handle after Start(). The child process has its own
-	// copy of the file descriptor via fork/exec, so this won't affect its ability to write.
-	if err := stderr.Close(); err != nil {
-		log.WithError(err).Error("Failed to close stderr file")
-	}
-
-	if err = helpers.WaitForTextInFile(stdOutFile, "Beacon chain gRPC server listening"); err != nil {
-		return fmt.Errorf("beacon node %d failed to restart properly: %w", node.index, err)
-	}
-
-	node.cmd = cmd
-	go func() {
-		_ = cmd.Wait()
-	}()
-
-	return nil
-}
-
 func (node *BeaconNode) UnderlyingProcess() *os.Process {
 	return node.cmd.Process
 }

testing/endtoend/components/builder.go

@@ -108,17 +108,6 @@ func (s *BuilderSet) StopAtIndex(i int) error {
 	return s.builders[i].Stop()
 }
 
-// RestartAtIndex for builders just does pause/resume.
-func (s *BuilderSet) RestartAtIndex(_ context.Context, i int) error {
-	if i >= len(s.builders) {
-		return errors.Errorf("provided index exceeds slice size: %d >= %d", i, len(s.builders))
-	}
-	if err := s.builders[i].Pause(); err != nil {
-		return err
-	}
-	return s.builders[i].Resume()
-}
-
 // ComponentAtIndex returns the component at the provided index.
 func (s *BuilderSet) ComponentAtIndex(i int) (e2etypes.ComponentRunner, error) {
 	if i >= len(s.builders) {

testing/endtoend/components/eth1/node_set.go

@@ -111,17 +111,6 @@ func (s *NodeSet) StopAtIndex(i int) error {
 	return s.nodes[i].Stop()
 }
 
-// RestartAtIndex for eth1 nodes just does pause/resume.
-func (s *NodeSet) RestartAtIndex(_ context.Context, i int) error {
-	if i >= len(s.nodes) {
-		return errors.Errorf("provided index exceeds slice size: %d >= %d", i, len(s.nodes))
-	}
-	if err := s.nodes[i].Pause(); err != nil {
-		return err
-	}
-	return s.nodes[i].Resume()
-}
-
 // ComponentAtIndex returns the component at the provided index.
 func (s *NodeSet) ComponentAtIndex(i int) (e2etypes.ComponentRunner, error) {
 	if i >= len(s.nodes) {

testing/endtoend/components/eth1/proxy.go

@@ -108,17 +108,6 @@ func (s *ProxySet) StopAtIndex(i int) error {
 	return s.proxies[i].Stop()
 }
 
-// RestartAtIndex for proxies just does pause/resume.
-func (s *ProxySet) RestartAtIndex(_ context.Context, i int) error {
-	if i >= len(s.proxies) {
-		return errors.Errorf("provided index exceeds slice size: %d >= %d", i, len(s.proxies))
-	}
-	if err := s.proxies[i].Pause(); err != nil {
-		return err
-	}
-	return s.proxies[i].Resume()
-}
-
 // ComponentAtIndex returns the component at the provided index.
 func (s *ProxySet) ComponentAtIndex(i int) (e2etypes.ComponentRunner, error) {
 	if i >= len(s.proxies) {

testing/endtoend/components/lighthouse_beacon.go

@@ -127,17 +127,6 @@ func (s *LighthouseBeaconNodeSet) StopAtIndex(i int) error {
 	return s.nodes[i].Stop()
 }
 
-// RestartAtIndex for Lighthouse just does pause/resume.
-func (s *LighthouseBeaconNodeSet) RestartAtIndex(_ context.Context, i int) error {
-	if i >= len(s.nodes) {
-		return errors.Errorf("provided index exceeds slice size: %d >= %d", i, len(s.nodes))
-	}
-	if err := s.nodes[i].Pause(); err != nil {
-		return err
-	}
-	return s.nodes[i].Resume()
-}
-
 // ComponentAtIndex returns the component at the provided index.
 func (s *LighthouseBeaconNodeSet) ComponentAtIndex(i int) (e2etypes.ComponentRunner, error) {
 	if i >= len(s.nodes) {
@@ -205,10 +194,9 @@ func (node *LighthouseBeaconNode) Start(ctx context.Context) error {
 		"--suggested-fee-recipient=0x878705ba3f8bc32fcf7f4caa1a35e72af65cf766",
 	}
 	if node.config.UseFixedPeerIDs {
-		// Use libp2p-addresses with full multiaddrs instead of trusted-peers with just peer IDs.
-		// This allows Lighthouse to connect directly to Prysm nodes without relying on DHT discovery.
-		flagVal := strings.Join(node.config.PeerMultiAddrs, ",")
-		args = append(args, fmt.Sprintf("--libp2p-addresses=%s", flagVal))
+		flagVal := strings.Join(node.config.PeerIDs, ",")
+		args = append(args,
+			fmt.Sprintf("--trusted-peers=%s", flagVal))
 	}
 	if node.config.UseBuilder {
 		args = append(args, fmt.Sprintf("--builder=%s:%d", "http://127.0.0.1", e2e.TestParams.Ports.Eth1ProxyPort+prysmNodeCount+index))

testing/endtoend/components/lighthouse_validator.go

@@ -132,17 +132,6 @@ func (s *LighthouseValidatorNodeSet) StopAtIndex(i int) error {
 	return s.nodes[i].Stop()
 }
 
-// RestartAtIndex for Lighthouse validators just does pause/resume.
-func (s *LighthouseValidatorNodeSet) RestartAtIndex(_ context.Context, i int) error {
-	if i >= len(s.nodes) {
-		return errors.Errorf("provided index exceeds slice size: %d >= %d", i, len(s.nodes))
-	}
-	if err := s.nodes[i].Pause(); err != nil {
-		return err
-	}
-	return s.nodes[i].Resume()
-}
-
 // ComponentAtIndex returns the component at the provided index.
 func (s *LighthouseValidatorNodeSet) ComponentAtIndex(i int) (types.ComponentRunner, error) {
 	if i >= len(s.nodes) {

testing/endtoend/components/tracing_sink.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"encoding/base64"
 	"io"
-	"net"
 	"net/http"
 	"os"
 	"os/signal"
@@ -16,7 +15,6 @@ import (
 	e2e "github.com/OffchainLabs/prysm/v7/testing/endtoend/params"
 	"github.com/OffchainLabs/prysm/v7/testing/endtoend/types"
 	"github.com/pkg/errors"
-	"golang.org/x/sys/unix"
 )
 
 var _ types.ComponentRunner = &TracingSink{}
@@ -34,7 +32,6 @@ var _ types.ComponentRunner = &TracingSink{}
 type TracingSink struct {
 	cancel   context.CancelFunc
 	started  chan struct{}
-	stopped  chan struct{}
 	endpoint string
 	server   *http.Server
 }
@@ -43,7 +40,6 @@ type TracingSink struct {
 func NewTracingSink(endpoint string) *TracingSink {
 	return &TracingSink{
 		started:  make(chan struct{}, 1),
-		stopped:  make(chan struct{}),
 		endpoint: endpoint,
 	}
 }
@@ -77,99 +73,62 @@ func (ts *TracingSink) Resume() error {
 
 // Stop stops the component and its underlying process.
 func (ts *TracingSink) Stop() error {
-	if ts.cancel != nil {
-		ts.cancel()
-	}
-	// Wait for server to actually shut down before returning
-	<-ts.stopped
+	ts.cancel()
 	return nil
 }
 
-// reusePortListener creates a TCP listener with SO_REUSEADDR set, allowing
-// the port to be reused immediately after the previous listener closes.
-// This is essential for sequential E2E tests that reuse the same port.
-func reusePortListener(addr string) (net.Listener, error) {
-	lc := net.ListenConfig{
-		Control: func(network, address string, c syscall.RawConn) error {
-			var setSockOptErr error
-			err := c.Control(func(fd uintptr) {
-				setSockOptErr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
-			})
-			if err != nil {
-				return err
-			}
-			return setSockOptErr
-		},
-	}
-	return lc.Listen(context.Background(), "tcp", addr)
-}
-
 // Initialize an http handler that writes all requests to a file.
 func (ts *TracingSink) initializeSink(ctx context.Context) {
-	defer close(ts.stopped)
-
 	mux := &http.ServeMux{}
 	ts.server = &http.Server{
 		Addr:              ts.endpoint,
 		Handler:           mux,
 		ReadHeaderTimeout: time.Second,
 	}
-	// Disable keep-alives to ensure connections close immediately
-	ts.server.SetKeepAlivesEnabled(false)
-
-	// Create listener with SO_REUSEADDR to allow port reuse between tests
-	listener, err := reusePortListener(ts.endpoint)
-	if err != nil {
-		log.WithError(err).Error("Failed to create listener")
-		return
-	}
-
+	defer func() {
+		if err := ts.server.Close(); err != nil {
+			log.WithError(err).Error("Failed to close http server")
+			return
+		}
+	}()
 	stdOutFile, err := helpers.DeleteAndCreateFile(e2e.TestParams.LogPath, e2e.TracingRequestSinkFileName)
 	if err != nil {
 		log.WithError(err).Error("Failed to create stdout file")
-		if closeErr := listener.Close(); closeErr != nil {
-			log.WithError(closeErr).Error("Failed to close listener after file creation error")
-		}
 		return
 	}
-
 	cleanup := func() {
 		if err := stdOutFile.Close(); err != nil {
 			log.WithError(err).Error("Could not close stdout file")
 		}
-		// Use Shutdown for graceful shutdown that releases the port
-		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-		if err := ts.server.Shutdown(shutdownCtx); err != nil {
-			log.WithError(err).Error("Could not gracefully shutdown http server")
-			// Force close if shutdown times out
-			if err := ts.server.Close(); err != nil {
-				log.WithError(err).Error("Could not close http server")
-			}
+		if err := ts.server.Close(); err != nil {
+			log.WithError(err).Error("Could not close http server")
 		}
 	}
-	defer cleanup()
-
 	mux.HandleFunc("/", func(_ http.ResponseWriter, r *http.Request) {
 		if err := captureRequest(stdOutFile, r); err != nil {
 			log.WithError(err).Error("Failed to capture http request")
 			return
 		}
 	})
-
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
-		select {
-		case <-ctx.Done():
-			return
-		case <-sigs:
-			return
+		for {
+			select {
+			case <-ctx.Done():
+				cleanup()
+				return
+			case <-sigs:
+				cleanup()
+				return
+			default:
+				// Sleep for 100ms and do nothing while waiting for
+				// cancellation.
+				time.Sleep(100 * time.Millisecond)
+			}
 		}
 	}()
-
-	// Use Serve with our custom listener instead of ListenAndServe
-	if err := ts.server.Serve(listener); err != nil && err != http.ErrServerClosed {
+	if err := ts.server.ListenAndServe(); err != http.ErrServerClosed {
 		log.WithError(err).Error("Failed to serve http")
 	}
 }

testing/endtoend/components/validator.go

@@ -134,17 +134,6 @@ func (s *ValidatorNodeSet) StopAtIndex(i int) error {
 	return s.nodes[i].Stop()
 }
 
-// RestartAtIndex for validators just does pause/resume since they don't have P2P issues.
-func (s *ValidatorNodeSet) RestartAtIndex(_ context.Context, i int) error {
-	if i >= len(s.nodes) {
-		return errors.Errorf("provided index exceeds slice size: %d >= %d", i, len(s.nodes))
-	}
-	if err := s.nodes[i].Pause(); err != nil {
-		return err
-	}
-	return s.nodes[i].Resume()
-}
-
 // ComponentAtIndex returns the component at the provided index.
 func (s *ValidatorNodeSet) ComponentAtIndex(i int) (e2etypes.ComponentRunner, error) {
 	if i >= len(s.nodes) {

testing/endtoend/endtoend_test.go

@@ -48,6 +48,7 @@ const (
 	// allNodesStartTimeout defines period after which nodes are considered
 	// stalled (safety measure for nodes stuck at startup, shouldn't normally happen).
 	allNodesStartTimeout = 5 * time.Minute
+
 	// errGeneralCode is used to represent the string value for all general process errors.
 	errGeneralCode = "exit status 1"
 )
@@ -194,20 +195,12 @@ func (r *testRunner) runEvaluators(ec *e2etypes.EvaluationContext, conns []*grpc
 	secondsPerEpoch := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
 	ticker := helpers.NewEpochTicker(tickingStartTime, secondsPerEpoch)
 	for currentEpoch := range ticker.C() {
-		log.WithField("epoch", currentEpoch).Info("Processing epoch")
 		if config.EvalInterceptor(ec, currentEpoch, conns) {
-			log.WithField("epoch", currentEpoch).Info("Interceptor returned true, skipping evaluators")
 			continue
 		}
 		r.executeProvidedEvaluators(ec, currentEpoch, conns, config.Evaluators)
 
 		if t.Failed() || currentEpoch >= config.EpochsToRun-1 {
-			log.WithFields(log.Fields{
-				"currentEpoch":  currentEpoch,
-				"EpochsToRun":   config.EpochsToRun,
-				"testFailed":    t.Failed(),
-				"epochLimitHit": currentEpoch >= config.EpochsToRun-1,
-			}).Info("Stopping evaluator loop")
 			ticker.Done()
 			if t.Failed() {
 				return errors.New("test failed")
@@ -247,8 +240,7 @@ func (r *testRunner) testDepositsAndTx(ctx context.Context, g *errgroup.Group,
 				}
 			}
 			// Only generate background transactions when relevant for the test.
-			// Checkpoint sync and REST API tests need EL blocks to advance, so include them.
-			if r.config.TestDeposits || r.config.TestFeature || r.config.UseBuilder || r.config.TestCheckpointSync || r.config.UseBeaconRestApi {
+			if r.config.TestDeposits || r.config.TestFeature || r.config.UseBuilder {
 				r.testTxGeneration(ctx, g, keystorePath, []e2etypes.ComponentRunner{})
 			}
 		}()
@@ -630,7 +622,7 @@ func (r *testRunner) scenarioRun() error {
 	tickingStartTime := helpers.EpochTickerStartTime(genesis)
 
 	ec := e2etypes.NewEvaluationContext(r.depositor.History())
-	log.WithField("EpochsToRun", r.config.EpochsToRun).Info("Starting evaluators")
+	// Run assigned evaluators.
 	return r.runEvaluators(ec, conns, tickingStartTime)
 }
 
@@ -676,9 +668,9 @@ func (r *testRunner) multiScenarioMulticlient(ec *e2etypes.EvaluationContext, ep
 	freezeStartEpoch := lastForkEpoch + 1
 	freezeEndEpoch := lastForkEpoch + 2
 	optimisticStartEpoch := lastForkEpoch + 6
-	optimisticEndEpoch := lastForkEpoch + 8
+	optimisticEndEpoch := lastForkEpoch + 7
 	recoveryEpochStart, recoveryEpochEnd := lastForkEpoch+3, lastForkEpoch+4
-	secondRecoveryEpochStart, secondRecoveryEpochMid, secondRecoveryEpochEnd := lastForkEpoch+9, lastForkEpoch+10, lastForkEpoch+11
+	secondRecoveryEpochStart, secondRecoveryEpochEnd := lastForkEpoch+8, lastForkEpoch+9
 
 	newPayloadMethod := "engine_newPayloadV4"
 	forkChoiceUpdatedMethod := "engine_forkchoiceUpdatedV3"
@@ -688,18 +680,13 @@ func (r *testRunner) multiScenarioMulticlient(ec *e2etypes.EvaluationContext, ep
 		forkChoiceUpdatedMethod = "engine_forkchoiceUpdatedV3"
 	}
 
-	// Skip evaluators during optimistic sync window (between start and end, exclusive)
-	if primitives.Epoch(epoch) > optimisticStartEpoch && primitives.Epoch(epoch) < optimisticEndEpoch {
-		return true
-	}
-
 	switch primitives.Epoch(epoch) {
 	case freezeStartEpoch:
 		require.NoError(r.t, r.comHandler.beaconNodes.PauseAtIndex(0))
 		require.NoError(r.t, r.comHandler.validatorNodes.PauseAtIndex(0))
 		return true
 	case freezeEndEpoch:
-		require.NoError(r.t, r.comHandler.beaconNodes.RestartAtIndex(r.comHandler.ctx, 0))
+		require.NoError(r.t, r.comHandler.beaconNodes.ResumeAtIndex(0))
 		require.NoError(r.t, r.comHandler.validatorNodes.ResumeAtIndex(0))
 		return true
 	case optimisticStartEpoch:
@@ -714,19 +701,6 @@ func (r *testRunner) multiScenarioMulticlient(ec *e2etypes.EvaluationContext, ep
 		}, func() bool {
 			return true
 		})
-		// Also intercept forkchoiceUpdated for prysm beacon node to prevent
-		// SetOptimisticToValid from clearing the optimistic status.
-		component.(e2etypes.EngineProxy).AddRequestInterceptor(forkChoiceUpdatedMethod, func() any {
-			return &ForkchoiceUpdatedResponse{
-				Status: &enginev1.PayloadStatus{
-					Status:          enginev1.PayloadStatus_SYNCING,
-					LatestValidHash: nil,
-				},
-				PayloadId: nil,
-			}
-		}, func() bool {
-			return true
-		})
 		// Set it for lighthouse beacon node.
 		component, err = r.comHandler.eth1Proxy.ComponentAtIndex(2)
 		require.NoError(r.t, err)
@@ -760,7 +734,6 @@ func (r *testRunner) multiScenarioMulticlient(ec *e2etypes.EvaluationContext, ep
 		engineProxy, ok := component.(e2etypes.EngineProxy)
 		require.Equal(r.t, true, ok)
 		engineProxy.RemoveRequestInterceptor(newPayloadMethod)
-		engineProxy.RemoveRequestInterceptor(forkChoiceUpdatedMethod)
 		engineProxy.ReleaseBackedUpRequests(newPayloadMethod)
 
 		// Remove for lighthouse too
@@ -774,8 +747,8 @@ func (r *testRunner) multiScenarioMulticlient(ec *e2etypes.EvaluationContext, ep
 
 		return true
 	case recoveryEpochStart, recoveryEpochEnd,
-		secondRecoveryEpochStart, secondRecoveryEpochMid, secondRecoveryEpochEnd:
-		// Allow epochs for the network to finalize again after optimistic sync test.
+		secondRecoveryEpochStart, secondRecoveryEpochEnd:
+		// Allow 2 epochs for the network to finalize again.
 		return true
 	}
 	return false
@@ -809,39 +782,31 @@ func (r *testRunner) eeOffline(_ *e2etypes.EvaluationContext, epoch uint64, _ []
 // as expected.
 func (r *testRunner) multiScenario(ec *e2etypes.EvaluationContext, epoch uint64, conns []*grpc.ClientConn) bool {
 	lastForkEpoch := params.LastForkEpoch()
-	// Freeze/restart scenario is skipped in minimal test: With only 2 beacon nodes,
-	// when one node restarts it enters initial sync mode. During initial sync, the
-	// restarting node doesn't subscribe to gossip topics, leaving the other node with
-	// 0 gossip peers. This causes a deadlock where the network can't produce blocks
-	// consistently (no gossip mesh) and the restarting node can't complete initial sync
-	// (no blocks being produced). This scenario works in multiclient test (4 nodes)
-	// where 3 healthy nodes maintain the gossip mesh while 1 node syncs.
+	freezeStartEpoch := lastForkEpoch + 1
+	freezeEndEpoch := lastForkEpoch + 2
 	valOfflineStartEpoch := lastForkEpoch + 6
 	valOfflineEndEpoch := lastForkEpoch + 7
 	optimisticStartEpoch := lastForkEpoch + 11
-	optimisticEndEpoch := lastForkEpoch + 13
+	optimisticEndEpoch := lastForkEpoch + 12
 
+	recoveryEpochStart, recoveryEpochEnd := lastForkEpoch+3, lastForkEpoch+4
 	secondRecoveryEpochStart, secondRecoveryEpochEnd := lastForkEpoch+8, lastForkEpoch+9
-	thirdRecoveryEpochStart, thirdRecoveryEpochEnd := lastForkEpoch+14, lastForkEpoch+15
-
-	type ForkchoiceUpdatedResponse struct {
-		Status    *enginev1.PayloadStatus  `json:"payloadStatus"`
-		PayloadId *enginev1.PayloadIDBytes `json:"payloadId"`
-	}
+	thirdRecoveryEpochStart, thirdRecoveryEpochEnd := lastForkEpoch+13, lastForkEpoch+14
 
 	newPayloadMethod := "engine_newPayloadV4"
-	forkChoiceUpdatedMethod := "engine_forkchoiceUpdatedV3"
 	//  Fallback if Electra is not set.
 	if params.BeaconConfig().ElectraForkEpoch == math.MaxUint64 {
 		newPayloadMethod = "engine_newPayloadV3"
 	}
-
-	// Skip evaluators during optimistic sync window (between start and end, exclusive)
-	if primitives.Epoch(epoch) > optimisticStartEpoch && primitives.Epoch(epoch) < optimisticEndEpoch {
-		return true
-	}
-
 	switch primitives.Epoch(epoch) {
+	case freezeStartEpoch:
+		require.NoError(r.t, r.comHandler.beaconNodes.PauseAtIndex(0))
+		require.NoError(r.t, r.comHandler.validatorNodes.PauseAtIndex(0))
+		return true
+	case freezeEndEpoch:
+		require.NoError(r.t, r.comHandler.beaconNodes.ResumeAtIndex(0))
+		require.NoError(r.t, r.comHandler.validatorNodes.ResumeAtIndex(0))
+		return true
 	case valOfflineStartEpoch:
 		require.NoError(r.t, r.comHandler.validatorNodes.PauseAtIndex(0))
 		require.NoError(r.t, r.comHandler.validatorNodes.PauseAtIndex(1))
@@ -861,36 +826,23 @@ func (r *testRunner) multiScenario(ec *e2etypes.EvaluationContext, epoch uint64,
 		}, func() bool {
 			return true
 		})
-		// Also intercept forkchoiceUpdated to prevent SetOptimisticToValid from
-		// clearing the optimistic status when the beacon node receives VALID.
-		component.(e2etypes.EngineProxy).AddRequestInterceptor(forkChoiceUpdatedMethod, func() any {
-			return &ForkchoiceUpdatedResponse{
-				Status: &enginev1.PayloadStatus{
-					Status:          enginev1.PayloadStatus_SYNCING,
-					LatestValidHash: nil,
-				},
-				PayloadId: nil,
-			}
-		}, func() bool {
-			return true
-		})
 		return true
 	case optimisticEndEpoch:
 		evs := []e2etypes.Evaluator{ev.OptimisticSyncEnabled}
 		r.executeProvidedEvaluators(ec, epoch, []*grpc.ClientConn{conns[0]}, evs)
-		// Disable Interceptors
+		// Disable Interceptor
 		component, err := r.comHandler.eth1Proxy.ComponentAtIndex(0)
 		require.NoError(r.t, err)
 		engineProxy, ok := component.(e2etypes.EngineProxy)
 		require.Equal(r.t, true, ok)
 		engineProxy.RemoveRequestInterceptor(newPayloadMethod)
 		engineProxy.ReleaseBackedUpRequests(newPayloadMethod)
-		engineProxy.RemoveRequestInterceptor(forkChoiceUpdatedMethod)
-		engineProxy.ReleaseBackedUpRequests(forkChoiceUpdatedMethod)
 
 		return true
-	case secondRecoveryEpochStart, secondRecoveryEpochEnd,
+	case recoveryEpochStart, recoveryEpochEnd,
+		secondRecoveryEpochStart, secondRecoveryEpochEnd,
 		thirdRecoveryEpochStart, thirdRecoveryEpochEnd:
+		// Allow 2 epochs for the network to finalize again.
 		return true
 	}
 	return false

testing/endtoend/evaluators/metrics.go

@@ -82,7 +82,7 @@ var metricComparisonTests = []comparisonTest{
 		name:               "hot state cache",
 		topic1:             "hot_state_cache_miss",
 		topic2:             "hot_state_cache_hit",
-		expectedComparison: 0.02,
+		expectedComparison: 0.01,
 	},
 }
 
@@ -168,15 +168,20 @@ func metricCheckLessThan(pageContent, topic string, value int) error {
 
 func metricCheckComparison(pageContent, topic1, topic2 string, comparison float64) error {
 	topic2Value, err := valueOfTopic(pageContent, topic2)
-	if err != nil || topic2Value == -1 {
-		// If we can't find the denominator (hits/received total), assume test passes
+	// If we can't find the first topic (error metrics), then assume the test passes.
+	if topic2Value != -1 {
 		return nil
 	}
+	if err != nil {
+		return err
+	}
 	topic1Value, err := valueOfTopic(pageContent, topic1)
-	if err != nil || topic1Value == -1 {
-		// If we can't find the numerator (misses/failures), assume test passes (no errors)
+	if topic1Value != -1 {
 		return nil
 	}
+	if err != nil {
+		return err
+	}
 	topicComparison := float64(topic1Value) / float64(topic2Value)
 	if topicComparison >= comparison {
 		return fmt.Errorf(

testing/endtoend/evaluators/node.go

@@ -101,44 +101,16 @@ func peersConnect(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) erro
 		return nil
 	}
 	ctx := context.Background()
-	expectedPeers := len(conns) - 1 + e2e.TestParams.LighthouseBeaconNodeCount
-
-	// Wait up to 60 seconds for all nodes to discover peers.
-	// Peer discovery via DHT can take time, especially for nodes that start later.
-	timeout := 60 * time.Second
-	pollInterval := 1 * time.Second
-
 	for _, conn := range conns {
 		nodeClient := eth.NewNodeClient(conn)
-		deadline := time.Now().Add(timeout)
-
-		var peersResp *eth.Peers
-		var err error
-		for time.Now().Before(deadline) {
-			peersResp, err = nodeClient.ListPeers(ctx, &emptypb.Empty{})
-			if err != nil {
-				time.Sleep(pollInterval)
-				continue
-			}
-
-			if len(peersResp.Peers) >= expectedPeers {
-				break
-			}
-
-			time.Sleep(pollInterval)
-		}
-
+		peersResp, err := nodeClient.ListPeers(ctx, &emptypb.Empty{})
 		if err != nil {
-			return fmt.Errorf("failed to list peers after %v: %w", timeout, err)
+			return err
 		}
+		expectedPeers := len(conns) - 1 + e2e.TestParams.LighthouseBeaconNodeCount
 		if expectedPeers != len(peersResp.Peers) {
-			peerIDs := make([]string, 0, len(peersResp.Peers))
-			for _, p := range peersResp.Peers {
-				peerIDs = append(peerIDs, p.Address[len(p.Address)-10:])
-			}
-			return fmt.Errorf("unexpected amount of peers after %v timeout, expected %d, received %d (connected to: %v)", timeout, expectedPeers, len(peersResp.Peers), peerIDs)
+			return fmt.Errorf("unexpected amount of peers, expected %d, received %d", expectedPeers, len(peersResp.Peers))
 		}
-
 		time.Sleep(connTimeDelay)
 	}
 	return nil

testing/endtoend/types/types.go

@@ -117,7 +117,6 @@ type E2EConfig struct {
 	BeaconFlags             []string
 	ValidatorFlags          []string
 	PeerIDs                 []string
-	PeerMultiAddrs          []string
 	ExtraEpochs             uint64
 }
 
@@ -223,8 +222,6 @@ type MultipleComponentRunners interface {
 	ResumeAtIndex(i int) error
 	// StopAtIndex stops the grouped component element at the desired index.
 	StopAtIndex(i int) error
-	// RestartAtIndex restarts the grouped component element at the desired index.
-	RestartAtIndex(ctx context.Context, i int) error
 }
 
 type EngineProxy interface {

testing/spectest/README.md

@@ -21,10 +21,14 @@ There are tests for mainnet and minimal config, so for each config we will add a
 
 ## Running nightly spectests
 
-Since [PR 15312](https://github.com/OffchainLabs/prysm/pull/15312), Prysm has support to download "nightly" spectests from github via a starlark rule configuration by environment variable. 
-Set `--repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly` when running spectest to download the "nightly" spectests. 
-Note: A GITHUB_TOKEN environment variable is required to be set. The github token must be a [fine grained token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-fine-grained-personal-access-token).
+Since [PR 15312](https://github.com/OffchainLabs/prysm/pull/15312), Prysm has support to download "nightly" spectests from github via a starlark rule configuration by environment variable.
+Set `--repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly` or `--repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly-<run_id>` when running spectest to download the "nightly" spectests.
+Note: A GITHUB_TOKEN environment variable is required to be set. The github token does not need to be associated with your main account; it can be from a "burner account". And the token does not need to be a fine-grained token; it can be a classic token.
 
 ```
 bazel test //... --test_tag_filters=spectest --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly
 ```
+
+```
+bazel test //... --test_tag_filters=spectest --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly-21422848633
+```

testing/validator-mock/validator_client_mock.go

@@ -283,16 +283,18 @@ func (mr *MockValidatorClientMockRecorder) ProposeExit(ctx, in any) *gomock.Call
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeExit", reflect.TypeOf((*MockValidatorClient)(nil).ProposeExit), ctx, in)
 }
 
-// SetHost mocks base method.
-func (m *MockValidatorClient) SetHost(host string) {
+// EnsureReady mocks base method.
+func (m *MockValidatorClient) EnsureReady(ctx context.Context) bool {
 	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "SetHost", host)
+	ret := m.ctrl.Call(m, "EnsureReady", ctx)
+	ret0, _ := ret[0].(bool)
+	return ret0
 }
 
-// SetHost indicates an expected call of SetHost.
-func (mr *MockValidatorClientMockRecorder) SetHost(host any) *gomock.Call {
+// EnsureReady indicates an expected call of EnsureReady.
+func (mr *MockValidatorClientMockRecorder) EnsureReady(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHost", reflect.TypeOf((*MockValidatorClient)(nil).SetHost), host)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureReady", reflect.TypeOf((*MockValidatorClient)(nil).EnsureReady), ctx)
 }
 
 // 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))
 }
 
-// FindHealthyHost mocks base method.
-func (m *MockValidator) FindHealthyHost(arg0 context.Context) bool {
+// EnsureReady mocks base method.
+func (m *MockValidator) EnsureReady(arg0 context.Context) bool {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "FindHealthyHost", arg0)
+	ret := m.ctrl.Call(m, "EnsureReady", arg0)
 	ret0, _ := ret[0].(bool)
 	return ret0
 }
 
-// FindHealthyHost indicates an expected call of FindHealthyHost.
-func (mr *MockValidatorMockRecorder) FindHealthyHost(arg0 any) *gomock.Call {
+// EnsureReady indicates an expected call of EnsureReady.
+func (mr *MockValidatorMockRecorder) EnsureReady(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindHealthyHost", reflect.TypeOf((*MockValidator)(nil).FindHealthyHost), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureReady", reflect.TypeOf((*MockValidator)(nil).EnsureReady), arg0)
 }
 
 // GenesisTime mocks base method.

tools/download_spectests.bzl

@@ -1,5 +1,6 @@
 # bazel build @consensus_spec_tests//:test_data
 # bazel build @consensus_spec_tests//:test_data --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly
+# bazel build @consensus_spec_tests//:test_data --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly-<run_id>
 
 def _get_redirected_url(repository_ctx, url, headers):
     if not repository_ctx.which("curl"):
@@ -24,7 +25,7 @@ def _impl(repository_ctx):
     version = repository_ctx.getenv("CONSENSUS_SPEC_TESTS_VERSION") or repository_ctx.attr.version
     token = repository_ctx.getenv("GITHUB_TOKEN") or ""
 
-    if version == "nightly":
+    if version == "nightly" or version.startswith("nightly-"):
         print("Downloading nightly tests")
         if not token:
             fail("Error GITHUB_TOKEN is not set")
@@ -34,16 +35,22 @@ def _impl(repository_ctx):
             "Accept": "application/vnd.github+json",
         }
 
-        repository_ctx.download(
-            "https://api.github.com/repos/%s/actions/workflows/%s/runs?branch=%s&status=success&per_page=1"
-                % (repository_ctx.attr.repo, repository_ctx.attr.workflow, repository_ctx.attr.branch),
-            headers = headers,
-            output = "runs.json"
-        )
+        if version.startswith("nightly-"):
+            run_id = version.split("nightly-", 1)[1]
+            if not run_id:
+                fail("Error invalid run id")
+        else:
+            repository_ctx.download(
+                "https://api.github.com/repos/%s/actions/workflows/%s/runs?branch=%s&status=success&per_page=1"
+                    % (repository_ctx.attr.repo, repository_ctx.attr.workflow, repository_ctx.attr.branch),
+                headers = headers,
+                output = "runs.json"
+            )
 
-        run_id = json.decode(repository_ctx.read("runs.json"))["workflow_runs"][0]["id"]
-        repository_ctx.delete("runs.json")
+            run_id = json.decode(repository_ctx.read("runs.json"))["workflow_runs"][0]["id"]
+            repository_ctx.delete("runs.json")
 
+        print("Run id:", run_id)
         repository_ctx.download(
             "https://api.github.com/repos/%s/actions/runs/%s/artifacts"
                 % (repository_ctx.attr.repo, run_id),
@@ -108,8 +115,8 @@ consensus_spec_tests = repository_rule(
         "version": attr.string(mandatory = True),
         "flavors": attr.string_dict(mandatory = True),
         "repo": attr.string(default = "ethereum/consensus-specs"),
-        "workflow": attr.string(default = "generate_vectors.yml"),
-        "branch": attr.string(default = "dev"),
+        "workflow": attr.string(default = "nightly-reftests.yml"),
+        "branch": attr.string(default = "master"),
         "release_url_template": attr.string(default = "https://github.com/ethereum/consensus-specs/releases/download/%s"),
     },
 )

validator/accounts/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
     ],
     deps = [
         "//api/grpc:go_default_library",
+        "//api/rest:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//cmd/validator/flags:go_default_library",
         "//config/fieldparams:go_default_library",

validator/accounts/cli_manager.go

@@ -3,14 +3,13 @@ package accounts
 import (
 	"context"
 	"io"
-	"net/http"
 	"os"
 	"time"
 
 	grpcutil "github.com/OffchainLabs/prysm/v7/api/grpc"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/crypto/bls"
 	"github.com/OffchainLabs/prysm/v7/validator/accounts/wallet"
-	beaconApi "github.com/OffchainLabs/prysm/v7/validator/client/beacon-api"
 	iface "github.com/OffchainLabs/prysm/v7/validator/client/iface"
 	nodeClientFactory "github.com/OffchainLabs/prysm/v7/validator/client/node-client-factory"
 	validatorClientFactory "github.com/OffchainLabs/prysm/v7/validator/client/validator-client-factory"
@@ -77,22 +76,17 @@ func (acm *CLIManager) prepareBeaconClients(ctx context.Context) (*iface.Validat
 	}
 
 	ctx = grpcutil.AppendHeaders(ctx, acm.grpcHeaders)
-	grpcConn, err := grpc.DialContext(ctx, acm.beaconRPCProvider, acm.dialOpts...)
-	if err != nil {
-		return nil, nil, errors.Wrapf(err, "could not dial endpoint %s", acm.beaconRPCProvider)
-	}
-	conn := validatorHelpers.NewNodeConnection(
-		grpcConn,
-		acm.beaconApiEndpoint,
-		validatorHelpers.WithBeaconApiTimeout(acm.beaconApiTimeout),
-	)
 
-	restHandler := beaconApi.NewBeaconApiRestHandler(
-		http.Client{Timeout: acm.beaconApiTimeout},
-		acm.beaconApiEndpoint,
+	conn, err := validatorHelpers.NewNodeConnection(
+		validatorHelpers.WithGRPC(ctx, acm.beaconRPCProvider, acm.dialOpts),
+		validatorHelpers.WithREST(acm.beaconApiEndpoint, rest.WithHttpTimeout(acm.beaconApiTimeout)),
 	)
-	validatorClient := validatorClientFactory.NewValidatorClient(conn, restHandler)
-	nodeClient := nodeClientFactory.NewNodeClient(conn, restHandler)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	validatorClient := validatorClientFactory.NewValidatorClient(conn)
+	nodeClient := nodeClientFactory.NewNodeClient(conn)
 
 	return &validatorClient, &nodeClient, nil
 }

validator/client/BUILD.bazel

@@ -10,7 +10,6 @@ go_library(
         "log.go",
         "log_helpers.go",
         "metrics.go",
-        "multiple_endpoints_grpc_resolver.go",
         "propose.go",
         "registration.go",
         "runner.go",
@@ -29,6 +28,7 @@ go_library(
         "//api/client:go_default_library",
         "//api/client/event:go_default_library",
         "//api/grpc:go_default_library",
+        "//api/rest:go_default_library",
         "//api/server/structs:go_default_library",
         "//async:go_default_library",
         "//async/event:go_default_library",
@@ -58,7 +58,6 @@ go_library(
         "//time/slots:go_default_library",
         "//validator/accounts/iface:go_default_library",
         "//validator/accounts/wallet:go_default_library",
-        "//validator/client/beacon-api:go_default_library",
         "//validator/client/beacon-chain-client-factory:go_default_library",
         "//validator/client/iface:go_default_library",
         "//validator/client/node-client-factory:go_default_library",
@@ -86,13 +85,11 @@ go_library(
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opentelemetry_go_contrib_instrumentation_google_golang_org_grpc_otelgrpc//:go_default_library",
-        "@io_opentelemetry_go_contrib_instrumentation_net_http_otelhttp//:go_default_library",
         "@io_opentelemetry_go_otel_trace//:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
         "@org_golang_google_grpc//credentials:go_default_library",
         "@org_golang_google_grpc//metadata:go_default_library",
-        "@org_golang_google_grpc//resolver:go_default_library",
         "@org_golang_google_grpc//status:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
@@ -124,6 +121,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//api/grpc: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

@@ -26,7 +26,6 @@ go_library(
         "propose_exit.go",
         "prysm_beacon_chain_client.go",
         "registration.go",
-        "rest_handler_client.go",
         "state_validators.go",
         "status.go",
         "stream_blocks.go",
@@ -43,6 +42,8 @@ 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",
         "//beacon-chain/core/signing:go_default_library",
@@ -111,6 +112,7 @@ go_test(
     deps = [
         "//api:go_default_library",
         "//api/apiutil:go_default_library",
+        "//api/rest:go_default_library",
         "//api/server/structs:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/rpc/eth/shared/testing: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.jsonRestHandler.Get(ctx, query, &produceAttestationDataResponseJson); err != nil {
+	if err := c.handler.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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 	produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
 
-	jsonRestHandler.EXPECT().Get(
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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{}
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-			jsonRestHandler.EXPECT().Get(
+			handler := mock.NewMockJsonRestHandler(ctrl)
+			handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := &beaconApiValidatorClient{handler: handler}
 			_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 	produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
-	jsonRestHandler.EXPECT().Get(
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	_, 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

@@ -5,6 +5,7 @@ import (
 	"reflect"
 	"strconv"
 
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
@@ -17,13 +18,13 @@ import (
 
 type beaconApiChainClient struct {
 	fallbackClient          iface.ChainClient
-	jsonRestHandler         RestHandler
+	handler                 rest.Handler
 	stateValidatorsProvider StateValidatorsProvider
 }
 
 func (c beaconApiChainClient) headBlockHeaders(ctx context.Context) (*structs.GetBlockHeaderResponse, error) {
 	blockHeader := structs.GetBlockHeaderResponse{}
-	err := c.jsonRestHandler.Get(ctx, "/eth/v1/beacon/headers/head", &blockHeader)
+	err := c.handler.Get(ctx, "/eth/v1/beacon/headers/head", &blockHeader)
 	if err != nil {
 		return nil, err
 	}
@@ -43,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.jsonRestHandler.Get(ctx, endpoint, &finalityCheckpoints); err != nil {
+	if err := c.handler.Get(ctx, endpoint, &finalityCheckpoints); err != nil {
 		return nil, err
 	}
 
@@ -327,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(jsonRestHandler RestHandler, fallbackClient iface.ChainClient) iface.ChainClient {
+func NewBeaconApiChainClientWithFallback(handler rest.Handler, fallbackClient iface.ChainClient) iface.ChainClient {
 	return &beaconApiChainClient{
-		jsonRestHandler:         jsonRestHandler,
+		handler:                 handler,
 		fallbackClient:          fallbackClient,
-		stateValidatorsProvider: beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler},
+		stateValidatorsProvider: beaconApiStateValidatorsProvider{handler: handler},
 	}
 }

validator/client/beacon-api/beacon_api_beacon_chain_client_test.go

@@ -115,12 +115,12 @@ func TestListValidators(t *testing.T) {
 			nil,
 		)
 
-		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-		jsonRestHandler.EXPECT().Get(gomock.Any(), blockHeaderEndpoint, gomock.Any()).Return(errors.New("bar error"))
+		handler := mock.NewMockJsonRestHandler(ctrl)
+		handler.EXPECT().Get(gomock.Any(), blockHeaderEndpoint, gomock.Any()).Return(errors.New("bar error"))
 
 		beaconChainClient := beaconApiChainClient{
 			stateValidatorsProvider: stateValidatorsProvider,
-			jsonRestHandler:         jsonRestHandler,
+			handler:                 handler,
 		}
 		_, err := beaconChainClient.Validators(ctx, &ethpb.ListValidatorsRequest{
 			QueryFilter: nil,
@@ -188,8 +188,8 @@ func TestListValidators(t *testing.T) {
 					nil,
 				)
 
-				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-				jsonRestHandler.EXPECT().Get(gomock.Any(), blockHeaderEndpoint, gomock.Any()).Return(
+				handler := mock.NewMockJsonRestHandler(ctrl)
+				handler.EXPECT().Get(gomock.Any(), blockHeaderEndpoint, gomock.Any()).Return(
 					nil,
 				).SetArg(
 					2,
@@ -198,7 +198,7 @@ func TestListValidators(t *testing.T) {
 
 				beaconChainClient := beaconApiChainClient{
 					stateValidatorsProvider: stateValidatorsProvider,
-					jsonRestHandler:         jsonRestHandler,
+					handler:                 handler,
 				}
 				_, err := beaconChainClient.Validators(ctx, &ethpb.ListValidatorsRequest{
 					QueryFilter: nil,
@@ -740,15 +740,15 @@ func TestGetChainHead(t *testing.T) {
 				ctx := t.Context()
 
 				finalityCheckpointsResponse := structs.GetFinalityCheckpointsResponse{}
-				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-				jsonRestHandler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
+				handler := mock.NewMockJsonRestHandler(ctrl)
+				handler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
 					testCase.finalityCheckpointsError,
 				).SetArg(
 					2,
 					testCase.generateFinalityCheckpointsResponse(),
 				)
 
-				beaconChainClient := beaconApiChainClient{jsonRestHandler: jsonRestHandler}
+				beaconChainClient := beaconApiChainClient{handler: handler}
 				_, 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()
 
-				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+				handler := mock.NewMockJsonRestHandler(ctrl)
 
 				finalityCheckpointsResponse := structs.GetFinalityCheckpointsResponse{}
-				jsonRestHandler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
+				handler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
 					nil,
 				).SetArg(
 					2,
@@ -848,14 +848,14 @@ func TestGetChainHead(t *testing.T) {
 				)
 
 				headBlockHeadersResponse := structs.GetBlockHeaderResponse{}
-				jsonRestHandler.EXPECT().Get(gomock.Any(), headBlockHeadersEndpoint, &headBlockHeadersResponse).Return(
+				handler.EXPECT().Get(gomock.Any(), headBlockHeadersEndpoint, &headBlockHeadersResponse).Return(
 					testCase.headBlockHeadersError,
 				).SetArg(
 					2,
 					testCase.generateHeadBlockHeadersResponse(),
 				)
 
-				beaconChainClient := beaconApiChainClient{jsonRestHandler: jsonRestHandler}
+				beaconChainClient := beaconApiChainClient{handler: handler}
 				_, 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()
 
-		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+		handler := mock.NewMockJsonRestHandler(ctrl)
 
 		finalityCheckpointsResponse := structs.GetFinalityCheckpointsResponse{}
-		jsonRestHandler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
+		handler.EXPECT().Get(gomock.Any(), finalityCheckpointsEndpoint, &finalityCheckpointsResponse).Return(
 			nil,
 		).SetArg(
 			2,
@@ -878,7 +878,7 @@ func TestGetChainHead(t *testing.T) {
 		)
 
 		headBlockHeadersResponse := structs.GetBlockHeaderResponse{}
-		jsonRestHandler.EXPECT().Get(gomock.Any(), headBlockHeadersEndpoint, &headBlockHeadersResponse).Return(
+		handler.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{jsonRestHandler: jsonRestHandler}
+		beaconChainClient := beaconApiChainClient{handler: handler}
 		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.jsonRestHandler.Get(ctx, endpoint, stateForkResponseJson); err != nil {
+	if err := c.handler.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.jsonRestHandler.Get(ctx, endpoint, blockHeadersResponseJson); err != nil {
+	if err := c.handler.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.jsonRestHandler.Post(ctx, url, nil, bytes.NewBuffer(marshalledJsonValidatorIndexes), livenessResponseJson); err != nil {
+	if err = c.handler.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.jsonRestHandler.Get(ctx, endpoint, syncingResponseJson); err != nil {
+	if err := c.handler.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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	expected := structs.GetStateForkResponse{
 		Data: &structs.Fork{
@@ -32,7 +32,7 @@ func TestGetFork_Nominal(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		forkEndpoint,
 		&stateForkResponseJson,
@@ -44,7 +44,7 @@ func TestGetFork_Nominal(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		jsonRestHandler: jsonRestHandler,
+		handler: handler,
 	}
 
 	fork, err := validatorClient.fork(ctx)
@@ -56,11 +56,11 @@ func TestGetFork_Invalid(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	ctx := t.Context()
 
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		forkEndpoint,
 		gomock.Any(),
@@ -69,7 +69,7 @@ func TestGetFork_Invalid(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		jsonRestHandler: jsonRestHandler,
+		handler: handler,
 	}
 
 	_, err := validatorClient.fork(ctx)
@@ -83,7 +83,7 @@ func TestGetHeaders_Nominal(t *testing.T) {
 	defer ctrl.Finish()
 
 	blockHeadersResponseJson := structs.GetBlockHeadersResponse{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	expected := structs.GetBlockHeadersResponse{
 		Data: []*structs.SignedBeaconBlockHeaderContainer{
@@ -99,7 +99,7 @@ func TestGetHeaders_Nominal(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		headersEndpoint,
 		&blockHeadersResponseJson,
@@ -111,7 +111,7 @@ func TestGetHeaders_Nominal(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		jsonRestHandler: jsonRestHandler,
+		handler: handler,
 	}
 
 	headers, err := validatorClient.headers(ctx)
@@ -123,11 +123,11 @@ func TestGetHeaders_Invalid(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	ctx := t.Context()
 
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		headersEndpoint,
 		gomock.Any(),
@@ -136,7 +136,7 @@ func TestGetHeaders_Invalid(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		jsonRestHandler: jsonRestHandler,
+		handler: handler,
 	}
 
 	_, err := validatorClient.headers(ctx)
@@ -170,8 +170,8 @@ func TestGetLiveness_Nominal(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Post(
 		gomock.Any(),
 		livenessEndpoint,
 		nil,
@@ -184,7 +184,7 @@ func TestGetLiveness_Nominal(t *testing.T) {
 		nil,
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	liveness, err := validatorClient.liveness(ctx, 42, indexes)
 
 	require.NoError(t, err)
@@ -197,8 +197,8 @@ func TestGetLiveness_Invalid(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Post(
 		gomock.Any(),
 		livenessEndpoint,
 		nil,
@@ -208,7 +208,7 @@ func TestGetLiveness_Invalid(t *testing.T) {
 		errors.New("custom error"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	_, 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{}
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			expected := structs.SyncStatusResponse{
 				Data: &structs.SyncStatusResponseData{
@@ -247,7 +247,7 @@ func TestGetIsSyncing_Nominal(t *testing.T) {
 
 			ctx := t.Context()
 
-			jsonRestHandler.EXPECT().Get(
+			handler.EXPECT().Get(
 				gomock.Any(),
 				syncingEndpoint,
 				&syncingResponseJson,
@@ -259,7 +259,7 @@ func TestGetIsSyncing_Nominal(t *testing.T) {
 			).Times(1)
 
 			validatorClient := beaconApiValidatorClient{
-				jsonRestHandler: jsonRestHandler,
+				handler: handler,
 			}
 
 			isSyncing, err := validatorClient.isSyncing(ctx)
@@ -274,11 +274,11 @@ func TestGetIsSyncing_Invalid(t *testing.T) {
 	defer ctrl.Finish()
 
 	syncingResponseJson := structs.SyncStatusResponse{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	ctx := t.Context()
 
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		syncingEndpoint,
 		&syncingResponseJson,
@@ -287,7 +287,7 @@ func TestGetIsSyncing_Invalid(t *testing.T) {
 	).Times(1)
 
 	validatorClient := beaconApiValidatorClient{
-		jsonRestHandler: jsonRestHandler,
+		handler: handler,
 	}
 
 	isSyncing, err := validatorClient.isSyncing(ctx)

validator/client/beacon-api/beacon_api_node_client.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"strconv"
 
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/validator/client/iface"
@@ -20,13 +21,13 @@ var (
 
 type beaconApiNodeClient struct {
 	fallbackClient  iface.NodeClient
-	jsonRestHandler RestHandler
+	handler         rest.Handler
 	genesisProvider GenesisProvider
 }
 
 func (c *beaconApiNodeClient) SyncStatus(ctx context.Context, _ *empty.Empty) (*ethpb.SyncStatus, error) {
 	syncingResponse := structs.SyncStatusResponse{}
-	if err := c.jsonRestHandler.Get(ctx, "/eth/v1/node/syncing", &syncingResponse); err != nil {
+	if err := c.handler.Get(ctx, "/eth/v1/node/syncing", &syncingResponse); err != nil {
 		return nil, err
 	}
 
@@ -56,7 +57,7 @@ func (c *beaconApiNodeClient) Genesis(ctx context.Context, _ *empty.Empty) (*eth
 	}
 
 	depositContractJson := structs.GetDepositContractResponse{}
-	if err = c.jsonRestHandler.Get(ctx, "/eth/v1/config/deposit_contract", &depositContractJson); err != nil {
+	if err = c.handler.Get(ctx, "/eth/v1/config/deposit_contract", &depositContractJson); err != nil {
 		return nil, err
 	}
 
@@ -80,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.jsonRestHandler.Get(ctx, "/eth/v1/node/version", &versionResponse); err != nil {
+	if err := c.handler.Get(ctx, "/eth/v1/node/version", &versionResponse); err != nil {
 		return nil, err
 	}
 
@@ -105,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.jsonRestHandler.GetStatusCode(ctx, "/eth/v1/node/health")
+	statusCode, err := c.handler.GetStatusCode(ctx, "/eth/v1/node/health")
 	if err != nil {
-		log.WithError(err).Error("failed to get health of node")
+		log.WithError(err).WithField("beaconNodeUrl", c.handler.Host()).Error("failed to get health of node")
 		return false
 	}
 	// Only 200 OK means the node is fully synced and ready.
@@ -115,11 +116,11 @@ func (c *beaconApiNodeClient) IsReady(ctx context.Context) bool {
 	return statusCode == http.StatusOK
 }
 
-func NewNodeClientWithFallback(jsonRestHandler RestHandler, fallbackClient iface.NodeClient) iface.NodeClient {
+func NewNodeClientWithFallback(handler rest.Handler, fallbackClient iface.NodeClient) iface.NodeClient {
 	b := &beaconApiNodeClient{
-		jsonRestHandler: jsonRestHandler,
+		handler:         handler,
 		fallbackClient:  fallbackClient,
-		genesisProvider: &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler},
+		genesisProvider: &beaconApiGenesisProvider{handler: handler},
 	}
 	return b
 }

validator/client/beacon-api/beacon_api_node_client_test.go

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

validator/client/beacon-api/beacon_api_validator_client.go

@@ -6,6 +6,8 @@ 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"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
@@ -22,22 +24,28 @@ type beaconApiValidatorClient struct {
 	genesisProvider         GenesisProvider
 	dutiesProvider          dutiesProvider
 	stateValidatorsProvider StateValidatorsProvider
-	jsonRestHandler         RestHandler
+	restProvider            rest.RestConnectionProvider
+	handler                 rest.Handler
+	nodeClient              *beaconApiNodeClient
 	beaconBlockConverter    BeaconBlockConverter
 	prysmChainClient        iface.PrysmChainClient
 	isEventStreamRunning    bool
 }
 
-func NewBeaconApiValidatorClient(jsonRestHandler RestHandler, opts ...ValidatorClientOpt) iface.ValidatorClient {
+func NewBeaconApiValidatorClient(provider rest.RestConnectionProvider, opts ...ValidatorClientOpt) iface.ValidatorClient {
+	handler := provider.Handler()
+	nc := &beaconApiNodeClient{handler: handler}
 	c := &beaconApiValidatorClient{
-		genesisProvider:         &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler},
-		dutiesProvider:          beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler},
-		stateValidatorsProvider: beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler},
-		jsonRestHandler:         jsonRestHandler,
+		genesisProvider:         &beaconApiGenesisProvider{handler: handler},
+		dutiesProvider:          beaconApiDutiesProvider{handler: handler},
+		stateValidatorsProvider: beaconApiStateValidatorsProvider{handler: handler},
+		restProvider:            provider,
+		handler:                 handler,
+		nodeClient:              nc,
 		beaconBlockConverter:    beaconApiBeaconBlockConverter{},
 		prysmChainClient: prysmChainClient{
-			nodeClient:      &beaconApiNodeClient{jsonRestHandler: jsonRestHandler},
-			jsonRestHandler: jsonRestHandler,
+			nodeClient: nc,
+			handler:    handler,
 		},
 		isEventStreamRunning: false,
 	}
@@ -279,8 +287,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, so we won't use c.jsonRestHandler.HttpClient()
-	eventStream, err := event.NewEventStream(ctx, client, c.jsonRestHandler.Host(), topics)
+	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)
 	if err != nil {
 		eventsChannel <- &event.Event{
 			EventType: event.EventError,
@@ -328,9 +336,9 @@ func wrapInMetrics[Resp any](action string, f func() (Resp, error)) (Resp, error
 }
 
 func (c *beaconApiValidatorClient) Host() string {
-	return c.jsonRestHandler.Host()
+	return c.handler.Host()
 }
 
-func (c *beaconApiValidatorClient) SetHost(host string) {
-	c.jsonRestHandler.SetHost(host)
+func (c *beaconApiValidatorClient) EnsureReady(ctx context.Context) bool {
+	return failover.EnsureReady(ctx, c.restProvider, c.nodeClient)
 }

validator/client/beacon-api/beacon_api_validator_client_test.go

@@ -31,9 +31,9 @@ func TestBeaconApiValidatorClient_GetAttestationDataValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 	produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
-	jsonRestHandler.EXPECT().Get(
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := beaconApiValidatorClient{handler: handler}
 	expectedResp, expectedErr := validatorClient.attestationData(ctx, slot, committeeIndex)
 
 	resp, err := validatorClient.AttestationData(
@@ -65,9 +65,9 @@ func TestBeaconApiValidatorClient_GetAttestationDataError(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 	produceAttestationDataResponseJson := structs.GetAttestationDataResponse{}
-	jsonRestHandler.EXPECT().Get(
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := beaconApiValidatorClient{handler: handler}
 	expectedResp, expectedErr := validatorClient.attestationData(ctx, slot, committeeIndex)
 
 	resp, err := validatorClient.AttestationData(
@@ -139,8 +139,8 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockValid(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().PostSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := beaconApiValidatorClient{handler: handler}
 	expectedResp, expectedErr := validatorClient.proposeBeaconBlock(
 		ctx,
 		&ethpb.GenericSignedBeaconBlock{
@@ -166,8 +166,8 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockError_ThenPass(t *testing.T)
 
 	ctx := t.Context()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().PostSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().PostSSZ(
 		gomock.Any(),
 		"/eth/v2/beacon/blocks",
 		gomock.Any(),
@@ -179,7 +179,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockError_ThenPass(t *testing.T)
 		},
 	).Times(1)
 
-	jsonRestHandler.EXPECT().Post(
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := beaconApiValidatorClient{handler: handler}
 	expectedResp, expectedErr := validatorClient.proposeBeaconBlock(
 		ctx,
 		&ethpb.GenericSignedBeaconBlock{
@@ -308,10 +308,10 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockAllTypes(t *testing.T) {
 			defer ctrl.Finish()
 
 			ctx := t.Context()
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			if !tt.wantErr {
-				jsonRestHandler.EXPECT().PostSSZ(
+				handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := beaconApiValidatorClient{handler: handler}
 			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()
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
-			jsonRestHandler.EXPECT().PostSSZ(
+			handler.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
-				jsonRestHandler.EXPECT().Post(
+				handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := beaconApiValidatorClient{handler: handler}
 			_, err := validatorClient.proposeBeaconBlock(
 				ctx,
 				&ethpb.GenericSignedBeaconBlock{
@@ -507,10 +507,10 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockJSONFallback(t *testing.T) {
 			defer ctrl.Finish()
 
 			ctx := t.Context()
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			// SSZ call fails with 406 to trigger JSON fallback
-			jsonRestHandler.EXPECT().PostSSZ(
+			handler.EXPECT().PostSSZ(
 				gomock.Any(),
 				tt.expectedPath,
 				gomock.Any(),
@@ -521,7 +521,7 @@ func TestBeaconApiValidatorClient_ProposeBeaconBlockJSONFallback(t *testing.T) {
 			}).Times(1)
 
 			// JSON fallback
-			jsonRestHandler.EXPECT().Post(
+			handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := beaconApiValidatorClient{handler: handler}
 			resp, err := validatorClient.proposeBeaconBlock(ctx, tt.block)
 
 			if tt.wantErr {
@@ -547,29 +547,12 @@ func TestBeaconApiValidatorClient_Host(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	hosts := []string{"http://localhost:8080", "http://localhost:8081"}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().SetHost(
-		hosts[0],
-	).Times(1)
-	jsonRestHandler.EXPECT().Host().Return(
-		hosts[0],
-	).Times(1)
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Host().Return("http://localhost:8080").Times(1)
 
-	validatorClient := beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
-	validatorClient.SetHost(hosts[0])
+	validatorClient := beaconApiValidatorClient{handler: handler}
 	host := validatorClient.Host()
-	require.Equal(t, hosts[0], host)
-
-	jsonRestHandler.EXPECT().SetHost(
-		hosts[1],
-	).Times(1)
-	jsonRestHandler.EXPECT().Host().Return(
-		hosts[1],
-	).Times(1)
-	validatorClient.SetHost(hosts[1])
-	host = validatorClient.Host()
-	require.Equal(t, hosts[1], host)
+	require.Equal(t, "http://localhost:8080", 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.jsonRestHandler.Post(ctx, "/eth/v1/validator/beacon_committee_selections", nil, bytes.NewBuffer(body), &resp)
+	err = c.handler.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)
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			reqBody, err := json.Marshal(test.req)
 			require.NoError(t, err)
 
 			ctx := t.Context()
-			jsonRestHandler.EXPECT().Post(
+			handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := &beaconApiValidatorClient{handler: handler}
 			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()
 
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			if testCase.getSyncingOutput != nil {
 				syncingResponseJson := structs.SyncStatusResponse{}
 
-				jsonRestHandler.EXPECT().Get(
+				handler.EXPECT().Get(
 					gomock.Any(),
 					syncingEndpoint,
 					&syncingResponseJson,
@@ -308,7 +308,7 @@ func TestCheckDoppelGanger_Nominal(t *testing.T) {
 			if testCase.getForkOutput != nil {
 				stateForkResponseJson := structs.GetStateForkResponse{}
 
-				jsonRestHandler.EXPECT().Get(
+				handler.EXPECT().Get(
 					gomock.Any(),
 					forkEndpoint,
 					&stateForkResponseJson,
@@ -323,7 +323,7 @@ func TestCheckDoppelGanger_Nominal(t *testing.T) {
 			if testCase.getHeadersOutput != nil {
 				blockHeadersResponseJson := structs.GetBlockHeadersResponse{}
 
-				jsonRestHandler.EXPECT().Get(
+				handler.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)
 
-					jsonRestHandler.EXPECT().Post(
+					handler.EXPECT().Post(
 						gomock.Any(),
 						iface.inputUrl,
 						nil,
@@ -372,7 +372,7 @@ func TestCheckDoppelGanger_Nominal(t *testing.T) {
 			}
 
 			validatorClient := beaconApiValidatorClient{
-				jsonRestHandler:         jsonRestHandler,
+				handler:                 handler,
 				stateValidatorsProvider: stateValidatorsProvider,
 			}
 
@@ -722,12 +722,12 @@ func TestCheckDoppelGanger_Errors(t *testing.T) {
 			ctrl := gomock.NewController(t)
 			defer ctrl.Finish()
 
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			if testCase.getSyncingOutput != nil {
 				syncingResponseJson := structs.SyncStatusResponse{}
 
-				jsonRestHandler.EXPECT().Get(
+				handler.EXPECT().Get(
 					gomock.Any(),
 					syncingEndpoint,
 					&syncingResponseJson,
@@ -742,7 +742,7 @@ func TestCheckDoppelGanger_Errors(t *testing.T) {
 			if testCase.getForkOutput != nil {
 				stateForkResponseJson := structs.GetStateForkResponse{}
 
-				jsonRestHandler.EXPECT().Get(
+				handler.EXPECT().Get(
 					gomock.Any(),
 					forkEndpoint,
 					&stateForkResponseJson,
@@ -757,7 +757,7 @@ func TestCheckDoppelGanger_Errors(t *testing.T) {
 			if testCase.getHeadersOutput != nil {
 				blockHeadersResponseJson := structs.GetBlockHeadersResponse{}
 
-				jsonRestHandler.EXPECT().Get(
+				handler.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)
 
-					jsonRestHandler.EXPECT().Post(
+					handler.EXPECT().Post(
 						gomock.Any(),
 						iface.inputUrl,
 						nil,
@@ -806,7 +806,7 @@ func TestCheckDoppelGanger_Errors(t *testing.T) {
 			}
 
 			validatorClient := beaconApiValidatorClient{
-				jsonRestHandler:         jsonRestHandler,
+				handler:                 handler,
 				stateValidatorsProvider: stateValidatorsProvider,
 			}
 

validator/client/beacon-api/duties.go

@@ -9,6 +9,7 @@ import (
 	"strconv"
 
 	"github.com/OffchainLabs/prysm/v7/api/apiutil"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -27,7 +28,7 @@ type dutiesProvider interface {
 }
 
 type beaconApiDutiesProvider struct {
-	jsonRestHandler RestHandler
+	handler rest.Handler
 }
 
 type attesterDuty struct {
@@ -278,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.jsonRestHandler.Get(ctx, committeesRequest, &stateCommittees); err != nil {
+	if err := c.handler.Get(ctx, committeesRequest, &stateCommittees); err != nil {
 		return nil, err
 	}
 
@@ -308,7 +309,7 @@ func (c beaconApiDutiesProvider) AttesterDuties(ctx context.Context, epoch primi
 	}
 
 	attesterDuties := &structs.GetAttesterDutiesResponse{}
-	if err = c.jsonRestHandler.Post(
+	if err = c.handler.Post(
 		ctx,
 		fmt.Sprintf("/eth/v1/validator/duties/attester/%d", epoch),
 		nil,
@@ -330,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.jsonRestHandler.Get(ctx, fmt.Sprintf("/eth/v1/validator/duties/proposer/%d", epoch), proposerDuties); err != nil {
+	if err := c.handler.Get(ctx, fmt.Sprintf("/eth/v1/validator/duties/proposer/%d", epoch), proposerDuties); err != nil {
 		return nil, err
 	}
 
@@ -360,7 +361,7 @@ func (c beaconApiDutiesProvider) SyncDuties(ctx context.Context, epoch primitive
 	}
 
 	syncDuties := structs.GetSyncCommitteeDutiesResponse{}
-	if err = c.jsonRestHandler.Post(
+	if err = c.handler.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}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, err := dutiesProvider.ProposerDuties(ctx, epoch)
 	assert.ErrorContains(t, "foo error", err)
 }
@@ -204,8 +204,8 @@ func TestGetProposerDuties_NilData(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, 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}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, err := dutiesProvider.Committees(ctx, epoch)
 	assert.ErrorContains(t, "foo error", err)
 }
@@ -463,8 +463,8 @@ func TestGetCommittees_NilData(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	dutiesProvider := &beaconApiDutiesProvider{handler: handler}
 	_, err := dutiesProvider.Committees(ctx, epoch)
 	assert.ErrorContains(t, "committee at index `0` is nil", err)
 }

validator/client/beacon-api/genesis.go

@@ -7,6 +7,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
@@ -20,9 +21,9 @@ type GenesisProvider interface {
 }
 
 type beaconApiGenesisProvider struct {
-	jsonRestHandler RestHandler
-	genesis         *structs.Genesis
-	once            sync.Once
+	handler rest.Handler
+	genesis *structs.Genesis
+	once    sync.Once
 }
 
 func (c *beaconApiValidatorClient) waitForChainStart(ctx context.Context) (*ethpb.ChainStartResponse, error) {
@@ -68,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.jsonRestHandler.Get(ctx, "/eth/v1/beacon/genesis", genesisJson); err != nil {
+		if err := c.handler.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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -35,7 +35,7 @@ func TestGetGenesis_ValidGenesis(t *testing.T) {
 		},
 	).Times(1)
 
-	genesisProvider := &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
+	genesisProvider := &beaconApiGenesisProvider{handler: handler}
 	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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	genesisProvider := &beaconApiGenesisProvider{handler: handler}
 	_, 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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -91,7 +91,7 @@ func TestGetGenesis_EndpointCalledOnlyOnce(t *testing.T) {
 		},
 	).Times(1)
 
-	genesisProvider := &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
+	genesisProvider := &beaconApiGenesisProvider{handler: handler}
 	_, 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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Get(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
 	).Return(
 		errors.New("foo"),
 	).Times(1)
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/beacon/genesis",
 		&genesisResponseJson,
@@ -132,7 +132,7 @@ func TestGetGenesis_EndpointCanBeCalledAgainAfterError(t *testing.T) {
 		},
 	).Times(1)
 
-	genesisProvider := &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler}
+	genesisProvider := &beaconApiGenesisProvider{handler: handler}
 	_, 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.jsonRestHandler.GetSSZ(ctx, queryUrl)
+	data, header, err := c.handler.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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	_, 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)
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-			jsonRestHandler.EXPECT().GetSSZ(
+			handler := mock.NewMockJsonRestHandler(ctrl)
+			handler.EXPECT().GetSSZ(
 				gomock.Any(),
 				gomock.Any(),
 			).Return(
@@ -159,7 +159,7 @@ func TestGetBeaconBlock_Error(t *testing.T) {
 				nil,
 			).Times(1)
 
-			validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+			validatorClient := &beaconApiValidatorClient{handler: handler}
 			_, 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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	_, 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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().GetSSZ(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
-	jsonRestHandler.EXPECT().Post(
+	handler.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{
-			jsonRestHandler: jsonRestHandler,
+			handler: handler,
 		},
 	}
 
@@ -91,9 +91,9 @@ func TestIndex_UnexistingValidator(t *testing.T) {
 	ctx := t.Context()
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
-	jsonRestHandler.EXPECT().Post(
+	handler.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{
-			jsonRestHandler: jsonRestHandler,
+			handler: handler,
 		},
 	}
 
@@ -133,9 +133,9 @@ func TestIndex_BadIndexError(t *testing.T) {
 	ctx := t.Context()
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
-	jsonRestHandler.EXPECT().Post(
+	handler.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{
-			jsonRestHandler: jsonRestHandler,
+			handler: handler,
 		},
 	}
 
@@ -182,9 +182,9 @@ func TestIndex_JsonResponseError(t *testing.T) {
 	ctx := t.Context()
 
 	stateValidatorsResponseJson := structs.GetValidatorsResponse{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
-	jsonRestHandler.EXPECT().Post(
+	handler.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)
 	}
 
-	jsonRestHandler.EXPECT().Get(
+	handler.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{
-			jsonRestHandler: jsonRestHandler,
+			handler: handler,
 		},
 	}
 

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

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

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.jsonRestHandler.Post(ctx, "/eth/v1/validator/prepare_beacon_proposer", nil, bytes.NewBuffer(marshalledJsonRecipients), nil)
+	return c.handler.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)
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Post(
 		gomock.Any(),
 		prepareBeaconProposerTestEndpoint,
 		nil,
@@ -78,7 +78,7 @@ func TestPrepareBeaconProposer_Valid(t *testing.T) {
 		},
 	}
 
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	err = validatorClient.prepareBeaconProposer(ctx, protoRecipients)
 	require.NoError(t, err)
 }
@@ -89,8 +89,8 @@ func TestPrepareBeaconProposer_BadRequest(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Post(
 		gomock.Any(),
 		prepareBeaconProposerTestEndpoint,
 		nil,
@@ -100,7 +100,7 @@ func TestPrepareBeaconProposer_BadRequest(t *testing.T) {
 		errors.New("foo error"),
 	).Times(1)
 
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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.jsonRestHandler.Post(
+	err = c.handler.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.jsonRestHandler.Post(
+	if err = c.handler.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)
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := 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())}
-			jsonRestHandler.EXPECT().Post(
+			handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := &beaconApiValidatorClient{handler: handler}
 			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)
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := 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})
 			}
-			jsonRestHandler.EXPECT().Post(
+			handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := &beaconApiValidatorClient{handler: handler}
 			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.jsonRestHandler.PostSSZ(ctx, endpoint, headers, bytes.NewBuffer(res.marshalledSSZ))
+		_, _, err = c.handler.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.jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(jsonData), nil)
+				err = c.handler.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.jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(jsonData), nil)
+		err = c.handler.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()
-				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+				handler := mock.NewMockJsonRestHandler(ctrl)
 
 				// Expect PostSSZ to be called first with SSZ data
 				headers := map[string]string{
 					"Eth-Consensus-Version": testCase.consensusVersion,
 				}
-				jsonRestHandler.EXPECT().PostSSZ(
+				handler.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{jsonRestHandler: jsonRestHandler}
+				validatorClient := &beaconApiValidatorClient{handler: handler}
 				_, 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()
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Expect PostSSZ to be called and succeed
 			headers := map[string]string{
 				"Eth-Consensus-Version": testCase.consensusVersion,
 			}
-			jsonRestHandler.EXPECT().PostSSZ(
+			handler.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
-			jsonRestHandler.EXPECT().Post(
+			handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := &beaconApiValidatorClient{handler: handler}
 			_, 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()
-		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+		handler := 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)
 
-		jsonRestHandler.EXPECT().PostSSZ(
+		handler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blocks",
 			gomock.Any(),
 			bytes.NewBuffer(denebBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		validatorClient := &beaconApiValidatorClient{handler: handler}
 		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()
-		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+		handler := 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)
 
-		jsonRestHandler.EXPECT().PostSSZ(
+		handler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blinded_blocks",
 			gomock.Any(),
 			bytes.NewBuffer(blindedDenebBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		validatorClient := &beaconApiValidatorClient{handler: handler}
 		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()
-		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+		handler := 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)
 
-		jsonRestHandler.EXPECT().PostSSZ(
+		handler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blocks",
 			gomock.Any(),
 			bytes.NewBuffer(electraBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		validatorClient := &beaconApiValidatorClient{handler: handler}
 		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()
-		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+		handler := 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)
 
-		jsonRestHandler.EXPECT().PostSSZ(
+		handler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blinded_blocks",
 			gomock.Any(),
 			bytes.NewBuffer(blindedElectraBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		validatorClient := &beaconApiValidatorClient{handler: handler}
 		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()
-		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+		handler := 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)
 
-		jsonRestHandler.EXPECT().PostSSZ(
+		handler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blocks",
 			gomock.Any(),
 			bytes.NewBuffer(fuluBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		validatorClient := &beaconApiValidatorClient{handler: handler}
 		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()
-		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+		handler := 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)
 
-		jsonRestHandler.EXPECT().PostSSZ(
+		handler.EXPECT().PostSSZ(
 			gomock.Any(),
 			"/eth/v2/beacon/blinded_blocks",
 			gomock.Any(),
 			bytes.NewBuffer(blindedFuluBytes),
 		)
 
-		validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+		validatorClient := &beaconApiValidatorClient{handler: handler}
 		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()
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Expect PostSSZ to be called first and fail
-			jsonRestHandler.EXPECT().PostSSZ(
+			handler.EXPECT().PostSSZ(
 				gomock.Any(),
 				testCase.endpoint,
 				gomock.Any(),
@@ -603,7 +603,7 @@ func TestProposeBeaconBlock_SSZFails_406_FallbackToJSON(t *testing.T) {
 				},
 			).Times(1)
 
-			jsonRestHandler.EXPECT().Post(
+			handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := &beaconApiValidatorClient{handler: handler}
 			_, 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()
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Expect PostSSZ to be called first and fail with non-406 error
 			sszHeaders := map[string]string{
 				"Eth-Consensus-Version": testCase.consensusVersion,
 			}
-			jsonRestHandler.EXPECT().PostSSZ(
+			handler.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
-			jsonRestHandler.EXPECT().Post(
+			handler.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{jsonRestHandler: jsonRestHandler}
+			validatorClient := &beaconApiValidatorClient{handler: handler}
 			_, 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.jsonRestHandler.Post(
+	if err = c.handler.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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Post(
 		gomock.Any(),
 		proposeExitTestEndpoint,
 		nil,
@@ -104,7 +104,7 @@ func TestProposeExit_BadRequest(t *testing.T) {
 		Signature: []byte{3},
 	}
 
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	_, err := validatorClient.proposeExit(ctx, protoSignedVoluntaryExit)
 	assert.ErrorContains(t, "foo error", err)
 }

validator/client/beacon-api/prysm_beacon_chain_client.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"github.com/OffchainLabs/prysm/v7/api/apiutil"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	validator2 "github.com/OffchainLabs/prysm/v7/consensus-types/validator"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
@@ -18,16 +19,16 @@ import (
 )
 
 // NewPrysmChainClient returns implementation of iface.PrysmChainClient.
-func NewPrysmChainClient(jsonRestHandler RestHandler, nodeClient iface.NodeClient) iface.PrysmChainClient {
+func NewPrysmChainClient(handler rest.Handler, nodeClient iface.NodeClient) iface.PrysmChainClient {
 	return prysmChainClient{
-		jsonRestHandler: jsonRestHandler,
-		nodeClient:      nodeClient,
+		handler:    handler,
+		nodeClient: nodeClient,
 	}
 }
 
 type prysmChainClient struct {
-	jsonRestHandler RestHandler
-	nodeClient      iface.NodeClient
+	handler    rest.Handler
+	nodeClient iface.NodeClient
 }
 
 func (c prysmChainClient) ValidatorCount(ctx context.Context, stateID string, statuses []validator2.Status) ([]iface.ValidatorCount, error) {
@@ -49,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.jsonRestHandler.Get(ctx, queryUrl, &validatorCountResponse); err != nil {
+	if err = c.handler.Get(ctx, queryUrl, &validatorCountResponse); err != nil {
 		return nil, err
 	}
 
@@ -96,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.jsonRestHandler.Post(ctx, "/prysm/validators/performance", nil, bytes.NewBuffer(request), resp); err != nil {
+	if err = c.handler.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()
-			jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+			handler := mock.NewMockJsonRestHandler(ctrl)
 
 			// Expect node version endpoint call.
 			var nodeVersionResponse structs.GetVersionResponse
-			jsonRestHandler.EXPECT().Get(
+			handler.EXPECT().Get(
 				gomock.Any(),
 				"/eth/v1/node/version",
 				&nodeVersionResponse,
@@ -132,7 +132,7 @@ func TestGetValidatorCount(t *testing.T) {
 			)
 
 			var validatorCountResponse structs.GetValidatorCountResponse
-			jsonRestHandler.EXPECT().Get(
+			handler.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{jsonRestHandler: jsonRestHandler},
-				jsonRestHandler: jsonRestHandler,
+				nodeClient: &beaconApiNodeClient{handler: handler},
+				handler:    handler,
 			}
 
 			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)
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	jsonRestHandler.EXPECT().Get(
+	handler.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{}
 
-	jsonRestHandler.EXPECT().Post(
+	handler.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{jsonRestHandler: jsonRestHandler},
-		jsonRestHandler: jsonRestHandler,
+		nodeClient: &beaconApiNodeClient{handler: handler},
+		handler:    handler,
 	}
 
 	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.jsonRestHandler.Post(ctx, endpoint, nil, bytes.NewBuffer(marshalledJsonRegistration), nil)
+	return c.handler.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)
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.EXPECT().Post(
 		gomock.Any(),
 		"/eth/v1/validator/register_validator",
 		nil,
@@ -129,7 +129,7 @@ func TestRegistration_Valid(t *testing.T) {
 		},
 	}
 
-	validatorClient := &beaconApiValidatorClient{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	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()
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
-	jsonRestHandler.EXPECT().Post(
+	handler := mock.NewMockJsonRestHandler(ctrl)
+	handler.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{jsonRestHandler: jsonRestHandler}
+	validatorClient := &beaconApiValidatorClient{handler: handler}
 	_, err := validatorClient.SubmitValidatorRegistrations(t.Context(), &ethpb.SignedValidatorRegistrationsV1{})
 	assert.ErrorContains(t, "foo error", err)
 }

validator/client/beacon-api/rest_handler_client_test.go

@@ -12,13 +12,12 @@ import (
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/api"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/network/httputil"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/testing/assert"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/sirupsen/logrus/hooks/test"
 )
@@ -45,12 +44,9 @@ func TestGet(t *testing.T) {
 	server := httptest.NewServer(mux)
 	defer server.Close()
 
-	jsonRestHandler := BeaconApiRestHandler{
-		client: http.Client{Timeout: time.Second * 5},
-		host:   server.URL,
-	}
+	handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 	resp := &structs.GetGenesisResponse{}
-	require.NoError(t, jsonRestHandler.Get(ctx, endpoint+"?arg1=abc&arg2=def", resp))
+	require.NoError(t, handler.Get(ctx, endpoint+"?arg1=abc&arg2=def", resp))
 	assert.DeepEqual(t, genesisJson, resp)
 }
 
@@ -79,12 +75,9 @@ func TestGetSSZ(t *testing.T) {
 		server := httptest.NewServer(mux)
 		defer server.Close()
 
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Second * 5},
-			host:   server.URL,
-		}
+		handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
-		body, header, err := jsonRestHandler.GetSSZ(ctx, endpoint)
+		body, header, err := handler.GetSSZ(ctx, endpoint)
 		require.NoError(t, err)
 		assert.DeepEqual(t, expectedBody, body)
 		require.StringContains(t, api.OctetStreamMediaType, header.Get("Content-Type"))
@@ -108,12 +101,9 @@ func TestGetSSZ(t *testing.T) {
 		server := httptest.NewServer(mux)
 		defer server.Close()
 
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Second * 5},
-			host:   server.URL,
-		}
+		handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
-		body, header, err := jsonRestHandler.GetSSZ(ctx, endpoint)
+		body, header, err := handler.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"))
@@ -136,12 +126,9 @@ func TestGetSSZ(t *testing.T) {
 		server := httptest.NewServer(mux)
 		defer server.Close()
 
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Second * 5},
-			host:   server.URL,
-		}
+		handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
-		_, _, err := jsonRestHandler.GetSSZ(ctx, endpoint)
+		_, _, err := handler.GetSSZ(ctx, endpoint)
 		require.NoError(t, err)
 		assert.LogsContain(t, logHook, "Server responded with non primary accept type")
 	})
@@ -161,7 +148,7 @@ func TestAcceptOverrideSSZ(t *testing.T) {
 		require.NoError(t, err)
 	}))
 	defer srv.Close()
-	c := NewBeaconApiRestHandler(http.Client{Timeout: time.Second * 5}, srv.URL)
+	c := rest.NewHandler(http.Client{Timeout: time.Second * 5}, srv.URL)
 	_, _, err := c.GetSSZ(t.Context(), "/test")
 	require.NoError(t, err)
 }
@@ -204,162 +191,12 @@ func TestPost(t *testing.T) {
 	server := httptest.NewServer(mux)
 	defer server.Close()
 
-	jsonRestHandler := BeaconApiRestHandler{
-		client: http.Client{Timeout: time.Second * 5},
-		host:   server.URL,
-	}
+	handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 	resp := &structs.GetGenesisResponse{}
-	require.NoError(t, jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(dataBytes), resp))
+	require.NoError(t, handler.Post(ctx, endpoint, headers, bytes.NewBuffer(dataBytes), resp))
 	assert.DeepEqual(t, genesisJson, resp)
 }
 
-func Test_decodeResp(t *testing.T) {
-	type j struct {
-		Foo string `json:"foo"`
-	}
-	t.Run("200 JSON with charset", func(t *testing.T) {
-		body := bytes.Buffer{}
-		r := &http.Response{
-			Status:     "200",
-			StatusCode: http.StatusOK,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {"application/json; charset=utf-8"}},
-		}
-		require.NoError(t, decodeResp(r, nil))
-	})
-	t.Run("200 non-JSON", func(t *testing.T) {
-		body := bytes.Buffer{}
-		r := &http.Response{
-			Status:     "200",
-			StatusCode: http.StatusOK,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {api.OctetStreamMediaType}},
-		}
-		require.NoError(t, decodeResp(r, nil))
-	})
-	t.Run("204 non-JSON", func(t *testing.T) {
-		body := bytes.Buffer{}
-		r := &http.Response{
-			Status:     "204",
-			StatusCode: http.StatusNoContent,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {api.OctetStreamMediaType}},
-		}
-		require.NoError(t, decodeResp(r, nil))
-	})
-	t.Run("500 non-JSON", func(t *testing.T) {
-		body := bytes.Buffer{}
-		_, err := body.WriteString("foo")
-		require.NoError(t, err)
-		r := &http.Response{
-			Status:     "500",
-			StatusCode: http.StatusInternalServerError,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {api.OctetStreamMediaType}},
-		}
-		err = decodeResp(r, nil)
-		errJson := &httputil.DefaultJsonError{}
-		require.Equal(t, true, errors.As(err, &errJson))
-		assert.Equal(t, http.StatusInternalServerError, errJson.Code)
-		assert.Equal(t, "foo", errJson.Message)
-	})
-	t.Run("200 JSON with resp", func(t *testing.T) {
-		body := bytes.Buffer{}
-		b, err := json.Marshal(&j{Foo: "foo"})
-		require.NoError(t, err)
-		body.Write(b)
-		r := &http.Response{
-			Status:     "200",
-			StatusCode: http.StatusOK,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {api.JsonMediaType}},
-		}
-		resp := &j{}
-		require.NoError(t, decodeResp(r, resp))
-		assert.Equal(t, "foo", resp.Foo)
-	})
-	t.Run("200 JSON without resp", func(t *testing.T) {
-		body := bytes.Buffer{}
-		r := &http.Response{
-			Status:     "200",
-			StatusCode: http.StatusOK,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {api.JsonMediaType}},
-		}
-		require.NoError(t, decodeResp(r, nil))
-	})
-	t.Run("204 JSON", func(t *testing.T) {
-		body := bytes.Buffer{}
-		r := &http.Response{
-			Status:     "204",
-			StatusCode: http.StatusNoContent,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {api.JsonMediaType}},
-		}
-		require.NoError(t, decodeResp(r, nil))
-	})
-	t.Run("500 JSON", func(t *testing.T) {
-		body := bytes.Buffer{}
-		b, err := json.Marshal(&httputil.DefaultJsonError{Code: http.StatusInternalServerError, Message: "error"})
-		require.NoError(t, err)
-		body.Write(b)
-		r := &http.Response{
-			Status:     "500",
-			StatusCode: http.StatusInternalServerError,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {api.JsonMediaType}},
-		}
-		err = decodeResp(r, nil)
-		errJson := &httputil.DefaultJsonError{}
-		require.Equal(t, true, errors.As(err, &errJson))
-		assert.Equal(t, http.StatusInternalServerError, errJson.Code)
-		assert.Equal(t, "error", errJson.Message)
-	})
-	t.Run("200 JSON cannot decode", func(t *testing.T) {
-		body := bytes.Buffer{}
-		_, err := body.WriteString("foo")
-		require.NoError(t, err)
-		r := &http.Response{
-			Status:     "200",
-			StatusCode: http.StatusOK,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {api.JsonMediaType}},
-			Request:    &http.Request{},
-		}
-		resp := &j{}
-		err = decodeResp(r, resp)
-		assert.ErrorContains(t, "failed to decode response body into json", err)
-	})
-	t.Run("500 JSON cannot decode", func(t *testing.T) {
-		body := bytes.Buffer{}
-		_, err := body.WriteString("foo")
-		require.NoError(t, err)
-		r := &http.Response{
-			Status:     "500",
-			StatusCode: http.StatusInternalServerError,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {api.JsonMediaType}},
-			Request:    &http.Request{},
-		}
-		err = decodeResp(r, nil)
-		assert.ErrorContains(t, "failed to decode response body into error json", err)
-	})
-	t.Run("500 not JSON", func(t *testing.T) {
-		body := bytes.Buffer{}
-		_, err := body.WriteString("foo")
-		require.NoError(t, err)
-		r := &http.Response{
-			Status:     "500",
-			StatusCode: http.StatusInternalServerError,
-			Body:       io.NopCloser(&body),
-			Header:     map[string][]string{"Content-Type": {"text/plain"}},
-			Request:    &http.Request{},
-		}
-		err = decodeResp(r, nil)
-		assert.ErrorContains(t, "HTTP request unsuccessful (500: foo)", err)
-	})
-}
-
 func TestGetStatusCode(t *testing.T) {
 	ctx := t.Context()
 	const endpoint = "/eth/v1/node/health"
@@ -401,24 +238,18 @@ func TestGetStatusCode(t *testing.T) {
 			server := httptest.NewServer(mux)
 			defer server.Close()
 
-			jsonRestHandler := BeaconApiRestHandler{
-				client: http.Client{Timeout: time.Second * 5},
-				host:   server.URL,
-			}
+			handler := rest.NewHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
-			statusCode, err := jsonRestHandler.GetStatusCode(ctx, endpoint)
+			statusCode, err := handler.GetStatusCode(ctx, endpoint)
 			require.NoError(t, err)
 			assert.Equal(t, tc.expectedStatusCode, statusCode)
 		})
 	}
 
 	t.Run("returns error on connection failure", func(t *testing.T) {
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Millisecond * 100},
-			host:   "http://localhost:99999", // Invalid port
-		}
+		handler := rest.NewHandler(http.Client{Timeout: time.Millisecond * 100}, "http://localhost:99999")
 
-		_, err := jsonRestHandler.GetStatusCode(ctx, endpoint)
+		_, err := handler.GetStatusCode(ctx, endpoint)
 		require.ErrorContains(t, "failed to perform request", err)
 	})
 }

validator/client/beacon-api/state_validators.go

@@ -9,6 +9,7 @@ import (
 	"strconv"
 
 	"github.com/OffchainLabs/prysm/v7/api/apiutil"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/pkg/errors"
@@ -21,7 +22,7 @@ type StateValidatorsProvider interface {
 }
 
 type beaconApiStateValidatorsProvider struct {
-	jsonRestHandler RestHandler
+	handler rest.Handler
 }
 
 func (c beaconApiStateValidatorsProvider) StateValidators(
@@ -93,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.jsonRestHandler.Post(ctx, endpoint, nil, bytes.NewBuffer(reqBytes), stateValidatorsJson); err == nil {
+	if err = c.handler.Post(ctx, endpoint, nil, bytes.NewBuffer(reqBytes), stateValidatorsJson); err == nil {
 		if stateValidatorsJson.Data == nil {
 			return nil, errors.New("stateValidatorsJson.Data is nil")
 		}
@@ -115,7 +116,7 @@ func (c beaconApiStateValidatorsProvider) getStateValidatorsHelper(
 
 	query := apiutil.BuildURL(endpoint, queryParams)
 
-	err = c.jsonRestHandler.Get(ctx, query, stateValidatorsJson)
+	err = c.handler.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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	wanted := []*structs.ValidatorContainer{
 		{
@@ -69,7 +69,7 @@ func TestGetStateValidators_Nominal_POST(t *testing.T) {
 
 	ctx := t.Context()
 
-	jsonRestHandler.EXPECT().Post(
+	handler.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{jsonRestHandler: jsonRestHandler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
 	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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := 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.
-	jsonRestHandler.EXPECT().Post(
+	handler.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)
 
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		query,
 		&stateValidatorsResponseJson,
@@ -190,7 +190,7 @@ func TestGetStateValidators_Nominal_GET(t *testing.T) {
 		},
 	).Times(1)
 
-	stateValidatorsProvider := beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
 	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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	ctx := t.Context()
 
 	// First call POST.
-	jsonRestHandler.EXPECT().Post(
+	handler.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)
 
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		query,
 		&stateValidatorsResponseJson,
@@ -254,7 +254,7 @@ func TestGetStateValidators_GetRestJsonResponseOnError(t *testing.T) {
 		errors.New("an error"),
 	).Times(1)
 
-	stateValidatorsProvider := beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
 	_, 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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
-	jsonRestHandler.EXPECT().Post(
+	handler.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{jsonRestHandler: jsonRestHandler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
 	_, 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{}
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	// First call POST which will return an error.
-	jsonRestHandler.EXPECT().Post(
+	handler.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)
 
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		query,
 		&stateValidatorsResponseJson,
@@ -353,7 +353,7 @@ func TestGetStateValidators_DataIsNil_GET(t *testing.T) {
 		},
 	).Times(1)
 
-	stateValidatorsProvider := beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler}
+	stateValidatorsProvider := beaconApiStateValidatorsProvider{handler: handler}
 	_, 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)
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: stateValidatorsProvider,
 		prysmChainClient: prysmChainClient{
 			nodeClient: &beaconApiNodeClient{
-				jsonRestHandler: jsonRestHandler,
+				handler: handler,
 			},
 		},
 	}
 
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	jsonRestHandler.EXPECT().Get(
+	handler.EXPECT().Get(
 		gomock.Any(),
 		"/eth/v1/node/version",
 		&nodeVersionResponse,
@@ -165,11 +165,11 @@ func TestMultipleValidatorStatus_Nominal(t *testing.T) {
 		nil,
 	).Times(1)
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	jsonRestHandler.EXPECT().Get(
+	handler.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{
-				jsonRestHandler: jsonRestHandler,
+				handler: handler,
 			},
 		},
 	}
@@ -317,11 +317,11 @@ func TestGetValidatorsStatusResponse_Nominal_SomeActiveValidators(t *testing.T)
 		nil,
 	).Times(1)
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	jsonRestHandler.EXPECT().Get(
+	handler.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
-	jsonRestHandler.EXPECT().Get(
+	handler.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{
-				jsonRestHandler: jsonRestHandler,
+				handler: handler,
 			},
-			jsonRestHandler: jsonRestHandler,
+			handler: handler,
 		},
 	}
 	actualValidatorsPubKey, actualValidatorsIndex, actualValidatorsStatusResponse, err := validatorClient.validatorsStatusResponse(ctx, validatorsPubKey, validatorsIndex)
@@ -465,11 +465,11 @@ func TestGetValidatorsStatusResponse_Nominal_NoActiveValidators(t *testing.T) {
 		nil,
 	).Times(1)
 
-	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+	handler := mock.NewMockJsonRestHandler(ctrl)
 
 	// Expect node version endpoint call.
 	var nodeVersionResponse structs.GetVersionResponse
-	jsonRestHandler.EXPECT().Get(
+	handler.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{
-				jsonRestHandler: jsonRestHandler,
+				handler: handler,
 			},
-			jsonRestHandler: jsonRestHandler,
+			handler: handler,
 		},
 	}
 	actualValidatorsPubKey, actualValidatorsIndex, actualValidatorsStatusResponse, err := validatorClient.validatorsStatusResponse(ctx, wantedValidatorsPubKey, nil)
@@ -704,11 +704,11 @@ func TestValidatorStatusResponse_InvalidData(t *testing.T) {
 					testCase.inputGetStateValidatorsInterface.outputErr,
 				).Times(1)
 
-				jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
+				handler := mock.NewMockJsonRestHandler(ctrl)
 
 				// Expect node version endpoint call.
 				var nodeVersionResponse structs.GetVersionResponse
-				jsonRestHandler.EXPECT().Get(
+				handler.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{
-							jsonRestHandler: jsonRestHandler,
+							handler: handler,
 						},
-						jsonRestHandler: jsonRestHandler,
+						handler: handler,
 					},
 				}
 

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.jsonRestHandler.Get(ctx, "/eth/v2/beacon/blocks/head", &signedBlockResponseJson); err != nil {
+	if err := c.handler.Get(ctx, "/eth/v2/beacon/blocks/head", &signedBlockResponseJson); err != nil {
 		return nil, err
 	}