removing unneeded function from gRPC provider

Co-authored-by: Radosław Kapka <rkapka@wp.pl>

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,172 @@
+package grpc
+
+import (
+	"context"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	pkgErrors "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
+	// SetHost switches to the endpoint at the given index.
+	// The new connection is created lazily on next CurrentConn() call.
+	SetHost(index int) error
+	// Close closes the current connection.
+	Close() error
+}
+
+type grpcConnectionProvider struct {
+	// Immutable after construction - no lock needed for reads
+	endpoints []string
+	ctx       context.Context
+	dialOpts  []grpc.DialOption
+
+	// Current connection state (protected by mu)
+	currentIndex uint64
+	conn         *grpc.ClientConn
+
+	mu     sync.Mutex
+	closed atomic.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, pkgErrors.New("no gRPC endpoints provided")
+	}
+
+	log.WithFields(logrus.Fields{
+		"endpoints": endpoints,
+		"count":     len(endpoints),
+	}).Info("Initialized gRPC connection provider with multiple endpoints")
+
+	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
+	}
+	var endpoints []string
+	for p := range strings.SplitSeq(endpoint, ",") {
+		if p = strings.TrimSpace(p); p != "" {
+			endpoints = append(endpoints, p)
+		}
+	}
+	return endpoints
+}
+
+func (p *grpcConnectionProvider) CurrentConn() *grpc.ClientConn {
+	if p.closed.Load() {
+		return nil
+	}
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	// 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) SetHost(index int) error {
+	if index < 0 || index >= len(p.endpoints) {
+		return pkgErrors.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]
+
+	// Close existing connection if any
+	if p.conn != nil {
+		if err := p.conn.Close(); err != nil {
+			log.WithError(err).WithField("endpoint", oldHost).Debug("Failed to close previous connection")
+		}
+		p.conn = nil
+	}
+
+	p.currentIndex = uint64(index)
+
+	log.WithFields(logrus.Fields{
+		"previousHost": oldHost,
+		"newHost":      p.endpoints[index],
+	}).Debug("Switched gRPC endpoint")
+	return nil
+}
+
+func (p *grpcConnectionProvider) Close() error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.closed.Load() {
+		return nil
+	}
+	p.closed.Store(true)
+
+	if p.conn != nil {
+		if err := p.conn.Close(); err != nil {
+			return pkgErrors.Wrapf(err, "failed to close connection to %s", p.endpoints[p.currentIndex])
+		}
+		p.conn = nil
+	}
+	return nil
+}

api/grpc/grpc_connection_provider_test.go

