Merge branch 'develop' into addArchivalFlag

* fix 1-worker underflow; lower default batch size

* adding test for single item in batcher

---------

Co-authored-by: Kasey Kirkham <kasey@users.noreply.github.com>

.bazelrc

@@ -6,6 +6,12 @@ import %workspace%/build/bazelrc/debug.bazelrc
 import %workspace%/build/bazelrc/hermetic-cc.bazelrc
 import %workspace%/build/bazelrc/performance.bazelrc
 
+# hermetic_cc_toolchain v3.0.1 required changes.
+common --enable_platform_specific_config
+build:linux --sandbox_add_mount_pair=/tmp
+build:macos --sandbox_add_mount_pair=/var/tmp
+build:windows --sandbox_add_mount_pair=C:\Temp
+
 # E2E run with debug gotag
 test:e2e --define gotags=debug
 

.bazelversion

@@ -1 +1 @@
-7.0.0
+7.1.0

WORKSPACE

@@ -16,12 +16,14 @@ load("@rules_pkg//:deps.bzl", "rules_pkg_dependencies")
 
 rules_pkg_dependencies()
 
+HERMETIC_CC_TOOLCHAIN_VERSION = "v3.0.1"
+
 http_archive(
     name = "hermetic_cc_toolchain",
-    sha256 = "973ab22945b921ef45b8e1d6ce01ca7ce1b8a462167449a36e297438c4ec2755",
-    strip_prefix = "hermetic_cc_toolchain-5098046bccc15d2962f3cc8e7e53d6a2a26072dc",
+    sha256 = "3bc6ec127622fdceb4129cb06b6f7ab098c4d539124dde96a6318e7c32a53f7a",
     urls = [
-        "https://github.com/uber/hermetic_cc_toolchain/archive/5098046bccc15d2962f3cc8e7e53d6a2a26072dc.tar.gz",  # 2023-06-28
+        "https://mirror.bazel.build/github.com/uber/hermetic_cc_toolchain/releases/download/{0}/hermetic_cc_toolchain-{0}.tar.gz".format(HERMETIC_CC_TOOLCHAIN_VERSION),
+        "https://github.com/uber/hermetic_cc_toolchain/releases/download/{0}/hermetic_cc_toolchain-{0}.tar.gz".format(HERMETIC_CC_TOOLCHAIN_VERSION),
     ],
 )
 
@@ -81,10 +83,10 @@ bazel_skylib_workspace()
 
 http_archive(
     name = "bazel_gazelle",
-    sha256 = "d3fa66a39028e97d76f9e2db8f1b0c11c099e8e01bf363a923074784e451f809",
+    integrity = "sha256-MpOL2hbmcABjA1R5Bj2dJMYO2o15/Uc5Vj9Q0zHLMgk=",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.33.0/bazel-gazelle-v0.33.0.tar.gz",
-        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.33.0/bazel-gazelle-v0.33.0.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.35.0/bazel-gazelle-v0.35.0.tar.gz",
+        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.35.0/bazel-gazelle-v0.35.0.tar.gz",
     ],
 )
 
@@ -151,17 +153,13 @@ http_archive(
         # Expose internals of go_test for custom build transitions.
         "//third_party:io_bazel_rules_go_test.patch",
     ],
-    sha256 = "d6ab6b57e48c09523e93050f13698f708428cfd5e619252e369d377af6597707",
+    sha256 = "80a98277ad1311dacd837f9b16db62887702e9f1d1c4c9f796d0121a46c8e184",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.43.0/rules_go-v0.43.0.zip",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.43.0/rules_go-v0.43.0.zip",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.46.0/rules_go-v0.46.0.zip",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.46.0/rules_go-v0.46.0.zip",
     ],
 )
 
-load("//:distroless_deps.bzl", "distroless_deps")
-
-distroless_deps()
-
 # Override default import in rules_go with special patch until
 # https://github.com/gogo/protobuf/pull/582 is merged.
 git_repository(
@@ -200,10 +198,14 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.21.6",
+    go_version = "1.21.8",
     nogo = "@//:nogo",
 )
 
+load("//:distroless_deps.bzl", "distroless_deps")
+
+distroless_deps()
+
 http_archive(
     name = "io_kubernetes_build",
     sha256 = "b84fbd1173acee9d02a7d3698ad269fdf4f7aa081e9cecd40e012ad0ad8cfa2a",

api/client/beacon/BUILD.bazel

@@ -6,12 +6,14 @@ go_library(
         "checkpoint.go",
         "client.go",
         "doc.go",
+        "health.go",
         "log.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/api/client/beacon",
     visibility = ["//visibility:public"],
     deps = [
         "//api/client:go_default_library",
+        "//api/client/beacon/iface:go_default_library",
         "//api/server:go_default_library",
         "//api/server/structs:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -37,10 +39,12 @@ go_test(
     srcs = [
         "checkpoint_test.go",
         "client_test.go",
+        "health_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
         "//api/client:go_default_library",
+        "//api/client/beacon/testing:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -54,5 +58,6 @@ go_test(
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@org_uber_go_mock//gomock:go_default_library",
     ],
 )

api/client/beacon/health.go

@@ -0,0 +1,55 @@
+package beacon
+
+import (
+	"context"
+	"sync"
+
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon/iface"
+)
+
+type NodeHealthTracker struct {
+	isHealthy  *bool
+	healthChan chan bool
+	node       iface.HealthNode
+	sync.RWMutex
+}
+
+func NewNodeHealthTracker(node iface.HealthNode) *NodeHealthTracker {
+	return &NodeHealthTracker{
+		node:       node,
+		healthChan: make(chan bool, 1),
+	}
+}
+
+// HealthUpdates provides a read-only channel for health updates.
+func (n *NodeHealthTracker) HealthUpdates() <-chan bool {
+	return n.healthChan
+}
+
+func (n *NodeHealthTracker) IsHealthy() bool {
+	n.RLock()
+	defer n.RUnlock()
+	if n.isHealthy == nil {
+		return false
+	}
+	return *n.isHealthy
+}
+
+func (n *NodeHealthTracker) CheckHealth(ctx context.Context) bool {
+	n.RLock()
+	newStatus := n.node.IsHealthy(ctx)
+	if n.isHealthy == nil {
+		n.isHealthy = &newStatus
+	}
+	isStatusChanged := newStatus != *n.isHealthy
+	n.RUnlock()
+
+	if isStatusChanged {
+		n.Lock()
+		// Double-check the condition to ensure it hasn't changed since the first check.
+		n.isHealthy = &newStatus
+		n.Unlock() // It's better to unlock as soon as the protected section is over.
+		n.healthChan <- newStatus
+	}
+	return newStatus
+}

api/client/beacon/health_test.go

@@ -0,0 +1,118 @@
+package beacon
+
+import (
+	"context"
+	"sync"
+	"testing"
+
+	healthTesting "github.com/prysmaticlabs/prysm/v5/api/client/beacon/testing"
+	"go.uber.org/mock/gomock"
+)
+
+func TestNodeHealth_IsHealthy(t *testing.T) {
+	tests := []struct {
+		name      string
+		isHealthy bool
+		want      bool
+	}{
+		{"initially healthy", true, true},
+		{"initially unhealthy", false, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			n := &NodeHealthTracker{
+				isHealthy:  &tt.isHealthy,
+				healthChan: make(chan bool, 1),
+			}
+			if got := n.IsHealthy(); got != tt.want {
+				t.Errorf("IsHealthy() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNodeHealth_UpdateNodeHealth(t *testing.T) {
+	tests := []struct {
+		name       string
+		initial    bool // Initial health status
+		newStatus  bool // Status to update to
+		shouldSend bool // Should a message be sent through the channel
+	}{
+		{"healthy to unhealthy", true, false, true},
+		{"unhealthy to healthy", false, true, true},
+		{"remain healthy", true, true, false},
+		{"remain unhealthy", false, false, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+			client := healthTesting.NewMockHealthClient(ctrl)
+			client.EXPECT().IsHealthy(gomock.Any()).Return(tt.newStatus)
+			n := &NodeHealthTracker{
+				isHealthy:  &tt.initial,
+				node:       client,
+				healthChan: make(chan bool, 1),
+			}
+
+			s := n.CheckHealth(context.Background())
+			// Check if health status was updated
+			if s != tt.newStatus {
+				t.Errorf("UpdateNodeHealth() failed to update isHealthy from %v to %v", tt.initial, tt.newStatus)
+			}
+
+			select {
+			case status := <-n.HealthUpdates():
+				if !tt.shouldSend {
+					t.Errorf("UpdateNodeHealth() unexpectedly sent status %v to HealthCh", status)
+				} else if status != tt.newStatus {
+					t.Errorf("UpdateNodeHealth() sent wrong status %v, want %v", status, tt.newStatus)
+				}
+			default:
+				if tt.shouldSend {
+					t.Error("UpdateNodeHealth() did not send any status to HealthCh when expected")
+				}
+			}
+		})
+	}
+}
+
+func TestNodeHealth_Concurrency(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	client := healthTesting.NewMockHealthClient(ctrl)
+	n := NewNodeHealthTracker(client)
+	var wg sync.WaitGroup
+
+	// Number of goroutines to spawn for both reading and writing
+	numGoroutines := 6
+
+	go func() {
+		for range n.HealthUpdates() {
+			// Consume values to avoid blocking on channel send.
+		}
+	}()
+
+	wg.Add(numGoroutines * 2) // for readers and writers
+
+	// Concurrently update health status
+	for i := 0; i < numGoroutines; i++ {
+		go func() {
+			defer wg.Done()
+			client.EXPECT().IsHealthy(gomock.Any()).Return(false)
+			n.CheckHealth(context.Background())
+			client.EXPECT().IsHealthy(gomock.Any()).Return(true)
+			n.CheckHealth(context.Background())
+		}()
+	}
+
+	// Concurrently read health status
+	for i := 0; i < numGoroutines; i++ {
+		go func() {
+			defer wg.Done()
+			_ = n.IsHealthy() // Just read the value
+		}()
+	}
+
+	wg.Wait() // Wait for all goroutines to finish
+}

api/client/beacon/iface/BUILD.bazel

@@ -0,0 +1,8 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["health.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/api/client/beacon/iface",
+    visibility = ["//visibility:public"],
+)

api/client/beacon/iface/health.go

@@ -0,0 +1,13 @@
+package iface
+
+import "context"
+
+type HealthTracker interface {
+	HealthUpdates() <-chan bool
+	IsHealthy() bool
+	CheckHealth(ctx context.Context) bool
+}
+
+type HealthNode interface {
+	IsHealthy(ctx context.Context) bool
+}

api/client/beacon/testing/BUILD.bazel

@@ -0,0 +1,12 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["mock.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/api/client/beacon/testing",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api/client/beacon/iface:go_default_library",
+        "@org_uber_go_mock//gomock:go_default_library",
+    ],
+)

api/client/beacon/testing/mock.go

@@ -0,0 +1,53 @@
+package testing
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon/iface"
+	"go.uber.org/mock/gomock"
+)
+
+var (
+	_ = iface.HealthNode(&MockHealthClient{})
+)
+
+// MockHealthClient is a mock of HealthClient interface.
+type MockHealthClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockHealthClientMockRecorder
+}
+
+// MockHealthClientMockRecorder is the mock recorder for MockHealthClient.
+type MockHealthClientMockRecorder struct {
+	mock *MockHealthClient
+}
+
+// IsHealthy mocks base method.
+func (m *MockHealthClient) IsHealthy(arg0 context.Context) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsHealthy", arg0)
+	ret0, ok := ret[0].(bool)
+	if !ok {
+		return false
+	}
+	return ret0
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockHealthClient) EXPECT() *MockHealthClientMockRecorder {
+	return m.recorder
+}
+
+// IsHealthy indicates an expected call of IsHealthy.
+func (mr *MockHealthClientMockRecorder) IsHealthy(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHealthy", reflect.TypeOf((*MockHealthClient)(nil).IsHealthy), arg0)
+}
+
+// NewMockHealthClient creates a new mock instance.
+func NewMockHealthClient(ctrl *gomock.Controller) *MockHealthClient {
+	mock := &MockHealthClient{ctrl: ctrl}
+	mock.recorder = &MockHealthClientMockRecorder{mock}
+	return mock
+}

api/client/errors.go

@@ -21,6 +21,9 @@ var ErrNotFound = errors.Wrap(ErrNotOK, "recv 404 NotFound response from API")
 // ErrInvalidNodeVersion indicates that the /eth/v1/node/version API response format was not recognized.
 var ErrInvalidNodeVersion = errors.New("invalid node version response")
 
+// ErrConnectionIssue represents a connection problem.
+var ErrConnectionIssue = errors.New("could not connect")
+
 // Non200Err is a function that parses an HTTP response to handle responses that are not 200 with a formatted error.
 func Non200Err(response *http.Response) error {
 	bodyBytes, err := io.ReadAll(response.Body)

api/client/event/BUILD.bazel

@@ -0,0 +1,24 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["event_stream.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/api/client/event",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api:go_default_library",
+        "//api/client:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["event_stream_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//testing/require:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)

api/client/event/event_stream.go

@@ -0,0 +1,148 @@
+package event
+
+import (
+	"bufio"
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api"
+	"github.com/prysmaticlabs/prysm/v5/api/client"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	EventHead                        = "head"
+	EventBlock                       = "block"
+	EventAttestation                 = "attestation"
+	EventVoluntaryExit               = "voluntary_exit"
+	EventBlsToExecutionChange        = "bls_to_execution_change"
+	EventProposerSlashing            = "proposer_slashing"
+	EventAttesterSlashing            = "attester_slashing"
+	EventFinalizedCheckpoint         = "finalized_checkpoint"
+	EventChainReorg                  = "chain_reorg"
+	EventContributionAndProof        = "contribution_and_proof"
+	EventLightClientFinalityUpdate   = "light_client_finality_update"
+	EventLightClientOptimisticUpdate = "light_client_optimistic_update"
+	EventPayloadAttributes           = "payload_attributes"
+	EventBlobSidecar                 = "blob_sidecar"
+	EventError                       = "error"
+	EventConnectionError             = "connection_error"
+)
+
+var (
+	_ = EventStreamClient(&EventStream{})
+)
+
+var DefaultEventTopics = []string{EventHead}
+
+type EventStreamClient interface {
+	Subscribe(eventsChannel chan<- *Event)
+}
+
+type Event struct {
+	EventType string
+	Data      []byte
+}
+
+// EventStream is responsible for subscribing to the Beacon API events endpoint
+// and dispatching received events to subscribers.
+type EventStream struct {
+	ctx        context.Context
+	httpClient *http.Client
+	host       string
+	topics     []string
+}
+
+func NewEventStream(ctx context.Context, httpClient *http.Client, host string, topics []string) (*EventStream, error) {
+	// Check if the host is a valid URL
+	_, err := url.ParseRequestURI(host)
+	if err != nil {
+		return nil, err
+	}
+	if len(topics) == 0 {
+		return nil, errors.New("no topics provided")
+	}
+
+	return &EventStream{
+		ctx:        ctx,
+		httpClient: httpClient,
+		host:       host,
+		topics:     topics,
+	}, nil
+}
+
+func (h *EventStream) Subscribe(eventsChannel chan<- *Event) {
+	allTopics := strings.Join(h.topics, ",")
+	log.WithField("topics", allTopics).Info("Listening to Beacon API events")
+	fullUrl := h.host + "/eth/v1/events?topics=" + allTopics
+	req, err := http.NewRequestWithContext(h.ctx, http.MethodGet, fullUrl, nil)
+	if err != nil {
+		eventsChannel <- &Event{
+			EventType: EventConnectionError,
+			Data:      []byte(errors.Wrap(err, "failed to create HTTP request").Error()),
+		}
+	}
+	req.Header.Set("Accept", api.EventStreamMediaType)
+	req.Header.Set("Connection", api.KeepAlive)
+	resp, err := h.httpClient.Do(req)
+	if err != nil {
+		eventsChannel <- &Event{
+			EventType: EventConnectionError,
+			Data:      []byte(errors.Wrap(err, client.ErrConnectionIssue.Error()).Error()),
+		}
+	}
+
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil {
+			log.WithError(closeErr).Error("Failed to close events response body")
+		}
+	}()
+	// Create a new scanner to read lines from the response body
+	scanner := bufio.NewScanner(resp.Body)
+
+	var eventType, data string // Variables to store event type and data
+
+	// Iterate over lines of the event stream
+	for scanner.Scan() {
+		select {
+		case <-h.ctx.Done():
+			log.Info("Context canceled, stopping event stream")
+			close(eventsChannel)
+			return
+		default:
+			line := scanner.Text() // TODO(13730): scanner does not handle /r and does not fully adhere to https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
+			// Handle the event based on your specific format
+			if line == "" {
+				// Empty line indicates the end of an event
+				if eventType != "" && data != "" {
+					// Process the event when both eventType and data are set
+					eventsChannel <- &Event{EventType: eventType, Data: []byte(data)}
+				}
+
+				// Reset eventType and data for the next event
+				eventType, data = "", ""
+				continue
+			}
+			et, ok := strings.CutPrefix(line, "event: ")
+			if ok {
+				// Extract event type from the "event" field
+				eventType = et
+			}
+			d, ok := strings.CutPrefix(line, "data: ")
+			if ok {
+				// Extract data from the "data" field
+				data = d
+			}
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		eventsChannel <- &Event{
+			EventType: EventConnectionError,
+			Data:      []byte(errors.Wrap(err, errors.Wrap(client.ErrConnectionIssue, "scanner failed").Error()).Error()),
+		}
+	}
+}

api/client/event/event_stream_test.go

@@ -0,0 +1,80 @@
+package event
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	log "github.com/sirupsen/logrus"
+)
+
+func TestNewEventStream(t *testing.T) {
+	validURL := "http://localhost:8080"
+	invalidURL := "://invalid"
+	topics := []string{"topic1", "topic2"}
+
+	tests := []struct {
+		name    string
+		host    string
+		topics  []string
+		wantErr bool
+	}{
+		{"Valid input", validURL, topics, false},
+		{"Invalid URL", invalidURL, topics, true},
+		{"No topics", validURL, []string{}, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := NewEventStream(context.Background(), &http.Client{}, tt.host, tt.topics)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("NewEventStream() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestEventStream(t *testing.T) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/eth/v1/events", func(w http.ResponseWriter, r *http.Request) {
+		flusher, ok := w.(http.Flusher)
+		require.Equal(t, true, ok)
+		for i := 1; i <= 2; i++ {
+			_, err := fmt.Fprintf(w, "event: head\ndata: data%d\n\n", i)
+			require.NoError(t, err)
+			flusher.Flush()                    // Trigger flush to simulate streaming data
+			time.Sleep(100 * time.Millisecond) // Simulate delay between events
+		}
+	})
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	topics := []string{"head"}
+	eventsChannel := make(chan *Event, 1)
+	stream, err := NewEventStream(context.Background(), http.DefaultClient, server.URL, topics)
+	require.NoError(t, err)
+	go stream.Subscribe(eventsChannel)
+
+	// Collect events
+	var events []*Event
+
+	for len(events) != 2 {
+		select {
+		case event := <-eventsChannel:
+			log.Info(event)
+			events = append(events, event)
+		}
+	}
+
+	// Assertions to verify the events content
+	expectedData := []string{"data1", "data2"}
+	for i, event := range events {
+		if string(event.Data) != expectedData[i] {
+			t.Errorf("Expected event data %q, got %q", expectedData[i], string(event.Data))
+		}
+	}
+}

beacon-chain/blockchain/chain_info.go

@@ -563,3 +563,9 @@ func (s *Service) RecentBlockSlot(root [32]byte) (primitives.Slot, error) {
 func (s *Service) inRegularSync() bool {
 	return s.cfg.SyncChecker.Synced()
 }
+
+// validating returns true if the beacon is tracking some validators that have
+// registered for proposing.
+func (s *Service) validating() bool {
+	return s.cfg.TrackedValidatorsCache.Validating()
+}

beacon-chain/blockchain/receive_attestation.go

@@ -95,7 +95,9 @@ func (s *Service) spawnProcessAttestationsRoutine() {
 				return
 			case slotInterval := <-ticker.C():
 				if slotInterval.Interval > 0 {
-					s.UpdateHead(s.ctx, slotInterval.Slot+1)
+					if s.validating() {
+						s.UpdateHead(s.ctx, slotInterval.Slot+1)
+					}
 				} else {
 					s.cfg.ForkChoiceStore.Lock()
 					if err := s.cfg.ForkChoiceStore.NewSlot(s.ctx, slotInterval.Slot); err != nil {

beacon-chain/cache/tracked_validators.go

@@ -41,3 +41,9 @@ func (t *TrackedValidatorsCache) Prune() {
 	defer t.Unlock()
 	t.trackedValidators = make(map[primitives.ValidatorIndex]TrackedValidator)
 }
+
+func (t *TrackedValidatorsCache) Validating() bool {
+	t.Lock()
+	defer t.Unlock()
+	return len(t.trackedValidators) > 0
+}

beacon-chain/core/epoch/precompute/BUILD.bazel

@@ -14,6 +14,7 @@ go_library(
     visibility = [
         "//beacon-chain:__subpackages__",
         "//testing/spectest:__subpackages__",
+        "//tools:__subpackages__",
     ],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",

beacon-chain/node/BUILD.bazel

@@ -55,6 +55,8 @@ go_library(
         "//beacon-chain/verification:go_default_library",
         "//cmd:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
+        "//cmd/beacon-chain/storage/flags:go_default_library",
+        "//cmd/beacon-chain/sync/backfill/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
@@ -94,6 +96,8 @@ go_test(
         "//beacon-chain/monitor:go_default_library",
         "//cmd:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
+        "//cmd/beacon-chain/storage/flags:go_default_library",
+        "//cmd/beacon-chain/sync/backfill/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

beacon-chain/node/config.go

@@ -2,17 +2,26 @@ package node
 
 import (
 	"fmt"
+	"math"
 
 	"github.com/ethereum/go-ethereum/common"
 	fastssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
+	storageFlags "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/storage/flags"
+	backfill "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/sync/backfill/flags"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	tracing2 "github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
 	"github.com/urfave/cli/v2"
 )
 
+const (
+	maxBlobRetentionEpoch         = math.MaxUint32
+	archivalSlotsPerArchivedPoint = 32
+)
+
 func configureTracing(cliCtx *cli.Context) error {
 	return tracing2.Setup(
 		"beacon-chain", // service name
@@ -198,6 +207,37 @@ func configureExecutionSetting(cliCtx *cli.Context) error {
 	return params.SetActive(c)
 }
 
+func configureArchivalNode(cliCtx *cli.Context) error {
+	if cliCtx.IsSet(flags.ArchivalNodeFlag.Name) {
+		log.Info("Enabling Archival mode on the beacon node")
+		if cliCtx.IsSet(flags.SlotsPerArchivedPoint.Name) {
+			log.Infof("Changing slots per archived point from %d to %d", cliCtx.Int(flags.SlotsPerArchivedPoint.Name), archivalSlotsPerArchivedPoint)
+		}
+		if err := cliCtx.Set(flags.SlotsPerArchivedPoint.Name, fmt.Sprintf("%d", archivalSlotsPerArchivedPoint)); err != nil {
+			return err
+		}
+		if !cliCtx.IsSet(features.SaveFullExecutionPayloads.Name) {
+			log.Info("Saving full execution payloads")
+			if err := cliCtx.Set(features.SaveFullExecutionPayloads.Name, "true"); err != nil {
+				return err
+			}
+		}
+		if !cliCtx.IsSet(backfill.EnableExperimentalBackfill.Name) {
+			log.Info("Enabling backfill on nodes")
+			if err := cliCtx.Set(backfill.EnableExperimentalBackfill.Name, "true"); err != nil {
+				return err
+			}
+		}
+		if cliCtx.IsSet(storageFlags.BlobRetentionEpochFlag.Name) {
+			log.Infof("Changing blob retention epochs from %d to %d", cliCtx.Uint64(storageFlags.BlobRetentionEpochFlag.Name), maxBlobRetentionEpoch)
+		}
+		if err := cliCtx.Set(storageFlags.BlobRetentionEpochFlag.Name, fmt.Sprintf("%d", maxBlobRetentionEpoch)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func configureFastSSZHashingAlgorithm() {
 	fastssz.EnableVectorizedHTR = true
 }

beacon-chain/node/config_test.go

@@ -11,6 +11,9 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
+	storageFlags "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/storage/flags"
+	backfill "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/sync/backfill/flags"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
@@ -228,3 +231,38 @@ func TestConfigureInterop(t *testing.T) {
 		})
 	}
 }
+
+func TestConfigureArchivalNode(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	hook := logTest.NewGlobal()
+
+	app := cli.App{}
+	set := flag.NewFlagSet("test", 0)
+	set.Bool(flags.ArchivalNodeFlag.Name, false, "")
+	set.Int(flags.SlotsPerArchivedPoint.Name, 2048, "")
+	set.Bool(features.SaveFullExecutionPayloads.Name, false, "")
+	set.Bool(backfill.EnableExperimentalBackfill.Name, false, "")
+	set.Uint64(storageFlags.BlobRetentionEpochFlag.Name, 4096, "")
+
+	require.NoError(t, set.Set(flags.ArchivalNodeFlag.Name, "true"))
+	cliCtx := cli.NewContext(&app, set, nil)
+
+	require.NoError(t, configureArchivalNode(cliCtx))
+	assert.LogsContain(t, hook, "Enabling Archival mode on the beacon node")
+	assert.LogsContain(t, hook, "Saving full execution payloads")
+	assert.LogsContain(t, hook, "Enabling backfill on nodes")
+
+	hook.Reset()
+
+	require.NoError(t, set.Set(flags.SlotsPerArchivedPoint.Name, "256"))
+	require.NoError(t, set.Set(features.SaveFullExecutionPayloads.Name, "true"))
+	require.NoError(t, set.Set(backfill.EnableExperimentalBackfill.Name, "true"))
+	require.NoError(t, set.Set(storageFlags.BlobRetentionEpochFlag.Name, "2048"))
+
+	cliCtx = cli.NewContext(&app, set, nil)
+	require.NoError(t, configureArchivalNode(cliCtx))
+	assert.LogsContain(t, hook, "Enabling Archival mode on the beacon node")
+	assert.LogsContain(t, hook, "Changing slots per archived point from 256 to 32")
+	assert.LogsContain(t, hook, "Changing blob retention epochs from 2048 to 4294967295")
+
+}

beacon-chain/node/node.go

@@ -134,6 +134,9 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 	if hasNetworkFlag(cliCtx) && cliCtx.IsSet(cmd.ChainConfigFileFlag.Name) {
 		return nil, fmt.Errorf("%s cannot be passed concurrently with network flag", cmd.ChainConfigFileFlag.Name)
 	}
+	if err := configureArchivalNode(cliCtx); err != nil {
+		return nil, err
+	}
 	if err := features.ConfigureBeaconChain(cliCtx); err != nil {
 		return nil, err
 	}

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

@@ -18,8 +18,10 @@ go_library(
         "@com_github_golang_protobuf//ptypes/timestamp",
         "@com_github_libp2p_go_libp2p//core/network:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
+        "@io_opencensus_go//trace: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",
         "@org_golang_google_grpc//status:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",
     ],
@@ -45,7 +47,9 @@ go_test(
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
+        "@com_github_grpc_ecosystem_grpc_gateway_v2//runtime:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
+        "@org_golang_google_grpc//metadata:go_default_library",
         "@org_golang_google_grpc//reflection:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",

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

@@ -6,7 +6,9 @@ package node
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"sort"
+	"strconv"
 	"time"
 
 	"github.com/golang/protobuf/ptypes/empty"
@@ -21,8 +23,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/io/logs"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"go.opencensus.io/trace"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
@@ -45,6 +49,35 @@ type Server struct {
 	BeaconMonitoringPort int
 }
 
+// GetHealth checks the health of the node
+func (ns *Server) GetHealth(ctx context.Context, request *ethpb.HealthRequest) (*empty.Empty, error) {
+	ctx, span := trace.StartSpan(ctx, "node.GetHealth")
+	defer span.End()
+
+	// Set a timeout for the health check operation
+	timeoutDuration := 10 * time.Second
+	ctx, cancel := context.WithTimeout(ctx, timeoutDuration)
+	defer cancel() // Important to avoid a context leak
+
+	if ns.SyncChecker.Synced() {
+		return &empty.Empty{}, nil
+	}
+	if ns.SyncChecker.Syncing() || ns.SyncChecker.Initialized() {
+		if request.SyncingStatus != 0 {
+			// override the 200 success with the provided request status
+			if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(request.SyncingStatus, 10))); err != nil {
+				return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
+			}
+			return &empty.Empty{}, nil
+		}
+		if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(http.StatusPartialContent, 10))); err != nil {
+			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
+		}
+		return &empty.Empty{}, nil
+	}
+	return &empty.Empty{}, status.Errorf(codes.Unavailable, "service unavailable")
+}
+
 // GetSyncStatus checks the current network sync status of the node.
 func (ns *Server) GetSyncStatus(_ context.Context, _ *empty.Empty) (*ethpb.SyncStatus, error) {
 	return &ethpb.SyncStatus{

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

@@ -3,12 +3,14 @@ package node
 import (
 	"context"
 	"errors"
+	"fmt"
 	"testing"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/p2p/enode"
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	dbutil "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
@@ -22,6 +24,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/reflection"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -170,3 +173,53 @@ func TestNodeServer_GetETH1ConnectionStatus(t *testing.T) {
 	assert.Equal(t, ep, res.CurrentAddress)
 	assert.Equal(t, errStr, res.CurrentConnectionError)
 }
+
+func TestNodeServer_GetHealth(t *testing.T) {
+	tests := []struct {
+		name         string
+		input        *mockSync.Sync
+		customStatus uint64
+		wantedErr    string
+	}{
+		{
+			name:  "happy path",
+			input: &mockSync.Sync{IsSyncing: false, IsSynced: true},
+		},
+		{
+			name:      "syncing",
+			input:     &mockSync.Sync{IsSyncing: false},
+			wantedErr: "service unavailable",
+		},
+		{
+			name:         "custom sync status",
+			input:        &mockSync.Sync{IsSyncing: true},
+			customStatus: 206,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := grpc.NewServer()
+			ns := &Server{
+				SyncChecker: tt.input,
+			}
+			ethpb.RegisterNodeServer(server, ns)
+			reflection.Register(server)
+			ctx := grpc.NewContextWithServerTransportStream(context.Background(), &runtime.ServerTransportStream{})
+			_, err := ns.GetHealth(ctx, &ethpb.HealthRequest{SyncingStatus: tt.customStatus})
+			if tt.wantedErr == "" {
+				require.NoError(t, err)
+				return
+			}
+			if tt.customStatus != 0 {
+				// Assuming the call was successful, now extract the headers
+				headers, _ := metadata.FromIncomingContext(ctx)
+				// Check for the specific header
+				values, ok := headers["x-http-code"]
+				require.Equal(t, true, ok && len(values) > 0)
+				require.Equal(t, fmt.Sprintf("%d", tt.customStatus), values[0])
+
+			}
+			require.ErrorContains(t, tt.wantedErr, err)
+		})
+	}
+}

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go

@@ -2697,10 +2697,13 @@ func TestProposer_PrepareBeaconProposer(t *testing.T) {
 				BeaconDB:               db,
 				TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
 			}
+			require.Equal(t, false, proposerServer.TrackedValidatorsCache.Validating())
 			_, err := proposerServer.PrepareBeaconProposer(ctx, tt.args.request)
 			if tt.wantErr != "" {
 				require.ErrorContains(t, tt.wantErr, err)
 				return
+			} else {
+				require.Equal(t, true, proposerServer.TrackedValidatorsCache.Validating())
 			}
 			require.NoError(t, err)
 			val, tracked := proposerServer.TrackedValidatorsCache.Validator(1)

beacon-chain/sync/BUILD.bazel

@@ -108,6 +108,7 @@ go_library(
         "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz/equality:go_default_library",
+        "//io/file:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//network/forks:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/sync/backfill/batcher.go

@@ -79,6 +79,10 @@ func (c *batchSequencer) update(b batch) {
 		// so we want to copy c to a, then on i=3, d to b, then on i=4 e to c.
 		c.seq[i-done] = c.seq[i]
 	}
+	if done == 1 && len(c.seq) == 1 {
+		c.seq[0] = c.batcher.beforeBatch(c.seq[0])
+		return
+	}
 	// Overwrite the moved batches with the next ones in the sequence.
 	// Continuing the example in the comment above, len(c.seq)==5, done=2, so i=3.
 	// We want to replace index 3 with the batch that should be processed after index 2,

beacon-chain/sync/backfill/batcher_test.go

@@ -64,6 +64,35 @@ func TestBatcherBefore(t *testing.T) {
 	}
 }
 
+func TestBatchSingleItem(t *testing.T) {
+	var min, max, size primitives.Slot
+	// seqLen = 1 means just one worker
+	seqLen := 1
+	min = 0
+	max = 11235
+	size = 64
+	seq := newBatchSequencer(seqLen, min, max, size)
+	got, err := seq.sequence()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(got))
+	b := got[0]
+
+	//  calling sequence again should give you the next (earlier) batch
+	seq.update(b.withState(batchImportComplete))
+	next, err := seq.sequence()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(next))
+	require.Equal(t, b.end, next[0].end+size)
+
+	// should get the same batch again when update is called with an error
+	seq.update(next[0].withState(batchErrRetryable))
+	same, err := seq.sequence()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(same))
+	require.Equal(t, next[0].begin, same[0].begin)
+	require.Equal(t, next[0].end, same[0].end)
+}
+
 func TestBatchSequencer(t *testing.T) {
 	var min, max, size primitives.Slot
 	seqLen := 8

beacon-chain/sync/metrics.go

@@ -144,6 +144,12 @@ var (
 			Help: "Time for gossiped blob sidecars to arrive",
 		},
 	)
+	blobSidecarVerificationGossipSummary = promauto.NewSummary(
+		prometheus.SummaryOpts{
+			Name: "gossip_blob_sidecar_verification_milliseconds",
+			Help: "Time to verify gossiped blob sidecars",
+		},
+	)
 
 	// Sync committee verification performance.
 	syncMessagesForUnknownBlocks = promauto.NewCounter(

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -2,10 +2,16 @@ package sync
 
 import (
 	"context"
+	"fmt"
+	"os"
+	"path"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition/interop"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/io/file"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -33,7 +39,10 @@ func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 			if r != [32]byte{} {
 				s.setBadBlock(ctx, r) // Setting head block as bad.
 			} else {
+				// TODO(13721): Remove this once we can deprecate the flag.
 				interop.WriteBlockToDisk(signed, true /*failed*/)
+
+				saveInvalidBlockToTemp(signed)
 				s.setBadBlock(ctx, root)
 			}
 		}
@@ -45,3 +54,21 @@ func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 	}
 	return err
 }
+
+// WriteInvalidBlockToDisk as a block ssz. Writes to temp directory.
+func saveInvalidBlockToTemp(block interfaces.ReadOnlySignedBeaconBlock) {
+	if !features.Get().SaveInvalidBlock {
+		return
+	}
+	filename := fmt.Sprintf("beacon_block_%d.ssz", block.Block().Slot())
+	fp := path.Join(os.TempDir(), filename)
+	log.Warnf("Writing invalid block to disk at %s", fp)
+	enc, err := block.MarshalSSZ()
+	if err != nil {
+		log.WithError(err).Error("Failed to ssz encode block")
+		return
+	}
+	if err := file.WriteFile(fp, enc); err != nil {
+		log.WithError(err).Error("Failed to write to disk")
+	}
+}

beacon-chain/sync/validate_blob.go

@@ -3,17 +3,21 @@ package sync
 import (
 	"context"
 	"fmt"
+	"os"
+	"path"
 	"strings"
 
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/rand"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/io/file"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -109,6 +113,7 @@ func (s *Service) validateBlob(ctx context.Context, pid peer.ID, msg *pubsub.Mes
 	}
 
 	if err := vf.SidecarKzgProofVerified(); err != nil {
+		saveInvalidBlobToTemp(blob)
 		return pubsub.ValidationReject, err
 	}
 
@@ -118,10 +123,12 @@ func (s *Service) validateBlob(ctx context.Context, pid peer.ID, msg *pubsub.Mes
 
 	fields := blobFields(blob)
 	sinceSlotStartTime := receivedTime.Sub(startTime)
+	validationTime := s.cfg.clock.Now().Sub(receivedTime)
 	fields["sinceSlotStartTime"] = sinceSlotStartTime
-	fields["validationTime"] = s.cfg.clock.Now().Sub(receivedTime)
+	fields["validationTime"] = validationTime
 	log.WithFields(fields).Debug("Received blob sidecar gossip")
 
+	blobSidecarVerificationGossipSummary.Observe(float64(validationTime.Milliseconds()))
 	blobSidecarArrivalGossipSummary.Observe(float64(sinceSlotStartTime.Milliseconds()))
 
 	vBlobData, err := vf.VerifiedROBlob()
@@ -165,3 +172,21 @@ func blobFields(b blocks.ROBlob) logrus.Fields {
 func computeSubnetForBlobSidecar(index uint64) uint64 {
 	return index % params.BeaconConfig().BlobsidecarSubnetCount
 }
+
+// saveInvalidBlobToTemp as a block ssz. Writes to temp directory.
+func saveInvalidBlobToTemp(b blocks.ROBlob) {
+	if !features.Get().SaveInvalidBlob {
+		return
+	}
+	filename := fmt.Sprintf("blob_sidecar_%#x_%d_%d.ssz", b.BlockRoot(), b.Slot(), b.Index)
+	fp := path.Join(os.TempDir(), filename)
+	log.Warnf("Writing invalid blob sidecar to disk at %s", fp)
+	enc, err := b.MarshalSSZ()
+	if err != nil {
+		log.WithError(err).Error("Failed to ssz encode blob sidecar")
+		return
+	}
+	if err := file.WriteFile(fp, enc); err != nil {
+		log.WithError(err).Error("Failed to write to disk")
+	}
+}

cmd/beacon-chain/BUILD.bazel

@@ -21,6 +21,7 @@ go_library(
         "//cmd/beacon-chain/flags:go_default_library",
         "//cmd/beacon-chain/jwt:go_default_library",
         "//cmd/beacon-chain/storage:go_default_library",
+        "//cmd/beacon-chain/storage/flags:go_default_library",
         "//cmd/beacon-chain/sync/backfill:go_default_library",
         "//cmd/beacon-chain/sync/backfill/flags:go_default_library",
         "//cmd/beacon-chain/sync/checkpoint:go_default_library",

cmd/beacon-chain/flags/base.go

@@ -259,4 +259,9 @@ var (
 		Usage: "Directory for the slasher database",
 		Value: cmd.DefaultDataDir(),
 	}
+	// ArchivalNodeFlag defines the flag that enables archival mode on a prysm beacon node.
+	ArchivalNodeFlag = &cli.BoolFlag{
+		Name:  "archive",
+		Usage: "Enables archival mode on a prysm beacon node.",
+	}
 )

cmd/beacon-chain/main.go

@@ -20,6 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	jwtcommands "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/jwt"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/storage"
+	storageFlags "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/storage/flags"
 	backfill "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/sync/backfill"
 	bflags "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/sync/backfill/flags"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/sync/checkpoint"
@@ -138,8 +139,9 @@ var appFlags = []cli.Flag{
 	genesis.BeaconAPIURL,
 	flags.SlasherDirFlag,
 	flags.JwtId,
-	storage.BlobStoragePathFlag,
-	storage.BlobRetentionEpochFlag,
+	flags.ArchivalNodeFlag,
+	storageFlags.BlobStoragePathFlag,
+	storageFlags.BlobRetentionEpochFlag,
 	bflags.EnableExperimentalBackfill,
 	bflags.BackfillBatchSize,
 	bflags.BackfillWorkerCount,

cmd/beacon-chain/storage/BUILD.bazel

@@ -9,6 +9,7 @@ go_library(
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/node:go_default_library",
         "//cmd:go_default_library",
+        "//cmd/beacon-chain/storage/flags:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -22,6 +23,7 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//cmd:go_default_library",
+        "//cmd/beacon-chain/storage/flags:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//testing/assert:go_default_library",

cmd/beacon-chain/storage/flags/BUILD.bazel

@@ -0,0 +1,12 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["flags.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/storage/flags",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//config/params:go_default_library",
+        "@com_github_urfave_cli_v2//:go_default_library",
+    ],
+)

cmd/beacon-chain/storage/flags/flags.go

@@ -0,0 +1,20 @@
+package flags
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/urfave/cli/v2"
+)
+
+var (
+	// BlobStoragePathFlag defines a flag to start the beacon chain from a give genesis state file.
+	BlobStoragePathFlag = &cli.PathFlag{
+		Name:  "blob-path",
+		Usage: "Location for blob storage. Default location will be a 'blobs' directory next to the beacon db.",
+	}
+	BlobRetentionEpochFlag = &cli.Uint64Flag{
+		Name:    "blob-retention-epochs",
+		Usage:   "Override the default blob retention period (measured in epochs). The node will exit with an error at startup if the value is less than the default of 4096 epochs.",
+		Value:   uint64(params.BeaconConfig().MinEpochsForBlobsSidecarsRequest),
+		Aliases: []string{"extend-blob-retention-epoch"},
+	}
+)

cmd/beacon-chain/storage/options.go

@@ -7,25 +7,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/node"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
+	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/storage/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/urfave/cli/v2"
 )
 
-var (
-	// BlobStoragePathFlag defines a flag to start the beacon chain from a give genesis state file.
-	BlobStoragePathFlag = &cli.PathFlag{
-		Name:  "blob-path",
-		Usage: "Location for blob storage. Default location will be a 'blobs' directory next to the beacon db.",
-	}
-	BlobRetentionEpochFlag = &cli.Uint64Flag{
-		Name:    "blob-retention-epochs",
-		Usage:   "Override the default blob retention period (measured in epochs). The node will exit with an error at startup if the value is less than the default of 4096 epochs.",
-		Value:   uint64(params.BeaconConfig().MinEpochsForBlobsSidecarsRequest),
-		Aliases: []string{"extend-blob-retention-epoch"},
-	}
-)
-
 // BeaconNodeOptions sets configuration values on the node.BeaconNode value at node startup.
 // Note: we can't get the right context from cli.Context, because the beacon node setup code uses this context to
 // create a cancellable context. If we switch to using App.RunContext, we can set up this cancellation in the cmd
@@ -42,7 +29,7 @@ func BeaconNodeOptions(c *cli.Context) ([]node.Option, error) {
 }
 
 func blobStoragePath(c *cli.Context) string {
-	blobsPath := c.Path(BlobStoragePathFlag.Name)
+	blobsPath := c.Path(flags.BlobStoragePathFlag.Name)
 	if blobsPath == "" {
 		// append a "blobs" subdir to the end of the data dir path
 		blobsPath = path.Join(c.String(cmd.DataDirFlag.Name), "blobs")
@@ -57,14 +44,14 @@ var errInvalidBlobRetentionEpochs = errors.New("value is smaller than spec minim
 // smaller than the spec default, an error will be returned.
 func blobRetentionEpoch(cliCtx *cli.Context) (primitives.Epoch, error) {
 	spec := params.BeaconConfig().MinEpochsForBlobsSidecarsRequest
-	if !cliCtx.IsSet(BlobRetentionEpochFlag.Name) {
+	if !cliCtx.IsSet(flags.BlobRetentionEpochFlag.Name) {
 		return spec, nil
 	}
 
-	re := primitives.Epoch(cliCtx.Uint64(BlobRetentionEpochFlag.Name))
+	re := primitives.Epoch(cliCtx.Uint64(flags.BlobRetentionEpochFlag.Name))
 	// Validate the epoch value against the spec default.
 	if re < params.BeaconConfig().MinEpochsForBlobsSidecarsRequest {
-		return spec, errors.Wrapf(errInvalidBlobRetentionEpochs, "%s=%d, spec=%d", BlobRetentionEpochFlag.Name, re, spec)
+		return spec, errors.Wrapf(errInvalidBlobRetentionEpochs, "%s=%d, spec=%d", flags.BlobRetentionEpochFlag.Name, re, spec)
 	}
 
 	return re, nil

cmd/beacon-chain/storage/options_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/cmd"
+	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/storage/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
@@ -26,7 +27,7 @@ func TestBlobStoragePath_NoFlagSpecified(t *testing.T) {
 func TestBlobStoragePath_FlagSpecified(t *testing.T) {
 	app := cli.App{}
 	set := flag.NewFlagSet("test", 0)
-	set.String(BlobStoragePathFlag.Name, "/blah/blah", BlobStoragePathFlag.Usage)
+	set.String(flags.BlobStoragePathFlag.Name, "/blah/blah", flags.BlobStoragePathFlag.Usage)
 	cliCtx := cli.NewContext(&app, set, nil)
 	storagePath := blobStoragePath(cliCtx)
 
@@ -46,18 +47,18 @@ func TestConfigureBlobRetentionEpoch(t *testing.T) {
 	require.Equal(t, specMinEpochs, epochs)
 
 	// manually define the flag in the set, so the following code can use set.Set
-	set.Uint64(BlobRetentionEpochFlag.Name, 0, "")
+	set.Uint64(flags.BlobRetentionEpochFlag.Name, 0, "")
 
 	// Test case: Input epoch is greater than or equal to spec value.
 	expectedChange := specMinEpochs + 1
-	require.NoError(t, set.Set(BlobRetentionEpochFlag.Name, fmt.Sprintf("%d", expectedChange)))
+	require.NoError(t, set.Set(flags.BlobRetentionEpochFlag.Name, fmt.Sprintf("%d", expectedChange)))
 	epochs, err = blobRetentionEpoch(cliCtx)
 	require.NoError(t, err)
 	require.Equal(t, primitives.Epoch(expectedChange), epochs)
 
 	// Test case: Input epoch is less than spec value.
 	expectedChange = specMinEpochs - 1
-	require.NoError(t, set.Set(BlobRetentionEpochFlag.Name, fmt.Sprintf("%d", expectedChange)))
+	require.NoError(t, set.Set(flags.BlobRetentionEpochFlag.Name, fmt.Sprintf("%d", expectedChange)))
 	_, err = blobRetentionEpoch(cliCtx)
 	require.ErrorIs(t, err, errInvalidBlobRetentionEpochs)
 }

cmd/beacon-chain/sync/backfill/flags/flags.go

@@ -22,7 +22,7 @@ var (
 		Usage: "Number of blocks per backfill batch. " +
 			"A larger number will request more blocks at once from peers, but also consume more system memory to " +
 			"hold batches in memory during processing. This has a multiplicative effect with " + backfillWorkerCountName + ".",
-		Value: 64,
+		Value: 32,
 	}
 	// BackfillWorkerCount allows users to tune the number of concurrent backfill batches to download, to maximize
 	// network utilization at the cost of higher memory.

cmd/beacon-chain/usage.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v5/cmd"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/storage"
+	storageFlags "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/storage/flags"
 	backfill "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/sync/backfill/flags"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/sync/checkpoint"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/sync/genesis"
@@ -130,13 +130,14 @@ var appHelpFlagGroups = []flagGroup{
 			flags.SlasherDirFlag,
 			flags.LocalBlockValueBoost,
 			flags.JwtId,
+			flags.ArchivalNodeFlag,
 			checkpoint.BlockPath,
 			checkpoint.StatePath,
 			checkpoint.RemoteURL,
 			genesis.StatePath,
 			genesis.BeaconAPIURL,
-			storage.BlobStoragePathFlag,
-			storage.BlobRetentionEpochFlag,
+			storageFlags.BlobStoragePathFlag,
+			storageFlags.BlobRetentionEpochFlag,
 			backfill.EnableExperimentalBackfill,
 			backfill.BackfillWorkerCount,
 			backfill.BackfillBatchSize,

config/features/config.go

@@ -72,6 +72,10 @@ type Flags struct {
 	PrepareAllPayloads bool // PrepareAllPayloads informs the engine to prepare a block on every slot.
 	// BlobSaveFsync requires blob saving to block on fsync to ensure blobs are durably persisted before passing DA.
 	BlobSaveFsync bool
+
+	SaveInvalidBlock bool // SaveInvalidBlock saves invalid block to temp.
+	SaveInvalidBlob  bool // SaveInvalidBlob saves invalid blob to temp.
+
 	// KeystoreImportDebounceInterval specifies the time duration the validator waits to reload new keys if they have
 	// changed on disk. This feature is for advanced use cases only.
 	KeystoreImportDebounceInterval time.Duration
@@ -187,6 +191,16 @@ func ConfigureBeaconChain(ctx *cli.Context) error {
 		cfg.WriteSSZStateTransitions = true
 	}
 
+	if ctx.Bool(saveInvalidBlockTempFlag.Name) {
+		logEnabled(saveInvalidBlockTempFlag)
+		cfg.SaveInvalidBlock = true
+	}
+
+	if ctx.Bool(saveInvalidBlobTempFlag.Name) {
+		logEnabled(saveInvalidBlobTempFlag)
+		cfg.SaveInvalidBlob = true
+	}
+
 	if ctx.IsSet(disableGRPCConnectionLogging.Name) {
 		logDisabled(disableGRPCConnectionLogging)
 		cfg.DisableGRPCConnectionLogs = true

config/features/flags.go

@@ -42,6 +42,14 @@ var (
 		Name:  "interop-write-ssz-state-transitions",
 		Usage: "Writes SSZ states to disk after attempted state transitio.",
 	}
+	saveInvalidBlockTempFlag = &cli.BoolFlag{
+		Name:  "save-invalid-block-temp",
+		Usage: "Writes invalid blocks to temp directory.",
+	}
+	saveInvalidBlobTempFlag = &cli.BoolFlag{
+		Name:  "save-invalid-blob-temp",
+		Usage: "Writes invalid blobs to temp directory.",
+	}
 	disableGRPCConnectionLogging = &cli.BoolFlag{
 		Name:  "disable-grpc-connection-logging",
 		Usage: "Disables displaying logs for newly connected grpc clients.",
@@ -196,6 +204,8 @@ var BeaconChainFlags = append(deprecatedBeaconFlags, append(deprecatedFlags, []c
 	devModeFlag,
 	enableExperimentalState,
 	writeSSZStateTransitionsFlag,
+	saveInvalidBlockTempFlag,
+	saveInvalidBlobTempFlag,
 	disableGRPCConnectionLogging,
 	HoleskyTestnet,
 	PraterTestnet,

proto/BUILD.bazel

@@ -1,4 +1,3 @@
-load("@prysm//tools/go:def.bzl", "go_library")
 load(
     "@bazel_skylib//rules:common_settings.bzl",
     "string_flag",

proto/engine/v1/json_marshal_unmarshal.go

@@ -16,8 +16,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
-var errExecutionUnmarshal = errors.New("unable to unmarshal execution engine data")
-
 // PayloadIDBytes defines a custom type for Payload IDs used by the engine API
 // client with proper JSON Marshal and Unmarshal methods to hex.
 type PayloadIDBytes [8]byte

proto/eth/v1/BUILD.bazel

@@ -113,7 +113,6 @@ ssz_proto_files(
     name = "ssz_proto_files",
     srcs = [
         "beacon_block.proto",
-        "beacon_state.proto",
     ],
     config = select({
         "//conditions:default": "mainnet",

proto/eth/v1/beacon_state.pb.go

@@ -1,938 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.31.0
-// 	protoc        v4.25.1
-// source: proto/eth/v1/beacon_state.proto
-
-package v1
-
-import (
-	reflect "reflect"
-	sync "sync"
-
-	github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield"
-	github_com_prysmaticlabs_prysm_v5_consensus_types_primitives "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	_ "github.com/prysmaticlabs/prysm/v5/proto/eth/ext"
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	_ "google.golang.org/protobuf/types/descriptorpb"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-type BeaconState struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	GenesisTime                 uint64                                                            `protobuf:"varint,1001,opt,name=genesis_time,json=genesisTime,proto3" json:"genesis_time,omitempty"`
-	GenesisValidatorsRoot       []byte                                                            `protobuf:"bytes,1002,opt,name=genesis_validators_root,json=genesisValidatorsRoot,proto3" json:"genesis_validators_root,omitempty" ssz-size:"32"`
-	Slot                        github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot `protobuf:"varint,1003,opt,name=slot,proto3" json:"slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"`
-	Fork                        *Fork                                                             `protobuf:"bytes,1004,opt,name=fork,proto3" json:"fork,omitempty"`
-	LatestBlockHeader           *BeaconBlockHeader                                                `protobuf:"bytes,2001,opt,name=latest_block_header,json=latestBlockHeader,proto3" json:"latest_block_header,omitempty"`
-	BlockRoots                  [][]byte                                                          `protobuf:"bytes,2002,rep,name=block_roots,json=blockRoots,proto3" json:"block_roots,omitempty" ssz-size:"8192,32"`
-	StateRoots                  [][]byte                                                          `protobuf:"bytes,2003,rep,name=state_roots,json=stateRoots,proto3" json:"state_roots,omitempty" ssz-size:"8192,32"`
-	HistoricalRoots             [][]byte                                                          `protobuf:"bytes,2004,rep,name=historical_roots,json=historicalRoots,proto3" json:"historical_roots,omitempty" ssz-max:"16777216" ssz-size:"?,32"`
-	Eth1Data                    *Eth1Data                                                         `protobuf:"bytes,3001,opt,name=eth1_data,json=eth1Data,proto3" json:"eth1_data,omitempty"`
-	Eth1DataVotes               []*Eth1Data                                                       `protobuf:"bytes,3002,rep,name=eth1_data_votes,json=eth1DataVotes,proto3" json:"eth1_data_votes,omitempty" ssz-max:"2048"`
-	Eth1DepositIndex            uint64                                                            `protobuf:"varint,3003,opt,name=eth1_deposit_index,json=eth1DepositIndex,proto3" json:"eth1_deposit_index,omitempty"`
-	Validators                  []*Validator                                                      `protobuf:"bytes,4001,rep,name=validators,proto3" json:"validators,omitempty" ssz-max:"1099511627776"`
-	Balances                    []uint64                                                          `protobuf:"varint,4002,rep,packed,name=balances,proto3" json:"balances,omitempty" ssz-max:"1099511627776"`
-	RandaoMixes                 [][]byte                                                          `protobuf:"bytes,5001,rep,name=randao_mixes,json=randaoMixes,proto3" json:"randao_mixes,omitempty" ssz-size:"65536,32"`
-	Slashings                   []uint64                                                          `protobuf:"varint,6001,rep,packed,name=slashings,proto3" json:"slashings,omitempty" ssz-size:"8192"`
-	PreviousEpochAttestations   []*PendingAttestation                                             `protobuf:"bytes,7001,rep,name=previous_epoch_attestations,json=previousEpochAttestations,proto3" json:"previous_epoch_attestations,omitempty" ssz-max:"4096"`
-	CurrentEpochAttestations    []*PendingAttestation                                             `protobuf:"bytes,7002,rep,name=current_epoch_attestations,json=currentEpochAttestations,proto3" json:"current_epoch_attestations,omitempty" ssz-max:"4096"`
-	JustificationBits           github_com_prysmaticlabs_go_bitfield.Bitvector4                   `protobuf:"bytes,8001,opt,name=justification_bits,json=justificationBits,proto3" json:"justification_bits,omitempty" cast-type:"github.com/prysmaticlabs/go-bitfield.Bitvector4" ssz-size:"1"`
-	PreviousJustifiedCheckpoint *Checkpoint                                                       `protobuf:"bytes,8002,opt,name=previous_justified_checkpoint,json=previousJustifiedCheckpoint,proto3" json:"previous_justified_checkpoint,omitempty"`
-	CurrentJustifiedCheckpoint  *Checkpoint                                                       `protobuf:"bytes,8003,opt,name=current_justified_checkpoint,json=currentJustifiedCheckpoint,proto3" json:"current_justified_checkpoint,omitempty"`
-	FinalizedCheckpoint         *Checkpoint                                                       `protobuf:"bytes,8004,opt,name=finalized_checkpoint,json=finalizedCheckpoint,proto3" json:"finalized_checkpoint,omitempty"`
-}
-
-func (x *BeaconState) Reset() {
-	*x = BeaconState{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *BeaconState) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*BeaconState) ProtoMessage() {}
-
-func (x *BeaconState) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use BeaconState.ProtoReflect.Descriptor instead.
-func (*BeaconState) Descriptor() ([]byte, []int) {
-	return file_proto_eth_v1_beacon_state_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *BeaconState) GetGenesisTime() uint64 {
-	if x != nil {
-		return x.GenesisTime
-	}
-	return 0
-}
-
-func (x *BeaconState) GetGenesisValidatorsRoot() []byte {
-	if x != nil {
-		return x.GenesisValidatorsRoot
-	}
-	return nil
-}
-
-func (x *BeaconState) GetSlot() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot {
-	if x != nil {
-		return x.Slot
-	}
-	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(0)
-}
-
-func (x *BeaconState) GetFork() *Fork {
-	if x != nil {
-		return x.Fork
-	}
-	return nil
-}
-
-func (x *BeaconState) GetLatestBlockHeader() *BeaconBlockHeader {
-	if x != nil {
-		return x.LatestBlockHeader
-	}
-	return nil
-}
-
-func (x *BeaconState) GetBlockRoots() [][]byte {
-	if x != nil {
-		return x.BlockRoots
-	}
-	return nil
-}
-
-func (x *BeaconState) GetStateRoots() [][]byte {
-	if x != nil {
-		return x.StateRoots
-	}
-	return nil
-}
-
-func (x *BeaconState) GetHistoricalRoots() [][]byte {
-	if x != nil {
-		return x.HistoricalRoots
-	}
-	return nil
-}
-
-func (x *BeaconState) GetEth1Data() *Eth1Data {
-	if x != nil {
-		return x.Eth1Data
-	}
-	return nil
-}
-
-func (x *BeaconState) GetEth1DataVotes() []*Eth1Data {
-	if x != nil {
-		return x.Eth1DataVotes
-	}
-	return nil
-}
-
-func (x *BeaconState) GetEth1DepositIndex() uint64 {
-	if x != nil {
-		return x.Eth1DepositIndex
-	}
-	return 0
-}
-
-func (x *BeaconState) GetValidators() []*Validator {
-	if x != nil {
-		return x.Validators
-	}
-	return nil
-}
-
-func (x *BeaconState) GetBalances() []uint64 {
-	if x != nil {
-		return x.Balances
-	}
-	return nil
-}
-
-func (x *BeaconState) GetRandaoMixes() [][]byte {
-	if x != nil {
-		return x.RandaoMixes
-	}
-	return nil
-}
-
-func (x *BeaconState) GetSlashings() []uint64 {
-	if x != nil {
-		return x.Slashings
-	}
-	return nil
-}
-
-func (x *BeaconState) GetPreviousEpochAttestations() []*PendingAttestation {
-	if x != nil {
-		return x.PreviousEpochAttestations
-	}
-	return nil
-}
-
-func (x *BeaconState) GetCurrentEpochAttestations() []*PendingAttestation {
-	if x != nil {
-		return x.CurrentEpochAttestations
-	}
-	return nil
-}
-
-func (x *BeaconState) GetJustificationBits() github_com_prysmaticlabs_go_bitfield.Bitvector4 {
-	if x != nil {
-		return x.JustificationBits
-	}
-	return github_com_prysmaticlabs_go_bitfield.Bitvector4(nil)
-}
-
-func (x *BeaconState) GetPreviousJustifiedCheckpoint() *Checkpoint {
-	if x != nil {
-		return x.PreviousJustifiedCheckpoint
-	}
-	return nil
-}
-
-func (x *BeaconState) GetCurrentJustifiedCheckpoint() *Checkpoint {
-	if x != nil {
-		return x.CurrentJustifiedCheckpoint
-	}
-	return nil
-}
-
-func (x *BeaconState) GetFinalizedCheckpoint() *Checkpoint {
-	if x != nil {
-		return x.FinalizedCheckpoint
-	}
-	return nil
-}
-
-type PendingAttestation struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	AggregationBits github_com_prysmaticlabs_go_bitfield.Bitlist                                `protobuf:"bytes,1,opt,name=aggregation_bits,json=aggregationBits,proto3" json:"aggregation_bits,omitempty" cast-type:"github.com/prysmaticlabs/go-bitfield.Bitlist" ssz-max:"2048"`
-	Data            *AttestationData                                                            `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
-	InclusionDelay  github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot           `protobuf:"varint,3,opt,name=inclusion_delay,json=inclusionDelay,proto3" json:"inclusion_delay,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"`
-	ProposerIndex   github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex `protobuf:"varint,4,opt,name=proposer_index,json=proposerIndex,proto3" json:"proposer_index,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.ValidatorIndex"`
-}
-
-func (x *PendingAttestation) Reset() {
-	*x = PendingAttestation{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *PendingAttestation) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*PendingAttestation) ProtoMessage() {}
-
-func (x *PendingAttestation) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use PendingAttestation.ProtoReflect.Descriptor instead.
-func (*PendingAttestation) Descriptor() ([]byte, []int) {
-	return file_proto_eth_v1_beacon_state_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *PendingAttestation) GetAggregationBits() github_com_prysmaticlabs_go_bitfield.Bitlist {
-	if x != nil {
-		return x.AggregationBits
-	}
-	return github_com_prysmaticlabs_go_bitfield.Bitlist(nil)
-}
-
-func (x *PendingAttestation) GetData() *AttestationData {
-	if x != nil {
-		return x.Data
-	}
-	return nil
-}
-
-func (x *PendingAttestation) GetInclusionDelay() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot {
-	if x != nil {
-		return x.InclusionDelay
-	}
-	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(0)
-}
-
-func (x *PendingAttestation) GetProposerIndex() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex {
-	if x != nil {
-		return x.ProposerIndex
-	}
-	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex(0)
-}
-
-type Committee struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Index      github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.CommitteeIndex   `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.CommitteeIndex"`
-	Slot       github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot             `protobuf:"varint,2,opt,name=slot,proto3" json:"slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"`
-	Validators []github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex `protobuf:"varint,3,rep,packed,name=validators,proto3" json:"validators,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.ValidatorIndex"`
-}
-
-func (x *Committee) Reset() {
-	*x = Committee{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Committee) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Committee) ProtoMessage() {}
-
-func (x *Committee) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Committee.ProtoReflect.Descriptor instead.
-func (*Committee) Descriptor() ([]byte, []int) {
-	return file_proto_eth_v1_beacon_state_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *Committee) GetIndex() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.CommitteeIndex {
-	if x != nil {
-		return x.Index
-	}
-	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.CommitteeIndex(0)
-}
-
-func (x *Committee) GetSlot() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot {
-	if x != nil {
-		return x.Slot
-	}
-	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(0)
-}
-
-func (x *Committee) GetValidators() []github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex {
-	if x != nil {
-		return x.Validators
-	}
-	return []github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.ValidatorIndex(nil)
-}
-
-type Fork struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	PreviousVersion []byte                                                             `protobuf:"bytes,1,opt,name=previous_version,json=previousVersion,proto3" json:"previous_version,omitempty" ssz-size:"4"`
-	CurrentVersion  []byte                                                             `protobuf:"bytes,2,opt,name=current_version,json=currentVersion,proto3" json:"current_version,omitempty" ssz-size:"4"`
-	Epoch           github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Epoch `protobuf:"varint,3,opt,name=epoch,proto3" json:"epoch,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Epoch"`
-}
-
-func (x *Fork) Reset() {
-	*x = Fork{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Fork) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Fork) ProtoMessage() {}
-
-func (x *Fork) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Fork.ProtoReflect.Descriptor instead.
-func (*Fork) Descriptor() ([]byte, []int) {
-	return file_proto_eth_v1_beacon_state_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *Fork) GetPreviousVersion() []byte {
-	if x != nil {
-		return x.PreviousVersion
-	}
-	return nil
-}
-
-func (x *Fork) GetCurrentVersion() []byte {
-	if x != nil {
-		return x.CurrentVersion
-	}
-	return nil
-}
-
-func (x *Fork) GetEpoch() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Epoch {
-	if x != nil {
-		return x.Epoch
-	}
-	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Epoch(0)
-}
-
-type ForkChoiceHeadsResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Data []*ForkChoiceHead `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
-}
-
-func (x *ForkChoiceHeadsResponse) Reset() {
-	*x = ForkChoiceHeadsResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[4]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ForkChoiceHeadsResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ForkChoiceHeadsResponse) ProtoMessage() {}
-
-func (x *ForkChoiceHeadsResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[4]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ForkChoiceHeadsResponse.ProtoReflect.Descriptor instead.
-func (*ForkChoiceHeadsResponse) Descriptor() ([]byte, []int) {
-	return file_proto_eth_v1_beacon_state_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *ForkChoiceHeadsResponse) GetData() []*ForkChoiceHead {
-	if x != nil {
-		return x.Data
-	}
-	return nil
-}
-
-type ForkChoiceHead struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Root []byte                                                            `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty" ssz-size:"32"`
-	Slot github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot `protobuf:"varint,2,opt,name=slot,proto3" json:"slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"`
-}
-
-func (x *ForkChoiceHead) Reset() {
-	*x = ForkChoiceHead{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[5]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ForkChoiceHead) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ForkChoiceHead) ProtoMessage() {}
-
-func (x *ForkChoiceHead) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[5]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ForkChoiceHead.ProtoReflect.Descriptor instead.
-func (*ForkChoiceHead) Descriptor() ([]byte, []int) {
-	return file_proto_eth_v1_beacon_state_proto_rawDescGZIP(), []int{5}
-}
-
-func (x *ForkChoiceHead) GetRoot() []byte {
-	if x != nil {
-		return x.Root
-	}
-	return nil
-}
-
-func (x *ForkChoiceHead) GetSlot() github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot {
-	if x != nil {
-		return x.Slot
-	}
-	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(0)
-}
-
-type BeaconStateResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Data *BeaconState `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
-}
-
-func (x *BeaconStateResponse) Reset() {
-	*x = BeaconStateResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[6]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *BeaconStateResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*BeaconStateResponse) ProtoMessage() {}
-
-func (x *BeaconStateResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_eth_v1_beacon_state_proto_msgTypes[6]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use BeaconStateResponse.ProtoReflect.Descriptor instead.
-func (*BeaconStateResponse) Descriptor() ([]byte, []int) {
-	return file_proto_eth_v1_beacon_state_proto_rawDescGZIP(), []int{6}
-}
-
-func (x *BeaconStateResponse) GetData() *BeaconState {
-	if x != nil {
-		return x.Data
-	}
-	return nil
-}
-
-var File_proto_eth_v1_beacon_state_proto protoreflect.FileDescriptor
-
-var file_proto_eth_v1_beacon_state_proto_rawDesc = []byte{
-	0x0a, 0x1f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62,
-	0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x12, 0x0f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
-	0x76, 0x31, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f,
-	0x65, 0x78, 0x74, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x1a, 0x1e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f,
-	0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f,
-	0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x1a, 0x1c, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31,
-	0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x22, 0xdb, 0x0b, 0x0a, 0x0b, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65,
-	0x12, 0x22, 0x0a, 0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65,
-	0x18, 0xe9, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
-	0x54, 0x69, 0x6d, 0x65, 0x12, 0x3f, 0x0a, 0x17, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18,
-	0xea, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x15,
-	0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
-	0x73, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x5a, 0x0a, 0x04, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0xeb, 0x07,
-	0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61,
-	0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73,
-	0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d,
-	0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x04, 0x73, 0x6c, 0x6f,
-	0x74, 0x12, 0x2a, 0x0a, 0x04, 0x66, 0x6f, 0x72, 0x6b, 0x18, 0xec, 0x07, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x15, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
-	0x76, 0x31, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x52, 0x04, 0x66, 0x6f, 0x72, 0x6b, 0x12, 0x53, 0x0a,
-	0x13, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65,
-	0x61, 0x64, 0x65, 0x72, 0x18, 0xd1, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, 0x74,
-	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65,
-	0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52,
-	0x11, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64,
-	0x65, 0x72, 0x12, 0x2d, 0x0a, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x72, 0x6f, 0x6f, 0x74,
-	0x73, 0x18, 0xd2, 0x0f, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x0b, 0x8a, 0xb5, 0x18, 0x07, 0x38, 0x31,
-	0x39, 0x32, 0x2c, 0x33, 0x32, 0x52, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74,
-	0x73, 0x12, 0x2d, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x73,
-	0x18, 0xd3, 0x0f, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x0b, 0x8a, 0xb5, 0x18, 0x07, 0x38, 0x31, 0x39,
-	0x32, 0x2c, 0x33, 0x32, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x73,
-	0x12, 0x40, 0x0a, 0x10, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x72,
-	0x6f, 0x6f, 0x74, 0x73, 0x18, 0xd4, 0x0f, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x14, 0x8a, 0xb5, 0x18,
-	0x04, 0x3f, 0x2c, 0x33, 0x32, 0x92, 0xb5, 0x18, 0x08, 0x31, 0x36, 0x37, 0x37, 0x37, 0x32, 0x31,
-	0x36, 0x52, 0x0f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x52, 0x6f, 0x6f,
-	0x74, 0x73, 0x12, 0x37, 0x0a, 0x09, 0x65, 0x74, 0x68, 0x31, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18,
-	0xb9, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
-	0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x74, 0x68, 0x31, 0x44, 0x61, 0x74,
-	0x61, 0x52, 0x08, 0x65, 0x74, 0x68, 0x31, 0x44, 0x61, 0x74, 0x61, 0x12, 0x4c, 0x0a, 0x0f, 0x65,
-	0x74, 0x68, 0x31, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x76, 0x6f, 0x74, 0x65, 0x73, 0x18, 0xba,
-	0x17, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
-	0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x74, 0x68, 0x31, 0x44, 0x61, 0x74, 0x61,
-	0x42, 0x08, 0x92, 0xb5, 0x18, 0x04, 0x32, 0x30, 0x34, 0x38, 0x52, 0x0d, 0x65, 0x74, 0x68, 0x31,
-	0x44, 0x61, 0x74, 0x61, 0x56, 0x6f, 0x74, 0x65, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x65, 0x74, 0x68,
-	0x31, 0x5f, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18,
-	0xbb, 0x17, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x65, 0x74, 0x68, 0x31, 0x44, 0x65, 0x70, 0x6f,
-	0x73, 0x69, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x4e, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, 0xa1, 0x1f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e,
-	0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x11, 0x92, 0xb5, 0x18, 0x0d, 0x31,
-	0x30, 0x39, 0x39, 0x35, 0x31, 0x31, 0x36, 0x32, 0x37, 0x37, 0x37, 0x36, 0x52, 0x0a, 0x76, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x2e, 0x0a, 0x08, 0x62, 0x61, 0x6c, 0x61,
-	0x6e, 0x63, 0x65, 0x73, 0x18, 0xa2, 0x1f, 0x20, 0x03, 0x28, 0x04, 0x42, 0x11, 0x92, 0xb5, 0x18,
-	0x0d, 0x31, 0x30, 0x39, 0x39, 0x35, 0x31, 0x31, 0x36, 0x32, 0x37, 0x37, 0x37, 0x36, 0x52, 0x08,
-	0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x30, 0x0a, 0x0c, 0x72, 0x61, 0x6e, 0x64,
-	0x61, 0x6f, 0x5f, 0x6d, 0x69, 0x78, 0x65, 0x73, 0x18, 0x89, 0x27, 0x20, 0x03, 0x28, 0x0c, 0x42,
-	0x0c, 0x8a, 0xb5, 0x18, 0x08, 0x36, 0x35, 0x35, 0x33, 0x36, 0x2c, 0x33, 0x32, 0x52, 0x0b, 0x72,
-	0x61, 0x6e, 0x64, 0x61, 0x6f, 0x4d, 0x69, 0x78, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x09, 0x73, 0x6c,
-	0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x18, 0xf1, 0x2e, 0x20, 0x03, 0x28, 0x04, 0x42, 0x08,
-	0x8a, 0xb5, 0x18, 0x04, 0x38, 0x31, 0x39, 0x32, 0x52, 0x09, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69,
-	0x6e, 0x67, 0x73, 0x12, 0x6e, 0x0a, 0x1b, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x18, 0xd9, 0x36, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x65, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x6e, 0x64,
-	0x69, 0x6e, 0x67, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x08,
-	0x92, 0xb5, 0x18, 0x04, 0x34, 0x30, 0x39, 0x36, 0x52, 0x19, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f,
-	0x75, 0x73, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x12, 0x6c, 0x0a, 0x1a, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65,
-	0x70, 0x6f, 0x63, 0x68, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x18, 0xda, 0x36, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
-	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69,
-	0x6e, 0x67, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x08, 0x92,
-	0xb5, 0x18, 0x04, 0x34, 0x30, 0x39, 0x36, 0x52, 0x18, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
-	0x45, 0x70, 0x6f, 0x63, 0x68, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x12, 0x68, 0x0a, 0x12, 0x6a, 0x75, 0x73, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x5f, 0x62, 0x69, 0x74, 0x73, 0x18, 0xc1, 0x3e, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x38,
-	0x82, 0xb5, 0x18, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70,
-	0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x67, 0x6f, 0x2d,
-	0x62, 0x69, 0x74, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x42, 0x69, 0x74, 0x76, 0x65, 0x63, 0x74,
-	0x6f, 0x72, 0x34, 0x8a, 0xb5, 0x18, 0x01, 0x31, 0x52, 0x11, 0x6a, 0x75, 0x73, 0x74, 0x69, 0x66,
-	0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x69, 0x74, 0x73, 0x12, 0x60, 0x0a, 0x1d, 0x70,
-	0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x6a, 0x75, 0x73, 0x74, 0x69, 0x66, 0x69, 0x65,
-	0x64, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0xc2, 0x3e, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
-	0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74,
-	0x52, 0x1b, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x4a, 0x75, 0x73, 0x74, 0x69, 0x66,
-	0x69, 0x65, 0x64, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x5e, 0x0a,
-	0x1c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x6a, 0x75, 0x73, 0x74, 0x69, 0x66, 0x69,
-	0x65, 0x64, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0xc3, 0x3e,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e,
-	0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e,
-	0x74, 0x52, 0x1a, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4a, 0x75, 0x73, 0x74, 0x69, 0x66,
-	0x69, 0x65, 0x64, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x4f, 0x0a,
-	0x14, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b,
-	0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0xc4, 0x3e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x65,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x43,
-	0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x13, 0x66, 0x69, 0x6e, 0x61, 0x6c,
-	0x69, 0x7a, 0x65, 0x64, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x97,
-	0x03, 0x0a, 0x12, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x63, 0x0a, 0x10, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x69, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42,
-	0x38, 0x82, 0xb5, 0x18, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
-	0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x67, 0x6f,
-	0x2d, 0x62, 0x69, 0x74, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x42, 0x69, 0x74, 0x6c, 0x69, 0x73,
-	0x74, 0x92, 0xb5, 0x18, 0x04, 0x32, 0x30, 0x34, 0x38, 0x52, 0x0f, 0x61, 0x67, 0x67, 0x72, 0x65,
-	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x69, 0x74, 0x73, 0x12, 0x34, 0x0a, 0x04, 0x64, 0x61,
-	0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
-	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73,
-	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61,
-	0x12, 0x6e, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65,
-	0x6c, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67,
-	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61,
-	0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35,
-	0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73,
-	0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74,
-	0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x6c, 0x61, 0x79,
-	0x12, 0x76, 0x0a, 0x0e, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x64,
-	0x65, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x42, 0x4f, 0x82, 0xb5, 0x18, 0x4b, 0x67, 0x69,
-	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74,
-	0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f,
-	0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f,
-	0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x0d, 0x70, 0x72, 0x6f, 0x70, 0x6f,
-	0x73, 0x65, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0xbe, 0x02, 0x0a, 0x09, 0x43, 0x6f, 0x6d,
-	0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x12, 0x65, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x4f, 0x82, 0xb5, 0x18, 0x4b, 0x67, 0x69, 0x74, 0x68, 0x75,
-	0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c,
-	0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e,
-	0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69,
-	0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65,
-	0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x59, 0x0a,
-	0x04, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18,
-	0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73,
-	0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f,
-	0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70,
-	0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c,
-	0x6f, 0x74, 0x52, 0x04, 0x73, 0x6c, 0x6f, 0x74, 0x12, 0x6f, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x04, 0x42, 0x4f, 0x82, 0xb5,
-	0x18, 0x4b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79,
-	0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d,
-	0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79,
-	0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x56,
-	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x0a, 0x76,
-	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x22, 0xc6, 0x01, 0x0a, 0x04, 0x46, 0x6f,
-	0x72, 0x6b, 0x12, 0x30, 0x0a, 0x10, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x76,
-	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x05, 0x8a, 0xb5,
-	0x18, 0x01, 0x34, 0x52, 0x0f, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x56, 0x65, 0x72,
-	0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f,
-	0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x05, 0x8a,
-	0xb5, 0x18, 0x01, 0x34, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72,
-	0x73, 0x69, 0x6f, 0x6e, 0x12, 0x5c, 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x04, 0x42, 0x46, 0x82, 0xb5, 0x18, 0x42, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
-	0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62,
-	0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65,
-	0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69,
-	0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x05, 0x65, 0x70, 0x6f,
-	0x63, 0x68, 0x22, 0x4e, 0x0a, 0x17, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65,
-	0x48, 0x65, 0x61, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a,
-	0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x65, 0x74,
-	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6f,
-	0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x48, 0x65, 0x61, 0x64, 0x52, 0x04, 0x64, 0x61,
-	0x74, 0x61, 0x22, 0x87, 0x01, 0x0a, 0x0e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63,
-	0x65, 0x48, 0x65, 0x61, 0x64, 0x12, 0x1a, 0x0a, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x04, 0x72, 0x6f, 0x6f,
-	0x74, 0x12, 0x59, 0x0a, 0x04, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42,
-	0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
-	0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72,
-	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73,
-	0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65,
-	0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x04, 0x73, 0x6c, 0x6f, 0x74, 0x22, 0x47, 0x0a, 0x13,
-	0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x1c, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68,
-	0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52,
-	0x04, 0x64, 0x61, 0x74, 0x61, 0x42, 0x7d, 0x0a, 0x13, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68,
-	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x42, 0x10, 0x42, 0x65,
-	0x61, 0x63, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01,
-	0x5a, 0x2e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79,
-	0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d,
-	0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31,
-	0xaa, 0x02, 0x0f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e,
-	0x56, 0x31, 0xca, 0x02, 0x0f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74,
-	0x68, 0x5c, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_proto_eth_v1_beacon_state_proto_rawDescOnce sync.Once
-	file_proto_eth_v1_beacon_state_proto_rawDescData = file_proto_eth_v1_beacon_state_proto_rawDesc
-)
-
-func file_proto_eth_v1_beacon_state_proto_rawDescGZIP() []byte {
-	file_proto_eth_v1_beacon_state_proto_rawDescOnce.Do(func() {
-		file_proto_eth_v1_beacon_state_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_eth_v1_beacon_state_proto_rawDescData)
-	})
-	return file_proto_eth_v1_beacon_state_proto_rawDescData
-}
-
-var file_proto_eth_v1_beacon_state_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
-var file_proto_eth_v1_beacon_state_proto_goTypes = []interface{}{
-	(*BeaconState)(nil),             // 0: ethereum.eth.v1.BeaconState
-	(*PendingAttestation)(nil),      // 1: ethereum.eth.v1.PendingAttestation
-	(*Committee)(nil),               // 2: ethereum.eth.v1.Committee
-	(*Fork)(nil),                    // 3: ethereum.eth.v1.Fork
-	(*ForkChoiceHeadsResponse)(nil), // 4: ethereum.eth.v1.ForkChoiceHeadsResponse
-	(*ForkChoiceHead)(nil),          // 5: ethereum.eth.v1.ForkChoiceHead
-	(*BeaconStateResponse)(nil),     // 6: ethereum.eth.v1.BeaconStateResponse
-	(*BeaconBlockHeader)(nil),       // 7: ethereum.eth.v1.BeaconBlockHeader
-	(*Eth1Data)(nil),                // 8: ethereum.eth.v1.Eth1Data
-	(*Validator)(nil),               // 9: ethereum.eth.v1.Validator
-	(*Checkpoint)(nil),              // 10: ethereum.eth.v1.Checkpoint
-	(*AttestationData)(nil),         // 11: ethereum.eth.v1.AttestationData
-}
-var file_proto_eth_v1_beacon_state_proto_depIdxs = []int32{
-	3,  // 0: ethereum.eth.v1.BeaconState.fork:type_name -> ethereum.eth.v1.Fork
-	7,  // 1: ethereum.eth.v1.BeaconState.latest_block_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
-	8,  // 2: ethereum.eth.v1.BeaconState.eth1_data:type_name -> ethereum.eth.v1.Eth1Data
-	8,  // 3: ethereum.eth.v1.BeaconState.eth1_data_votes:type_name -> ethereum.eth.v1.Eth1Data
-	9,  // 4: ethereum.eth.v1.BeaconState.validators:type_name -> ethereum.eth.v1.Validator
-	1,  // 5: ethereum.eth.v1.BeaconState.previous_epoch_attestations:type_name -> ethereum.eth.v1.PendingAttestation
-	1,  // 6: ethereum.eth.v1.BeaconState.current_epoch_attestations:type_name -> ethereum.eth.v1.PendingAttestation
-	10, // 7: ethereum.eth.v1.BeaconState.previous_justified_checkpoint:type_name -> ethereum.eth.v1.Checkpoint
-	10, // 8: ethereum.eth.v1.BeaconState.current_justified_checkpoint:type_name -> ethereum.eth.v1.Checkpoint
-	10, // 9: ethereum.eth.v1.BeaconState.finalized_checkpoint:type_name -> ethereum.eth.v1.Checkpoint
-	11, // 10: ethereum.eth.v1.PendingAttestation.data:type_name -> ethereum.eth.v1.AttestationData
-	5,  // 11: ethereum.eth.v1.ForkChoiceHeadsResponse.data:type_name -> ethereum.eth.v1.ForkChoiceHead
-	0,  // 12: ethereum.eth.v1.BeaconStateResponse.data:type_name -> ethereum.eth.v1.BeaconState
-	13, // [13:13] is the sub-list for method output_type
-	13, // [13:13] is the sub-list for method input_type
-	13, // [13:13] is the sub-list for extension type_name
-	13, // [13:13] is the sub-list for extension extendee
-	0,  // [0:13] is the sub-list for field type_name
-}
-
-func init() { file_proto_eth_v1_beacon_state_proto_init() }
-func file_proto_eth_v1_beacon_state_proto_init() {
-	if File_proto_eth_v1_beacon_state_proto != nil {
-		return
-	}
-	file_proto_eth_v1_attestation_proto_init()
-	file_proto_eth_v1_beacon_block_proto_init()
-	file_proto_eth_v1_validator_proto_init()
-	if !protoimpl.UnsafeEnabled {
-		file_proto_eth_v1_beacon_state_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*BeaconState); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_proto_eth_v1_beacon_state_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PendingAttestation); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_proto_eth_v1_beacon_state_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Committee); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_proto_eth_v1_beacon_state_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Fork); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_proto_eth_v1_beacon_state_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ForkChoiceHeadsResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_proto_eth_v1_beacon_state_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ForkChoiceHead); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_proto_eth_v1_beacon_state_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*BeaconStateResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_proto_eth_v1_beacon_state_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   7,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_proto_eth_v1_beacon_state_proto_goTypes,
-		DependencyIndexes: file_proto_eth_v1_beacon_state_proto_depIdxs,
-		MessageInfos:      file_proto_eth_v1_beacon_state_proto_msgTypes,
-	}.Build()
-	File_proto_eth_v1_beacon_state_proto = out.File
-	file_proto_eth_v1_beacon_state_proto_rawDesc = nil
-	file_proto_eth_v1_beacon_state_proto_goTypes = nil
-	file_proto_eth_v1_beacon_state_proto_depIdxs = nil
-}

proto/eth/v1/beacon_state.pb.gw.go

@@ -1,4 +0,0 @@
-//go:build ignore
-// +build ignore
-
-package ignore

proto/eth/v1/beacon_state.proto

@@ -1,107 +0,0 @@
-// Copyright 2020 Prysmatic Labs.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-syntax = "proto3";
-
-package ethereum.eth.v1;
-
-import "google/protobuf/descriptor.proto";
-
-import "proto/eth/ext/options.proto";
-import "proto/eth/v1/attestation.proto";
-import "proto/eth/v1/beacon_block.proto";
-import "proto/eth/v1/validator.proto";
-
-option csharp_namespace = "Ethereum.Eth.V1";
-option go_package = "github.com/prysmaticlabs/prysm/v5/proto/eth/v1";
-option java_multiple_files = true;
-option java_outer_classname = "BeaconStateProto";
-option java_package = "org.ethereum.eth.v1";
-option php_namespace = "Ethereum\\Eth\\v1";
-
-message BeaconState {
-  // Versioning [1001-2000]
-  uint64 genesis_time = 1001;
-  bytes genesis_validators_root = 1002 [(ethereum.eth.ext.ssz_size) = "32"];
-  uint64 slot = 1003 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
-  Fork fork = 1004;
-
-  // History [2001-3000]
-  BeaconBlockHeader latest_block_header = 2001;
-  repeated bytes block_roots = 2002 [(ethereum.eth.ext.ssz_size) = "block_roots.size"];
-  repeated bytes state_roots = 2003 [(ethereum.eth.ext.ssz_size) = "state_roots.size"];
-  repeated bytes historical_roots = 2004 [(ethereum.eth.ext.ssz_size) = "?,32", (ethereum.eth.ext.ssz_max) = "16777216"];
-
-  // Eth1 [3001-4000]
-  Eth1Data eth1_data = 3001;
-  repeated Eth1Data eth1_data_votes = 3002 [(ethereum.eth.ext.ssz_max) = "eth1_data_votes.size"];
-  uint64 eth1_deposit_index = 3003;
-
-  // Registry [4001-5000]
-  repeated Validator validators = 4001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  repeated uint64 balances = 4002 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-
-  // Randomness [5001-6000]
-  repeated bytes randao_mixes = 5001 [(ethereum.eth.ext.ssz_size) = "randao_mixes.size"];
-
-  // Slashings [6001-7000]
-  repeated uint64 slashings = 6001 [(ethereum.eth.ext.ssz_size) = "slashings.size"];
-
-  // Attestations [7001-8000]
-  repeated PendingAttestation previous_epoch_attestations = 7001 [(ethereum.eth.ext.ssz_max) = "previous_epoch_attestations.max"];
-  repeated PendingAttestation current_epoch_attestations = 7002 [(ethereum.eth.ext.ssz_max) = "current_epoch_attestations.max"];
-
-  // Finality [8001-9000]
-  // Spec type [4]Bitvector which means this would be a fixed size of 4 bits.
-  bytes justification_bits = 8001 [(ethereum.eth.ext.ssz_size) = "1", (ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/go-bitfield.Bitvector4"];
-  Checkpoint previous_justified_checkpoint = 8002;
-  Checkpoint current_justified_checkpoint = 8003;
-  Checkpoint finalized_checkpoint = 8004;
-}
-
-message PendingAttestation {
-  // Bitfield representation of validator indices that have voted exactly
-  // the same vote and have been aggregated into this attestation.
-  bytes aggregation_bits = 1 [(ethereum.eth.ext.ssz_max) = "2048", (ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/go-bitfield.Bitlist"];
-  AttestationData data = 2;
-  // The difference of when attestation gets created and get included on chain.
-  uint64 inclusion_delay = 3 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
-  // The proposer who included the attestation in the block.
-  uint64 proposer_index = 4 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.ValidatorIndex"];
-}
-
-message Committee {
-  uint64 index = 1 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.CommitteeIndex"];
-  uint64 slot = 2 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
-  repeated uint64 validators = 3 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.ValidatorIndex"];
-}
-
-// Fork structure used for indicating beacon chain versioning and forks.
-message Fork {
-  bytes previous_version = 1 [(ethereum.eth.ext.ssz_size) = "4"];
-  bytes current_version = 2 [(ethereum.eth.ext.ssz_size) = "4"];
-  uint64 epoch = 3 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Epoch"];
-}
-
-message ForkChoiceHeadsResponse {
-  repeated ForkChoiceHead data = 1;
-}
-
-message ForkChoiceHead {
-  bytes root = 1 [(ethereum.eth.ext.ssz_size) = "32"];
-  uint64 slot = 2 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
-}
-
-message BeaconStateResponse {
-  BeaconState data = 1;
-}

proto/eth/v2/BUILD.bazel

@@ -99,7 +99,6 @@ ssz_proto_files(
     srcs = [
         "beacon_block.proto",
         "beacon_lightclient.proto",
-        "beacon_state.proto",
         "sync_committee.proto",
         "validator.proto",
         "withdrawals.proto",

proto/eth/v2/beacon_state.pb.gw.go

@@ -1,4 +0,0 @@
-//go:build ignore
-// +build ignore
-
-package ignore

proto/eth/v2/beacon_state.proto

@@ -1,243 +0,0 @@
-// Copyright 2021 Prysmatic Labs.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-syntax = "proto3";
-
-package ethereum.eth.v2;
-
-import "proto/eth/ext/options.proto";
-import "proto/eth/v1/attestation.proto";
-import "proto/eth/v1/beacon_block.proto";
-import "proto/eth/v1/beacon_state.proto";
-import "proto/eth/v1/validator.proto";
-import "proto/eth/v2/sync_committee.proto";
-import "proto/eth/v2/version.proto";
-import "proto/engine/v1/execution_engine.proto";
-
-option csharp_namespace = "Ethereum.Eth.V2";
-option go_package = "github.com/prysmaticlabs/prysm/v5/proto/eth/v2;eth";
-option java_multiple_files = true;
-option java_outer_classname = "SyncCommitteeProto";
-option java_package = "org.ethereum.eth.v2";
-option php_namespace = "Ethereum\\Eth\\v2";
-
-message BeaconState {
-  // Versioning [1001-2000]
-  uint64 genesis_time = 1001;
-  bytes genesis_validators_root = 1002 [(ethereum.eth.ext.ssz_size) = "32"];
-  uint64 slot = 1003 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
-  v1.Fork fork = 1004;
-
-  // History [2001-3000]
-  v1.BeaconBlockHeader latest_block_header = 2001;
-  repeated bytes block_roots = 2002 [(ethereum.eth.ext.ssz_size) = "block_roots.size"];
-  repeated bytes state_roots = 2003 [(ethereum.eth.ext.ssz_size) = "state_roots.size"];
-  repeated bytes historical_roots = 2004 [(ethereum.eth.ext.ssz_size) = "?,32", (ethereum.eth.ext.ssz_max)  = "16777216"];
-
-  // Eth1 [3001-4000]
-  v1.Eth1Data eth1_data = 3001;
-  repeated v1.Eth1Data eth1_data_votes = 3002 [(ethereum.eth.ext.ssz_max) = "eth1_data_votes.size"];
-  uint64 eth1_deposit_index = 3003;
-
-  // Registry [4001-5000]
-  repeated v1.Validator validators = 4001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  repeated uint64 balances = 4002 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-
-  // Randomness [5001-6000]
-  repeated bytes randao_mixes = 5001 [(ethereum.eth.ext.ssz_size) = "randao_mixes.size"];
-
-  // Slashings [6001-7000]
-  repeated uint64 slashings = 6001 [(ethereum.eth.ext.ssz_size) = "slashings.size"];
-
-  // Participation [7001-8000]
-  bytes previous_epoch_participation = 7001 [(ethereum.eth.ext.ssz_max) = "1099511627776"]; // [New in Altair, replaced previous_epoch_attestations]
-  bytes current_epoch_participation = 7002 [(ethereum.eth.ext.ssz_max) = "1099511627776"]; // [New in Altair, replaced current_epoch_attestations]
-
-  // Finality [8001-9000]
-  // Spec type [4]Bitvector which means this would be a fixed size of 4 bits.
-  bytes justification_bits = 8001 [(ethereum.eth.ext.ssz_size) = "1", (ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/go-bitfield.Bitvector4"];
-  v1.Checkpoint previous_justified_checkpoint = 8002;
-  v1.Checkpoint current_justified_checkpoint = 8003;
-  v1.Checkpoint finalized_checkpoint = 8004;
-
-  // New Altair fields [9001-10000]
-  repeated uint64 inactivity_scores = 9001 [(ethereum.eth.ext.ssz_max) = "1099511627776"]; // [New in Altair]
-  SyncCommittee current_sync_committee = 9002; // [New in Altair]
-  SyncCommittee next_sync_committee = 9003; // [New in Altair]
-}
-
-message BeaconStateBellatrix {
-  // Versioning [1001-2000]
-  uint64 genesis_time = 1001;
-  bytes genesis_validators_root = 1002 [(ethereum.eth.ext.ssz_size) = "32"];
-  uint64 slot = 1003 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
-  v1.Fork fork = 1004;
-
-  // History [2001-3000]
-  v1.BeaconBlockHeader latest_block_header = 2001;
-  repeated bytes block_roots = 2002 [(ethereum.eth.ext.ssz_size) = "block_roots.size"];
-  repeated bytes state_roots = 2003 [(ethereum.eth.ext.ssz_size) = "state_roots.size"];
-  repeated bytes historical_roots = 2004 [(ethereum.eth.ext.ssz_size) = "?,32", (ethereum.eth.ext.ssz_max)  = "16777216"];
-
-  // Eth1 [3001-4000]
-  v1.Eth1Data eth1_data = 3001;
-  repeated v1.Eth1Data eth1_data_votes = 3002 [(ethereum.eth.ext.ssz_max) = "eth1_data_votes.size"];
-  uint64 eth1_deposit_index = 3003;
-
-  // Registry [4001-5000]
-  repeated v1.Validator validators = 4001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  repeated uint64 balances = 4002 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-
-  // Randomness [5001-6000]
-  repeated bytes randao_mixes = 5001 [(ethereum.eth.ext.ssz_size) = "randao_mixes.size"];
-
-  // Slashings [6001-7000]
-  repeated uint64 slashings = 6001 [(ethereum.eth.ext.ssz_size) = "slashings.size"];
-
-  // Participation [7001-8000]
-  bytes previous_epoch_participation = 7001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  bytes current_epoch_participation = 7002 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-
-  // Finality [8001-9000]
-  // Spec type [4]Bitvector which means this would be a fixed size of 4 bits.
-  bytes justification_bits = 8001 [(ethereum.eth.ext.ssz_size) = "1", (ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/go-bitfield.Bitvector4"];
-  v1.Checkpoint previous_justified_checkpoint = 8002;
-  v1.Checkpoint current_justified_checkpoint = 8003;
-  v1.Checkpoint finalized_checkpoint = 8004;
-
-  // Altair fields [9001-10000]
-  repeated uint64 inactivity_scores = 9001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  SyncCommittee current_sync_committee = 9002; // [New in Altair]
-  SyncCommittee next_sync_committee = 9003; // [New in Altair]
-
-  // Bellatrix fields [10001-11000]
-  engine.v1.ExecutionPayloadHeader latest_execution_payload_header = 10001; // [New in Bellatrix]
-}
-
-message BeaconStateCapella {
-  // Versioning [1001-2000]
-  uint64 genesis_time = 1001;
-  bytes genesis_validators_root = 1002 [(ethereum.eth.ext.ssz_size) = "32"];
-  uint64 slot = 1003 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
-  v1.Fork fork = 1004;
-
-  // History [2001-3000]
-  v1.BeaconBlockHeader latest_block_header = 2001;
-  repeated bytes block_roots = 2002 [(ethereum.eth.ext.ssz_size) = "block_roots.size"];
-  repeated bytes state_roots = 2003 [(ethereum.eth.ext.ssz_size) = "state_roots.size"];
-  repeated bytes historical_roots = 2004 [(ethereum.eth.ext.ssz_size) = "?,32", (ethereum.eth.ext.ssz_max)  = "16777216"];
-
-  // Eth1 [3001-4000]
-  v1.Eth1Data eth1_data = 3001;
-  repeated v1.Eth1Data eth1_data_votes = 3002 [(ethereum.eth.ext.ssz_max) = "eth1_data_votes.size"];
-  uint64 eth1_deposit_index = 3003;
-
-  // Registry [4001-5000]
-  repeated v1.Validator validators = 4001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  repeated uint64 balances = 4002 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-
-  // Randomness [5001-6000]
-  repeated bytes randao_mixes = 5001 [(ethereum.eth.ext.ssz_size) = "randao_mixes.size"];
-
-  // Slashings [6001-7000]
-  repeated uint64 slashings = 6001 [(ethereum.eth.ext.ssz_size) = "slashings.size"];
-
-  // Participation [7001-8000]
-  bytes previous_epoch_participation = 7001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  bytes current_epoch_participation = 7002 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-
-  // Finality [8001-9000]
-  // Spec type [4]Bitvector which means this would be a fixed size of 4 bits.
-  bytes justification_bits = 8001 [(ethereum.eth.ext.ssz_size) = "1", (ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/go-bitfield.Bitvector4"];
-  v1.Checkpoint previous_justified_checkpoint = 8002;
-  v1.Checkpoint current_justified_checkpoint = 8003;
-  v1.Checkpoint finalized_checkpoint = 8004;
-
-  // Altair fields [9001-10000]
-  repeated uint64 inactivity_scores = 9001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  SyncCommittee current_sync_committee = 9002; // [New in Altair]
-  SyncCommittee next_sync_committee = 9003; // [New in Altair]
-
-  // Bellatrix fields [10001-11000]
-  ethereum.engine.v1.ExecutionPayloadHeaderCapella latest_execution_payload_header = 10001; // [New in Bellatrix]
-
-  // Capella fields [11001-12000]
-  uint64 next_withdrawal_index = 11001; // [New in Capella]
-  uint64 next_withdrawal_validator_index = 11002 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.ValidatorIndex"]; // [New in Capella]
-
-  repeated HistoricalSummary historical_summaries = 11003 [(ethereum.eth.ext.ssz_max) = "16777216"]; // [New in Capella]
-}
-
-message BeaconStateDeneb {
-  // Versioning [1001-2000]
-  uint64 genesis_time = 1001;
-  bytes genesis_validators_root = 1002 [(ethereum.eth.ext.ssz_size) = "32"];
-  uint64 slot = 1003 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
-  v1.Fork fork = 1004;
-  // History [2001-3000]
-  v1.BeaconBlockHeader latest_block_header = 2001;
-  repeated bytes block_roots = 2002 [(ethereum.eth.ext.ssz_size) = "block_roots.size"];
-  repeated bytes state_roots = 2003 [(ethereum.eth.ext.ssz_size) = "state_roots.size"];
-  repeated bytes historical_roots = 2004 [(ethereum.eth.ext.ssz_size) = "?,32", (ethereum.eth.ext.ssz_max) = "16777216"];
-  // Eth1 [3001-4000]
-  v1.Eth1Data eth1_data = 3001;
-  repeated v1.Eth1Data eth1_data_votes = 3002 [(ethereum.eth.ext.ssz_max) = "eth1_data_votes.size"];
-  uint64 eth1_deposit_index = 3003;
-  // Registry [4001-5000]
-  repeated v1.Validator validators = 4001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  repeated uint64 balances = 4002 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  // Randomness [5001-6000]
-  repeated bytes randao_mixes = 5001 [(ethereum.eth.ext.ssz_size) = "randao_mixes.size"];
-  // Slashings [6001-7000]
-  repeated uint64 slashings = 6001 [(ethereum.eth.ext.ssz_size) = "slashings.size"];
-  // Participation [7001-8000]
-  bytes previous_epoch_participation = 7001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  bytes current_epoch_participation = 7002 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  // Finality [8001-9000]
-  // Spec type [4]Bitvector which means this would be a fixed size of 4 bits.
-  bytes justification_bits = 8001 [(ethereum.eth.ext.ssz_size) = "1", (ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/go-bitfield.Bitvector4"];
-  v1.Checkpoint previous_justified_checkpoint = 8002;
-  v1.Checkpoint current_justified_checkpoint = 8003;
-  v1.Checkpoint finalized_checkpoint = 8004;
-  // Altair fields [9001-10000]
-  repeated uint64 inactivity_scores = 9001 [(ethereum.eth.ext.ssz_max) = "1099511627776"];
-  SyncCommittee current_sync_committee = 9002; // [New in Altair]
-  SyncCommittee next_sync_committee = 9003; // [New in Altair]
-  // Bellatrix fields [10001-11000]
-  ethereum.engine.v1.ExecutionPayloadHeaderDeneb latest_execution_payload_header = 10001; // [Updated in Deneb]
-  // Capella fields [11001-12000]
-  uint64 next_withdrawal_index = 11001; // [New in Capella]
-  uint64 next_withdrawal_validator_index = 11002 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.ValidatorIndex"]; // [New in Capella]
-
-  repeated HistoricalSummary historical_summaries = 11003 [(ethereum.eth.ext.ssz_max) = "16777216"]; // [New in Capella]
-}
-
-message HistoricalSummary {
-  bytes block_summary_root = 1 [(ethereum.eth.ext.ssz_size) = "32"];
-  bytes state_summary_root = 2 [(ethereum.eth.ext.ssz_size) = "32"];
-}
-
-message BeaconStateSSZResponseV2 {
-  v2.Version version = 1;
-  bytes data = 2;
-}
-
-message ForkChoiceHeadsResponse {
-  repeated ForkChoiceHead data = 1;
-}
-
-message ForkChoiceHead {
-  bytes root = 1 [(ethereum.eth.ext.ssz_size) = "32"];
-  uint64 slot = 2 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
-  bool execution_optimistic = 3;
-}

proto/migration/BUILD.bazel

@@ -6,22 +6,15 @@ go_library(
         "enums.go",
         "v1alpha1_to_v1.go",
         "v1alpha1_to_v2.go",
-        "v2_to_v1alpha1.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/proto/migration",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/state:go_default_library",
-        "//config/fieldparams:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//encoding/ssz:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
 
@@ -30,22 +23,13 @@ go_test(
     srcs = [
         "enums_test.go",
         "v1alpha1_to_v1_test.go",
-        "v1alpha1_to_v2_test.go",
-        "v2_to_v1alpha1_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
-        "//config/fieldparams:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
 )

proto/migration/v1alpha1_to_v1.go

@@ -1,170 +1,10 @@
 package migration
 
 import (
-	"github.com/pkg/errors"
-	"google.golang.org/protobuf/proto"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
-// BlockIfaceToV1BlockHeader converts a signed beacon block interface into a signed beacon block header.
-func BlockIfaceToV1BlockHeader(block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv1.SignedBeaconBlockHeader, error) {
-	bodyRoot, err := block.Block().Body().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get body root of block")
-	}
-	parentRoot := block.Block().ParentRoot()
-	stateRoot := block.Block().StateRoot()
-	sig := block.Signature()
-	return &ethpbv1.SignedBeaconBlockHeader{
-		Message: &ethpbv1.BeaconBlockHeader{
-			Slot:          block.Block().Slot(),
-			ProposerIndex: block.Block().ProposerIndex(),
-			ParentRoot:    parentRoot[:],
-			StateRoot:     stateRoot[:],
-			BodyRoot:      bodyRoot[:],
-		},
-		Signature: sig[:],
-	}, nil
-}
-
-// V1Alpha1ToV1SignedBlock converts a v1alpha1 SignedBeaconBlock proto to a v1 proto.
-func V1Alpha1ToV1SignedBlock(alphaBlk *ethpbalpha.SignedBeaconBlock) (*ethpbv1.SignedBeaconBlock, error) {
-	marshaledBlk, err := proto.Marshal(alphaBlk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1Block := &ethpbv1.SignedBeaconBlock{}
-	if err := proto.Unmarshal(marshaledBlk, v1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1Block, nil
-}
-
-// V1ToV1Alpha1SignedBlock converts a v1 SignedBeaconBlock proto to a v1alpha1 proto.
-func V1ToV1Alpha1SignedBlock(v1Blk *ethpbv1.SignedBeaconBlock) (*ethpbalpha.SignedBeaconBlock, error) {
-	marshaledBlk, err := proto.Marshal(v1Blk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1alpha1Block := &ethpbalpha.SignedBeaconBlock{}
-	if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1alpha1Block, nil
-}
-
-// V1Alpha1ToV1Block converts a v1alpha1 ReadOnlyBeaconBlock proto to a v1 proto.
-func V1Alpha1ToV1Block(alphaBlk *ethpbalpha.BeaconBlock) (*ethpbv1.BeaconBlock, error) {
-	marshaledBlk, err := proto.Marshal(alphaBlk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1Block := &ethpbv1.BeaconBlock{}
-	if err := proto.Unmarshal(marshaledBlk, v1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1Block, nil
-}
-
-// V1Alpha1AggregateAttAndProofToV1 converts a v1alpha1 aggregate attestation and proof to v1.
-func V1Alpha1AggregateAttAndProofToV1(v1alpha1Att *ethpbalpha.AggregateAttestationAndProof) *ethpbv1.AggregateAttestationAndProof {
-	if v1alpha1Att == nil {
-		return &ethpbv1.AggregateAttestationAndProof{}
-	}
-	return &ethpbv1.AggregateAttestationAndProof{
-		AggregatorIndex: v1alpha1Att.AggregatorIndex,
-		Aggregate:       V1Alpha1AttestationToV1(v1alpha1Att.Aggregate),
-		SelectionProof:  v1alpha1Att.SelectionProof,
-	}
-}
-
-// V1SignedAggregateAttAndProofToV1Alpha1 converts a v1 signed aggregate attestation and proof to v1alpha1.
-func V1SignedAggregateAttAndProofToV1Alpha1(v1Att *ethpbv1.SignedAggregateAttestationAndProof) *ethpbalpha.SignedAggregateAttestationAndProof {
-	if v1Att == nil {
-		return &ethpbalpha.SignedAggregateAttestationAndProof{}
-	}
-	return &ethpbalpha.SignedAggregateAttestationAndProof{
-		Message: &ethpbalpha.AggregateAttestationAndProof{
-			AggregatorIndex: v1Att.Message.AggregatorIndex,
-			Aggregate:       V1AttestationToV1Alpha1(v1Att.Message.Aggregate),
-			SelectionProof:  v1Att.Message.SelectionProof,
-		},
-		Signature: v1Att.Signature,
-	}
-}
-
-// V1Alpha1IndexedAttToV1 converts a v1alpha1 indexed attestation to v1.
-func V1Alpha1IndexedAttToV1(v1alpha1Att *ethpbalpha.IndexedAttestation) *ethpbv1.IndexedAttestation {
-	if v1alpha1Att == nil {
-		return &ethpbv1.IndexedAttestation{}
-	}
-	return &ethpbv1.IndexedAttestation{
-		AttestingIndices: v1alpha1Att.AttestingIndices,
-		Data:             V1Alpha1AttDataToV1(v1alpha1Att.Data),
-		Signature:        v1alpha1Att.Signature,
-	}
-}
-
-// V1Alpha1AttestationToV1 converts a v1alpha1 attestation to v1.
-func V1Alpha1AttestationToV1(v1alpha1Att *ethpbalpha.Attestation) *ethpbv1.Attestation {
-	if v1alpha1Att == nil {
-		return &ethpbv1.Attestation{}
-	}
-	return &ethpbv1.Attestation{
-		AggregationBits: v1alpha1Att.AggregationBits,
-		Data:            V1Alpha1AttDataToV1(v1alpha1Att.Data),
-		Signature:       v1alpha1Att.Signature,
-	}
-}
-
-// V1AttestationToV1Alpha1 converts a v1 attestation to v1alpha1.
-func V1AttestationToV1Alpha1(v1Att *ethpbv1.Attestation) *ethpbalpha.Attestation {
-	if v1Att == nil {
-		return &ethpbalpha.Attestation{}
-	}
-	return &ethpbalpha.Attestation{
-		AggregationBits: v1Att.AggregationBits,
-		Data:            V1AttDataToV1Alpha1(v1Att.Data),
-		Signature:       v1Att.Signature,
-	}
-}
-
-// V1Alpha1AttDataToV1 converts a v1alpha1 attestation data to v1.
-func V1Alpha1AttDataToV1(v1alpha1AttData *ethpbalpha.AttestationData) *ethpbv1.AttestationData {
-	if v1alpha1AttData == nil || v1alpha1AttData.Source == nil || v1alpha1AttData.Target == nil {
-		return &ethpbv1.AttestationData{}
-	}
-	return &ethpbv1.AttestationData{
-		Slot:            v1alpha1AttData.Slot,
-		Index:           v1alpha1AttData.CommitteeIndex,
-		BeaconBlockRoot: v1alpha1AttData.BeaconBlockRoot,
-		Source: &ethpbv1.Checkpoint{
-			Root:  v1alpha1AttData.Source.Root,
-			Epoch: v1alpha1AttData.Source.Epoch,
-		},
-		Target: &ethpbv1.Checkpoint{
-			Root:  v1alpha1AttData.Target.Root,
-			Epoch: v1alpha1AttData.Target.Epoch,
-		},
-	}
-}
-
-// V1Alpha1AttSlashingToV1 converts a v1alpha1 attester slashing to v1.
-func V1Alpha1AttSlashingToV1(v1alpha1Slashing *ethpbalpha.AttesterSlashing) *ethpbv1.AttesterSlashing {
-	if v1alpha1Slashing == nil {
-		return &ethpbv1.AttesterSlashing{}
-	}
-	return &ethpbv1.AttesterSlashing{
-		Attestation_1: V1Alpha1IndexedAttToV1(v1alpha1Slashing.Attestation_1),
-		Attestation_2: V1Alpha1IndexedAttToV1(v1alpha1Slashing.Attestation_2),
-	}
-}
-
 // V1Alpha1SignedHeaderToV1 converts a v1alpha1 signed beacon block header to v1.
 func V1Alpha1SignedHeaderToV1(v1alpha1Hdr *ethpbalpha.SignedBeaconBlockHeader) *ethpbv1.SignedBeaconBlockHeader {
 	if v1alpha1Hdr == nil || v1alpha1Hdr.Header == nil {
@@ -191,23 +31,6 @@ func V1Alpha1HeaderToV1(v1alpha1Hdr *ethpbalpha.BeaconBlockHeader) *ethpbv1.Beac
 	}
 }
 
-// V1SignedHeaderToV1Alpha1 converts a v1 signed beacon block header to v1alpha1.
-func V1SignedHeaderToV1Alpha1(v1Header *ethpbv1.SignedBeaconBlockHeader) *ethpbalpha.SignedBeaconBlockHeader {
-	if v1Header == nil || v1Header.Message == nil {
-		return &ethpbalpha.SignedBeaconBlockHeader{}
-	}
-	return &ethpbalpha.SignedBeaconBlockHeader{
-		Header: &ethpbalpha.BeaconBlockHeader{
-			Slot:          v1Header.Message.Slot,
-			ProposerIndex: v1Header.Message.ProposerIndex,
-			ParentRoot:    v1Header.Message.ParentRoot,
-			StateRoot:     v1Header.Message.StateRoot,
-			BodyRoot:      v1Header.Message.BodyRoot,
-		},
-		Signature: v1Header.Signature,
-	}
-}
-
 // V1HeaderToV1Alpha1 converts a v1 beacon block header to v1alpha1.
 func V1HeaderToV1Alpha1(v1Header *ethpbv1.BeaconBlockHeader) *ethpbalpha.BeaconBlockHeader {
 	if v1Header == nil {
@@ -222,128 +45,6 @@ func V1HeaderToV1Alpha1(v1Header *ethpbv1.BeaconBlockHeader) *ethpbalpha.BeaconB
 	}
 }
 
-// V1Alpha1ProposerSlashingToV1 converts a v1alpha1 proposer slashing to v1.
-func V1Alpha1ProposerSlashingToV1(v1alpha1Slashing *ethpbalpha.ProposerSlashing) *ethpbv1.ProposerSlashing {
-	if v1alpha1Slashing == nil {
-		return &ethpbv1.ProposerSlashing{}
-	}
-	return &ethpbv1.ProposerSlashing{
-		SignedHeader_1: V1Alpha1SignedHeaderToV1(v1alpha1Slashing.Header_1),
-		SignedHeader_2: V1Alpha1SignedHeaderToV1(v1alpha1Slashing.Header_2),
-	}
-}
-
-// V1Alpha1ExitToV1 converts a v1alpha1 SignedVoluntaryExit to v1.
-func V1Alpha1ExitToV1(v1alpha1Exit *ethpbalpha.SignedVoluntaryExit) *ethpbv1.SignedVoluntaryExit {
-	if v1alpha1Exit == nil || v1alpha1Exit.Exit == nil {
-		return &ethpbv1.SignedVoluntaryExit{}
-	}
-	return &ethpbv1.SignedVoluntaryExit{
-		Message: &ethpbv1.VoluntaryExit{
-			Epoch:          v1alpha1Exit.Exit.Epoch,
-			ValidatorIndex: v1alpha1Exit.Exit.ValidatorIndex,
-		},
-		Signature: v1alpha1Exit.Signature,
-	}
-}
-
-// V1ExitToV1Alpha1 converts a v1 SignedVoluntaryExit to v1alpha1.
-func V1ExitToV1Alpha1(v1Exit *ethpbv1.SignedVoluntaryExit) *ethpbalpha.SignedVoluntaryExit {
-	if v1Exit == nil || v1Exit.Message == nil {
-		return &ethpbalpha.SignedVoluntaryExit{}
-	}
-	return &ethpbalpha.SignedVoluntaryExit{
-		Exit: &ethpbalpha.VoluntaryExit{
-			Epoch:          v1Exit.Message.Epoch,
-			ValidatorIndex: v1Exit.Message.ValidatorIndex,
-		},
-		Signature: v1Exit.Signature,
-	}
-}
-
-// V1AttToV1Alpha1 converts a v1 attestation to v1alpha1.
-func V1AttToV1Alpha1(v1Att *ethpbv1.Attestation) *ethpbalpha.Attestation {
-	if v1Att == nil {
-		return &ethpbalpha.Attestation{}
-	}
-	return &ethpbalpha.Attestation{
-		AggregationBits: v1Att.AggregationBits,
-		Data:            V1AttDataToV1Alpha1(v1Att.Data),
-		Signature:       v1Att.Signature,
-	}
-}
-
-// V1IndexedAttToV1Alpha1 converts a v1 indexed attestation to v1alpha1.
-func V1IndexedAttToV1Alpha1(v1Att *ethpbv1.IndexedAttestation) *ethpbalpha.IndexedAttestation {
-	if v1Att == nil {
-		return &ethpbalpha.IndexedAttestation{}
-	}
-	return &ethpbalpha.IndexedAttestation{
-		AttestingIndices: v1Att.AttestingIndices,
-		Data:             V1AttDataToV1Alpha1(v1Att.Data),
-		Signature:        v1Att.Signature,
-	}
-}
-
-// V1AttDataToV1Alpha1 converts a v1 attestation data to v1alpha1.
-func V1AttDataToV1Alpha1(v1AttData *ethpbv1.AttestationData) *ethpbalpha.AttestationData {
-	if v1AttData == nil || v1AttData.Source == nil || v1AttData.Target == nil {
-		return &ethpbalpha.AttestationData{}
-	}
-	return &ethpbalpha.AttestationData{
-		Slot:            v1AttData.Slot,
-		CommitteeIndex:  v1AttData.Index,
-		BeaconBlockRoot: v1AttData.BeaconBlockRoot,
-		Source: &ethpbalpha.Checkpoint{
-			Root:  v1AttData.Source.Root,
-			Epoch: v1AttData.Source.Epoch,
-		},
-		Target: &ethpbalpha.Checkpoint{
-			Root:  v1AttData.Target.Root,
-			Epoch: v1AttData.Target.Epoch,
-		},
-	}
-}
-
-// V1AttSlashingToV1Alpha1 converts a v1 attester slashing to v1alpha1.
-func V1AttSlashingToV1Alpha1(v1Slashing *ethpbv1.AttesterSlashing) *ethpbalpha.AttesterSlashing {
-	if v1Slashing == nil {
-		return &ethpbalpha.AttesterSlashing{}
-	}
-	return &ethpbalpha.AttesterSlashing{
-		Attestation_1: V1IndexedAttToV1Alpha1(v1Slashing.Attestation_1),
-		Attestation_2: V1IndexedAttToV1Alpha1(v1Slashing.Attestation_2),
-	}
-}
-
-// V1ProposerSlashingToV1Alpha1 converts a v1 proposer slashing to v1alpha1.
-func V1ProposerSlashingToV1Alpha1(v1Slashing *ethpbv1.ProposerSlashing) *ethpbalpha.ProposerSlashing {
-	if v1Slashing == nil {
-		return &ethpbalpha.ProposerSlashing{}
-	}
-	return &ethpbalpha.ProposerSlashing{
-		Header_1: V1SignedHeaderToV1Alpha1(v1Slashing.SignedHeader_1),
-		Header_2: V1SignedHeaderToV1Alpha1(v1Slashing.SignedHeader_2),
-	}
-}
-
-// V1Alpha1ValidatorToV1 converts a v1alpha1 validator to v1.
-func V1Alpha1ValidatorToV1(v1Alpha1Validator *ethpbalpha.Validator) *ethpbv1.Validator {
-	if v1Alpha1Validator == nil {
-		return &ethpbv1.Validator{}
-	}
-	return &ethpbv1.Validator{
-		Pubkey:                     v1Alpha1Validator.PublicKey,
-		WithdrawalCredentials:      v1Alpha1Validator.WithdrawalCredentials,
-		EffectiveBalance:           v1Alpha1Validator.EffectiveBalance,
-		Slashed:                    v1Alpha1Validator.Slashed,
-		ActivationEligibilityEpoch: v1Alpha1Validator.ActivationEligibilityEpoch,
-		ActivationEpoch:            v1Alpha1Validator.ActivationEpoch,
-		ExitEpoch:                  v1Alpha1Validator.ExitEpoch,
-		WithdrawableEpoch:          v1Alpha1Validator.WithdrawableEpoch,
-	}
-}
-
 // V1ValidatorToV1Alpha1 converts a v1 validator to v1alpha1.
 func V1ValidatorToV1Alpha1(v1Validator *ethpbv1.Validator) *ethpbalpha.Validator {
 	if v1Validator == nil {
@@ -360,161 +61,3 @@ func V1ValidatorToV1Alpha1(v1Validator *ethpbv1.Validator) *ethpbalpha.Validator
 		WithdrawableEpoch:          v1Validator.WithdrawableEpoch,
 	}
 }
-
-// SignedBeaconBlock converts a signed beacon block interface to a v1alpha1 block.
-func SignedBeaconBlock(block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv1.SignedBeaconBlock, error) {
-	if block == nil || block.IsNil() {
-		return nil, errors.New("could not find requested block")
-	}
-	blk, err := block.PbPhase0Block()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get raw block")
-	}
-
-	v1Block, err := V1Alpha1ToV1SignedBlock(blk)
-	if err != nil {
-		return nil, errors.New("could not convert block to v1 block")
-	}
-
-	return v1Block, nil
-}
-
-// BeaconStateToProto converts a state.BeaconState object to its protobuf equivalent.
-func BeaconStateToProto(state state.BeaconState) (*ethpbv1.BeaconState, error) {
-	sourceFork := state.Fork()
-	sourceLatestBlockHeader := state.LatestBlockHeader()
-	sourceEth1Data := state.Eth1Data()
-	sourceEth1DataVotes := state.Eth1DataVotes()
-	sourceValidators := state.Validators()
-	sourcePrevEpochAtts, err := state.PreviousEpochAttestations()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get previous epoch attestations from state")
-	}
-	sourceCurrEpochAtts, err := state.CurrentEpochAttestations()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get current epoch attestations from state")
-	}
-	sourceJustificationBits := state.JustificationBits()
-	sourcePrevJustifiedCheckpoint := state.PreviousJustifiedCheckpoint()
-	sourceCurrJustifiedCheckpoint := state.CurrentJustifiedCheckpoint()
-	sourceFinalizedCheckpoint := state.FinalizedCheckpoint()
-
-	resultEth1DataVotes := make([]*ethpbv1.Eth1Data, len(sourceEth1DataVotes))
-	for i, vote := range sourceEth1DataVotes {
-		resultEth1DataVotes[i] = &ethpbv1.Eth1Data{
-			DepositRoot:  bytesutil.SafeCopyBytes(vote.DepositRoot),
-			DepositCount: vote.DepositCount,
-			BlockHash:    bytesutil.SafeCopyBytes(vote.BlockHash),
-		}
-	}
-	resultValidators := make([]*ethpbv1.Validator, len(sourceValidators))
-	for i, validator := range sourceValidators {
-		resultValidators[i] = &ethpbv1.Validator{
-			Pubkey:                     bytesutil.SafeCopyBytes(validator.PublicKey),
-			WithdrawalCredentials:      bytesutil.SafeCopyBytes(validator.WithdrawalCredentials),
-			EffectiveBalance:           validator.EffectiveBalance,
-			Slashed:                    validator.Slashed,
-			ActivationEligibilityEpoch: validator.ActivationEligibilityEpoch,
-			ActivationEpoch:            validator.ActivationEpoch,
-			ExitEpoch:                  validator.ExitEpoch,
-			WithdrawableEpoch:          validator.WithdrawableEpoch,
-		}
-	}
-	resultPrevEpochAtts := make([]*ethpbv1.PendingAttestation, len(sourcePrevEpochAtts))
-	for i, att := range sourcePrevEpochAtts {
-		data := att.Data
-		resultPrevEpochAtts[i] = &ethpbv1.PendingAttestation{
-			AggregationBits: att.AggregationBits,
-			Data: &ethpbv1.AttestationData{
-				Slot:            data.Slot,
-				Index:           data.CommitteeIndex,
-				BeaconBlockRoot: data.BeaconBlockRoot,
-				Source: &ethpbv1.Checkpoint{
-					Epoch: data.Source.Epoch,
-					Root:  data.Source.Root,
-				},
-				Target: &ethpbv1.Checkpoint{
-					Epoch: data.Target.Epoch,
-					Root:  data.Target.Root,
-				},
-			},
-			InclusionDelay: att.InclusionDelay,
-			ProposerIndex:  att.ProposerIndex,
-		}
-	}
-	resultCurrEpochAtts := make([]*ethpbv1.PendingAttestation, len(sourceCurrEpochAtts))
-	for i, att := range sourceCurrEpochAtts {
-		data := att.Data
-		resultCurrEpochAtts[i] = &ethpbv1.PendingAttestation{
-			AggregationBits: att.AggregationBits,
-			Data: &ethpbv1.AttestationData{
-				Slot:            data.Slot,
-				Index:           data.CommitteeIndex,
-				BeaconBlockRoot: data.BeaconBlockRoot,
-				Source: &ethpbv1.Checkpoint{
-					Epoch: data.Source.Epoch,
-					Root:  data.Source.Root,
-				},
-				Target: &ethpbv1.Checkpoint{
-					Epoch: data.Target.Epoch,
-					Root:  data.Target.Root,
-				},
-			},
-			InclusionDelay: att.InclusionDelay,
-			ProposerIndex:  att.ProposerIndex,
-		}
-	}
-
-	hRoot, err := state.HistoricalRoots()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not get historical roots from state")
-	}
-	result := &ethpbv1.BeaconState{
-		GenesisTime:           state.GenesisTime(),
-		GenesisValidatorsRoot: bytesutil.SafeCopyBytes(state.GenesisValidatorsRoot()),
-		Slot:                  state.Slot(),
-		Fork: &ethpbv1.Fork{
-			PreviousVersion: bytesutil.SafeCopyBytes(sourceFork.PreviousVersion),
-			CurrentVersion:  bytesutil.SafeCopyBytes(sourceFork.CurrentVersion),
-			Epoch:           sourceFork.Epoch,
-		},
-		LatestBlockHeader: &ethpbv1.BeaconBlockHeader{
-			Slot:          sourceLatestBlockHeader.Slot,
-			ProposerIndex: sourceLatestBlockHeader.ProposerIndex,
-			ParentRoot:    bytesutil.SafeCopyBytes(sourceLatestBlockHeader.ParentRoot),
-			StateRoot:     bytesutil.SafeCopyBytes(sourceLatestBlockHeader.StateRoot),
-			BodyRoot:      bytesutil.SafeCopyBytes(sourceLatestBlockHeader.BodyRoot),
-		},
-		BlockRoots:      bytesutil.SafeCopy2dBytes(state.BlockRoots()),
-		StateRoots:      bytesutil.SafeCopy2dBytes(state.StateRoots()),
-		HistoricalRoots: bytesutil.SafeCopy2dBytes(hRoot),
-		Eth1Data: &ethpbv1.Eth1Data{
-			DepositRoot:  bytesutil.SafeCopyBytes(sourceEth1Data.DepositRoot),
-			DepositCount: sourceEth1Data.DepositCount,
-			BlockHash:    bytesutil.SafeCopyBytes(sourceEth1Data.BlockHash),
-		},
-		Eth1DataVotes:             resultEth1DataVotes,
-		Eth1DepositIndex:          state.Eth1DepositIndex(),
-		Validators:                resultValidators,
-		Balances:                  state.Balances(),
-		RandaoMixes:               bytesutil.SafeCopy2dBytes(state.RandaoMixes()),
-		Slashings:                 state.Slashings(),
-		PreviousEpochAttestations: resultPrevEpochAtts,
-		CurrentEpochAttestations:  resultCurrEpochAtts,
-		JustificationBits:         bytesutil.SafeCopyBytes(sourceJustificationBits),
-		PreviousJustifiedCheckpoint: &ethpbv1.Checkpoint{
-			Epoch: sourcePrevJustifiedCheckpoint.Epoch,
-			Root:  bytesutil.SafeCopyBytes(sourcePrevJustifiedCheckpoint.Root),
-		},
-		CurrentJustifiedCheckpoint: &ethpbv1.Checkpoint{
-			Epoch: sourceCurrJustifiedCheckpoint.Epoch,
-			Root:  bytesutil.SafeCopyBytes(sourceCurrJustifiedCheckpoint.Root),
-		},
-		FinalizedCheckpoint: &ethpbv1.Checkpoint{
-			Epoch: sourceFinalizedCheckpoint.Epoch,
-			Root:  bytesutil.SafeCopyBytes(sourceFinalizedCheckpoint.Root),
-		},
-	}
-
-	return result, nil
-}

proto/migration/v1alpha1_to_v1_test.go

@@ -3,403 +3,12 @@ package migration
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/go-bitfield"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
-	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-var (
-	slot             = primitives.Slot(1)
-	epoch            = primitives.Epoch(1)
-	validatorIndex   = primitives.ValidatorIndex(1)
-	committeeIndex   = primitives.CommitteeIndex(1)
-	depositCount     = uint64(2)
-	attestingIndices = []uint64{1, 2}
-	blockNumber      = uint64(10)
-	gasLimit         = uint64(10)
-	gasUsed          = uint64(10)
-	timestamp        = uint64(10)
-	parentRoot       = bytesutil.PadTo([]byte("parentroot"), fieldparams.RootLength)
-	stateRoot        = bytesutil.PadTo([]byte("stateroot"), fieldparams.RootLength)
-	signature        = bytesutil.PadTo([]byte("signature"), 96)
-	randaoReveal     = bytesutil.PadTo([]byte("randaoreveal"), 96)
-	depositRoot      = bytesutil.PadTo([]byte("depositroot"), fieldparams.RootLength)
-	blockHash        = bytesutil.PadTo([]byte("blockhash"), 32)
-	beaconBlockRoot  = bytesutil.PadTo([]byte("beaconblockroot"), fieldparams.RootLength)
-	sourceRoot       = bytesutil.PadTo([]byte("sourceroot"), fieldparams.RootLength)
-	targetRoot       = bytesutil.PadTo([]byte("targetroot"), fieldparams.RootLength)
-	bodyRoot         = bytesutil.PadTo([]byte("bodyroot"), fieldparams.RootLength)
-	selectionProof   = bytesutil.PadTo([]byte("selectionproof"), 96)
-	parentHash       = bytesutil.PadTo([]byte("parenthash"), 32)
-	feeRecipient     = bytesutil.PadTo([]byte("feerecipient"), 20)
-	receiptsRoot     = bytesutil.PadTo([]byte("receiptsroot"), 32)
-	logsBloom        = bytesutil.PadTo([]byte("logsbloom"), 256)
-	prevRandao       = bytesutil.PadTo([]byte("prevrandao"), 32)
-	extraData        = bytesutil.PadTo([]byte("extradata"), 32)
-	baseFeePerGas    = bytesutil.PadTo([]byte("basefeepergas"), 32)
-	transactionsRoot = bytesutil.PadTo([]byte("transactions"), 32)
-	aggregationBits  = bitfield.Bitlist{0x01}
-)
-
-func Test_BlockIfaceToV1BlockHeader(t *testing.T) {
-	alphaBlock := util.HydrateSignedBeaconBlock(&ethpbalpha.SignedBeaconBlock{})
-	alphaBlock.Block.Slot = slot
-	alphaBlock.Block.ProposerIndex = validatorIndex
-	alphaBlock.Block.ParentRoot = parentRoot
-	alphaBlock.Block.StateRoot = stateRoot
-	alphaBlock.Signature = signature
-
-	wsb, err := blocks.NewSignedBeaconBlock(alphaBlock)
-	require.NoError(t, err)
-	v1Header, err := BlockIfaceToV1BlockHeader(wsb)
-	require.NoError(t, err)
-	bodyRoot, err := alphaBlock.Block.Body.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, bodyRoot[:], v1Header.Message.BodyRoot)
-	assert.Equal(t, slot, v1Header.Message.Slot)
-	assert.Equal(t, validatorIndex, v1Header.Message.ProposerIndex)
-	assert.DeepEqual(t, parentRoot, v1Header.Message.ParentRoot)
-	assert.DeepEqual(t, stateRoot, v1Header.Message.StateRoot)
-	assert.DeepEqual(t, signature, v1Header.Signature)
-}
-
-func Test_V1Alpha1AggregateAttAndProofToV1(t *testing.T) {
-	proof := [32]byte{1}
-	att := util.HydrateAttestation(&ethpbalpha.Attestation{
-		Data: &ethpbalpha.AttestationData{
-			Slot: 5,
-		},
-	})
-	alpha := &ethpbalpha.AggregateAttestationAndProof{
-		AggregatorIndex: 1,
-		Aggregate:       att,
-		SelectionProof:  proof[:],
-	}
-	v1 := V1Alpha1AggregateAttAndProofToV1(alpha)
-	assert.Equal(t, v1.AggregatorIndex, primitives.ValidatorIndex(1))
-	assert.DeepSSZEqual(t, v1.Aggregate.Data.Slot, att.Data.Slot)
-	assert.DeepEqual(t, v1.SelectionProof, proof[:])
-}
-
-func Test_V1Alpha1ToV1SignedBlock(t *testing.T) {
-	alphaBlock := util.HydrateSignedBeaconBlock(&ethpbalpha.SignedBeaconBlock{})
-	alphaBlock.Block.Slot = slot
-	alphaBlock.Block.ProposerIndex = validatorIndex
-	alphaBlock.Block.ParentRoot = parentRoot
-	alphaBlock.Block.StateRoot = stateRoot
-	alphaBlock.Block.Body.RandaoReveal = randaoReveal
-	alphaBlock.Block.Body.Eth1Data = &ethpbalpha.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	alphaBlock.Signature = signature
-
-	v1Block, err := V1Alpha1ToV1SignedBlock(alphaBlock)
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	v1Root, err := v1Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v1Root)
-}
-
-func Test_V1ToV1Alpha1SignedBlock(t *testing.T) {
-	v1Block := util.HydrateV1SignedBeaconBlock(&ethpbv1.SignedBeaconBlock{})
-	v1Block.Block.Slot = slot
-	v1Block.Block.ProposerIndex = validatorIndex
-	v1Block.Block.ParentRoot = parentRoot
-	v1Block.Block.StateRoot = stateRoot
-	v1Block.Block.Body.RandaoReveal = randaoReveal
-	v1Block.Block.Body.Eth1Data = &ethpbv1.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	v1Block.Signature = signature
-
-	alphaBlock, err := V1ToV1Alpha1SignedBlock(v1Block)
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	v1Root, err := v1Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v1Root, alphaRoot)
-}
-
-func Test_V1ToV1Alpha1Block(t *testing.T) {
-	alphaBlock := util.HydrateBeaconBlock(&ethpbalpha.BeaconBlock{})
-	alphaBlock.Slot = slot
-	alphaBlock.ProposerIndex = validatorIndex
-	alphaBlock.ParentRoot = parentRoot
-	alphaBlock.StateRoot = stateRoot
-	alphaBlock.Body.RandaoReveal = randaoReveal
-	alphaBlock.Body.Eth1Data = &ethpbalpha.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-
-	v1Block, err := V1Alpha1ToV1Block(alphaBlock)
-	require.NoError(t, err)
-	v1Root, err := v1Block.HashTreeRoot()
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v1Root)
-}
-
-func Test_V1Alpha1AttSlashingToV1(t *testing.T) {
-	alphaAttestation := &ethpbalpha.IndexedAttestation{
-		AttestingIndices: attestingIndices,
-		Data: &ethpbalpha.AttestationData{
-			Slot:            slot,
-			CommitteeIndex:  committeeIndex,
-			BeaconBlockRoot: beaconBlockRoot,
-			Source: &ethpbalpha.Checkpoint{
-				Epoch: epoch,
-				Root:  sourceRoot,
-			},
-			Target: &ethpbalpha.Checkpoint{
-				Epoch: epoch,
-				Root:  targetRoot,
-			},
-		},
-		Signature: signature,
-	}
-	alphaSlashing := &ethpbalpha.AttesterSlashing{
-		Attestation_1: alphaAttestation,
-		Attestation_2: alphaAttestation,
-	}
-
-	v1Slashing := V1Alpha1AttSlashingToV1(alphaSlashing)
-	alphaRoot, err := alphaSlashing.HashTreeRoot()
-	require.NoError(t, err)
-	v1Root, err := v1Slashing.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v1Root)
-}
-
-func Test_V1Alpha1ProposerSlashingToV1(t *testing.T) {
-	alphaHeader := util.HydrateSignedBeaconHeader(&ethpbalpha.SignedBeaconBlockHeader{})
-	alphaHeader.Header.Slot = slot
-	alphaHeader.Header.ProposerIndex = validatorIndex
-	alphaHeader.Header.ParentRoot = parentRoot
-	alphaHeader.Header.StateRoot = stateRoot
-	alphaHeader.Header.BodyRoot = bodyRoot
-	alphaHeader.Signature = signature
-	alphaSlashing := &ethpbalpha.ProposerSlashing{
-		Header_1: alphaHeader,
-		Header_2: alphaHeader,
-	}
-
-	v1Slashing := V1Alpha1ProposerSlashingToV1(alphaSlashing)
-	alphaRoot, err := alphaSlashing.HashTreeRoot()
-	require.NoError(t, err)
-	v1Root, err := v1Slashing.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v1Root)
-}
-
-func Test_V1Alpha1ExitToV1(t *testing.T) {
-	alphaExit := &ethpbalpha.SignedVoluntaryExit{
-		Exit: &ethpbalpha.VoluntaryExit{
-			Epoch:          epoch,
-			ValidatorIndex: validatorIndex,
-		},
-		Signature: signature,
-	}
-
-	v1Exit := V1Alpha1ExitToV1(alphaExit)
-	alphaRoot, err := alphaExit.HashTreeRoot()
-	require.NoError(t, err)
-	v1Root, err := v1Exit.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v1Root)
-}
-
-func Test_V1ExitToV1Alpha1(t *testing.T) {
-	v1Exit := &ethpbv1.SignedVoluntaryExit{
-		Message: &ethpbv1.VoluntaryExit{
-			Epoch:          epoch,
-			ValidatorIndex: validatorIndex,
-		},
-		Signature: signature,
-	}
-
-	alphaExit := V1ExitToV1Alpha1(v1Exit)
-	alphaRoot, err := alphaExit.HashTreeRoot()
-	require.NoError(t, err)
-	v1Root, err := v1Exit.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v1Root)
-}
-
-func Test_V1AttSlashingToV1Alpha1(t *testing.T) {
-	v1Attestation := &ethpbv1.IndexedAttestation{
-		AttestingIndices: attestingIndices,
-		Data: &ethpbv1.AttestationData{
-			Slot:            slot,
-			Index:           committeeIndex,
-			BeaconBlockRoot: beaconBlockRoot,
-			Source: &ethpbv1.Checkpoint{
-				Epoch: epoch,
-				Root:  sourceRoot,
-			},
-			Target: &ethpbv1.Checkpoint{
-				Epoch: epoch,
-				Root:  targetRoot,
-			},
-		},
-		Signature: signature,
-	}
-	v1Slashing := &ethpbv1.AttesterSlashing{
-		Attestation_1: v1Attestation,
-		Attestation_2: v1Attestation,
-	}
-
-	alphaSlashing := V1AttSlashingToV1Alpha1(v1Slashing)
-	alphaRoot, err := alphaSlashing.HashTreeRoot()
-	require.NoError(t, err)
-	v1Root, err := v1Slashing.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v1Root, alphaRoot)
-}
-
-func Test_V1ProposerSlashingToV1Alpha1(t *testing.T) {
-	v1Header := &ethpbv1.SignedBeaconBlockHeader{
-		Message: &ethpbv1.BeaconBlockHeader{
-			Slot:          slot,
-			ProposerIndex: validatorIndex,
-			ParentRoot:    parentRoot,
-			StateRoot:     stateRoot,
-			BodyRoot:      bodyRoot,
-		},
-		Signature: signature,
-	}
-	v1Slashing := &ethpbv1.ProposerSlashing{
-		SignedHeader_1: v1Header,
-		SignedHeader_2: v1Header,
-	}
-
-	alphaSlashing := V1ProposerSlashingToV1Alpha1(v1Slashing)
-	alphaRoot, err := alphaSlashing.HashTreeRoot()
-	require.NoError(t, err)
-	v1Root, err := v1Slashing.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v1Root)
-}
-
-func Test_V1Alpha1AttToV1(t *testing.T) {
-	alphaAtt := &ethpbalpha.Attestation{
-		AggregationBits: aggregationBits,
-		Data: &ethpbalpha.AttestationData{
-			Slot:            slot,
-			CommitteeIndex:  committeeIndex,
-			BeaconBlockRoot: beaconBlockRoot,
-			Source: &ethpbalpha.Checkpoint{
-				Epoch: epoch,
-				Root:  sourceRoot,
-			},
-			Target: &ethpbalpha.Checkpoint{
-				Epoch: epoch,
-				Root:  targetRoot,
-			},
-		},
-		Signature: signature,
-	}
-
-	v1Att := V1Alpha1AttestationToV1(alphaAtt)
-	v1Root, err := v1Att.HashTreeRoot()
-	require.NoError(t, err)
-	alphaRoot, err := alphaAtt.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v1Root, alphaRoot)
-}
-
-func Test_V1AttToV1Alpha1(t *testing.T) {
-	v1Att := &ethpbv1.Attestation{
-		AggregationBits: aggregationBits,
-		Data: &ethpbv1.AttestationData{
-			Slot:            slot,
-			Index:           committeeIndex,
-			BeaconBlockRoot: beaconBlockRoot,
-			Source: &ethpbv1.Checkpoint{
-				Epoch: epoch,
-				Root:  sourceRoot,
-			},
-			Target: &ethpbv1.Checkpoint{
-				Epoch: epoch,
-				Root:  targetRoot,
-			},
-		},
-		Signature: signature,
-	}
-
-	alphaAtt := V1AttToV1Alpha1(v1Att)
-	alphaRoot, err := alphaAtt.HashTreeRoot()
-	require.NoError(t, err)
-	v1Root, err := v1Att.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v1Root, alphaRoot)
-}
-
-func Test_BlockInterfaceToV1Block(t *testing.T) {
-	v1Alpha1Block := util.HydrateSignedBeaconBlock(&ethpbalpha.SignedBeaconBlock{})
-	v1Alpha1Block.Block.Slot = slot
-	v1Alpha1Block.Block.ProposerIndex = validatorIndex
-	v1Alpha1Block.Block.ParentRoot = parentRoot
-	v1Alpha1Block.Block.StateRoot = stateRoot
-	v1Alpha1Block.Block.Body.RandaoReveal = randaoReveal
-	v1Alpha1Block.Block.Body.Eth1Data = &ethpbalpha.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	v1Alpha1Block.Signature = signature
-
-	wsb, err := blocks.NewSignedBeaconBlock(v1Alpha1Block)
-	require.NoError(t, err)
-	v1Block, err := SignedBeaconBlock(wsb)
-	require.NoError(t, err)
-	v1Root, err := v1Block.HashTreeRoot()
-	require.NoError(t, err)
-	v1Alpha1Root, err := v1Alpha1Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v1Root, v1Alpha1Root)
-}
-
-func Test_V1Alpha1ValidatorToV1(t *testing.T) {
-	v1Alpha1Validator := &ethpbalpha.Validator{
-		PublicKey:                  []byte("pubkey"),
-		WithdrawalCredentials:      []byte("withdraw"),
-		EffectiveBalance:           99,
-		Slashed:                    true,
-		ActivationEligibilityEpoch: 1,
-		ActivationEpoch:            11,
-		ExitEpoch:                  111,
-		WithdrawableEpoch:          1111,
-	}
-
-	v1Validator := V1Alpha1ValidatorToV1(v1Alpha1Validator)
-	require.NotNil(t, v1Validator)
-	assert.DeepEqual(t, []byte("pubkey"), v1Validator.Pubkey)
-	assert.DeepEqual(t, []byte("withdraw"), v1Validator.WithdrawalCredentials)
-	assert.Equal(t, uint64(99), v1Validator.EffectiveBalance)
-	assert.Equal(t, true, v1Validator.Slashed)
-	assert.Equal(t, primitives.Epoch(1), v1Validator.ActivationEligibilityEpoch)
-	assert.Equal(t, primitives.Epoch(11), v1Validator.ActivationEpoch)
-	assert.Equal(t, primitives.Epoch(111), v1Validator.ExitEpoch)
-	assert.Equal(t, primitives.Epoch(1111), v1Validator.WithdrawableEpoch)
-}
-
 func Test_V1ValidatorToV1Alpha1(t *testing.T) {
 	v1Validator := &ethpbv1.Validator{
 		Pubkey:                     []byte("pubkey"),
@@ -423,231 +32,3 @@ func Test_V1ValidatorToV1Alpha1(t *testing.T) {
 	assert.Equal(t, primitives.Epoch(111), v1Alpha1Validator.ExitEpoch)
 	assert.Equal(t, primitives.Epoch(1111), v1Alpha1Validator.WithdrawableEpoch)
 }
-
-func Test_V1SignedAggregateAttAndProofToV1Alpha1(t *testing.T) {
-	v1Att := &ethpbv1.SignedAggregateAttestationAndProof{
-		Message: &ethpbv1.AggregateAttestationAndProof{
-			AggregatorIndex: 1,
-			Aggregate:       util.HydrateV1Attestation(&ethpbv1.Attestation{}),
-			SelectionProof:  selectionProof,
-		},
-		Signature: signature,
-	}
-	v1Alpha1Att := V1SignedAggregateAttAndProofToV1Alpha1(v1Att)
-
-	v1Root, err := v1Att.HashTreeRoot()
-	require.NoError(t, err)
-	v1Alpha1Root, err := v1Alpha1Att.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v1Root, v1Alpha1Root)
-}
-
-func Test_V1AttestationToV1Alpha1(t *testing.T) {
-	v1Att := util.HydrateV1Attestation(&ethpbv1.Attestation{})
-	v1Alpha1Att := V1AttToV1Alpha1(v1Att)
-
-	v1Root, err := v1Att.HashTreeRoot()
-	require.NoError(t, err)
-	v1Alpha1Root, err := v1Alpha1Att.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v1Root, v1Alpha1Root)
-}
-func TestBeaconStateToProto(t *testing.T) {
-	source, err := util.NewBeaconState(util.FillRootsNaturalOpt, func(state *ethpbalpha.BeaconState) error {
-		state.GenesisTime = 1
-		state.GenesisValidatorsRoot = bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32)
-		state.Slot = 2
-		state.Fork = &ethpbalpha.Fork{
-			PreviousVersion: bytesutil.PadTo([]byte("123"), 4),
-			CurrentVersion:  bytesutil.PadTo([]byte("456"), 4),
-			Epoch:           3,
-		}
-		state.LatestBlockHeader = &ethpbalpha.BeaconBlockHeader{
-			Slot:          4,
-			ProposerIndex: 5,
-			ParentRoot:    bytesutil.PadTo([]byte("lbhparentroot"), 32),
-			StateRoot:     bytesutil.PadTo([]byte("lbhstateroot"), 32),
-			BodyRoot:      bytesutil.PadTo([]byte("lbhbodyroot"), 32),
-		}
-		state.BlockRoots = [][]byte{bytesutil.PadTo([]byte("blockroots"), 32)}
-		state.StateRoots = [][]byte{bytesutil.PadTo([]byte("stateroots"), 32)}
-		state.HistoricalRoots = [][]byte{bytesutil.PadTo([]byte("historicalroots"), 32)}
-		state.Eth1Data = &ethpbalpha.Eth1Data{
-			DepositRoot:  bytesutil.PadTo([]byte("e1ddepositroot"), 32),
-			DepositCount: 6,
-			BlockHash:    bytesutil.PadTo([]byte("e1dblockhash"), 32),
-		}
-		state.Eth1DataVotes = []*ethpbalpha.Eth1Data{{
-			DepositRoot:  bytesutil.PadTo([]byte("e1dvdepositroot"), 32),
-			DepositCount: 7,
-			BlockHash:    bytesutil.PadTo([]byte("e1dvblockhash"), 32),
-		}}
-		state.Eth1DepositIndex = 8
-		state.Validators = []*ethpbalpha.Validator{{
-			PublicKey:                  bytesutil.PadTo([]byte("publickey"), 48),
-			WithdrawalCredentials:      bytesutil.PadTo([]byte("withdrawalcredentials"), 32),
-			EffectiveBalance:           9,
-			Slashed:                    true,
-			ActivationEligibilityEpoch: 10,
-			ActivationEpoch:            11,
-			ExitEpoch:                  12,
-			WithdrawableEpoch:          13,
-		}}
-		state.Balances = []uint64{14}
-		state.RandaoMixes = [][]byte{bytesutil.PadTo([]byte("randaomixes"), 32)}
-		state.Slashings = []uint64{15}
-		state.PreviousEpochAttestations = []*ethpbalpha.PendingAttestation{{
-			AggregationBits: bitfield.Bitlist{16},
-			Data: &ethpbalpha.AttestationData{
-				Slot:            17,
-				CommitteeIndex:  18,
-				BeaconBlockRoot: bytesutil.PadTo([]byte("peabeaconblockroot"), 32),
-				Source: &ethpbalpha.Checkpoint{
-					Epoch: 19,
-					Root:  bytesutil.PadTo([]byte("peasroot"), 32),
-				},
-				Target: &ethpbalpha.Checkpoint{
-					Epoch: 20,
-					Root:  bytesutil.PadTo([]byte("peatroot"), 32),
-				},
-			},
-			InclusionDelay: 21,
-			ProposerIndex:  22,
-		}}
-		state.CurrentEpochAttestations = []*ethpbalpha.PendingAttestation{{
-			AggregationBits: bitfield.Bitlist{23},
-			Data: &ethpbalpha.AttestationData{
-				Slot:            24,
-				CommitteeIndex:  25,
-				BeaconBlockRoot: bytesutil.PadTo([]byte("ceabeaconblockroot"), 32),
-				Source: &ethpbalpha.Checkpoint{
-					Epoch: 26,
-					Root:  bytesutil.PadTo([]byte("ceasroot"), 32),
-				},
-				Target: &ethpbalpha.Checkpoint{
-					Epoch: 27,
-					Root:  bytesutil.PadTo([]byte("ceatroot"), 32),
-				},
-			},
-			InclusionDelay: 28,
-			ProposerIndex:  29,
-		}}
-		state.JustificationBits = bitfield.Bitvector4{1}
-		state.PreviousJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 30,
-			Root:  bytesutil.PadTo([]byte("pjcroot"), 32),
-		}
-		state.CurrentJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 31,
-			Root:  bytesutil.PadTo([]byte("cjcroot"), 32),
-		}
-		state.FinalizedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 32,
-			Root:  bytesutil.PadTo([]byte("fcroot"), 32),
-		}
-		return nil
-	})
-	require.NoError(t, err)
-
-	result, err := BeaconStateToProto(source)
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	assert.Equal(t, uint64(1), result.GenesisTime)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32), result.GenesisValidatorsRoot)
-	assert.Equal(t, primitives.Slot(2), result.Slot)
-	resultFork := result.Fork
-	require.NotNil(t, resultFork)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("123"), 4), resultFork.PreviousVersion)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("456"), 4), resultFork.CurrentVersion)
-	assert.Equal(t, primitives.Epoch(3), resultFork.Epoch)
-	resultLatestBlockHeader := result.LatestBlockHeader
-	require.NotNil(t, resultLatestBlockHeader)
-	assert.Equal(t, primitives.Slot(4), resultLatestBlockHeader.Slot)
-	assert.Equal(t, primitives.ValidatorIndex(5), resultLatestBlockHeader.ProposerIndex)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhparentroot"), 32), resultLatestBlockHeader.ParentRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhstateroot"), 32), resultLatestBlockHeader.StateRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhbodyroot"), 32), resultLatestBlockHeader.BodyRoot)
-	assert.Equal(t, 8192, len(result.BlockRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blockroots"), 32), result.BlockRoots[0])
-	assert.Equal(t, 8192, len(result.StateRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("stateroots"), 32), result.StateRoots[0])
-	assert.Equal(t, 1, len(result.HistoricalRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("historicalroots"), 32), result.HistoricalRoots[0])
-	resultEth1Data := result.Eth1Data
-	require.NotNil(t, resultEth1Data)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1ddepositroot"), 32), resultEth1Data.DepositRoot)
-	assert.Equal(t, uint64(6), resultEth1Data.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dblockhash"), 32), resultEth1Data.BlockHash)
-	require.Equal(t, 1, len(result.Eth1DataVotes))
-	resultEth1DataVote := result.Eth1DataVotes[0]
-	require.NotNil(t, resultEth1DataVote)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvdepositroot"), 32), resultEth1DataVote.DepositRoot)
-	assert.Equal(t, uint64(7), resultEth1DataVote.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvblockhash"), 32), resultEth1DataVote.BlockHash)
-	assert.Equal(t, uint64(8), result.Eth1DepositIndex)
-	require.Equal(t, 1, len(result.Validators))
-	resultValidator := result.Validators[0]
-	require.NotNil(t, resultValidator)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("publickey"), 48), resultValidator.Pubkey)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("withdrawalcredentials"), 32), resultValidator.WithdrawalCredentials)
-	assert.Equal(t, uint64(9), resultValidator.EffectiveBalance)
-	assert.Equal(t, true, resultValidator.Slashed)
-	assert.Equal(t, primitives.Epoch(10), resultValidator.ActivationEligibilityEpoch)
-	assert.Equal(t, primitives.Epoch(11), resultValidator.ActivationEpoch)
-	assert.Equal(t, primitives.Epoch(12), resultValidator.ExitEpoch)
-	assert.Equal(t, primitives.Epoch(13), resultValidator.WithdrawableEpoch)
-	assert.DeepEqual(t, []uint64{14}, result.Balances)
-	assert.Equal(t, 65536, len(result.RandaoMixes))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("randaomixes"), 32), result.RandaoMixes[0])
-	assert.DeepEqual(t, []uint64{15}, result.Slashings)
-	require.Equal(t, 1, len(result.PreviousEpochAttestations))
-	resultPrevEpochAtt := result.PreviousEpochAttestations[0]
-	require.NotNil(t, resultPrevEpochAtt)
-	assert.DeepEqual(t, bitfield.Bitlist{16}, resultPrevEpochAtt.AggregationBits)
-	resultPrevEpochAttData := resultPrevEpochAtt.Data
-	require.NotNil(t, resultPrevEpochAttData)
-	assert.Equal(t, primitives.Slot(17), resultPrevEpochAttData.Slot)
-	assert.Equal(t, primitives.CommitteeIndex(18), resultPrevEpochAttData.Index)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("peabeaconblockroot"), 32), resultPrevEpochAttData.BeaconBlockRoot)
-	resultPrevEpochAttSource := resultPrevEpochAttData.Source
-	require.NotNil(t, resultPrevEpochAttSource)
-	assert.Equal(t, primitives.Epoch(19), resultPrevEpochAttSource.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("peasroot"), 32), resultPrevEpochAttSource.Root)
-	resultPrevEpochAttTarget := resultPrevEpochAttData.Target
-	require.NotNil(t, resultPrevEpochAttTarget)
-	assert.Equal(t, primitives.Epoch(20), resultPrevEpochAttTarget.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("peatroot"), 32), resultPrevEpochAttTarget.Root)
-	assert.Equal(t, primitives.Slot(21), resultPrevEpochAtt.InclusionDelay)
-	assert.Equal(t, primitives.ValidatorIndex(22), resultPrevEpochAtt.ProposerIndex)
-	resultCurrEpochAtt := result.CurrentEpochAttestations[0]
-	require.NotNil(t, resultCurrEpochAtt)
-	assert.DeepEqual(t, bitfield.Bitlist{23}, resultCurrEpochAtt.AggregationBits)
-	resultCurrEpochAttData := resultCurrEpochAtt.Data
-	require.NotNil(t, resultCurrEpochAttData)
-	assert.Equal(t, primitives.Slot(24), resultCurrEpochAttData.Slot)
-	assert.Equal(t, primitives.CommitteeIndex(25), resultCurrEpochAttData.Index)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("ceabeaconblockroot"), 32), resultCurrEpochAttData.BeaconBlockRoot)
-	resultCurrEpochAttSource := resultCurrEpochAttData.Source
-	require.NotNil(t, resultCurrEpochAttSource)
-	assert.Equal(t, primitives.Epoch(26), resultCurrEpochAttSource.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("ceasroot"), 32), resultCurrEpochAttSource.Root)
-	resultCurrEpochAttTarget := resultCurrEpochAttData.Target
-	require.NotNil(t, resultCurrEpochAttTarget)
-	assert.Equal(t, primitives.Epoch(27), resultCurrEpochAttTarget.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("ceatroot"), 32), resultCurrEpochAttTarget.Root)
-	assert.Equal(t, primitives.Slot(28), resultCurrEpochAtt.InclusionDelay)
-	assert.Equal(t, primitives.ValidatorIndex(29), resultCurrEpochAtt.ProposerIndex)
-	assert.DeepEqual(t, bitfield.Bitvector4{1}, result.JustificationBits)
-	resultPrevJustifiedCheckpoint := result.PreviousJustifiedCheckpoint
-	require.NotNil(t, resultPrevJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(30), resultPrevJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("pjcroot"), 32), resultPrevJustifiedCheckpoint.Root)
-	resultCurrJustifiedCheckpoint := result.CurrentJustifiedCheckpoint
-	require.NotNil(t, resultCurrJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(31), resultCurrJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("cjcroot"), 32), resultCurrJustifiedCheckpoint.Root)
-	resultFinalizedCheckpoint := result.FinalizedCheckpoint
-	require.NotNil(t, resultFinalizedCheckpoint)
-	assert.Equal(t, primitives.Epoch(32), resultFinalizedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("fcroot"), 32), resultFinalizedCheckpoint.Root)
-}

proto/migration/v1alpha1_to_v2_test.go

@@ -1,901 +0,0 @@
-package migration
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-)
-
-func TestV1Alpha1SignedContributionAndProofToV2(t *testing.T) {
-	alphaContribution := &ethpbalpha.SignedContributionAndProof{
-		Message: &ethpbalpha.ContributionAndProof{
-			AggregatorIndex: validatorIndex,
-			Contribution: &ethpbalpha.SyncCommitteeContribution{
-				Slot:              slot,
-				BlockRoot:         blockHash,
-				SubcommitteeIndex: 1,
-				AggregationBits:   bitfield.NewBitvector128(),
-				Signature:         signature,
-			},
-			SelectionProof: signature,
-		},
-		Signature: signature,
-	}
-	v2Contribution := V1Alpha1SignedContributionAndProofToV2(alphaContribution)
-	require.NotNil(t, v2Contribution)
-	require.NotNil(t, v2Contribution.Message)
-	require.NotNil(t, v2Contribution.Message.Contribution)
-	assert.DeepEqual(t, signature, v2Contribution.Signature)
-	msg := v2Contribution.Message
-	assert.Equal(t, validatorIndex, msg.AggregatorIndex)
-	assert.DeepEqual(t, signature, msg.SelectionProof)
-	contrib := msg.Contribution
-	assert.Equal(t, slot, contrib.Slot)
-	assert.DeepEqual(t, blockHash, contrib.BeaconBlockRoot)
-	assert.Equal(t, uint64(1), contrib.SubcommitteeIndex)
-	assert.DeepEqual(t, bitfield.NewBitvector128(), contrib.AggregationBits)
-	assert.DeepEqual(t, signature, contrib.Signature)
-}
-
-func Test_V1Alpha1BeaconBlockAltairToV2(t *testing.T) {
-	alphaBlock := util.HydrateBeaconBlockAltair(&ethpbalpha.BeaconBlockAltair{})
-	alphaBlock.Slot = slot
-	alphaBlock.ProposerIndex = validatorIndex
-	alphaBlock.ParentRoot = parentRoot
-	alphaBlock.StateRoot = stateRoot
-	alphaBlock.Body.RandaoReveal = randaoReveal
-	alphaBlock.Body.Eth1Data = &ethpbalpha.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	syncCommitteeBits := bitfield.NewBitvector512()
-	syncCommitteeBits.SetBitAt(100, true)
-	alphaBlock.Body.SyncAggregate = &ethpbalpha.SyncAggregate{
-		SyncCommitteeBits:      syncCommitteeBits,
-		SyncCommitteeSignature: signature,
-	}
-
-	v2Block, err := V1Alpha1BeaconBlockAltairToV2(alphaBlock)
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	v2Root, err := v2Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v2Root)
-}
-
-func Test_V1Alpha1BeaconBlockBellatrixToV2(t *testing.T) {
-	alphaBlock := util.HydrateBeaconBlockBellatrix(&ethpbalpha.BeaconBlockBellatrix{})
-	alphaBlock.Slot = slot
-	alphaBlock.ProposerIndex = validatorIndex
-	alphaBlock.ParentRoot = parentRoot
-	alphaBlock.StateRoot = stateRoot
-	alphaBlock.Body.RandaoReveal = randaoReveal
-	alphaBlock.Body.Eth1Data = &ethpbalpha.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	syncCommitteeBits := bitfield.NewBitvector512()
-	syncCommitteeBits.SetBitAt(100, true)
-	alphaBlock.Body.SyncAggregate = &ethpbalpha.SyncAggregate{
-		SyncCommitteeBits:      syncCommitteeBits,
-		SyncCommitteeSignature: signature,
-	}
-
-	v2Block, err := V1Alpha1BeaconBlockBellatrixToV2(alphaBlock)
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	v2Root, err := v2Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v2Root)
-}
-
-func Test_V1Alpha1BeaconBlockBellatrixToV2Blinded(t *testing.T) {
-	alphaBlock := util.HydrateBeaconBlockBellatrix(&ethpbalpha.BeaconBlockBellatrix{})
-	alphaBlock.Slot = slot
-	alphaBlock.ProposerIndex = validatorIndex
-	alphaBlock.ParentRoot = parentRoot
-	alphaBlock.StateRoot = stateRoot
-	alphaBlock.Body.RandaoReveal = randaoReveal
-	alphaBlock.Body.Eth1Data = &ethpbalpha.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	syncCommitteeBits := bitfield.NewBitvector512()
-	syncCommitteeBits.SetBitAt(100, true)
-	alphaBlock.Body.SyncAggregate = &ethpbalpha.SyncAggregate{
-		SyncCommitteeBits:      syncCommitteeBits,
-		SyncCommitteeSignature: signature,
-	}
-	alphaBlock.Body.ExecutionPayload.Transactions = [][]byte{[]byte("transaction1"), []byte("transaction2")}
-
-	v2Block, err := V1Alpha1BeaconBlockBellatrixToV2Blinded(alphaBlock)
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	v2Root, err := v2Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v2Root)
-}
-
-func Test_V1Alpha1BeaconBlockCapellaToV2Blinded(t *testing.T) {
-	alphaBlock := util.HydrateBeaconBlockCapella(&ethpbalpha.BeaconBlockCapella{})
-	alphaBlock.Slot = slot
-	alphaBlock.ProposerIndex = validatorIndex
-	alphaBlock.ParentRoot = parentRoot
-	alphaBlock.StateRoot = stateRoot
-	alphaBlock.Body.RandaoReveal = randaoReveal
-	alphaBlock.Body.Eth1Data = &ethpbalpha.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	syncCommitteeBits := bitfield.NewBitvector512()
-	syncCommitteeBits.SetBitAt(100, true)
-	alphaBlock.Body.SyncAggregate = &ethpbalpha.SyncAggregate{
-		SyncCommitteeBits:      syncCommitteeBits,
-		SyncCommitteeSignature: signature,
-	}
-	alphaBlock.Body.ExecutionPayload.Transactions = [][]byte{[]byte("transaction1"), []byte("transaction2")}
-
-	v2Block, err := V1Alpha1BeaconBlockCapellaToV2Blinded(alphaBlock)
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	v2Root, err := v2Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, alphaRoot, v2Root)
-}
-
-func TestBeaconStateAltairToProto(t *testing.T) {
-	source, err := util.NewBeaconStateAltair(util.FillRootsNaturalOptAltair, func(state *ethpbalpha.BeaconStateAltair) error {
-		state.GenesisTime = 1
-		state.GenesisValidatorsRoot = bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32)
-		state.Slot = 2
-		state.Fork = &ethpbalpha.Fork{
-			PreviousVersion: bytesutil.PadTo([]byte("123"), 4),
-			CurrentVersion:  bytesutil.PadTo([]byte("456"), 4),
-			Epoch:           3,
-		}
-		state.LatestBlockHeader = &ethpbalpha.BeaconBlockHeader{
-			Slot:          4,
-			ProposerIndex: 5,
-			ParentRoot:    bytesutil.PadTo([]byte("lbhparentroot"), 32),
-			StateRoot:     bytesutil.PadTo([]byte("lbhstateroot"), 32),
-			BodyRoot:      bytesutil.PadTo([]byte("lbhbodyroot"), 32),
-		}
-		state.BlockRoots = [][]byte{bytesutil.PadTo([]byte("blockroots"), 32)}
-		state.StateRoots = [][]byte{bytesutil.PadTo([]byte("stateroots"), 32)}
-		state.HistoricalRoots = [][]byte{bytesutil.PadTo([]byte("historicalroots"), 32)}
-		state.Eth1Data = &ethpbalpha.Eth1Data{
-			DepositRoot:  bytesutil.PadTo([]byte("e1ddepositroot"), 32),
-			DepositCount: 6,
-			BlockHash:    bytesutil.PadTo([]byte("e1dblockhash"), 32),
-		}
-		state.Eth1DataVotes = []*ethpbalpha.Eth1Data{{
-			DepositRoot:  bytesutil.PadTo([]byte("e1dvdepositroot"), 32),
-			DepositCount: 7,
-			BlockHash:    bytesutil.PadTo([]byte("e1dvblockhash"), 32),
-		}}
-		state.Eth1DepositIndex = 8
-		state.Validators = []*ethpbalpha.Validator{{
-			PublicKey:                  bytesutil.PadTo([]byte("publickey"), 48),
-			WithdrawalCredentials:      bytesutil.PadTo([]byte("withdrawalcredentials"), 32),
-			EffectiveBalance:           9,
-			Slashed:                    true,
-			ActivationEligibilityEpoch: 10,
-			ActivationEpoch:            11,
-			ExitEpoch:                  12,
-			WithdrawableEpoch:          13,
-		}}
-		state.Balances = []uint64{14}
-		state.RandaoMixes = [][]byte{bytesutil.PadTo([]byte("randaomixes"), 32)}
-		state.Slashings = []uint64{15}
-		state.JustificationBits = bitfield.Bitvector4{1}
-		state.PreviousJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 30,
-			Root:  bytesutil.PadTo([]byte("pjcroot"), 32),
-		}
-		state.CurrentJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 31,
-			Root:  bytesutil.PadTo([]byte("cjcroot"), 32),
-		}
-		state.FinalizedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 32,
-			Root:  bytesutil.PadTo([]byte("fcroot"), 32),
-		}
-		state.PreviousEpochParticipation = []byte("previousepochparticipation")
-		state.CurrentEpochParticipation = []byte("currentepochparticipation")
-		state.InactivityScores = []uint64{1, 2, 3}
-		state.CurrentSyncCommittee = &ethpbalpha.SyncCommittee{
-			Pubkeys:         [][]byte{bytesutil.PadTo([]byte("cscpubkeys"), 48)},
-			AggregatePubkey: bytesutil.PadTo([]byte("cscaggregatepubkey"), 48),
-		}
-		state.NextSyncCommittee = &ethpbalpha.SyncCommittee{
-			Pubkeys:         [][]byte{bytesutil.PadTo([]byte("nscpubkeys"), 48)},
-			AggregatePubkey: bytesutil.PadTo([]byte("nscaggregatepubkey"), 48),
-		}
-		return nil
-	})
-	require.NoError(t, err)
-
-	result, err := BeaconStateAltairToProto(source)
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	assert.Equal(t, uint64(1), result.GenesisTime)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32), result.GenesisValidatorsRoot)
-	assert.Equal(t, primitives.Slot(2), result.Slot)
-	resultFork := result.Fork
-	require.NotNil(t, resultFork)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("123"), 4), resultFork.PreviousVersion)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("456"), 4), resultFork.CurrentVersion)
-	assert.Equal(t, primitives.Epoch(3), resultFork.Epoch)
-	resultLatestBlockHeader := result.LatestBlockHeader
-	require.NotNil(t, resultLatestBlockHeader)
-	assert.Equal(t, primitives.Slot(4), resultLatestBlockHeader.Slot)
-	assert.Equal(t, primitives.ValidatorIndex(5), resultLatestBlockHeader.ProposerIndex)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhparentroot"), 32), resultLatestBlockHeader.ParentRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhstateroot"), 32), resultLatestBlockHeader.StateRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhbodyroot"), 32), resultLatestBlockHeader.BodyRoot)
-	assert.Equal(t, 8192, len(result.BlockRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blockroots"), 32), result.BlockRoots[0])
-	assert.Equal(t, 8192, len(result.StateRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("stateroots"), 32), result.StateRoots[0])
-	assert.Equal(t, 1, len(result.HistoricalRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("historicalroots"), 32), result.HistoricalRoots[0])
-	resultEth1Data := result.Eth1Data
-	require.NotNil(t, resultEth1Data)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1ddepositroot"), 32), resultEth1Data.DepositRoot)
-	assert.Equal(t, uint64(6), resultEth1Data.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dblockhash"), 32), resultEth1Data.BlockHash)
-	require.Equal(t, 1, len(result.Eth1DataVotes))
-	resultEth1DataVote := result.Eth1DataVotes[0]
-	require.NotNil(t, resultEth1DataVote)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvdepositroot"), 32), resultEth1DataVote.DepositRoot)
-	assert.Equal(t, uint64(7), resultEth1DataVote.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvblockhash"), 32), resultEth1DataVote.BlockHash)
-	assert.Equal(t, uint64(8), result.Eth1DepositIndex)
-	require.Equal(t, 1, len(result.Validators))
-	resultValidator := result.Validators[0]
-	require.NotNil(t, resultValidator)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("publickey"), 48), resultValidator.Pubkey)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("withdrawalcredentials"), 32), resultValidator.WithdrawalCredentials)
-	assert.Equal(t, uint64(9), resultValidator.EffectiveBalance)
-	assert.Equal(t, true, resultValidator.Slashed)
-	assert.Equal(t, primitives.Epoch(10), resultValidator.ActivationEligibilityEpoch)
-	assert.Equal(t, primitives.Epoch(11), resultValidator.ActivationEpoch)
-	assert.Equal(t, primitives.Epoch(12), resultValidator.ExitEpoch)
-	assert.Equal(t, primitives.Epoch(13), resultValidator.WithdrawableEpoch)
-	assert.DeepEqual(t, []uint64{14}, result.Balances)
-	assert.Equal(t, 65536, len(result.RandaoMixes))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("randaomixes"), 32), result.RandaoMixes[0])
-	assert.DeepEqual(t, []uint64{15}, result.Slashings)
-	assert.DeepEqual(t, bitfield.Bitvector4{1}, result.JustificationBits)
-	resultPrevJustifiedCheckpoint := result.PreviousJustifiedCheckpoint
-	require.NotNil(t, resultPrevJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(30), resultPrevJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("pjcroot"), 32), resultPrevJustifiedCheckpoint.Root)
-	resultCurrJustifiedCheckpoint := result.CurrentJustifiedCheckpoint
-	require.NotNil(t, resultCurrJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(31), resultCurrJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("cjcroot"), 32), resultCurrJustifiedCheckpoint.Root)
-	resultFinalizedCheckpoint := result.FinalizedCheckpoint
-	require.NotNil(t, resultFinalizedCheckpoint)
-	assert.Equal(t, primitives.Epoch(32), resultFinalizedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("fcroot"), 32), resultFinalizedCheckpoint.Root)
-	assert.DeepEqual(t, []byte("previousepochparticipation"), result.PreviousEpochParticipation)
-	assert.DeepEqual(t, []byte("currentepochparticipation"), result.CurrentEpochParticipation)
-	assert.DeepEqual(t, []uint64{1, 2, 3}, result.InactivityScores)
-	require.NotNil(t, result.CurrentSyncCommittee)
-	assert.DeepEqual(t, [][]byte{bytesutil.PadTo([]byte("cscpubkeys"), 48)}, result.CurrentSyncCommittee.Pubkeys)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("cscaggregatepubkey"), 48), result.CurrentSyncCommittee.AggregatePubkey)
-	require.NotNil(t, result.NextSyncCommittee)
-	assert.DeepEqual(t, [][]byte{bytesutil.PadTo([]byte("nscpubkeys"), 48)}, result.NextSyncCommittee.Pubkeys)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("nscaggregatepubkey"), 48), result.NextSyncCommittee.AggregatePubkey)
-}
-
-func TestBeaconStateBellatrixToProto(t *testing.T) {
-	source, err := util.NewBeaconStateBellatrix(util.FillRootsNaturalOptBellatrix, func(state *ethpbalpha.BeaconStateBellatrix) error {
-		state.GenesisTime = 1
-		state.GenesisValidatorsRoot = bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32)
-		state.Slot = 2
-		state.Fork = &ethpbalpha.Fork{
-			PreviousVersion: bytesutil.PadTo([]byte("123"), 4),
-			CurrentVersion:  bytesutil.PadTo([]byte("456"), 4),
-			Epoch:           3,
-		}
-		state.LatestBlockHeader = &ethpbalpha.BeaconBlockHeader{
-			Slot:          4,
-			ProposerIndex: 5,
-			ParentRoot:    bytesutil.PadTo([]byte("lbhparentroot"), 32),
-			StateRoot:     bytesutil.PadTo([]byte("lbhstateroot"), 32),
-			BodyRoot:      bytesutil.PadTo([]byte("lbhbodyroot"), 32),
-		}
-		state.BlockRoots = [][]byte{bytesutil.PadTo([]byte("blockroots"), 32)}
-		state.StateRoots = [][]byte{bytesutil.PadTo([]byte("stateroots"), 32)}
-		state.HistoricalRoots = [][]byte{bytesutil.PadTo([]byte("historicalroots"), 32)}
-		state.Eth1Data = &ethpbalpha.Eth1Data{
-			DepositRoot:  bytesutil.PadTo([]byte("e1ddepositroot"), 32),
-			DepositCount: 6,
-			BlockHash:    bytesutil.PadTo([]byte("e1dblockhash"), 32),
-		}
-		state.Eth1DataVotes = []*ethpbalpha.Eth1Data{{
-			DepositRoot:  bytesutil.PadTo([]byte("e1dvdepositroot"), 32),
-			DepositCount: 7,
-			BlockHash:    bytesutil.PadTo([]byte("e1dvblockhash"), 32),
-		}}
-		state.Eth1DepositIndex = 8
-		state.Validators = []*ethpbalpha.Validator{{
-			PublicKey:                  bytesutil.PadTo([]byte("publickey"), 48),
-			WithdrawalCredentials:      bytesutil.PadTo([]byte("withdrawalcredentials"), 32),
-			EffectiveBalance:           9,
-			Slashed:                    true,
-			ActivationEligibilityEpoch: 10,
-			ActivationEpoch:            11,
-			ExitEpoch:                  12,
-			WithdrawableEpoch:          13,
-		}}
-		state.Balances = []uint64{14}
-		state.RandaoMixes = [][]byte{bytesutil.PadTo([]byte("randaomixes"), 32)}
-		state.Slashings = []uint64{15}
-		state.JustificationBits = bitfield.Bitvector4{1}
-		state.PreviousJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 30,
-			Root:  bytesutil.PadTo([]byte("pjcroot"), 32),
-		}
-		state.CurrentJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 31,
-			Root:  bytesutil.PadTo([]byte("cjcroot"), 32),
-		}
-		state.FinalizedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 32,
-			Root:  bytesutil.PadTo([]byte("fcroot"), 32),
-		}
-		state.PreviousEpochParticipation = []byte("previousepochparticipation")
-		state.CurrentEpochParticipation = []byte("currentepochparticipation")
-		state.InactivityScores = []uint64{1, 2, 3}
-		state.CurrentSyncCommittee = &ethpbalpha.SyncCommittee{
-			Pubkeys:         [][]byte{bytesutil.PadTo([]byte("cscpubkeys"), 48)},
-			AggregatePubkey: bytesutil.PadTo([]byte("cscaggregatepubkey"), 48),
-		}
-		state.NextSyncCommittee = &ethpbalpha.SyncCommittee{
-			Pubkeys:         [][]byte{bytesutil.PadTo([]byte("nscpubkeys"), 48)},
-			AggregatePubkey: bytesutil.PadTo([]byte("nscaggregatepubkey"), 48),
-		}
-		state.LatestExecutionPayloadHeader = &enginev1.ExecutionPayloadHeader{
-			ParentHash:       bytesutil.PadTo([]byte("parenthash"), 32),
-			FeeRecipient:     bytesutil.PadTo([]byte("feerecipient"), 20),
-			StateRoot:        bytesutil.PadTo([]byte("stateroot"), 32),
-			ReceiptsRoot:     bytesutil.PadTo([]byte("receiptroot"), 32),
-			LogsBloom:        bytesutil.PadTo([]byte("logsbloom"), 256),
-			PrevRandao:       bytesutil.PadTo([]byte("prevrandao"), 32),
-			BlockNumber:      123,
-			GasLimit:         456,
-			GasUsed:          789,
-			Timestamp:        012,
-			ExtraData:        []byte("extradata"),
-			BaseFeePerGas:    bytesutil.PadTo([]byte("basefeepergas"), 32),
-			BlockHash:        bytesutil.PadTo([]byte("blockhash"), 32),
-			TransactionsRoot: bytesutil.PadTo([]byte("transactionsroot"), 32),
-		}
-		return nil
-	})
-	require.NoError(t, err)
-
-	result, err := BeaconStateBellatrixToProto(source)
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	assert.Equal(t, uint64(1), result.GenesisTime)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32), result.GenesisValidatorsRoot)
-	assert.Equal(t, primitives.Slot(2), result.Slot)
-	resultFork := result.Fork
-	require.NotNil(t, resultFork)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("123"), 4), resultFork.PreviousVersion)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("456"), 4), resultFork.CurrentVersion)
-	assert.Equal(t, primitives.Epoch(3), resultFork.Epoch)
-	resultLatestBlockHeader := result.LatestBlockHeader
-	require.NotNil(t, resultLatestBlockHeader)
-	assert.Equal(t, primitives.Slot(4), resultLatestBlockHeader.Slot)
-	assert.Equal(t, primitives.ValidatorIndex(5), resultLatestBlockHeader.ProposerIndex)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhparentroot"), 32), resultLatestBlockHeader.ParentRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhstateroot"), 32), resultLatestBlockHeader.StateRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhbodyroot"), 32), resultLatestBlockHeader.BodyRoot)
-	assert.Equal(t, 8192, len(result.BlockRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blockroots"), 32), result.BlockRoots[0])
-	assert.Equal(t, 8192, len(result.StateRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("stateroots"), 32), result.StateRoots[0])
-	assert.Equal(t, 1, len(result.HistoricalRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("historicalroots"), 32), result.HistoricalRoots[0])
-	resultEth1Data := result.Eth1Data
-	require.NotNil(t, resultEth1Data)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1ddepositroot"), 32), resultEth1Data.DepositRoot)
-	assert.Equal(t, uint64(6), resultEth1Data.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dblockhash"), 32), resultEth1Data.BlockHash)
-	require.Equal(t, 1, len(result.Eth1DataVotes))
-	resultEth1DataVote := result.Eth1DataVotes[0]
-	require.NotNil(t, resultEth1DataVote)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvdepositroot"), 32), resultEth1DataVote.DepositRoot)
-	assert.Equal(t, uint64(7), resultEth1DataVote.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvblockhash"), 32), resultEth1DataVote.BlockHash)
-	assert.Equal(t, uint64(8), result.Eth1DepositIndex)
-	require.Equal(t, 1, len(result.Validators))
-	resultValidator := result.Validators[0]
-	require.NotNil(t, resultValidator)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("publickey"), 48), resultValidator.Pubkey)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("withdrawalcredentials"), 32), resultValidator.WithdrawalCredentials)
-	assert.Equal(t, uint64(9), resultValidator.EffectiveBalance)
-	assert.Equal(t, true, resultValidator.Slashed)
-	assert.Equal(t, primitives.Epoch(10), resultValidator.ActivationEligibilityEpoch)
-	assert.Equal(t, primitives.Epoch(11), resultValidator.ActivationEpoch)
-	assert.Equal(t, primitives.Epoch(12), resultValidator.ExitEpoch)
-	assert.Equal(t, primitives.Epoch(13), resultValidator.WithdrawableEpoch)
-	assert.DeepEqual(t, []uint64{14}, result.Balances)
-	assert.Equal(t, 65536, len(result.RandaoMixes))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("randaomixes"), 32), result.RandaoMixes[0])
-	assert.DeepEqual(t, []uint64{15}, result.Slashings)
-	assert.DeepEqual(t, bitfield.Bitvector4{1}, result.JustificationBits)
-	resultPrevJustifiedCheckpoint := result.PreviousJustifiedCheckpoint
-	require.NotNil(t, resultPrevJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(30), resultPrevJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("pjcroot"), 32), resultPrevJustifiedCheckpoint.Root)
-	resultCurrJustifiedCheckpoint := result.CurrentJustifiedCheckpoint
-	require.NotNil(t, resultCurrJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(31), resultCurrJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("cjcroot"), 32), resultCurrJustifiedCheckpoint.Root)
-	resultFinalizedCheckpoint := result.FinalizedCheckpoint
-	require.NotNil(t, resultFinalizedCheckpoint)
-	assert.Equal(t, primitives.Epoch(32), resultFinalizedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("fcroot"), 32), resultFinalizedCheckpoint.Root)
-	assert.DeepEqual(t, []byte("previousepochparticipation"), result.PreviousEpochParticipation)
-	assert.DeepEqual(t, []byte("currentepochparticipation"), result.CurrentEpochParticipation)
-	assert.DeepEqual(t, []uint64{1, 2, 3}, result.InactivityScores)
-	require.NotNil(t, result.CurrentSyncCommittee)
-	assert.DeepEqual(t, [][]byte{bytesutil.PadTo([]byte("cscpubkeys"), 48)}, result.CurrentSyncCommittee.Pubkeys)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("cscaggregatepubkey"), 48), result.CurrentSyncCommittee.AggregatePubkey)
-	require.NotNil(t, result.NextSyncCommittee)
-	assert.DeepEqual(t, [][]byte{bytesutil.PadTo([]byte("nscpubkeys"), 48)}, result.NextSyncCommittee.Pubkeys)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("nscaggregatepubkey"), 48), result.NextSyncCommittee.AggregatePubkey)
-	resultLatestExecutionPayloadHeader := result.LatestExecutionPayloadHeader
-	require.NotNil(t, resultLatestExecutionPayloadHeader)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("parenthash"), 32), resultLatestExecutionPayloadHeader.ParentHash)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("feerecipient"), 20), resultLatestExecutionPayloadHeader.FeeRecipient)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("stateroot"), 32), resultLatestExecutionPayloadHeader.StateRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("receiptroot"), 32), resultLatestExecutionPayloadHeader.ReceiptsRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("logsbloom"), 256), resultLatestExecutionPayloadHeader.LogsBloom)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("prevrandao"), 32), resultLatestExecutionPayloadHeader.PrevRandao)
-	assert.Equal(t, uint64(123), resultLatestExecutionPayloadHeader.BlockNumber)
-	assert.Equal(t, uint64(456), resultLatestExecutionPayloadHeader.GasLimit)
-	assert.Equal(t, uint64(789), resultLatestExecutionPayloadHeader.GasUsed)
-	assert.Equal(t, uint64(012), resultLatestExecutionPayloadHeader.Timestamp)
-	assert.DeepEqual(t, []byte("extradata"), resultLatestExecutionPayloadHeader.ExtraData)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("basefeepergas"), 32), resultLatestExecutionPayloadHeader.BaseFeePerGas)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blockhash"), 32), resultLatestExecutionPayloadHeader.BlockHash)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("transactionsroot"), 32), resultLatestExecutionPayloadHeader.TransactionsRoot)
-}
-
-func TestBeaconStateCapellaToProto(t *testing.T) {
-	source, err := util.NewBeaconStateCapella(util.FillRootsNaturalOptCapella, func(state *ethpbalpha.BeaconStateCapella) error {
-		state.GenesisTime = 1
-		state.GenesisValidatorsRoot = bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32)
-		state.Slot = 2
-		state.Fork = &ethpbalpha.Fork{
-			PreviousVersion: bytesutil.PadTo([]byte("123"), 4),
-			CurrentVersion:  bytesutil.PadTo([]byte("456"), 4),
-			Epoch:           3,
-		}
-		state.LatestBlockHeader = &ethpbalpha.BeaconBlockHeader{
-			Slot:          4,
-			ProposerIndex: 5,
-			ParentRoot:    bytesutil.PadTo([]byte("lbhparentroot"), 32),
-			StateRoot:     bytesutil.PadTo([]byte("lbhstateroot"), 32),
-			BodyRoot:      bytesutil.PadTo([]byte("lbhbodyroot"), 32),
-		}
-		state.BlockRoots = [][]byte{bytesutil.PadTo([]byte("blockroots"), 32)}
-		state.StateRoots = [][]byte{bytesutil.PadTo([]byte("stateroots"), 32)}
-		state.HistoricalRoots = [][]byte{bytesutil.PadTo([]byte("historicalroots"), 32)}
-		state.Eth1Data = &ethpbalpha.Eth1Data{
-			DepositRoot:  bytesutil.PadTo([]byte("e1ddepositroot"), 32),
-			DepositCount: 6,
-			BlockHash:    bytesutil.PadTo([]byte("e1dblockhash"), 32),
-		}
-		state.Eth1DataVotes = []*ethpbalpha.Eth1Data{{
-			DepositRoot:  bytesutil.PadTo([]byte("e1dvdepositroot"), 32),
-			DepositCount: 7,
-			BlockHash:    bytesutil.PadTo([]byte("e1dvblockhash"), 32),
-		}}
-		state.Eth1DepositIndex = 8
-		state.Validators = []*ethpbalpha.Validator{{
-			PublicKey:                  bytesutil.PadTo([]byte("publickey"), 48),
-			WithdrawalCredentials:      bytesutil.PadTo([]byte("withdrawalcredentials"), 32),
-			EffectiveBalance:           9,
-			Slashed:                    true,
-			ActivationEligibilityEpoch: 10,
-			ActivationEpoch:            11,
-			ExitEpoch:                  12,
-			WithdrawableEpoch:          13,
-		}}
-		state.Balances = []uint64{14}
-		state.RandaoMixes = [][]byte{bytesutil.PadTo([]byte("randaomixes"), 32)}
-		state.Slashings = []uint64{15}
-		state.JustificationBits = bitfield.Bitvector4{1}
-		state.PreviousJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 30,
-			Root:  bytesutil.PadTo([]byte("pjcroot"), 32),
-		}
-		state.CurrentJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 31,
-			Root:  bytesutil.PadTo([]byte("cjcroot"), 32),
-		}
-		state.FinalizedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 32,
-			Root:  bytesutil.PadTo([]byte("fcroot"), 32),
-		}
-		state.PreviousEpochParticipation = []byte("previousepochparticipation")
-		state.CurrentEpochParticipation = []byte("currentepochparticipation")
-		state.InactivityScores = []uint64{1, 2, 3}
-		state.CurrentSyncCommittee = &ethpbalpha.SyncCommittee{
-			Pubkeys:         [][]byte{bytesutil.PadTo([]byte("cscpubkeys"), 48)},
-			AggregatePubkey: bytesutil.PadTo([]byte("cscaggregatepubkey"), 48),
-		}
-		state.NextSyncCommittee = &ethpbalpha.SyncCommittee{
-			Pubkeys:         [][]byte{bytesutil.PadTo([]byte("nscpubkeys"), 48)},
-			AggregatePubkey: bytesutil.PadTo([]byte("nscaggregatepubkey"), 48),
-		}
-		state.LatestExecutionPayloadHeader = &enginev1.ExecutionPayloadHeaderCapella{
-			ParentHash:       bytesutil.PadTo([]byte("parenthash"), 32),
-			FeeRecipient:     bytesutil.PadTo([]byte("feerecipient"), 20),
-			StateRoot:        bytesutil.PadTo([]byte("stateroot"), 32),
-			ReceiptsRoot:     bytesutil.PadTo([]byte("receiptroot"), 32),
-			LogsBloom:        bytesutil.PadTo([]byte("logsbloom"), 256),
-			PrevRandao:       bytesutil.PadTo([]byte("prevrandao"), 32),
-			BlockNumber:      123,
-			GasLimit:         456,
-			GasUsed:          789,
-			Timestamp:        012,
-			ExtraData:        []byte("extradata"),
-			BaseFeePerGas:    bytesutil.PadTo([]byte("basefeepergas"), 32),
-			BlockHash:        bytesutil.PadTo([]byte("blockhash"), 32),
-			TransactionsRoot: bytesutil.PadTo([]byte("transactionsroot"), 32),
-			WithdrawalsRoot:  bytesutil.PadTo([]byte("withdrawalsroot"), 32),
-		}
-		state.NextWithdrawalIndex = 123
-		state.NextWithdrawalValidatorIndex = 123
-		state.HistoricalSummaries = []*ethpbalpha.HistoricalSummary{
-			{
-				BlockSummaryRoot: bytesutil.PadTo([]byte("blocksummaryroot"), 32),
-				StateSummaryRoot: bytesutil.PadTo([]byte("statesummaryroot"), 32),
-			},
-			{
-				BlockSummaryRoot: bytesutil.PadTo([]byte("blocksummaryroot2"), 32),
-				StateSummaryRoot: bytesutil.PadTo([]byte("statesummaryroot2"), 32),
-			}}
-		return nil
-	})
-	require.NoError(t, err)
-
-	result, err := BeaconStateCapellaToProto(source)
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	assert.Equal(t, uint64(1), result.GenesisTime)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32), result.GenesisValidatorsRoot)
-	assert.Equal(t, primitives.Slot(2), result.Slot)
-	resultFork := result.Fork
-	require.NotNil(t, resultFork)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("123"), 4), resultFork.PreviousVersion)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("456"), 4), resultFork.CurrentVersion)
-	assert.Equal(t, primitives.Epoch(3), resultFork.Epoch)
-	resultLatestBlockHeader := result.LatestBlockHeader
-	require.NotNil(t, resultLatestBlockHeader)
-	assert.Equal(t, primitives.Slot(4), resultLatestBlockHeader.Slot)
-	assert.Equal(t, primitives.ValidatorIndex(5), resultLatestBlockHeader.ProposerIndex)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhparentroot"), 32), resultLatestBlockHeader.ParentRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhstateroot"), 32), resultLatestBlockHeader.StateRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhbodyroot"), 32), resultLatestBlockHeader.BodyRoot)
-	assert.Equal(t, 8192, len(result.BlockRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blockroots"), 32), result.BlockRoots[0])
-	assert.Equal(t, 8192, len(result.StateRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("stateroots"), 32), result.StateRoots[0])
-	assert.Equal(t, 1, len(result.HistoricalRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("historicalroots"), 32), result.HistoricalRoots[0])
-	resultEth1Data := result.Eth1Data
-	require.NotNil(t, resultEth1Data)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1ddepositroot"), 32), resultEth1Data.DepositRoot)
-	assert.Equal(t, uint64(6), resultEth1Data.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dblockhash"), 32), resultEth1Data.BlockHash)
-	require.Equal(t, 1, len(result.Eth1DataVotes))
-	resultEth1DataVote := result.Eth1DataVotes[0]
-	require.NotNil(t, resultEth1DataVote)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvdepositroot"), 32), resultEth1DataVote.DepositRoot)
-	assert.Equal(t, uint64(7), resultEth1DataVote.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvblockhash"), 32), resultEth1DataVote.BlockHash)
-	assert.Equal(t, uint64(8), result.Eth1DepositIndex)
-	require.Equal(t, 1, len(result.Validators))
-	resultValidator := result.Validators[0]
-	require.NotNil(t, resultValidator)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("publickey"), 48), resultValidator.Pubkey)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("withdrawalcredentials"), 32), resultValidator.WithdrawalCredentials)
-	assert.Equal(t, uint64(9), resultValidator.EffectiveBalance)
-	assert.Equal(t, true, resultValidator.Slashed)
-	assert.Equal(t, primitives.Epoch(10), resultValidator.ActivationEligibilityEpoch)
-	assert.Equal(t, primitives.Epoch(11), resultValidator.ActivationEpoch)
-	assert.Equal(t, primitives.Epoch(12), resultValidator.ExitEpoch)
-	assert.Equal(t, primitives.Epoch(13), resultValidator.WithdrawableEpoch)
-	assert.DeepEqual(t, []uint64{14}, result.Balances)
-	assert.Equal(t, 65536, len(result.RandaoMixes))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("randaomixes"), 32), result.RandaoMixes[0])
-	assert.DeepEqual(t, []uint64{15}, result.Slashings)
-	assert.DeepEqual(t, bitfield.Bitvector4{1}, result.JustificationBits)
-	resultPrevJustifiedCheckpoint := result.PreviousJustifiedCheckpoint
-	require.NotNil(t, resultPrevJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(30), resultPrevJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("pjcroot"), 32), resultPrevJustifiedCheckpoint.Root)
-	resultCurrJustifiedCheckpoint := result.CurrentJustifiedCheckpoint
-	require.NotNil(t, resultCurrJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(31), resultCurrJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("cjcroot"), 32), resultCurrJustifiedCheckpoint.Root)
-	resultFinalizedCheckpoint := result.FinalizedCheckpoint
-	require.NotNil(t, resultFinalizedCheckpoint)
-	assert.Equal(t, primitives.Epoch(32), resultFinalizedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("fcroot"), 32), resultFinalizedCheckpoint.Root)
-	assert.DeepEqual(t, []byte("previousepochparticipation"), result.PreviousEpochParticipation)
-	assert.DeepEqual(t, []byte("currentepochparticipation"), result.CurrentEpochParticipation)
-	assert.DeepEqual(t, []uint64{1, 2, 3}, result.InactivityScores)
-	require.NotNil(t, result.CurrentSyncCommittee)
-	assert.DeepEqual(t, [][]byte{bytesutil.PadTo([]byte("cscpubkeys"), 48)}, result.CurrentSyncCommittee.Pubkeys)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("cscaggregatepubkey"), 48), result.CurrentSyncCommittee.AggregatePubkey)
-	require.NotNil(t, result.NextSyncCommittee)
-	assert.DeepEqual(t, [][]byte{bytesutil.PadTo([]byte("nscpubkeys"), 48)}, result.NextSyncCommittee.Pubkeys)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("nscaggregatepubkey"), 48), result.NextSyncCommittee.AggregatePubkey)
-	resultLatestExecutionPayloadHeader := result.LatestExecutionPayloadHeader
-	require.NotNil(t, resultLatestExecutionPayloadHeader)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("parenthash"), 32), resultLatestExecutionPayloadHeader.ParentHash)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("feerecipient"), 20), resultLatestExecutionPayloadHeader.FeeRecipient)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("stateroot"), 32), resultLatestExecutionPayloadHeader.StateRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("receiptroot"), 32), resultLatestExecutionPayloadHeader.ReceiptsRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("logsbloom"), 256), resultLatestExecutionPayloadHeader.LogsBloom)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("prevrandao"), 32), resultLatestExecutionPayloadHeader.PrevRandao)
-	assert.Equal(t, uint64(123), resultLatestExecutionPayloadHeader.BlockNumber)
-	assert.Equal(t, uint64(456), resultLatestExecutionPayloadHeader.GasLimit)
-	assert.Equal(t, uint64(789), resultLatestExecutionPayloadHeader.GasUsed)
-	assert.Equal(t, uint64(012), resultLatestExecutionPayloadHeader.Timestamp)
-	assert.DeepEqual(t, []byte("extradata"), resultLatestExecutionPayloadHeader.ExtraData)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("basefeepergas"), 32), resultLatestExecutionPayloadHeader.BaseFeePerGas)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blockhash"), 32), resultLatestExecutionPayloadHeader.BlockHash)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("transactionsroot"), 32), resultLatestExecutionPayloadHeader.TransactionsRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("withdrawalsroot"), 32), resultLatestExecutionPayloadHeader.WithdrawalsRoot)
-	assert.Equal(t, uint64(123), result.NextWithdrawalIndex)
-	assert.Equal(t, primitives.ValidatorIndex(123), result.NextWithdrawalValidatorIndex)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blocksummaryroot"), 32), result.HistoricalSummaries[0].BlockSummaryRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("statesummaryroot"), 32), result.HistoricalSummaries[0].StateSummaryRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blocksummaryroot2"), 32), result.HistoricalSummaries[1].BlockSummaryRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("statesummaryroot2"), 32), result.HistoricalSummaries[1].StateSummaryRoot)
-}
-
-func TestBeaconStateDenebToProto(t *testing.T) {
-	source, err := util.NewBeaconStateDeneb(util.FillRootsNaturalOptDeneb, func(state *ethpbalpha.BeaconStateDeneb) error {
-		state.GenesisTime = 1
-		state.GenesisValidatorsRoot = bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32)
-		state.Slot = 2
-		state.Fork = &ethpbalpha.Fork{
-			PreviousVersion: bytesutil.PadTo([]byte("123"), 4),
-			CurrentVersion:  bytesutil.PadTo([]byte("456"), 4),
-			Epoch:           3,
-		}
-		state.LatestBlockHeader = &ethpbalpha.BeaconBlockHeader{
-			Slot:          4,
-			ProposerIndex: 5,
-			ParentRoot:    bytesutil.PadTo([]byte("lbhparentroot"), 32),
-			StateRoot:     bytesutil.PadTo([]byte("lbhstateroot"), 32),
-			BodyRoot:      bytesutil.PadTo([]byte("lbhbodyroot"), 32),
-		}
-		state.BlockRoots = [][]byte{bytesutil.PadTo([]byte("blockroots"), 32)}
-		state.StateRoots = [][]byte{bytesutil.PadTo([]byte("stateroots"), 32)}
-		state.HistoricalRoots = [][]byte{bytesutil.PadTo([]byte("historicalroots"), 32)}
-		state.Eth1Data = &ethpbalpha.Eth1Data{
-			DepositRoot:  bytesutil.PadTo([]byte("e1ddepositroot"), 32),
-			DepositCount: 6,
-			BlockHash:    bytesutil.PadTo([]byte("e1dblockhash"), 32),
-		}
-		state.Eth1DataVotes = []*ethpbalpha.Eth1Data{{
-			DepositRoot:  bytesutil.PadTo([]byte("e1dvdepositroot"), 32),
-			DepositCount: 7,
-			BlockHash:    bytesutil.PadTo([]byte("e1dvblockhash"), 32),
-		}}
-		state.Eth1DepositIndex = 8
-		state.Validators = []*ethpbalpha.Validator{{
-			PublicKey:                  bytesutil.PadTo([]byte("publickey"), 48),
-			WithdrawalCredentials:      bytesutil.PadTo([]byte("withdrawalcredentials"), 32),
-			EffectiveBalance:           9,
-			Slashed:                    true,
-			ActivationEligibilityEpoch: 10,
-			ActivationEpoch:            11,
-			ExitEpoch:                  12,
-			WithdrawableEpoch:          13,
-		}}
-		state.Balances = []uint64{14}
-		state.RandaoMixes = [][]byte{bytesutil.PadTo([]byte("randaomixes"), 32)}
-		state.Slashings = []uint64{15}
-		state.JustificationBits = bitfield.Bitvector4{1}
-		state.PreviousJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 30,
-			Root:  bytesutil.PadTo([]byte("pjcroot"), 32),
-		}
-		state.CurrentJustifiedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 31,
-			Root:  bytesutil.PadTo([]byte("cjcroot"), 32),
-		}
-		state.FinalizedCheckpoint = &ethpbalpha.Checkpoint{
-			Epoch: 32,
-			Root:  bytesutil.PadTo([]byte("fcroot"), 32),
-		}
-		state.PreviousEpochParticipation = []byte("previousepochparticipation")
-		state.CurrentEpochParticipation = []byte("currentepochparticipation")
-		state.InactivityScores = []uint64{1, 2, 3}
-		state.CurrentSyncCommittee = &ethpbalpha.SyncCommittee{
-			Pubkeys:         [][]byte{bytesutil.PadTo([]byte("cscpubkeys"), 48)},
-			AggregatePubkey: bytesutil.PadTo([]byte("cscaggregatepubkey"), 48),
-		}
-		state.NextSyncCommittee = &ethpbalpha.SyncCommittee{
-			Pubkeys:         [][]byte{bytesutil.PadTo([]byte("nscpubkeys"), 48)},
-			AggregatePubkey: bytesutil.PadTo([]byte("nscaggregatepubkey"), 48),
-		}
-		state.LatestExecutionPayloadHeader = &enginev1.ExecutionPayloadHeaderDeneb{
-			ParentHash:       bytesutil.PadTo([]byte("parenthash"), 32),
-			FeeRecipient:     bytesutil.PadTo([]byte("feerecipient"), 20),
-			StateRoot:        bytesutil.PadTo([]byte("stateroot"), 32),
-			ReceiptsRoot:     bytesutil.PadTo([]byte("receiptroot"), 32),
-			LogsBloom:        bytesutil.PadTo([]byte("logsbloom"), 256),
-			PrevRandao:       bytesutil.PadTo([]byte("prevrandao"), 32),
-			BlockNumber:      123,
-			GasLimit:         456,
-			GasUsed:          789,
-			Timestamp:        012,
-			ExtraData:        []byte("extradata"),
-			BaseFeePerGas:    bytesutil.PadTo([]byte("basefeepergas"), 32),
-			BlockHash:        bytesutil.PadTo([]byte("blockhash"), 32),
-			TransactionsRoot: bytesutil.PadTo([]byte("transactionsroot"), 32),
-			WithdrawalsRoot:  bytesutil.PadTo([]byte("withdrawalsroot"), 32),
-			BlobGasUsed:      343,
-			ExcessBlobGas:    676,
-		}
-		state.NextWithdrawalIndex = 123
-		state.NextWithdrawalValidatorIndex = 123
-		state.HistoricalSummaries = []*ethpbalpha.HistoricalSummary{
-			{
-				BlockSummaryRoot: bytesutil.PadTo([]byte("blocksummaryroot"), 32),
-				StateSummaryRoot: bytesutil.PadTo([]byte("statesummaryroot"), 32),
-			},
-			{
-				BlockSummaryRoot: bytesutil.PadTo([]byte("blocksummaryroot2"), 32),
-				StateSummaryRoot: bytesutil.PadTo([]byte("statesummaryroot2"), 32),
-			}}
-		return nil
-	})
-	require.NoError(t, err)
-
-	result, err := BeaconStateDenebToProto(source)
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	assert.Equal(t, uint64(1), result.GenesisTime)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("genesisvalidatorsroot"), 32), result.GenesisValidatorsRoot)
-	assert.Equal(t, primitives.Slot(2), result.Slot)
-	resultFork := result.Fork
-	require.NotNil(t, resultFork)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("123"), 4), resultFork.PreviousVersion)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("456"), 4), resultFork.CurrentVersion)
-	assert.Equal(t, primitives.Epoch(3), resultFork.Epoch)
-	resultLatestBlockHeader := result.LatestBlockHeader
-	require.NotNil(t, resultLatestBlockHeader)
-	assert.Equal(t, primitives.Slot(4), resultLatestBlockHeader.Slot)
-	assert.Equal(t, primitives.ValidatorIndex(5), resultLatestBlockHeader.ProposerIndex)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhparentroot"), 32), resultLatestBlockHeader.ParentRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhstateroot"), 32), resultLatestBlockHeader.StateRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("lbhbodyroot"), 32), resultLatestBlockHeader.BodyRoot)
-	assert.Equal(t, 8192, len(result.BlockRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blockroots"), 32), result.BlockRoots[0])
-	assert.Equal(t, 8192, len(result.StateRoots))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("stateroots"), 32), result.StateRoots[0])
-	resultEth1Data := result.Eth1Data
-	require.NotNil(t, resultEth1Data)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1ddepositroot"), 32), resultEth1Data.DepositRoot)
-	assert.Equal(t, uint64(6), resultEth1Data.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dblockhash"), 32), resultEth1Data.BlockHash)
-	require.Equal(t, 1, len(result.Eth1DataVotes))
-	resultEth1DataVote := result.Eth1DataVotes[0]
-	require.NotNil(t, resultEth1DataVote)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvdepositroot"), 32), resultEth1DataVote.DepositRoot)
-	assert.Equal(t, uint64(7), resultEth1DataVote.DepositCount)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("e1dvblockhash"), 32), resultEth1DataVote.BlockHash)
-	assert.Equal(t, uint64(8), result.Eth1DepositIndex)
-	require.Equal(t, 1, len(result.Validators))
-	resultValidator := result.Validators[0]
-	require.NotNil(t, resultValidator)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("publickey"), 48), resultValidator.Pubkey)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("withdrawalcredentials"), 32), resultValidator.WithdrawalCredentials)
-	assert.Equal(t, uint64(9), resultValidator.EffectiveBalance)
-	assert.Equal(t, true, resultValidator.Slashed)
-	assert.Equal(t, primitives.Epoch(10), resultValidator.ActivationEligibilityEpoch)
-	assert.Equal(t, primitives.Epoch(11), resultValidator.ActivationEpoch)
-	assert.Equal(t, primitives.Epoch(12), resultValidator.ExitEpoch)
-	assert.Equal(t, primitives.Epoch(13), resultValidator.WithdrawableEpoch)
-	assert.DeepEqual(t, []uint64{14}, result.Balances)
-	assert.Equal(t, 65536, len(result.RandaoMixes))
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("randaomixes"), 32), result.RandaoMixes[0])
-	assert.DeepEqual(t, []uint64{15}, result.Slashings)
-	assert.DeepEqual(t, bitfield.Bitvector4{1}, result.JustificationBits)
-	resultPrevJustifiedCheckpoint := result.PreviousJustifiedCheckpoint
-	require.NotNil(t, resultPrevJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(30), resultPrevJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("pjcroot"), 32), resultPrevJustifiedCheckpoint.Root)
-	resultCurrJustifiedCheckpoint := result.CurrentJustifiedCheckpoint
-	require.NotNil(t, resultCurrJustifiedCheckpoint)
-	assert.Equal(t, primitives.Epoch(31), resultCurrJustifiedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("cjcroot"), 32), resultCurrJustifiedCheckpoint.Root)
-	resultFinalizedCheckpoint := result.FinalizedCheckpoint
-	require.NotNil(t, resultFinalizedCheckpoint)
-	assert.Equal(t, primitives.Epoch(32), resultFinalizedCheckpoint.Epoch)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("fcroot"), 32), resultFinalizedCheckpoint.Root)
-	assert.DeepEqual(t, []byte("previousepochparticipation"), result.PreviousEpochParticipation)
-	assert.DeepEqual(t, []byte("currentepochparticipation"), result.CurrentEpochParticipation)
-	assert.DeepEqual(t, []uint64{1, 2, 3}, result.InactivityScores)
-	require.NotNil(t, result.CurrentSyncCommittee)
-	assert.DeepEqual(t, [][]byte{bytesutil.PadTo([]byte("cscpubkeys"), 48)}, result.CurrentSyncCommittee.Pubkeys)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("cscaggregatepubkey"), 48), result.CurrentSyncCommittee.AggregatePubkey)
-	require.NotNil(t, result.NextSyncCommittee)
-	assert.DeepEqual(t, [][]byte{bytesutil.PadTo([]byte("nscpubkeys"), 48)}, result.NextSyncCommittee.Pubkeys)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("nscaggregatepubkey"), 48), result.NextSyncCommittee.AggregatePubkey)
-	resultLatestExecutionPayloadHeader := result.LatestExecutionPayloadHeader
-	require.NotNil(t, resultLatestExecutionPayloadHeader)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("parenthash"), 32), resultLatestExecutionPayloadHeader.ParentHash)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("feerecipient"), 20), resultLatestExecutionPayloadHeader.FeeRecipient)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("stateroot"), 32), resultLatestExecutionPayloadHeader.StateRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("receiptroot"), 32), resultLatestExecutionPayloadHeader.ReceiptsRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("logsbloom"), 256), resultLatestExecutionPayloadHeader.LogsBloom)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("prevrandao"), 32), resultLatestExecutionPayloadHeader.PrevRandao)
-	assert.Equal(t, uint64(123), resultLatestExecutionPayloadHeader.BlockNumber)
-	assert.Equal(t, uint64(456), resultLatestExecutionPayloadHeader.GasLimit)
-	assert.Equal(t, uint64(789), resultLatestExecutionPayloadHeader.GasUsed)
-	assert.Equal(t, uint64(012), resultLatestExecutionPayloadHeader.Timestamp)
-	assert.DeepEqual(t, []byte("extradata"), resultLatestExecutionPayloadHeader.ExtraData)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("basefeepergas"), 32), resultLatestExecutionPayloadHeader.BaseFeePerGas)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blockhash"), 32), resultLatestExecutionPayloadHeader.BlockHash)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("transactionsroot"), 32), resultLatestExecutionPayloadHeader.TransactionsRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("withdrawalsroot"), 32), resultLatestExecutionPayloadHeader.WithdrawalsRoot)
-	assert.DeepEqual(t, uint64(343), resultLatestExecutionPayloadHeader.BlobGasUsed)
-	assert.DeepEqual(t, uint64(676), resultLatestExecutionPayloadHeader.ExcessBlobGas)
-	assert.Equal(t, uint64(123), result.NextWithdrawalIndex)
-	assert.Equal(t, primitives.ValidatorIndex(123), result.NextWithdrawalValidatorIndex)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blocksummaryroot"), 32), result.HistoricalSummaries[0].BlockSummaryRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("statesummaryroot"), 32), result.HistoricalSummaries[0].StateSummaryRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("blocksummaryroot2"), 32), result.HistoricalSummaries[1].BlockSummaryRoot)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("statesummaryroot2"), 32), result.HistoricalSummaries[1].StateSummaryRoot)
-}
-
-func TestV1Alpha1SignedBLSToExecChangeToV2(t *testing.T) {
-	alphaChange := &ethpbalpha.SignedBLSToExecutionChange{
-		Message: &ethpbalpha.BLSToExecutionChange{
-			ValidatorIndex:     validatorIndex,
-			FromBlsPubkey:      bytesutil.PadTo([]byte("fromblspubkey"), 48),
-			ToExecutionAddress: bytesutil.PadTo([]byte("toexecutionaddress"), 20),
-		},
-		Signature: signature,
-	}
-	change := V1Alpha1SignedBLSToExecChangeToV2(alphaChange)
-	require.NotNil(t, change)
-	require.NotNil(t, change.Message)
-	assert.DeepEqual(t, signature, change.Signature)
-	assert.Equal(t, validatorIndex, change.Message.ValidatorIndex)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("fromblspubkey"), 48), change.Message.FromBlsPubkey)
-	assert.DeepEqual(t, bytesutil.PadTo([]byte("toexecutionaddress"), 20), change.Message.ToExecutionAddress)
-}

proto/migration/v2_to_v1alpha1.go

@@ -1,113 +0,0 @@
-package migration
-
-import (
-	"github.com/pkg/errors"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"google.golang.org/protobuf/proto"
-)
-
-// AltairToV1Alpha1SignedBlock converts a v2 SignedBeaconBlockAltair proto to a v1alpha1 proto.
-func AltairToV1Alpha1SignedBlock(altairBlk *ethpbv2.SignedBeaconBlockAltair) (*ethpbalpha.SignedBeaconBlockAltair, error) {
-	marshaledBlk, err := proto.Marshal(altairBlk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1alpha1Block := &ethpbalpha.SignedBeaconBlockAltair{}
-	if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1alpha1Block, nil
-}
-
-// BellatrixToV1Alpha1SignedBlock converts a v2 SignedBeaconBlockBellatrix proto to a v1alpha1 proto.
-func BellatrixToV1Alpha1SignedBlock(bellatrixBlk *ethpbv2.SignedBeaconBlockBellatrix) (*ethpbalpha.SignedBeaconBlockBellatrix, error) {
-	marshaledBlk, err := proto.Marshal(bellatrixBlk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1alpha1Block := &ethpbalpha.SignedBeaconBlockBellatrix{}
-	if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1alpha1Block, nil
-}
-
-// CapellaToV1Alpha1SignedBlock converts a v2 SignedBeaconBlockCapella proto to a v1alpha1 proto.
-func CapellaToV1Alpha1SignedBlock(capellaBlk *ethpbv2.SignedBeaconBlockCapella) (*ethpbalpha.SignedBeaconBlockCapella, error) {
-	marshaledBlk, err := proto.Marshal(capellaBlk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1alpha1Block := &ethpbalpha.SignedBeaconBlockCapella{}
-	if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1alpha1Block, nil
-}
-
-// DenebToV1Alpha1SignedBlock converts a v2 SignedBeaconBlockDeneb proto to a v1alpha1 proto.
-func DenebToV1Alpha1SignedBlock(denebBlk *ethpbv2.SignedBeaconBlockDeneb) (*ethpbalpha.SignedBeaconBlockDeneb, error) {
-	marshaledBlk, err := proto.Marshal(denebBlk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1alpha1Block := &ethpbalpha.SignedBeaconBlockDeneb{}
-	if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1alpha1Block, nil
-}
-
-// V2BeaconBlockDenebToV1Alpha1 converts a v2 Deneb beacon block to a v1alpha1
-// Deneb block.
-func V2BeaconBlockDenebToV1Alpha1(v2block *ethpbv2.BeaconBlockDeneb) (*ethpbalpha.BeaconBlockDeneb, error) {
-	marshaledBlk, err := proto.Marshal(v2block)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1alpha1block := &ethpbalpha.BeaconBlockDeneb{}
-	if err := proto.Unmarshal(marshaledBlk, v1alpha1block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1alpha1block, nil
-}
-
-// BlindedBellatrixToV1Alpha1SignedBlock converts a v2 SignedBlindedBeaconBlockBellatrix proto to a v1alpha1 proto.
-func BlindedBellatrixToV1Alpha1SignedBlock(bellatrixBlk *ethpbv2.SignedBlindedBeaconBlockBellatrix) (*ethpbalpha.SignedBlindedBeaconBlockBellatrix, error) {
-	marshaledBlk, err := proto.Marshal(bellatrixBlk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1alpha1Block := &ethpbalpha.SignedBlindedBeaconBlockBellatrix{}
-	if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1alpha1Block, nil
-}
-
-// BlindedCapellaToV1Alpha1SignedBlock converts a v2 SignedBlindedBeaconBlockCapella proto to a v1alpha1 proto.
-func BlindedCapellaToV1Alpha1SignedBlock(capellaBlk *ethpbv2.SignedBlindedBeaconBlockCapella) (*ethpbalpha.SignedBlindedBeaconBlockCapella, error) {
-	marshaledBlk, err := proto.Marshal(capellaBlk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1alpha1Block := &ethpbalpha.SignedBlindedBeaconBlockCapella{}
-	if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1alpha1Block, nil
-}
-
-// BlindedDenebToV1Alpha1SignedBlock converts a v2 SignedBlindedBeaconBlockDeneb proto to a v1alpha1 proto.
-func BlindedDenebToV1Alpha1SignedBlock(denebBlk *ethpbv2.SignedBlindedBeaconBlockDeneb) (*ethpbalpha.SignedBlindedBeaconBlockDeneb, error) {
-	marshaledBlk, err := proto.Marshal(denebBlk)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal block")
-	}
-	v1alpha1Block := &ethpbalpha.SignedBlindedBeaconBlockDeneb{}
-	if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal block")
-	}
-	return v1alpha1Block, nil
-}

proto/migration/v2_to_v1alpha1_test.go

@@ -1,132 +0,0 @@
-package migration
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/go-bitfield"
-	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-)
-
-func Test_AltairToV1Alpha1SignedBlock(t *testing.T) {
-	v2Block := util.HydrateV2AltairSignedBeaconBlock(&ethpbv2.SignedBeaconBlockAltair{})
-	v2Block.Message.Slot = slot
-	v2Block.Message.ProposerIndex = validatorIndex
-	v2Block.Message.ParentRoot = parentRoot
-	v2Block.Message.StateRoot = stateRoot
-	v2Block.Message.Body.RandaoReveal = randaoReveal
-	v2Block.Message.Body.Eth1Data = &ethpbv1.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	syncCommitteeBits := bitfield.NewBitvector512()
-	syncCommitteeBits.SetBitAt(100, true)
-	v2Block.Message.Body.SyncAggregate = &ethpbv1.SyncAggregate{
-		SyncCommitteeBits:      syncCommitteeBits,
-		SyncCommitteeSignature: signature,
-	}
-	v2Block.Signature = signature
-
-	alphaBlock, err := AltairToV1Alpha1SignedBlock(v2Block)
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	v2Root, err := v2Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v2Root, alphaRoot)
-}
-
-func Test_BellatrixToV1Alpha1SignedBlock(t *testing.T) {
-	v2Block := util.HydrateV2BellatrixSignedBeaconBlock(&ethpbv2.SignedBeaconBlockBellatrix{})
-	v2Block.Message.Slot = slot
-	v2Block.Message.ProposerIndex = validatorIndex
-	v2Block.Message.ParentRoot = parentRoot
-	v2Block.Message.StateRoot = stateRoot
-	v2Block.Message.Body.RandaoReveal = randaoReveal
-	v2Block.Message.Body.Eth1Data = &ethpbv1.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	syncCommitteeBits := bitfield.NewBitvector512()
-	syncCommitteeBits.SetBitAt(100, true)
-	v2Block.Message.Body.SyncAggregate = &ethpbv1.SyncAggregate{
-		SyncCommitteeBits:      syncCommitteeBits,
-		SyncCommitteeSignature: signature,
-	}
-	v2Block.Message.Body.ExecutionPayload = &enginev1.ExecutionPayload{
-		ParentHash:    parentHash,
-		FeeRecipient:  feeRecipient,
-		StateRoot:     stateRoot,
-		ReceiptsRoot:  receiptsRoot,
-		LogsBloom:     logsBloom,
-		PrevRandao:    prevRandao,
-		BlockNumber:   blockNumber,
-		GasLimit:      gasLimit,
-		GasUsed:       gasUsed,
-		Timestamp:     timestamp,
-		ExtraData:     extraData,
-		BaseFeePerGas: baseFeePerGas,
-		BlockHash:     blockHash,
-		Transactions:  [][]byte{[]byte("transaction1"), []byte("transaction2")},
-	}
-	v2Block.Signature = signature
-
-	alphaBlock, err := BellatrixToV1Alpha1SignedBlock(v2Block)
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	v2Root, err := v2Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v2Root, alphaRoot)
-}
-
-func Test_BlindedBellatrixToV1Alpha1SignedBlock(t *testing.T) {
-	v2Block := util.HydrateV2SignedBlindedBeaconBlockBellatrix(&ethpbv2.SignedBlindedBeaconBlockBellatrix{})
-	v2Block.Message.Slot = slot
-	v2Block.Message.ProposerIndex = validatorIndex
-	v2Block.Message.ParentRoot = parentRoot
-	v2Block.Message.StateRoot = stateRoot
-	v2Block.Message.Body.RandaoReveal = randaoReveal
-	v2Block.Message.Body.Eth1Data = &ethpbv1.Eth1Data{
-		DepositRoot:  depositRoot,
-		DepositCount: depositCount,
-		BlockHash:    blockHash,
-	}
-	syncCommitteeBits := bitfield.NewBitvector512()
-	syncCommitteeBits.SetBitAt(100, true)
-	v2Block.Message.Body.SyncAggregate = &ethpbv1.SyncAggregate{
-		SyncCommitteeBits:      syncCommitteeBits,
-		SyncCommitteeSignature: signature,
-	}
-	v2Block.Message.Body.ExecutionPayloadHeader = &enginev1.ExecutionPayloadHeader{
-		ParentHash:       parentHash,
-		FeeRecipient:     feeRecipient,
-		StateRoot:        stateRoot,
-		ReceiptsRoot:     receiptsRoot,
-		LogsBloom:        logsBloom,
-		PrevRandao:       prevRandao,
-		BlockNumber:      blockNumber,
-		GasLimit:         gasLimit,
-		GasUsed:          gasUsed,
-		Timestamp:        timestamp,
-		ExtraData:        extraData,
-		BaseFeePerGas:    baseFeePerGas,
-		BlockHash:        blockHash,
-		TransactionsRoot: transactionsRoot,
-	}
-	v2Block.Signature = signature
-
-	alphaBlock, err := BlindedBellatrixToV1Alpha1SignedBlock(v2Block)
-	require.NoError(t, err)
-	alphaRoot, err := alphaBlock.HashTreeRoot()
-	require.NoError(t, err)
-	v2Root, err := v2Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, v2Root, alphaRoot)
-}

proto/prysm/BUILD.bazel

@@ -1 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")

proto/prysm/v1alpha1/node.pb.go

@@ -130,6 +130,53 @@ func (ConnectionState) EnumDescriptor() ([]byte, []int) {
 	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{1}
 }
 
+type HealthRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SyncingStatus uint64 `protobuf:"varint,1,opt,name=syncing_status,json=syncingStatus,proto3" json:"syncing_status,omitempty"`
+}
+
+func (x *HealthRequest) Reset() {
+	*x = HealthRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *HealthRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*HealthRequest) ProtoMessage() {}
+
+func (x *HealthRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use HealthRequest.ProtoReflect.Descriptor instead.
+func (*HealthRequest) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *HealthRequest) GetSyncingStatus() uint64 {
+	if x != nil {
+		return x.SyncingStatus
+	}
+	return 0
+}
+
 type SyncStatus struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -141,7 +188,7 @@ type SyncStatus struct {
 func (x *SyncStatus) Reset() {
 	*x = SyncStatus{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[0]
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[1]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -154,7 +201,7 @@ func (x *SyncStatus) String() string {
 func (*SyncStatus) ProtoMessage() {}
 
 func (x *SyncStatus) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[0]
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[1]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -167,7 +214,7 @@ func (x *SyncStatus) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SyncStatus.ProtoReflect.Descriptor instead.
 func (*SyncStatus) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{0}
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{1}
 }
 
 func (x *SyncStatus) GetSyncing() bool {
@@ -190,7 +237,7 @@ type Genesis struct {
 func (x *Genesis) Reset() {
 	*x = Genesis{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[1]
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[2]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -203,7 +250,7 @@ func (x *Genesis) String() string {
 func (*Genesis) ProtoMessage() {}
 
 func (x *Genesis) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[1]
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[2]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -216,7 +263,7 @@ func (x *Genesis) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Genesis.ProtoReflect.Descriptor instead.
 func (*Genesis) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{1}
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{2}
 }
 
 func (x *Genesis) GetGenesisTime() *timestamppb.Timestamp {
@@ -252,7 +299,7 @@ type Version struct {
 func (x *Version) Reset() {
 	*x = Version{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[2]
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -265,7 +312,7 @@ func (x *Version) String() string {
 func (*Version) ProtoMessage() {}
 
 func (x *Version) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[2]
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[3]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -278,7 +325,7 @@ func (x *Version) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Version.ProtoReflect.Descriptor instead.
 func (*Version) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{2}
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{3}
 }
 
 func (x *Version) GetVersion() string {
@@ -306,7 +353,7 @@ type ImplementedServices struct {
 func (x *ImplementedServices) Reset() {
 	*x = ImplementedServices{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[3]
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -319,7 +366,7 @@ func (x *ImplementedServices) String() string {
 func (*ImplementedServices) ProtoMessage() {}
 
 func (x *ImplementedServices) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[3]
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -332,7 +379,7 @@ func (x *ImplementedServices) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ImplementedServices.ProtoReflect.Descriptor instead.
 func (*ImplementedServices) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{3}
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{4}
 }
 
 func (x *ImplementedServices) GetServices() []string {
@@ -353,7 +400,7 @@ type PeerRequest struct {
 func (x *PeerRequest) Reset() {
 	*x = PeerRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[4]
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -366,7 +413,7 @@ func (x *PeerRequest) String() string {
 func (*PeerRequest) ProtoMessage() {}
 
 func (x *PeerRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[4]
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[5]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -379,7 +426,7 @@ func (x *PeerRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use PeerRequest.ProtoReflect.Descriptor instead.
 func (*PeerRequest) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{4}
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{5}
 }
 
 func (x *PeerRequest) GetPeerId() string {
@@ -400,7 +447,7 @@ type Peers struct {
 func (x *Peers) Reset() {
 	*x = Peers{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[5]
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[6]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -413,7 +460,7 @@ func (x *Peers) String() string {
 func (*Peers) ProtoMessage() {}
 
 func (x *Peers) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[5]
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[6]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -426,7 +473,7 @@ func (x *Peers) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Peers.ProtoReflect.Descriptor instead.
 func (*Peers) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{5}
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{6}
 }
 
 func (x *Peers) GetPeers() []*Peer {
@@ -451,7 +498,7 @@ type Peer struct {
 func (x *Peer) Reset() {
 	*x = Peer{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[6]
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[7]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -464,7 +511,7 @@ func (x *Peer) String() string {
 func (*Peer) ProtoMessage() {}
 
 func (x *Peer) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[6]
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[7]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -477,7 +524,7 @@ func (x *Peer) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Peer.ProtoReflect.Descriptor instead.
 func (*Peer) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{6}
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{7}
 }
 
 func (x *Peer) GetAddress() string {
@@ -528,7 +575,7 @@ type HostData struct {
 func (x *HostData) Reset() {
 	*x = HostData{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[7]
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[8]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -541,7 +588,7 @@ func (x *HostData) String() string {
 func (*HostData) ProtoMessage() {}
 
 func (x *HostData) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[7]
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[8]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -554,7 +601,7 @@ func (x *HostData) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use HostData.ProtoReflect.Descriptor instead.
 func (*HostData) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{7}
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{8}
 }
 
 func (x *HostData) GetAddresses() []string {
@@ -592,7 +639,7 @@ type ETH1ConnectionStatus struct {
 func (x *ETH1ConnectionStatus) Reset() {
 	*x = ETH1ConnectionStatus{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[8]
+		mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[9]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -605,7 +652,7 @@ func (x *ETH1ConnectionStatus) String() string {
 func (*ETH1ConnectionStatus) ProtoMessage() {}
 
 func (x *ETH1ConnectionStatus) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[8]
+	mi := &file_proto_prysm_v1alpha1_node_proto_msgTypes[9]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -618,7 +665,7 @@ func (x *ETH1ConnectionStatus) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ETH1ConnectionStatus.ProtoReflect.Descriptor instead.
 func (*ETH1ConnectionStatus) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{8}
+	return file_proto_prysm_v1alpha1_node_proto_rawDescGZIP(), []int{9}
 }
 
 func (x *ETH1ConnectionStatus) GetCurrentAddress() string {
@@ -663,143 +710,154 @@ var file_proto_prysm_v1alpha1_node_proto_rawDesc = []byte{
 	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70,
 	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f,
 	0x65, 0x78, 0x74, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x22, 0x26, 0x0a, 0x0a, 0x53, 0x79, 0x6e, 0x63, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12,
-	0x18, 0x0a, 0x07, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08,
-	0x52, 0x07, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x22, 0xc2, 0x01, 0x0a, 0x07, 0x47, 0x65,
-	0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
-	0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69,
-	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
-	0x54, 0x69, 0x6d, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f,
-	0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x16, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43,
-	0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3e,
-	0x0a, 0x17, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x6f, 0x72, 0x73, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42,
-	0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x15, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3f,
-	0x0a, 0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72,
-	0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73,
-	0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22,
-	0x31, 0x0a, 0x13, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x53, 0x65,
-	0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x65, 0x73, 0x22, 0x26, 0x0a, 0x0b, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72, 0x49, 0x64, 0x22, 0x3a, 0x0a, 0x05, 0x50, 0x65,
-	0x65, 0x72, 0x73, 0x12, 0x31, 0x0a, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74,
-	0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52,
-	0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x22, 0xe2, 0x01, 0x0a, 0x04, 0x50, 0x65, 0x65, 0x72, 0x12,
-	0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x42, 0x0a, 0x09, 0x64, 0x69, 0x72,
-	0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x65,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c,
-	0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x51, 0x0a,
-	0x10, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74,
-	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65,
-	0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
-	0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52,
-	0x0f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65,
-	0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x72,
-	0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x72, 0x22, 0x53, 0x0a, 0x08, 0x48,
-	0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72,
-	0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x64,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72, 0x49, 0x64, 0x12, 0x10,
-	0x0a, 0x03, 0x65, 0x6e, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x72,
-	0x22, 0xc4, 0x01, 0x0a, 0x14, 0x45, 0x54, 0x48, 0x31, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74,
-	0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x75, 0x72,
-	0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x12, 0x38, 0x0a, 0x18, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x6f,
-	0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x16, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e,
-	0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x1c, 0x0a, 0x09,
-	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52,
-	0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f,
-	0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x18,
-	0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x2a, 0x37, 0x0a, 0x0d, 0x50, 0x65, 0x65, 0x72, 0x44,
-	0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e,
-	0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x42, 0x4f, 0x55, 0x4e, 0x44,
-	0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x4f, 0x55, 0x54, 0x42, 0x4f, 0x55, 0x4e, 0x44, 0x10, 0x02,
-	0x2a, 0x55, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74,
-	0x61, 0x74, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x44, 0x49, 0x53, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43,
-	0x54, 0x45, 0x44, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x49, 0x53, 0x43, 0x4f, 0x4e, 0x4e,
-	0x45, 0x43, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x4e, 0x4e,
-	0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x43, 0x4f, 0x4e, 0x4e, 0x45,
-	0x43, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x32, 0x93, 0x07, 0x0a, 0x04, 0x4e, 0x6f, 0x64, 0x65,
-	0x12, 0x6e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x53, 0x74, 0x61, 0x74, 0x75,
-	0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
-	0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x22, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70,
-	0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67,
-	0x12, 0x68, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x16,
-	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
-	0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47,
-	0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a,
-	0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f,
-	0x64, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x68, 0x0a, 0x0a, 0x47, 0x65,
-	0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
-	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79,
-	0x1a, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e,
-	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
-	0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76,
-	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x76, 0x65, 0x72,
-	0x73, 0x69, 0x6f, 0x6e, 0x12, 0x82, 0x01, 0x0a, 0x17, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6d, 0x70,
-	0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73,
-	0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2a, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
-	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
-	0x2e, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76,
-	0x69, 0x63, 0x65, 0x73, 0x22, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x12, 0x1b, 0x2f, 0x65,
+	0x6f, 0x22, 0x36, 0x0a, 0x0d, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74,
+	0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63,
+	0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x26, 0x0a, 0x0a, 0x53, 0x79, 0x6e,
+	0x63, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x79, 0x6e, 0x63, 0x69,
+	0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e,
+	0x67, 0x22, 0xc2, 0x01, 0x0a, 0x07, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x3d, 0x0a,
+	0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52,
+	0x0b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x38, 0x0a, 0x18,
+	0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74,
+	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x16,
+	0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3e, 0x0a, 0x17, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69,
+	0x73, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x5f, 0x72, 0x6f, 0x6f,
+	0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52,
+	0x15, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
+	0x72, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x3f, 0x0a, 0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
+	0x6e, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x6d,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x31, 0x0a, 0x13, 0x49, 0x6d, 0x70, 0x6c, 0x65,
+	0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x1a,
+	0x0a, 0x08, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x08, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x22, 0x26, 0x0a, 0x0b, 0x50, 0x65,
+	0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65,
+	0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72,
+	0x49, 0x64, 0x22, 0x3a, 0x0a, 0x05, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x31, 0x0a, 0x05, 0x70,
+	0x65, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x65, 0x74, 0x68,
+	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
+	0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x22, 0xe2,
+	0x01, 0x0a, 0x04, 0x50, 0x65, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x12, 0x42, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e,
+	0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65,
+	0x72, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65,
+	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x51, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x26, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76,
+	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74,
+	0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72,
+	0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72, 0x49,
+	0x64, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+	0x65, 0x6e, 0x72, 0x22, 0x53, 0x0a, 0x08, 0x48, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12,
+	0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x09, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x17, 0x0a,
+	0x07, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
+	0x70, 0x65, 0x65, 0x72, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x72, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x72, 0x22, 0xc4, 0x01, 0x0a, 0x14, 0x45, 0x54, 0x48,
+	0x31, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75,
+	0x73, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72,
+	0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x38, 0x0a, 0x18, 0x63, 0x75,
+	0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x16, 0x63, 0x75,
+	0x72, 0x72, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x45,
+	0x72, 0x72, 0x6f, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x63,
+	0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x2a,
+	0x37, 0x0a, 0x0d, 0x50, 0x65, 0x65, 0x72, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0b, 0x0a,
+	0x07, 0x49, 0x4e, 0x42, 0x4f, 0x55, 0x4e, 0x44, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x4f, 0x55,
+	0x54, 0x42, 0x4f, 0x55, 0x4e, 0x44, 0x10, 0x02, 0x2a, 0x55, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x6e,
+	0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x44,
+	0x49, 0x53, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x00, 0x12, 0x11, 0x0a,
+	0x0d, 0x44, 0x49, 0x53, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x01,
+	0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x02, 0x12,
+	0x0e, 0x0a, 0x0a, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x32,
+	0x81, 0x08, 0x0a, 0x04, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x6e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x53,
+	0x79, 0x6e, 0x63, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x1a, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68,
+	0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x53, 0x74,
+	0x61, 0x74, 0x75, 0x73, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a, 0x2f, 0x65,
 	0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65,
-	0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x62, 0x0a, 0x07, 0x47, 0x65, 0x74,
-	0x48, 0x6f, 0x73, 0x74, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1f, 0x2e, 0x65,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c,
-	0x70, 0x68, 0x61, 0x31, 0x2e, 0x48, 0x6f, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x22, 0x1e, 0x82,
-	0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c,
-	0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x70, 0x32, 0x70, 0x12, 0x6b, 0x0a,
-	0x07, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x12, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
+	0x2f, 0x73, 0x79, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x12, 0x68, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x47,
+	0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1e,
+	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x22, 0x22,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61,
+	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73,
+	0x69, 0x73, 0x12, 0x68, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+	0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72,
 	0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
-	0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x65,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c,
-	0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0x19, 0x12, 0x17, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
-	0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x70, 0x65, 0x65, 0x72, 0x12, 0x63, 0x0a, 0x09, 0x4c, 0x69,
-	0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a,
-	0x1c, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76,
-	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x73, 0x22, 0x20, 0x82,
-	0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c,
-	0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x70, 0x65, 0x65, 0x72, 0x73, 0x12,
-	0x8b, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x45, 0x54, 0x48, 0x31, 0x43, 0x6f, 0x6e, 0x6e, 0x65,
-	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d,
-	0x70, 0x74, 0x79, 0x1a, 0x2b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
-	0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x54, 0x48, 0x31,
-	0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
-	0x22, 0x2b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x25, 0x12, 0x23, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76,
-	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x65, 0x74, 0x68,
-	0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x94, 0x01,
-	0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
-	0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x09, 0x4e, 0x6f, 0x64,
-	0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61,
-	0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
-	0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e,
-	0x45, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x15, 0x45,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x61, 0x6c,
-	0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c,
+	0x12, 0x1a, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f,
+	0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x6c, 0x0a, 0x09,
+	0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65,
+	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x2e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12,
+	0x19, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e,
+	0x6f, 0x64, 0x65, 0x2f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x82, 0x01, 0x0a, 0x17, 0x4c,
+	0x69, 0x73, 0x74, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x53, 0x65,
+	0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2a,
+	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
+	0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x22, 0x23, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x1d, 0x12, 0x1b, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12,
+	0x62, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x1a, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74,
+	0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x48, 0x6f, 0x73, 0x74, 0x44,
+	0x61, 0x74, 0x61, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x65, 0x74,
+	0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f,
+	0x70, 0x32, 0x70, 0x12, 0x6b, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x12, 0x22,
+	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74,
+	0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x22,
+	0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x70, 0x65, 0x65, 0x72,
+	0x12, 0x63, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x16, 0x2e,
+	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1c, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
+	0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x65,
+	0x65, 0x72, 0x73, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x65, 0x74,
+	0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f,
+	0x70, 0x65, 0x65, 0x72, 0x73, 0x12, 0x8b, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x45, 0x54, 0x48,
+	0x31, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75,
+	0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2b, 0x2e, 0x65, 0x74, 0x68, 0x65,
+	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x2e, 0x45, 0x54, 0x48, 0x31, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x25, 0x12, 0x23,
+	0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6e, 0x6f,
+	0x64, 0x65, 0x2f, 0x65, 0x74, 0x68, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x42, 0x94, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65,
+	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x42, 0x09, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a,
+	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d,
+	0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76,
+	0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31,
+	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02, 0x15, 0x45, 0x74, 0x68,
+	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
+	0x61, 0x31, 0xca, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74,
+	0x68, 0x5c, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
 }
 
 var (
@@ -815,45 +873,48 @@ func file_proto_prysm_v1alpha1_node_proto_rawDescGZIP() []byte {
 }
 
 var file_proto_prysm_v1alpha1_node_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
-var file_proto_prysm_v1alpha1_node_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
+var file_proto_prysm_v1alpha1_node_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
 var file_proto_prysm_v1alpha1_node_proto_goTypes = []interface{}{
 	(PeerDirection)(0),            // 0: ethereum.eth.v1alpha1.PeerDirection
 	(ConnectionState)(0),          // 1: ethereum.eth.v1alpha1.ConnectionState
-	(*SyncStatus)(nil),            // 2: ethereum.eth.v1alpha1.SyncStatus
-	(*Genesis)(nil),               // 3: ethereum.eth.v1alpha1.Genesis
-	(*Version)(nil),               // 4: ethereum.eth.v1alpha1.Version
-	(*ImplementedServices)(nil),   // 5: ethereum.eth.v1alpha1.ImplementedServices
-	(*PeerRequest)(nil),           // 6: ethereum.eth.v1alpha1.PeerRequest
-	(*Peers)(nil),                 // 7: ethereum.eth.v1alpha1.Peers
-	(*Peer)(nil),                  // 8: ethereum.eth.v1alpha1.Peer
-	(*HostData)(nil),              // 9: ethereum.eth.v1alpha1.HostData
-	(*ETH1ConnectionStatus)(nil),  // 10: ethereum.eth.v1alpha1.ETH1ConnectionStatus
-	(*timestamppb.Timestamp)(nil), // 11: google.protobuf.Timestamp
-	(*emptypb.Empty)(nil),         // 12: google.protobuf.Empty
+	(*HealthRequest)(nil),         // 2: ethereum.eth.v1alpha1.HealthRequest
+	(*SyncStatus)(nil),            // 3: ethereum.eth.v1alpha1.SyncStatus
+	(*Genesis)(nil),               // 4: ethereum.eth.v1alpha1.Genesis
+	(*Version)(nil),               // 5: ethereum.eth.v1alpha1.Version
+	(*ImplementedServices)(nil),   // 6: ethereum.eth.v1alpha1.ImplementedServices
+	(*PeerRequest)(nil),           // 7: ethereum.eth.v1alpha1.PeerRequest
+	(*Peers)(nil),                 // 8: ethereum.eth.v1alpha1.Peers
+	(*Peer)(nil),                  // 9: ethereum.eth.v1alpha1.Peer
+	(*HostData)(nil),              // 10: ethereum.eth.v1alpha1.HostData
+	(*ETH1ConnectionStatus)(nil),  // 11: ethereum.eth.v1alpha1.ETH1ConnectionStatus
+	(*timestamppb.Timestamp)(nil), // 12: google.protobuf.Timestamp
+	(*emptypb.Empty)(nil),         // 13: google.protobuf.Empty
 }
 var file_proto_prysm_v1alpha1_node_proto_depIdxs = []int32{
-	11, // 0: ethereum.eth.v1alpha1.Genesis.genesis_time:type_name -> google.protobuf.Timestamp
-	8,  // 1: ethereum.eth.v1alpha1.Peers.peers:type_name -> ethereum.eth.v1alpha1.Peer
+	12, // 0: ethereum.eth.v1alpha1.Genesis.genesis_time:type_name -> google.protobuf.Timestamp
+	9,  // 1: ethereum.eth.v1alpha1.Peers.peers:type_name -> ethereum.eth.v1alpha1.Peer
 	0,  // 2: ethereum.eth.v1alpha1.Peer.direction:type_name -> ethereum.eth.v1alpha1.PeerDirection
 	1,  // 3: ethereum.eth.v1alpha1.Peer.connection_state:type_name -> ethereum.eth.v1alpha1.ConnectionState
-	12, // 4: ethereum.eth.v1alpha1.Node.GetSyncStatus:input_type -> google.protobuf.Empty
-	12, // 5: ethereum.eth.v1alpha1.Node.GetGenesis:input_type -> google.protobuf.Empty
-	12, // 6: ethereum.eth.v1alpha1.Node.GetVersion:input_type -> google.protobuf.Empty
-	12, // 7: ethereum.eth.v1alpha1.Node.ListImplementedServices:input_type -> google.protobuf.Empty
-	12, // 8: ethereum.eth.v1alpha1.Node.GetHost:input_type -> google.protobuf.Empty
-	6,  // 9: ethereum.eth.v1alpha1.Node.GetPeer:input_type -> ethereum.eth.v1alpha1.PeerRequest
-	12, // 10: ethereum.eth.v1alpha1.Node.ListPeers:input_type -> google.protobuf.Empty
-	12, // 11: ethereum.eth.v1alpha1.Node.GetETH1ConnectionStatus:input_type -> google.protobuf.Empty
-	2,  // 12: ethereum.eth.v1alpha1.Node.GetSyncStatus:output_type -> ethereum.eth.v1alpha1.SyncStatus
-	3,  // 13: ethereum.eth.v1alpha1.Node.GetGenesis:output_type -> ethereum.eth.v1alpha1.Genesis
-	4,  // 14: ethereum.eth.v1alpha1.Node.GetVersion:output_type -> ethereum.eth.v1alpha1.Version
-	5,  // 15: ethereum.eth.v1alpha1.Node.ListImplementedServices:output_type -> ethereum.eth.v1alpha1.ImplementedServices
-	9,  // 16: ethereum.eth.v1alpha1.Node.GetHost:output_type -> ethereum.eth.v1alpha1.HostData
-	8,  // 17: ethereum.eth.v1alpha1.Node.GetPeer:output_type -> ethereum.eth.v1alpha1.Peer
-	7,  // 18: ethereum.eth.v1alpha1.Node.ListPeers:output_type -> ethereum.eth.v1alpha1.Peers
-	10, // 19: ethereum.eth.v1alpha1.Node.GetETH1ConnectionStatus:output_type -> ethereum.eth.v1alpha1.ETH1ConnectionStatus
-	12, // [12:20] is the sub-list for method output_type
-	4,  // [4:12] is the sub-list for method input_type
+	13, // 4: ethereum.eth.v1alpha1.Node.GetSyncStatus:input_type -> google.protobuf.Empty
+	13, // 5: ethereum.eth.v1alpha1.Node.GetGenesis:input_type -> google.protobuf.Empty
+	13, // 6: ethereum.eth.v1alpha1.Node.GetVersion:input_type -> google.protobuf.Empty
+	2,  // 7: ethereum.eth.v1alpha1.Node.GetHealth:input_type -> ethereum.eth.v1alpha1.HealthRequest
+	13, // 8: ethereum.eth.v1alpha1.Node.ListImplementedServices:input_type -> google.protobuf.Empty
+	13, // 9: ethereum.eth.v1alpha1.Node.GetHost:input_type -> google.protobuf.Empty
+	7,  // 10: ethereum.eth.v1alpha1.Node.GetPeer:input_type -> ethereum.eth.v1alpha1.PeerRequest
+	13, // 11: ethereum.eth.v1alpha1.Node.ListPeers:input_type -> google.protobuf.Empty
+	13, // 12: ethereum.eth.v1alpha1.Node.GetETH1ConnectionStatus:input_type -> google.protobuf.Empty
+	3,  // 13: ethereum.eth.v1alpha1.Node.GetSyncStatus:output_type -> ethereum.eth.v1alpha1.SyncStatus
+	4,  // 14: ethereum.eth.v1alpha1.Node.GetGenesis:output_type -> ethereum.eth.v1alpha1.Genesis
+	5,  // 15: ethereum.eth.v1alpha1.Node.GetVersion:output_type -> ethereum.eth.v1alpha1.Version
+	13, // 16: ethereum.eth.v1alpha1.Node.GetHealth:output_type -> google.protobuf.Empty
+	6,  // 17: ethereum.eth.v1alpha1.Node.ListImplementedServices:output_type -> ethereum.eth.v1alpha1.ImplementedServices
+	10, // 18: ethereum.eth.v1alpha1.Node.GetHost:output_type -> ethereum.eth.v1alpha1.HostData
+	9,  // 19: ethereum.eth.v1alpha1.Node.GetPeer:output_type -> ethereum.eth.v1alpha1.Peer
+	8,  // 20: ethereum.eth.v1alpha1.Node.ListPeers:output_type -> ethereum.eth.v1alpha1.Peers
+	11, // 21: ethereum.eth.v1alpha1.Node.GetETH1ConnectionStatus:output_type -> ethereum.eth.v1alpha1.ETH1ConnectionStatus
+	13, // [13:22] is the sub-list for method output_type
+	4,  // [4:13] is the sub-list for method input_type
 	4,  // [4:4] is the sub-list for extension type_name
 	4,  // [4:4] is the sub-list for extension extendee
 	0,  // [0:4] is the sub-list for field type_name
@@ -866,7 +927,7 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 	}
 	if !protoimpl.UnsafeEnabled {
 		file_proto_prysm_v1alpha1_node_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SyncStatus); i {
+			switch v := v.(*HealthRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -878,7 +939,7 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_node_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Genesis); i {
+			switch v := v.(*SyncStatus); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -890,7 +951,7 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_node_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Version); i {
+			switch v := v.(*Genesis); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -902,7 +963,7 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_node_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ImplementedServices); i {
+			switch v := v.(*Version); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -914,7 +975,7 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_node_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PeerRequest); i {
+			switch v := v.(*ImplementedServices); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -926,7 +987,7 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_node_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Peers); i {
+			switch v := v.(*PeerRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -938,7 +999,7 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_node_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Peer); i {
+			switch v := v.(*Peers); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -950,7 +1011,7 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_node_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*HostData); i {
+			switch v := v.(*Peer); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -962,6 +1023,18 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_node_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*HostData); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_prysm_v1alpha1_node_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ETH1ConnectionStatus); i {
 			case 0:
 				return &v.state
@@ -980,7 +1053,7 @@ func file_proto_prysm_v1alpha1_node_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_prysm_v1alpha1_node_proto_rawDesc,
 			NumEnums:      2,
-			NumMessages:   9,
+			NumMessages:   10,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
@@ -1010,6 +1083,7 @@ type NodeClient interface {
 	GetSyncStatus(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SyncStatus, error)
 	GetGenesis(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Genesis, error)
 	GetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Version, error)
+	GetHealth(ctx context.Context, in *HealthRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
 	ListImplementedServices(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ImplementedServices, error)
 	GetHost(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HostData, error)
 	GetPeer(ctx context.Context, in *PeerRequest, opts ...grpc.CallOption) (*Peer, error)
@@ -1052,6 +1126,15 @@ func (c *nodeClient) GetVersion(ctx context.Context, in *emptypb.Empty, opts ...
 	return out, nil
 }
 
+func (c *nodeClient) GetHealth(ctx context.Context, in *HealthRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.Node/GetHealth", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *nodeClient) ListImplementedServices(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ImplementedServices, error) {
 	out := new(ImplementedServices)
 	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.Node/ListImplementedServices", in, out, opts...)
@@ -1102,6 +1185,7 @@ type NodeServer interface {
 	GetSyncStatus(context.Context, *emptypb.Empty) (*SyncStatus, error)
 	GetGenesis(context.Context, *emptypb.Empty) (*Genesis, error)
 	GetVersion(context.Context, *emptypb.Empty) (*Version, error)
+	GetHealth(context.Context, *HealthRequest) (*emptypb.Empty, error)
 	ListImplementedServices(context.Context, *emptypb.Empty) (*ImplementedServices, error)
 	GetHost(context.Context, *emptypb.Empty) (*HostData, error)
 	GetPeer(context.Context, *PeerRequest) (*Peer, error)
@@ -1122,6 +1206,9 @@ func (*UnimplementedNodeServer) GetGenesis(context.Context, *emptypb.Empty) (*Ge
 func (*UnimplementedNodeServer) GetVersion(context.Context, *emptypb.Empty) (*Version, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetVersion not implemented")
 }
+func (*UnimplementedNodeServer) GetHealth(context.Context, *HealthRequest) (*emptypb.Empty, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetHealth not implemented")
+}
 func (*UnimplementedNodeServer) ListImplementedServices(context.Context, *emptypb.Empty) (*ImplementedServices, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ListImplementedServices not implemented")
 }
@@ -1196,6 +1283,24 @@ func _Node_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(int
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Node_GetHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HealthRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).GetHealth(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/ethereum.eth.v1alpha1.Node/GetHealth",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).GetHealth(ctx, req.(*HealthRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Node_ListImplementedServices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(emptypb.Empty)
 	if err := dec(in); err != nil {
@@ -1302,6 +1407,10 @@ var _Node_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetVersion",
 			Handler:    _Node_GetVersion_Handler,
 		},
+		{
+			MethodName: "GetHealth",
+			Handler:    _Node_GetHealth_Handler,
+		},
 		{
 			MethodName: "ListImplementedServices",
 			Handler:    _Node_ListImplementedServices_Handler,

proto/prysm/v1alpha1/node.pb.gw.go

@@ -89,6 +89,42 @@ func local_request_Node_GetVersion_0(ctx context.Context, marshaler runtime.Mars
 
 }
 
+var (
+	filter_Node_GetHealth_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Node_GetHealth_0(ctx context.Context, marshaler runtime.Marshaler, client NodeClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq HealthRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Node_GetHealth_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.GetHealth(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Node_GetHealth_0(ctx context.Context, marshaler runtime.Marshaler, server NodeServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq HealthRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Node_GetHealth_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.GetHealth(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 func request_Node_ListImplementedServices_0(ctx context.Context, marshaler runtime.Marshaler, client NodeClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq emptypb.Empty
 	var metadata runtime.ServerMetadata
@@ -272,6 +308,29 @@ func RegisterNodeHandlerServer(ctx context.Context, mux *runtime.ServeMux, serve
 
 	})
 
+	mux.Handle("GET", pattern_Node_GetHealth_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.v1alpha1.Node/GetHealth")
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Node_GetHealth_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Node_GetHealth_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Node_ListImplementedServices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -488,6 +547,26 @@ func RegisterNodeHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien
 
 	})
 
+	mux.Handle("GET", pattern_Node_GetHealth_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.v1alpha1.Node/GetHealth")
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Node_GetHealth_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Node_GetHealth_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Node_ListImplementedServices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -598,6 +677,8 @@ var (
 
 	pattern_Node_GetVersion_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"eth", "v1alpha1", "node", "version"}, ""))
 
+	pattern_Node_GetHealth_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"eth", "v1alpha1", "node", "health"}, ""))
+
 	pattern_Node_ListImplementedServices_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"eth", "v1alpha1", "node", "services"}, ""))
 
 	pattern_Node_GetHost_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"eth", "v1alpha1", "node", "p2p"}, ""))
@@ -616,6 +697,8 @@ var (
 
 	forward_Node_GetVersion_0 = runtime.ForwardResponseMessage
 
+	forward_Node_GetHealth_0 = runtime.ForwardResponseMessage
+
 	forward_Node_ListImplementedServices_0 = runtime.ForwardResponseMessage
 
 	forward_Node_GetHost_0 = runtime.ForwardResponseMessage

proto/prysm/v1alpha1/node.proto

@@ -54,6 +54,13 @@ service Node {
         };
     }
 
+    // Retrieve the current health of the node.
+    rpc GetHealth(HealthRequest) returns (google.protobuf.Empty) {
+        option (google.api.http) = {
+            get: "/eth/v1alpha1/node/health"
+        };
+    }
+
     // Retrieve the list of services implemented and enabled by this node.
     //
     // Any service not present in this list may return UNIMPLEMENTED or
@@ -94,6 +101,10 @@ service Node {
     }
 }
 
+message HealthRequest {
+    uint64 syncing_status = 1;
+}
+
 // Information about the current network sync status of the node.
 message SyncStatus {
     // Whether or not the node is currently syncing.

proto/testing/test.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.31.0
-// 	protoc        v4.23.3
+// 	protoc        v4.25.1
 // source: proto/testing/test.proto
 
 package testing

testing/spectypes/BUILD.bazel

@@ -1 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")

testing/validator-mock/BUILD.bazel

@@ -13,6 +13,8 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/testing/validator-mock",
     visibility = ["//visibility:public"],
     deps = [
+        "//api/client/beacon:go_default_library",
+        "//api/client/event:go_default_library",
         "//consensus-types/validator:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//validator/client/iface:go_default_library",

testing/validator-mock/node_client_mock.go

@@ -13,6 +13,7 @@ import (
 	context "context"
 	reflect "reflect"
 
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	gomock "go.uber.org/mock/gomock"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
@@ -22,6 +23,7 @@ import (
 type MockNodeClient struct {
 	ctrl     *gomock.Controller
 	recorder *MockNodeClientMockRecorder
+	healthTracker *beacon.NodeHealthTracker
 }
 
 // MockNodeClientMockRecorder is the mock recorder for MockNodeClient.
@@ -33,6 +35,7 @@ type MockNodeClientMockRecorder struct {
 func NewMockNodeClient(ctrl *gomock.Controller) *MockNodeClient {
 	mock := &MockNodeClient{ctrl: ctrl}
 	mock.recorder = &MockNodeClientMockRecorder{mock}
+	mock.healthTracker = beacon.NewNodeHealthTracker(mock)
 	return mock
 }
 
@@ -114,3 +117,7 @@ func (mr *MockNodeClientMockRecorder) ListPeers(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPeers", reflect.TypeOf((*MockNodeClient)(nil).ListPeers), arg0, arg1)
 }
+
+func (m *MockNodeClient) HealthTracker() *beacon.NodeHealthTracker {
+	return m.healthTracker
+}

testing/validator-mock/validator_client_mock.go

@@ -13,6 +13,8 @@ import (
 	context "context"
 	reflect "reflect"
 
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
+	"github.com/prysmaticlabs/prysm/v5/api/client/event"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	iface "github.com/prysmaticlabs/prysm/v5/validator/client/iface"
 	gomock "go.uber.org/mock/gomock"
@@ -297,32 +299,57 @@ func (mr *MockValidatorClientMockRecorder) ProposeExit(arg0, arg1 any) *gomock.C
 }
 
 // StartEventStream mocks base method.
-func (m *MockValidatorClient) StartEventStream(arg0 context.Context) error {
+func (m *MockValidatorClient) StartEventStream(arg0 context.Context, arg1 []string, arg2 chan<- *event.Event){
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartEventStream", arg0)
+	_ = m.ctrl.Call(m, "StartEventStream", arg0,arg1,arg2)
+}
+
+// StartEventStream indicates an expected call of StartEventStream.
+func (mr *MockValidatorClientMockRecorder) StartEventStream(arg0,arg1,arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartEventStream", reflect.TypeOf((*MockValidatorClient)(nil).StartEventStream), arg0, arg1, arg2)
+}
+
+// ProcessEvent mocks base method.
+func (m *MockValidatorClient) ProcessEvent(arg0 *event.Event) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ProcessEvent", arg0)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// StartEventStream indicates an expected call of StartEventStream.
-func (mr *MockValidatorClientMockRecorder) StartEventStream(arg0 any) *gomock.Call {
+// ProcessEvent indicates an expected call of ProcessEvent.
+func (mr *MockValidatorClientMockRecorder) ProcessEvent(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartEventStream", reflect.TypeOf((*MockValidatorClient)(nil).StartEventStream), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessEvent", reflect.TypeOf((*MockValidatorClient)(nil).ProcessEvent), arg0)
 }
 
-// StreamSlots mocks base method.
-func (m *MockValidatorClient) StreamSlots(arg0 context.Context, arg1 *eth.StreamSlotsRequest) (eth.BeaconNodeValidator_StreamSlotsClient, error) {
+// NodeIsHealthy mocks base method.
+func (m *MockValidatorClient) NodeIsHealthy(arg0 context.Context) bool {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StreamSlots", arg0, arg1)
-	ret0, _ := ret[0].(eth.BeaconNodeValidator_StreamSlotsClient)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
+	ret := m.ctrl.Call(m, "NodeIsHealthy",arg0)
+	ret0, _ := ret[0].(bool)
+	return ret0
 }
 
-// StreamSlots indicates an expected call of StreamSlots.
-func (mr *MockValidatorClientMockRecorder) StreamSlots(arg0, arg1 any) *gomock.Call {
+// NodeIsHealthy indicates an expected call of NodeIsHealthy.
+func (mr *MockValidatorClientMockRecorder) NodeIsHealthy(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamSlots", reflect.TypeOf((*MockValidatorClient)(nil).StreamSlots), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeIsHealthy", reflect.TypeOf((*MockValidatorClient)(nil).NodeIsHealthy), arg0)
+}
+
+// NodeHealthTracker mocks base method.
+func (m *MockValidatorClient) NodeHealthTracker() *beacon.NodeHealthTracker {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NodeHealthTracker")
+	ret0, _ := ret[0].(*beacon.NodeHealthTracker)
+	return ret0
+}
+
+// NodeHealthTracker indicates an expected call of NodeHealthTracker.
+func (mr *MockValidatorClientMockRecorder) NodeHealthTracker() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeHealthTracker", reflect.TypeOf((*MockValidatorClient)(nil).NodeHealthTracker))
 }
 
 // SubmitAggregateSelectionProof mocks base method.

tools/pcli/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/tools/pcli",
     visibility = ["//visibility:private"],
     deps = [
+        "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",

tools/pcli/main.go

@@ -13,6 +13,7 @@ import (
 	"github.com/kr/pretty"
 	"github.com/pkg/errors"
 	fssz "github.com/prysmaticlabs/fastssz"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
@@ -28,14 +29,283 @@ import (
 	"gopkg.in/d4l3k/messagediff.v1"
 )
 
-func main() {
-	var blockPath string
-	var preStatePath string
-	var expectedPostStatePath string
-	var network string
-	var sszPath string
-	var sszType string
+var blockPath string
+var preStatePath string
+var expectedPostStatePath string
+var network string
+var sszPath string
+var sszType string
+var prettyCommand = &cli.Command{
+	Name:    "pretty",
+	Aliases: []string{"p"},
+	Usage:   "pretty-print SSZ data",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:        "ssz-path",
+			Usage:       "Path to file(ssz)",
+			Required:    true,
+			Destination: &sszPath,
+		},
+		&cli.StringFlag{
+			Name: "data-type",
+			Usage: "ssz file data type: " +
+				"block|" +
+				"blinded_block|" +
+				"signed_block|" +
+				"attestation|" +
+				"block_header|" +
+				"deposit|" +
+				"proposer_slashing|" +
+				"signed_block_header|" +
+				"signed_voluntary_exit|" +
+				"voluntary_exit|" +
+				"state_capella",
+			Required:    true,
+			Destination: &sszType,
+		},
+	},
+	Action: func(c *cli.Context) error {
+		var data fssz.Unmarshaler
+		switch sszType {
+		case "block":
+			data = &ethpb.BeaconBlock{}
+		case "signed_block":
+			data = &ethpb.SignedBeaconBlock{}
+		case "blinded_block":
+			data = &ethpb.BlindedBeaconBlockBellatrix{}
+		case "attestation":
+			data = &ethpb.Attestation{}
+		case "block_header":
+			data = &ethpb.BeaconBlockHeader{}
+		case "deposit":
+			data = &ethpb.Deposit{}
+		case "deposit_message":
+			data = &ethpb.DepositMessage{}
+		case "proposer_slashing":
+			data = &ethpb.ProposerSlashing{}
+		case "signed_block_header":
+			data = &ethpb.SignedBeaconBlockHeader{}
+		case "signed_voluntary_exit":
+			data = &ethpb.SignedVoluntaryExit{}
+		case "voluntary_exit":
+			data = &ethpb.VoluntaryExit{}
+		case "state_capella":
+			data = &ethpb.BeaconStateCapella{}
+		default:
+			log.Fatal("Invalid type")
+		}
+		prettyPrint(sszPath, data)
+		return nil
+	},
+}
 
+var benchmarkHashCommand = &cli.Command{
+	Name:    "benchmark-hash",
+	Aliases: []string{"b"},
+	Usage:   "benchmark-hash SSZ data",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:        "ssz-path",
+			Usage:       "Path to file(ssz)",
+			Required:    true,
+			Destination: &sszPath,
+		},
+		&cli.StringFlag{
+			Name: "data-type",
+			Usage: "ssz file data type: " +
+				"block_capella|" +
+				"blinded_block_capella|" +
+				"signed_block_capella|" +
+				"attestation|" +
+				"block_header|" +
+				"deposit|" +
+				"proposer_slashing|" +
+				"signed_block_header|" +
+				"signed_voluntary_exit|" +
+				"voluntary_exit|" +
+				"state_capella",
+			Required:    true,
+			Destination: &sszType,
+		},
+	},
+	Action: func(c *cli.Context) error {
+		benchmarkHash(sszPath, sszType)
+		return nil
+	},
+}
+
+var unrealizedCheckpointsCommand = &cli.Command{
+	Name:     "unrealized-checkpoints",
+	Category: "state-computations",
+	Usage:    "Subcommand to compute manually the unrealized checkpoints",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:        "state-path",
+			Usage:       "Path to state file(ssz)",
+			Destination: &preStatePath,
+		},
+	},
+	Action: func(c *cli.Context) error {
+		if preStatePath == "" {
+			log.Info("State path not provided, please provide path")
+			reader := bufio.NewReader(os.Stdin)
+			text, err := reader.ReadString('\n')
+			if err != nil {
+				log.Fatal(err)
+			}
+			if text = strings.ReplaceAll(text, "\n", ""); text == "" {
+				log.Fatal("Empty state path given")
+			}
+			preStatePath = text
+		}
+		stateObj, err := detectState(preStatePath)
+		if err != nil {
+			log.Fatal(err)
+		}
+		preStateRoot, err := stateObj.HashTreeRoot(context.Background())
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Infof(
+			"Computing unrealized justification for state at slot %d and root %#x",
+			stateObj.Slot(),
+			preStateRoot,
+		)
+		uj, uf, err := precompute.UnrealizedCheckpoints(stateObj)
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Infof("Computed:\nUnrealized Justified: (Root: %#x, Epoch: %d)\nUnrealized Finalized: (Root: %#x, Epoch: %d).", uj.Root, uj.Epoch, uf.Root, uf.Epoch)
+		return nil
+	},
+}
+
+var stateTransitionCommand = &cli.Command{
+	Name:     "state-transition",
+	Category: "state-computations",
+	Usage:    "Subcommand to run manual state transitions",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:        "block-path",
+			Usage:       "Path to block file(ssz)",
+			Destination: &blockPath,
+		},
+		&cli.StringFlag{
+			Name:        "pre-state-path",
+			Usage:       "Path to pre state file(ssz)",
+			Destination: &preStatePath,
+		},
+		&cli.StringFlag{
+			Name:        "expected-post-state-path",
+			Usage:       "Path to expected post state file(ssz)",
+			Destination: &expectedPostStatePath,
+		},
+		&cli.StringFlag{
+			Name:        "network",
+			Usage:       "Network to run the state transition in",
+			Destination: &network,
+		},
+	},
+	Action: func(c *cli.Context) error {
+		if network != "" {
+			switch network {
+			case params.PraterName:
+				if err := params.SetActive(params.PraterConfig()); err != nil {
+					log.Fatal(err)
+				}
+			case params.GoerliName:
+				if err := params.SetActive(params.PraterConfig()); err != nil {
+					log.Fatal(err)
+				}
+			case params.SepoliaName:
+				if err := params.SetActive(params.SepoliaConfig()); err != nil {
+					log.Fatal(err)
+				}
+			case params.HoleskyName:
+				if err := params.SetActive(params.HoleskyConfig()); err != nil {
+					log.Fatal(err)
+				}
+			default:
+				log.Fatalf("Unknown network provided: %s", network)
+			}
+		}
+
+		if blockPath == "" {
+			log.Info("Block path not provided for state transition. " +
+				"Please provide path")
+			reader := bufio.NewReader(os.Stdin)
+			text, err := reader.ReadString('\n')
+			if err != nil {
+				log.Fatal(err)
+			}
+			if text = strings.ReplaceAll(text, "\n", ""); text == "" {
+				log.Fatal("Empty block path given")
+			}
+			blockPath = text
+		}
+		block, err := detectBlock(blockPath)
+		if err != nil {
+			log.Fatal(err)
+		}
+		blkRoot, err := block.Block().HashTreeRoot()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if preStatePath == "" {
+			log.Info("Pre State path not provided for state transition. " +
+				"Please provide path")
+			reader := bufio.NewReader(os.Stdin)
+			text, err := reader.ReadString('\n')
+			if err != nil {
+				log.Fatal(err)
+			}
+			if text = strings.ReplaceAll(text, "\n", ""); text == "" {
+				log.Fatal("Empty state path given")
+			}
+			preStatePath = text
+		}
+		stateObj, err := detectState(preStatePath)
+		if err != nil {
+			log.Fatal(err)
+		}
+		preStateRoot, err := stateObj.HashTreeRoot(context.Background())
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.WithFields(log.Fields{
+			"blockSlot":    fmt.Sprintf("%d", block.Block().Slot()),
+			"preStateSlot": fmt.Sprintf("%d", stateObj.Slot()),
+		}).Infof(
+			"Performing state transition with a block root of %#x and pre state root of %#x",
+			blkRoot,
+			preStateRoot,
+		)
+		postState, err := debugStateTransition(context.Background(), stateObj, block)
+		if err != nil {
+			log.Fatal(err)
+		}
+		postRoot, err := postState.HashTreeRoot(context.Background())
+		if err != nil {
+			log.Fatal(err)
+		}
+		log.Infof("Finished state transition with post state root of %#x", postRoot)
+
+		// Diff the state if a post state is provided.
+		if expectedPostStatePath != "" {
+			expectedState, err := detectState(expectedPostStatePath)
+			if err != nil {
+				log.Fatal(err)
+			}
+			if !equality.DeepEqual(expectedState.ToProtoUnsafe(), postState.ToProtoUnsafe()) {
+				diff, _ := messagediff.PrettyDiff(expectedState.ToProtoUnsafe(), postState.ToProtoUnsafe())
+				log.Errorf("Derived state differs from provided post state: %s", diff)
+			}
+		}
+		return nil
+	},
+}
+
+func main() {
 	customFormatter := new(prefixed.TextFormatter)
 	customFormatter.TimestampFormat = "2006-01-02 15:04:05"
 	customFormatter.FullTimestamp = true
@@ -45,227 +315,10 @@ func main() {
 	app.Usage = "A command line utility to run Ethereum consensus specific commands"
 	app.Version = version.Version()
 	app.Commands = []*cli.Command{
-		{
-			Name:    "pretty",
-			Aliases: []string{"p"},
-			Usage:   "pretty-print SSZ data",
-			Flags: []cli.Flag{
-				&cli.StringFlag{
-					Name:        "ssz-path",
-					Usage:       "Path to file(ssz)",
-					Required:    true,
-					Destination: &sszPath,
-				},
-				&cli.StringFlag{
-					Name: "data-type",
-					Usage: "ssz file data type: " +
-						"block|" +
-						"blinded_block|" +
-						"signed_block|" +
-						"attestation|" +
-						"block_header|" +
-						"deposit|" +
-						"proposer_slashing|" +
-						"signed_block_header|" +
-						"signed_voluntary_exit|" +
-						"voluntary_exit|" +
-						"state_capella",
-					Required:    true,
-					Destination: &sszType,
-				},
-			},
-			Action: func(c *cli.Context) error {
-				var data fssz.Unmarshaler
-				switch sszType {
-				case "block":
-					data = &ethpb.BeaconBlock{}
-				case "signed_block":
-					data = &ethpb.SignedBeaconBlock{}
-				case "blinded_block":
-					data = &ethpb.BlindedBeaconBlockBellatrix{}
-				case "attestation":
-					data = &ethpb.Attestation{}
-				case "block_header":
-					data = &ethpb.BeaconBlockHeader{}
-				case "deposit":
-					data = &ethpb.Deposit{}
-				case "deposit_message":
-					data = &ethpb.DepositMessage{}
-				case "proposer_slashing":
-					data = &ethpb.ProposerSlashing{}
-				case "signed_block_header":
-					data = &ethpb.SignedBeaconBlockHeader{}
-				case "signed_voluntary_exit":
-					data = &ethpb.SignedVoluntaryExit{}
-				case "voluntary_exit":
-					data = &ethpb.VoluntaryExit{}
-				case "state_capella":
-					data = &ethpb.BeaconStateCapella{}
-				default:
-					log.Fatal("Invalid type")
-				}
-				prettyPrint(sszPath, data)
-				return nil
-			},
-		},
-		{
-			Name:    "benchmark-hash",
-			Aliases: []string{"b"},
-			Usage:   "benchmark-hash SSZ data",
-			Flags: []cli.Flag{
-				&cli.StringFlag{
-					Name:        "ssz-path",
-					Usage:       "Path to file(ssz)",
-					Required:    true,
-					Destination: &sszPath,
-				},
-				&cli.StringFlag{
-					Name: "data-type",
-					Usage: "ssz file data type: " +
-						"block_capella|" +
-						"blinded_block_capella|" +
-						"signed_block_capella|" +
-						"attestation|" +
-						"block_header|" +
-						"deposit|" +
-						"proposer_slashing|" +
-						"signed_block_header|" +
-						"signed_voluntary_exit|" +
-						"voluntary_exit|" +
-						"state_capella",
-					Required:    true,
-					Destination: &sszType,
-				},
-			},
-			Action: func(c *cli.Context) error {
-				benchmarkHash(sszPath, sszType)
-				return nil
-			},
-		},
-		{
-			Name:     "state-transition",
-			Category: "state-transition",
-			Usage:    "Subcommand to run manual state transitions",
-			Flags: []cli.Flag{
-				&cli.StringFlag{
-					Name:        "block-path",
-					Usage:       "Path to block file(ssz)",
-					Destination: &blockPath,
-				},
-				&cli.StringFlag{
-					Name:        "pre-state-path",
-					Usage:       "Path to pre state file(ssz)",
-					Destination: &preStatePath,
-				},
-				&cli.StringFlag{
-					Name:        "expected-post-state-path",
-					Usage:       "Path to expected post state file(ssz)",
-					Destination: &expectedPostStatePath,
-				},
-				&cli.StringFlag{
-					Name:        "network",
-					Usage:       "Network to run the state transition in",
-					Destination: &network,
-				},
-			},
-			Action: func(c *cli.Context) error {
-				if network != "" {
-					switch network {
-					case params.PraterName:
-						if err := params.SetActive(params.PraterConfig()); err != nil {
-							log.Fatal(err)
-						}
-					case params.GoerliName:
-						if err := params.SetActive(params.PraterConfig()); err != nil {
-							log.Fatal(err)
-						}
-					case params.SepoliaName:
-						if err := params.SetActive(params.SepoliaConfig()); err != nil {
-							log.Fatal(err)
-						}
-					case params.HoleskyName:
-						if err := params.SetActive(params.HoleskyConfig()); err != nil {
-							log.Fatal(err)
-						}
-					default:
-						log.Fatalf("Unknown network provided: %s", network)
-					}
-				}
-
-				if blockPath == "" {
-					log.Info("Block path not provided for state transition. " +
-						"Please provide path")
-					reader := bufio.NewReader(os.Stdin)
-					text, err := reader.ReadString('\n')
-					if err != nil {
-						log.Fatal(err)
-					}
-					if text = strings.ReplaceAll(text, "\n", ""); text == "" {
-						log.Fatal("Empty block path given")
-					}
-					blockPath = text
-				}
-				block, err := detectBlock(blockPath)
-				if err != nil {
-					log.Fatal(err)
-				}
-				blkRoot, err := block.Block().HashTreeRoot()
-				if err != nil {
-					log.Fatal(err)
-				}
-				if preStatePath == "" {
-					log.Info("Pre State path not provided for state transition. " +
-						"Please provide path")
-					reader := bufio.NewReader(os.Stdin)
-					text, err := reader.ReadString('\n')
-					if err != nil {
-						log.Fatal(err)
-					}
-					if text = strings.ReplaceAll(text, "\n", ""); text == "" {
-						log.Fatal("Empty state path given")
-					}
-					preStatePath = text
-				}
-				stateObj, err := detectState(preStatePath)
-				if err != nil {
-					log.Fatal(err)
-				}
-				preStateRoot, err := stateObj.HashTreeRoot(context.Background())
-				if err != nil {
-					log.Fatal(err)
-				}
-				log.WithFields(log.Fields{
-					"blockSlot":    fmt.Sprintf("%d", block.Block().Slot()),
-					"preStateSlot": fmt.Sprintf("%d", stateObj.Slot()),
-				}).Infof(
-					"Performing state transition with a block root of %#x and pre state root of %#x",
-					blkRoot,
-					preStateRoot,
-				)
-				postState, err := debugStateTransition(context.Background(), stateObj, block)
-				if err != nil {
-					log.Fatal(err)
-				}
-				postRoot, err := postState.HashTreeRoot(context.Background())
-				if err != nil {
-					log.Fatal(err)
-				}
-				log.Infof("Finished state transition with post state root of %#x", postRoot)
-
-				// Diff the state if a post state is provided.
-				if expectedPostStatePath != "" {
-					expectedState, err := detectState(expectedPostStatePath)
-					if err != nil {
-						log.Fatal(err)
-					}
-					if !equality.DeepEqual(expectedState.ToProtoUnsafe(), postState.ToProtoUnsafe()) {
-						diff, _ := messagediff.PrettyDiff(expectedState.ToProtoUnsafe(), postState.ToProtoUnsafe())
-						log.Errorf("Derived state differs from provided post state: %s", diff)
-					}
-				}
-				return nil
-			},
-		},
+		prettyCommand,
+		benchmarkHashCommand,
+		unrealizedCheckpointsCommand,
+		stateTransitionCommand,
 	}
 	if err := app.Run(os.Args); err != nil {
 		log.Error(err.Error())

validator/accounts/cli_manager.go

@@ -87,10 +87,7 @@ func (acm *CLIManager) prepareBeaconClients(ctx context.Context) (*iface.Validat
 		acm.beaconApiTimeout,
 	)
 
-	restHandler := &beaconApi.BeaconApiJsonRestHandler{
-		HttpClient: http.Client{Timeout: acm.beaconApiTimeout},
-		Host:       acm.beaconApiEndpoint,
-	}
+	restHandler := beaconApi.NewBeaconApiJsonRestHandler(http.Client{Timeout: acm.beaconApiTimeout}, acm.beaconApiEndpoint)
 	validatorClient := validatorClientFactory.NewValidatorClient(conn, restHandler)
 	nodeClient := nodeClientFactory.NewNodeClient(conn, restHandler)
 

validator/accounts/testing/BUILD.bazel

@@ -10,6 +10,8 @@ go_library(
         "//validator:__subpackages__",
     ],
     deps = [
+        "//api/client/beacon:go_default_library",
+        "//api/client/event:go_default_library",
         "//config/proposer:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

validator/accounts/testing/mock.go

@@ -7,6 +7,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
+	"github.com/prysmaticlabs/prysm/v5/api/client/event"
 	"github.com/prysmaticlabs/prysm/v5/config/proposer"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -213,14 +215,18 @@ func (m *Validator) SetProposerSettings(_ context.Context, settings *proposer.Se
 	return nil
 }
 
-func (_ *Validator) StartEventStream(_ context.Context) error {
+func (*Validator) StartEventStream(_ context.Context, _ []string, _ chan<- *event.Event) {
 	panic("implement me")
 }
 
-func (_ *Validator) EventStreamIsRunning() bool {
+func (*Validator) ProcessEvent(event *event.Event) {
 	panic("implement me")
 }
 
-func (_ *Validator) NodeIsHealthy(ctx context.Context) bool {
+func (*Validator) EventStreamIsRunning() bool {
+	panic("implement me")
+}
+
+func (*Validator) HealthTracker() *beacon.NodeHealthTracker {
 	panic("implement me")
 }

validator/client/BUILD.bazel

@@ -23,7 +23,11 @@ go_library(
         "//validator:__subpackages__",
     ],
     deps = [
+        "//api/client:go_default_library",
+        "//api/client/beacon:go_default_library",
+        "//api/client/event:go_default_library",
         "//api/grpc:go_default_library",
+        "//api/server/structs:go_default_library",
         "//async:go_default_library",
         "//async/event:go_default_library",
         "//beacon-chain/builder:go_default_library",
@@ -115,6 +119,8 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//api/client/beacon:go_default_library",
+        "//api/client/beacon/testing:go_default_library",
         "//async/event:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//cache/lru:go_default_library",

validator/client/beacon-api/BUILD.bazel

@@ -16,7 +16,6 @@ go_library(
         "domain_data.go",
         "doppelganger.go",
         "duties.go",
-        "event_handler.go",
         "genesis.go",
         "get_beacon_block.go",
         "index.go",
@@ -43,10 +42,11 @@ go_library(
     visibility = ["//validator:__subpackages__"],
     deps = [
         "//api:go_default_library",
+        "//api/client/beacon:go_default_library",
+        "//api/client/event:go_default_library",
         "//api/server/structs:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/rpc/eth/events:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
@@ -86,7 +86,6 @@ go_test(
         "domain_data_test.go",
         "doppelganger_test.go",
         "duties_test.go",
-        "event_handler_test.go",
         "genesis_test.go",
         "get_beacon_block_test.go",
         "index_test.go",
@@ -138,7 +137,6 @@ go_test(
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_golang_protobuf//ptypes/empty",
         "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",
         "@org_uber_go_mock//gomock:go_default_library",

validator/client/beacon-api/beacon_api_node_client.go

@@ -7,16 +7,22 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/validator/client/iface"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
+var (
+	_ = iface.NodeClient(&beaconApiNodeClient{})
+)
+
 type beaconApiNodeClient struct {
 	fallbackClient  iface.NodeClient
 	jsonRestHandler JsonRestHandler
 	genesisProvider GenesisProvider
+	healthTracker   *beacon.NodeHealthTracker
 }
 
 func (c *beaconApiNodeClient) GetSyncStatus(ctx context.Context, _ *empty.Empty) (*ethpb.SyncStatus, error) {
@@ -101,10 +107,16 @@ func (c *beaconApiNodeClient) IsHealthy(ctx context.Context) bool {
 	return c.jsonRestHandler.Get(ctx, "/eth/v1/node/health", nil) == nil
 }
 
+func (c *beaconApiNodeClient) HealthTracker() *beacon.NodeHealthTracker {
+	return c.healthTracker
+}
+
 func NewNodeClientWithFallback(jsonRestHandler JsonRestHandler, fallbackClient iface.NodeClient) iface.NodeClient {
-	return &beaconApiNodeClient{
+	b := &beaconApiNodeClient{
 		jsonRestHandler: jsonRestHandler,
 		fallbackClient:  fallbackClient,
 		genesisProvider: beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler},
 	}
+	b.healthTracker = beacon.NewNodeHealthTracker(b)
+	return b
 }

validator/client/beacon-api/beacon_api_validator_client.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api/client/event"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/validator/client/iface"
@@ -14,20 +15,14 @@ import (
 
 type ValidatorClientOpt func(*beaconApiValidatorClient)
 
-func WithEventHandler(h *EventHandler) ValidatorClientOpt {
-	return func(c *beaconApiValidatorClient) {
-		c.eventHandler = h
-	}
-}
-
 type beaconApiValidatorClient struct {
 	genesisProvider         GenesisProvider
 	dutiesProvider          dutiesProvider
 	stateValidatorsProvider StateValidatorsProvider
 	jsonRestHandler         JsonRestHandler
-	eventHandler            *EventHandler
 	beaconBlockConverter    BeaconBlockConverter
 	prysmBeaconChainCLient  iface.PrysmBeaconChainClient
+	isEventStreamRunning    bool
 }
 
 func NewBeaconApiValidatorClient(jsonRestHandler JsonRestHandler, opts ...ValidatorClientOpt) iface.ValidatorClient {
@@ -41,6 +36,7 @@ func NewBeaconApiValidatorClient(jsonRestHandler JsonRestHandler, opts ...Valida
 			nodeClient:      &beaconApiNodeClient{jsonRestHandler: jsonRestHandler},
 			jsonRestHandler: jsonRestHandler,
 		},
+		isEventStreamRunning: false,
 	}
 	for _, o := range opts {
 		o(c)
@@ -135,10 +131,6 @@ func (c *beaconApiValidatorClient) ProposeExit(ctx context.Context, in *ethpb.Si
 	})
 }
 
-func (c *beaconApiValidatorClient) StreamSlots(ctx context.Context, in *ethpb.StreamSlotsRequest) (ethpb.BeaconNodeValidator_StreamSlotsClient, error) {
-	return c.streamSlots(ctx, in, time.Second), nil
-}
-
 func (c *beaconApiValidatorClient) StreamBlocksAltair(ctx context.Context, in *ethpb.StreamBlocksRequest) (ethpb.BeaconNodeValidator_StreamBlocksAltairClient, error) {
 	return c.streamBlocks(ctx, in, time.Second), nil
 }
@@ -198,17 +190,22 @@ func (c *beaconApiValidatorClient) WaitForChainStart(ctx context.Context, _ *emp
 	return c.waitForChainStart(ctx)
 }
 
-func (c *beaconApiValidatorClient) StartEventStream(ctx context.Context) error {
-	if c.eventHandler != nil {
-		if err := c.eventHandler.get(ctx, []string{"head"}); err != nil {
-			return errors.Wrapf(err, "could not invoke event handler")
+func (c *beaconApiValidatorClient) StartEventStream(ctx context.Context, topics []string, eventsChannel chan<- *event.Event) {
+	eventStream, err := event.NewEventStream(ctx, c.jsonRestHandler.HttpClient(), c.jsonRestHandler.Host(), topics)
+	if err != nil {
+		eventsChannel <- &event.Event{
+			EventType: event.EventError,
+			Data:      []byte(errors.Wrap(err, "failed to start event stream").Error()),
 		}
+		return
 	}
-	return nil
+	c.isEventStreamRunning = true
+	eventStream.Subscribe(eventsChannel)
+	c.isEventStreamRunning = false
 }
 
 func (c *beaconApiValidatorClient) EventStreamIsRunning() bool {
-	return c.eventHandler.running
+	return c.isEventStreamRunning
 }
 
 func (c *beaconApiValidatorClient) GetAggregatedSelections(ctx context.Context, selections []iface.BeaconCommitteeSelection) ([]iface.BeaconCommitteeSelection, error) {

validator/client/beacon-api/event_handler.go

@@ -1,134 +0,0 @@
-package beacon_api
-
-import (
-	"context"
-	"net/http"
-	"strings"
-	"sync"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/api"
-)
-
-// Currently set to the first power of 2 bigger than the size of the `head` event
-// which is 446 bytes
-const eventByteLimit = 512
-
-// EventHandler is responsible for subscribing to the Beacon API events endpoint
-// and dispatching received events to subscribers.
-type EventHandler struct {
-	httpClient *http.Client
-	host       string
-	running    bool
-	subs       []eventSub
-	sync.Mutex
-}
-
-type eventSub struct {
-	name string
-	ch   chan<- event
-}
-
-type event struct {
-	eventType string
-	data      string
-}
-
-// NewEventHandler returns a new handler.
-func NewEventHandler(httpClient *http.Client, host string) *EventHandler {
-	return &EventHandler{
-		httpClient: httpClient,
-		host:       host,
-		running:    false,
-		subs:       make([]eventSub, 0),
-	}
-}
-
-func (h *EventHandler) subscribe(sub eventSub) {
-	h.Lock()
-	h.subs = append(h.subs, sub)
-	h.Unlock()
-}
-
-func (h *EventHandler) get(ctx context.Context, topics []string) error {
-	if len(topics) == 0 {
-		return errors.New("no topics provided")
-	}
-	if h.running {
-		log.Warn("Event listener is already running, ignoring function call")
-	}
-
-	go func() {
-		h.running = true
-		defer func() { h.running = false }()
-
-		allTopics := strings.Join(topics, ",")
-		log.Info("Starting listening to Beacon API events on topics: " + allTopics)
-		url := h.host + "/eth/v1/events?topics=" + allTopics
-		req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-		if err != nil {
-			log.WithError(err).Error("Failed to create HTTP request")
-			return
-		}
-		req.Header.Set("Accept", api.EventStreamMediaType)
-		req.Header.Set("Connection", api.KeepAlive)
-		resp, err := h.httpClient.Do(req)
-		if err != nil {
-			log.WithError(err).Error("Failed to perform HTTP request")
-			return
-		}
-
-		defer func() {
-			if closeErr := resp.Body.Close(); closeErr != nil {
-				log.WithError(closeErr).Error("Failed to close events response body")
-			}
-		}()
-
-		// We signal an EOF error in a special way. When we get this error while reading the response body,
-		// there might still be an event received in the body that we should handle.
-		eof := false
-		for {
-			if ctx.Err() != nil {
-				log.WithError(ctx.Err()).Error("Stopping listening to Beacon API events")
-				return
-			}
-
-			rawData := make([]byte, eventByteLimit)
-			_, err = resp.Body.Read(rawData)
-			if err != nil {
-				if strings.Contains(err.Error(), "EOF") {
-					log.Error("Received EOF while reading events response body. Stopping listening to Beacon API events")
-					eof = true
-				} else {
-					log.WithError(err).Error("Stopping listening to Beacon API events")
-					return
-				}
-			}
-
-			e := strings.Split(string(rawData), "\n")
-			// We expect that the event format will contain event type and data separated with a newline
-			if len(e) < 2 {
-				// We reached EOF and there is no event to send
-				if eof {
-					return
-				}
-				continue
-			}
-
-			for _, sub := range h.subs {
-				select {
-				case sub.ch <- event{eventType: e[0], data: e[1]}:
-				// Event sent successfully.
-				default:
-					log.Warn("Subscriber '" + sub.name + "' not ready to receive events")
-				}
-			}
-			// We reached EOF and sent the last event
-			if eof {
-				return
-			}
-		}
-	}()
-
-	return nil
-}

validator/client/beacon-api/event_handler_test.go

@@ -1,55 +0,0 @@
-package beacon_api
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	logtest "github.com/sirupsen/logrus/hooks/test"
-)
-
-func TestEventHandler(t *testing.T) {
-	logHook := logtest.NewGlobal()
-
-	mux := http.NewServeMux()
-	mux.HandleFunc("/eth/v1/events", func(w http.ResponseWriter, r *http.Request) {
-		flusher, ok := w.(http.Flusher)
-		require.Equal(t, true, ok)
-		_, err := fmt.Fprint(w, "head\ndata\n\n")
-		require.NoError(t, err)
-		flusher.Flush()
-	})
-	server := httptest.NewServer(mux)
-	defer server.Close()
-
-	handler := NewEventHandler(http.DefaultClient, server.URL)
-	ch1 := make(chan event, 1)
-	sub1 := eventSub{ch: ch1}
-	ch2 := make(chan event, 1)
-	sub2 := eventSub{ch: ch2}
-	ch3 := make(chan event, 1)
-	sub3 := eventSub{name: "sub3", ch: ch3}
-	// fill up the channel so that it can't receive more events
-	ch3 <- event{}
-	handler.subscribe(sub1)
-	handler.subscribe(sub2)
-	handler.subscribe(sub3)
-
-	require.NoError(t, handler.get(context.Background(), []string{"head"}))
-	// make sure the goroutine inside handler.get is invoked
-	time.Sleep(500 * time.Millisecond)
-
-	e := <-ch1
-	assert.Equal(t, "head", e.eventType)
-	assert.Equal(t, "data", e.data)
-	e = <-ch2
-	assert.Equal(t, "head", e.eventType)
-	assert.Equal(t, "data", e.data)
-
-	assert.LogsContain(t, logHook, "Subscriber 'sub3' not ready to receive events")
-}

validator/client/beacon-api/json_rest_handler.go

@@ -16,23 +16,43 @@ import (
 type JsonRestHandler interface {
 	Get(ctx context.Context, endpoint string, resp interface{}) error
 	Post(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer, resp interface{}) error
+	HttpClient() *http.Client
+	Host() string
 }
 
 type BeaconApiJsonRestHandler struct {
-	HttpClient http.Client
-	Host       string
+	client http.Client
+	host   string
+}
+
+// NewBeaconApiJsonRestHandler returns a JsonRestHandler
+func NewBeaconApiJsonRestHandler(client http.Client, host string) JsonRestHandler {
+	return &BeaconApiJsonRestHandler{
+		client: client,
+		host:   host,
+	}
+}
+
+// GetHttpClient returns the underlying HTTP client of the handler
+func (c BeaconApiJsonRestHandler) HttpClient() *http.Client {
+	return &c.client
+}
+
+// GetHost returns the underlying HTTP host
+func (c BeaconApiJsonRestHandler) 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 BeaconApiJsonRestHandler) Get(ctx context.Context, endpoint string, resp interface{}) error {
-	url := c.Host + endpoint
+	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return errors.Wrapf(err, "failed to create request for endpoint %s", url)
 	}
 
-	httpResp, err := c.HttpClient.Do(req)
+	httpResp, err := c.client.Do(req)
 	if err != nil {
 		return errors.Wrapf(err, "failed to perform request for endpoint %s", url)
 	}
@@ -58,7 +78,7 @@ func (c BeaconApiJsonRestHandler) Post(
 		return errors.New("data is nil")
 	}
 
-	url := c.Host + apiEndpoint
+	url := c.host + apiEndpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, data)
 	if err != nil {
 		return errors.Wrapf(err, "failed to create request for endpoint %s", url)
@@ -69,7 +89,7 @@ func (c BeaconApiJsonRestHandler) Post(
 	}
 	req.Header.Set("Content-Type", api.JsonMediaType)
 
-	httpResp, err := c.HttpClient.Do(req)
+	httpResp, err := c.client.Do(req)
 	if err != nil {
 		return errors.Wrapf(err, "failed to perform request for endpoint %s", url)
 	}

validator/client/beacon-api/json_rest_handler_test.go

@@ -41,8 +41,8 @@ func TestGet(t *testing.T) {
 	defer server.Close()
 
 	jsonRestHandler := BeaconApiJsonRestHandler{
-		HttpClient: http.Client{Timeout: time.Second * 5},
-		Host:       server.URL,
+		client: http.Client{Timeout: time.Second * 5},
+		host:   server.URL,
 	}
 	resp := &structs.GetGenesisResponse{}
 	require.NoError(t, jsonRestHandler.Get(ctx, endpoint+"?arg1=abc&arg2=def", resp))
@@ -87,8 +87,8 @@ func TestPost(t *testing.T) {
 	defer server.Close()
 
 	jsonRestHandler := BeaconApiJsonRestHandler{
-		HttpClient: http.Client{Timeout: time.Second * 5},
-		Host:       server.URL,
+		client: http.Client{Timeout: time.Second * 5},
+		host:   server.URL,
 	}
 	resp := &structs.GetGenesisResponse{}
 	require.NoError(t, jsonRestHandler.Post(ctx, endpoint, headers, bytes.NewBuffer(dataBytes), resp))

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

@@ -12,6 +12,7 @@ package mock
 import (
 	bytes "bytes"
 	context "context"
+	"net/http"
 	reflect "reflect"
 
 	gomock "go.uber.org/mock/gomock"
@@ -35,6 +36,14 @@ func NewMockJsonRestHandler(ctrl *gomock.Controller) *MockJsonRestHandler {
 	return mock
 }
 
+func (mr *MockJsonRestHandler) HttpClient() *http.Client {
+	return nil
+}
+
+func (mr *MockJsonRestHandler) Host() string {
+	return ""
+}
+
 // EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockJsonRestHandler) EXPECT() *MockJsonRestHandlerMockRecorder {
 	return m.recorder
@@ -67,3 +76,4 @@ func (mr *MockJsonRestHandlerMockRecorder) Post(ctx, endpoint, headers, data, re
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockJsonRestHandler)(nil).Post), ctx, endpoint, headers, data, resp)
 }
+

validator/client/beacon-api/stream_blocks.go

@@ -4,13 +4,11 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"strconv"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/events"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"google.golang.org/grpc"
@@ -23,15 +21,6 @@ type abstractSignedBlockResponseJson struct {
 	Data                json.RawMessage `json:"data"`
 }
 
-type streamSlotsClient struct {
-	grpc.ClientStream
-	ctx                context.Context
-	beaconApiClient    beaconApiValidatorClient
-	streamSlotsRequest *ethpb.StreamSlotsRequest
-	pingDelay          time.Duration
-	ch                 chan event
-}
-
 type streamBlocksAltairClient struct {
 	grpc.ClientStream
 	ctx                 context.Context
@@ -47,18 +36,6 @@ type headSignedBeaconBlockResult struct {
 	slot                 primitives.Slot
 }
 
-func (c beaconApiValidatorClient) streamSlots(ctx context.Context, in *ethpb.StreamSlotsRequest, pingDelay time.Duration) ethpb.BeaconNodeValidator_StreamSlotsClient {
-	ch := make(chan event, 1)
-	c.eventHandler.subscribe(eventSub{name: "stream slots", ch: ch})
-	return &streamSlotsClient{
-		ctx:                ctx,
-		beaconApiClient:    c,
-		streamSlotsRequest: in,
-		pingDelay:          pingDelay,
-		ch:                 ch,
-	}
-}
-
 func (c beaconApiValidatorClient) streamBlocks(ctx context.Context, in *ethpb.StreamBlocksRequest, pingDelay time.Duration) ethpb.BeaconNodeValidator_StreamBlocksAltairClient {
 	return &streamBlocksAltairClient{
 		ctx:                 ctx,
@@ -68,30 +45,6 @@ func (c beaconApiValidatorClient) streamBlocks(ctx context.Context, in *ethpb.St
 	}
 }
 
-func (c *streamSlotsClient) Recv() (*ethpb.StreamSlotsResponse, error) {
-	for {
-		select {
-		case rawEvent := <-c.ch:
-			if rawEvent.eventType != events.HeadTopic {
-				continue
-			}
-			e := &structs.HeadEvent{}
-			if err := json.Unmarshal([]byte(rawEvent.data), e); err != nil {
-				return nil, errors.Wrap(err, "failed to unmarshal head event into JSON")
-			}
-			uintSlot, err := strconv.ParseUint(e.Slot, 10, 64)
-			if err != nil {
-				return nil, errors.Wrap(err, "failed to parse slot")
-			}
-			return &ethpb.StreamSlotsResponse{
-				Slot: primitives.Slot(uintSlot),
-			}, nil
-		case <-c.ctx.Done():
-			return nil, errors.New("context canceled")
-		}
-	}
-}
-
 func (c *streamBlocksAltairClient) Recv() (*ethpb.StreamBlocksResponse, error) {
 	result, err := c.beaconApiClient.getHeadSignedBeaconBlock(c.ctx)
 	if err != nil {

validator/client/grpc-api/BUILD.bazel

@@ -11,6 +11,10 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/validator/client/grpc-api",
     visibility = ["//validator:__subpackages__"],
     deps = [
+        "//api/client:go_default_library",
+        "//api/client/beacon:go_default_library",
+        "//api/client/event:go_default_library",
+        "//api/server/structs:go_default_library",
         "//beacon-chain/rpc/eth/helpers:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//consensus-types/primitives:go_default_library",
@@ -20,6 +24,8 @@ go_library(
         "//validator/client/iface:go_default_library",
         "@com_github_golang_protobuf//ptypes/empty",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
     ],
 )
@@ -33,6 +39,8 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//api/client/event:go_default_library",
+        "//api/server/structs:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
@@ -43,6 +51,7 @@ go_test(
         "//testing/util:go_default_library",
         "//testing/validator-mock:go_default_library",
         "//validator/client/iface:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test: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_node_client.go

@@ -4,13 +4,20 @@ import (
 	"context"
 
 	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/validator/client/iface"
+	log "github.com/sirupsen/logrus"
 	"google.golang.org/grpc"
 )
 
+var (
+	_ = iface.NodeClient(&grpcNodeClient{})
+)
+
 type grpcNodeClient struct {
-	nodeClient ethpb.NodeClient
+	nodeClient    ethpb.NodeClient
+	healthTracker *beacon.NodeHealthTracker
 }
 
 func (c *grpcNodeClient) GetSyncStatus(ctx context.Context, in *empty.Empty) (*ethpb.SyncStatus, error) {
@@ -29,10 +36,21 @@ func (c *grpcNodeClient) ListPeers(ctx context.Context, in *empty.Empty) (*ethpb
 	return c.nodeClient.ListPeers(ctx, in)
 }
 
-func (c *grpcNodeClient) IsHealthy(context.Context) bool {
-	panic("function not supported for gRPC client")
+func (c *grpcNodeClient) IsHealthy(ctx context.Context) bool {
+	_, err := c.nodeClient.GetHealth(ctx, &ethpb.HealthRequest{})
+	if err != nil {
+		log.WithError(err).Debug("failed to get health of node")
+		return false
+	}
+	return true
+}
+
+func (c *grpcNodeClient) HealthTracker() *beacon.NodeHealthTracker {
+	return c.healthTracker
 }
 
 func NewNodeClient(cc grpc.ClientConnInterface) iface.NodeClient {
-	return &grpcNodeClient{ethpb.NewNodeClient(cc)}
+	g := &grpcNodeClient{nodeClient: ethpb.NewNodeClient(cc)}
+	g.healthTracker = beacon.NewNodeHealthTracker(g)
+	return g
 }

validator/client/grpc-api/grpc_validator_client.go

@@ -2,16 +2,24 @@ package grpc_api
 
 import (
 	"context"
+	"encoding/json"
+	"strconv"
 
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api/client"
+	eventClient "github.com/prysmaticlabs/prysm/v5/api/client/event"
+	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/validator/client/iface"
+	log "github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 	"google.golang.org/grpc"
 )
 
 type grpcValidatorClient struct {
 	beaconNodeValidatorClient ethpb.BeaconNodeValidatorClient
+	isEventStreamRunning      bool
 }
 
 func (c *grpcValidatorClient) GetDuties(ctx context.Context, in *ethpb.DutiesRequest) (*ethpb.DutiesResponse, error) {
@@ -70,10 +78,6 @@ func (c *grpcValidatorClient) ProposeExit(ctx context.Context, in *ethpb.SignedV
 	return c.beaconNodeValidatorClient.ProposeExit(ctx, in)
 }
 
-func (c *grpcValidatorClient) StreamSlots(ctx context.Context, in *ethpb.StreamSlotsRequest) (ethpb.BeaconNodeValidator_StreamSlotsClient, error) {
-	return c.beaconNodeValidatorClient.StreamSlots(ctx, in)
-}
-
 func (c *grpcValidatorClient) StreamBlocksAltair(ctx context.Context, in *ethpb.StreamBlocksRequest) (ethpb.BeaconNodeValidator_StreamBlocksAltairClient, error) {
 	return c.beaconNodeValidatorClient.StreamBlocksAltair(ctx, in)
 }
@@ -119,7 +123,7 @@ func (c *grpcValidatorClient) WaitForChainStart(ctx context.Context, in *empty.E
 	stream, err := c.beaconNodeValidatorClient.WaitForChainStart(ctx, in)
 	if err != nil {
 		return nil, errors.Wrap(
-			iface.ErrConnectionIssue,
+			client.ErrConnectionIssue,
 			errors.Wrap(err, "could not setup beacon chain ChainStart streaming client").Error(),
 		)
 	}
@@ -146,13 +150,97 @@ func (grpcValidatorClient) GetAggregatedSyncSelections(context.Context, []iface.
 }
 
 func NewGrpcValidatorClient(cc grpc.ClientConnInterface) iface.ValidatorClient {
-	return &grpcValidatorClient{ethpb.NewBeaconNodeValidatorClient(cc)}
+	return &grpcValidatorClient{ethpb.NewBeaconNodeValidatorClient(cc), false}
 }
 
-func (c *grpcValidatorClient) StartEventStream(context.Context) error {
-	panic("function not supported for gRPC client")
+func (c *grpcValidatorClient) StartEventStream(ctx context.Context, topics []string, eventsChannel chan<- *eventClient.Event) {
+	ctx, span := trace.StartSpan(ctx, "validator.gRPCClient.StartEventStream")
+	defer span.End()
+	if len(topics) == 0 {
+		eventsChannel <- &eventClient.Event{
+			EventType: eventClient.EventError,
+			Data:      []byte(errors.New("no topics were added").Error()),
+		}
+		return
+	}
+	// TODO(13563): ONLY WORKS WITH HEAD TOPIC RIGHT NOW/ONLY PROVIDES THE SLOT
+	containsHead := false
+	for i := range topics {
+		if topics[i] == eventClient.EventHead {
+			containsHead = true
+		}
+	}
+	if !containsHead {
+		eventsChannel <- &eventClient.Event{
+			EventType: eventClient.EventConnectionError,
+			Data:      []byte(errors.Wrap(client.ErrConnectionIssue, "gRPC only supports the head topic, and head topic was not passed").Error()),
+		}
+	}
+	if containsHead && len(topics) > 1 {
+		log.Warn("gRPC only supports the head topic, other topics will be ignored")
+	}
+
+	stream, err := c.beaconNodeValidatorClient.StreamSlots(ctx, &ethpb.StreamSlotsRequest{VerifiedOnly: true})
+	if err != nil {
+		eventsChannel <- &eventClient.Event{
+			EventType: eventClient.EventConnectionError,
+			Data:      []byte(errors.Wrap(client.ErrConnectionIssue, err.Error()).Error()),
+		}
+		return
+	}
+	c.isEventStreamRunning = true
+	for {
+		select {
+		case <-ctx.Done():
+			log.Info("Context canceled, stopping event stream")
+			close(eventsChannel)
+			c.isEventStreamRunning = false
+			return
+		default:
+			if ctx.Err() != nil {
+				c.isEventStreamRunning = false
+				if errors.Is(ctx.Err(), context.Canceled) {
+					eventsChannel <- &eventClient.Event{
+						EventType: eventClient.EventConnectionError,
+						Data:      []byte(errors.Wrap(client.ErrConnectionIssue, ctx.Err().Error()).Error()),
+					}
+					return
+				}
+				eventsChannel <- &eventClient.Event{
+					EventType: eventClient.EventError,
+					Data:      []byte(ctx.Err().Error()),
+				}
+				return
+			}
+			res, err := stream.Recv()
+			if err != nil {
+				c.isEventStreamRunning = false
+				eventsChannel <- &eventClient.Event{
+					EventType: eventClient.EventConnectionError,
+					Data:      []byte(errors.Wrap(client.ErrConnectionIssue, err.Error()).Error()),
+				}
+				return
+			}
+			if res == nil {
+				continue
+			}
+			b, err := json.Marshal(structs.HeadEvent{
+				Slot: strconv.FormatUint(uint64(res.Slot), 10),
+			})
+			if err != nil {
+				eventsChannel <- &eventClient.Event{
+					EventType: eventClient.EventError,
+					Data:      []byte(errors.Wrap(err, "failed to marshal Head Event").Error()),
+				}
+			}
+			eventsChannel <- &eventClient.Event{
+				EventType: eventClient.EventHead,
+				Data:      b,
+			}
+		}
+	}
 }
 
 func (c *grpcValidatorClient) EventStreamIsRunning() bool {
-	panic("function not supported for gRPC client")
+	return c.isEventStreamRunning
 }

validator/client/grpc-api/grpc_validator_client_test.go

@@ -2,11 +2,18 @@ package grpc_api
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"testing"
+	"time"
 
+	eventClient "github.com/prysmaticlabs/prysm/v5/api/client/event"
+	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	mock2 "github.com/prysmaticlabs/prysm/v5/testing/mock"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	logTest "github.com/sirupsen/logrus/hooks/test"
 	"go.uber.org/mock/gomock"
 	"google.golang.org/protobuf/types/known/emptypb"
 )
@@ -21,8 +28,105 @@ func TestWaitForChainStart_StreamSetupFails(t *testing.T) {
 		gomock.Any(),
 	).Return(nil, errors.New("failed stream"))
 
-	validatorClient := &grpcValidatorClient{beaconNodeValidatorClient}
+	validatorClient := &grpcValidatorClient{beaconNodeValidatorClient, true}
 	_, err := validatorClient.WaitForChainStart(context.Background(), &emptypb.Empty{})
 	want := "could not setup beacon chain ChainStart streaming client"
 	assert.ErrorContains(t, want, err)
 }
+
+func TestStartEventStream(t *testing.T) {
+	hook := logTest.NewGlobal()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	beaconNodeValidatorClient := mock2.NewMockBeaconNodeValidatorClient(ctrl)
+	grpcClient := &grpcValidatorClient{beaconNodeValidatorClient, true}
+	tests := []struct {
+		name    string
+		topics  []string
+		prepare func()
+		verify  func(t *testing.T, event *eventClient.Event)
+	}{
+		{
+			name:   "Happy path Head topic",
+			topics: []string{"head"},
+			prepare: func() {
+				stream := mock2.NewMockBeaconNodeValidator_StreamSlotsClient(ctrl)
+				beaconNodeValidatorClient.EXPECT().StreamSlots(gomock.Any(),
+					&eth.StreamSlotsRequest{VerifiedOnly: true}).Return(stream, nil)
+				stream.EXPECT().Context().Return(ctx).AnyTimes()
+				stream.EXPECT().Recv().Return(
+					&eth.StreamSlotsResponse{Slot: 123},
+					nil,
+				).AnyTimes()
+			},
+			verify: func(t *testing.T, event *eventClient.Event) {
+				require.Equal(t, event.EventType, eventClient.EventHead)
+				head := structs.HeadEvent{}
+				require.NoError(t, json.Unmarshal(event.Data, &head))
+				require.Equal(t, head.Slot, "123")
+			},
+		},
+		{
+			name:   "no head produces error",
+			topics: []string{"unsupportedTopic"},
+			prepare: func() {
+				stream := mock2.NewMockBeaconNodeValidator_StreamSlotsClient(ctrl)
+				beaconNodeValidatorClient.EXPECT().StreamSlots(gomock.Any(),
+					&eth.StreamSlotsRequest{VerifiedOnly: true}).Return(stream, nil)
+				stream.EXPECT().Context().Return(ctx).AnyTimes()
+				stream.EXPECT().Recv().Return(
+					&eth.StreamSlotsResponse{Slot: 123},
+					nil,
+				).AnyTimes()
+			},
+			verify: func(t *testing.T, event *eventClient.Event) {
+				require.Equal(t, event.EventType, eventClient.EventConnectionError)
+			},
+		},
+		{
+			name:   "Unsupported topics warning",
+			topics: []string{"head", "unsupportedTopic"},
+			prepare: func() {
+				stream := mock2.NewMockBeaconNodeValidator_StreamSlotsClient(ctrl)
+				beaconNodeValidatorClient.EXPECT().StreamSlots(gomock.Any(),
+					&eth.StreamSlotsRequest{VerifiedOnly: true}).Return(stream, nil)
+				stream.EXPECT().Context().Return(ctx).AnyTimes()
+				stream.EXPECT().Recv().Return(
+					&eth.StreamSlotsResponse{Slot: 123},
+					nil,
+				).AnyTimes()
+			},
+			verify: func(t *testing.T, event *eventClient.Event) {
+				require.Equal(t, event.EventType, eventClient.EventHead)
+				head := structs.HeadEvent{}
+				require.NoError(t, json.Unmarshal(event.Data, &head))
+				require.Equal(t, head.Slot, "123")
+				assert.LogsContain(t, hook, "gRPC only supports the head topic")
+			},
+		},
+		{
+			name:    "No topics error",
+			topics:  []string{},
+			prepare: func() {},
+			verify: func(t *testing.T, event *eventClient.Event) {
+				require.Equal(t, event.EventType, eventClient.EventError)
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			eventsChannel := make(chan *eventClient.Event, 1) // Buffer to prevent blocking
+			tc.prepare()                                      // Setup mock expectations
+
+			go grpcClient.StartEventStream(ctx, tc.topics, eventsChannel)
+
+			event := <-eventsChannel
+			// Depending on what you're testing, you may need a timeout or a specific number of events to read
+			time.AfterFunc(1*time.Second, cancel) // Prevents hanging forever
+			tc.verify(t, event)
+		})
+	}
+}

validator/client/iface/BUILD.bazel

@@ -12,6 +12,8 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/validator/client/iface",
     visibility = ["//visibility:public"],
     deps = [
+        "//api/client/beacon:go_default_library",
+        "//api/client/event:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/proposer:go_default_library",
         "//consensus-types/primitives:go_default_library",

validator/client/iface/node_client.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
@@ -12,5 +13,5 @@ type NodeClient interface {
 	GetGenesis(ctx context.Context, in *empty.Empty) (*ethpb.Genesis, error)
 	GetVersion(ctx context.Context, in *empty.Empty) (*ethpb.Version, error)
 	ListPeers(ctx context.Context, in *empty.Empty) (*ethpb.Peers, error)
-	IsHealthy(ctx context.Context) bool
+	HealthTracker() *beacon.NodeHealthTracker
 }

validator/client/iface/validator.go

@@ -2,9 +2,10 @@ package iface
 
 import (
 	"context"
-	"errors"
 	"time"
 
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
+	"github.com/prysmaticlabs/prysm/v5/api/client/event"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/proposer"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -14,9 +15,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/validator/keymanager"
 )
 
-// ErrConnectionIssue represents a connection problem.
-var ErrConnectionIssue = errors.New("could not connect")
-
 // ValidatorRole defines the validator role.
 type ValidatorRole int8
 
@@ -57,16 +55,16 @@ type Validator interface {
 	UpdateDomainDataCaches(ctx context.Context, slot primitives.Slot)
 	WaitForKeymanagerInitialization(ctx context.Context) error
 	Keymanager() (keymanager.IKeymanager, error)
-	ReceiveSlots(ctx context.Context, connectionErrorChannel chan<- error)
 	HandleKeyReload(ctx context.Context, currentKeys [][fieldparams.BLSPubkeyLength]byte) (bool, error)
 	CheckDoppelGanger(ctx context.Context) error
 	PushProposerSettings(ctx context.Context, km keymanager.IKeymanager, slot primitives.Slot, deadline time.Time) error
 	SignValidatorRegistrationRequest(ctx context.Context, signer SigningFunc, newValidatorRegistration *ethpb.ValidatorRegistrationV1) (*ethpb.SignedValidatorRegistrationV1, error)
+	StartEventStream(ctx context.Context, topics []string, eventsChan chan<- *event.Event)
+	ProcessEvent(event *event.Event)
 	ProposerSettings() *proposer.Settings
 	SetProposerSettings(context.Context, *proposer.Settings) error
-	StartEventStream(ctx context.Context) error
 	EventStreamIsRunning() bool
-	NodeIsHealthy(ctx context.Context) bool
+	HealthTracker() *beacon.NodeHealthTracker
 }
 
 // SigningFunc interface defines a type for the a function that signs a message

validator/client/iface/validator_client.go

@@ -9,6 +9,7 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/prysmaticlabs/prysm/v5/api/client/event"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
@@ -144,9 +145,8 @@ type ValidatorClient interface {
 	GetSyncSubcommitteeIndex(ctx context.Context, in *ethpb.SyncSubcommitteeIndexRequest) (*ethpb.SyncSubcommitteeIndexResponse, error)
 	GetSyncCommitteeContribution(ctx context.Context, in *ethpb.SyncCommitteeContributionRequest) (*ethpb.SyncCommitteeContribution, error)
 	SubmitSignedContributionAndProof(ctx context.Context, in *ethpb.SignedContributionAndProof) (*empty.Empty, error)
-	StreamSlots(ctx context.Context, in *ethpb.StreamSlotsRequest) (ethpb.BeaconNodeValidator_StreamSlotsClient, error)
 	SubmitValidatorRegistrations(ctx context.Context, in *ethpb.SignedValidatorRegistrationsV1) (*empty.Empty, error)
-	StartEventStream(ctx context.Context) error
+	StartEventStream(ctx context.Context, topics []string, eventsChannel chan<- *event.Event)
 	EventStreamIsRunning() bool
 	GetAggregatedSelections(ctx context.Context, selections []BeaconCommitteeSelection) ([]BeaconCommitteeSelection, error)
 	GetAggregatedSyncSelections(ctx context.Context, selections []SyncCommitteeSelection) ([]SyncCommitteeSelection, error)

validator/client/runner.go

@@ -7,7 +7,8 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
+	"github.com/prysmaticlabs/prysm/v5/api/client"
+	"github.com/prysmaticlabs/prysm/v5/api/client/event"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -40,12 +41,12 @@ func run(ctx context.Context, v iface.Validator) {
 	if err != nil {
 		return // Exit if context is canceled.
 	}
-
-	connectionErrorChannel := make(chan error, 1)
-	go v.ReceiveSlots(ctx, connectionErrorChannel)
 	if err := v.UpdateDuties(ctx, headSlot); err != nil {
 		handleAssignmentError(err, headSlot)
 	}
+	eventsChan := make(chan *event.Event, 1)
+	healthTracker := v.HealthTracker()
+	runHealthCheckRoutine(ctx, v, eventsChan)
 
 	accountsChangedChan := make(chan [][fieldparams.BLSPubkeyLength]byte, 1)
 	km, err := v.Keymanager()
@@ -76,15 +77,10 @@ func run(ctx context.Context, v iface.Validator) {
 			sub.Unsubscribe()
 			close(accountsChangedChan)
 			return // Exit if context is canceled.
-		case slotsError := <-connectionErrorChannel:
-			if slotsError != nil {
-				log.WithError(slotsError).Warn("slots stream interrupted")
-				go v.ReceiveSlots(ctx, connectionErrorChannel)
+		case slot := <-v.NextSlot():
+			if !healthTracker.IsHealthy() {
 				continue
 			}
-		case currentKeys := <-accountsChangedChan:
-			onAccountsChanged(ctx, v, currentKeys, accountsChangedChan)
-		case slot := <-v.NextSlot():
 			span.AddAttributes(trace.Int64Attribute("slot", int64(slot))) // lint:ignore uintcast -- This conversion is OK for tracing.
 
 			deadline := v.SlotDeadline(slot)
@@ -128,6 +124,22 @@ func run(ctx context.Context, v iface.Validator) {
 				continue
 			}
 			performRoles(slotCtx, allRoles, v, slot, &wg, span)
+		case isHealthyAgain := <-healthTracker.HealthUpdates():
+			if isHealthyAgain {
+				headSlot, err = initializeValidatorAndGetHeadSlot(ctx, v)
+				if err != nil {
+					log.WithError(err).Error("Failed to re initialize validator and get head slot")
+					continue
+				}
+				if err := v.UpdateDuties(ctx, headSlot); err != nil {
+					handleAssignmentError(err, headSlot)
+					continue
+				}
+			}
+		case e := <-eventsChan:
+			v.ProcessEvent(e)
+		case currentKeys := <-accountsChangedChan: // should be less of a priority than next slot
+			onAccountsChanged(ctx, v, currentKeys, accountsChangedChan)
 		}
 	}
 }
@@ -196,13 +208,6 @@ func initializeValidatorAndGetHeadSlot(ctx context.Context, v iface.Validator) (
 			log.WithError(err).Fatal("Could not wait for validator activation")
 		}
 
-		if features.Get().EnableBeaconRESTApi {
-			if err = v.StartEventStream(ctx); err != nil {
-				log.WithError(err).Fatal("Could not start API event stream")
-			}
-			runHealthCheckRoutine(ctx, v)
-		}
-
 		headSlot, err = v.CanonicalHeadSlot(ctx)
 		if isConnectionError(err) {
 			log.WithError(err).Warn("Could not get current canonical head slot")
@@ -273,7 +278,7 @@ func performRoles(slotCtx context.Context, allRoles map[[48]byte][]iface.Validat
 }
 
 func isConnectionError(err error) bool {
-	return err != nil && errors.Is(err, iface.ErrConnectionIssue)
+	return err != nil && errors.Is(err, client.ErrConnectionIssue)
 }
 
 func handleAssignmentError(err error, slot primitives.Slot) {
@@ -288,24 +293,23 @@ func handleAssignmentError(err error, slot primitives.Slot) {
 	}
 }
 
-func runHealthCheckRoutine(ctx context.Context, v iface.Validator) {
+func runHealthCheckRoutine(ctx context.Context, v iface.Validator, eventsChan chan<- *event.Event) {
+	log.Info("Starting health check routine for beacon node apis")
 	healthCheckTicker := time.NewTicker(time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
+	tracker := v.HealthTracker()
 	go func() {
-		for {
-			select {
-			case <-healthCheckTicker.C:
-				if v.NodeIsHealthy(ctx) && !v.EventStreamIsRunning() {
-					if err := v.StartEventStream(ctx); err != nil {
-						log.WithError(err).Error("Could not start API event stream")
-					}
-				}
-			case <-ctx.Done():
-				if ctx.Err() != nil {
-					log.WithError(ctx.Err()).Error("Context cancelled")
-				}
-				log.Error("Context cancelled")
+		// trigger the healthcheck immediately the first time
+		for ; true; <-healthCheckTicker.C {
+			if ctx.Err() != nil {
+				log.WithError(ctx.Err()).Error("Context cancelled")
 				return
 			}
+			isHealthy := tracker.CheckHealth(ctx)
+			// in case of node returning healthy but event stream died
+			if isHealthy && !v.EventStreamIsRunning() {
+				log.Info("Event stream reconnecting...")
+				go v.StartEventStream(ctx, event.DefaultEventTopics, eventsChan)
+			}
 		}
 	}()
 }

validator/client/runner_test.go

@@ -8,6 +8,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
+	healthTesting "github.com/prysmaticlabs/prysm/v5/api/client/beacon/testing"
 	"github.com/prysmaticlabs/prysm/v5/async/event"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -18,6 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/validator/client/iface"
 	"github.com/prysmaticlabs/prysm/v5/validator/client/testutil"
 	logTest "github.com/sirupsen/logrus/hooks/test"
+	"go.uber.org/mock/gomock"
 )
 
 func cancelledContext() context.Context {
@@ -27,21 +30,41 @@ func cancelledContext() context.Context {
 }
 
 func TestCancelledContext_CleansUpValidator(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	v := &testutil.FakeValidator{
+		Km:      &mockKeymanager{accountsChangedFeed: &event.Feed{}},
+		Tracker: tracker,
+	}
 	run(cancelledContext(), v)
 	assert.Equal(t, true, v.DoneCalled, "Expected Done() to be called")
 }
 
 func TestCancelledContext_WaitsForChainStart(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	v := &testutil.FakeValidator{
+		Km:      &mockKeymanager{accountsChangedFeed: &event.Feed{}},
+		Tracker: tracker,
+	}
 	run(cancelledContext(), v)
 	assert.Equal(t, 1, v.WaitForChainStartCalled, "Expected WaitForChainStart() to be called")
 }
 
 func TestRetry_On_ConnectionError(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
 	retry := 10
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true)
 	v := &testutil.FakeValidator{
 		Km:               &mockKeymanager{accountsChangedFeed: &event.Feed{}},
+		Tracker:          tracker,
 		RetryTillSuccess: retry,
 	}
 	backOffPeriod = 10 * time.Millisecond
@@ -55,18 +78,31 @@ func TestRetry_On_ConnectionError(t *testing.T) {
 	assert.Equal(t, retry*3, v.WaitForChainStartCalled, "Expected WaitForChainStart() to be called")
 	assert.Equal(t, retry*2, v.WaitForSyncCalled, "Expected WaitForSync() to be called")
 	assert.Equal(t, retry, v.WaitForActivationCalled, "Expected WaitForActivation() to be called")
-	assert.Equal(t, retry, v.CanonicalHeadSlotCalled, "Expected WaitForActivation() to be called")
-	assert.Equal(t, retry, v.ReceiveBlocksCalled, "Expected WaitForActivation() to be called")
+	assert.Equal(t, retry, v.CanonicalHeadSlotCalled, "Expected CanonicalHeadSlotCalled() to be called")
 }
 
 func TestCancelledContext_WaitsForActivation(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	v := &testutil.FakeValidator{
+		Km:      &mockKeymanager{accountsChangedFeed: &event.Feed{}},
+		Tracker: tracker,
+	}
 	run(cancelledContext(), v)
 	assert.Equal(t, 1, v.WaitForActivationCalled, "Expected WaitForActivation() to be called")
 }
 
 func TestUpdateDuties_NextSlot(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	// avoid race condition between the cancellation of the context in the go stream from slot and the setting of IsHealthy
+	_ = tracker.CheckHealth(context.Background())
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	ctx, cancel := context.WithCancel(context.Background())
 
 	slot := primitives.Slot(55)
@@ -86,7 +122,14 @@ func TestUpdateDuties_NextSlot(t *testing.T) {
 
 func TestUpdateDuties_HandlesError(t *testing.T) {
 	hook := logTest.NewGlobal()
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	// avoid race condition between the cancellation of the context in the go stream from slot and the setting of IsHealthy
+	_ = tracker.CheckHealth(context.Background())
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	ctx, cancel := context.WithCancel(context.Background())
 
 	slot := primitives.Slot(55)
@@ -105,7 +148,14 @@ func TestUpdateDuties_HandlesError(t *testing.T) {
 }
 
 func TestRoleAt_NextSlot(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	// avoid race condition between the cancellation of the context in the go stream from slot and the setting of IsHealthy
+	_ = tracker.CheckHealth(context.Background())
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	ctx, cancel := context.WithCancel(context.Background())
 
 	slot := primitives.Slot(55)
@@ -124,7 +174,14 @@ func TestRoleAt_NextSlot(t *testing.T) {
 }
 
 func TestAttests_NextSlot(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	// avoid race condition between the cancellation of the context in the go stream from slot and the setting of IsHealthy
+	_ = tracker.CheckHealth(context.Background())
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	ctx, cancel := context.WithCancel(context.Background())
 
 	slot := primitives.Slot(55)
@@ -144,7 +201,14 @@ func TestAttests_NextSlot(t *testing.T) {
 }
 
 func TestProposes_NextSlot(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	// avoid race condition between the cancellation of the context in the go stream from slot and the setting of IsHealthy
+	_ = tracker.CheckHealth(context.Background())
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	ctx, cancel := context.WithCancel(context.Background())
 
 	slot := primitives.Slot(55)
@@ -164,7 +228,14 @@ func TestProposes_NextSlot(t *testing.T) {
 }
 
 func TestBothProposesAndAttests_NextSlot(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	// avoid race condition between the cancellation of the context in the go stream from slot and the setting of IsHealthy
+	_ = tracker.CheckHealth(context.Background())
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	ctx, cancel := context.WithCancel(context.Background())
 
 	slot := primitives.Slot(55)
@@ -188,7 +259,12 @@ func TestBothProposesAndAttests_NextSlot(t *testing.T) {
 func TestKeyReload_ActiveKey(t *testing.T) {
 	ctx := context.Background()
 	km := &mockKeymanager{}
-	v := &testutil.FakeValidator{Km: km}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	v := &testutil.FakeValidator{Km: km, Tracker: tracker}
 	ac := make(chan [][fieldparams.BLSPubkeyLength]byte)
 	current := [][fieldparams.BLSPubkeyLength]byte{testutil.ActiveKey}
 	onAccountsChanged(ctx, v, current, ac)
@@ -202,7 +278,12 @@ func TestKeyReload_NoActiveKey(t *testing.T) {
 	na := notActive(t)
 	ctx := context.Background()
 	km := &mockKeymanager{}
-	v := &testutil.FakeValidator{Km: km}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	v := &testutil.FakeValidator{Km: km, Tracker: tracker}
 	ac := make(chan [][fieldparams.BLSPubkeyLength]byte)
 	current := [][fieldparams.BLSPubkeyLength]byte{na}
 	onAccountsChanged(ctx, v, current, ac)
@@ -224,7 +305,12 @@ func notActive(t *testing.T) [fieldparams.BLSPubkeyLength]byte {
 }
 
 func TestUpdateProposerSettingsAt_EpochStart(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	err := v.SetProposerSettings(context.Background(), &proposer.Settings{
 		DefaultConfig: &proposer.Option{
 			FeeRecipientConfig: &proposer.FeeRecipientConfig{
@@ -249,7 +335,16 @@ func TestUpdateProposerSettingsAt_EpochStart(t *testing.T) {
 }
 
 func TestUpdateProposerSettingsAt_EpochEndOk(t *testing.T) {
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, ProposerSettingWait: time.Duration(params.BeaconConfig().SecondsPerSlot-1) * time.Second}
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
+	v := &testutil.FakeValidator{
+		Km:                  &mockKeymanager{accountsChangedFeed: &event.Feed{}},
+		ProposerSettingWait: time.Duration(params.BeaconConfig().SecondsPerSlot-1) * time.Second,
+		Tracker:             tracker,
+	}
 	err := v.SetProposerSettings(context.Background(), &proposer.Settings{
 		DefaultConfig: &proposer.Option{
 			FeeRecipientConfig: &proposer.FeeRecipientConfig{
@@ -275,9 +370,15 @@ func TestUpdateProposerSettingsAt_EpochEndOk(t *testing.T) {
 
 func TestUpdateProposerSettings_ContinuesAfterValidatorRegistrationFails(t *testing.T) {
 	errSomeotherError := errors.New("some internal error")
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	node := healthTesting.NewMockHealthClient(ctrl)
+	tracker := beacon.NewNodeHealthTracker(node)
+	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
 	v := &testutil.FakeValidator{
 		ProposerSettingsErr: errors.Wrap(ErrBuilderValidatorRegistration, errSomeotherError.Error()),
 		Km:                  &mockKeymanager{accountsChangedFeed: &event.Feed{}},
+		Tracker:             tracker,
 	}
 	err := v.SetProposerSettings(context.Background(), &proposer.Settings{
 		DefaultConfig: &proposer.Option{

validator/client/service.go

@@ -194,14 +194,12 @@ func (v *ValidatorService) Start() {
 		return
 	}
 
-	restHandler := &beaconApi.BeaconApiJsonRestHandler{
-		HttpClient: http.Client{Timeout: v.conn.GetBeaconApiTimeout()},
-		Host:       v.conn.GetBeaconApiUrl(),
-	}
+	restHandler := beaconApi.NewBeaconApiJsonRestHandler(
+		http.Client{Timeout: v.conn.GetBeaconApiTimeout()},
+		v.conn.GetBeaconApiUrl(),
+	)
 
-	evHandler := beaconApi.NewEventHandler(http.DefaultClient, v.conn.GetBeaconApiUrl())
-	opts := []beaconApi.ValidatorClientOpt{beaconApi.WithEventHandler(evHandler)}
-	validatorClient := validatorClientFactory.NewValidatorClient(v.conn, restHandler, opts...)
+	validatorClient := validatorClientFactory.NewValidatorClient(v.conn, restHandler)
 
 	valStruct := &validator{
 		validatorClient:                validatorClient,

validator/client/testutil/BUILD.bazel

@@ -10,6 +10,9 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/validator/client/testutil",
     visibility = ["//validator:__subpackages__"],
     deps = [
+        "//api/client:go_default_library",
+        "//api/client/beacon:go_default_library",
+        "//api/client/event:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/proposer:go_default_library",
         "//consensus-types/primitives:go_default_library",

validator/client/testutil/mock_validator.go

@@ -5,6 +5,9 @@ import (
 	"context"
 	"time"
 
+	api "github.com/prysmaticlabs/prysm/v5/api/client"
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
+	"github.com/prysmaticlabs/prysm/v5/api/client/event"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/proposer"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -55,6 +58,7 @@ type FakeValidator struct {
 	proposerSettings                  *proposer.Settings
 	ProposerSettingWait               time.Duration
 	Km                                keymanager.IKeymanager
+	Tracker                           *beacon.NodeHealthTracker
 }
 
 // Done for mocking.
@@ -75,7 +79,7 @@ func (fv *FakeValidator) LogSubmittedSyncCommitteeMessages() {}
 func (fv *FakeValidator) WaitForChainStart(_ context.Context) error {
 	fv.WaitForChainStartCalled++
 	if fv.RetryTillSuccess >= fv.WaitForChainStartCalled {
-		return iface.ErrConnectionIssue
+		return api.ErrConnectionIssue
 	}
 	return nil
 }
@@ -87,7 +91,7 @@ func (fv *FakeValidator) WaitForActivation(_ context.Context, accountChan chan [
 		return nil
 	}
 	if fv.RetryTillSuccess >= fv.WaitForActivationCalled {
-		return iface.ErrConnectionIssue
+		return api.ErrConnectionIssue
 	}
 	return nil
 }
@@ -96,7 +100,7 @@ func (fv *FakeValidator) WaitForActivation(_ context.Context, accountChan chan [
 func (fv *FakeValidator) WaitForSync(_ context.Context) error {
 	fv.WaitForSyncCalled++
 	if fv.RetryTillSuccess >= fv.WaitForSyncCalled {
-		return iface.ErrConnectionIssue
+		return api.ErrConnectionIssue
 	}
 	return nil
 }
@@ -111,7 +115,7 @@ func (fv *FakeValidator) SlasherReady(_ context.Context) error {
 func (fv *FakeValidator) CanonicalHeadSlot(_ context.Context) (primitives.Slot, error) {
 	fv.CanonicalHeadSlotCalled++
 	if fv.RetryTillSuccess > fv.CanonicalHeadSlotCalled {
-		return 0, iface.ErrConnectionIssue
+		return 0, api.ErrConnectionIssue
 	}
 	return 0, nil
 }
@@ -217,14 +221,6 @@ func (*FakeValidator) CheckDoppelGanger(_ context.Context) error {
 	return nil
 }
 
-// ReceiveSlots for mocking
-func (fv *FakeValidator) ReceiveSlots(_ context.Context, connectionErrorChannel chan<- error) {
-	fv.ReceiveBlocksCalled++
-	if fv.RetryTillSuccess > fv.ReceiveBlocksCalled {
-		connectionErrorChannel <- iface.ErrConnectionIssue
-	}
-}
-
 // HandleKeyReload for mocking
 func (fv *FakeValidator) HandleKeyReload(_ context.Context, newKeys [][fieldparams.BLSPubkeyLength]byte) (anyActive bool, err error) {
 	fv.HandleKeyReloadCalled = true
@@ -286,14 +282,15 @@ func (fv *FakeValidator) SetProposerSettings(_ context.Context, settings *propos
 	return nil
 }
 
-func (fv *FakeValidator) StartEventStream(_ context.Context) error {
-	return nil
+func (*FakeValidator) StartEventStream(_ context.Context, _ []string, _ chan<- *event.Event) {
 }
 
-func (fv *FakeValidator) EventStreamIsRunning() bool {
+func (*FakeValidator) ProcessEvent(_ *event.Event) {}
+
+func (*FakeValidator) EventStreamIsRunning() bool {
 	return true
 }
 
-func (fv *FakeValidator) NodeIsHealthy(context.Context) bool {
-	return true
+func (fv *FakeValidator) HealthTracker() *beacon.NodeHealthTracker {
+	return fv.Tracker
 }

validator/client/validator.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"encoding/binary"
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"io"
 	"math"
@@ -20,6 +21,10 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/api/client"
+	"github.com/prysmaticlabs/prysm/v5/api/client/beacon"
+	eventClient "github.com/prysmaticlabs/prysm/v5/api/client/event"
+	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
@@ -248,7 +253,7 @@ func (v *validator) WaitForChainStart(ctx context.Context) error {
 
 	chainStartRes, err := v.validatorClient.WaitForChainStart(ctx, &emptypb.Empty{})
 	if err == io.EOF {
-		return iface.ErrConnectionIssue
+		return client.ErrConnectionIssue
 	}
 
 	if ctx.Err() == context.Canceled {
@@ -257,7 +262,7 @@ func (v *validator) WaitForChainStart(ctx context.Context) error {
 
 	if err != nil {
 		return errors.Wrap(
-			iface.ErrConnectionIssue,
+			client.ErrConnectionIssue,
 			errors.Wrap(err, "could not receive ChainStart from stream").Error(),
 		)
 	}
@@ -310,7 +315,7 @@ func (v *validator) WaitForSync(ctx context.Context) error {
 
 	s, err := v.nodeClient.GetSyncStatus(ctx, &emptypb.Empty{})
 	if err != nil {
-		return errors.Wrap(iface.ErrConnectionIssue, errors.Wrap(err, "could not get sync status").Error())
+		return errors.Wrap(client.ErrConnectionIssue, errors.Wrap(err, "could not get sync status").Error())
 	}
 	if !s.Syncing {
 		return nil
@@ -322,7 +327,7 @@ func (v *validator) WaitForSync(ctx context.Context) error {
 		case <-time.After(slots.DivideSlotBy(2 /* twice per slot */)):
 			s, err := v.nodeClient.GetSyncStatus(ctx, &emptypb.Empty{})
 			if err != nil {
-				return errors.Wrap(iface.ErrConnectionIssue, errors.Wrap(err, "could not get sync status").Error())
+				return errors.Wrap(client.ErrConnectionIssue, errors.Wrap(err, "could not get sync status").Error())
 			}
 			if !s.Syncing {
 				return nil
@@ -334,35 +339,6 @@ func (v *validator) WaitForSync(ctx context.Context) error {
 	}
 }
 
-// ReceiveSlots starts a stream listener to obtain
-// slots from the beacon node when it imports a block. Upon receiving a slot, the service
-// broadcasts it to a feed for other usages to subscribe to.
-func (v *validator) ReceiveSlots(ctx context.Context, connectionErrorChannel chan<- error) {
-	stream, err := v.validatorClient.StreamSlots(ctx, &ethpb.StreamSlotsRequest{VerifiedOnly: true})
-	if err != nil {
-		log.WithError(err).Error("Failed to retrieve slots stream, " + iface.ErrConnectionIssue.Error())
-		connectionErrorChannel <- errors.Wrap(iface.ErrConnectionIssue, err.Error())
-		return
-	}
-
-	for {
-		if ctx.Err() == context.Canceled {
-			log.WithError(ctx.Err()).Error("Context canceled - shutting down slots receiver")
-			return
-		}
-		res, err := stream.Recv()
-		if err != nil {
-			log.WithError(err).Error("Could not receive slots from beacon node: " + iface.ErrConnectionIssue.Error())
-			connectionErrorChannel <- errors.Wrap(iface.ErrConnectionIssue, err.Error())
-			return
-		}
-		if res == nil {
-			continue
-		}
-		v.setHighestSlot(res.Slot)
-	}
-}
-
 func (v *validator) checkAndLogValidatorStatus(statuses []*validatorStatus, activeValCount int64) bool {
 	nonexistentIndex := primitives.ValidatorIndex(^uint64(0))
 	var validatorActivated bool
@@ -429,7 +405,7 @@ func (v *validator) CanonicalHeadSlot(ctx context.Context) (primitives.Slot, err
 	defer span.End()
 	head, err := v.beaconClient.GetChainHead(ctx, &emptypb.Empty{})
 	if err != nil {
-		return 0, errors.Wrap(iface.ErrConnectionIssue, err.Error())
+		return 0, errors.Wrap(client.ErrConnectionIssue, err.Error())
 	}
 	return head.HeadSlot, nil
 }
@@ -1092,16 +1068,43 @@ func (v *validator) PushProposerSettings(ctx context.Context, km keymanager.IKey
 	return nil
 }
 
-func (v *validator) StartEventStream(ctx context.Context) error {
-	return v.validatorClient.StartEventStream(ctx)
+func (v *validator) StartEventStream(ctx context.Context, topics []string, eventsChannel chan<- *eventClient.Event) {
+	log.WithField("topics", topics).Info("Starting event stream")
+	v.validatorClient.StartEventStream(ctx, topics, eventsChannel)
+}
+
+func (v *validator) ProcessEvent(event *eventClient.Event) {
+	if event == nil || event.Data == nil {
+		log.Warn("Received empty event")
+	}
+	switch event.EventType {
+	case eventClient.EventError:
+		log.Error(string(event.Data))
+	case eventClient.EventConnectionError:
+		log.WithError(errors.New(string(event.Data))).Error("Event stream interrupted")
+	case eventClient.EventHead:
+		log.Debug("Received head event")
+		head := &structs.HeadEvent{}
+		if err := json.Unmarshal(event.Data, head); err != nil {
+			log.WithError(err).Error("Failed to unmarshal head Event into JSON")
+		}
+		uintSlot, err := strconv.ParseUint(head.Slot, 10, 64)
+		if err != nil {
+			log.WithError(err).Error("Failed to parse slot")
+		}
+		v.setHighestSlot(primitives.Slot(uintSlot))
+	default:
+		// just keep going and log the error
+		log.WithField("type", event.EventType).WithField("data", string(event.Data)).Warn("Received an unknown event")
+	}
 }
 
 func (v *validator) EventStreamIsRunning() bool {
 	return v.validatorClient.EventStreamIsRunning()
 }
 
-func (v *validator) NodeIsHealthy(ctx context.Context) bool {
-	return v.nodeClient.IsHealthy(ctx)
+func (v *validator) HealthTracker() *beacon.NodeHealthTracker {
+	return v.nodeClient.HealthTracker()
 }
 
 func (v *validator) filterAndCacheActiveKeys(ctx context.Context, pubkeys [][fieldparams.BLSPubkeyLength]byte, slot primitives.Slot) ([][fieldparams.BLSPubkeyLength]byte, error) {