@@ -0,0 +1,203 @@
+package grpc
+
+import (
+	"context"
+	"net"
+	"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", ",,,", nil},
+		{"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) {
+			assert.DeepEqual(t, tt.expected, parseEndpoints(tt.input))
+		})
+	}
+}
+
+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.SetHost(1))
+
+	p.mu.Lock()
+	assert.Equal(t, (*grpc.ClientConn)(nil), p.conn, "Connection should be nil after SetHost (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("SetHost", func(t *testing.T) {
+		require.NoError(t, provider.SetHost(1))
+		assert.Equal(t, addrs[1], provider.CurrentHost())
+		assert.NotNil(t, provider.CurrentConn()) // New connection created lazily
+		require.NoError(t, provider.SetHost(0))
+		assert.Equal(t, addrs[0], provider.CurrentHost())
+		require.ErrorContains(t, "invalid host index", provider.SetHost(-1))
+		require.ErrorContains(t, "invalid host index", provider.SetHost(3))
+	})
+
+	t.Run("SetHost circular", func(t *testing.T) {
+		// Test round-robin style switching using SetHost with manual index
+		indices := []int{1, 2, 0, 1} // Simulate circular switching
+		for i, idx := range indices {
+			require.NoError(t, provider.SetHost(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())
+	require.NoError(t, provider.Close())
+	assert.Equal(t, (*grpc.ClientConn)(nil), provider.CurrentConn())
+	require.NoError(t, provider.Close()) // Double close is safe
+}

api/grpc/mock_grpc_provider.go

@@ -0,0 +1,20 @@
+package grpc
+
+import "google.golang.org/grpc"
+
+// MockGrpcProvider implements GrpcConnectionProvider for testing.
+type MockGrpcProvider struct {
+	MockConn  *grpc.ClientConn
+	MockHosts []string
+}
+
+func (m *MockGrpcProvider) CurrentConn() *grpc.ClientConn { return m.MockConn }
+func (m *MockGrpcProvider) CurrentHost() string {
+	if len(m.MockHosts) > 0 {
+		return m.MockHosts[0]
+	}
+	return ""
+}
+func (m *MockGrpcProvider) Hosts() []string   { return m.MockHosts }
+func (m *MockGrpcProvider) SetHost(int) error { return nil }
+func (m *MockGrpcProvider) Close() error      { return nil }

api/rest/BUILD.bazel

@@ -0,0 +1,33 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "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/mock_rest_provider.go

@@ -0,0 +1,23 @@
+package rest
+
+import "net/http"
+
+// MockRestProvider implements RestConnectionProvider for testing.
+type MockRestProvider struct {
+	MockClient  *http.Client
+	MockHandler RestHandler
+	MockHosts   []string
+	HostIndex   int
+}
+
+func (m *MockRestProvider) HttpClient() *http.Client { return m.MockClient }
+func (m *MockRestProvider) RestHandler() RestHandler { return m.MockHandler }
+func (m *MockRestProvider) CurrentHost() string {
+	if len(m.MockHosts) > 0 {
+		return m.MockHosts[m.HostIndex%len(m.MockHosts)]
+	}
+	return ""
+}
+func (m *MockRestProvider) Hosts() []string         { return m.MockHosts }
+func (m *MockRestProvider) SetHost(index int) error { m.HostIndex = index; return nil }
+func (m *MockRestProvider) NextHost()               { m.HostIndex = (m.HostIndex + 1) % len(m.MockHosts) }

api/rest/rest_connection_provider.go

@@ -0,0 +1,177 @@
+package rest
+
+import (
+	"net/http"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v7/api/client"
+	pkgErrors "github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+)
+
+var log = logrus.WithField("prefix", "rest")
+
+// 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
+	// RestHandler returns the REST handler for making API requests.
+	RestHandler() RestHandler
+	// CurrentHost returns the current REST API endpoint URL.
+	CurrentHost() string
+	// Hosts returns all configured REST API endpoint URLs.
+	Hosts() []string
+	// SetHost switches to the endpoint at the given index.
+	SetHost(index int) error
+	// NextHost switches to the next endpoint in round-robin fashion.
+	NextHost()
+}
+
+// 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   RestHandler
+	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, pkgErrors.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 = newRestHandler(*p.httpClient, endpoints[0])
+
+	log.WithFields(logrus.Fields{
+		"endpoints": endpoints,
+		"count":     len(endpoints),
+	}).Info("Initialized REST connection provider with endpoints")
+
+	return p, nil
+}
+
+// parseEndpoints splits a comma-separated endpoint string into individual endpoints.
+func parseEndpoints(endpoint string) []string {
+	if endpoint == "" {
+		return nil
+	}
+	var endpoints []string
+	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) RestHandler() RestHandler {
+	return p.restHandler
+}
+
+func (p *restConnectionProvider) CurrentHost() string {
+	idx := p.currentIndex.Load() % uint64(len(p.endpoints))
+	return p.endpoints[idx]
+}
+
+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) SetHost(index int) error {
+	if index < 0 || index >= len(p.endpoints) {
+		return pkgErrors.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.SetHost(p.endpoints[index])
+
+	log.WithFields(logrus.Fields{
+		"previousHost": p.endpoints[oldIdx%uint64(len(p.endpoints))],
+		"newHost":      p.endpoints[index],
+	}).Debug("Trying REST endpoint")
+	return nil
+}
+
+func (p *restConnectionProvider) NextHost() {
+	oldIdx := p.currentIndex.Load()
+	newIdx := (oldIdx + 1) % uint64(len(p.endpoints))
+	p.currentIndex.Store(newIdx)
+
+	// Update the rest handler's host
+	p.restHandler.SetHost(p.endpoints[newIdx])
+
+	log.WithFields(logrus.Fields{
+		"previousHost": p.endpoints[oldIdx],
+		"newHost":      p.endpoints[newIdx],
+	}).Debug("Switched to next REST endpoint")
+}

api/rest/rest_connection_provider_test.go

@@ -0,0 +1,85 @@
+package rest
+
+import (
+	"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", ",,,", nil},
+		{"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) {
+			assert.DeepEqual(t, tt.expected, parseEndpoints(tt.input))
+		})
+	}
+}
+
+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("SetHost", func(t *testing.T) {
+		require.NoError(t, provider.SetHost(1))
+		assert.Equal(t, "http://host2:3500", provider.CurrentHost())
+		require.NoError(t, provider.SetHost(0))
+		assert.Equal(t, "http://host1:3500", provider.CurrentHost())
+		require.ErrorContains(t, "invalid host index", provider.SetHost(-1))
+		require.ErrorContains(t, "invalid host index", provider.SetHost(3))
+	})
+
+	t.Run("NextHost circular", func(t *testing.T) {
+		require.NoError(t, provider.SetHost(0)) // Reset to start
+		expected := []string{"http://host2:3500", "http://host3:3500", "http://host1:3500", "http://host2:3500"}
+		for i, exp := range expected {
+			provider.NextHost()
+			assert.Equal(t, exp, 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 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,6 +21,7 @@ import (
 
 type reqOption func(*http.Request)
 
+// RestHandler defines the interface for making REST API requests.
 type RestHandler interface {
 	Get(ctx context.Context, endpoint string, resp any) error
 	GetStatusCode(ctx context.Context, endpoint string) (int, error)
@@ -32,26 +33,31 @@ type RestHandler interface {
 	SetHost(host string)
 }
 
-type BeaconApiRestHandler struct {
+type restHandler struct {
 	client       http.Client
 	host         string
 	reqOverrides []reqOption
 }
 
-// NewBeaconApiRestHandler returns a RestHandler
-func NewBeaconApiRestHandler(client http.Client, host string) RestHandler {
-	brh := &BeaconApiRestHandler{
+// newRestHandler returns a RestHandler (internal use)
+func newRestHandler(client http.Client, host string) RestHandler {
+	return NewRestHandler(client, host)
+}
+
+// NewRestHandler returns a RestHandler
+func NewRestHandler(client http.Client, host string) RestHandler {
+	rh := &restHandler{
 		client: client,
 		host:   host,
 	}
-	brh.appendAcceptOverride()
-	return brh
+	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 *restHandler) appendAcceptOverride() {
 	if accept := os.Getenv(params.EnvNameOverrideAccept); accept != "" {
 		c.reqOverrides = append(c.reqOverrides, func(req *http.Request) {
 			req.Header.Set("Accept", accept)
@@ -60,18 +66,18 @@ func (c *BeaconApiRestHandler) appendAcceptOverride() {
 }
 
 // HttpClient returns the underlying HTTP client of the handler
-func (c *BeaconApiRestHandler) HttpClient() *http.Client {
+func (c *restHandler) HttpClient() *http.Client {
 	return &c.client
 }
 
 // Host returns the underlying HTTP host
-func (c *BeaconApiRestHandler) Host() string {
+func (c *restHandler) Host() string {
 	return c.host
 }
 
 // Get sends a GET request and decodes the response body as a JSON object into the passed in object.
 // If an HTTP error is returned, the body is decoded as a DefaultJsonError JSON object and returned as the first return value.
-func (c *BeaconApiRestHandler) Get(ctx context.Context, endpoint string, resp any) error {
+func (c *restHandler) Get(ctx context.Context, endpoint string, resp any) error {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -94,7 +100,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 *restHandler) GetStatusCode(ctx context.Context, endpoint string) (int, error) {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -113,7 +119,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 *restHandler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -168,7 +174,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 *restHandler) Post(
 	ctx context.Context,
 	apiEndpoint string,
 	headers map[string]string,
@@ -204,7 +210,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 *restHandler) PostSSZ(
 	ctx context.Context,
 	apiEndpoint string,
 	headers map[string]string,
@@ -305,6 +311,6 @@ func decodeResp(httpResp *http.Response, resp any) error {
 	return nil
 }
 
-func (c *BeaconApiRestHandler) SetHost(host string) {
+func (c *restHandler) SetHost(host string) {
 	c.host = host
 }

beacon-chain/core/gloas/BUILD.bazel

@@ -2,10 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "bid.go",
-        "pending_payment.go",
-    ],
+    srcs = ["bid.go"],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
     visibility = ["//visibility:public"],
     deps = [
@@ -15,7 +12,6 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -26,15 +22,10 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "bid_test.go",
-        "pending_payment_test.go",
-    ],
+    srcs = ["bid_test.go"],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/interfaces:go_default_library",

beacon-chain/core/gloas/pending_payment.go

@@ -1,76 +0,0 @@
-package gloas
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/pkg/errors"
-)
-
-// ProcessBuilderPendingPayments processes the builder pending payments from the previous epoch.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def process_builder_pending_payments(state: BeaconState) -> None:
-//
-//	quorum = get_builder_payment_quorum_threshold(state)
-//	for payment in state.builder_pending_payments[:SLOTS_PER_EPOCH]:
-//	    if payment.weight >= quorum:
-//	        state.builder_pending_withdrawals.append(payment.withdrawal)
-//
-//	old_payments = state.builder_pending_payments[SLOTS_PER_EPOCH:]
-//	new_payments = [BuilderPendingPayment() for _ in range(SLOTS_PER_EPOCH)]
-//	state.builder_pending_payments = old_payments + new_payments
-func ProcessBuilderPendingPayments(state state.BeaconState) error {
-	quorum, err := builderQuorumThreshold(state)
-	if err != nil {
-		return errors.Wrap(err, "could not compute builder payment quorum threshold")
-	}
-
-	payments, err := state.BuilderPendingPayments()
-	if err != nil {
-		return errors.Wrap(err, "could not get builder pending payments")
-	}
-
-	slotsPerEpoch := uint64(params.BeaconConfig().SlotsPerEpoch)
-	var withdrawals []*ethpb.BuilderPendingWithdrawal
-	for _, payment := range payments[:slotsPerEpoch] {
-		if quorum > payment.Weight {
-			continue
-		}
-		withdrawals = append(withdrawals, payment.Withdrawal)
-	}
-
-	if err := state.AppendBuilderPendingWithdrawals(withdrawals); err != nil {
-		return errors.Wrap(err, "could not append builder pending withdrawals")
-	}
-
-	if err := state.RotateBuilderPendingPayments(); err != nil {
-		return errors.Wrap(err, "could not rotate builder pending payments")
-	}
-
-	return nil
-}
-
-// builderQuorumThreshold calculates the quorum threshold for builder payments.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def get_builder_payment_quorum_threshold(state: BeaconState) -> uint64:
-//
-//	per_slot_balance = get_total_active_balance(state) // SLOTS_PER_EPOCH
-//	quorum = per_slot_balance * BUILDER_PAYMENT_THRESHOLD_NUMERATOR
-//	return uint64(quorum // BUILDER_PAYMENT_THRESHOLD_DENOMINATOR)
-func builderQuorumThreshold(state state.ReadOnlyBeaconState) (primitives.Gwei, error) {
-	activeBalance, err := helpers.TotalActiveBalance(state)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get total active balance")
-	}
-
-	cfg := params.BeaconConfig()
-	slotsPerEpoch := uint64(cfg.SlotsPerEpoch)
-	numerator := cfg.BuilderPaymentThresholdNumerator
-	denominator := cfg.BuilderPaymentThresholdDenominator
-
-	activeBalancePerSlot := activeBalance / slotsPerEpoch
-	quorum := (activeBalancePerSlot * numerator) / denominator
-	return primitives.Gwei(quorum), nil
-}

beacon-chain/core/gloas/pending_payment_test.go

@@ -1,119 +0,0 @@
-package gloas
-
-import (
-	"slices"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestBuilderQuorumThreshold(t *testing.T) {
-	helpers.ClearCache()
-	cfg := params.BeaconConfig()
-
-	validators := []*ethpb.Validator{
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-	}
-	st, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{Validators: validators})
-	require.NoError(t, err)
-
-	got, err := builderQuorumThreshold(st)
-	require.NoError(t, err)
-
-	total := uint64(len(validators)) * cfg.MaxEffectiveBalance
-	perSlot := total / uint64(cfg.SlotsPerEpoch)
-	want := (perSlot * cfg.BuilderPaymentThresholdNumerator) / cfg.BuilderPaymentThresholdDenominator
-	require.Equal(t, primitives.Gwei(want), got)
-}
-
-func TestProcessBuilderPendingPayments(t *testing.T) {
-	helpers.ClearCache()
-	cfg := params.BeaconConfig()
-
-	buildPayments := func(weights ...primitives.Gwei) []*ethpb.BuilderPendingPayment {
-		p := make([]*ethpb.BuilderPendingPayment, 2*int(cfg.SlotsPerEpoch))
-		for i := range p {
-			p[i] = &ethpb.BuilderPendingPayment{
-				Withdrawal: &ethpb.BuilderPendingWithdrawal{FeeRecipient: make([]byte, 20)},
-			}
-		}
-		for i, w := range weights {
-			p[i].Weight = w
-			p[i].Withdrawal.Amount = 1
-		}
-		return p
-	}
-
-	validators := []*ethpb.Validator{
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-	}
-	pbSt, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{Validators: validators})
-	require.NoError(t, err)
-
-	total := uint64(len(validators)) * cfg.MaxEffectiveBalance
-	perSlot := total / uint64(cfg.SlotsPerEpoch)
-	quorum := (perSlot * cfg.BuilderPaymentThresholdNumerator) / cfg.BuilderPaymentThresholdDenominator
-	slotsPerEpoch := int(cfg.SlotsPerEpoch)
-
-	t.Run("append qualifying withdrawals", func(t *testing.T) {
-		payments := buildPayments(primitives.Gwei(quorum+1), primitives.Gwei(quorum+2))
-		st := &testProcessState{BeaconState: pbSt, payments: payments}
-
-		require.NoError(t, ProcessBuilderPendingPayments(st))
-		require.Equal(t, 2, len(st.withdrawals))
-		require.Equal(t, payments[0].Withdrawal, st.withdrawals[0])
-		require.Equal(t, payments[1].Withdrawal, st.withdrawals[1])
-
-		require.Equal(t, 2*slotsPerEpoch, len(st.payments))
-		for i := slotsPerEpoch; i < 2*slotsPerEpoch; i++ {
-			require.Equal(t, primitives.Gwei(0), st.payments[i].Weight)
-			require.Equal(t, primitives.Gwei(0), st.payments[i].Withdrawal.Amount)
-			require.Equal(t, 20, len(st.payments[i].Withdrawal.FeeRecipient))
-		}
-	})
-
-	t.Run("no withdrawals when below quorum", func(t *testing.T) {
-		payments := buildPayments(primitives.Gwei(quorum - 1))
-		st := &testProcessState{BeaconState: pbSt, payments: payments}
-
-		require.NoError(t, ProcessBuilderPendingPayments(st))
-		require.Equal(t, 0, len(st.withdrawals))
-	})
-}
-
-type testProcessState struct {
-	state.BeaconState
-	payments    []*ethpb.BuilderPendingPayment
-	withdrawals []*ethpb.BuilderPendingWithdrawal
-}
-
-func (t *testProcessState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error) {
-	return t.payments, nil
-}
-
-func (t *testProcessState) AppendBuilderPendingWithdrawals(withdrawals []*ethpb.BuilderPendingWithdrawal) error {
-	t.withdrawals = append(t.withdrawals, withdrawals...)
-	return nil
-}
-
-func (t *testProcessState) RotateBuilderPendingPayments() error {
-	slotsPerEpoch := int(params.BeaconConfig().SlotsPerEpoch)
-	rotated := slices.Clone(t.payments[slotsPerEpoch:])
-	for range slotsPerEpoch {
-		rotated = append(rotated, &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		})
-	}
-	t.payments = rotated
-	return nil
-}

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

@@ -132,7 +132,7 @@ func TestGetSpec(t *testing.T) {
 	config.MinSyncCommitteeParticipants = 71
 	config.ProposerReorgCutoffBPS = primitives.BP(121)
 	config.AttestationDueBPS = primitives.BP(122)
-	config.AggregateDueBPS = primitives.BP(123)
+	config.AggregrateDueBPS = primitives.BP(123)
 	config.ContributionDueBPS = primitives.BP(124)
 	config.TerminalBlockHash = common.HexToHash("TerminalBlockHash")
 	config.TerminalBlockHashActivationEpoch = 72
@@ -170,8 +170,6 @@ func TestGetSpec(t *testing.T) {
 	config.SyncMessageDueBPS = 103
 	config.BuilderWithdrawalPrefixByte = byte('b')
 	config.BuilderIndexSelfBuild = primitives.BuilderIndex(125)
-	config.BuilderPaymentThresholdNumerator = 104
-	config.BuilderPaymentThresholdDenominator = 105
 
 	var dbp [4]byte
 	copy(dbp[:], []byte{'0', '0', '0', '1'})
@@ -212,7 +210,7 @@ func TestGetSpec(t *testing.T) {
 	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &resp))
 	data, ok := resp.Data.(map[string]any)
 	require.Equal(t, true, ok)
-	assert.Equal(t, 180, len(data))
+	assert.Equal(t, 178, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -470,7 +468,7 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "121", v)
 			case "ATTESTATION_DUE_BPS":
 				assert.Equal(t, "122", v)
-			case "AGGREGATE_DUE_BPS":
+			case "AGGREGRATE_DUE_BPS":
 				assert.Equal(t, "123", v)
 			case "CONTRIBUTION_DUE_BPS":
 				assert.Equal(t, "124", v)
@@ -590,10 +588,6 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "102", v)
 			case "SYNC_MESSAGE_DUE_BPS":
 				assert.Equal(t, "103", v)
-			case "BUILDER_PAYMENT_THRESHOLD_NUMERATOR":
-				assert.Equal(t, "104", v)
-			case "BUILDER_PAYMENT_THRESHOLD_DENOMINATOR":
-				assert.Equal(t, "105", v)
 			case "BLOB_SCHEDULE":
 				blobSchedule, ok := v.([]any)
 				assert.Equal(t, true, ok)

beacon-chain/state/interfaces_gloas.go

@@ -9,8 +9,6 @@ import (
 type writeOnlyGloasFields interface {
 	SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error
 	SetBuilderPendingPayment(index primitives.Slot, payment *ethpb.BuilderPendingPayment) error
-	RotateBuilderPendingPayments() error
-	AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal) error
 }
 
 type readOnlyGloasFields interface {
@@ -18,5 +16,4 @@ type readOnlyGloasFields interface {
 	IsActiveBuilder(primitives.BuilderIndex) (bool, error)
 	CanBuilderCoverBid(primitives.BuilderIndex, primitives.Gwei) (bool, error)
 	LatestBlockHash() ([32]byte, error)
-	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
 }

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

@@ -135,15 +135,3 @@ func (b *BeaconState) builderPendingBalanceToWithdraw(builderIndex primitives.Bu
 	}
 	return total
 }
-
-// BuilderPendingPayments returns a copy of the builder pending payments.
-func (b *BeaconState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("BuilderPendingPayments", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.builderPendingPaymentsVal(), nil
-}

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

@@ -157,12 +157,3 @@ func TestBuilderHelpers(t *testing.T) {
 		require.Equal(t, false, ok)
 	})
 }
-
-func TestBuilderPendingPayments_UnsupportedVersion(t *testing.T) {
-	stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-	require.NoError(t, err)
-	st := stIface.(*state_native.BeaconState)
-
-	_, err = st.BuilderPendingPayments()
-	require.ErrorContains(t, "BuilderPendingPayments", err)
-}

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

@@ -725,13 +725,3 @@ func ProtobufBeaconStateFulu(s any) (*ethpb.BeaconStateFulu, error) {
 	}
 	return pbState, nil
 }
-
-// ProtobufBeaconStateGloas transforms an input into beacon state Gloas in the form of protobuf.
-// Error is returned if the input is not type protobuf beacon state.
-func ProtobufBeaconStateGloas(s any) (*ethpb.BeaconStateGloas, error) {
-	pbState, ok := s.(*ethpb.BeaconStateGloas)
-	if !ok {
-		return nil, errors.New("input is not type pb.BeaconStateGloas")
-	}
-	return pbState, nil
-}

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

@@ -4,75 +4,12 @@ import (
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stateutil"
-	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 )
 
-// RotateBuilderPendingPayments rotates the queue by dropping slots per epoch payments from the
-// front and appending slots per epoch empty payments to the end.
-// This implements: state.builder_pending_payments = state.builder_pending_payments[SLOTS_PER_EPOCH:] + [BuilderPendingPayment() for _ in range(SLOTS_PER_EPOCH)]
-func (b *BeaconState) RotateBuilderPendingPayments() error {
-	if b.version < version.Gloas {
-		return errNotSupported("RotateBuilderPendingPayments", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	copy(b.builderPendingPayments[:slotsPerEpoch], b.builderPendingPayments[slotsPerEpoch:2*slotsPerEpoch])
-
-	for i := slotsPerEpoch; i < primitives.Slot(len(b.builderPendingPayments)); i++ {
-		b.builderPendingPayments[i] = emptyPayment()
-	}
-
-	b.markFieldAsDirty(types.BuilderPendingPayments)
-	b.rebuildTrie[types.BuilderPendingPayments] = true
-	return nil
-}
-
-// AppendBuilderPendingWithdrawals appends builder pending withdrawals to the beacon state.
-// If the withdrawals slice is shared, it copies the slice first to preserve references.
-func (b *BeaconState) AppendBuilderPendingWithdrawals(withdrawals []*ethpb.BuilderPendingWithdrawal) error {
-	if b.version < version.Gloas {
-		return errNotSupported("AppendBuilderPendingWithdrawals", b.version)
-	}
-
-	if len(withdrawals) == 0 {
-		return nil
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	pendingWithdrawals := b.builderPendingWithdrawals
-	if b.sharedFieldReferences[types.BuilderPendingWithdrawals].Refs() > 1 {
-		pendingWithdrawals = make([]*ethpb.BuilderPendingWithdrawal, 0, len(b.builderPendingWithdrawals)+len(withdrawals))
-		pendingWithdrawals = append(pendingWithdrawals, b.builderPendingWithdrawals...)
-		b.sharedFieldReferences[types.BuilderPendingWithdrawals].MinusRef()
-		b.sharedFieldReferences[types.BuilderPendingWithdrawals] = stateutil.NewRef(1)
-	}
-
-	b.builderPendingWithdrawals = append(pendingWithdrawals, withdrawals...)
-	b.markFieldAsDirty(types.BuilderPendingWithdrawals)
-	return nil
-}
-
-func emptyPayment() *ethpb.BuilderPendingPayment {
-	return &ethpb.BuilderPendingPayment{
-		Weight: 0,
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: make([]byte, 20),
-			Amount:       0,
-			BuilderIndex: 0,
-		},
-	}
-}
-
 // SetExecutionPayloadBid sets the latest execution payload bid in the state.
 func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error {
 	if b.version < version.Gloas {

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

@@ -5,8 +5,6 @@ import (
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stateutil"
-	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
@@ -140,110 +138,3 @@ func TestSetBuilderPendingPayment(t *testing.T) {
 		require.Equal(t, false, st.dirtyFields[types.BuilderPendingPayments])
 	})
 }
-
-func TestRotateBuilderPendingPayments(t *testing.T) {
-	totalPayments := 2 * params.BeaconConfig().SlotsPerEpoch
-	payments := make([]*ethpb.BuilderPendingPayment, totalPayments)
-	for i := range payments {
-		idx := uint64(i)
-		payments[i] = &ethpb.BuilderPendingPayment{
-			Weight: primitives.Gwei(idx * 100e9),
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-				Amount:       primitives.Gwei(idx * 1e9),
-				BuilderIndex: primitives.BuilderIndex(idx + 100),
-			},
-		}
-	}
-
-	statePb, err := InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
-		BuilderPendingPayments: payments,
-	})
-	require.NoError(t, err)
-	st, ok := statePb.(*BeaconState)
-	require.Equal(t, true, ok)
-
-	oldPayments, err := st.BuilderPendingPayments()
-	require.NoError(t, err)
-	require.NoError(t, st.RotateBuilderPendingPayments())
-
-	newPayments, err := st.BuilderPendingPayments()
-	require.NoError(t, err)
-	slotsPerEpoch := int(params.BeaconConfig().SlotsPerEpoch)
-	for i := range slotsPerEpoch {
-		require.DeepEqual(t, oldPayments[slotsPerEpoch+i], newPayments[i])
-	}
-
-	for i := slotsPerEpoch; i < 2*slotsPerEpoch; i++ {
-		payment := newPayments[i]
-		require.Equal(t, primitives.Gwei(0), payment.Weight)
-		require.Equal(t, 20, len(payment.Withdrawal.FeeRecipient))
-		require.Equal(t, primitives.Gwei(0), payment.Withdrawal.Amount)
-		require.Equal(t, primitives.BuilderIndex(0), payment.Withdrawal.BuilderIndex)
-	}
-}
-
-func TestRotateBuilderPendingPayments_UnsupportedVersion(t *testing.T) {
-	st := &BeaconState{version: version.Electra}
-	err := st.RotateBuilderPendingPayments()
-	require.ErrorContains(t, "RotateBuilderPendingPayments", err)
-}
-
-func TestAppendBuilderPendingWithdrawal_CopyOnWrite(t *testing.T) {
-	wd := &ethpb.BuilderPendingWithdrawal{
-		FeeRecipient: make([]byte, 20),
-		Amount:       1,
-		BuilderIndex: 2,
-	}
-	statePb, err := InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
-		BuilderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{wd},
-	})
-	require.NoError(t, err)
-
-	st, ok := statePb.(*BeaconState)
-	require.Equal(t, true, ok)
-
-	copied := st.Copy().(*BeaconState)
-	require.Equal(t, uint(2), st.sharedFieldReferences[types.BuilderPendingWithdrawals].Refs())
-
-	appended := &ethpb.BuilderPendingWithdrawal{
-		FeeRecipient: make([]byte, 20),
-		Amount:       4,
-		BuilderIndex: 5,
-	}
-	require.NoError(t, copied.AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal{appended}))
-
-	require.Equal(t, 1, len(st.builderPendingWithdrawals))
-	require.Equal(t, 2, len(copied.builderPendingWithdrawals))
-	require.DeepEqual(t, wd, copied.builderPendingWithdrawals[0])
-	require.DeepEqual(t, appended, copied.builderPendingWithdrawals[1])
-	require.DeepEqual(t, wd, st.builderPendingWithdrawals[0])
-	require.Equal(t, uint(1), st.sharedFieldReferences[types.BuilderPendingWithdrawals].Refs())
-	require.Equal(t, uint(1), copied.sharedFieldReferences[types.BuilderPendingWithdrawals].Refs())
-}
-
-func TestAppendBuilderPendingWithdrawals(t *testing.T) {
-	st := &BeaconState{
-		version:     version.Gloas,
-		dirtyFields: make(map[types.FieldIndex]bool),
-		sharedFieldReferences: map[types.FieldIndex]*stateutil.Reference{
-			types.BuilderPendingWithdrawals: stateutil.NewRef(1),
-		},
-		builderPendingWithdrawals: make([]*ethpb.BuilderPendingWithdrawal, 0),
-	}
-
-	first := &ethpb.BuilderPendingWithdrawal{Amount: 1}
-	second := &ethpb.BuilderPendingWithdrawal{Amount: 2}
-	require.NoError(t, st.AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal{first, second}))
-
-	require.Equal(t, 2, len(st.builderPendingWithdrawals))
-	require.DeepEqual(t, first, st.builderPendingWithdrawals[0])
-	require.DeepEqual(t, second, st.builderPendingWithdrawals[1])
-	require.Equal(t, true, st.dirtyFields[types.BuilderPendingWithdrawals])
-}
-
-func TestAppendBuilderPendingWithdrawals_UnsupportedVersion(t *testing.T) {
-	st := &BeaconState{version: version.Electra}
-	err := st.AppendBuilderPendingWithdrawals([]*ethpb.BuilderPendingWithdrawal{{}})
-	require.ErrorContains(t, "AppendBuilderPendingWithdrawals", err)
-}

beacon-chain/sync/batch_verifier.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/verification"
+	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/crypto/bls"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing"
@@ -53,6 +56,32 @@ func (s *Service) verifierRoutine() {
 	}
 }
 
+// A routine that runs in the background to perform batch
+// KZG verifications by draining the channel and processing all pending requests.
+func (s *Service) kzgVerifierRoutine() {
+	for {
+		kzgBatch := make([]*kzgVerifier, 0, 1)
+		select {
+		case <-s.ctx.Done():
+			return
+		case kzg := <-s.kzgChan:
+			kzgBatch = append(kzgBatch, kzg)
+		}
+		for {
+			select {
+			case <-s.ctx.Done():
+				return
+			case kzg := <-s.kzgChan:
+				kzgBatch = append(kzgBatch, kzg)
+				continue
+			default:
+				verifyKzgBatch(kzgBatch)
+			}
+			break
+		}
+	}
+}
+
 func (s *Service) validateWithBatchVerifier(ctx context.Context, message string, set *bls.SignatureBatch) (pubsub.ValidationResult, error) {
 	_, span := trace.StartSpan(ctx, "sync.validateWithBatchVerifier")
 	defer span.End()
@@ -125,3 +154,71 @@ func performBatchAggregation(aggSet *bls.SignatureBatch) (*bls.SignatureBatch, e
 	}
 	return aggSet, nil
 }
+
+func (s *Service) validateWithKzgBatchVerifier(ctx context.Context, dataColumns []blocks.RODataColumn) (pubsub.ValidationResult, error) {
+	_, span := trace.StartSpan(ctx, "sync.validateWithKzgBatchVerifier")
+	defer span.End()
+
+	timeout := time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second
+
+	resChan := make(chan error, 1)
+	verificationSet := &kzgVerifier{dataColumns: dataColumns, resChan: resChan}
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	select {
+	case s.kzgChan <- verificationSet:
+	case <-ctx.Done():
+		return pubsub.ValidationIgnore, ctx.Err()
+	}
+
+	select {
+	case <-ctx.Done():
+		return pubsub.ValidationIgnore, ctx.Err() // parent context canceled, give up
+	case err := <-resChan:
+		if err != nil {
+			log.WithError(err).Trace("Could not perform batch verification")
+			tracing.AnnotateError(span, err)
+			return s.validateUnbatchedColumnsKzg(ctx, dataColumns)
+		}
+	}
+	return pubsub.ValidationAccept, nil
+}
+
+func (s *Service) validateUnbatchedColumnsKzg(ctx context.Context, columns []blocks.RODataColumn) (pubsub.ValidationResult, error) {
+	_, span := trace.StartSpan(ctx, "sync.validateUnbatchedColumnsKzg")
+	defer span.End()
+	start := time.Now()
+	if err := peerdas.VerifyDataColumnsSidecarKZGProofs(columns); err != nil {
+		err = errors.Wrap(err, "could not verify")
+		tracing.AnnotateError(span, err)
+		return pubsub.ValidationReject, err
+	}
+	verification.DataColumnBatchKZGVerificationHistogram.WithLabelValues("fallback").Observe(float64(time.Since(start).Milliseconds()))
+	return pubsub.ValidationAccept, nil
+}
+
+func verifyKzgBatch(kzgBatch []*kzgVerifier) {
+	if len(kzgBatch) == 0 {
+		return
+	}
+
+	allDataColumns := make([]blocks.RODataColumn, 0, len(kzgBatch))
+	for _, kzgVerifier := range kzgBatch {
+		allDataColumns = append(allDataColumns, kzgVerifier.dataColumns...)
+	}
+
+	var verificationErr error
+	start := time.Now()
+	err := peerdas.VerifyDataColumnsSidecarKZGProofs(allDataColumns)
+	if err != nil {
+		verificationErr = errors.Wrap(err, "batch KZG verification failed")
+	} else {
+		verification.DataColumnBatchKZGVerificationHistogram.WithLabelValues("batch").Observe(float64(time.Since(start).Milliseconds()))
+	}
+
+	// Send the same result to all verifiers in the batch
+	for _, verifier := range kzgBatch {
+		verifier.resChan <- verificationErr
+	}
+}

beacon-chain/sync/kzg_batch_verifier_test.go

@@ -1,14 +1,339 @@
 package sync
 
 import (
+	"context"
+	"sync"
 	"testing"
+	"time"
 
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
+	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 	"github.com/OffchainLabs/prysm/v7/testing/util"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
 )
 
+func TestValidateWithKzgBatchVerifier(t *testing.T) {
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	tests := []struct {
+		name           string
+		dataColumns    []blocks.RODataColumn
+		expectedResult pubsub.ValidationResult
+		expectError    bool
+	}{
+		{
+			name:           "single valid data column",
+			dataColumns:    createValidTestDataColumns(t, 1),
+			expectedResult: pubsub.ValidationAccept,
+			expectError:    false,
+		},
+		{
+			name:           "multiple valid data columns",
+			dataColumns:    createValidTestDataColumns(t, 3),
+			expectedResult: pubsub.ValidationAccept,
+			expectError:    false,
+		},
+		{
+			name:           "single invalid data column",
+			dataColumns:    createInvalidTestDataColumns(t, 1),
+			expectedResult: pubsub.ValidationReject,
+			expectError:    true,
+		},
+		{
+			name:           "empty data column slice",
+			dataColumns:    []blocks.RODataColumn{},
+			expectedResult: pubsub.ValidationAccept,
+			expectError:    false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := t.Context()
+
+			service := &Service{
+				ctx:     ctx,
+				kzgChan: make(chan *kzgVerifier, 100),
+			}
+			go service.kzgVerifierRoutine()
+
+			result, err := service.validateWithKzgBatchVerifier(ctx, tt.dataColumns)
+
+			require.Equal(t, tt.expectedResult, result)
+			if tt.expectError {
+				assert.NotNil(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestVerifierRoutine(t *testing.T) {
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	t.Run("processes single request", func(t *testing.T) {
+		ctx := t.Context()
+
+		service := &Service{
+			ctx:     ctx,
+			kzgChan: make(chan *kzgVerifier, 100),
+		}
+		go service.kzgVerifierRoutine()
+
+		dataColumns := createValidTestDataColumns(t, 1)
+		resChan := make(chan error, 1)
+		service.kzgChan <- &kzgVerifier{dataColumns: dataColumns, resChan: resChan}
+
+		select {
+		case err := <-resChan:
+			require.NoError(t, err)
+		case <-time.After(time.Second):
+			t.Fatal("timeout waiting for verification result")
+		}
+	})
+
+	t.Run("batches multiple requests", func(t *testing.T) {
+		ctx := t.Context()
+
+		service := &Service{
+			ctx:     ctx,
+			kzgChan: make(chan *kzgVerifier, 100),
+		}
+		go service.kzgVerifierRoutine()
+
+		const numRequests = 5
+		resChans := make([]chan error, numRequests)
+
+		for i := range numRequests {
+			dataColumns := createValidTestDataColumns(t, 1)
+			resChan := make(chan error, 1)
+			resChans[i] = resChan
+			service.kzgChan <- &kzgVerifier{dataColumns: dataColumns, resChan: resChan}
+		}
+
+		for i := range numRequests {
+			select {
+			case err := <-resChans[i]:
+				require.NoError(t, err)
+			case <-time.After(time.Second):
+				t.Fatalf("timeout waiting for verification result %d", i)
+			}
+		}
+	})
+
+	t.Run("context cancellation stops routine", func(t *testing.T) {
+		ctx, cancel := context.WithCancel(context.Background())
+
+		service := &Service{
+			ctx:     ctx,
+			kzgChan: make(chan *kzgVerifier, 100),
+		}
+
+		routineDone := make(chan struct{})
+		go func() {
+			service.kzgVerifierRoutine()
+			close(routineDone)
+		}()
+
+		cancel()
+
+		select {
+		case <-routineDone:
+		case <-time.After(time.Second):
+			t.Fatal("timeout waiting for routine to exit")
+		}
+	})
+}
+
+func TestVerifyKzgBatch(t *testing.T) {
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	t.Run("all valid data columns succeed", func(t *testing.T) {
+		dataColumns := createValidTestDataColumns(t, 3)
+		resChan := make(chan error, 1)
+		kzgVerifiers := []*kzgVerifier{{dataColumns: dataColumns, resChan: resChan}}
+
+		verifyKzgBatch(kzgVerifiers)
+
+		select {
+		case err := <-resChan:
+			require.NoError(t, err)
+		case <-time.After(time.Second):
+			t.Fatal("timeout waiting for batch verification")
+		}
+	})
+
+	t.Run("invalid proofs fail entire batch", func(t *testing.T) {
+		validColumns := createValidTestDataColumns(t, 1)
+		invalidColumns := createInvalidTestDataColumns(t, 1)
+		allColumns := append(validColumns, invalidColumns...)
+
+		resChan := make(chan error, 1)
+		kzgVerifiers := []*kzgVerifier{{dataColumns: allColumns, resChan: resChan}}
+
+		verifyKzgBatch(kzgVerifiers)
+
+		select {
+		case err := <-resChan:
+			assert.NotNil(t, err)
+		case <-time.After(time.Second):
+			t.Fatal("timeout waiting for batch verification")
+		}
+	})
+
+	t.Run("empty batch handling", func(t *testing.T) {
+		verifyKzgBatch([]*kzgVerifier{})
+	})
+}
+
+func TestKzgBatchVerifierConcurrency(t *testing.T) {
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	ctx := t.Context()
+
+	service := &Service{
+		ctx:     ctx,
+		kzgChan: make(chan *kzgVerifier, 100),
+	}
+	go service.kzgVerifierRoutine()
+
+	const numGoroutines = 10
+	const numRequestsPerGoroutine = 5
+
+	var wg sync.WaitGroup
+	wg.Add(numGoroutines)
+
+	// Multiple goroutines sending verification requests simultaneously
+	for i := range numGoroutines {
+		go func(goroutineID int) {
+			defer wg.Done()
+
+			for range numRequestsPerGoroutine {
+				dataColumns := createValidTestDataColumns(t, 1)
+				result, err := service.validateWithKzgBatchVerifier(ctx, dataColumns)
+				require.Equal(t, pubsub.ValidationAccept, result)
+				require.NoError(t, err)
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestKzgBatchVerifierFallback(t *testing.T) {
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	t.Run("fallback handles mixed valid/invalid batch correctly", func(t *testing.T) {
+		ctx := t.Context()
+
+		service := &Service{
+			ctx:     ctx,
+			kzgChan: make(chan *kzgVerifier, 100),
+		}
+		go service.kzgVerifierRoutine()
+
+		validColumns := createValidTestDataColumns(t, 1)
+		invalidColumns := createInvalidTestDataColumns(t, 1)
+
+		result, err := service.validateWithKzgBatchVerifier(ctx, validColumns)
+		require.Equal(t, pubsub.ValidationAccept, result)
+		require.NoError(t, err)
+
+		result, err = service.validateWithKzgBatchVerifier(ctx, invalidColumns)
+		require.Equal(t, pubsub.ValidationReject, result)
+		assert.NotNil(t, err)
+	})
+
+	t.Run("empty data columns fallback", func(t *testing.T) {
+		ctx := t.Context()
+
+		service := &Service{
+			ctx:     ctx,
+			kzgChan: make(chan *kzgVerifier, 100),
+		}
+		go service.kzgVerifierRoutine()
+
+		result, err := service.validateWithKzgBatchVerifier(ctx, []blocks.RODataColumn{})
+		require.Equal(t, pubsub.ValidationAccept, result)
+		require.NoError(t, err)
+	})
+}
+
+func TestValidateWithKzgBatchVerifier_DeadlockOnTimeout(t *testing.T) {
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.SecondsPerSlot = 0
+	params.OverrideBeaconConfig(cfg)
+
+	ctx, cancel := context.WithCancel(t.Context())
+	defer cancel()
+
+	service := &Service{
+		ctx:     ctx,
+		kzgChan: make(chan *kzgVerifier),
+	}
+	go service.kzgVerifierRoutine()
+
+	result, err := service.validateWithKzgBatchVerifier(context.Background(), nil)
+	require.Equal(t, pubsub.ValidationIgnore, result)
+	require.ErrorIs(t, err, context.DeadlineExceeded)
+
+	done := make(chan struct{})
+	go func() {
+		_, _ = service.validateWithKzgBatchVerifier(context.Background(), nil)
+		close(done)
+	}()
+
+	select {
+	case <-done:
+	case <-time.After(500 * time.Millisecond):
+		t.Fatal("validateWithKzgBatchVerifier blocked")
+	}
+}
+
+func TestValidateWithKzgBatchVerifier_ContextCanceledBeforeSend(t *testing.T) {
+	cancelledCtx, cancel := context.WithCancel(t.Context())
+	cancel()
+
+	service := &Service{
+		ctx:     context.Background(),
+		kzgChan: make(chan *kzgVerifier),
+	}
+
+	done := make(chan struct{})
+	go func() {
+		result, err := service.validateWithKzgBatchVerifier(cancelledCtx, nil)
+		require.Equal(t, pubsub.ValidationIgnore, result)
+		require.ErrorIs(t, err, context.Canceled)
+		close(done)
+	}()
+
+	select {
+	case <-done:
+	case <-time.After(500 * time.Millisecond):
+		t.Fatal("validateWithKzgBatchVerifier did not return after context cancellation")
+	}
+
+	select {
+	case <-service.kzgChan:
+		t.Fatal("verificationSet was sent to kzgChan despite canceled context")
+	default:
+	}
+}
+
 func createValidTestDataColumns(t *testing.T, count int) []blocks.RODataColumn {
 	_, roSidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, count)
 	if len(roSidecars) >= count {

beacon-chain/sync/service.go

@@ -168,6 +168,7 @@ type Service struct {
 	syncContributionBitsOverlapLock  sync.RWMutex
 	syncContributionBitsOverlapCache *lru.Cache
 	signatureChan                    chan *signatureVerifier
+	kzgChan                          chan *kzgVerifier
 	clockWaiter                      startup.ClockWaiter
 	initialSyncComplete              chan struct{}
 	verifierWaiter                   *verification.InitializerWaiter
@@ -208,7 +209,10 @@ func NewService(ctx context.Context, opts ...Option) *Service {
 	}
 	// Initialize signature channel with configured limit
 	r.signatureChan = make(chan *signatureVerifier, r.cfg.batchVerifierLimit)
-
+	// Initialize KZG channel with fixed buffer size of 100.
+	// This buffer size is designed to handle burst traffic of data column gossip messages:
+	// - Data columns arrive less frequently than attestations (default batchVerifierLimit=1000)
+	r.kzgChan = make(chan *kzgVerifier, 100)
 	// Correctly remove it from our seen pending block map.
 	// The eviction method always assumes that the mutex is held.
 	r.slotToPendingBlocks.OnEvicted(func(s string, i any) {
@@ -261,6 +265,7 @@ func (s *Service) Start() {
 	s.newColumnsVerifier = newDataColumnsVerifierFromInitializer(v)
 
 	go s.verifierRoutine()
+	go s.kzgVerifierRoutine()
 	go s.startDiscoveryAndSubscriptions()
 	go s.processDataColumnLogs()
 

beacon-chain/sync/validate_data_column.go

@@ -144,9 +144,12 @@ func (s *Service) validateDataColumn(ctx context.Context, pid peer.ID, msg *pubs
 	}
 
 	// [REJECT] The sidecar's column data is valid as verified by `verify_data_column_sidecar_kzg_proofs(sidecar)`.
-	if err := verifier.SidecarKzgProofVerified(); err != nil {
-		return pubsub.ValidationReject, err
+	validationResult, err := s.validateWithKzgBatchVerifier(ctx, roDataColumns)
+	if validationResult != pubsub.ValidationAccept {
+		return validationResult, err
 	}
+	// Mark KZG verification as satisfied since we did it via batch verifier
+	verifier.SatisfyRequirement(verification.RequireSidecarKzgProofVerified)
 
 	// [IGNORE] The sidecar is the first sidecar for the tuple `(block_header.slot, block_header.proposer_index, sidecar.index)`
 	// with valid header signature, sidecar inclusion proof, and kzg proof.

beacon-chain/sync/validate_data_column_test.go

@@ -71,7 +71,10 @@ func TestValidateDataColumn(t *testing.T) {
 			ctx:                 ctx,
 			newColumnsVerifier:  newDataColumnsVerifier,
 			seenDataColumnCache: newSlotAwareCache(seenDataColumnSize),
+			kzgChan:             make(chan *kzgVerifier, 100),
 		}
+		// Start the KZG verifier routine for batch verification
+		go service.kzgVerifierRoutine()
 
 		// Encode a `beaconBlock` message instead of expected.
 		buf := new(bytes.Buffer)

changelog/eth2353_fix-aggregate-typo.md

@@ -1,2 +0,0 @@
-### Fixed
-- Fixed a typo: AggregrateDueBPS -> AggregateDueBPS.

changelog/fix-validator-web-auth-bypass.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Prevent authentication bypass on direct `/v2/validator/*` endpoints by enforcing auth checks for non-public routes.

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_longer-e2e-sync-evaluator.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- adding a optimistic check for e2e evlauator on synced head, it may be slower post fulu to sync. 

changelog/manu-kzg-batch.md

@@ -1,3 +0,0 @@
-### Removed
-
-- Batching of KZG verification for incoming via gossip data column sidecars

changelog/t_process-builder-pending-payments.md

@@ -1,2 +0,0 @@
-### Added
-- add pending payments processing and quorum threshold, plus spectests and state hooks (rotate/append)

config/params/config.go

@@ -88,7 +88,7 @@ type BeaconChainConfig struct {
 	IntervalsPerSlot                uint64           `yaml:"INTERVALS_PER_SLOT"`                              // IntervalsPerSlot defines the number of fork choice intervals in a slot defined in the fork choice spec.
 	ProposerReorgCutoffBPS          primitives.BP    `yaml:"PROPOSER_REORG_CUTOFF_BPS" spec:"true"`           // ProposerReorgCutoffBPS defines the proposer reorg deadline in basis points of the slot.
 	AttestationDueBPS               primitives.BP    `yaml:"ATTESTATION_DUE_BPS" spec:"true"`                 // AttestationDueBPS defines the attestation due time in basis points of the slot.
-	AggregateDueBPS                 primitives.BP    `yaml:"AGGREGATE_DUE_BPS" spec:"true"`                   // AggregateDueBPS defines the aggregate due time in basis points of the slot.
+	AggregrateDueBPS                primitives.BP    `yaml:"AGGREGRATE_DUE_BPS" spec:"true"`                  // AggregrateDueBPS defines the aggregate due time in basis points of the slot.
 	SyncMessageDueBPS               primitives.BP    `yaml:"SYNC_MESSAGE_DUE_BPS" spec:"true"`                // SyncMessageDueBPS defines the sync message due time in basis points of the slot.
 	ContributionDueBPS              primitives.BP    `yaml:"CONTRIBUTION_DUE_BPS" spec:"true"`                // ContributionDueBPS defines the contribution due time in basis points of the slot.
 
@@ -293,10 +293,6 @@ type BeaconChainConfig struct {
 	ValidatorCustodyRequirement           uint64           `yaml:"VALIDATOR_CUSTODY_REQUIREMENT" spec:"true"`                // ValidatorCustodyRequirement is the minimum number of custody groups an honest node with validators attached custodies and serves samples from
 	BalancePerAdditionalCustodyGroup      uint64           `yaml:"BALANCE_PER_ADDITIONAL_CUSTODY_GROUP" spec:"true"`         // BalancePerAdditionalCustodyGroup is the balance increment corresponding to one additional group to custody.
 
-	// Values introduced in Gloas upgrade
-	BuilderPaymentThresholdNumerator   uint64 `yaml:"BUILDER_PAYMENT_THRESHOLD_NUMERATOR" spec:"true"`   // BuilderPaymentThresholdNumerator is the numerator for builder payment quorum threshold calculation.
-	BuilderPaymentThresholdDenominator uint64 `yaml:"BUILDER_PAYMENT_THRESHOLD_DENOMINATOR" spec:"true"` // BuilderPaymentThresholdDenominator is the denominator for builder payment quorum threshold calculation.
-
 	// Networking Specific Parameters
 	MaxPayloadSize                  uint64          `yaml:"MAX_PAYLOAD_SIZE" spec:"true"`                   // MAX_PAYLOAD_SIZE is the maximum allowed size of uncompressed payload in gossip messages and rpc chunks.
 	AttestationSubnetCount          uint64          `yaml:"ATTESTATION_SUBNET_COUNT" spec:"true"`           // AttestationSubnetCount is the number of attestation subnets used in the gossipsub protocol.

config/params/loader.go

@@ -243,7 +243,7 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("MAX_BLOBS_PER_BLOCK: %d", cfg.DeprecatedMaxBlobsPerBlock),
 		fmt.Sprintf("PROPOSER_REORG_CUTOFF_BPS: %d", cfg.ProposerReorgCutoffBPS),
 		fmt.Sprintf("ATTESTATION_DUE_BPS: %d", cfg.AttestationDueBPS),
-		fmt.Sprintf("AGGREGATE_DUE_BPS: %d", cfg.AggregateDueBPS),
+		fmt.Sprintf("AGGREGRATE_DUE_BPS: %d", cfg.AggregrateDueBPS),
 		fmt.Sprintf("SYNC_MESSAGE_DUE_BPS: %d", cfg.SyncMessageDueBPS),
 		fmt.Sprintf("CONTRIBUTION_DUE_BPS: %d", cfg.ContributionDueBPS),
 	}

config/params/loader_test.go

@@ -24,6 +24,7 @@ import (
 // These are variables that we don't use in Prysm. (i.e. future hardfork, light client... etc)
 // IMPORTANT: Use one field per line and sort these alphabetically to reduce conflicts.
 var placeholderFields = []string{
+	"AGGREGATE_DUE_BPS",
 	"AGGREGATE_DUE_BPS_GLOAS",
 	"ATTESTATION_DEADLINE",
 	"ATTESTATION_DUE_BPS_GLOAS",
@@ -98,7 +99,7 @@ func assertEqualConfigs(t *testing.T, name string, fields []string, expected, ac
 	assert.Equal(t, expected.HysteresisDownwardMultiplier, actual.HysteresisDownwardMultiplier, "%s: HysteresisDownwardMultiplier", name)
 	assert.Equal(t, expected.HysteresisUpwardMultiplier, actual.HysteresisUpwardMultiplier, "%s: HysteresisUpwardMultiplier", name)
 	assert.Equal(t, expected.AttestationDueBPS, actual.AttestationDueBPS, "%s: AttestationDueBPS", name)
-	assert.Equal(t, expected.AggregateDueBPS, actual.AggregateDueBPS, "%s: AggregateDueBPS", name)
+	assert.Equal(t, expected.AggregrateDueBPS, actual.AggregrateDueBPS, "%s: AggregrateDueBPS", name)
 	assert.Equal(t, expected.ContributionDueBPS, actual.ContributionDueBPS, "%s: ContributionDueBPS", name)
 	assert.Equal(t, expected.ProposerReorgCutoffBPS, actual.ProposerReorgCutoffBPS, "%s: ProposerReorgCutoffBPS", name)
 	assert.Equal(t, expected.SyncMessageDueBPS, actual.SyncMessageDueBPS, "%s: SyncMessageDueBPS", name)

config/params/mainnet_config.go

@@ -123,7 +123,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	// Time-based protocol parameters.
 	ProposerReorgCutoffBPS: primitives.BP(1667),
 	AttestationDueBPS:      primitives.BP(3333),
-	AggregateDueBPS:        primitives.BP(6667),
+	AggregrateDueBPS:       primitives.BP(6667),
 	SyncMessageDueBPS:      primitives.BP(3333),
 	ContributionDueBPS:     primitives.BP(6667),
 
@@ -331,11 +331,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	MinEpochsForDataColumnSidecarsRequest: 4096,
 	ValidatorCustodyRequirement:           8,
 	BalancePerAdditionalCustodyGroup:      32_000_000_000,
-
-	// Values related to gloas
-	BuilderPaymentThresholdNumerator:   6,
-	BuilderPaymentThresholdDenominator: 10,
-
 	// Values related to networking parameters.
 	MaxPayloadSize:                  10 * 1 << 20, // 10 MiB
 	AttestationSubnetCount:          64,

testing/endtoend/endtoend_test.go

@@ -289,45 +289,10 @@ func (r *testRunner) waitForMatchingHead(ctx context.Context, timeout time.Durat
 				return errors.Wrap(err, "unexpected error requesting head block root from 'ref' beacon node")
 			}
 			if bytesutil.ToBytes32(cResp.HeadBlockRoot) == bytesutil.ToBytes32(rResp.HeadBlockRoot) {
-				// Head matches, now wait for node to exit optimistic mode.
-				// For Fulu, the execution client may take additional time to sync and verify payloads.
-				// Give extra time (up to 2 minutes) for optimistic status to clear.
-				return r.waitForNonOptimistic(ctx, 2*time.Minute, check)
-			}
-		}
-	}
-}
-
-// waitForNonOptimistic waits for a node to exit optimistic mode, with a bounded timeout.
-// If the timeout is reached, it logs a warning but does not fail - the evaluator will
-// handle optimistic nodes gracefully by skipping finalized/justified checks.
-func (r *testRunner) waitForNonOptimistic(ctx context.Context, timeout time.Duration, conn *grpc.ClientConn) error {
-	start := time.Now()
-	deadline := start.Add(timeout)
-	checkClient := eth.NewBeaconChainClient(conn)
-
-	for time.Now().Before(deadline) {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		default:
-			cResp, err := checkClient.GetChainHead(ctx, &emptypb.Empty{})
-			if err != nil {
-				// If we can't get chain head, just continue - head already matched
-				time.Sleep(100 * time.Millisecond)
-				continue
-			}
-			if !cResp.OptimisticStatus {
-				log.Infof("Node exited optimistic mode after %s", time.Since(start))
 				return nil
 			}
-			time.Sleep(100 * time.Millisecond)
 		}
 	}
-
-	// Timeout reached but node is still optimistic - this is OK, evaluator handles it
-	log.Warnf("Node still in optimistic mode after %s, continuing anyway (evaluator will handle)", timeout)
-	return nil
 }
 
 func (r *testRunner) testCheckpointSync(ctx context.Context, g *errgroup.Group, i int, conns []*grpc.ClientConn, bnAPI, enr, minerEnr string) error {

testing/endtoend/evaluators/node.go

@@ -129,12 +129,11 @@ func finishedSyncing(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) e
 }
 
 func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) error {
-	headSlots := make([]primitives.Slot, len(conns))
+	headEpochs := make([]primitives.Epoch, len(conns))
 	justifiedRoots := make([][]byte, len(conns))
 	prevJustifiedRoots := make([][]byte, len(conns))
 	finalizedRoots := make([][]byte, len(conns))
 	chainHeads := make([]*eth.ChainHead, len(conns))
-	optimisticStatus := make([]bool, len(conns))
 	g, _ := errgroup.WithContext(context.Background())
 
 	for i, conn := range conns {
@@ -146,12 +145,11 @@ func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientCo
 			if err != nil {
 				return errors.Wrapf(err, "connection number=%d", conIdx)
 			}
-			headSlots[conIdx] = chainHead.HeadSlot
+			headEpochs[conIdx] = chainHead.HeadEpoch
 			justifiedRoots[conIdx] = chainHead.JustifiedBlockRoot
 			prevJustifiedRoots[conIdx] = chainHead.PreviousJustifiedBlockRoot
 			finalizedRoots[conIdx] = chainHead.FinalizedBlockRoot
 			chainHeads[conIdx] = chainHead
-			optimisticStatus[conIdx] = chainHead.OptimisticStatus
 			return nil
 		})
 	}
@@ -160,26 +158,14 @@ func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientCo
 	}
 
 	for i := range conns {
-		// Allow head slots to differ by at most 2 slots to account for timing
-		// differences when querying nodes and chain advancement during evaluation.
-		slotDiff := headSlots[0] - headSlots[i]
-		if headSlots[i] > headSlots[0] {
-			slotDiff = headSlots[i] - headSlots[0]
-		}
-		if slotDiff > 2 {
+		if headEpochs[0] != headEpochs[i] {
 			return fmt.Errorf(
-				"received conflicting head slots on node %d, expected %d (±2), received %d",
+				"received conflicting head epochs on node %d, expected %d, received %d",
 				i,
-				headSlots[0],
-				headSlots[i],
+				headEpochs[0],
+				headEpochs[i],
 			)
 		}
-		// Skip finalized/justified checks for nodes in optimistic mode.
-		// Optimistic nodes haven't verified execution payloads yet, so their
-		// finalized/justified state may lag behind fully verified nodes.
-		if optimisticStatus[i] {
-			continue
-		}
 		if !bytes.Equal(justifiedRoots[0], justifiedRoots[i]) {
 			return fmt.Errorf(
 				"received conflicting justified block roots on node %d, expected %#x, received %#x: %s and %s",

testing/spectest/mainnet/BUILD.bazel

@@ -200,7 +200,6 @@ go_test(
         "fulu__sanity__blocks_test.go",
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
-        "gloas__epoch_processing__process_builder_pending_payments_test.go",
         "gloas__operations__execution_payload_header_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
@@ -280,7 +279,6 @@ go_test(
         "//testing/spectest/shared/fulu/rewards:go_default_library",
         "//testing/spectest/shared/fulu/sanity:go_default_library",
         "//testing/spectest/shared/fulu/ssz_static:go_default_library",
-        "//testing/spectest/shared/gloas/epoch_processing:go_default_library",
         "//testing/spectest/shared/gloas/operations:go_default_library",
         "//testing/spectest/shared/gloas/ssz_static:go_default_library",
         "//testing/spectest/shared/phase0/epoch_processing:go_default_library",

testing/spectest/mainnet/gloas__epoch_processing__process_builder_pending_payments_test.go

@@ -1,11 +0,0 @@
-package mainnet
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/epoch_processing"
-)
-
-func TestMainnet_Gloas_EpochProcessing_ProcessBuilderPendingPayments(t *testing.T) {
-	epoch_processing.RunBuilderPendingPaymentsTests(t, "mainnet")
-}

testing/spectest/minimal/BUILD.bazel

@@ -206,7 +206,6 @@ go_test(
         "fulu__sanity__blocks_test.go",
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
-        "gloas__epoch_processing__process_builder_pending_payments_test.go",
         "gloas__operations__execution_payload_bid_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
@@ -290,7 +289,6 @@ go_test(
         "//testing/spectest/shared/fulu/rewards:go_default_library",
         "//testing/spectest/shared/fulu/sanity:go_default_library",
         "//testing/spectest/shared/fulu/ssz_static:go_default_library",
-        "//testing/spectest/shared/gloas/epoch_processing:go_default_library",
         "//testing/spectest/shared/gloas/operations:go_default_library",
         "//testing/spectest/shared/gloas/ssz_static:go_default_library",
         "//testing/spectest/shared/phase0/epoch_processing:go_default_library",

testing/spectest/minimal/gloas__epoch_processing__process_builder_pending_payments_test.go

@@ -1,11 +0,0 @@
-package minimal
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/epoch_processing"
-)
-
-func TestMinimal_Gloas_EpochProcessing_ProcessBuilderPendingPayments(t *testing.T) {
-	epoch_processing.RunBuilderPendingPaymentsTests(t, "minimal")
-}

testing/spectest/shared/gloas/epoch_processing/BUILD.bazel

@@ -1,26 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    testonly = True,
-    srcs = [
-        "builder_pending_payments.go",
-        "helpers.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/epoch_processing",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/gloas:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/spectest/utils:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_golang_snappy//:go_default_library",
-        "@com_github_google_go_cmp//cmp:go_default_library",
-        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
-    ],
-)

testing/spectest/shared/gloas/epoch_processing/builder_pending_payments.go

@@ -1,26 +0,0 @@
-package epoch_processing
-
-import (
-	"path"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/utils"
-)
-
-func RunBuilderPendingPaymentsTests(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "gloas", "epoch_processing/builder_pending_payments/pyspec_tests")
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			folderPath := path.Join(testsFolderPath, folder.Name())
-			RunEpochOperationTest(t, folderPath, processBuilderPendingPayments)
-		})
-	}
-}
-
-func processBuilderPendingPayments(t *testing.T, st state.BeaconState) (state.BeaconState, error) {
-	return st, gloas.ProcessBuilderPendingPayments(st)
-}

testing/spectest/shared/gloas/epoch_processing/helpers.go

@@ -1,76 +0,0 @@
-package epoch_processing
-
-import (
-	"os"
-	"path"
-	"strings"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
-)
-
-type epochOperation func(*testing.T, state.BeaconState) (state.BeaconState, error)
-
-// RunEpochOperationTest takes in the prestate and processes it through the
-// passed in epoch operation function and checks the post state with the expected post state.
-func RunEpochOperationTest(
-	t *testing.T,
-	testFolderPath string,
-	operationFn epochOperation,
-) {
-	preBeaconStateFile, err := util.BazelFileBytes(path.Join(testFolderPath, "pre.ssz_snappy"))
-	require.NoError(t, err)
-	preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-	require.NoError(t, err, "Failed to decompress")
-	preBeaconStateBase := &ethpb.BeaconStateGloas{}
-	if err := preBeaconStateBase.UnmarshalSSZ(preBeaconStateSSZ); err != nil {
-		t.Fatalf("Failed to unmarshal: %v", err)
-	}
-	preBeaconState, err := state_native.InitializeFromProtoGloas(preBeaconStateBase)
-	require.NoError(t, err)
-
-	// If the post.ssz is not present, it means the test should fail on our end.
-	postSSZFilepath, err := bazel.Runfile(path.Join(testFolderPath, "post.ssz_snappy"))
-	postSSZExists := true
-	if err != nil && strings.Contains(err.Error(), "could not locate file") {
-		postSSZExists = false
-	} else if err != nil {
-		t.Fatal(err)
-	}
-
-	beaconState, err := operationFn(t, preBeaconState)
-	if postSSZExists {
-		require.NoError(t, err)
-
-		postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-		require.NoError(t, err)
-		postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-		require.NoError(t, err, "Failed to decompress")
-		postBeaconState := &ethpb.BeaconStateGloas{}
-		if err := postBeaconState.UnmarshalSSZ(postBeaconStateSSZ); err != nil {
-			t.Fatalf("Failed to unmarshal: %v", err)
-		}
-
-		pbState, err := state_native.ProtobufBeaconStateGloas(beaconState.ToProtoUnsafe())
-		require.NoError(t, err)
-		if !proto.Equal(pbState, postBeaconState) {
-			t.Log(cmp.Diff(postBeaconState, pbState, protocmp.Transform()))
-			t.Fatal("Post state does not match expected")
-		}
-	} else {
-		if err == nil {
-			t.Fatal("Did not fail when expected")
-		}
-		t.Logf("Expected failure; failure reason = %v", err)
-		return
-	}
-}

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,8 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//api/grpc:go_default_library",
+        "//api/rest:go_default_library",
         "//api/server/structs:go_default_library",
         "//async/event:go_default_library",
         "//beacon-chain/core/signing:go_default_library",

validator/client/aggregate.go

@@ -207,7 +207,7 @@ func (v *validator) signSlotWithSelectionProof(ctx context.Context, pubKey [fiel
 // such that any attestations from this slot have time to reach the beacon node
 // before creating the aggregated attestation.
 func (v *validator) waitToSlotTwoThirds(ctx context.Context, slot primitives.Slot) {
-	v.waitUntilSlotComponent(ctx, slot, params.BeaconConfig().AggregateDueBPS)
+	v.waitUntilSlotComponent(ctx, slot, params.BeaconConfig().AggregrateDueBPS)
 }
 
 // This returns the signature of validator signing over aggregate and

validator/client/aggregate_test.go

@@ -257,7 +257,7 @@ func TestWaitForSlotTwoThird_WaitCorrectly(t *testing.T) {
 			numOfSlots := primitives.Slot(4)
 			slotDuration := params.BeaconConfig().SlotDuration()
 			validator.genesisTime = currentTime.Add(-slotDuration * time.Duration(numOfSlots))
-			timeToSleep := params.BeaconConfig().SlotComponentDuration(params.BeaconConfig().AggregateDueBPS)
+			timeToSleep := params.BeaconConfig().SlotComponentDuration(params.BeaconConfig().AggregrateDueBPS)
 
 			twoThirdTime := currentTime.Add(timeToSleep)
 			validator.waitToSlotTwoThirds(t.Context(), numOfSlots)

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,7 @@ go_library(
         "//api:go_default_library",
         "//api/apiutil:go_default_library",
         "//api/client/event: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 +111,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/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,7 +18,7 @@ import (
 
 type beaconApiChainClient struct {
 	fallbackClient          iface.ChainClient
-	jsonRestHandler         RestHandler
+	jsonRestHandler         rest.RestHandler
 	stateValidatorsProvider StateValidatorsProvider
 }
 
@@ -327,7 +328,7 @@ 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(jsonRestHandler rest.RestHandler, fallbackClient iface.ChainClient) iface.ChainClient {
 	return &beaconApiChainClient{
 		jsonRestHandler:         jsonRestHandler,
 		fallbackClient:          fallbackClient,

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,7 +21,7 @@ var (
 
 type beaconApiNodeClient struct {
 	fallbackClient  iface.NodeClient
-	jsonRestHandler RestHandler
+	jsonRestHandler rest.RestHandler
 	genesisProvider GenesisProvider
 }
 
@@ -115,7 +116,7 @@ func (c *beaconApiNodeClient) IsReady(ctx context.Context) bool {
 	return statusCode == http.StatusOK
 }
 
-func NewNodeClientWithFallback(jsonRestHandler RestHandler, fallbackClient iface.NodeClient) iface.NodeClient {
+func NewNodeClientWithFallback(jsonRestHandler rest.RestHandler, fallbackClient iface.NodeClient) iface.NodeClient {
 	b := &beaconApiNodeClient{
 		jsonRestHandler: jsonRestHandler,
 		fallbackClient:  fallbackClient,

validator/client/beacon-api/beacon_api_validator_client.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/api/client/event"
+	"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,13 +23,13 @@ type beaconApiValidatorClient struct {
 	genesisProvider         GenesisProvider
 	dutiesProvider          dutiesProvider
 	stateValidatorsProvider StateValidatorsProvider
-	jsonRestHandler         RestHandler
+	jsonRestHandler         rest.RestHandler
 	beaconBlockConverter    BeaconBlockConverter
 	prysmChainClient        iface.PrysmChainClient
 	isEventStreamRunning    bool
 }
 
-func NewBeaconApiValidatorClient(jsonRestHandler RestHandler, opts ...ValidatorClientOpt) iface.ValidatorClient {
+func NewBeaconApiValidatorClient(jsonRestHandler rest.RestHandler, opts ...ValidatorClientOpt) iface.ValidatorClient {
 	c := &beaconApiValidatorClient{
 		genesisProvider:         &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler},
 		dutiesProvider:          beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler},

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
+	jsonRestHandler rest.RestHandler
 }
 
 type attesterDuty struct {

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,7 +21,7 @@ type GenesisProvider interface {
 }
 
 type beaconApiGenesisProvider struct {
-	jsonRestHandler RestHandler
+	jsonRestHandler rest.RestHandler
 	genesis         *structs.Genesis
 	once            sync.Once
 }

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,7 +19,7 @@ import (
 )
 
 // NewPrysmChainClient returns implementation of iface.PrysmChainClient.
-func NewPrysmChainClient(jsonRestHandler RestHandler, nodeClient iface.NodeClient) iface.PrysmChainClient {
+func NewPrysmChainClient(jsonRestHandler rest.RestHandler, nodeClient iface.NodeClient) iface.PrysmChainClient {
 	return prysmChainClient{
 		jsonRestHandler: jsonRestHandler,
 		nodeClient:      nodeClient,
@@ -26,7 +27,7 @@ func NewPrysmChainClient(jsonRestHandler RestHandler, nodeClient iface.NodeClien
 }
 
 type prysmChainClient struct {
-	jsonRestHandler RestHandler
+	jsonRestHandler rest.RestHandler
 	nodeClient      iface.NodeClient
 }
 

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,10 +44,7 @@ func TestGet(t *testing.T) {
 	server := httptest.NewServer(mux)
 	defer server.Close()
 
-	jsonRestHandler := BeaconApiRestHandler{
-		client: http.Client{Timeout: time.Second * 5},
-		host:   server.URL,
-	}
+	jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 	resp := &structs.GetGenesisResponse{}
 	require.NoError(t, jsonRestHandler.Get(ctx, endpoint+"?arg1=abc&arg2=def", resp))
 	assert.DeepEqual(t, genesisJson, resp)
@@ -79,10 +75,7 @@ func TestGetSSZ(t *testing.T) {
 		server := httptest.NewServer(mux)
 		defer server.Close()
 
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Second * 5},
-			host:   server.URL,
-		}
+		jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
 		body, header, err := jsonRestHandler.GetSSZ(ctx, endpoint)
 		require.NoError(t, err)
@@ -108,10 +101,7 @@ func TestGetSSZ(t *testing.T) {
 		server := httptest.NewServer(mux)
 		defer server.Close()
 
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Second * 5},
-			host:   server.URL,
-		}
+		jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
 		body, header, err := jsonRestHandler.GetSSZ(ctx, endpoint)
 		require.NoError(t, err)
@@ -136,10 +126,7 @@ func TestGetSSZ(t *testing.T) {
 		server := httptest.NewServer(mux)
 		defer server.Close()
 
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Second * 5},
-			host:   server.URL,
-		}
+		jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
 		_, _, err := jsonRestHandler.GetSSZ(ctx, endpoint)
 		require.NoError(t, err)
@@ -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.NewRestHandler(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,
-	}
+	jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 	resp := &structs.GetGenesisResponse{}
 	require.NoError(t, jsonRestHandler.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,10 +238,7 @@ func TestGetStatusCode(t *testing.T) {
 			server := httptest.NewServer(mux)
 			defer server.Close()
 
-			jsonRestHandler := BeaconApiRestHandler{
-				client: http.Client{Timeout: time.Second * 5},
-				host:   server.URL,
-			}
+			jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Second * 5}, server.URL)
 
 			statusCode, err := jsonRestHandler.GetStatusCode(ctx, endpoint)
 			require.NoError(t, err)
@@ -413,10 +247,7 @@ func TestGetStatusCode(t *testing.T) {
 	}
 
 	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
-		}
+		jsonRestHandler := rest.NewRestHandler(http.Client{Timeout: time.Millisecond * 100}, "http://localhost:99999")
 
 		_, err := jsonRestHandler.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
+	jsonRestHandler rest.RestHandler
 }
 
 func (c beaconApiStateValidatorsProvider) StateValidators(

validator/client/beacon-chain-client-factory/beacon_chain_client_factory.go

@@ -9,19 +9,17 @@ import (
 	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 )
 
-func NewChainClient(validatorConn validatorHelpers.NodeConnection, jsonRestHandler beaconApi.RestHandler) iface.ChainClient {
-	grpcClient := grpcApi.NewGrpcChainClient(validatorConn.GetGrpcClientConn())
+func NewChainClient(validatorConn validatorHelpers.NodeConnection) iface.ChainClient {
+	grpcClient := grpcApi.NewGrpcChainClient(validatorConn)
 	if features.Get().EnableBeaconRESTApi {
-		return beaconApi.NewBeaconApiChainClientWithFallback(jsonRestHandler, grpcClient)
-	} else {
-		return grpcClient
+		return beaconApi.NewBeaconApiChainClientWithFallback(validatorConn.GetRestHandler(), grpcClient)
 	}
+	return grpcClient
 }
 
-func NewPrysmChainClient(validatorConn validatorHelpers.NodeConnection, jsonRestHandler beaconApi.RestHandler) iface.PrysmChainClient {
+func NewPrysmChainClient(validatorConn validatorHelpers.NodeConnection) iface.PrysmChainClient {
 	if features.Get().EnableBeaconRESTApi {
-		return beaconApi.NewPrysmChainClient(jsonRestHandler, nodeClientFactory.NewNodeClient(validatorConn, jsonRestHandler))
-	} else {
-		return grpcApi.NewGrpcPrysmChainClient(validatorConn.GetGrpcClientConn())
+		return beaconApi.NewPrysmChainClient(validatorConn.GetRestHandler(), nodeClientFactory.NewNodeClient(validatorConn))
 	}
+	return grpcApi.NewGrpcPrysmChainClient(validatorConn)
 }

validator/client/grpc-api/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "grpc_beacon_chain_client.go",
+        "grpc_client_manager.go",
         "grpc_node_client.go",
         "grpc_prysm_beacon_chain_client.go",
         "grpc_validator_client.go",
@@ -25,6 +26,7 @@ go_library(
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//validator/client/iface:go_default_library",
+        "//validator/helpers:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_golang_protobuf//ptypes/empty",
         "@com_github_pkg_errors//:go_default_library",
@@ -39,6 +41,7 @@ go_test(
     name = "go_default_test",
     size = "small",
     srcs = [
+        "grpc_client_manager_test.go",
         "grpc_prysm_beacon_chain_client_test.go",
         "grpc_validator_client_test.go",
     ],
@@ -56,7 +59,9 @@ go_test(
         "//testing/util:go_default_library",
         "//testing/validator-mock:go_default_library",
         "//validator/client/iface:go_default_library",
+        "//validator/helpers:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_uber_go_mock//gomock:go_default_library",
     ],

validator/client/grpc-api/grpc_beacon_chain_client.go

@@ -5,38 +5,42 @@ import (
 
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/validator/client/iface"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	"github.com/golang/protobuf/ptypes/empty"
-	"google.golang.org/grpc"
 )
 
 type grpcChainClient struct {
-	beaconChainClient ethpb.BeaconChainClient
+	*grpcClientManager[ethpb.BeaconChainClient]
 }
 
 func (c *grpcChainClient) ChainHead(ctx context.Context, in *empty.Empty) (*ethpb.ChainHead, error) {
-	return c.beaconChainClient.GetChainHead(ctx, in)
+	return c.getClient().GetChainHead(ctx, in)
 }
 
 func (c *grpcChainClient) ValidatorBalances(ctx context.Context, in *ethpb.ListValidatorBalancesRequest) (*ethpb.ValidatorBalances, error) {
-	return c.beaconChainClient.ListValidatorBalances(ctx, in)
+	return c.getClient().ListValidatorBalances(ctx, in)
 }
 
 func (c *grpcChainClient) Validators(ctx context.Context, in *ethpb.ListValidatorsRequest) (*ethpb.Validators, error) {
-	return c.beaconChainClient.ListValidators(ctx, in)
+	return c.getClient().ListValidators(ctx, in)
 }
 
 func (c *grpcChainClient) ValidatorQueue(ctx context.Context, in *empty.Empty) (*ethpb.ValidatorQueue, error) {
-	return c.beaconChainClient.GetValidatorQueue(ctx, in)
+	return c.getClient().GetValidatorQueue(ctx, in)
 }
 
 func (c *grpcChainClient) ValidatorPerformance(ctx context.Context, in *ethpb.ValidatorPerformanceRequest) (*ethpb.ValidatorPerformanceResponse, error) {
-	return c.beaconChainClient.GetValidatorPerformance(ctx, in)
+	return c.getClient().GetValidatorPerformance(ctx, in)
 }
 
 func (c *grpcChainClient) ValidatorParticipation(ctx context.Context, in *ethpb.GetValidatorParticipationRequest) (*ethpb.ValidatorParticipationResponse, error) {
-	return c.beaconChainClient.GetValidatorParticipation(ctx, in)
+	return c.getClient().GetValidatorParticipation(ctx, in)
 }
 
-func NewGrpcChainClient(cc grpc.ClientConnInterface) iface.ChainClient {
-	return &grpcChainClient{ethpb.NewBeaconChainClient(cc)}
+// NewGrpcChainClient creates a new gRPC chain client that supports
+// dynamic connection switching via the NodeConnection's GrpcConnectionProvider.
+func NewGrpcChainClient(conn validatorHelpers.NodeConnection) iface.ChainClient {
+	return &grpcChainClient{
+		grpcClientManager: newGrpcClientManager(conn, ethpb.NewBeaconChainClient),
+	}
 }

validator/client/grpc-api/grpc_client_manager.go

@@ -0,0 +1,58 @@
+package grpc_api
+
+import (
+	"sync"
+
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
+	"google.golang.org/grpc"
+)
+
+// grpcClientManager handles dynamic gRPC client recreation when the connection changes.
+// It uses generics to work with any gRPC client type.
+type grpcClientManager[T any] struct {
+	sync.RWMutex
+	conn      validatorHelpers.NodeConnection
+	client    T
+	lastHost  string
+	newClient func(grpc.ClientConnInterface) T
+}
+
+// newGrpcClientManager creates a new client manager with the given connection and client constructor.
+func newGrpcClientManager[T any](
+	conn validatorHelpers.NodeConnection,
+	newClient func(grpc.ClientConnInterface) T,
+) *grpcClientManager[T] {
+	return &grpcClientManager[T]{
+		conn:      conn,
+		newClient: newClient,
+		client:    newClient(conn.GetGrpcClientConn()),
+		lastHost:  conn.GetGrpcConnectionProvider().CurrentHost(),
+	}
+}
+
+// getClient returns the current client, recreating it if the connection has changed.
+func (m *grpcClientManager[T]) getClient() T {
+	// Safety check for tests that create manager directly without connection
+	if m.conn == nil || m.conn.GetGrpcConnectionProvider() == nil {
+		return m.client
+	}
+	currentHost := m.conn.GetGrpcConnectionProvider().CurrentHost()
+	m.RLock()
+	if m.lastHost == currentHost {
+		client := m.client
+		m.RUnlock()
+		return client
+	}
+	m.RUnlock()
+
+	// Connection changed, need to recreate client
+	m.Lock()
+	defer m.Unlock()
+	// Double-check after acquiring write lock
+	if m.lastHost == currentHost {
+		return m.client
+	}
+	m.client = m.newClient(m.conn.GetGrpcClientConn())
+	m.lastHost = currentHost
+	return m.client
+}

validator/client/grpc-api/grpc_client_manager_test.go

@@ -0,0 +1,168 @@
+package grpc_api
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
+	"google.golang.org/grpc"
+)
+
+// mockProvider implements grpcutil.GrpcConnectionProvider for testing.
+type mockProvider struct {
+	hosts        []string
+	currentIndex int
+	mu           sync.Mutex
+}
+
+func (m *mockProvider) CurrentConn() *grpc.ClientConn { return nil }
+func (m *mockProvider) Hosts() []string               { return m.hosts }
+func (m *mockProvider) Close() error                  { return nil }
+
+func (m *mockProvider) CurrentHost() string {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.hosts[m.currentIndex]
+}
+
+func (m *mockProvider) SetHost(index int) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.currentIndex = index
+	return nil
+}
+
+// nextHost is a test helper for round-robin simulation (not part of the interface).
+func (m *mockProvider) nextHost() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.currentIndex = (m.currentIndex + 1) % len(m.hosts)
+}
+
+// testClient is a simple type for testing the generic client manager.
+type testClient struct{ id int }
+
+// testManager creates a manager with client creation counting.
+func testManager(t *testing.T, provider *mockProvider) (*grpcClientManager[*testClient], *int) {
+	conn, err := validatorHelpers.NewNodeConnection(validatorHelpers.WithGrpcProvider(provider))
+	require.NoError(t, err)
+
+	clientCount := new(int)
+	newClient := func(grpc.ClientConnInterface) *testClient {
+		*clientCount++
+		return &testClient{id: *clientCount}
+	}
+
+	manager := newGrpcClientManager(conn, newClient)
+	require.NotNil(t, manager)
+	return manager, clientCount
+}
+
+func TestGrpcClientManager(t *testing.T) {
+	t.Run("tracks host", func(t *testing.T) {
+		provider := &mockProvider{hosts: []string{"host1:4000", "host2:4000"}}
+		manager, count := testManager(t, provider)
+		assert.Equal(t, 1, *count)
+		assert.Equal(t, "host1:4000", manager.lastHost)
+	})
+
+	t.Run("same host returns same client", func(t *testing.T) {
+		provider := &mockProvider{hosts: []string{"host1:4000", "host2:4000"}}
+		manager, count := testManager(t, provider)
+
+		c1, c2, c3 := manager.getClient(), manager.getClient(), manager.getClient()
+		assert.Equal(t, 1, *count)
+		assert.Equal(t, c1, c2)
+		assert.Equal(t, c2, c3)
+	})
+
+	t.Run("host change recreates client", func(t *testing.T) {
+		provider := &mockProvider{hosts: []string{"host1:4000", "host2:4000"}}
+		manager, count := testManager(t, provider)
+
+		c1 := manager.getClient()
+		assert.Equal(t, 1, c1.id)
+
+		provider.nextHost()
+		c2 := manager.getClient()
+		assert.Equal(t, 2, *count)
+		assert.Equal(t, 2, c2.id)
+
+		// Same host again - no recreation
+		c3 := manager.getClient()
+		assert.Equal(t, 2, *count)
+		assert.Equal(t, c2, c3)
+	})
+
+	t.Run("multiple host switches", func(t *testing.T) {
+		provider := &mockProvider{hosts: []string{"host1:4000", "host2:4000", "host3:4000"}}
+		manager, count := testManager(t, provider)
+		assert.Equal(t, 1, *count)
+
+		for expected := 2; expected <= 4; expected++ {
+			provider.nextHost()
+			_ = manager.getClient()
+			assert.Equal(t, expected, *count)
+		}
+	})
+}
+
+func TestGrpcClientManager_Concurrent(t *testing.T) {
+	t.Run("concurrent access same host", func(t *testing.T) {
+		provider := &mockProvider{hosts: []string{"host1:4000", "host2:4000"}}
+		manager, _ := testManager(t, provider)
+
+		var clientCount int
+		var countMu sync.Mutex
+		// Override with thread-safe counter
+		manager.newClient = func(grpc.ClientConnInterface) *testClient {
+			countMu.Lock()
+			clientCount++
+			id := clientCount
+			countMu.Unlock()
+			return &testClient{id: id}
+		}
+		manager.client = manager.newClient(nil)
+		clientCount = 1
+
+		var wg sync.WaitGroup
+		for range 100 {
+			wg.Go(func() { _ = manager.getClient() })
+		}
+		wg.Wait()
+
+		countMu.Lock()
+		assert.Equal(t, 1, clientCount)
+		countMu.Unlock()
+	})
+
+	t.Run("concurrent with host changes", func(t *testing.T) {
+		provider := &mockProvider{hosts: []string{"host1:4000", "host2:4000"}}
+		manager, _ := testManager(t, provider)
+
+		var clientCount int
+		var countMu sync.Mutex
+		manager.newClient = func(grpc.ClientConnInterface) *testClient {
+			countMu.Lock()
+			clientCount++
+			id := clientCount
+			countMu.Unlock()
+			return &testClient{id: id}
+		}
+		manager.client = manager.newClient(nil)
+		clientCount = 1
+
+		var wg sync.WaitGroup
+		for range 50 {
+			wg.Go(func() { _ = manager.getClient() })
+			wg.Go(func() { provider.nextHost() })
+		}
+		wg.Wait()
+
+		countMu.Lock()
+		assert.NotEqual(t, 0, clientCount, "Should have created at least one client")
+		countMu.Unlock()
+	})
+}

validator/client/grpc-api/grpc_node_client.go

@@ -5,8 +5,8 @@ import (
 
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/validator/client/iface"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	"github.com/golang/protobuf/ptypes/empty"
-	"google.golang.org/grpc"
 )
 
 var (
@@ -14,35 +14,48 @@ var (
 )
 
 type grpcNodeClient struct {
-	nodeClient ethpb.NodeClient
+	*grpcClientManager[ethpb.NodeClient]
 }
 
 func (c *grpcNodeClient) SyncStatus(ctx context.Context, in *empty.Empty) (*ethpb.SyncStatus, error) {
-	return c.nodeClient.GetSyncStatus(ctx, in)
+	return c.getClient().GetSyncStatus(ctx, in)
 }
 
 func (c *grpcNodeClient) Genesis(ctx context.Context, in *empty.Empty) (*ethpb.Genesis, error) {
-	return c.nodeClient.GetGenesis(ctx, in)
+	return c.getClient().GetGenesis(ctx, in)
 }
 
 func (c *grpcNodeClient) Version(ctx context.Context, in *empty.Empty) (*ethpb.Version, error) {
-	return c.nodeClient.GetVersion(ctx, in)
+	return c.getClient().GetVersion(ctx, in)
 }
 
 func (c *grpcNodeClient) Peers(ctx context.Context, in *empty.Empty) (*ethpb.Peers, error) {
-	return c.nodeClient.ListPeers(ctx, in)
+	return c.getClient().ListPeers(ctx, in)
 }
 
 func (c *grpcNodeClient) IsReady(ctx context.Context) bool {
-	_, err := c.nodeClient.GetHealth(ctx, &ethpb.HealthRequest{})
+	_, err := c.getClient().GetHealth(ctx, &ethpb.HealthRequest{})
 	if err != nil {
-		log.WithError(err).Error("Failed to get health of node")
+		log.WithError(err).Debug("Failed to get health of node")
+		return false
+	}
+	// Then check sync status - we only want fully synced nodes
+	syncStatus, err := c.getClient().GetSyncStatus(ctx, &empty.Empty{})
+	if err != nil {
+		log.WithError(err).Debug("Failed to get sync status of node")
+		return false
+	}
+	if syncStatus.Syncing {
+		log.Debug("Node is syncing, not fully synced")
 		return false
 	}
 	return true
 }
 
-func NewNodeClient(cc grpc.ClientConnInterface) iface.NodeClient {
-	g := &grpcNodeClient{nodeClient: ethpb.NewNodeClient(cc)}
-	return g
+// NewNodeClient creates a new gRPC node client that supports
+// dynamic connection switching via the NodeConnection's GrpcConnectionProvider.
+func NewNodeClient(conn validatorHelpers.NodeConnection) iface.NodeClient {
+	return &grpcNodeClient{
+		grpcClientManager: newGrpcClientManager(conn, ethpb.NewNodeClient),
+	}
 }

validator/client/grpc-api/grpc_prysm_beacon_chain_client.go

@@ -12,9 +12,9 @@ import (
 	eth "github.com/OffchainLabs/prysm/v7/proto/eth/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/validator/client/iface"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/pkg/errors"
-	"google.golang.org/grpc"
 )
 
 type grpcPrysmChainClient struct {
@@ -95,6 +95,8 @@ func (c *grpcPrysmChainClient) ValidatorPerformance(ctx context.Context, in *eth
 	return c.chainClient.ValidatorPerformance(ctx, in)
 }
 
-func NewGrpcPrysmChainClient(cc grpc.ClientConnInterface) iface.PrysmChainClient {
-	return &grpcPrysmChainClient{chainClient: &grpcChainClient{ethpb.NewBeaconChainClient(cc)}}
+// NewGrpcPrysmChainClient creates a new gRPC Prysm chain client that supports
+// dynamic connection switching via the NodeConnection's GrpcConnectionProvider.
+func NewGrpcPrysmChainClient(conn validatorHelpers.NodeConnection) iface.PrysmChainClient {
+	return &grpcPrysmChainClient{chainClient: NewGrpcChainClient(conn)}
 }

validator/client/grpc-api/grpc_validator_client.go

@@ -14,24 +14,24 @@ import (
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/validator/client/iface"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/pkg/errors"
-	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
 type grpcValidatorClient struct {
-	beaconNodeValidatorClient ethpb.BeaconNodeValidatorClient
-	isEventStreamRunning      bool
+	*grpcClientManager[ethpb.BeaconNodeValidatorClient]
+	isEventStreamRunning bool
 }
 
 func (c *grpcValidatorClient) Duties(ctx context.Context, in *ethpb.DutiesRequest) (*ethpb.ValidatorDutiesContainer, error) {
 	if features.Get().DisableDutiesV2 {
 		return c.getDuties(ctx, in)
 	}
-	dutiesResponse, err := c.beaconNodeValidatorClient.GetDutiesV2(ctx, in)
+	dutiesResponse, err := c.getClient().GetDutiesV2(ctx, in)
 	if err != nil {
 		if status.Code(err) == codes.Unimplemented {
 			log.Warn("GetDutiesV2 returned status code unavailable, falling back to GetDuties")
@@ -47,7 +47,7 @@ func (c *grpcValidatorClient) Duties(ctx context.Context, in *ethpb.DutiesReques
 
 // getDuties is calling the v1 of get duties
 func (c *grpcValidatorClient) getDuties(ctx context.Context, in *ethpb.DutiesRequest) (*ethpb.ValidatorDutiesContainer, error) {
-	dutiesResponse, err := c.beaconNodeValidatorClient.GetDuties(ctx, in)
+	dutiesResponse, err := c.getClient().GetDuties(ctx, in)
 	if err != nil {
 		return nil, errors.Wrap(
 			client.ErrConnectionIssue,
@@ -147,108 +147,108 @@ func toValidatorDutyV2(duty *ethpb.DutiesV2Response_Duty) (*ethpb.ValidatorDuty,
 }
 
 func (c *grpcValidatorClient) CheckDoppelGanger(ctx context.Context, in *ethpb.DoppelGangerRequest) (*ethpb.DoppelGangerResponse, error) {
-	return c.beaconNodeValidatorClient.CheckDoppelGanger(ctx, in)
+	return c.getClient().CheckDoppelGanger(ctx, in)
 }
 
 func (c *grpcValidatorClient) DomainData(ctx context.Context, in *ethpb.DomainRequest) (*ethpb.DomainResponse, error) {
-	return c.beaconNodeValidatorClient.DomainData(ctx, in)
+	return c.getClient().DomainData(ctx, in)
 }
 
 func (c *grpcValidatorClient) AttestationData(ctx context.Context, in *ethpb.AttestationDataRequest) (*ethpb.AttestationData, error) {
-	return c.beaconNodeValidatorClient.GetAttestationData(ctx, in)
+	return c.getClient().GetAttestationData(ctx, in)
 }
 
 func (c *grpcValidatorClient) BeaconBlock(ctx context.Context, in *ethpb.BlockRequest) (*ethpb.GenericBeaconBlock, error) {
-	return c.beaconNodeValidatorClient.GetBeaconBlock(ctx, in)
+	return c.getClient().GetBeaconBlock(ctx, in)
 }
 
 func (c *grpcValidatorClient) FeeRecipientByPubKey(ctx context.Context, in *ethpb.FeeRecipientByPubKeyRequest) (*ethpb.FeeRecipientByPubKeyResponse, error) {
-	return c.beaconNodeValidatorClient.GetFeeRecipientByPubKey(ctx, in)
+	return c.getClient().GetFeeRecipientByPubKey(ctx, in)
 }
 
 func (c *grpcValidatorClient) SyncCommitteeContribution(ctx context.Context, in *ethpb.SyncCommitteeContributionRequest) (*ethpb.SyncCommitteeContribution, error) {
-	return c.beaconNodeValidatorClient.GetSyncCommitteeContribution(ctx, in)
+	return c.getClient().GetSyncCommitteeContribution(ctx, in)
 }
 
 func (c *grpcValidatorClient) SyncMessageBlockRoot(ctx context.Context, in *empty.Empty) (*ethpb.SyncMessageBlockRootResponse, error) {
-	return c.beaconNodeValidatorClient.GetSyncMessageBlockRoot(ctx, in)
+	return c.getClient().GetSyncMessageBlockRoot(ctx, in)
 }
 
 func (c *grpcValidatorClient) SyncSubcommitteeIndex(ctx context.Context, in *ethpb.SyncSubcommitteeIndexRequest) (*ethpb.SyncSubcommitteeIndexResponse, error) {
-	return c.beaconNodeValidatorClient.GetSyncSubcommitteeIndex(ctx, in)
+	return c.getClient().GetSyncSubcommitteeIndex(ctx, in)
 }
 
 func (c *grpcValidatorClient) MultipleValidatorStatus(ctx context.Context, in *ethpb.MultipleValidatorStatusRequest) (*ethpb.MultipleValidatorStatusResponse, error) {
-	return c.beaconNodeValidatorClient.MultipleValidatorStatus(ctx, in)
+	return c.getClient().MultipleValidatorStatus(ctx, in)
 }
 
 func (c *grpcValidatorClient) PrepareBeaconProposer(ctx context.Context, in *ethpb.PrepareBeaconProposerRequest) (*empty.Empty, error) {
-	return c.beaconNodeValidatorClient.PrepareBeaconProposer(ctx, in)
+	return c.getClient().PrepareBeaconProposer(ctx, in)
 }
 
 func (c *grpcValidatorClient) ProposeAttestation(ctx context.Context, in *ethpb.Attestation) (*ethpb.AttestResponse, error) {
-	return c.beaconNodeValidatorClient.ProposeAttestation(ctx, in)
+	return c.getClient().ProposeAttestation(ctx, in)
 }
 
 func (c *grpcValidatorClient) ProposeAttestationElectra(ctx context.Context, in *ethpb.SingleAttestation) (*ethpb.AttestResponse, error) {
-	return c.beaconNodeValidatorClient.ProposeAttestationElectra(ctx, in)
+	return c.getClient().ProposeAttestationElectra(ctx, in)
 }
 
 func (c *grpcValidatorClient) ProposeBeaconBlock(ctx context.Context, in *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
-	return c.beaconNodeValidatorClient.ProposeBeaconBlock(ctx, in)
+	return c.getClient().ProposeBeaconBlock(ctx, in)
 }
 
 func (c *grpcValidatorClient) ProposeExit(ctx context.Context, in *ethpb.SignedVoluntaryExit) (*ethpb.ProposeExitResponse, error) {
-	return c.beaconNodeValidatorClient.ProposeExit(ctx, in)
+	return c.getClient().ProposeExit(ctx, in)
 }
 
 func (c *grpcValidatorClient) StreamBlocksAltair(ctx context.Context, in *ethpb.StreamBlocksRequest) (ethpb.BeaconNodeValidator_StreamBlocksAltairClient, error) {
-	return c.beaconNodeValidatorClient.StreamBlocksAltair(ctx, in)
+	return c.getClient().StreamBlocksAltair(ctx, in)
 }
 
 func (c *grpcValidatorClient) SubmitAggregateSelectionProof(ctx context.Context, in *ethpb.AggregateSelectionRequest, _ primitives.ValidatorIndex, _ uint64) (*ethpb.AggregateSelectionResponse, error) {
-	return c.beaconNodeValidatorClient.SubmitAggregateSelectionProof(ctx, in)
+	return c.getClient().SubmitAggregateSelectionProof(ctx, in)
 }
 
 func (c *grpcValidatorClient) SubmitAggregateSelectionProofElectra(ctx context.Context, in *ethpb.AggregateSelectionRequest, _ primitives.ValidatorIndex, _ uint64) (*ethpb.AggregateSelectionElectraResponse, error) {
-	return c.beaconNodeValidatorClient.SubmitAggregateSelectionProofElectra(ctx, in)
+	return c.getClient().SubmitAggregateSelectionProofElectra(ctx, in)
 }
 
 func (c *grpcValidatorClient) SubmitSignedAggregateSelectionProof(ctx context.Context, in *ethpb.SignedAggregateSubmitRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
-	return c.beaconNodeValidatorClient.SubmitSignedAggregateSelectionProof(ctx, in)
+	return c.getClient().SubmitSignedAggregateSelectionProof(ctx, in)
 }
 
 func (c *grpcValidatorClient) SubmitSignedAggregateSelectionProofElectra(ctx context.Context, in *ethpb.SignedAggregateSubmitElectraRequest) (*ethpb.SignedAggregateSubmitResponse, error) {
-	return c.beaconNodeValidatorClient.SubmitSignedAggregateSelectionProofElectra(ctx, in)
+	return c.getClient().SubmitSignedAggregateSelectionProofElectra(ctx, in)
 }
 
 func (c *grpcValidatorClient) SubmitSignedContributionAndProof(ctx context.Context, in *ethpb.SignedContributionAndProof) (*empty.Empty, error) {
-	return c.beaconNodeValidatorClient.SubmitSignedContributionAndProof(ctx, in)
+	return c.getClient().SubmitSignedContributionAndProof(ctx, in)
 }
 
 func (c *grpcValidatorClient) SubmitSyncMessage(ctx context.Context, in *ethpb.SyncCommitteeMessage) (*empty.Empty, error) {
-	return c.beaconNodeValidatorClient.SubmitSyncMessage(ctx, in)
+	return c.getClient().SubmitSyncMessage(ctx, in)
 }
 
 func (c *grpcValidatorClient) SubmitValidatorRegistrations(ctx context.Context, in *ethpb.SignedValidatorRegistrationsV1) (*empty.Empty, error) {
-	return c.beaconNodeValidatorClient.SubmitValidatorRegistrations(ctx, in)
+	return c.getClient().SubmitValidatorRegistrations(ctx, in)
 }
 
 func (c *grpcValidatorClient) SubscribeCommitteeSubnets(ctx context.Context, in *ethpb.CommitteeSubnetsSubscribeRequest, _ []*ethpb.ValidatorDuty) (*empty.Empty, error) {
-	return c.beaconNodeValidatorClient.SubscribeCommitteeSubnets(ctx, in)
+	return c.getClient().SubscribeCommitteeSubnets(ctx, in)
 }
 
 func (c *grpcValidatorClient) ValidatorIndex(ctx context.Context, in *ethpb.ValidatorIndexRequest) (*ethpb.ValidatorIndexResponse, error) {
-	return c.beaconNodeValidatorClient.ValidatorIndex(ctx, in)
+	return c.getClient().ValidatorIndex(ctx, in)
 }
 
 func (c *grpcValidatorClient) ValidatorStatus(ctx context.Context, in *ethpb.ValidatorStatusRequest) (*ethpb.ValidatorStatusResponse, error) {
-	return c.beaconNodeValidatorClient.ValidatorStatus(ctx, in)
+	return c.getClient().ValidatorStatus(ctx, in)
 }
 
 // Deprecated: Do not use.
 func (c *grpcValidatorClient) WaitForChainStart(ctx context.Context, in *empty.Empty) (*ethpb.ChainStartResponse, error) {
-	stream, err := c.beaconNodeValidatorClient.WaitForChainStart(ctx, in)
+	stream, err := c.getClient().WaitForChainStart(ctx, in)
 	if err != nil {
 		return nil, errors.Wrap(
 			client.ErrConnectionIssue,
@@ -260,13 +260,13 @@ func (c *grpcValidatorClient) WaitForChainStart(ctx context.Context, in *empty.E
 }
 
 func (c *grpcValidatorClient) AssignValidatorToSubnet(ctx context.Context, in *ethpb.AssignValidatorToSubnetRequest) (*empty.Empty, error) {
-	return c.beaconNodeValidatorClient.AssignValidatorToSubnet(ctx, in)
+	return c.getClient().AssignValidatorToSubnet(ctx, in)
 }
 func (c *grpcValidatorClient) AggregatedSigAndAggregationBits(
 	ctx context.Context,
 	in *ethpb.AggregatedSigAndAggregationBitsRequest,
 ) (*ethpb.AggregatedSigAndAggregationBitsResponse, error) {
-	return c.beaconNodeValidatorClient.AggregatedSigAndAggregationBits(ctx, in)
+	return c.getClient().AggregatedSigAndAggregationBits(ctx, in)
 }
 
 func (*grpcValidatorClient) AggregatedSelections(context.Context, []iface.BeaconCommitteeSelection) ([]iface.BeaconCommitteeSelection, error) {
@@ -277,8 +277,12 @@ func (*grpcValidatorClient) AggregatedSyncSelections(context.Context, []iface.Sy
 	return nil, iface.ErrNotSupported
 }
 
-func NewGrpcValidatorClient(cc grpc.ClientConnInterface) iface.ValidatorClient {
-	return &grpcValidatorClient{ethpb.NewBeaconNodeValidatorClient(cc), false}
+// NewGrpcValidatorClient creates a new gRPC validator client that supports
+// dynamic connection switching via the NodeConnection's GrpcConnectionProvider.
+func NewGrpcValidatorClient(conn validatorHelpers.NodeConnection) iface.ValidatorClient {
+	return &grpcValidatorClient{
+		grpcClientManager: newGrpcClientManager(conn, ethpb.NewBeaconNodeValidatorClient),
+	}
 }
 
 func (c *grpcValidatorClient) StartEventStream(ctx context.Context, topics []string, eventsChannel chan<- *eventClient.Event) {
@@ -308,7 +312,7 @@ func (c *grpcValidatorClient) StartEventStream(ctx context.Context, topics []str
 		log.Warn("gRPC only supports the head topic, other topics will be ignored")
 	}
 
-	stream, err := c.beaconNodeValidatorClient.StreamSlots(ctx, &ethpb.StreamSlotsRequest{VerifiedOnly: true})
+	stream, err := c.getClient().StreamSlots(ctx, &ethpb.StreamSlotsRequest{VerifiedOnly: true})
 	if err != nil {
 		eventsChannel <- &eventClient.Event{
 			EventType: eventClient.EventConnectionError,
@@ -374,11 +378,20 @@ func (c *grpcValidatorClient) EventStreamIsRunning() bool {
 	return c.isEventStreamRunning
 }
 
-func (*grpcValidatorClient) Host() string {
-	log.Warn(iface.ErrNotSupported)
-	return ""
+func (c *grpcValidatorClient) Host() string {
+	return c.grpcClientManager.conn.GetGrpcConnectionProvider().CurrentHost()
 }
 
-func (*grpcValidatorClient) SetHost(_ string) {
-	log.Warn(iface.ErrNotSupported)
+func (c *grpcValidatorClient) SetHost(host string) {
+	provider := c.grpcClientManager.conn.GetGrpcConnectionProvider()
+	// Find the index of the requested host and switch to it
+	for i, h := range provider.Hosts() {
+		if h == host {
+			if err := provider.SetHost(i); err != nil {
+				log.WithError(err).WithField("host", host).Error("Failed to set gRPC host")
+			}
+			return
+		}
+	}
+	log.WithField("host", host).Warn("Requested gRPC host not found in configured endpoints")
 }

validator/client/grpc-api/grpc_validator_client_test.go

@@ -133,7 +133,12 @@ func TestWaitForChainStart_StreamSetupFails(t *testing.T) {
 		gomock.Any(),
 	).Return(nil, errors.New("failed stream"))
 
-	validatorClient := &grpcValidatorClient{beaconNodeValidatorClient, true}
+	validatorClient := &grpcValidatorClient{
+		grpcClientManager: &grpcClientManager[eth.BeaconNodeValidatorClient]{
+			client: beaconNodeValidatorClient,
+		},
+		isEventStreamRunning: true,
+	}
 	_, err := validatorClient.WaitForChainStart(t.Context(), &emptypb.Empty{})
 	want := "could not setup beacon chain ChainStart streaming client"
 	assert.ErrorContains(t, want, err)
@@ -146,7 +151,12 @@ func TestStartEventStream(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 	beaconNodeValidatorClient := mock2.NewMockBeaconNodeValidatorClient(ctrl)
-	grpcClient := &grpcValidatorClient{beaconNodeValidatorClient, true}
+	grpcClient := &grpcValidatorClient{
+		grpcClientManager: &grpcClientManager[eth.BeaconNodeValidatorClient]{
+			client: beaconNodeValidatorClient,
+		},
+		isEventStreamRunning: true,
+	}
 	tests := []struct {
 		name    string
 		topics  []string

validator/client/multiple_endpoints_grpc_resolver.go

@@ -1,53 +0,0 @@
-package client
-
-import (
-	"strings"
-
-	"google.golang.org/grpc/resolver"
-)
-
-// Modification of a default grpc passthrough resolver (google.golang.org/grpc/resolver/passthrough) allowing to use multiple addresses
-// in grpc endpoint. Example:
-// conn, err := grpc.DialContext(ctx, "127.0.0.1:4000,127.0.0.1:4001", grpc.WithInsecure(), grpc.WithResolvers(&multipleEndpointsGrpcResolverBuilder{}))
-// It can be used with any grpc load balancer (pick_first, round_robin). Default is pick_first.
-// Round robin can be used by adding the following option:
-// grpc.WithDefaultServiceConfig("{\"loadBalancingConfig\":[{\"round_robin\":{}}]}")
-type multipleEndpointsGrpcResolverBuilder struct{}
-
-// Build creates and starts multiple endpoints resolver.
-func (*multipleEndpointsGrpcResolverBuilder) Build(target resolver.Target, cc resolver.ClientConn, _ resolver.BuildOptions) (resolver.Resolver, error) {
-	r := &multipleEndpointsGrpcResolver{
-		target: target,
-		cc:     cc,
-	}
-	r.start()
-	return r, nil
-}
-
-// Scheme returns default scheme.
-func (*multipleEndpointsGrpcResolverBuilder) Scheme() string {
-	return resolver.GetDefaultScheme()
-}
-
-type multipleEndpointsGrpcResolver struct {
-	target resolver.Target
-	cc     resolver.ClientConn
-}
-
-func (r *multipleEndpointsGrpcResolver) start() {
-	ep := r.target.Endpoint()
-	endpoints := strings.Split(ep, ",")
-	var addrs []resolver.Address
-	for _, endpoint := range endpoints {
-		addrs = append(addrs, resolver.Address{Addr: endpoint, ServerName: endpoint})
-	}
-	if err := r.cc.UpdateState(resolver.State{Addresses: addrs}); err != nil {
-		log.WithError(err).Error("Failed to update grpc connection state")
-	}
-}
-
-// ResolveNow --
-func (*multipleEndpointsGrpcResolver) ResolveNow(_ resolver.ResolveNowOptions) {}
-
-// Close --
-func (*multipleEndpointsGrpcResolver) Close() {}

validator/client/node-client-factory/node_client_factory.go

@@ -8,11 +8,10 @@ import (
 	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 )
 
-func NewNodeClient(validatorConn validatorHelpers.NodeConnection, jsonRestHandler beaconApi.RestHandler) iface.NodeClient {
-	grpcClient := grpcApi.NewNodeClient(validatorConn.GetGrpcClientConn())
+func NewNodeClient(validatorConn validatorHelpers.NodeConnection) iface.NodeClient {
+	grpcClient := grpcApi.NewNodeClient(validatorConn)
 	if features.Get().EnableBeaconRESTApi {
-		return beaconApi.NewNodeClientWithFallback(jsonRestHandler, grpcClient)
-	} else {
-		return grpcClient
+		return beaconApi.NewNodeClientWithFallback(validatorConn.GetRestHandler(), grpcClient)
 	}
+	return grpcClient
 }

validator/client/service.go

@@ -2,13 +2,11 @@ package client
 
 import (
 	"context"
-	"net/http"
-	"strings"
 	"time"
 
-	api "github.com/OffchainLabs/prysm/v7/api/client"
 	eventClient "github.com/OffchainLabs/prysm/v7/api/client/event"
 	grpcutil "github.com/OffchainLabs/prysm/v7/api/grpc"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/async/event"
 	lruwrpr "github.com/OffchainLabs/prysm/v7/cache/lru"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -17,7 +15,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/validator/accounts/wallet"
-	beaconApi "github.com/OffchainLabs/prysm/v7/validator/client/beacon-api"
 	beaconChainClientFactory "github.com/OffchainLabs/prysm/v7/validator/client/beacon-chain-client-factory"
 	"github.com/OffchainLabs/prysm/v7/validator/client/iface"
 	nodeclientfactory "github.com/OffchainLabs/prysm/v7/validator/client/node-client-factory"
@@ -35,7 +32,6 @@ import (
 	grpcprometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
 	"github.com/pkg/errors"
 	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
-	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/protobuf/proto"
@@ -72,6 +68,7 @@ type Config struct {
 	DB                      db.Database
 	Wallet                  *wallet.Wallet
 	WalletInitializedFeed   *event.Feed
+	Conn                    validatorHelpers.NodeConnection // Optional: inject connection for testing
 	MaxHealthChecks         int
 	GRPCMaxCallRecvMsgSize  int
 	GRPCRetries             uint
@@ -122,6 +119,12 @@ func NewValidatorService(ctx context.Context, cfg *Config) (*ValidatorService, e
 		maxHealthChecks:         cfg.MaxHealthChecks,
 	}
 
+	// Use injected connection if provided (for testing)
+	if cfg.Conn != nil {
+		s.conn = cfg.Conn
+		return s, nil
+	}
+
 	dialOpts := ConstructDialOptions(
 		cfg.GRPCMaxCallRecvMsgSize,
 		cfg.BeaconNodeCert,
@@ -134,19 +137,21 @@ func NewValidatorService(ctx context.Context, cfg *Config) (*ValidatorService, e
 
 	s.ctx = grpcutil.AppendHeaders(ctx, cfg.GRPCHeaders)
 
-	grpcConn, err := grpc.DialContext(ctx, cfg.BeaconNodeGRPCEndpoint, dialOpts...)
+	conn, err := validatorHelpers.NewNodeConnection(
+		validatorHelpers.WithGrpc(s.ctx, cfg.BeaconNodeGRPCEndpoint, dialOpts),
+		validatorHelpers.WithREST(cfg.BeaconApiEndpoint,
+			rest.WithHttpHeaders(cfg.BeaconApiHeaders),
+			rest.WithHttpTimeout(cfg.BeaconApiTimeout),
+			rest.WithTracing(),
+		),
+	)
 	if err != nil {
 		return s, err
 	}
-	if cfg.BeaconNodeCert != "" {
+	if cfg.BeaconNodeCert != "" && cfg.BeaconNodeGRPCEndpoint != "" {
 		log.Info("Established secure gRPC connection")
 	}
-	s.conn = validatorHelpers.NewNodeConnection(
-		grpcConn,
-		cfg.BeaconApiEndpoint,
-		validatorHelpers.WithBeaconApiHeaders(cfg.BeaconApiHeaders),
-		validatorHelpers.WithBeaconApiTimeout(cfg.BeaconApiTimeout),
-	)
+	s.conn = conn
 
 	return s, nil
 }
@@ -181,20 +186,13 @@ func (v *ValidatorService) Start() {
 		return
 	}
 
-	u := strings.ReplaceAll(v.conn.GetBeaconApiUrl(), " ", "")
-	hosts := strings.Split(u, ",")
-	if len(hosts) == 0 {
-		log.WithError(err).Error("No API hosts provided")
+	restProvider := v.conn.GetRestConnectionProvider()
+	if restProvider == nil || len(restProvider.Hosts()) == 0 {
+		log.Error("No REST API hosts provided")
 		return
 	}
 
-	headersTransport := api.NewCustomHeadersTransport(http.DefaultTransport, v.conn.GetBeaconApiHeaders())
-	restHandler := beaconApi.NewBeaconApiRestHandler(
-		http.Client{Timeout: v.conn.GetBeaconApiTimeout(), Transport: otelhttp.NewTransport(headersTransport)},
-		hosts[0],
-	)
-
-	validatorClient := validatorclientfactory.NewValidatorClient(v.conn, restHandler)
+	validatorClient := validatorclientfactory.NewValidatorClient(v.conn)
 
 	v.validator = &validator{
 		slotFeed:                       new(event.Feed),
@@ -208,12 +206,12 @@ func (v *ValidatorService) Start() {
 		graffiti:                       v.graffiti,
 		graffitiStruct:                 v.graffitiStruct,
 		graffitiOrderedIndex:           graffitiOrderedIndex,
-		beaconNodeHosts:                hosts,
+		conn:                           v.conn,
 		currentHostIndex:               0,
 		validatorClient:                validatorClient,
-		chainClient:                    beaconChainClientFactory.NewChainClient(v.conn, restHandler),
-		nodeClient:                     nodeclientfactory.NewNodeClient(v.conn, restHandler),
-		prysmChainClient:               beaconChainClientFactory.NewPrysmChainClient(v.conn, restHandler),
+		chainClient:                    beaconChainClientFactory.NewChainClient(v.conn),
+		nodeClient:                     nodeclientfactory.NewNodeClient(v.conn),
+		prysmChainClient:               beaconChainClientFactory.NewPrysmChainClient(v.conn),
 		db:                             v.db,
 		km:                             nil,
 		web3SignerConfig:               v.web3SignerConfig,
@@ -369,7 +367,6 @@ func ConstructDialOptions(
 			grpcprometheus.StreamClientInterceptor,
 			grpcretry.StreamClientInterceptor(),
 		),
-		grpc.WithResolvers(&multipleEndpointsGrpcResolverBuilder{}),
 	}
 
 	dialOpts = append(dialOpts, extraOpts...)

validator/client/service_test.go

@@ -33,7 +33,10 @@ func TestStop_CancelsContext(t *testing.T) {
 
 func TestNew_Insecure(t *testing.T) {
 	hook := logTest.NewGlobal()
-	_, err := NewValidatorService(t.Context(), &Config{})
+	_, err := NewValidatorService(t.Context(), &Config{
+		BeaconNodeGRPCEndpoint: "localhost:4000",
+		BeaconApiEndpoint:      "http://localhost:3500",
+	})
 	require.NoError(t, err)
 	require.LogsContain(t, hook, "You are using an insecure gRPC connection")
 }
@@ -58,7 +61,11 @@ func TestStart_GrpcHeaders(t *testing.T) {
 			"Authorization", "this is a valid value",
 		},
 	} {
-		cfg := &Config{GRPCHeaders: strings.Split(input, ",")}
+		cfg := &Config{
+			BeaconNodeGRPCEndpoint: "localhost:4000",
+			BeaconApiEndpoint:      "http://localhost:3500",
+			GRPCHeaders:            strings.Split(input, ","),
+		}
 		validatorService, err := NewValidatorService(ctx, cfg)
 		require.NoError(t, err)
 		md, _ := metadata.FromOutgoingContext(validatorService.ctx)

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

@@ -10,12 +10,10 @@ import (
 
 func NewValidatorClient(
 	validatorConn validatorHelpers.NodeConnection,
-	jsonRestHandler beaconApi.RestHandler,
 	opt ...beaconApi.ValidatorClientOpt,
 ) iface.ValidatorClient {
 	if features.Get().EnableBeaconRESTApi {
-		return beaconApi.NewBeaconApiValidatorClient(jsonRestHandler, opt...)
-	} else {
-		return grpcApi.NewGrpcValidatorClient(validatorConn.GetGrpcClientConn())
+		return beaconApi.NewBeaconApiValidatorClient(validatorConn.GetRestHandler(), opt...)
 	}
+	return grpcApi.NewGrpcValidatorClient(validatorConn)
 }

validator/client/validator.go

@@ -38,6 +38,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/validator/db"
 	dbCommon "github.com/OffchainLabs/prysm/v7/validator/db/common"
 	"github.com/OffchainLabs/prysm/v7/validator/graffiti"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	"github.com/OffchainLabs/prysm/v7/validator/keymanager"
 	"github.com/OffchainLabs/prysm/v7/validator/keymanager/local"
 	remoteweb3signer "github.com/OffchainLabs/prysm/v7/validator/keymanager/remote-web3signer"
@@ -101,9 +102,9 @@ type validator struct {
 	pubkeyToStatus                     map[[fieldparams.BLSPubkeyLength]byte]*validatorStatus
 	wallet                             *wallet.Wallet
 	walletInitializedChan              chan *wallet.Wallet
-	currentHostIndex                   uint64
 	walletInitializedFeed              *event.Feed
 	graffitiOrderedIndex               uint64
+	conn                               validatorHelpers.NodeConnection
 	submittedAtts                      map[submittedAttKey]*submittedAtt
 	validatorsRegBatchSize             int
 	validatorClient                    iface.ValidatorClient
@@ -114,7 +115,7 @@ type validator struct {
 	km                                 keymanager.IKeymanager
 	accountChangedSub                  event.Subscription
 	ticker                             slots.Ticker
-	beaconNodeHosts                    []string
+	currentHostIndex                   uint64
 	genesisTime                        time.Time
 	graffiti                           []byte
 	voteStats                          voteStats
@@ -1311,34 +1312,64 @@ func (v *validator) Host() string {
 }
 
 func (v *validator) changeHost() {
-	next := (v.currentHostIndex + 1) % uint64(len(v.beaconNodeHosts))
+	hosts := v.hosts()
+	if len(hosts) <= 1 {
+		return
+	}
+	next := (v.currentHostIndex + 1) % uint64(len(hosts))
 	log.WithFields(logrus.Fields{
-		"currentHost": v.beaconNodeHosts[v.currentHostIndex],
-		"nextHost":    v.beaconNodeHosts[next],
+		"currentHost": hosts[v.currentHostIndex],
+		"nextHost":    hosts[next],
 	}).Warn("Beacon node is not responding, switching host")
-	v.validatorClient.SetHost(v.beaconNodeHosts[next])
+	v.validatorClient.SetHost(hosts[next])
 	v.currentHostIndex = next
 }
 
+// hosts returns the list of configured beacon node hosts.
+func (v *validator) hosts() []string {
+	if features.Get().EnableBeaconRESTApi {
+		return v.conn.GetRestConnectionProvider().Hosts()
+	}
+	return v.conn.GetGrpcConnectionProvider().Hosts()
+}
+
+// numHosts returns the number of configured beacon node hosts.
+func (v *validator) numHosts() int {
+	return len(v.hosts())
+}
+
 func (v *validator) FindHealthyHost(ctx context.Context) bool {
-	// Tail-recursive closure keeps retry count private.
-	var check func(remaining int) bool
-	check = func(remaining int) bool {
-		if v.nodeClient.IsReady(ctx) { // ready → done
+	numHosts := v.numHosts()
+	startingHost := v.Host()
+	attemptedHosts := []string{}
+
+	// Check all hosts for a fully synced node
+	for i := range numHosts {
+		if v.nodeClient.IsReady(ctx) {
+			if len(attemptedHosts) > 0 {
+				log.WithFields(logrus.Fields{
+					"previousHost":   startingHost,
+					"newHost":        v.Host(),
+					"failedAttempts": attemptedHosts,
+				}).Info("Failover succeeded: connected to healthy beacon node")
+			}
 			return true
 		}
-		if len(v.beaconNodeHosts) == 1 && features.Get().EnableBeaconRESTApi {
-			log.WithField("host", v.Host()).Warn("Beacon node is not responding, no backup node configured")
-			return false
+		log.WithField("host", v.Host()).Debug("Beacon node not fully synced")
+		attemptedHosts = append(attemptedHosts, v.Host())
+
+		// Try next host if not the last iteration
+		if i < numHosts-1 {
+			v.changeHost()
 		}
-		if remaining == 0 || !features.Get().EnableBeaconRESTApi {
-			return false // exhausted or REST disabled
-		}
-		v.changeHost()
-		return check(remaining - 1) // recurse
 	}
 
-	return check(len(v.beaconNodeHosts))
+	if numHosts == 1 {
+		log.WithField("host", v.Host()).Warn("Beacon node is not fully synced, no backup node configured")
+	} else {
+		log.Warn("No fully synced beacon node found")
+	}
+	return false
 }
 
 func (v *validator) filterAndCacheActiveKeys(ctx context.Context, pubkeys [][fieldparams.BLSPubkeyLength]byte, slot primitives.Slot) ([][fieldparams.BLSPubkeyLength]byte, error) {

validator/client/validator_test.go

@@ -16,6 +16,8 @@ import (
 	"testing"
 	"time"
 
+	grpcutil "github.com/OffchainLabs/prysm/v7/api/grpc"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/async/event"
 	"github.com/OffchainLabs/prysm/v7/cmd/validator/flags"
@@ -37,6 +39,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/validator/accounts/wallet"
 	"github.com/OffchainLabs/prysm/v7/validator/client/iface"
 	dbTest "github.com/OffchainLabs/prysm/v7/validator/db/testing"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	"github.com/OffchainLabs/prysm/v7/validator/keymanager"
 	"github.com/OffchainLabs/prysm/v7/validator/keymanager/local"
 	remoteweb3signer "github.com/OffchainLabs/prysm/v7/validator/keymanager/remote-web3signer"
@@ -2792,18 +2795,27 @@ func TestValidator_Host(t *testing.T) {
 }
 
 func TestValidator_ChangeHost(t *testing.T) {
+	// Enable REST API mode for this test since changeHost only calls SetHost in REST API mode
+	resetCfg := features.InitWithReset(&features.Flags{EnableBeaconRESTApi: true})
+	defer resetCfg()
+
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
+	hosts := []string{"http://localhost:8080", "http://localhost:8081"}
+	restProvider := &rest.MockRestProvider{MockHosts: hosts}
+	conn, err := validatorHelpers.NewNodeConnection(validatorHelpers.WithRestProvider(restProvider))
+	require.NoError(t, err)
+
 	client := validatormock.NewMockValidatorClient(ctrl)
 	v := validator{
 		validatorClient:  client,
-		beaconNodeHosts:  []string{"http://localhost:8080", "http://localhost:8081"},
+		conn:             conn,
 		currentHostIndex: 0,
 	}
 
-	client.EXPECT().SetHost(v.beaconNodeHosts[1])
-	client.EXPECT().SetHost(v.beaconNodeHosts[0])
+	client.EXPECT().SetHost(hosts[1])
+	client.EXPECT().SetHost(hosts[0])
 	v.changeHost()
 	assert.Equal(t, uint64(1), v.currentHostIndex)
 	v.changeHost()
@@ -2838,12 +2850,16 @@ func TestUpdateValidatorStatusCache(t *testing.T) {
 		gomock.Any(),
 		gomock.Any()).Return(mockResponse, nil)
 
+	mockProvider := &grpcutil.MockGrpcProvider{MockHosts: []string{"localhost:4000", "localhost:4001"}}
+	conn, err := validatorHelpers.NewNodeConnection(validatorHelpers.WithGrpcProvider(mockProvider))
+	require.NoError(t, err)
+
 	v := &validator{
 		validatorClient:  client,
-		beaconNodeHosts:  []string{"http://localhost:8080", "http://localhost:8081"},
+		conn:             conn,
 		currentHostIndex: 0,
 		pubkeyToStatus: map[[fieldparams.BLSPubkeyLength]byte]*validatorStatus{
-			[fieldparams.BLSPubkeyLength]byte{0x03}: &validatorStatus{ // add non existent key and status to cache, should be fully removed on update
+			[fieldparams.BLSPubkeyLength]byte{0x03}: { // add non existent key and status to cache, should be fully removed on update
 				publicKey: []byte{0x03},
 				status: &ethpb.ValidatorStatusResponse{
 					Status: ethpb.ValidatorStatus_ACTIVE,
@@ -2853,7 +2869,7 @@ func TestUpdateValidatorStatusCache(t *testing.T) {
 		},
 	}
 
-	err := v.updateValidatorStatusCache(ctx, pubkeys)
+	err = v.updateValidatorStatusCache(ctx, pubkeys)
 	assert.NoError(t, err)
 
 	// make sure the nonexistent key is fully removed

validator/client/wait_helpers.go

@@ -51,7 +51,7 @@ func (v *validator) slotComponentSpanName(component primitives.BP) string {
 	switch component {
 	case cfg.AttestationDueBPS:
 		return "validator.waitAttestationWindow"
-	case cfg.AggregateDueBPS:
+	case cfg.AggregrateDueBPS:
 		return "validator.waitAggregateWindow"
 	case cfg.SyncMessageDueBPS:
 		return "validator.waitSyncMessageWindow"

validator/client/wait_helpers_test.go

@@ -47,7 +47,7 @@ func TestSlotComponentSpanName(t *testing.T) {
 		},
 		{
 			name:      "aggregate",
-			component: cfg.AggregateDueBPS,
+			component: cfg.AggregrateDueBPS,
 			expected:  "validator.waitAggregateWindow",
 		},
 		{

validator/helpers/BUILD.bazel

@@ -10,6 +10,8 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/validator/helpers",
     visibility = ["//visibility:public"],
     deps = [
+        "//api/grpc:go_default_library",
+        "//api/rest:go_default_library",
         "//config/fieldparams:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//validator/db/iface:go_default_library",
@@ -24,18 +26,23 @@ go_test(
     srcs = [
         "converts_test.go",
         "metadata_test.go",
+        "node_connection_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
+        "//api/grpc:go_default_library",
+        "//api/rest:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/proposer:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//validator/db/common:go_default_library",
         "//validator/db/iface:go_default_library",
         "//validator/slashing-protection-history/format:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
     ],
 )

validator/helpers/node_connection.go

@@ -1,78 +1,152 @@
 package helpers
 
 import (
-	"time"
+	"context"
+	"net/http"
 
+	grpcutil "github.com/OffchainLabs/prysm/v7/api/grpc"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
+	"github.com/pkg/errors"
 	"google.golang.org/grpc"
 )
 
-// Use an interface with a private dummy function to force all other packages to call NewNodeConnection
+// NodeConnection provides access to both gRPC and REST API connections to a beacon node.
 type NodeConnection interface {
+	// GetGrpcClientConn returns the current gRPC client connection.
+	// Returns nil if no gRPC provider is configured.
 	GetGrpcClientConn() *grpc.ClientConn
-	GetBeaconApiUrl() string
-	GetBeaconApiHeaders() map[string][]string
-	setBeaconApiHeaders(map[string][]string)
-	GetBeaconApiTimeout() time.Duration
-	setBeaconApiTimeout(time.Duration)
-	dummy()
+	// GetGrpcConnectionProvider returns the gRPC connection provider.
+	GetGrpcConnectionProvider() grpcutil.GrpcConnectionProvider
+	// GetRestConnectionProvider returns the REST connection provider.
+	GetRestConnectionProvider() rest.RestConnectionProvider
+	// GetRestHandler returns the REST handler for making API requests.
+	// Returns nil if no REST provider is configured.
+	GetRestHandler() rest.RestHandler
+	// GetHttpClient returns the configured HTTP client for REST API requests.
+	// Returns nil if no REST provider is configured.
+	GetHttpClient() *http.Client
 }
 
 type nodeConnection struct {
-	grpcClientConn   *grpc.ClientConn
-	beaconApiUrl     string
-	beaconApiHeaders map[string][]string
-	beaconApiTimeout time.Duration
-}
-
-// NodeConnectionOption is a functional option for configuring the node connection.
-type NodeConnectionOption func(nc NodeConnection)
-
-// WithBeaconApiHeaders sets the HTTP headers that should be sent to the server along with each request.
-func WithBeaconApiHeaders(headers map[string][]string) NodeConnectionOption {
-	return func(nc NodeConnection) {
-		nc.setBeaconApiHeaders(headers)
-	}
-}
-
-// WithBeaconApiTimeout sets the HTTP request timeout.
-func WithBeaconApiTimeout(timeout time.Duration) NodeConnectionOption {
-	return func(nc NodeConnection) {
-		nc.setBeaconApiTimeout(timeout)
-	}
+	grpcConnectionProvider grpcutil.GrpcConnectionProvider
+	restConnectionProvider rest.RestConnectionProvider
 }
 
 func (c *nodeConnection) GetGrpcClientConn() *grpc.ClientConn {
-	return c.grpcClientConn
-}
-
-func (c *nodeConnection) GetBeaconApiUrl() string {
-	return c.beaconApiUrl
-}
-
-func (c *nodeConnection) GetBeaconApiHeaders() map[string][]string {
-	return c.beaconApiHeaders
-}
-
-func (c *nodeConnection) setBeaconApiHeaders(headers map[string][]string) {
-	c.beaconApiHeaders = headers
-}
-
-func (c *nodeConnection) GetBeaconApiTimeout() time.Duration {
-	return c.beaconApiTimeout
-}
-
-func (c *nodeConnection) setBeaconApiTimeout(timeout time.Duration) {
-	c.beaconApiTimeout = timeout
-}
-
-func (*nodeConnection) dummy() {}
-
-func NewNodeConnection(grpcConn *grpc.ClientConn, beaconApiUrl string, opts ...NodeConnectionOption) NodeConnection {
-	conn := &nodeConnection{}
-	conn.grpcClientConn = grpcConn
-	conn.beaconApiUrl = beaconApiUrl
-	for _, opt := range opts {
-		opt(conn)
+	if c.grpcConnectionProvider == nil {
+		return nil
+	}
+	return c.grpcConnectionProvider.CurrentConn()
+}
+
+func (c *nodeConnection) GetGrpcConnectionProvider() grpcutil.GrpcConnectionProvider {
+	return c.grpcConnectionProvider
+}
+
+func (c *nodeConnection) GetRestConnectionProvider() rest.RestConnectionProvider {
+	return c.restConnectionProvider
+}
+
+func (c *nodeConnection) GetRestHandler() rest.RestHandler {
+	if c.restConnectionProvider == nil {
+		return nil
+	}
+	return c.restConnectionProvider.RestHandler()
+}
+
+func (c *nodeConnection) GetHttpClient() *http.Client {
+	if c.restConnectionProvider == nil {
+		return nil
+	}
+	return c.restConnectionProvider.HttpClient()
+}
+
+// nodeConnectionBuilder is used internally to build a NodeConnection.
+type nodeConnectionBuilder struct {
+	grpcProvider grpcutil.GrpcConnectionProvider
+	restProvider rest.RestConnectionProvider
+}
+
+// NodeConnectionOption is a functional option for configuring a NodeConnection.
+type NodeConnectionOption func(*nodeConnectionBuilder) error
+
+// WithGrpc configures a gRPC connection provider for the NodeConnection.
+// If endpoint is empty, this option is a no-op.
+func WithGrpc(ctx context.Context, endpoint string, dialOpts []grpc.DialOption) NodeConnectionOption {
+	return func(b *nodeConnectionBuilder) error {
+		if endpoint == "" {
+			return nil
+		}
+		provider, err := grpcutil.NewGrpcConnectionProvider(ctx, endpoint, dialOpts)
+		if err != nil {
+			return errors.Wrap(err, "failed to create gRPC connection provider")
+		}
+		b.grpcProvider = provider
+		return nil
+	}
+}
+
+// WithREST configures a REST connection provider for the NodeConnection.
+// If endpoint is empty, this option is a no-op.
+func WithREST(endpoint string, opts ...rest.RestConnectionProviderOption) NodeConnectionOption {
+	return func(b *nodeConnectionBuilder) error {
+		if endpoint == "" {
+			return nil
+		}
+		provider, err := rest.NewRestConnectionProvider(endpoint, opts...)
+		if err != nil {
+			return errors.Wrap(err, "failed to create REST connection provider")
+		}
+		b.restProvider = provider
+		return nil
+	}
+}
+
+// WithGrpcProvider sets a pre-built gRPC connection provider.
+// This is primarily useful for testing with mock providers.
+func WithGrpcProvider(provider grpcutil.GrpcConnectionProvider) NodeConnectionOption {
+	return func(b *nodeConnectionBuilder) error {
+		b.grpcProvider = provider
+		return nil
+	}
+}
+
+// WithRestProvider sets a pre-built REST connection provider.
+// This is primarily useful for testing with mock providers.
+func WithRestProvider(provider rest.RestConnectionProvider) NodeConnectionOption {
+	return func(b *nodeConnectionBuilder) error {
+		b.restProvider = provider
+		return nil
+	}
+}
+
+// NewNodeConnection creates a new NodeConnection with the given options.
+// At least one provider (gRPC or REST) must be configured via options.
+// Returns an error if no providers are configured.
+func NewNodeConnection(opts ...NodeConnectionOption) (NodeConnection, error) {
+	b := &nodeConnectionBuilder{}
+	for _, opt := range opts {
+		if err := opt(b); err != nil {
+			return nil, err
+		}
+	}
+
+	if b.grpcProvider == nil && b.restProvider == nil {
+		return nil, errors.New("at least one beacon node endpoint must be provided (--beacon-rpc-provider or --beacon-rest-api-provider)")
+	}
+
+	return &nodeConnection{
+		grpcConnectionProvider: b.grpcProvider,
+		restConnectionProvider: b.restProvider,
+	}, nil
+}
+
+// MockNodeConnection creates a minimal NodeConnection for testing.
+// It uses a mock gRPC provider with no actual connection.
+func MockNodeConnection() NodeConnection {
+	return &nodeConnection{
+		grpcConnectionProvider: &grpcutil.MockGrpcProvider{
+			MockHosts: []string{"mock:4000"},
+		},
 	}
-	return conn
 }

validator/helpers/node_connection_test.go

@@ -0,0 +1,102 @@
+package helpers
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	grpcutil "github.com/OffchainLabs/prysm/v7/api/grpc"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"google.golang.org/grpc"
+)
+
+func TestNewNodeConnection(t *testing.T) {
+	t.Run("with both providers", func(t *testing.T) {
+		grpcProvider := &grpcutil.MockGrpcProvider{MockHosts: []string{"localhost:4000"}}
+		restProvider := &rest.MockRestProvider{MockHosts: []string{"http://localhost:3500"}}
+		conn, err := NewNodeConnection(
+			WithGrpcProvider(grpcProvider),
+			WithRestProvider(restProvider),
+		)
+		require.NoError(t, err)
+
+		assert.Equal(t, grpcProvider, conn.GetGrpcConnectionProvider())
+		assert.Equal(t, restProvider, conn.GetRestConnectionProvider())
+	})
+
+	t.Run("with only rest provider", func(t *testing.T) {
+		restProvider := &rest.MockRestProvider{MockHosts: []string{"http://localhost:3500"}}
+		conn, err := NewNodeConnection(WithRestProvider(restProvider))
+		require.NoError(t, err)
+
+		assert.Equal(t, (grpcutil.GrpcConnectionProvider)(nil), conn.GetGrpcConnectionProvider())
+		assert.Equal(t, (*grpc.ClientConn)(nil), conn.GetGrpcClientConn())
+		assert.Equal(t, restProvider, conn.GetRestConnectionProvider())
+	})
+
+	t.Run("with only grpc provider", func(t *testing.T) {
+		grpcProvider := &grpcutil.MockGrpcProvider{MockHosts: []string{"localhost:4000"}}
+		conn, err := NewNodeConnection(WithGrpcProvider(grpcProvider))
+		require.NoError(t, err)
+
+		assert.Equal(t, grpcProvider, conn.GetGrpcConnectionProvider())
+		assert.Equal(t, (rest.RestConnectionProvider)(nil), conn.GetRestConnectionProvider())
+		assert.Equal(t, (*http.Client)(nil), conn.GetHttpClient())
+	})
+
+	t.Run("with no providers returns error", func(t *testing.T) {
+		conn, err := NewNodeConnection()
+		require.ErrorContains(t, "at least one beacon node endpoint must be provided", err)
+		assert.Equal(t, (NodeConnection)(nil), conn)
+	})
+
+	t.Run("with empty endpoints is no-op", func(t *testing.T) {
+		// Empty endpoints should be skipped, resulting in no providers
+		conn, err := NewNodeConnection(
+			WithGrpc(context.Background(), "", nil),
+			WithREST(""),
+		)
+		require.ErrorContains(t, "at least one beacon node endpoint must be provided", err)
+		assert.Equal(t, (NodeConnection)(nil), conn)
+	})
+}
+
+func TestNodeConnection_GetGrpcClientConn(t *testing.T) {
+	t.Run("delegates to provider", func(t *testing.T) {
+		// We can't easily create a real grpc.ClientConn in tests,
+		// but we can verify the delegation works with nil
+		grpcProvider := &grpcutil.MockGrpcProvider{MockConn: nil, MockHosts: []string{"localhost:4000"}}
+		conn, err := NewNodeConnection(WithGrpcProvider(grpcProvider))
+		require.NoError(t, err)
+
+		// Should delegate to provider.CurrentConn()
+		assert.Equal(t, grpcProvider.CurrentConn(), conn.GetGrpcClientConn())
+	})
+
+	t.Run("returns nil when provider is nil", func(t *testing.T) {
+		restProvider := &rest.MockRestProvider{MockHosts: []string{"http://localhost:3500"}}
+		conn, err := NewNodeConnection(WithRestProvider(restProvider))
+		require.NoError(t, err)
+		assert.Equal(t, (*grpc.ClientConn)(nil), conn.GetGrpcClientConn())
+	})
+}
+
+func TestNodeConnection_GetHttpClient(t *testing.T) {
+	t.Run("delegates to provider", func(t *testing.T) {
+		mockClient := &http.Client{}
+		restProvider := &rest.MockRestProvider{MockClient: mockClient, MockHosts: []string{"http://localhost:3500"}}
+		conn, err := NewNodeConnection(WithRestProvider(restProvider))
+		require.NoError(t, err)
+
+		assert.Equal(t, mockClient, conn.GetHttpClient())
+	})
+
+	t.Run("returns nil when provider is nil", func(t *testing.T) {
+		grpcProvider := &grpcutil.MockGrpcProvider{MockHosts: []string{"localhost:4000"}}
+		conn, err := NewNodeConnection(WithGrpcProvider(grpcProvider))
+		require.NoError(t, err)
+		assert.Equal(t, (*http.Client)(nil), conn.GetHttpClient())
+	})
+}

validator/node/node_test.go

@@ -41,6 +41,8 @@ func TestNode_Builds(t *testing.T) {
 	set.String("wallet-password-file", passwordFile, "path to wallet password")
 	set.String("keymanager-kind", "imported", "keymanager kind")
 	set.String("verbosity", "debug", "log verbosity")
+	set.String("beacon-rpc-provider", "localhost:4000", "beacon node RPC endpoint")
+	set.String("beacon-rest-api-provider", "http://localhost:3500", "beacon node REST API endpoint")
 	require.NoError(t, set.Set(flags.WalletPasswordFileFlag.Name, passwordFile))
 	ctx := cli.NewContext(&app, set, nil)
 	opts := []accounts.Option{

validator/rpc/BUILD.bazel

@@ -23,9 +23,9 @@ go_library(
     ],
     deps = [
         "//api:go_default_library",
-        "//api/client:go_default_library",
         "//api/grpc:go_default_library",
         "//api/pagination:go_default_library",
+        "//api/rest:go_default_library",
         "//api/server:go_default_library",
         "//api/server/httprest:go_default_library",
         "//api/server/middleware:go_default_library",
@@ -55,7 +55,6 @@ go_library(
         "//validator/accounts/petnames:go_default_library",
         "//validator/accounts/wallet:go_default_library",
         "//validator/client: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",
@@ -79,7 +78,6 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_wealdtech_go_eth2_wallet_encryptor_keystorev4//:go_default_library",
-        "@io_opentelemetry_go_contrib_instrumentation_net_http_otelhttp//:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
         "@org_golang_google_grpc//metadata:go_default_library",
@@ -106,6 +104,7 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//api:go_default_library",
+        "//api/grpc:go_default_library",
         "//async/event:go_default_library",
         "//cmd/validator/flags:go_default_library",
         "//config/features:go_default_library",
@@ -135,6 +134,7 @@ go_test(
         "//validator/db/iface:go_default_library",
         "//validator/db/kv:go_default_library",
         "//validator/db/testing:go_default_library",
+        "//validator/helpers:go_default_library",
         "//validator/keymanager:go_default_library",
         "//validator/keymanager/derived:go_default_library",
         "//validator/keymanager/remote-web3signer:go_default_library",

validator/rpc/beacon.go

@@ -1,13 +1,10 @@
 package rpc
 
 import (
-	"net/http"
-
-	api "github.com/OffchainLabs/prysm/v7/api/client"
 	grpcutil "github.com/OffchainLabs/prysm/v7/api/grpc"
+	"github.com/OffchainLabs/prysm/v7/api/rest"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/validator/client"
-	beaconApi "github.com/OffchainLabs/prysm/v7/validator/client/beacon-api"
 	beaconChainClientFactory "github.com/OffchainLabs/prysm/v7/validator/client/beacon-chain-client-factory"
 	nodeClientFactory "github.com/OffchainLabs/prysm/v7/validator/client/node-client-factory"
 	validatorClientFactory "github.com/OffchainLabs/prysm/v7/validator/client/validator-client-factory"
@@ -17,7 +14,6 @@ import (
 	grpcopentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing"
 	grpcprometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
 	"github.com/pkg/errors"
-	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"google.golang.org/grpc"
 )
 
@@ -41,30 +37,26 @@ func (s *Server) registerBeaconClient() error {
 
 	s.ctx = grpcutil.AppendHeaders(s.ctx, s.grpcHeaders)
 
-	grpcConn, err := grpc.DialContext(s.ctx, s.beaconNodeEndpoint, dialOpts...)
+	conn, err := validatorHelpers.NewNodeConnection(
+		validatorHelpers.WithGrpc(s.ctx, s.beaconNodeEndpoint, dialOpts),
+		validatorHelpers.WithREST(s.beaconApiEndpoint,
+			rest.WithHttpHeaders(s.beaconApiHeaders),
+			rest.WithHttpTimeout(s.beaconApiTimeout),
+			rest.WithTracing(),
+		),
+	)
 	if err != nil {
-		return errors.Wrapf(err, "could not dial endpoint: %s", s.beaconNodeEndpoint)
+		return err
 	}
-	if s.beaconNodeCert != "" {
+	if s.beaconNodeCert != "" && s.beaconNodeEndpoint != "" {
 		log.Info("Established secure gRPC connection")
 	}
-	s.healthClient = ethpb.NewHealthClient(grpcConn)
+	if grpcConn := conn.GetGrpcClientConn(); grpcConn != nil {
+		s.healthClient = ethpb.NewHealthClient(grpcConn)
+	}
 
-	conn := validatorHelpers.NewNodeConnection(
-		grpcConn,
-		s.beaconApiEndpoint,
-		validatorHelpers.WithBeaconApiHeaders(s.beaconApiHeaders),
-		validatorHelpers.WithBeaconApiTimeout(s.beaconApiTimeout),
-	)
-
-	headersTransport := api.NewCustomHeadersTransport(http.DefaultTransport, conn.GetBeaconApiHeaders())
-	restHandler := beaconApi.NewBeaconApiRestHandler(
-		http.Client{Timeout: s.beaconApiTimeout, Transport: otelhttp.NewTransport(headersTransport)},
-		s.beaconApiEndpoint,
-	)
-
-	s.chainClient = beaconChainClientFactory.NewChainClient(conn, restHandler)
-	s.nodeClient = nodeClientFactory.NewNodeClient(conn, restHandler)
-	s.beaconNodeValidatorClient = validatorClientFactory.NewValidatorClient(conn, restHandler)
+	s.chainClient = beaconChainClientFactory.NewChainClient(conn)
+	s.nodeClient = nodeClientFactory.NewNodeClient(conn)
+	s.beaconNodeValidatorClient = validatorClientFactory.NewValidatorClient(conn)
 	return nil
 }

validator/rpc/beacon_test.go

@@ -3,19 +3,17 @@ package rpc
 import (
 	"testing"
 
+	grpcutil "github.com/OffchainLabs/prysm/v7/api/grpc"
 	"github.com/OffchainLabs/prysm/v7/testing/assert"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 	"google.golang.org/grpc/metadata"
 )
 
 func TestGrpcHeaders(t *testing.T) {
-	s := &Server{
-		ctx:         t.Context(),
-		grpcHeaders: []string{"first=value1", "second=value2"},
-	}
-	err := s.registerBeaconClient()
-	require.NoError(t, err)
-	md, _ := metadata.FromOutgoingContext(s.ctx)
+	ctx := t.Context()
+	grpcHeaders := []string{"first=value1", "second=value2"}
+	ctx = grpcutil.AppendHeaders(ctx, grpcHeaders)
+	md, _ := metadata.FromOutgoingContext(ctx)
 	require.Equal(t, 2, md.Len(), "MetadataV0 contains wrong number of values")
 	assert.Equal(t, "value1", md.Get("first")[0])
 	assert.Equal(t, "value2", md.Get("second")[0])

validator/rpc/handler_wallet_test.go

@@ -21,6 +21,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/validator/accounts/wallet"
 	"github.com/OffchainLabs/prysm/v7/validator/client"
 	"github.com/OffchainLabs/prysm/v7/validator/client/testutil"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	"github.com/OffchainLabs/prysm/v7/validator/keymanager"
 	"github.com/google/uuid"
 	"github.com/tyler-smith/go-bip39"
@@ -46,6 +47,7 @@ func TestServer_CreateWallet_Local(t *testing.T) {
 	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -443,6 +445,7 @@ func TestServer_WalletConfig(t *testing.T) {
 	require.NoError(t, err)
 	s.wallet = w
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,

validator/rpc/handlers_accounts_test.go

@@ -23,6 +23,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/validator/accounts/iface"
 	"github.com/OffchainLabs/prysm/v7/validator/client"
 	"github.com/OffchainLabs/prysm/v7/validator/client/testutil"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	"github.com/OffchainLabs/prysm/v7/validator/keymanager"
 	"github.com/OffchainLabs/prysm/v7/validator/keymanager/derived"
 	constant "github.com/OffchainLabs/prysm/v7/validator/testing"
@@ -53,6 +54,7 @@ func TestServer_ListAccounts(t *testing.T) {
 	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -158,6 +160,7 @@ func TestServer_BackupAccounts(t *testing.T) {
 	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -282,6 +285,7 @@ func TestServer_VoluntaryExit(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,

validator/rpc/handlers_keymanager_test.go

@@ -34,6 +34,7 @@ import (
 	DBIface "github.com/OffchainLabs/prysm/v7/validator/db/iface"
 	"github.com/OffchainLabs/prysm/v7/validator/db/kv"
 	dbtest "github.com/OffchainLabs/prysm/v7/validator/db/testing"
+	validatorHelpers "github.com/OffchainLabs/prysm/v7/validator/helpers"
 	"github.com/OffchainLabs/prysm/v7/validator/keymanager"
 	"github.com/OffchainLabs/prysm/v7/validator/keymanager/derived"
 	remoteweb3signer "github.com/OffchainLabs/prysm/v7/validator/keymanager/remote-web3signer"
@@ -52,6 +53,7 @@ func TestServer_ListKeystores(t *testing.T) {
 	t.Run("wallet not ready", func(t *testing.T) {
 		m := &testutil.FakeValidator{}
 		vs, err := client.NewValidatorService(ctx, &client.Config{
+			Conn:      validatorHelpers.MockNodeConnection(),
 			Validator: m,
 		})
 		require.NoError(t, err)
@@ -81,6 +83,7 @@ func TestServer_ListKeystores(t *testing.T) {
 	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -147,6 +150,7 @@ func TestServer_ImportKeystores(t *testing.T) {
 	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -368,6 +372,7 @@ func TestServer_ImportKeystores_WrongKeymanagerKind(t *testing.T) {
 	}})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -652,6 +657,7 @@ func TestServer_DeleteKeystores_WrongKeymanagerKind(t *testing.T) {
 		}})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -695,6 +701,7 @@ func setupServerWithWallet(t testing.TB) *Server {
 	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -730,6 +737,7 @@ func TestServer_SetVoluntaryExit(t *testing.T) {
 
 	m := &testutil.FakeValidator{Km: km}
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:      validatorHelpers.MockNodeConnection(),
 		Validator: m,
 	})
 	require.NoError(t, err)
@@ -953,6 +961,7 @@ func TestServer_GetGasLimit(t *testing.T) {
 			err := m.SetProposerSettings(ctx, tt.args)
 			require.NoError(t, err)
 			vs, err := client.NewValidatorService(ctx, &client.Config{
+				Conn:      validatorHelpers.MockNodeConnection(),
 				Validator: m,
 			})
 			require.NoError(t, err)
@@ -1111,6 +1120,7 @@ func TestServer_SetGasLimit(t *testing.T) {
 				require.NoError(t, err)
 				validatorDB := dbtest.SetupDB(t, t.TempDir(), [][fieldparams.BLSPubkeyLength]byte{}, isSlashingProtectionMinimal)
 				vs, err := client.NewValidatorService(ctx, &client.Config{
+					Conn:      validatorHelpers.MockNodeConnection(),
 					Validator: m,
 					DB:        validatorDB,
 				})
@@ -1300,6 +1310,7 @@ func TestServer_DeleteGasLimit(t *testing.T) {
 				require.NoError(t, err)
 				validatorDB := dbtest.SetupDB(t, t.TempDir(), [][fieldparams.BLSPubkeyLength]byte{}, isSlashingProtectionMinimal)
 				vs, err := client.NewValidatorService(ctx, &client.Config{
+					Conn:      validatorHelpers.MockNodeConnection(),
 					Validator: m,
 					DB:        validatorDB,
 				})
@@ -1348,6 +1359,7 @@ func TestServer_ListRemoteKeys(t *testing.T) {
 	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false, Web3SignerConfig: config})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -1404,6 +1416,7 @@ func TestServer_ImportRemoteKeys(t *testing.T) {
 	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false, Web3SignerConfig: config})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -1466,6 +1479,7 @@ func TestServer_DeleteRemoteKeys(t *testing.T) {
 	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false, Web3SignerConfig: config})
 	require.NoError(t, err)
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:   validatorHelpers.MockNodeConnection(),
 		Wallet: w,
 		Validator: &testutil.FakeValidator{
 			Km: km,
@@ -1567,6 +1581,7 @@ func TestServer_ListFeeRecipientByPubkey(t *testing.T) {
 			require.NoError(t, err)
 
 			vs, err := client.NewValidatorService(ctx, &client.Config{
+				Conn:      validatorHelpers.MockNodeConnection(),
 				Validator: m,
 			})
 			require.NoError(t, err)
@@ -1591,6 +1606,7 @@ func TestServer_ListFeeRecipientByPubKey_NoFeeRecipientSet(t *testing.T) {
 	ctx := t.Context()
 
 	vs, err := client.NewValidatorService(ctx, &client.Config{
+		Conn:      validatorHelpers.MockNodeConnection(),
 		Validator: &testutil.FakeValidator{},
 	})
 	require.NoError(t, err)
@@ -1780,6 +1796,7 @@ func TestServer_FeeRecipientByPubkey(t *testing.T) {
 
 				// save a default here
 				vs, err := client.NewValidatorService(ctx, &client.Config{
+					Conn:      validatorHelpers.MockNodeConnection(),
 					Validator: m,
 					DB:        validatorDB,
 				})
@@ -1890,6 +1907,7 @@ func TestServer_DeleteFeeRecipientByPubkey(t *testing.T) {
 				require.NoError(t, err)
 				validatorDB := dbtest.SetupDB(t, t.TempDir(), [][fieldparams.BLSPubkeyLength]byte{}, isSlashingProtectionMinimal)
 				vs, err := client.NewValidatorService(ctx, &client.Config{
+					Conn:      validatorHelpers.MockNodeConnection(),
 					Validator: m,
 					DB:        validatorDB,
 				})
@@ -1940,6 +1958,7 @@ func TestServer_Graffiti(t *testing.T) {
 	graffiti := "graffiti"
 	m := &testutil.FakeValidator{}
 	vs, err := client.NewValidatorService(t.Context(), &client.Config{
+		Conn:      validatorHelpers.MockNodeConnection(),
 		Validator: m,
 	})
 	require.NoError(t, err)

validator/rpc/intercepter.go

@@ -37,16 +37,8 @@ func (s *Server) AuthTokenInterceptor() grpc.UnaryServerInterceptor {
 // AuthTokenHandler is an HTTP handler to authorize a route.
 func (s *Server) AuthTokenHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		path := r.URL.Path
-		needsAuth := strings.Contains(path, api.WebApiUrlPrefix) || strings.Contains(path, api.KeymanagerApiPrefix)
-		// Protect direct (non-/api) web endpoints too; otherwise callers can bypass auth by hitting /v2/validator/*.
-		if strings.HasPrefix(path, api.WebUrlPrefix) &&
-			!strings.HasPrefix(path, api.WebUrlPrefix+"initialize") &&
-			!strings.HasPrefix(path, api.WebUrlPrefix+"health/") {
-			needsAuth = true
-		}
-
-		if needsAuth && !strings.Contains(path, api.SystemLogsPrefix) {
+		// if it's not initialize or has a web prefix
+		if (strings.Contains(r.URL.Path, api.WebApiUrlPrefix) || strings.Contains(r.URL.Path, api.KeymanagerApiPrefix)) && !strings.Contains(r.URL.Path, api.SystemLogsPrefix) {
 			// ignore some routes
 			reqToken := r.Header.Get("Authorization")
 			if reqToken == "" {

validator/rpc/intercepter_test.go

@@ -107,16 +107,6 @@ func TestServer_AuthTokenHandler(t *testing.T) {
 		require.NoError(t, json.Unmarshal(rr.Body.Bytes(), errJson))
 		require.StringContains(t, "Unauthorized", errJson.Message)
 	})
-	t.Run("direct /v2 endpoint also needs auth token (no /api bypass)", func(t *testing.T) {
-		rr := httptest.NewRecorder()
-		req, err := http.NewRequest(http.MethodGet, "/v2/validator/beacon/status", http.NoBody)
-		require.NoError(t, err)
-		testHandler.ServeHTTP(rr, req)
-		require.Equal(t, http.StatusUnauthorized, rr.Code)
-		errJson := &httputil.DefaultJsonError{}
-		require.NoError(t, json.Unmarshal(rr.Body.Bytes(), errJson))
-		require.StringContains(t, "Unauthorized", errJson.Message)
-	})
 	t.Run("initialize does not need auth", func(t *testing.T) {
 		rr := httptest.NewRecorder()
 		req, err := http.NewRequest(http.MethodGet, api.WebUrlPrefix+"initialize", http.NoBody)