zip only json

api/client/client.go

@@ -6,7 +6,6 @@ import (
 	"net"
 	"net/http"
 	"net/url"
-	"os"
 
 	"github.com/pkg/errors"
 )
@@ -15,17 +14,14 @@ const (
 	MaxBodySize      int64 = 1 << 23 // 8MB default, WithMaxBodySize can override
 	MaxBodySizeState int64 = 1 << 29 // 512MB
 	MaxErrBodySize   int64 = 1 << 17 // 128KB
-
-	envNameOverrideAccept = "PRYSM_API_OVERRIDE_ACCEPT"
 )
 
 // Client is a wrapper object around the HTTP client.
 type Client struct {
-	hc           *http.Client
-	baseURL      *url.URL
-	token        string
-	maxBodySize  int64
-	reqOverrides []ReqOption
+	hc          *http.Client
+	baseURL     *url.URL
+	token       string
+	maxBodySize int64
 }
 
 // NewClient constructs a new client with the provided options (ex WithTimeout).
@@ -44,21 +40,9 @@ func NewClient(host string, opts ...ClientOpt) (*Client, error) {
 	for _, o := range opts {
 		o(c)
 	}
-	c.appendAcceptOverride()
 	return c, nil
 }
 
-// appendAcceptOverride enables the Accept header to be customized at runtime via an environment variable.
-// This is specified as an env var because it is a niche option that prysm may use for performance testing or debugging
-// bug which users are unlikely to need. Using an env var keeps the set of user-facing flags cleaner.
-func (c *Client) appendAcceptOverride() {
-	if accept := os.Getenv(envNameOverrideAccept); accept != "" {
-		c.reqOverrides = append(c.reqOverrides, func(req *http.Request) {
-			req.Header.Set("Accept", accept)
-		})
-	}
-}
-
 // Token returns the bearer token used for jwt authentication
 func (c *Client) Token() string {
 	return c.token
@@ -71,9 +55,6 @@ func (c *Client) BaseURL() *url.URL {
 
 // Do execute the request against the http client
 func (c *Client) Do(req *http.Request) (*http.Response, error) {
-	for _, o := range c.reqOverrides {
-		o(req)
-	}
 	return c.hc.Do(req)
 }
 
@@ -106,7 +87,7 @@ func (c *Client) Get(ctx context.Context, path string, opts ...ReqOption) ([]byt
 	for _, o := range opts {
 		o(req)
 	}
-	r, err := c.Do(req)
+	r, err := c.hc.Do(req)
 	if err != nil {
 		return nil, err
 	}

api/client/client_test.go

@@ -1,10 +1,7 @@
 package client
 
 import (
-	"net/http"
-	"net/http/httptest"
 	"net/url"
-	"os"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/testing/require"
@@ -49,23 +46,3 @@ func TestBaseURL(t *testing.T) {
 	require.Equal(t, "www.offchainlabs.com", cl.BaseURL().Hostname())
 	require.Equal(t, "3500", cl.BaseURL().Port())
 }
-
-func TestAcceptOverride(t *testing.T) {
-	name := "TestAcceptOverride"
-	orig := os.Getenv(envNameOverrideAccept)
-	defer func() {
-		os.Setenv(envNameOverrideAccept, orig)
-	}()
-	os.Setenv(envNameOverrideAccept, name)
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(t, name, r.Header.Get("Accept"))
-		w.WriteHeader(200)
-		w.Write([]byte("ok"))
-	}))
-	defer srv.Close()
-	c, err := NewClient(srv.URL)
-	require.NoError(t, err)
-	b, err := c.Get(t.Context(), "/test")
-	require.NoError(t, err)
-	require.Equal(t, "ok", string(b))
-}

api/server/middleware/BUILD.bazel

@@ -8,7 +8,11 @@ go_library(
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/api/server/middleware",
     visibility = ["//visibility:public"],
-    deps = ["@com_github_rs_cors//:go_default_library"],
+    deps = [
+        "//api:go_default_library",
+        "@com_github_rs_cors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
 )
 
 go_test(
@@ -22,5 +26,6 @@ go_test(
         "//api:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

api/server/middleware/middleware.go

@@ -1,11 +1,14 @@
 package middleware
 
 import (
+	"compress/gzip"
 	"fmt"
 	"net/http"
 	"strings"
 
+	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/rs/cors"
+	log "github.com/sirupsen/logrus"
 )
 
 type Middleware func(http.Handler) http.Handler
@@ -112,6 +115,46 @@ func AcceptHeaderHandler(serverAcceptedTypes []string) Middleware {
 	}
 }
 
+// AcceptEncodingHeaderHandler compresses the response before sending it back to the client, if gzip is supported.
+func AcceptEncodingHeaderHandler() Middleware {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
+				next.ServeHTTP(w, r)
+				return
+			}
+
+			gz := gzip.NewWriter(w)
+			gzipRW := &gzipResponseWriter{gz: gz, ResponseWriter: w}
+			defer func() {
+				if !gzipRW.zipped {
+					return
+				}
+				if err := gz.Close(); err != nil {
+					log.WithError(err).Error("Failed to close gzip writer")
+				}
+			}()
+
+			next.ServeHTTP(gzipRW, r)
+		})
+	}
+}
+
+type gzipResponseWriter struct {
+	gz *gzip.Writer
+	http.ResponseWriter
+	zipped bool
+}
+
+func (g *gzipResponseWriter) Write(b []byte) (int, error) {
+	if strings.Contains(g.Header().Get("Content-Type"), api.JsonMediaType) {
+		g.zipped = true
+		g.Header().Set("Content-Encoding", "gzip")
+		return g.gz.Write(b)
+	}
+	return g.ResponseWriter.Write(b)
+}
+
 func MiddlewareChain(h http.Handler, mw []Middleware) http.Handler {
 	if len(mw) < 1 {
 		return h

api/server/middleware/middleware_test.go

@@ -1,12 +1,16 @@
 package middleware
 
 import (
+	"bytes"
+	"compress/gzip"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
+	log "github.com/sirupsen/logrus"
 )
 
 func TestNormalizeQueryValuesHandler(t *testing.T) {
@@ -124,6 +128,89 @@ func TestContentTypeHandler(t *testing.T) {
 	}
 }
 
+func TestAcceptEncodingHeaderHandler(t *testing.T) {
+	dummyContent := "Test gzip middleware content"
+	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", r.Header.Get("Accept"))
+		_, err := w.Write([]byte(dummyContent))
+		require.NoError(t, err)
+	})
+
+	handler := AcceptEncodingHeaderHandler()(nextHandler)
+
+	tests := []struct {
+		name             string
+		accept           string
+		acceptEncoding   string
+		expectCompressed bool
+	}{
+		{
+			name:             "Gzip supported",
+			accept:           api.JsonMediaType,
+			acceptEncoding:   "gzip",
+			expectCompressed: true,
+		},
+		{
+			name:             "Multiple encodings supported",
+			accept:           api.JsonMediaType,
+			acceptEncoding:   "deflate, gzip",
+			expectCompressed: true,
+		},
+		{
+			name:             "Gzip not supported",
+			accept:           api.JsonMediaType,
+			acceptEncoding:   "deflate",
+			expectCompressed: false,
+		},
+		{
+			name:             "No accept encoding header",
+			accept:           api.JsonMediaType,
+			acceptEncoding:   "",
+			expectCompressed: false,
+		},
+		{
+			name:             "SSZ",
+			accept:           api.OctetStreamMediaType,
+			acceptEncoding:   "gzip",
+			expectCompressed: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest("GET", "/", nil)
+			req.Header.Set("Accept", tt.accept)
+			if tt.acceptEncoding != "" {
+				req.Header.Set("Accept-Encoding", tt.acceptEncoding)
+			}
+			rr := httptest.NewRecorder()
+
+			handler.ServeHTTP(rr, req)
+
+			if tt.expectCompressed {
+				require.Equal(t, "gzip", rr.Header().Get("Content-Encoding"), "Expected Content-Encoding header to be 'gzip'")
+
+				compressedBody := rr.Body.Bytes()
+				require.NotEqual(t, dummyContent, string(compressedBody), "Response body should be compressed and differ from the original")
+
+				gzReader, err := gzip.NewReader(bytes.NewReader(compressedBody))
+				require.NoError(t, err, "Failed to create gzipReader")
+				defer func() {
+					if err := gzReader.Close(); err != nil {
+						log.WithError(err).Error("Failed to close gzip reader")
+					}
+				}()
+
+				decompressedBody, err := io.ReadAll(gzReader)
+				require.NoError(t, err, "Failed to decompress response body")
+				require.Equal(t, dummyContent, string(decompressedBody), "Decompressed content should match the original")
+			} else {
+				require.Equal(t, dummyContent, rr.Body.String(), "Response body should be uncompressed and match the original")
+			}
+		})
+	}
+}
+
 func TestAcceptHeaderHandler(t *testing.T) {
 	acceptedTypes := []string{"application/json", "application/octet-stream"}
 

beacon-chain/p2p/rpc_topic_mappings.go

@@ -22,52 +22,50 @@ const (
 	SchemaVersionV3 = "/3"
 )
 
-const (
-	// Specifies the protocol prefix for all our Req/Resp topics.
-	protocolPrefix = "/eth2/beacon_chain/req"
+// Specifies the protocol prefix for all our Req/Resp topics.
+const protocolPrefix = "/eth2/beacon_chain/req"
 
-	// StatusMessageName specifies the name for the status message topic.
-	StatusMessageName = "/status"
+// StatusMessageName specifies the name for the status message topic.
+const StatusMessageName = "/status"
 
-	// GoodbyeMessageName specifies the name for the goodbye message topic.
-	GoodbyeMessageName = "/goodbye"
+// GoodbyeMessageName specifies the name for the goodbye message topic.
+const GoodbyeMessageName = "/goodbye"
 
-	// BeaconBlocksByRangeMessageName specifies the name for the beacon blocks by range message topic.
-	BeaconBlocksByRangeMessageName = "/beacon_blocks_by_range"
+// BeaconBlocksByRangeMessageName specifies the name for the beacon blocks by range message topic.
+const BeaconBlocksByRangeMessageName = "/beacon_blocks_by_range"
 
-	// BeaconBlocksByRootsMessageName specifies the name for the beacon blocks by root message topic.
-	BeaconBlocksByRootsMessageName = "/beacon_blocks_by_root"
+// BeaconBlocksByRootsMessageName specifies the name for the beacon blocks by root message topic.
+const BeaconBlocksByRootsMessageName = "/beacon_blocks_by_root"
 
-	// PingMessageName Specifies the name for the ping message topic.
-	PingMessageName = "/ping"
+// PingMessageName Specifies the name for the ping message topic.
+const PingMessageName = "/ping"
 
-	// MetadataMessageName specifies the name for the metadata message topic.
-	MetadataMessageName = "/metadata"
+// MetadataMessageName specifies the name for the metadata message topic.
+const MetadataMessageName = "/metadata"
 
-	// BlobSidecarsByRangeName is the name for the BlobSidecarsByRange v1 message topic.
-	BlobSidecarsByRangeName = "/blob_sidecars_by_range"
+// BlobSidecarsByRangeName is the name for the BlobSidecarsByRange v1 message topic.
+const BlobSidecarsByRangeName = "/blob_sidecars_by_range"
 
-	// BlobSidecarsByRootName is the name for the BlobSidecarsByRoot v1 message topic.
-	BlobSidecarsByRootName = "/blob_sidecars_by_root"
+// BlobSidecarsByRootName is the name for the BlobSidecarsByRoot v1 message topic.
+const BlobSidecarsByRootName = "/blob_sidecars_by_root"
 
-	// LightClientBootstrapName is the name for the LightClientBootstrap message topic,
-	LightClientBootstrapName = "/light_client_bootstrap"
+// LightClientBootstrapName is the name for the LightClientBootstrap message topic,
+const LightClientBootstrapName = "/light_client_bootstrap"
 
-	// LightClientUpdatesByRangeName is the name for the LightClientUpdatesByRange topic.
-	LightClientUpdatesByRangeName = "/light_client_updates_by_range"
+// LightClientUpdatesByRangeName is the name for the LightClientUpdatesByRange topic.
+const LightClientUpdatesByRangeName = "/light_client_updates_by_range"
 
-	// LightClientFinalityUpdateName is the name for the LightClientFinalityUpdate topic.
-	LightClientFinalityUpdateName = "/light_client_finality_update"
+// LightClientFinalityUpdateName is the name for the LightClientFinalityUpdate topic.
+const LightClientFinalityUpdateName = "/light_client_finality_update"
 
-	// LightClientOptimisticUpdateName is the name for the LightClientOptimisticUpdate topic.
-	LightClientOptimisticUpdateName = "/light_client_optimistic_update"
+// LightClientOptimisticUpdateName is the name for the LightClientOptimisticUpdate topic.
+const LightClientOptimisticUpdateName = "/light_client_optimistic_update"
 
-	// DataColumnSidecarsByRootName is the name for the DataColumnSidecarsByRoot v1 message topic.
-	DataColumnSidecarsByRootName = "/data_column_sidecars_by_root"
+// DataColumnSidecarsByRootName is the name for the DataColumnSidecarsByRoot v1 message topic.
+const DataColumnSidecarsByRootName = "/data_column_sidecars_by_root"
 
-	// DataColumnSidecarsByRangeName is the name for the DataColumnSidecarsByRange v1 message topic.
-	DataColumnSidecarsByRangeName = "/data_column_sidecars_by_range"
-)
+// DataColumnSidecarsByRangeName is the name for the DataColumnSidecarsByRange v1 message topic.
+const DataColumnSidecarsByRangeName = "/data_column_sidecars_by_range"
 
 const (
 	// V1 RPC Topics
@@ -103,9 +101,6 @@ const (
 	// RPCDataColumnSidecarsByRootTopicV1 is a topic for requesting data column sidecars by their block root.
 	// /eth2/beacon_chain/req/data_column_sidecars_by_root/1 - New in Fulu.
 	RPCDataColumnSidecarsByRootTopicV1 = protocolPrefix + DataColumnSidecarsByRootName + SchemaVersionV1
-	// RPCDataColumnSidecarsByRangeTopicV1 is a topic for requesting data column sidecars by their slot.
-	// /eth2/beacon_chain/req/data_column_sidecars_by_range/1 - New in Fulu.
-	RPCDataColumnSidecarsByRangeTopicV1 = protocolPrefix + DataColumnSidecarsByRangeName + SchemaVersionV1
 
 	// V2 RPC Topics
 	// RPCBlocksByRangeTopicV2 defines v2 the topic for the blocks by range rpc method.
@@ -126,103 +121,91 @@ const (
 )
 
 // RPCTopicMappings map the base message type to the rpc request.
-var (
-	RPCTopicMappings = map[string]interface{}{
-		// RPC Status Message
-		RPCStatusTopicV1: new(pb.Status),
+var RPCTopicMappings = map[string]interface{}{
+	// RPC Status Message
+	RPCStatusTopicV1: new(pb.Status),
+	// RPC Goodbye Message
+	RPCGoodByeTopicV1: new(primitives.SSZUint64),
+	// RPC Block By Range Message
+	RPCBlocksByRangeTopicV1: new(pb.BeaconBlocksByRangeRequest),
+	RPCBlocksByRangeTopicV2: new(pb.BeaconBlocksByRangeRequest),
+	// RPC Block By Root Message
+	RPCBlocksByRootTopicV1: new(p2ptypes.BeaconBlockByRootsReq),
+	RPCBlocksByRootTopicV2: new(p2ptypes.BeaconBlockByRootsReq),
+	// RPC Ping Message
+	RPCPingTopicV1: new(primitives.SSZUint64),
+	// RPC Metadata Message
+	RPCMetaDataTopicV1: new(interface{}),
+	RPCMetaDataTopicV2: new(interface{}),
+	RPCMetaDataTopicV3: new(interface{}),
+	// BlobSidecarsByRange v1 Message
+	RPCBlobSidecarsByRangeTopicV1: new(pb.BlobSidecarsByRangeRequest),
+	// BlobSidecarsByRoot v1 Message
+	RPCBlobSidecarsByRootTopicV1: new(p2ptypes.BlobSidecarsByRootReq),
 
-		// RPC Goodbye Message
-		RPCGoodByeTopicV1: new(primitives.SSZUint64),
+	// Light client
+	RPCLightClientBootstrapTopicV1:        new([fieldparams.RootLength]byte),
+	RPCLightClientUpdatesByRangeTopicV1:   new(pb.LightClientUpdatesByRangeRequest),
+	RPCLightClientFinalityUpdateTopicV1:   new(interface{}),
+	RPCLightClientOptimisticUpdateTopicV1: new(interface{}),
 
-		// RPC Block By Range Message
-		RPCBlocksByRangeTopicV1: new(pb.BeaconBlocksByRangeRequest),
-		RPCBlocksByRangeTopicV2: new(pb.BeaconBlocksByRangeRequest),
+	// DataColumnSidecarsByRoot v1 Message
+	RPCDataColumnSidecarsByRootTopicV1: new(p2ptypes.DataColumnsByRootIdentifiers),
+}
 
-		// RPC Block By Root Message
-		RPCBlocksByRootTopicV1: new(p2ptypes.BeaconBlockByRootsReq),
-		RPCBlocksByRootTopicV2: new(p2ptypes.BeaconBlockByRootsReq),
+// Maps all registered protocol prefixes.
+var protocolMapping = map[string]bool{
+	protocolPrefix: true,
+}
 
-		// RPC Ping Message
-		RPCPingTopicV1: new(primitives.SSZUint64),
+// Maps all the protocol message names for the different rpc
+// topics.
+var messageMapping = map[string]bool{
+	StatusMessageName:               true,
+	GoodbyeMessageName:              true,
+	BeaconBlocksByRangeMessageName:  true,
+	BeaconBlocksByRootsMessageName:  true,
+	PingMessageName:                 true,
+	MetadataMessageName:             true,
+	BlobSidecarsByRangeName:         true,
+	BlobSidecarsByRootName:          true,
+	LightClientBootstrapName:        true,
+	LightClientUpdatesByRangeName:   true,
+	LightClientFinalityUpdateName:   true,
+	LightClientOptimisticUpdateName: true,
+	DataColumnSidecarsByRootName:    true,
+}
 
-		// RPC Metadata Message
-		RPCMetaDataTopicV1: new(interface{}),
-		RPCMetaDataTopicV2: new(interface{}),
-		RPCMetaDataTopicV3: new(interface{}),
+// Maps all the RPC messages which are to updated in altair.
+var altairMapping = map[string]bool{
+	BeaconBlocksByRangeMessageName: true,
+	BeaconBlocksByRootsMessageName: true,
+	MetadataMessageName:            true,
+}
 
-		// BlobSidecarsByRange v1 Message
-		RPCBlobSidecarsByRangeTopicV1: new(pb.BlobSidecarsByRangeRequest),
+// Maps all the RPC messages which are to updated in fulu.
+var fuluMapping = map[string]bool{
+	MetadataMessageName: true,
+}
 
-		// BlobSidecarsByRoot v1 Message
-		RPCBlobSidecarsByRootTopicV1: new(p2ptypes.BlobSidecarsByRootReq),
+var versionMapping = map[string]bool{
+	SchemaVersionV1: true,
+	SchemaVersionV2: true,
+	SchemaVersionV3: true,
+}
 
-		// Light client
-		RPCLightClientBootstrapTopicV1:        new([fieldparams.RootLength]byte),
-		RPCLightClientUpdatesByRangeTopicV1:   new(pb.LightClientUpdatesByRangeRequest),
-		RPCLightClientFinalityUpdateTopicV1:   new(interface{}),
-		RPCLightClientOptimisticUpdateTopicV1: new(interface{}),
-
-		// DataColumnSidecarsByRange v1 Message
-		RPCDataColumnSidecarsByRangeTopicV1: new(pb.DataColumnSidecarsByRangeRequest),
-
-		// DataColumnSidecarsByRoot v1 Message
-		RPCDataColumnSidecarsByRootTopicV1: new(p2ptypes.DataColumnsByRootIdentifiers),
-	}
-
-	// Maps all registered protocol prefixes.
-	protocolMapping = map[string]bool{
-		protocolPrefix: true,
-	}
-
-	// Maps all the protocol message names for the different rpc topics.
-	messageMapping = map[string]bool{
-		StatusMessageName:               true,
-		GoodbyeMessageName:              true,
-		BeaconBlocksByRangeMessageName:  true,
-		BeaconBlocksByRootsMessageName:  true,
-		PingMessageName:                 true,
-		MetadataMessageName:             true,
-		BlobSidecarsByRangeName:         true,
-		BlobSidecarsByRootName:          true,
-		LightClientBootstrapName:        true,
-		LightClientUpdatesByRangeName:   true,
-		LightClientFinalityUpdateName:   true,
-		LightClientOptimisticUpdateName: true,
-		DataColumnSidecarsByRootName:    true,
-		DataColumnSidecarsByRangeName:   true,
-	}
-
-	// Maps all the RPC messages which are to updated in altair.
-	altairMapping = map[string]string{
-		BeaconBlocksByRangeMessageName: SchemaVersionV2,
-		BeaconBlocksByRootsMessageName: SchemaVersionV2,
-		MetadataMessageName:            SchemaVersionV2,
-	}
-
-	// Maps all the RPC messages which are to updated in fulu.
-	fuluMapping = map[string]string{
-		MetadataMessageName: SchemaVersionV3,
-	}
-
-	versionMapping = map[string]bool{
-		SchemaVersionV1: true,
-		SchemaVersionV2: true,
-		SchemaVersionV3: true,
-	}
-
-	// OmitContextBytesV1 keeps track of which RPC methods do not write context bytes in their v1 incarnations.
-	// Phase0 did not have the notion of context bytes, which prefix wire-encoded values with a [4]byte identifier
-	// to convey the schema for the receiver to use. These RPCs had a version bump to V2 when the context byte encoding
-	// was introduced. For other RPC methods, context bytes are always required.
-	OmitContextBytesV1 = map[string]bool{
-		StatusMessageName:              true,
-		GoodbyeMessageName:             true,
-		BeaconBlocksByRangeMessageName: true,
-		BeaconBlocksByRootsMessageName: true,
-		PingMessageName:                true,
-		MetadataMessageName:            true,
-	}
-)
+// OmitContextBytesV1 keeps track of which RPC methods do not write context bytes in their v1 incarnations.
+// Phase0 did not have the notion of context bytes, which prefix wire-encoded values with a [4]byte identifier
+// to convey the schema for the receiver to use. These RPCs had a version bump to V2 when the context byte encoding
+// was introduced. For other RPC methods, context bytes are always required.
+var OmitContextBytesV1 = map[string]bool{
+	StatusMessageName:              true,
+	GoodbyeMessageName:             true,
+	BeaconBlocksByRangeMessageName: true,
+	BeaconBlocksByRootsMessageName: true,
+	PingMessageName:                true,
+	MetadataMessageName:            true,
+}
 
 // VerifyTopicMapping verifies that the topic and its accompanying
 // message type is correct.
@@ -344,17 +327,13 @@ func TopicFromMessage(msg string, epoch primitives.Epoch) (string, error) {
 	beaconConfig := params.BeaconConfig()
 
 	// Check if the message is to be updated in fulu.
-	if epoch >= beaconConfig.FuluForkEpoch {
-		if version, ok := fuluMapping[msg]; ok {
-			return protocolPrefix + msg + version, nil
-		}
+	if epoch >= beaconConfig.FuluForkEpoch && fuluMapping[msg] {
+		return protocolPrefix + msg + SchemaVersionV3, nil
 	}
 
 	// Check if the message is to be updated in altair.
-	if epoch >= beaconConfig.AltairForkEpoch {
-		if version, ok := altairMapping[msg]; ok {
-			return protocolPrefix + msg + version, nil
-		}
+	if epoch >= beaconConfig.AltairForkEpoch && altairMapping[msg] {
+		return protocolPrefix + msg + SchemaVersionV2, nil
 	}
 
 	return protocolPrefix + msg + SchemaVersionV1, nil

beacon-chain/p2p/rpc_topic_mappings_test.go

@@ -119,31 +119,50 @@ func TestTopicFromMessage_CorrectType(t *testing.T) {
 	})
 
 	t.Run("after altair fork but before fulu fork", func(t *testing.T) {
-		// Not modified in altair fork.
-		topic, err := TopicFromMessage(GoodbyeMessageName, altairForkEpoch)
-		require.NoError(t, err)
-		require.Equal(t, "/eth2/beacon_chain/req/goodbye/1", topic)
+		for m := range messageMapping {
+			topic, err := TopicFromMessage(m, altairForkEpoch)
+			require.NoError(t, err)
 
-		// Modified in altair fork.
-		topic, err = TopicFromMessage(MetadataMessageName, altairForkEpoch)
-		require.NoError(t, err)
-		require.Equal(t, "/eth2/beacon_chain/req/metadata/2", topic)
+			if altairMapping[m] {
+				require.Equal(t, true, strings.Contains(topic, SchemaVersionV2))
+				_, _, version, err := TopicDeconstructor(topic)
+				require.NoError(t, err)
+				require.Equal(t, SchemaVersionV2, version)
+				continue
+			}
+
+			require.Equal(t, true, strings.Contains(topic, SchemaVersionV1))
+			_, _, version, err := TopicDeconstructor(topic)
+			require.NoError(t, err)
+			require.Equal(t, SchemaVersionV1, version)
+		}
 	})
 
 	t.Run("after fulu fork", func(t *testing.T) {
-		// Not modified in any fork.
-		topic, err := TopicFromMessage(GoodbyeMessageName, fuluForkEpoch)
-		require.NoError(t, err)
-		require.Equal(t, "/eth2/beacon_chain/req/goodbye/1", topic)
+		for m := range messageMapping {
+			topic, err := TopicFromMessage(m, fuluForkEpoch)
+			require.NoError(t, err)
 
-		// Modified in altair fork.
-		topic, err = TopicFromMessage(BeaconBlocksByRangeMessageName, fuluForkEpoch)
-		require.NoError(t, err)
-		require.Equal(t, "/eth2/beacon_chain/req/beacon_blocks_by_range/2", topic)
+			if fuluMapping[m] {
+				require.Equal(t, true, strings.Contains(topic, SchemaVersionV3))
+				_, _, version, err := TopicDeconstructor(topic)
+				require.NoError(t, err)
+				require.Equal(t, SchemaVersionV3, version)
+				continue
+			}
 
-		// Modified both in altair and fulu fork.
-		topic, err = TopicFromMessage(MetadataMessageName, fuluForkEpoch)
-		require.NoError(t, err)
-		require.Equal(t, "/eth2/beacon_chain/req/metadata/3", topic)
+			if altairMapping[m] {
+				require.Equal(t, true, strings.Contains(topic, SchemaVersionV2))
+				_, _, version, err := TopicDeconstructor(topic)
+				require.NoError(t, err)
+				require.Equal(t, SchemaVersionV2, version)
+				continue
+			}
+
+			require.Equal(t, true, strings.Contains(topic, SchemaVersionV1))
+			_, _, version, err := TopicDeconstructor(topic)
+			require.NoError(t, err)
+			require.Equal(t, SchemaVersionV1, version)
+		}
 	})
 }

beacon-chain/p2p/types/types.go

@@ -213,7 +213,7 @@ func (s BlobSidecarsByRootReq) Len() int {
 // ====================================
 // DataColumnsByRootIdentifiers section
 // ====================================
-var _ ssz.Marshaler = DataColumnsByRootIdentifiers{}
+var _ ssz.Marshaler = (*DataColumnsByRootIdentifiers)(nil)
 var _ ssz.Unmarshaler = (*DataColumnsByRootIdentifiers)(nil)
 
 // DataColumnsByRootIdentifiers is used to specify a list of data column targets (root+index) in a DataColumnSidecarsByRoot RPC request.
@@ -275,33 +275,33 @@ func (d *DataColumnsByRootIdentifiers) UnmarshalSSZ(buf []byte) error {
 	return nil
 }
 
-func (d DataColumnsByRootIdentifiers) MarshalSSZ() ([]byte, error) {
+func (d *DataColumnsByRootIdentifiers) MarshalSSZ() ([]byte, error) {
 	var err error
-	count := len(d)
+	count := len(*d)
 	maxSize := params.BeaconConfig().MaxRequestBlocksDeneb
 	if uint64(count) > maxSize {
 		return nil, errors.Errorf("data column identifiers list exceeds max size: %d > %d", count, maxSize)
 	}
 
-	if len(d) == 0 {
+	if len(*d) == 0 {
 		return []byte{}, nil
 	}
 	sizes := make([]uint32, count)
 	valTotal := uint32(0)
-	for i, elem := range d {
+	for i, elem := range *d {
 		if elem == nil {
 			return nil, errors.New("nil item in DataColumnsByRootIdentifiers list")
 		}
 		sizes[i] = uint32(elem.SizeSSZ())
 		valTotal += sizes[i]
 	}
-	offSize := uint32(4 * len(d))
+	offSize := uint32(4 * len(*d))
 	out := make([]byte, offSize, offSize+valTotal)
 	for i := range sizes {
 		binary.LittleEndian.PutUint32(out[i*4:i*4+4], offSize)
 		offSize += sizes[i]
 	}
-	for _, elem := range d {
+	for _, elem := range *d {
 		out, err = elem.MarshalSSZTo(out)
 		if err != nil {
 			return nil, err
@@ -312,7 +312,7 @@ func (d DataColumnsByRootIdentifiers) MarshalSSZ() ([]byte, error) {
 }
 
 // MarshalSSZTo implements ssz.Marshaler. It appends the serialized DataColumnSidecarsByRootReq value to the provided byte slice.
-func (d DataColumnsByRootIdentifiers) MarshalSSZTo(dst []byte) ([]byte, error) {
+func (d *DataColumnsByRootIdentifiers) MarshalSSZTo(dst []byte) ([]byte, error) {
 	obj, err := d.MarshalSSZ()
 	if err != nil {
 		return nil, err
@@ -321,11 +321,11 @@ func (d DataColumnsByRootIdentifiers) MarshalSSZTo(dst []byte) ([]byte, error) {
 }
 
 // SizeSSZ implements ssz.Marshaler. It returns the size of the serialized representation.
-func (d DataColumnsByRootIdentifiers) SizeSSZ() int {
+func (d *DataColumnsByRootIdentifiers) SizeSSZ() int {
 	size := 0
-	for i := 0; i < len(d); i++ {
+	for i := 0; i < len(*d); i++ {
 		size += 4
-		size += (d)[i].SizeSSZ()
+		size += (*d)[i].SizeSSZ()
 	}
 	return size
 }

beacon-chain/rpc/endpoints.go

@@ -130,6 +130,7 @@ func (s *Service) rewardsEndpoints(blocker lookup.Blocker, stater lookup.Stater,
 			name:     namespace + ".BlockRewards",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.BlockRewards,
 			methods: []string{http.MethodGet},
@@ -140,6 +141,7 @@ func (s *Service) rewardsEndpoints(blocker lookup.Blocker, stater lookup.Stater,
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.AttestationRewards,
 			methods: []string{http.MethodPost},
@@ -150,6 +152,7 @@ func (s *Service) rewardsEndpoints(blocker lookup.Blocker, stater lookup.Stater,
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SyncCommitteeRewards,
 			methods: []string{http.MethodPost},
@@ -172,6 +175,7 @@ func (s *Service) builderEndpoints(stater lookup.Stater) []endpoint {
 			name:     namespace + ".ExpectedWithdrawals",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.ExpectedWithdrawals,
 			methods: []string{http.MethodGet},
@@ -194,6 +198,7 @@ func (s *Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
 			name:     namespace + ".Blobs",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.Blobs,
 			methods: []string{http.MethodGet},
@@ -237,6 +242,7 @@ func (s *Service) validatorEndpoints(
 			name:     namespace + ".GetAggregateAttestation",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetAggregateAttestation,
 			methods: []string{http.MethodGet},
@@ -246,6 +252,7 @@ func (s *Service) validatorEndpoints(
 			name:     namespace + ".GetAggregateAttestationV2",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetAggregateAttestationV2,
 			methods: []string{http.MethodGet},
@@ -256,6 +263,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitContributionAndProofs,
 			methods: []string{http.MethodPost},
@@ -267,6 +275,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitAggregateAndProofs,
 			methods: []string{http.MethodPost},
@@ -277,6 +286,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitAggregateAndProofsV2,
 			methods: []string{http.MethodPost},
@@ -286,6 +296,7 @@ func (s *Service) validatorEndpoints(
 			name:     namespace + ".ProduceSyncCommitteeContribution",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.ProduceSyncCommitteeContribution,
 			methods: []string{http.MethodGet},
@@ -296,6 +307,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitSyncCommitteeSubscription,
 			methods: []string{http.MethodPost},
@@ -306,6 +318,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitBeaconCommitteeSubscription,
 			methods: []string{http.MethodPost},
@@ -315,6 +328,7 @@ func (s *Service) validatorEndpoints(
 			name:     namespace + ".GetAttestationData",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetAttestationData,
 			methods: []string{http.MethodGet},
@@ -325,6 +339,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.RegisterValidator,
 			methods: []string{http.MethodPost},
@@ -335,6 +350,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetAttesterDuties,
 			methods: []string{http.MethodPost},
@@ -344,6 +360,7 @@ func (s *Service) validatorEndpoints(
 			name:     namespace + ".GetProposerDuties",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetProposerDuties,
 			methods: []string{http.MethodGet},
@@ -354,6 +371,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetSyncCommitteeDuties,
 			methods: []string{http.MethodPost},
@@ -364,6 +382,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.PrepareBeaconProposer,
 			methods: []string{http.MethodPost},
@@ -374,6 +393,7 @@ func (s *Service) validatorEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetLiveness,
 			methods: []string{http.MethodPost},
@@ -383,6 +403,7 @@ func (s *Service) validatorEndpoints(
 			name:     namespace + ".ProduceBlockV3",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.ProduceBlockV3,
 			methods: []string{http.MethodGet},
@@ -429,6 +450,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 			name:     namespace + ".GetSyncStatus",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetSyncStatus,
 			methods: []string{http.MethodGet},
@@ -438,6 +460,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 			name:     namespace + ".GetIdentity",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetIdentity,
 			methods: []string{http.MethodGet},
@@ -447,6 +470,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 			name:     namespace + ".GetPeer",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetPeer,
 			methods: []string{http.MethodGet},
@@ -456,6 +480,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 			name:     namespace + ".GetPeers",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetPeers,
 			methods: []string{http.MethodGet},
@@ -465,6 +490,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 			name:     namespace + ".GetPeerCount",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetPeerCount,
 			methods: []string{http.MethodGet},
@@ -474,6 +500,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 			name:     namespace + ".GetVersion",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetVersion,
 			methods: []string{http.MethodGet},
@@ -483,6 +510,7 @@ func (s *Service) nodeEndpoints() []endpoint {
 			name:     namespace + ".GetHealth",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetHealth,
 			methods: []string{http.MethodGet},
@@ -533,6 +561,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetCommittees",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetCommittees,
 			methods: []string{http.MethodGet},
@@ -542,6 +571,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetStateFork",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetStateFork,
 			methods: []string{http.MethodGet},
@@ -551,6 +581,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetStateRoot",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetStateRoot,
 			methods: []string{http.MethodGet},
@@ -560,6 +591,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetSyncCommittees",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetSyncCommittees,
 			methods: []string{http.MethodGet},
@@ -569,6 +601,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetRandao",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetRandao,
 			methods: []string{http.MethodGet},
@@ -580,6 +613,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.PublishBlock,
 			methods: []string{http.MethodPost},
@@ -591,6 +625,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.PublishBlindedBlock,
 			methods: []string{http.MethodPost},
@@ -601,6 +636,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.PublishBlockV2,
 			methods: []string{http.MethodPost},
@@ -611,6 +647,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.PublishBlindedBlockV2,
 			methods: []string{http.MethodPost},
@@ -620,6 +657,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetBlockV2",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetBlockV2,
 			methods: []string{http.MethodGet},
@@ -630,6 +668,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetBlockAttestations",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetBlockAttestations,
 			methods: []string{http.MethodGet},
@@ -639,6 +678,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetBlockAttestationsV2",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetBlockAttestationsV2,
 			methods: []string{http.MethodGet},
@@ -648,6 +688,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetBlindedBlock",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetBlindedBlock,
 			methods: []string{http.MethodGet},
@@ -657,6 +698,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetBlockRoot",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetBlockRoot,
 			methods: []string{http.MethodGet},
@@ -667,6 +709,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".ListAttestations",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.ListAttestations,
 			methods: []string{http.MethodGet},
@@ -676,6 +719,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".ListAttestationsV2",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.ListAttestationsV2,
 			methods: []string{http.MethodGet},
@@ -686,6 +730,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitAttestations,
 			methods: []string{http.MethodPost},
@@ -696,6 +741,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitAttestationsV2,
 			methods: []string{http.MethodPost},
@@ -705,6 +751,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".ListVoluntaryExits",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.ListVoluntaryExits,
 			methods: []string{http.MethodGet},
@@ -715,6 +762,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitVoluntaryExit,
 			methods: []string{http.MethodPost},
@@ -725,6 +773,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitSyncCommitteeSignatures,
 			methods: []string{http.MethodPost},
@@ -734,6 +783,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".ListBLSToExecutionChanges",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.ListBLSToExecutionChanges,
 			methods: []string{http.MethodGet},
@@ -744,6 +794,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitBLSToExecutionChanges,
 			methods: []string{http.MethodPost},
@@ -754,6 +805,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetAttesterSlashings",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetAttesterSlashings,
 			methods: []string{http.MethodGet},
@@ -763,6 +815,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetAttesterSlashingsV2",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetAttesterSlashingsV2,
 			methods: []string{http.MethodGet},
@@ -773,6 +826,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitAttesterSlashings,
 			methods: []string{http.MethodPost},
@@ -783,6 +837,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitAttesterSlashingsV2,
 			methods: []string{http.MethodPost},
@@ -792,6 +847,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetProposerSlashings",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetProposerSlashings,
 			methods: []string{http.MethodGet},
@@ -802,6 +858,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.SubmitProposerSlashing,
 			methods: []string{http.MethodPost},
@@ -811,6 +868,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetBlockHeaders",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetBlockHeaders,
 			methods: []string{http.MethodGet},
@@ -820,6 +878,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetBlockHeader",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetBlockHeader,
 			methods: []string{http.MethodGet},
@@ -829,6 +888,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetGenesis",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetGenesis,
 			methods: []string{http.MethodGet},
@@ -838,6 +898,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetFinalityCheckpoints",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetFinalityCheckpoints,
 			methods: []string{http.MethodGet},
@@ -848,6 +909,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetValidators,
 			methods: []string{http.MethodGet, http.MethodPost},
@@ -857,6 +919,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetValidator",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetValidator,
 			methods: []string{http.MethodGet},
@@ -867,6 +930,7 @@ func (s *Service) beaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetValidatorBalances,
 			methods: []string{http.MethodGet, http.MethodPost},
@@ -887,6 +951,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetDepositSnapshot",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetDepositSnapshot,
 			methods: []string{http.MethodGet},
@@ -896,6 +961,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetPendingDeposits",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetPendingDeposits,
 			methods: []string{http.MethodGet},
@@ -914,6 +980,7 @@ func (s *Service) beaconEndpoints(
 			name:     namespace + ".GetPendingPartialWithdrawals",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetPendingPartialWithdrawals,
 			methods: []string{http.MethodGet},
@@ -929,6 +996,7 @@ func (*Service) configEndpoints() []endpoint {
 			name:     namespace + ".GetDepositContract",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: config.GetDepositContract,
 			methods: []string{http.MethodGet},
@@ -938,6 +1006,7 @@ func (*Service) configEndpoints() []endpoint {
 			name:     namespace + ".GetForkSchedule",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: config.GetForkSchedule,
 			methods: []string{http.MethodGet},
@@ -947,6 +1016,7 @@ func (*Service) configEndpoints() []endpoint {
 			name:     namespace + ".GetSpec",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: config.GetSpec,
 			methods: []string{http.MethodGet},
@@ -971,6 +1041,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 			name:     namespace + ".GetLightClientBootstrap",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetLightClientBootstrap,
 			methods: []string{http.MethodGet},
@@ -980,6 +1051,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 			name:     namespace + ".GetLightClientUpdatesByRange",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetLightClientUpdatesByRange,
 			methods: []string{http.MethodGet},
@@ -989,6 +1061,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 			name:     namespace + ".GetLightClientFinalityUpdate",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetLightClientFinalityUpdate,
 			methods: []string{http.MethodGet},
@@ -998,6 +1071,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 			name:     namespace + ".GetLightClientOptimisticUpdate",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetLightClientOptimisticUpdate,
 			methods: []string{http.MethodGet},
@@ -1024,6 +1098,7 @@ func (s *Service) debugEndpoints(stater lookup.Stater) []endpoint {
 			name:     namespace + ".GetBeaconStateV2",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetBeaconStateV2,
 			methods: []string{http.MethodGet},
@@ -1033,6 +1108,7 @@ func (s *Service) debugEndpoints(stater lookup.Stater) []endpoint {
 			name:     namespace + ".GetForkChoiceHeadsV2",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetForkChoiceHeadsV2,
 			methods: []string{http.MethodGet},
@@ -1042,6 +1118,7 @@ func (s *Service) debugEndpoints(stater lookup.Stater) []endpoint {
 			name:     namespace + ".GetForkChoice",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetForkChoice,
 			methods: []string{http.MethodGet},
@@ -1066,6 +1143,7 @@ func (s *Service) eventsEndpoints() []endpoint {
 			name:     namespace + ".StreamEvents",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.EventStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.StreamEvents,
 			methods: []string{http.MethodGet},
@@ -1101,6 +1179,7 @@ func (s *Service) prysmBeaconEndpoints(
 			name:     namespace + ".GetWeakSubjectivity",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetWeakSubjectivity,
 			methods: []string{http.MethodGet},
@@ -1110,6 +1189,7 @@ func (s *Service) prysmBeaconEndpoints(
 			name:     namespace + ".GetValidatorCount",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetValidatorCount,
 			methods: []string{http.MethodGet},
@@ -1119,6 +1199,7 @@ func (s *Service) prysmBeaconEndpoints(
 			name:     namespace + ".GetValidatorCount",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetValidatorCount,
 			methods: []string{http.MethodGet},
@@ -1129,6 +1210,7 @@ func (s *Service) prysmBeaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetIndividualVotes,
 			methods: []string{http.MethodPost},
@@ -1138,6 +1220,7 @@ func (s *Service) prysmBeaconEndpoints(
 			name:     namespace + ".GetChainHead",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetChainHead,
 			methods: []string{http.MethodGet},
@@ -1148,6 +1231,7 @@ func (s *Service) prysmBeaconEndpoints(
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.PublishBlobs,
 			methods: []string{http.MethodPost},
@@ -1175,6 +1259,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 			name:     namespace + ".ListTrustedPeer",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.ListTrustedPeer,
 			methods: []string{http.MethodGet},
@@ -1184,6 +1269,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 			name:     namespace + ".ListTrustedPeer",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.ListTrustedPeer,
 			methods: []string{http.MethodGet},
@@ -1194,6 +1280,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.AddTrustedPeer,
 			methods: []string{http.MethodPost},
@@ -1204,6 +1291,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.AddTrustedPeer,
 			methods: []string{http.MethodPost},
@@ -1213,6 +1301,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 			name:     namespace + ".RemoveTrustedPeer",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.RemoveTrustedPeer,
 			methods: []string{http.MethodDelete},
@@ -1222,6 +1311,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 			name:     namespace + ".RemoveTrustedPeer",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.RemoveTrustedPeer,
 			methods: []string{http.MethodDelete},
@@ -1244,6 +1334,7 @@ func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *cor
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetPerformance,
 			methods: []string{http.MethodPost},
@@ -1254,6 +1345,7 @@ func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *cor
 			middleware: []middleware.Middleware{
 				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetPerformance,
 			methods: []string{http.MethodPost},
@@ -1263,6 +1355,7 @@ func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *cor
 			name:     namespace + ".GetParticipation",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetParticipation,
 			methods: []string{http.MethodGet},
@@ -1272,6 +1365,7 @@ func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *cor
 			name:     namespace + ".GetActiveSetChanges",
 			middleware: []middleware.Middleware{
 				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
 			},
 			handler: server.GetActiveSetChanges,
 			methods: []string{http.MethodGet},

beacon-chain/rpc/lookup/BUILD.bazel

@@ -10,13 +10,11 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/blockchain:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -38,9 +36,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
@@ -49,7 +45,6 @@ go_test(
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/state/stategen/mock:go_default_library",
         "//beacon-chain/verification:go_default_library",
-        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",

beacon-chain/rpc/lookup/blocker.go

@@ -3,15 +3,12 @@ package lookup
 import (
 	"context"
 	"fmt"
-	"math"
 	"strconv"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/core"
-	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
@@ -52,7 +49,6 @@ type BeaconDbBlocker struct {
 	ChainInfoFetcher   blockchain.ChainInfoFetcher
 	GenesisTimeFetcher blockchain.TimeFetcher
 	BlobStorage        *filesystem.BlobStorage
-	DataColumnStorage  *filesystem.DataColumnStorage
 }
 
 // Block returns the beacon block for a given identifier. The identifier can be one of:
@@ -216,190 +212,64 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []int) (
 
 	root := bytesutil.ToBytes32(rootSlice)
 
-	roSignedBlock, err := p.BeaconDB.Block(ctx, root)
+	b, err := p.BeaconDB.Block(ctx, root)
 	if err != nil {
 		return nil, &core.RpcError{Err: errors.Wrapf(err, "failed to retrieve block %#x from db", rootSlice), Reason: core.Internal}
 	}
-
-	if roSignedBlock == nil {
+	if b == nil {
 		return nil, &core.RpcError{Err: fmt.Errorf("block %#x not found in db", rootSlice), Reason: core.NotFound}
 	}
 
-	// If block is not in the retention window, return 200 w/ empty list
-	if !p.BlobStorage.WithinRetentionPeriod(slots.ToEpoch(roSignedBlock.Block().Slot()), slots.ToEpoch(p.GenesisTimeFetcher.CurrentSlot())) {
+	// if block is not in the retention window, return 200 w/ empty list
+	if !p.BlobStorage.WithinRetentionPeriod(slots.ToEpoch(b.Block().Slot()), slots.ToEpoch(p.GenesisTimeFetcher.CurrentSlot())) {
 		return make([]*blocks.VerifiedROBlob, 0), nil
 	}
 
-	roBlock := roSignedBlock.Block()
-
-	commitments, err := roBlock.Body().BlobKzgCommitments()
+	commitments, err := b.Block().Body().BlobKzgCommitments()
 	if err != nil {
 		return nil, &core.RpcError{Err: errors.Wrapf(err, "failed to retrieve kzg commitments from block %#x", rootSlice), Reason: core.Internal}
 	}
-
-	// If there are no commitments return 200 w/ empty list
+	// if there are no commitments return 200 w/ empty list
 	if len(commitments) == 0 {
 		return make([]*blocks.VerifiedROBlob, 0), nil
 	}
 
-	// Compute the first Fulu slot.
-	fuluForkEpoch := params.BeaconConfig().FuluForkEpoch
-	fuluForkSlot := primitives.Slot(math.MaxUint64)
-	if fuluForkEpoch != primitives.Epoch(math.MaxUint64) {
-		fuluForkSlot, err = slots.EpochStart(fuluForkEpoch)
-		if err != nil {
-			return nil, &core.RpcError{Err: errors.Wrap(err, "could not calculate peerDAS start slot"), Reason: core.Internal}
-		}
-	}
+	sum := p.BlobStorage.Summary(root)
 
-	if roBlock.Slot() >= fuluForkSlot {
-		roBlock, err := blocks.NewROBlockWithRoot(roSignedBlock, root)
-		if err != nil {
-			return nil, &core.RpcError{Err: errors.Wrapf(err, "failed to create roBlock with root %#x", root), Reason: core.Internal}
-		}
-
-		return p.blobsFromStoredDataColumns(roBlock, indices)
-	}
-
-	return p.blobsFromStoredBlobs(commitments, root, indices)
-}
-
-// blobsFromStoredBlobs retrieves blob sidercars corresponding to `indices` and `root` from the store.
-// This function expects blob sidecars to be stored (aka. no data column sidecars).
-func (p *BeaconDbBlocker) blobsFromStoredBlobs(commitments [][]byte, root [fieldparams.RootLength]byte, indices []int) ([]*blocks.VerifiedROBlob, *core.RpcError) {
-	summary := p.BlobStorage.Summary(root)
-	maxBlobCount := summary.MaxBlobsForEpoch()
-
-	for _, index := range indices {
-		if uint64(index) >= maxBlobCount {
-			return nil, &core.RpcError{
-				Err:    fmt.Errorf("requested index %d is bigger than the maximum possible blob count %d", index, maxBlobCount),
-				Reason: core.BadRequest,
-			}
-		}
-
-		if !summary.HasIndex(uint64(index)) {
-			return nil, &core.RpcError{
-				Err:    fmt.Errorf("requested index %d not found", index),
-				Reason: core.NotFound,
-			}
-		}
-	}
-
-	// If no indices are provided, use all indices that are available in the summary.
 	if len(indices) == 0 {
-		for index := range commitments {
-			if summary.HasIndex(uint64(index)) {
-				indices = append(indices, index)
+		for i := range commitments {
+			if sum.HasIndex(uint64(i)) {
+				indices = append(indices, i)
+			}
+		}
+	} else {
+		for _, ix := range indices {
+			if uint64(ix) >= sum.MaxBlobsForEpoch() {
+				return nil, &core.RpcError{
+					Err:    fmt.Errorf("requested index %d is bigger than the maximum possible blob count %d", ix, sum.MaxBlobsForEpoch()),
+					Reason: core.BadRequest,
+				}
+			}
+			if !sum.HasIndex(uint64(ix)) {
+				return nil, &core.RpcError{
+					Err:    fmt.Errorf("requested index %d not found", ix),
+					Reason: core.NotFound,
+				}
 			}
 		}
 	}
 
-	// Retrieve blob sidecars from the store.
-	blobs := make([]*blocks.VerifiedROBlob, 0, len(indices))
-	for _, index := range indices {
-		blobSidecar, err := p.BlobStorage.Get(root, uint64(index))
+	blobs := make([]*blocks.VerifiedROBlob, len(indices))
+	for i, index := range indices {
+		vblob, err := p.BlobStorage.Get(root, uint64(index))
 		if err != nil {
 			return nil, &core.RpcError{
-				Err:    fmt.Errorf("could not retrieve blob for block root %#x at index %d", root, index),
+				Err:    fmt.Errorf("could not retrieve blob for block root %#x at index %d", rootSlice, index),
 				Reason: core.Internal,
 			}
 		}
-
-		blobs = append(blobs, &blobSidecar)
+		blobs[i] = &vblob
 	}
 
 	return blobs, nil
 }
-
-// blobsFromStoredDataColumns retrieves data column sidecars from the store,
-// reconstructs the whole matrix if needed, converts the matrix to blobs,
-// and then returns converted blobs corresponding to `indices` and `root`.
-// This function expects data column sidecars to be stored (aka. no blob sidecars).
-// If not enough data column sidecars are available to convert blobs from them
-// (either directly or after reconstruction), an error is returned.
-func (p *BeaconDbBlocker) blobsFromStoredDataColumns(block blocks.ROBlock, indices []int) ([]*blocks.VerifiedROBlob, *core.RpcError) {
-	root := block.Root()
-
-	// Use all indices if none are provided.
-	if len(indices) == 0 {
-		commitments, err := block.Block().Body().BlobKzgCommitments()
-		if err != nil {
-			return nil, &core.RpcError{
-				Err:    errors.Wrap(err, "could not retrieve blob commitments"),
-				Reason: core.Internal,
-			}
-		}
-
-		for index := range commitments {
-			indices = append(indices, index)
-		}
-	}
-
-	// Count how many columns we have in the store.
-	summary := p.DataColumnStorage.Summary(root)
-	stored := summary.Stored()
-	count := uint64(len(stored))
-
-	if count < peerdas.MinimumColumnsCountToReconstruct() {
-		// There is no way to reconstruct the data columns.
-		return nil, &core.RpcError{
-			Err:    errors.Errorf("the node does not custody enough data columns to reconstruct blobs - please start the beacon node with the `--%s` flag to ensure this call to succeed, or retry later if it is already the case", flags.SubscribeAllDataSubnets.Name),
-			Reason: core.NotFound,
-		}
-	}
-
-	// Retrieve from the database needed data columns.
-	verifiedRoDataColumnSidecars, err := p.neededDataColumnSidecars(root, stored)
-	if err != nil {
-		return nil, &core.RpcError{
-			Err:    errors.Wrap(err, "needed data column sidecars"),
-			Reason: core.Internal,
-		}
-	}
-
-	// Reconstruct blob sidecars from data column sidecars.
-	verifiedRoBlobSidecars, err := peerdas.ReconstructBlobs(block, verifiedRoDataColumnSidecars, indices)
-	if err != nil {
-		return nil, &core.RpcError{
-			Err:    errors.Wrap(err, "blobs from data columns"),
-			Reason: core.Internal,
-		}
-	}
-
-	return verifiedRoBlobSidecars, nil
-}
-
-// neededDataColumnSidecars retrieves all data column sidecars corresponding to (non extended) blobs if available,
-// else retrieves all data column sidecars from the store.
-func (p *BeaconDbBlocker) neededDataColumnSidecars(root [fieldparams.RootLength]byte, stored map[uint64]bool) ([]blocks.VerifiedRODataColumn, error) {
-	// Check if we have all the non-extended data columns.
-	cellsPerBlob := fieldparams.CellsPerBlob
-	blobIndices := make([]uint64, 0, cellsPerBlob)
-	hasAllBlobColumns := true
-	for i := range uint64(cellsPerBlob) {
-		if !stored[i] {
-			hasAllBlobColumns = false
-			break
-		}
-		blobIndices = append(blobIndices, i)
-	}
-
-	if hasAllBlobColumns {
-		// Retrieve only the non-extended data columns.
-		verifiedRoSidecars, err := p.DataColumnStorage.Get(root, blobIndices)
-		if err != nil {
-			return nil, errors.Wrap(err, "data columns storage get")
-		}
-
-		return verifiedRoSidecars, nil
-	}
-
-	// Retrieve all the data columns.
-	verifiedRoSidecars, err := p.DataColumnStorage.Get(root, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "data columns storage get")
-	}
-
-	return verifiedRoSidecars, nil
-}

beacon-chain/rpc/lookup/blocker_test.go

@@ -8,15 +8,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	mockChain "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/core"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/testutil"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
@@ -161,335 +158,172 @@ func TestGetBlock(t *testing.T) {
 }
 
 func TestGetBlob(t *testing.T) {
-	const (
-		slot          = 123
-		blobCount     = 4
-		denebForEpoch = 1
-		fuluForkEpoch = 2
-	)
-
-	setupDeneb := func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		cfg := params.BeaconConfig().Copy()
-		cfg.DenebForkEpoch = denebForEpoch
-		params.OverrideBeaconConfig(cfg)
-	}
-
-	setupFulu := func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		cfg := params.BeaconConfig().Copy()
-		cfg.DenebForkEpoch = denebForEpoch
-		cfg.FuluForkEpoch = fuluForkEpoch
-		params.OverrideBeaconConfig(cfg)
-	}
-
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.DenebForkEpoch = 1
+	params.OverrideBeaconConfig(cfg)
 	ctx := t.Context()
 	db := testDB.SetupDB(t)
-
-	// Start the trusted setup.
-	err := kzg.Start()
-	require.NoError(t, err)
-
-	// Create and save Deneb block and blob sidecars.
-	_, blobStorage := filesystem.NewEphemeralBlobStorageAndFs(t)
-
-	denebBlock, storedBlobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [fieldparams.RootLength]byte{}, slot, blobCount)
-	denebBlockRoot := denebBlock.Root()
-
-	verifiedStoredSidecars := verification.FakeVerifySliceForTest(t, storedBlobSidecars)
-	for i := range verifiedStoredSidecars {
-		err := blobStorage.Save(verifiedStoredSidecars[i])
-		require.NoError(t, err)
+	denebBlock, blobs := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 123, 4)
+	require.NoError(t, db.SaveBlock(t.Context(), denebBlock))
+	_, bs := filesystem.NewEphemeralBlobStorageAndFs(t)
+	testSidecars := verification.FakeVerifySliceForTest(t, blobs)
+	for i := range testSidecars {
+		require.NoError(t, bs.Save(testSidecars[i]))
 	}
-
-	err = db.SaveBlock(t.Context(), denebBlock)
-	require.NoError(t, err)
-
-	// Create Electra block and blob sidecars. (Electra block = Fulu block),
-	// save the block, convert blob sidecars to data column sidecars and save the block.
-	fuluForkSlot := fuluForkEpoch * params.BeaconConfig().SlotsPerEpoch
-	fuluBlock, fuluBlobSidecars := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, fuluForkSlot, blobCount)
-	fuluBlockRoot := fuluBlock.Root()
-
-	cellsAndProofsList := make([]kzg.CellsAndProofs, 0, len(fuluBlobSidecars))
-	for _, blob := range fuluBlobSidecars {
-		var kzgBlob kzg.Blob
-		copy(kzgBlob[:], blob.Blob)
-		cellsAndProogs, err := kzg.ComputeCellsAndKZGProofs(&kzgBlob)
-		require.NoError(t, err)
-		cellsAndProofsList = append(cellsAndProofsList, cellsAndProogs)
-	}
-
-	dataColumnSidecarPb, err := peerdas.DataColumnSidecars(fuluBlock, cellsAndProofsList)
-	require.NoError(t, err)
-
-	verifiedRoDataColumnSidecars := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecarPb))
-	for _, sidecarPb := range dataColumnSidecarPb {
-		roDataColumn, err := blocks.NewRODataColumnWithRoot(sidecarPb, fuluBlockRoot)
-		require.NoError(t, err)
-
-		verifiedRoDataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
-		verifiedRoDataColumnSidecars = append(verifiedRoDataColumnSidecars, verifiedRoDataColumn)
-	}
-
-	err = db.SaveBlock(t.Context(), fuluBlock)
-	require.NoError(t, err)
-
+	blockRoot := blobs[0].BlockRoot()
 	t.Run("genesis", func(t *testing.T) {
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{}
 		_, rpcErr := blocker.Blobs(ctx, "genesis", nil)
-		require.Equal(t, http.StatusBadRequest, core.ErrorReasonToHTTP(rpcErr.Reason))
-		require.StringContains(t, "blobs are not supported for Phase 0 fork", rpcErr.Err.Error())
+		assert.Equal(t, http.StatusBadRequest, core.ErrorReasonToHTTP(rpcErr.Reason))
+		assert.StringContains(t, "blobs are not supported for Phase 0 fork", rpcErr.Err.Error())
 	})
-
 	t.Run("head", func(t *testing.T) {
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{Root: denebBlockRoot[:]},
+			ChainInfoFetcher: &mockChain.ChainService{Root: blockRoot[:]},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: blobStorage,
-		}
-
-		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "head", nil)
-		require.IsNil(t, rpcErr)
-		require.Equal(t, blobCount, len(retrievedVerifiedSidecars))
-
-		for i := range blobCount {
-			expected := verifiedStoredSidecars[i]
-
-			actual := retrievedVerifiedSidecars[i].BlobSidecar
-			require.NotNil(t, actual)
-
-			require.Equal(t, expected.Index, actual.Index)
-			require.DeepEqual(t, expected.Blob, actual.Blob)
-			require.DeepEqual(t, expected.KzgCommitment, actual.KzgCommitment)
-			require.DeepEqual(t, expected.KzgProof, actual.KzgProof)
+			BlobStorage: bs,
 		}
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "head", nil)
+		assert.Equal(t, rpcErr == nil, true)
+		require.Equal(t, 4, len(verifiedBlobs))
+		sidecar := verifiedBlobs[0].BlobSidecar
+		require.NotNil(t, sidecar)
+		assert.Equal(t, uint64(0), sidecar.Index)
+		assert.DeepEqual(t, blobs[0].Blob, sidecar.Blob)
+		assert.DeepEqual(t, blobs[0].KzgCommitment, sidecar.KzgCommitment)
+		assert.DeepEqual(t, blobs[0].KzgProof, sidecar.KzgProof)
+		sidecar = verifiedBlobs[1].BlobSidecar
+		require.NotNil(t, sidecar)
+		assert.Equal(t, uint64(1), sidecar.Index)
+		assert.DeepEqual(t, blobs[1].Blob, sidecar.Blob)
+		assert.DeepEqual(t, blobs[1].KzgCommitment, sidecar.KzgCommitment)
+		assert.DeepEqual(t, blobs[1].KzgProof, sidecar.KzgProof)
+		sidecar = verifiedBlobs[2].BlobSidecar
+		require.NotNil(t, sidecar)
+		assert.Equal(t, uint64(2), sidecar.Index)
+		assert.DeepEqual(t, blobs[2].Blob, sidecar.Blob)
+		assert.DeepEqual(t, blobs[2].KzgCommitment, sidecar.KzgCommitment)
+		assert.DeepEqual(t, blobs[2].KzgProof, sidecar.KzgProof)
+		sidecar = verifiedBlobs[3].BlobSidecar
+		require.NotNil(t, sidecar)
+		assert.Equal(t, uint64(3), sidecar.Index)
+		assert.DeepEqual(t, blobs[3].Blob, sidecar.Blob)
+		assert.DeepEqual(t, blobs[3].KzgCommitment, sidecar.KzgCommitment)
+		assert.DeepEqual(t, blobs[3].KzgProof, sidecar.KzgProof)
 	})
-
 	t.Run("finalized", func(t *testing.T) {
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: blockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: blobStorage,
+			BlobStorage: bs,
 		}
 
-		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "finalized", nil)
-		require.IsNil(t, rpcErr)
-		require.Equal(t, blobCount, len(verifiedSidecars))
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "finalized", nil)
+		assert.Equal(t, rpcErr == nil, true)
+		require.Equal(t, 4, len(verifiedBlobs))
 	})
-
 	t.Run("justified", func(t *testing.T) {
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{CurrentJustifiedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{CurrentJustifiedCheckPoint: &ethpb.Checkpoint{Root: blockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: blobStorage,
+			BlobStorage: bs,
 		}
 
-		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "justified", nil)
-		require.IsNil(t, rpcErr)
-		require.Equal(t, blobCount, len(verifiedSidecars))
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "justified", nil)
+		assert.Equal(t, rpcErr == nil, true)
+		require.Equal(t, 4, len(verifiedBlobs))
 	})
-
 	t.Run("root", func(t *testing.T) {
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: blobStorage,
+			BlobStorage: bs,
 		}
-
-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(denebBlockRoot[:]), nil)
-		require.IsNil(t, rpcErr)
-		require.Equal(t, blobCount, len(verifiedBlobs))
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(blockRoot[:]), nil)
+		assert.Equal(t, rpcErr == nil, true)
+		require.Equal(t, 4, len(verifiedBlobs))
 	})
-
 	t.Run("slot", func(t *testing.T) {
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: blobStorage,
+			BlobStorage: bs,
 		}
-
 		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123", nil)
-		require.IsNil(t, rpcErr)
-		require.Equal(t, blobCount, len(verifiedBlobs))
+		assert.Equal(t, rpcErr == nil, true)
+		require.Equal(t, 4, len(verifiedBlobs))
 	})
-
 	t.Run("one blob only", func(t *testing.T) {
-		const index = 2
-
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: blockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: blobStorage,
+			BlobStorage: bs,
 		}
-
-		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "123", []int{index})
-		require.IsNil(t, rpcErr)
-		require.Equal(t, 1, len(retrievedVerifiedSidecars))
-
-		expected := verifiedStoredSidecars[index]
-		actual := retrievedVerifiedSidecars[0].BlobSidecar
-		require.NotNil(t, actual)
-
-		require.Equal(t, uint64(index), actual.Index)
-		require.DeepEqual(t, expected.Blob, actual.Blob)
-		require.DeepEqual(t, expected.KzgCommitment, actual.KzgCommitment)
-		require.DeepEqual(t, expected.KzgProof, actual.KzgProof)
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123", []int{2})
+		assert.Equal(t, rpcErr == nil, true)
+		require.Equal(t, 1, len(verifiedBlobs))
+		sidecar := verifiedBlobs[0].BlobSidecar
+		require.NotNil(t, sidecar)
+		assert.Equal(t, uint64(2), sidecar.Index)
+		assert.DeepEqual(t, blobs[2].Blob, sidecar.Blob)
+		assert.DeepEqual(t, blobs[2].KzgCommitment, sidecar.KzgCommitment)
+		assert.DeepEqual(t, blobs[2].KzgProof, sidecar.KzgProof)
 	})
-
 	t.Run("no blobs returns an empty array", func(t *testing.T) {
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: blockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
 			BlobStorage: filesystem.NewEphemeralBlobStorage(t),
 		}
-
 		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123", nil)
-		require.IsNil(t, rpcErr)
+		assert.Equal(t, rpcErr == nil, true)
 		require.Equal(t, 0, len(verifiedBlobs))
 	})
-
 	t.Run("no blob at index", func(t *testing.T) {
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: blockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: blobStorage,
+			BlobStorage: bs,
 		}
-
-		noBlobIndex := len(storedBlobSidecars) + 1
+		noBlobIndex := len(blobs) + 1
 		_, rpcErr := blocker.Blobs(ctx, "123", []int{0, noBlobIndex})
 		require.NotNil(t, rpcErr)
-		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
+		assert.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
 	})
-
 	t.Run("index too big", func(t *testing.T) {
-		setupDeneb(t)
-
 		blocker := &BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: blockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: blobStorage,
+			BlobStorage: bs,
 		}
 		_, rpcErr := blocker.Blobs(ctx, "123", []int{0, math.MaxInt})
 		require.NotNil(t, rpcErr)
-		require.Equal(t, core.ErrorReason(core.BadRequest), rpcErr.Reason)
-	})
-
-	t.Run("not enough stored data column sidecars", func(t *testing.T) {
-		setupFulu(t)
-
-		_, dataColumnStorage := filesystem.NewEphemeralDataColumnStorageAndFs(t)
-		err = dataColumnStorage.Save(verifiedRoDataColumnSidecars[:fieldparams.CellsPerBlob-1])
-		require.NoError(t, err)
-
-		blocker := &BeaconDbBlocker{
-			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
-				Genesis: time.Now(),
-			},
-			BeaconDB:          db,
-			BlobStorage:       blobStorage,
-			DataColumnStorage: dataColumnStorage,
-		}
-
-		_, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]), nil)
-		require.NotNil(t, rpcErr)
-		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
-	})
-
-	t.Run("reconstruction needed", func(t *testing.T) {
-		setupFulu(t)
-
-		_, dataColumnStorage := filesystem.NewEphemeralDataColumnStorageAndFs(t)
-		err = dataColumnStorage.Save(verifiedRoDataColumnSidecars[1 : peerdas.MinimumColumnsCountToReconstruct()+1])
-		require.NoError(t, err)
-
-		blocker := &BeaconDbBlocker{
-			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
-				Genesis: time.Now(),
-			},
-			BeaconDB:          db,
-			BlobStorage:       blobStorage,
-			DataColumnStorage: dataColumnStorage,
-		}
-
-		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]), nil)
-		require.IsNil(t, rpcErr)
-		require.Equal(t, len(fuluBlobSidecars), len(retrievedVerifiedRoBlobs))
-
-		for i, retrievedVerifiedRoBlob := range retrievedVerifiedRoBlobs {
-			retrievedBlobSidecarPb := retrievedVerifiedRoBlob.BlobSidecar
-			initialBlobSidecarPb := fuluBlobSidecars[i].BlobSidecar
-			require.DeepSSZEqual(t, initialBlobSidecarPb, retrievedBlobSidecarPb)
-		}
-	})
-
-	t.Run("no reconstruction needed", func(t *testing.T) {
-		setupFulu(t)
-
-		_, dataColumnStorage := filesystem.NewEphemeralDataColumnStorageAndFs(t)
-		err = dataColumnStorage.Save(verifiedRoDataColumnSidecars)
-		require.NoError(t, err)
-
-		blocker := &BeaconDbBlocker{
-			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
-				Genesis: time.Now(),
-			},
-			BeaconDB:          db,
-			BlobStorage:       blobStorage,
-			DataColumnStorage: dataColumnStorage,
-		}
-
-		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]), nil)
-		require.IsNil(t, rpcErr)
-		require.Equal(t, len(fuluBlobSidecars), len(retrievedVerifiedRoBlobs))
-
-		for i, retrievedVerifiedRoBlob := range retrievedVerifiedRoBlobs {
-			retrievedBlobSidecarPb := retrievedVerifiedRoBlob.BlobSidecar
-			initialBlobSidecarPb := fuluBlobSidecars[i].BlobSidecar
-			require.DeepSSZEqual(t, initialBlobSidecarPb, retrievedBlobSidecarPb)
-		}
+		assert.Equal(t, core.ErrorReason(core.BadRequest), rpcErr.Reason)
 	})
 }

beacon-chain/sync/BUILD.bazel

@@ -25,7 +25,6 @@ go_library(
         "rpc_blob_sidecars_by_range.go",
         "rpc_blob_sidecars_by_root.go",
         "rpc_chunked_response.go",
-        "rpc_data_column_sidecars_by_range.go",
         "rpc_data_column_sidecars_by_root.go",
         "rpc_goodbye.go",
         "rpc_light_client.go",
@@ -172,7 +171,6 @@ go_test(
         "rpc_beacon_blocks_by_root_test.go",
         "rpc_blob_sidecars_by_range_test.go",
         "rpc_blob_sidecars_by_root_test.go",
-        "rpc_data_column_sidecars_by_range_test.go",
         "rpc_data_column_sidecars_by_root_test.go",
         "rpc_goodbye_test.go",
         "rpc_handler_test.go",
@@ -284,7 +282,6 @@ go_test(
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@com_github_stretchr_testify//require:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/sync/metrics.go

@@ -89,13 +89,6 @@ var (
 			Buckets: []float64{5, 10, 50, 100, 150, 250, 500, 1000, 2000},
 		},
 	)
-	rpcDataColumnsByRangeResponseLatency = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "rpc_data_columns_by_range_response_latency_milliseconds",
-			Help:    "Captures total time to respond to rpc DataColumnsByRange requests in a milliseconds distribution",
-			Buckets: []float64{5, 10, 50, 100, 150, 250, 500, 1000, 2000},
-		},
-	)
 	arrivalBlockPropagationHistogram = promauto.NewHistogram(
 		prometheus.HistogramOpts{
 			Name:    "block_arrival_latency_milliseconds",

beacon-chain/sync/rate_limiter.go

@@ -47,10 +47,6 @@ func newRateLimiter(p2pProvider p2p.P2P) *limiter {
 	allowedBlobsPerSecond := float64(flags.Get().BlobBatchLimit)
 	allowedBlobsBurst := int64(flags.Get().BlobBatchLimitBurstFactor * flags.Get().BlobBatchLimit)
 
-	// Initialize data column limits.
-	allowedDataColumnsPerSecond := float64(flags.Get().DataColumnBatchLimit)
-	allowedDataColumnsBurst := int64(flags.Get().DataColumnBatchLimitBurstFactor * flags.Get().DataColumnBatchLimit)
-
 	// Set topic map for all rpc topics.
 	topicMap := make(map[string]*leakybucket.Collector, len(p2p.RPCTopicMappings))
 	// Goodbye Message
@@ -71,9 +67,6 @@ func newRateLimiter(p2pProvider p2p.P2P) *limiter {
 	// for BlobSidecarsByRoot and BlobSidecarsByRange
 	blobCollector := leakybucket.NewCollector(allowedBlobsPerSecond, allowedBlobsBurst, blockBucketPeriod, false)
 
-	// for DataColumnSidecarsByRoot and DataColumnSidecarsByRange
-	dataColumnSidecars := leakybucket.NewCollector(allowedDataColumnsPerSecond, allowedDataColumnsBurst, blockBucketPeriod, false)
-
 	// BlocksByRoots requests
 	topicMap[addEncoding(p2p.RPCBlocksByRootTopicV1)] = blockCollector
 	topicMap[addEncoding(p2p.RPCBlocksByRootTopicV2)] = blockCollectorV2
@@ -93,11 +86,6 @@ func newRateLimiter(p2pProvider p2p.P2P) *limiter {
 	topicMap[addEncoding(p2p.RPCLightClientOptimisticUpdateTopicV1)] = leakybucket.NewCollector(1, defaultBurstLimit, leakyBucketPeriod, false /* deleteEmptyBuckets */)
 	topicMap[addEncoding(p2p.RPCLightClientFinalityUpdateTopicV1)] = leakybucket.NewCollector(1, defaultBurstLimit, leakyBucketPeriod, false /* deleteEmptyBuckets */)
 
-	// DataColumnSidecarsByRootV1
-	topicMap[addEncoding(p2p.RPCDataColumnSidecarsByRootTopicV1)] = dataColumnSidecars
-	// DataColumnSidecarsByRangeV1
-	topicMap[addEncoding(p2p.RPCDataColumnSidecarsByRangeTopicV1)] = dataColumnSidecars
-
 	// General topic for all rpc requests.
 	topicMap[rpcLimiterTopic] = leakybucket.NewCollector(5, defaultBurstLimit*2, leakyBucketPeriod, false /* deleteEmptyBuckets */)
 

beacon-chain/sync/rate_limiter_test.go

@@ -17,7 +17,7 @@ import (
 
 func TestNewRateLimiter(t *testing.T) {
 	rlimiter := newRateLimiter(mockp2p.NewTestP2P(t))
-	assert.Equal(t, len(rlimiter.limiterMap), 18, "correct number of topics not registered")
+	assert.Equal(t, len(rlimiter.limiterMap), 16, "correct number of topics not registered")
 }
 
 func TestNewRateLimiter_FreeCorrectly(t *testing.T) {

beacon-chain/sync/rpc.go

@@ -42,15 +42,15 @@ func (s *Service) rpcHandlerByTopicFromFork(forkIndex int) (map[string]rpcHandle
 	// Fulu: https://github.com/ethereum/consensus-specs/blob/dev/specs/fulu/p2p-interface.md#messages
 	if forkIndex >= version.Fulu {
 		return map[string]rpcHandler{
-			p2p.RPCGoodByeTopicV1:                   s.goodbyeRPCHandler,
-			p2p.RPCBlocksByRangeTopicV2:             s.beaconBlocksByRangeRPCHandler,
-			p2p.RPCBlocksByRootTopicV2:              s.beaconBlocksRootRPCHandler,
-			p2p.RPCPingTopicV1:                      s.pingHandler,
-			p2p.RPCMetaDataTopicV3:                  s.metaDataHandler, // Modified in Fulu
-			p2p.RPCBlobSidecarsByRootTopicV1:        s.blobSidecarByRootRPCHandler,
-			p2p.RPCBlobSidecarsByRangeTopicV1:       s.blobSidecarsByRangeRPCHandler,
-			p2p.RPCDataColumnSidecarsByRootTopicV1:  s.dataColumnSidecarByRootRPCHandler,   // Added in Fulu
-			p2p.RPCDataColumnSidecarsByRangeTopicV1: s.dataColumnSidecarsByRangeRPCHandler, // Added in Fulu
+			p2p.RPCStatusTopicV1:                   s.statusRPCHandler,
+			p2p.RPCGoodByeTopicV1:                  s.goodbyeRPCHandler,
+			p2p.RPCBlocksByRangeTopicV2:            s.beaconBlocksByRangeRPCHandler,
+			p2p.RPCBlocksByRootTopicV2:             s.beaconBlocksRootRPCHandler,
+			p2p.RPCPingTopicV1:                     s.pingHandler,
+			p2p.RPCMetaDataTopicV3:                 s.metaDataHandler, // Modified in Fulu
+			p2p.RPCBlobSidecarsByRootTopicV1:       s.blobSidecarByRootRPCHandler,
+			p2p.RPCBlobSidecarsByRangeTopicV1:      s.blobSidecarsByRangeRPCHandler,
+			p2p.RPCDataColumnSidecarsByRootTopicV1: s.dataColumnSidecarByRootRPCHandler, // Added in Fulu
 		}, nil
 	}
 

beacon-chain/sync/rpc_data_column_sidecars_by_range.go

@@ -1,218 +0,0 @@
-package sync
-
-import (
-	"context"
-	"slices"
-	"time"
-
-	p2ptypes "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/types"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
-	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
-	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	libp2pcore "github.com/libp2p/go-libp2p/core"
-	"github.com/pkg/errors"
-
-	"github.com/sirupsen/logrus"
-)
-
-// We count a single request as a single rate limiting amount, regardless of the number of columns requested.
-const rateLimitingAmount = 1
-
-var notDataColumnsByRangeIdentifiersError = errors.New("not data columns by range identifiers")
-
-// dataColumnSidecarsByRangeRPCHandler looks up the request data columns from the database from a given start slot index
-func (s *Service) dataColumnSidecarsByRangeRPCHandler(ctx context.Context, msg interface{}, stream libp2pcore.Stream) error {
-	ctx, span := trace.StartSpan(ctx, "sync.DataColumnSidecarsByRangeHandler")
-	defer span.End()
-
-	// Check if the message type is the one expected.
-	request, ok := msg.(*pb.DataColumnSidecarsByRangeRequest)
-	if !ok {
-		return notDataColumnsByRangeIdentifiersError
-	}
-
-	ctx, cancel := context.WithTimeout(ctx, respTimeout)
-	defer cancel()
-
-	SetRPCStreamDeadlines(stream)
-	beaconConfig := params.BeaconConfig()
-	maxRequestDataColumnSidecars := beaconConfig.MaxRequestDataColumnSidecars
-	remotePeer := stream.Conn().RemotePeer()
-
-	requestedColumns := request.Columns
-
-	// Format log fields.
-	var requestedColumnsLog interface{} = "all"
-	if uint64(len(requestedColumns)) != beaconConfig.NumberOfColumns {
-		requestedColumnsLog = requestedColumns
-	}
-
-	log := log.WithFields(logrus.Fields{
-		"remotePeer":       remotePeer,
-		"requestedColumns": requestedColumnsLog,
-		"startSlot":        request.StartSlot,
-		"count":            request.Count,
-	})
-
-	// Validate the request regarding rate limiting.
-	if err := s.rateLimiter.validateRequest(stream, rateLimitingAmount); err != nil {
-		return errors.Wrap(err, "rate limiter validate request")
-	}
-
-	// Validate the request regarding its parameters.
-	rangeParameters, err := validateDataColumnsByRange(request, s.cfg.chain.CurrentSlot())
-	if err != nil {
-		s.writeErrorResponseToStream(responseCodeInvalidRequest, err.Error(), stream)
-		s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(remotePeer)
-		tracing.AnnotateError(span, err)
-		return errors.Wrap(err, "validate data columns by range")
-	}
-	if rangeParameters == nil {
-		log.Debug("No data columns by range to serve")
-		return nil
-	}
-
-	log.Debug("Serving data columns by range request")
-
-	// Ticker to stagger out large requests.
-	ticker := time.NewTicker(time.Second)
-
-	batcher, err := newBlockRangeBatcher(*rangeParameters, s.cfg.beaconDB, s.rateLimiter, s.cfg.chain.IsCanonical, ticker)
-	if err != nil {
-		s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
-		tracing.AnnotateError(span, err)
-		return errors.Wrap(err, "new block range batcher")
-	}
-
-	// Derive the wanted columns for the request.
-	wantedColumns := make([]uint64, len(request.Columns))
-	copy(wantedColumns, request.Columns)
-
-	// Sort the wanted columns.
-	slices.Sort(wantedColumns)
-
-	var batch blockBatch
-	for batch, ok = batcher.next(ctx, stream); ok; batch, ok = batcher.next(ctx, stream) {
-		batchStart := time.Now()
-		maxRequestDataColumnSidecars, err = s.streamDataColumnBatch(ctx, batch, maxRequestDataColumnSidecars, wantedColumns, stream)
-		rpcDataColumnsByRangeResponseLatency.Observe(float64(time.Since(batchStart).Milliseconds()))
-		if err != nil {
-			return err
-		}
-
-		// Once the quota is reached, we're done serving the request.
-		if maxRequestDataColumnSidecars == 0 {
-			log.WithField("initialQuota", beaconConfig.MaxRequestDataColumnSidecars).Debug("Reached quota for data column sidecars by range request")
-			break
-		}
-	}
-
-	if err := batch.error(); err != nil {
-		log.WithError(err).Debug("error in DataColumnSidecarsByRange batch")
-
-		// If we hit a rate limit, the error response has already been written, and the stream is already closed.
-		if !errors.Is(err, p2ptypes.ErrRateLimited) {
-			s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
-		}
-
-		tracing.AnnotateError(span, err)
-		return err
-	}
-
-	closeStream(stream, log)
-	return nil
-}
-
-func (s *Service) streamDataColumnBatch(ctx context.Context, batch blockBatch, quota uint64, wantedDataColumnIndices []uint64, stream libp2pcore.Stream) (uint64, error) {
-	_, span := trace.StartSpan(ctx, "sync.streamDataColumnBatch")
-	defer span.End()
-
-	// Defensive check to guard against underflow.
-	if quota == 0 {
-		return 0, nil
-	}
-
-	// Loop over the blocks in the batch.
-	for _, block := range batch.canonical() {
-		// Get the block blockRoot.
-		blockRoot := block.Root()
-
-		// Retrieve the data column sidecars from the store.
-		verifiedRODataColumns, err := s.cfg.dataColumnStorage.Get(blockRoot, wantedDataColumnIndices)
-		if err != nil {
-			s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
-			return quota, errors.Wrapf(err, "get data column sidecars: block root %#x", blockRoot)
-		}
-
-		// Write the retrieved sidecars to the stream.
-		for _, verifiedRODataColumn := range verifiedRODataColumns {
-			sidecar := verifiedRODataColumn.DataColumnSidecar
-			SetStreamWriteDeadline(stream, defaultWriteDuration)
-
-			if err := WriteDataColumnSidecarChunk(stream, s.cfg.chain, s.cfg.p2p.Encoding(), sidecar); err != nil {
-				s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
-				tracing.AnnotateError(span, err)
-				return quota, errors.Wrap(err, "write data column sidecar chunk")
-			}
-
-			s.rateLimiter.add(stream, rateLimitingAmount)
-			quota -= 1
-
-			// Stop streaming results once the quota of writes for the request is consumed.
-			if quota == 0 {
-				return 0, nil
-			}
-		}
-	}
-
-	return quota, nil
-}
-
-func validateDataColumnsByRange(request *pb.DataColumnSidecarsByRangeRequest, currentSlot primitives.Slot) (*rangeParams, error) {
-	startSlot, count := request.StartSlot, request.Count
-
-	if count == 0 {
-		return nil, errors.Wrap(p2ptypes.ErrInvalidRequest, "invalid request count parameter")
-	}
-
-	endSlot, err := request.StartSlot.SafeAdd(count - 1)
-	if err != nil {
-		return nil, errors.Wrap(p2ptypes.ErrInvalidRequest, "overflow start + count -1")
-	}
-
-	// Peers may overshoot the current slot when in initial sync,
-	// so we don't want to penalize them by treating the request as an error.
-	if startSlot > currentSlot {
-		return nil, nil
-	}
-
-	// Compute the oldest slot we'll allow a peer to request, based on the current slot.
-	minStartSlot, err := dataColumnsRPCMinValidSlot(currentSlot)
-	if err != nil {
-		return nil, errors.Wrap(p2ptypes.ErrInvalidRequest, "data columns RPC min valid slot")
-	}
-
-	// Return early if there is nothing to serve.
-	if endSlot < minStartSlot {
-		return nil, nil
-	}
-
-	// Do not serve sidecars for slots before the minimum valid slot or after the current slot.
-	startSlot = max(startSlot, minStartSlot)
-	endSlot = min(endSlot, currentSlot)
-
-	sizeMinusOne, err := endSlot.SafeSub(uint64(startSlot))
-	if err != nil {
-		return nil, errors.Errorf("overflow end - start: %d - %d - should never happen", endSlot, startSlot)
-	}
-
-	size, err := sizeMinusOne.SafeAdd(1)
-	if err != nil {
-		return nil, errors.Wrap(p2ptypes.ErrInvalidRequest, "overflow end - start + 1")
-	}
-
-	rangeParameters := &rangeParams{start: startSlot, end: endSlot, size: uint64(size)}
-	return rangeParameters, nil
-}

beacon-chain/sync/rpc_data_column_sidecars_by_range_test.go

@@ -1,301 +0,0 @@
-package sync
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"math"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/libp2p/go-libp2p/core/network"
-	"github.com/libp2p/go-libp2p/core/protocol"
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/require"
-
-	chainMock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
-	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
-	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	consensusblocks "github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
-)
-
-func TestDataColumnSidecarsByRangeRPCHandler(t *testing.T) {
-	ctx := context.Background()
-	t.Run("wrong message type", func(t *testing.T) {
-		service := &Service{}
-		err := service.dataColumnSidecarsByRangeRPCHandler(ctx, nil, nil)
-		require.ErrorIs(t, err, notDataColumnsByRangeIdentifiersError)
-	})
-
-	t.Run("invalid request", func(t *testing.T) {
-		slot := primitives.Slot(400)
-
-		localP2P, remoteP2P := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
-
-		service := &Service{
-			cfg: &config{
-				p2p: localP2P,
-				chain: &chainMock.ChainService{
-					Slot: &slot,
-				},
-			},
-			rateLimiter: newRateLimiter(localP2P),
-		}
-
-		protocolID := protocol.ID(fmt.Sprintf("%s/ssz_snappy", p2p.RPCDataColumnSidecarsByRangeTopicV1))
-
-		var wg sync.WaitGroup
-		wg.Add(1)
-
-		remoteP2P.BHost.SetStreamHandler(protocolID, func(stream network.Stream) {
-			defer wg.Done()
-			code, _, err := readStatusCodeNoDeadline(stream, localP2P.Encoding())
-			require.NoError(t, err)
-			require.Equal(t, responseCodeInvalidRequest, code)
-		})
-
-		localP2P.Connect(remoteP2P)
-		stream, err := localP2P.BHost.NewStream(ctx, remoteP2P.BHost.ID(), protocolID)
-		require.NoError(t, err)
-
-		msg := &pb.DataColumnSidecarsByRangeRequest{
-			Count: 0, // Invalid count
-		}
-		require.Equal(t, true, localP2P.Peers().Scorers().BadResponsesScorer().Score(remoteP2P.PeerID()) >= 0)
-
-		err = service.dataColumnSidecarsByRangeRPCHandler(ctx, msg, stream)
-		require.NotNil(t, err)
-		require.Equal(t, true, localP2P.Peers().Scorers().BadResponsesScorer().Score(remoteP2P.PeerID()) < 0)
-
-		if util.WaitTimeout(&wg, 1*time.Second) {
-			t.Fatal("Did not receive stream within 1 sec")
-		}
-	})
-
-	t.Run("nominal", func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		beaconConfig := params.BeaconConfig()
-		beaconConfig.FuluForkEpoch = 0
-		params.OverrideBeaconConfig(beaconConfig)
-
-		slot := primitives.Slot(400)
-
-		params := []util.DataColumnParam{
-			{Slot: 10, Index: 1}, {Slot: 10, Index: 2}, {Slot: 10, Index: 3},
-			{Slot: 40, Index: 4}, {Slot: 40, Index: 6},
-			{Slot: 45, Index: 7}, {Slot: 45, Index: 8}, {Slot: 45, Index: 9},
-		}
-
-		_, verifiedRODataColumns := util.CreateTestVerifiedRoDataColumnSidecars(t, params)
-
-		storage := filesystem.NewEphemeralDataColumnStorage(t)
-		err := storage.Save(verifiedRODataColumns)
-		require.NoError(t, err)
-
-		localP2P, remoteP2P := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
-		protocolID := protocol.ID(fmt.Sprintf("%s/ssz_snappy", p2p.RPCDataColumnSidecarsByRangeTopicV1))
-
-		roots := [][fieldparams.RootLength]byte{
-			verifiedRODataColumns[0].BlockRoot(),
-			verifiedRODataColumns[3].BlockRoot(),
-			verifiedRODataColumns[5].BlockRoot(),
-		}
-
-		slots := []primitives.Slot{
-			verifiedRODataColumns[0].Slot(),
-			verifiedRODataColumns[3].Slot(),
-			verifiedRODataColumns[5].Slot(),
-		}
-
-		beaconDB := testDB.SetupDB(t)
-		roBlocks := make([]blocks.ROBlock, 0, len(roots))
-		for i := range 3 {
-			signedBeaconBlockPb := util.NewBeaconBlock()
-			signedBeaconBlockPb.Block.Slot = slots[i]
-			if i != 0 {
-				signedBeaconBlockPb.Block.ParentRoot = roots[i-1][:]
-			}
-
-			signedBeaconBlock, err := consensusblocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-			require.NoError(t, err)
-
-			// There is a discrepancy between the root of the beacon block and the rodata column root,
-			// but for the sake of this test, we actually don't care.
-			roblock, err := consensusblocks.NewROBlockWithRoot(signedBeaconBlock, roots[i])
-			require.NoError(t, err)
-
-			roBlocks = append(roBlocks, roblock)
-		}
-
-		err = beaconDB.SaveROBlocks(ctx, roBlocks, false /*cache*/)
-		require.NoError(t, err)
-
-		service := &Service{
-			cfg: &config{
-				p2p:      localP2P,
-				beaconDB: beaconDB,
-				chain: &chainMock.ChainService{
-					Slot: &slot,
-				},
-				dataColumnStorage: storage,
-			},
-			rateLimiter: newRateLimiter(localP2P),
-		}
-
-		ctxMap := ContextByteVersions{
-			[4]byte{245, 165, 253, 66}: version.Fulu,
-		}
-
-		root0 := verifiedRODataColumns[0].BlockRoot()
-		root3 := verifiedRODataColumns[3].BlockRoot()
-		root5 := verifiedRODataColumns[5].BlockRoot()
-
-		var wg sync.WaitGroup
-		wg.Add(1)
-
-		remoteP2P.BHost.SetStreamHandler(protocolID, func(stream network.Stream) {
-			defer wg.Done()
-
-			sidecars := make([]*blocks.RODataColumn, 0, 5)
-
-			for i := uint64(0); ; /* no stop condition */ i++ {
-				sidecar, err := readChunkedDataColumnSidecar(stream, remoteP2P, ctxMap)
-				if errors.Is(err, io.EOF) {
-					// End of stream.
-					break
-				}
-
-				require.NoError(t, err)
-				sidecars = append(sidecars, sidecar)
-			}
-
-			require.Equal(t, 8, len(sidecars))
-			require.Equal(t, root0, sidecars[0].BlockRoot())
-			require.Equal(t, root0, sidecars[1].BlockRoot())
-			require.Equal(t, root0, sidecars[2].BlockRoot())
-			require.Equal(t, root3, sidecars[3].BlockRoot())
-			require.Equal(t, root3, sidecars[4].BlockRoot())
-			require.Equal(t, root5, sidecars[5].BlockRoot())
-			require.Equal(t, root5, sidecars[6].BlockRoot())
-			require.Equal(t, root5, sidecars[7].BlockRoot())
-
-			require.Equal(t, uint64(1), sidecars[0].Index)
-			require.Equal(t, uint64(2), sidecars[1].Index)
-			require.Equal(t, uint64(3), sidecars[2].Index)
-			require.Equal(t, uint64(4), sidecars[3].Index)
-			require.Equal(t, uint64(6), sidecars[4].Index)
-			require.Equal(t, uint64(7), sidecars[5].Index)
-			require.Equal(t, uint64(8), sidecars[6].Index)
-			require.Equal(t, uint64(9), sidecars[7].Index)
-		})
-
-		localP2P.Connect(remoteP2P)
-		stream, err := localP2P.BHost.NewStream(ctx, remoteP2P.BHost.ID(), protocolID)
-		require.NoError(t, err)
-
-		msg := &pb.DataColumnSidecarsByRangeRequest{
-			StartSlot: 5,
-			Count:     50,
-			Columns:   []uint64{1, 2, 3, 4, 6, 7, 8, 9, 10},
-		}
-
-		err = service.dataColumnSidecarsByRangeRPCHandler(ctx, msg, stream)
-		require.NoError(t, err)
-	})
-
-}
-
-func TestValidateDataColumnsByRange(t *testing.T) {
-	maxUint := primitives.Slot(math.MaxUint64)
-
-	params.SetupTestConfigCleanup(t)
-	config := params.BeaconConfig()
-	config.FuluForkEpoch = 10
-	config.MinEpochsForDataColumnSidecarsRequest = 4096
-	params.OverrideBeaconConfig(config)
-
-	tests := []struct {
-		name        string
-		startSlot   primitives.Slot
-		count       uint64
-		currentSlot primitives.Slot
-		expected    *rangeParams
-		expectErr   bool
-		errContains string
-	}{
-		{
-			name:        "zero count returns error",
-			count:       0,
-			expectErr:   true,
-			errContains: "invalid request count parameter",
-		},
-		{
-			name:        "overflow in addition returns error",
-			startSlot:   maxUint - 5,
-			count:       10,
-			currentSlot: maxUint,
-			expectErr:   true,
-			errContains: "overflow start + count -1",
-		},
-		{
-			name:        "start greater than current returns nil",
-			startSlot:   150,
-			count:       10,
-			currentSlot: 100,
-			expected:    nil,
-			expectErr:   false,
-		},
-		{
-			name:        "end slot greater than min start slot returns nil",
-			startSlot:   150,
-			count:       100,
-			currentSlot: 300,
-			expected:    nil,
-			expectErr:   false,
-		},
-		{
-			name:        "range within limits",
-			startSlot:   350,
-			count:       10,
-			currentSlot: 400,
-			expected:    &rangeParams{start: 350, end: 359, size: 10},
-			expectErr:   false,
-		},
-		{
-			name:        "range exceeds limits",
-			startSlot:   0,
-			count:       10_000,
-			currentSlot: 400,
-			expected:    &rangeParams{start: 320, end: 400, size: 81},
-			expectErr:   false,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			request := &pb.DataColumnSidecarsByRangeRequest{
-				StartSlot: tc.startSlot,
-				Count:     tc.count,
-			}
-
-			rangeParameters, err := validateDataColumnsByRange(request, tc.currentSlot)
-			if tc.expectErr {
-				require.ErrorContains(t, err, tc.errContains)
-				return
-			}
-
-			require.NoError(t, err)
-			require.Equal(t, tc.expected, rangeParameters)
-		})
-	}
-}

beacon-chain/sync/rpc_data_column_sidecars_by_root.go

@@ -12,7 +12,6 @@ import (
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -99,15 +98,12 @@ func (s *Service) dataColumnSidecarByRootRPCHandler(ctx context.Context, msg int
 	log.Debug("Serving data column sidecar by root request")
 
 	count := 0
-	for _, ident := range requestedColumnIdents {
+	for root, columns := range requestedColumnsByRoot {
 		if err := ctx.Err(); err != nil {
 			closeStream(stream, log)
 			return errors.Wrap(err, "context error")
 		}
 
-		root := bytesutil.ToBytes32(ident.BlockRoot)
-		columns := ident.Columns
-
 		// Throttle request processing to no more than batchSize/sec.
 		for range columns {
 			if ticker != nil && count != 0 && count%batchSize == 0 {
@@ -174,10 +170,5 @@ func dataColumnsRPCMinValidSlot(currentSlot primitives.Slot) (primitives.Slot, e
 		minStartEpoch = currEpoch - minReqEpochs
 	}
 
-	epochStart, err := slots.EpochStart(minStartEpoch)
-	if err != nil {
-		return 0, errors.Wrapf(err, "epoch start for epoch %d", minStartEpoch)
-	}
-
-	return epochStart, nil
+	return slots.EpochStart(minStartEpoch)
 }

beacon-chain/sync/rpc_data_column_sidecars_by_root_test.go

@@ -139,7 +139,7 @@ func TestDataColumnSidecarsByRootRPCHandler(t *testing.T) {
 			sidecars := make([]*blocks.RODataColumn, 0, 5)
 
 			for i := uint64(0); ; /* no stop condition */ i++ {
-				sidecar, err := readChunkedDataColumnSidecar(stream, remoteP2P, ctxMap)
+				sidecar, err := readChunkedDataColumnSideCar(stream, remoteP2P, ctxMap)
 				if errors.Is(err, io.EOF) {
 					// End of stream.
 					break
@@ -276,28 +276,21 @@ func TestDataColumnsRPCMinValidSlot(t *testing.T) {
 			expected:      primitives.Slot(math.MaxUint64),
 		},
 		{
-			name:          "Current epoch is before fulu fork epoch",
-			fuluForkEpoch: 10,
-			minReqEpochs:  5,
-			currentSlot:   primitives.Slot(8 * slotsPerEpoch),
-			expected:      primitives.Slot(10 * slotsPerEpoch),
-		},
-		{
-			name:          "Current epoch is fulu fork epoch",
+			name:          "Current epoch equals fork epoch",
 			fuluForkEpoch: 10,
 			minReqEpochs:  5,
 			currentSlot:   primitives.Slot(10 * slotsPerEpoch),
 			expected:      primitives.Slot(10 * slotsPerEpoch),
 		},
 		{
-			name:          "Current epoch between fulu fork epoch and minReqEpochs",
+			name:          "Current epoch less than minReqEpochs",
 			fuluForkEpoch: 10,
 			minReqEpochs:  20,
 			currentSlot:   primitives.Slot(15 * slotsPerEpoch),
 			expected:      primitives.Slot(10 * slotsPerEpoch),
 		},
 		{
-			name:          "Current epoch after fulu fork epoch + minReqEpochs",
+			name:          "Current epoch greater than minReqEpochs + fork epoch",
 			fuluForkEpoch: 10,
 			minReqEpochs:  5,
 			currentSlot:   primitives.Slot(20 * slotsPerEpoch),

beacon-chain/sync/rpc_send_request.go

@@ -4,14 +4,12 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"slices"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
 	p2ptypes "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
@@ -32,24 +30,18 @@ var errBlobUnmarshal = errors.New("Could not unmarshal chunk-encoded blob")
 // Any error from the following declaration block should result in peer downscoring.
 var (
 	// ErrInvalidFetchedData is used to signal that an error occurred which should result in peer downscoring.
-	ErrInvalidFetchedData                    = errors.New("invalid data returned from peer")
-	errBlobIndexOutOfBounds                  = errors.Wrap(verification.ErrBlobInvalid, "blob index out of range")
-	errMaxRequestBlobSidecarsExceeded        = errors.Wrap(verification.ErrBlobInvalid, "peer exceeded req blob chunk tx limit")
-	errChunkResponseSlotNotAsc               = errors.Wrap(verification.ErrBlobInvalid, "blob slot not higher than previous block root")
-	errChunkResponseIndexNotAsc              = errors.Wrap(verification.ErrBlobInvalid, "blob indices for a block must start at 0 and increase by 1")
-	errUnrequested                           = errors.Wrap(verification.ErrBlobInvalid, "received BlobSidecar in response that was not requested")
-	errBlobResponseOutOfBounds               = errors.Wrap(verification.ErrBlobInvalid, "received BlobSidecar with slot outside BlobSidecarsByRangeRequest bounds")
-	errChunkResponseBlockMismatch            = errors.Wrap(verification.ErrBlobInvalid, "blob block details do not match")
-	errChunkResponseParentMismatch           = errors.Wrap(verification.ErrBlobInvalid, "parent root for response element doesn't match previous element root")
-	errDataColumnChunkedReadFailure          = errors.New("failed to read stream of chunk-encoded data columns")
-	errMaxRequestDataColumnSidecarsExceeded  = errors.New("count of requested data column sidecars exceeds MAX_REQUEST_DATA_COLUMN_SIDECARS")
-	errMaxResponseDataColumnSidecarsExceeded = errors.New("peer returned more data column sidecars than requested")
+	ErrInvalidFetchedData             = errors.New("invalid data returned from peer")
+	errBlobIndexOutOfBounds           = errors.Wrap(verification.ErrBlobInvalid, "blob index out of range")
+	errMaxRequestBlobSidecarsExceeded = errors.Wrap(verification.ErrBlobInvalid, "peer exceeded req blob chunk tx limit")
+	errChunkResponseSlotNotAsc        = errors.Wrap(verification.ErrBlobInvalid, "blob slot not higher than previous block root")
+	errChunkResponseIndexNotAsc       = errors.Wrap(verification.ErrBlobInvalid, "blob indices for a block must start at 0 and increase by 1")
+	errUnrequested                    = errors.Wrap(verification.ErrBlobInvalid, "received BlobSidecar in response that was not requested")
+	errBlobResponseOutOfBounds        = errors.Wrap(verification.ErrBlobInvalid, "received BlobSidecar with slot outside BlobSidecarsByRangeRequest bounds")
+	errChunkResponseBlockMismatch     = errors.Wrap(verification.ErrBlobInvalid, "blob block details do not match")
+	errChunkResponseParentMismatch    = errors.Wrap(verification.ErrBlobInvalid, "parent root for response element doesn't match previous element root")
+	errDataColumnChunkedReadFailure   = errors.New("failed to read stream of chunk-encoded data columns")
 )
 
-// ------
-// Blocks
-// ------
-
 // BeaconBlockProcessor defines a block processing function, which allows to start utilizing
 // blocks even before all blocks are ready.
 type BeaconBlockProcessor func(block interfaces.ReadOnlySignedBeaconBlock) error
@@ -163,14 +155,6 @@ func SendBeaconBlocksByRootRequest(
 	return blocks, nil
 }
 
-// -------------
-// Blob sidecars
-// -------------
-
-// BlobResponseValidation represents a function that can validate aspects of a single unmarshaled blob sidecar
-// that was received from a peer in response to an rpc request.
-type BlobResponseValidation func(blocks.ROBlob) error
-
 func SendBlobsByRangeRequest(ctx context.Context, tor blockchain.TemporalOracle, p2pApi p2p.SenderEncoder, pid peer.ID, ctxMap ContextByteVersions, req *ethpb.BlobSidecarsByRangeRequest, bvs ...BlobResponseValidation) ([]blocks.ROBlob, error) {
 	topic, err := p2p.TopicFromMessage(p2p.BlobSidecarsByRangeName, slots.ToEpoch(tor.CurrentSlot()))
 	if err != nil {
@@ -232,6 +216,10 @@ func SendBlobSidecarByRoot(
 	return readChunkEncodedBlobs(stream, p2pApi.Encoding(), ctxMap, blobValidatorFromRootReq(req), max)
 }
 
+// BlobResponseValidation represents a function that can validate aspects of a single unmarshaled blob
+// that was received from a peer in response to an rpc request.
+type BlobResponseValidation func(blocks.ROBlob) error
+
 func composeBlobValidations(vf ...BlobResponseValidation) BlobResponseValidation {
 	return func(blob blocks.ROBlob) error {
 		for i := range vf {
@@ -397,258 +385,10 @@ func readChunkedBlobSidecar(stream network.Stream, encoding encoder.NetworkEncod
 	return rob, nil
 }
 
-// --------------------
-// Data column sidecars
-// --------------------
-
-// SendDataColumnSidecarsByRangeRequest sends a request for data column sidecars by range
-// and returns the fetched data column sidecars.
-func SendDataColumnSidecarsByRangeRequest(
-	ctx context.Context,
-	tor blockchain.TemporalOracle,
-	p2pApi p2p.P2P,
-	pid peer.ID,
-	ctxMap ContextByteVersions,
-	request *ethpb.DataColumnSidecarsByRangeRequest,
-) ([]blocks.RODataColumn, error) {
-	// Return early if nothing to request.
-	if request == nil || request.Count == 0 || len(request.Columns) == 0 {
-		return nil, nil
-	}
-
-	beaconConfig := params.BeaconConfig()
-	numberOfColumns := beaconConfig.NumberOfColumns
-	maxRequestDataColumnSidecars := params.BeaconConfig().MaxRequestDataColumnSidecars
-
-	// Check if we do not request too many sidecars.
-	columnsCount := uint64(len(request.Columns))
-	totalCount := request.Count * columnsCount
-	if totalCount > maxRequestDataColumnSidecars {
-		return nil, errors.Wrapf(errMaxRequestDataColumnSidecarsExceeded, "requestedCount=%d, allowedCount=%d", totalCount, maxRequestDataColumnSidecars)
-	}
-
-	// Build the topic.
-	currentSlot := tor.CurrentSlot()
-	currentEpoch := slots.ToEpoch(currentSlot)
-	topic, err := p2p.TopicFromMessage(p2p.DataColumnSidecarsByRangeName, currentEpoch)
-	if err != nil {
-		return nil, errors.Wrap(err, "topic from message")
-	}
-
-	// Build the logs.
-	var columnsLog interface{} = "all"
-	if columnsCount < numberOfColumns {
-		columns := request.Columns
-		slices.Sort(columns)
-		columnsLog = columns
-	}
-
-	log := log.WithFields(logrus.Fields{
-		"peer":       pid,
-		"topic":      topic,
-		"startSlot":  request.StartSlot,
-		"count":      request.Count,
-		"columns":    columnsLog,
-		"totalCount": totalCount,
-	})
-
-	// Send the request.
-	stream, err := p2pApi.Send(ctx, request, topic, pid)
-	if err != nil {
-		return nil, errors.Wrap(err, "p2p send")
-	}
-	defer closeStream(stream, log)
-
-	// Read the data column sidecars from the stream.
-	roDataColumns := make([]blocks.RODataColumn, 0, totalCount)
-	for range totalCount {
-		// Avoid reading extra chunks if the context is done.
-		if err := ctx.Err(); err != nil {
-			return nil, err
-		}
-
-		validatorSlotWithinBounds, err := isSidecarSlotWithinBounds(request)
-		if err != nil {
-			return nil, errors.Wrap(err, "is sidecar slot within bounds")
-		}
-
-		roDataColumn, err := readChunkedDataColumnSidecar(
-			stream, p2pApi, ctxMap,
-			validatorSlotWithinBounds,
-			isSidecarIndexRequested(request),
-		)
-		if errors.Is(err, io.EOF) {
-			return roDataColumns, nil
-		}
-		if err != nil {
-			return nil, errors.Wrap(err, "read chunked data column sidecar")
-		}
-
-		if roDataColumn == nil {
-			return nil, errors.New("nil data column sidecar, should never happen")
-		}
-
-		roDataColumns = append(roDataColumns, *roDataColumn)
-	}
-
-	// All requested sidecars were delivered by the peer. Expecting EOF.
-	if _, err := readChunkedDataColumnSidecar(stream, p2pApi, ctxMap); !errors.Is(err, io.EOF) {
-		return nil, errors.Wrapf(errMaxResponseDataColumnSidecarsExceeded, "requestedCount=%d", totalCount)
-	}
-
-	return roDataColumns, nil
-}
-
-// isSidecarSlotWithinBounds verifies that the slot of the data column sidecar is within the bounds of the request.
-func isSidecarSlotWithinBounds(request *ethpb.DataColumnSidecarsByRangeRequest) (DataColumnResponseValidation, error) {
-	// endSlot is exclusive (while request.StartSlot is inclusive).
-	endSlot, err := request.StartSlot.SafeAdd(request.Count)
-	if err != nil {
-		return nil, errors.Wrap(err, "calculate end slot")
-	}
-
-	validator := func(sidecar blocks.RODataColumn) error {
-		slot := sidecar.Slot()
-
-		if !(request.StartSlot <= slot && slot < endSlot) {
-			return errors.Errorf("data column sidecar slot %d out of range [%d, %d[", slot, request.StartSlot, endSlot)
-		}
-
-		return nil
-	}
-
-	return validator, nil
-}
-
-// isSidecarIndexRequested verifies that the index of the data column sidecar is found in the requested indices.
-func isSidecarIndexRequested(request *ethpb.DataColumnSidecarsByRangeRequest) DataColumnResponseValidation {
-	requestedIndices := make(map[uint64]bool)
-	for _, col := range request.Columns {
-		requestedIndices[col] = true
-	}
-
-	return func(sidecar blocks.RODataColumn) error {
-		columnIndex := sidecar.Index
-		if !requestedIndices[columnIndex] {
-			return errors.Errorf("data column sidecar index %d not found in requested indices", columnIndex)
-		}
-
-		return nil
-	}
-}
-
-// SendDataColumnSidecarsByRootRequest sends a request for data column sidecars by root
-// and returns the fetched data column sidecars.
-func SendDataColumnSidecarsByRootRequest(
-	ctx context.Context,
-	tor blockchain.TemporalOracle,
-	p2pApi p2p.P2P,
-	pid peer.ID,
-	ctxMap ContextByteVersions,
-	request p2ptypes.DataColumnsByRootIdentifiers,
-) ([]blocks.RODataColumn, error) {
-	// Return early if the request is nil.
-	if request == nil {
-		return nil, nil
-	}
-
-	// Compute how many sidecars are requested.
-	count := uint64(0)
-	for _, identifier := range request {
-		count += uint64(len(identifier.Columns))
-	}
-
-	// Return early if nothing to request.
-	if count == 0 {
-		return nil, nil
-	}
-
-	// Verify that the request count is within the maximum allowed.
-	maxRequestDataColumnSidecars := params.BeaconConfig().MaxRequestDataColumnSidecars
-	if count > maxRequestDataColumnSidecars {
-		return nil, errors.Wrapf(errMaxRequestDataColumnSidecarsExceeded, "current: %d, max: %d", count, maxRequestDataColumnSidecars)
-	}
-
-	// Get the topic for the request.
-	topic, err := p2p.TopicFromMessage(p2p.DataColumnSidecarsByRootName, slots.ToEpoch(tor.CurrentSlot()))
-	if err != nil {
-		return nil, errors.Wrap(err, "topic from message")
-	}
-
-	// Send the request to the peer.
-	stream, err := p2pApi.Send(ctx, request, topic, pid)
-	if err != nil {
-		return nil, errors.Wrap(err, "p2p api send")
-	}
-	defer closeStream(stream, log)
-
-	// Read the data column sidecars from the stream.
-	roDataColumns := make([]blocks.RODataColumn, 0, count)
-
-	// Read the data column sidecars from the stream.
-	for range count {
-		roDataColumn, err := readChunkedDataColumnSidecar(stream, p2pApi, ctxMap, isSidecarIndexRootRequested(request))
-		if errors.Is(err, io.EOF) {
-			return roDataColumns, nil
-		}
-		if err != nil {
-			return nil, errors.Wrap(err, "read chunked data column sidecar")
-		}
-
-		if roDataColumn == nil {
-			return nil, errors.Wrap(err, "nil data column sidecar, should never happen")
-		}
-
-		roDataColumns = append(roDataColumns, *roDataColumn)
-	}
-
-	// All requested sidecars were delivered by the peer. Expecting EOF.
-	if _, err := readChunkedDataColumnSidecar(stream, p2pApi, ctxMap); !errors.Is(err, io.EOF) {
-		return nil, errors.Wrapf(errMaxResponseDataColumnSidecarsExceeded, "requestedCount=%d", count)
-	}
-
-	return roDataColumns, nil
-}
-
-func isSidecarIndexRootRequested(request p2ptypes.DataColumnsByRootIdentifiers) DataColumnResponseValidation {
-	columnsIndexFromRoot := make(map[[fieldparams.RootLength]byte]map[uint64]bool)
-
-	for _, sidecar := range request {
-		blockRoot := bytesutil.ToBytes32(sidecar.BlockRoot)
-		if columnsIndexFromRoot[blockRoot] == nil {
-			columnsIndexFromRoot[blockRoot] = make(map[uint64]bool)
-		}
-
-		for _, column := range sidecar.Columns {
-			columnsIndexFromRoot[blockRoot][column] = true
-		}
-	}
-
-	return func(sidecar blocks.RODataColumn) error {
-		root, index := sidecar.BlockRoot(), sidecar.Index
-		indices, ok := columnsIndexFromRoot[root]
-
-		if !ok {
-			return errors.Errorf("root #%x returned by peer but not requested", root)
-		}
-
-		if !indices[index] {
-			return errors.Errorf("index %d for root #%x returned by peer but not requested", index, root)
-		}
-
-		return nil
-	}
-}
-
-// DataColumnResponseValidation represents a function that can validate aspects of a single unmarshaled data column sidecar
-// that was received from a peer in response to an rpc request.
-type DataColumnResponseValidation func(column blocks.RODataColumn) error
-
-func readChunkedDataColumnSidecar(
+func readChunkedDataColumnSideCar(
 	stream network.Stream,
 	p2pApi p2p.P2P,
 	ctxMap ContextByteVersions,
-	validationFunctions ...DataColumnResponseValidation,
 ) (*blocks.RODataColumn, error) {
 	// Read the status code from the stream.
 	statusCode, errMessage, err := ReadStatusCode(stream, p2pApi.Encoding())
@@ -692,12 +432,5 @@ func readChunkedDataColumnSidecar(
 		return nil, errors.Wrap(err, "new read only data column")
 	}
 
-	// Run validation functions.
-	for _, validationFunction := range validationFunctions {
-		if err := validationFunction(roDataColumn); err != nil {
-			return nil, errors.Wrap(err, "validation function")
-		}
-	}
-
 	return &roDataColumn, nil
 }

beacon-chain/sync/rpc_send_request_test.go

@@ -5,15 +5,12 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"sync"
 	"testing"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/types"
 	p2pTypes "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/types"
-	p2ptypes "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
@@ -23,7 +20,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
@@ -886,745 +882,3 @@ func TestSendBlobsByRangeRequest(t *testing.T) {
 func TestErrInvalidFetchedDataDistinction(t *testing.T) {
 	require.Equal(t, false, errors.Is(ErrInvalidFetchedData, verification.ErrBlobInvalid))
 }
-
-func TestSendDataColumnSidecarsByRangeRequest(t *testing.T) {
-	nilTestCases := []struct {
-		name    string
-		request *ethpb.DataColumnSidecarsByRangeRequest
-	}{
-		{
-			name:    "nil request",
-			request: nil,
-		},
-		{
-			name:    "count is 0",
-			request: &ethpb.DataColumnSidecarsByRangeRequest{},
-		},
-		{
-			name:    "columns is nil",
-			request: &ethpb.DataColumnSidecarsByRangeRequest{Count: 1},
-		},
-	}
-
-	for _, tc := range nilTestCases {
-		t.Run(tc.name, func(t *testing.T) {
-			actual, err := SendDataColumnSidecarsByRangeRequest(t.Context(), nil, nil, "aRandomPID", nil, tc.request)
-			require.NoError(t, err)
-			require.IsNil(t, actual)
-		})
-	}
-
-	t.Run("too many columns in request", func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		beaconConfig := params.BeaconConfig()
-		beaconConfig.MaxRequestDataColumnSidecars = 0
-		params.OverrideBeaconConfig(beaconConfig)
-
-		request := &ethpb.DataColumnSidecarsByRangeRequest{Count: 1, Columns: []uint64{1, 2, 3}}
-		_, err := SendDataColumnSidecarsByRangeRequest(t.Context(), nil, nil, "aRandomPID", nil, request)
-		require.ErrorContains(t, errMaxRequestDataColumnSidecarsExceeded.Error(), err)
-	})
-
-	type slotIndex struct {
-		Slot  primitives.Slot
-		Index uint64
-	}
-
-	createSidecar := func(slotIndex slotIndex) *ethpb.DataColumnSidecar {
-		const count = 4
-		kzgCommitmentsInclusionProof := make([][]byte, 0, count)
-		for range count {
-			kzgCommitmentsInclusionProof = append(kzgCommitmentsInclusionProof, make([]byte, 32))
-		}
-
-		return &ethpb.DataColumnSidecar{
-			Index: slotIndex.Index,
-			SignedBlockHeader: &ethpb.SignedBeaconBlockHeader{
-				Header: &ethpb.BeaconBlockHeader{
-					Slot:       slotIndex.Slot,
-					ParentRoot: make([]byte, fieldparams.RootLength),
-					StateRoot:  make([]byte, fieldparams.RootLength),
-					BodyRoot:   make([]byte, fieldparams.RootLength),
-				},
-				Signature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-		}
-	}
-
-	testCases := []struct {
-		name          string
-		slotIndices   []slotIndex
-		expectedError error
-	}{
-		{
-			name: "too many responses",
-			slotIndices: []slotIndex{
-				{Slot: 0, Index: 1},
-				{Slot: 0, Index: 2},
-				{Slot: 0, Index: 3},
-				{Slot: 1, Index: 1},
-				{Slot: 1, Index: 2},
-				{Slot: 1, Index: 3},
-				{Slot: 0, Index: 3}, // Duplicate
-			},
-			expectedError: errMaxResponseDataColumnSidecarsExceeded,
-		},
-		{
-			name: "perfect match",
-			slotIndices: []slotIndex{
-				{Slot: 0, Index: 1},
-				{Slot: 0, Index: 2},
-				{Slot: 0, Index: 3},
-				{Slot: 1, Index: 1},
-				{Slot: 1, Index: 2},
-				{Slot: 1, Index: 3},
-			},
-		},
-		{
-			name: "few responses than maximum possible",
-			slotIndices: []slotIndex{
-				{Slot: 0, Index: 1},
-				{Slot: 0, Index: 2},
-				{Slot: 0, Index: 3},
-				{Slot: 1, Index: 1},
-				{Slot: 1, Index: 2},
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			protocol := fmt.Sprintf("%s/ssz_snappy", p2p.RPCDataColumnSidecarsByRangeTopicV1)
-			clock := startup.NewClock(time.Now(), [fieldparams.RootLength]byte{})
-
-			p1, p2 := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
-			p1.Connect(p2)
-
-			expected := make([]*ethpb.DataColumnSidecar, 0, len(tc.slotIndices))
-			for _, slotIndex := range tc.slotIndices {
-				sidecar := createSidecar(slotIndex)
-				expected = append(expected, sidecar)
-			}
-
-			requestSent := &ethpb.DataColumnSidecarsByRangeRequest{
-				StartSlot: 0,
-				Count:     2,
-				Columns:   []uint64{1, 3, 2},
-			}
-
-			var wg sync.WaitGroup
-			wg.Add(1)
-
-			p2.SetStreamHandler(protocol, func(stream network.Stream) {
-				wg.Done()
-
-				requestReceived := new(ethpb.DataColumnSidecarsByRangeRequest)
-				err := p2.Encoding().DecodeWithMaxLength(stream, requestReceived)
-				assert.NoError(t, err)
-				assert.DeepSSZEqual(t, requestSent, requestReceived)
-
-				for _, sidecar := range expected {
-					err := WriteDataColumnSidecarChunk(stream, clock, p2.Encoding(), sidecar)
-					assert.NoError(t, err)
-				}
-
-				err = stream.CloseWrite()
-				assert.NoError(t, err)
-			})
-
-			ctx := t.Context()
-			ctxMap := ContextByteVersions{[4]byte{245, 165, 253, 66}: version.Fulu}
-
-			actual, err := SendDataColumnSidecarsByRangeRequest(ctx, clock, p1, p2.PeerID(), ctxMap, requestSent)
-			if tc.expectedError != nil {
-				require.ErrorContains(t, tc.expectedError.Error(), err)
-				if util.WaitTimeout(&wg, time.Second) {
-					t.Fatal("Did not receive stream within 1 sec")
-				}
-
-				return
-			}
-
-			require.Equal(t, len(expected), len(actual))
-			for i := range expected {
-				require.DeepSSZEqual(t, expected[i], actual[i].DataColumnSidecar)
-			}
-		})
-	}
-}
-
-func TestIsSidecarSlotWithinBounds(t *testing.T) {
-	request := &ethpb.DataColumnSidecarsByRangeRequest{
-		StartSlot: 10,
-		Count:     10,
-	}
-
-	validator, err := isSidecarSlotWithinBounds(request)
-	require.NoError(t, err)
-
-	testCases := []struct {
-		name            string
-		slot            primitives.Slot
-		isErrorExpected bool
-	}{
-		{
-			name:            "too soon",
-			slot:            9,
-			isErrorExpected: true,
-		},
-		{
-			name:            "too late",
-			slot:            20,
-			isErrorExpected: true,
-		},
-		{
-			name:            "within bounds",
-			slot:            15,
-			isErrorExpected: false,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			const count = 4
-			kzgCommitmentsInclusionProof := make([][]byte, 0, count)
-			for range count {
-				kzgCommitmentsInclusionProof = append(kzgCommitmentsInclusionProof, make([]byte, 32))
-			}
-
-			sidecarPb := &ethpb.DataColumnSidecar{
-				SignedBlockHeader: &ethpb.SignedBeaconBlockHeader{
-					Header: &ethpb.BeaconBlockHeader{
-						Slot:       tc.slot,
-						ParentRoot: make([]byte, fieldparams.RootLength),
-						StateRoot:  make([]byte, fieldparams.RootLength),
-						BodyRoot:   make([]byte, fieldparams.RootLength),
-					},
-					Signature: make([]byte, fieldparams.BLSSignatureLength),
-				},
-				KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-			}
-
-			sidecar, err := blocks.NewRODataColumn(sidecarPb)
-			require.NoError(t, err)
-
-			err = validator(sidecar)
-			if tc.isErrorExpected {
-				require.NotNil(t, err)
-				return
-			}
-
-			require.NoError(t, err)
-		})
-	}
-}
-
-func TestIsSidecarIndexRequested(t *testing.T) {
-	request := &ethpb.DataColumnSidecarsByRangeRequest{
-		Columns: []uint64{2, 9, 4},
-	}
-
-	validator := isSidecarIndexRequested(request)
-
-	testCases := []struct {
-		name            string
-		index           uint64
-		isErrorExpected bool
-	}{
-		{
-			name:            "not requested",
-			index:           1,
-			isErrorExpected: true,
-		},
-		{
-			name:            "requested",
-			index:           9,
-			isErrorExpected: false,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			const count = 4
-			kzgCommitmentsInclusionProof := make([][]byte, 0, count)
-			for range count {
-				kzgCommitmentsInclusionProof = append(kzgCommitmentsInclusionProof, make([]byte, 32))
-			}
-
-			sidecarPb := &ethpb.DataColumnSidecar{
-				SignedBlockHeader: &ethpb.SignedBeaconBlockHeader{
-					Header: &ethpb.BeaconBlockHeader{
-						Slot:       0,
-						ParentRoot: make([]byte, fieldparams.RootLength),
-						StateRoot:  make([]byte, fieldparams.RootLength),
-						BodyRoot:   make([]byte, fieldparams.RootLength),
-					},
-					Signature: make([]byte, fieldparams.BLSSignatureLength),
-				},
-				KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-				Index:                        tc.index,
-			}
-
-			sidecar, err := blocks.NewRODataColumn(sidecarPb)
-			require.NoError(t, err)
-
-			err = validator(sidecar)
-			if tc.isErrorExpected {
-				require.NotNil(t, err)
-				return
-			}
-
-			require.NoError(t, err)
-		})
-	}
-}
-
-func TestSendDataColumnSidecarsByRootRequest(t *testing.T) {
-	nilTestCases := []struct {
-		name    string
-		request p2ptypes.DataColumnsByRootIdentifiers
-	}{
-		{
-			name:    "nil request",
-			request: nil,
-		},
-		{
-			name:    "count is 0",
-			request: p2ptypes.DataColumnsByRootIdentifiers{{}, {}},
-		},
-	}
-
-	for _, tc := range nilTestCases {
-		t.Run(tc.name, func(t *testing.T) {
-			actual, err := SendDataColumnSidecarsByRootRequest(t.Context(), nil, nil, "aRandomPID", nil, tc.request)
-			require.NoError(t, err)
-			require.IsNil(t, actual)
-		})
-	}
-
-	t.Run("too many columns in request", func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		beaconConfig := params.BeaconConfig()
-		beaconConfig.MaxRequestDataColumnSidecars = 4
-		params.OverrideBeaconConfig(beaconConfig)
-
-		request := p2ptypes.DataColumnsByRootIdentifiers{
-			{Columns: []uint64{1, 2, 3}},
-			{Columns: []uint64{4, 5, 6}},
-		}
-
-		_, err := SendDataColumnSidecarsByRootRequest(t.Context(), nil, nil, "aRandomPID", nil, request)
-		require.ErrorContains(t, errMaxRequestDataColumnSidecarsExceeded.Error(), err)
-	})
-
-	type slotIndex struct {
-		Slot  primitives.Slot
-		Index uint64
-	}
-
-	createSidecar := func(rootIndex slotIndex) blocks.RODataColumn {
-		const count = 4
-		kzgCommitmentsInclusionProof := make([][]byte, 0, count)
-		for range count {
-			kzgCommitmentsInclusionProof = append(kzgCommitmentsInclusionProof, make([]byte, 32))
-		}
-
-		sidecarPb := &ethpb.DataColumnSidecar{
-			Index: rootIndex.Index,
-			SignedBlockHeader: &ethpb.SignedBeaconBlockHeader{
-				Header: &ethpb.BeaconBlockHeader{
-					ParentRoot: make([]byte, fieldparams.RootLength),
-					StateRoot:  make([]byte, fieldparams.RootLength),
-					BodyRoot:   make([]byte, fieldparams.RootLength),
-				},
-				Signature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-		}
-
-		roSidecar, err := blocks.NewRODataColumn(sidecarPb)
-		require.NoError(t, err)
-
-		return roSidecar
-	}
-
-	testCases := []struct {
-		name          string
-		slotIndices   []slotIndex
-		expectedError error
-	}{
-		{
-			name: "too many responses",
-			slotIndices: []slotIndex{
-				{Slot: 1, Index: 1},
-				{Slot: 1, Index: 2},
-				{Slot: 1, Index: 3},
-				{Slot: 2, Index: 1},
-				{Slot: 2, Index: 2},
-				{Slot: 2, Index: 3},
-				{Slot: 1, Index: 3}, // Duplicate
-			},
-			expectedError: errMaxResponseDataColumnSidecarsExceeded,
-		},
-		{
-			name: "perfect match",
-			slotIndices: []slotIndex{
-				{Slot: 1, Index: 1},
-				{Slot: 1, Index: 2},
-				{Slot: 1, Index: 3},
-				{Slot: 2, Index: 1},
-				{Slot: 2, Index: 2},
-				{Slot: 2, Index: 3},
-			},
-		},
-		{
-			name: "few responses than maximum possible",
-			slotIndices: []slotIndex{
-				{Slot: 1, Index: 1},
-				{Slot: 1, Index: 2},
-				{Slot: 1, Index: 3},
-				{Slot: 2, Index: 1},
-				{Slot: 2, Index: 2},
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			protocol := fmt.Sprintf("%s/ssz_snappy", p2p.RPCDataColumnSidecarsByRootTopicV1)
-			clock := startup.NewClock(time.Now(), [fieldparams.RootLength]byte{})
-
-			p1, p2 := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
-			p1.Connect(p2)
-
-			expected := make([]blocks.RODataColumn, 0, len(tc.slotIndices))
-			for _, slotIndex := range tc.slotIndices {
-				roSidecar := createSidecar(slotIndex)
-				expected = append(expected, roSidecar)
-			}
-
-			blockRoot1, blockRoot2 := expected[0].BlockRoot(), expected[3].BlockRoot()
-
-			sentRequest := p2ptypes.DataColumnsByRootIdentifiers{
-				{BlockRoot: blockRoot1[:], Columns: []uint64{1, 2, 3}},
-				{BlockRoot: blockRoot2[:], Columns: []uint64{1, 2, 3}},
-			}
-
-			var wg sync.WaitGroup
-			wg.Add(1)
-
-			p2.SetStreamHandler(protocol, func(stream network.Stream) {
-				wg.Done()
-
-				requestReceived := new(p2ptypes.DataColumnsByRootIdentifiers)
-				err := p2.Encoding().DecodeWithMaxLength(stream, requestReceived)
-				assert.NoError(t, err)
-
-				require.Equal(t, len(sentRequest), len(*requestReceived))
-				for i := range sentRequest {
-					require.DeepSSZEqual(t, (sentRequest)[i], (*requestReceived)[i])
-				}
-
-				for _, sidecar := range expected {
-					err := WriteDataColumnSidecarChunk(stream, clock, p2.Encoding(), sidecar.DataColumnSidecar)
-					assert.NoError(t, err)
-				}
-
-				err = stream.CloseWrite()
-				assert.NoError(t, err)
-			})
-
-			ctx := t.Context()
-			ctxMap := ContextByteVersions{[4]byte{245, 165, 253, 66}: version.Fulu}
-
-			actual, err := SendDataColumnSidecarsByRootRequest(ctx, clock, p1, p2.PeerID(), ctxMap, sentRequest)
-			if tc.expectedError != nil {
-				require.ErrorContains(t, tc.expectedError.Error(), err)
-				if util.WaitTimeout(&wg, time.Second) {
-					t.Fatal("Did not receive stream within 1 sec")
-				}
-
-				return
-			}
-
-			require.Equal(t, len(expected), len(actual))
-			for i := range expected {
-				require.DeepSSZEqual(t, expected[i], actual[i])
-			}
-		})
-	}
-}
-
-func TestIsSidecarIndexRootRequested(t *testing.T) {
-	testCases := []struct {
-		name            string
-		root            [fieldparams.RootLength]byte
-		index           uint64
-		isErrorExpected bool
-	}{
-		{
-			name:            "non requested root",
-			root:            [fieldparams.RootLength]byte{2},
-			isErrorExpected: true,
-		},
-		{
-			name:            "non requested index",
-			root:            [fieldparams.RootLength]byte{1},
-			index:           3,
-			isErrorExpected: true,
-		},
-		{
-			name:            "nominal",
-			root:            [fieldparams.RootLength]byte{1},
-			index:           2,
-			isErrorExpected: false,
-		},
-	}
-
-	request := types.DataColumnsByRootIdentifiers{
-		{BlockRoot: []byte{1}, Columns: []uint64{1, 2}},
-	}
-
-	validator := isSidecarIndexRootRequested(request)
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			const count = 4
-			kzgCommitmentsInclusionProof := make([][]byte, 0, count)
-			for range count {
-				kzgCommitmentsInclusionProof = append(kzgCommitmentsInclusionProof, make([]byte, 32))
-			}
-
-			sidecarPb := &ethpb.DataColumnSidecar{
-				SignedBlockHeader: &ethpb.SignedBeaconBlockHeader{
-					Header: &ethpb.BeaconBlockHeader{
-						ParentRoot: make([]byte, fieldparams.RootLength),
-						StateRoot:  make([]byte, fieldparams.RootLength),
-						BodyRoot:   make([]byte, fieldparams.RootLength),
-					},
-					Signature: make([]byte, fieldparams.BLSSignatureLength),
-				},
-				KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-				Index:                        tc.index,
-			}
-
-			// There is a discrepancy between `tc.root` and the real root,
-			// but we don't care about it here.
-			sidecar, err := blocks.NewRODataColumnWithRoot(sidecarPb, tc.root)
-			require.NoError(t, err)
-
-			err = validator(sidecar)
-			if tc.isErrorExpected {
-				require.NotNil(t, err)
-				return
-			}
-
-			require.NoError(t, err)
-		})
-	}
-}
-
-func TestReadChunkedDataColumnSidecar(t *testing.T) {
-	t.Run("non nil status code", func(t *testing.T) {
-		const reason = "a dummy reason"
-
-		p1, p2 := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
-
-		var wg sync.WaitGroup
-		wg.Add(1)
-		p2.SetStreamHandler(p2p.RPCDataColumnSidecarsByRootTopicV1, func(stream network.Stream) {
-			defer wg.Done()
-
-			_, err := readChunkedDataColumnSidecar(stream, p2, nil)
-			require.ErrorContains(t, reason, err)
-		})
-
-		p1.Connect(p2)
-
-		stream, err := p1.BHost.NewStream(t.Context(), p2.PeerID(), p2p.RPCDataColumnSidecarsByRootTopicV1)
-		require.NoError(t, err)
-
-		writeErrorResponseToStream(responseCodeInvalidRequest, reason, stream, p1)
-
-		if util.WaitTimeout(&wg, time.Second) {
-			t.Fatal("Did not receive stream within 1 sec")
-		}
-	})
-
-	t.Run("unrecognized fork digest", func(t *testing.T) {
-		p1, p2 := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
-
-		var wg sync.WaitGroup
-		wg.Add(1)
-		p2.SetStreamHandler(p2p.RPCDataColumnSidecarsByRootTopicV1, func(stream network.Stream) {
-			defer wg.Done()
-
-			_, err := readChunkedDataColumnSidecar(stream, p2, ContextByteVersions{})
-			require.ErrorContains(t, "unrecognized fork digest", err)
-		})
-
-		p1.Connect(p2)
-
-		stream, err := p1.BHost.NewStream(t.Context(), p2.PeerID(), p2p.RPCDataColumnSidecarsByRootTopicV1)
-		require.NoError(t, err)
-
-		_, err = stream.Write([]byte{responseCodeSuccess})
-		require.NoError(t, err)
-
-		err = writeContextToStream([]byte{42, 42, 42, 42}, stream)
-		require.NoError(t, err)
-
-		if util.WaitTimeout(&wg, time.Second) {
-			t.Fatal("Did not receive stream within 1 sec")
-		}
-	})
-
-	t.Run("before fulu", func(t *testing.T) {
-		p1, p2 := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
-
-		var wg sync.WaitGroup
-		wg.Add(1)
-		p2.SetStreamHandler(p2p.RPCDataColumnSidecarsByRootTopicV1, func(stream network.Stream) {
-			defer wg.Done()
-
-			_, err := readChunkedDataColumnSidecar(stream, p2, ContextByteVersions{[4]byte{1, 2, 3, 4}: version.Phase0})
-			require.ErrorContains(t, "unexpected context bytes", err)
-		})
-
-		p1.Connect(p2)
-
-		stream, err := p1.BHost.NewStream(t.Context(), p2.PeerID(), p2p.RPCDataColumnSidecarsByRootTopicV1)
-		require.NoError(t, err)
-
-		_, err = stream.Write([]byte{responseCodeSuccess})
-		require.NoError(t, err)
-
-		err = writeContextToStream([]byte{1, 2, 3, 4}, stream)
-		require.NoError(t, err)
-
-		if util.WaitTimeout(&wg, time.Second) {
-			t.Fatal("Did not receive stream within 1 sec")
-		}
-	})
-
-	t.Run("one validation failed", func(t *testing.T) {
-		const reason = "a dummy reason"
-
-		p1, p2 := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
-
-		var wg sync.WaitGroup
-		wg.Add(1)
-		p2.SetStreamHandler(p2p.RPCDataColumnSidecarsByRootTopicV1, func(stream network.Stream) {
-			defer wg.Done()
-
-			validationOne := func(column blocks.RODataColumn) error {
-				return nil
-			}
-
-			validationTwo := func(column blocks.RODataColumn) error {
-				return errors.New(reason)
-			}
-
-			_, err := readChunkedDataColumnSidecar(
-				stream,
-				p2,
-				ContextByteVersions{[4]byte{1, 2, 3, 4}: version.Fulu},
-				validationOne, // OK
-				validationTwo, // Fail
-			)
-
-			require.ErrorContains(t, reason, err)
-		})
-
-		p1.Connect(p2)
-
-		stream, err := p1.BHost.NewStream(t.Context(), p2.PeerID(), p2p.RPCDataColumnSidecarsByRootTopicV1)
-		require.NoError(t, err)
-
-		const count = 4
-		kzgCommitmentsInclusionProof := make([][]byte, 0, count)
-		for range count {
-			kzgCommitmentsInclusionProof = append(kzgCommitmentsInclusionProof, make([]byte, 32))
-		}
-
-		// Success response code.
-		_, err = stream.Write([]byte{responseCodeSuccess})
-		require.NoError(t, err)
-
-		// Fork digest.
-		err = writeContextToStream([]byte{1, 2, 3, 4}, stream)
-		require.NoError(t, err)
-
-		// Sidecar.
-		_, err = p1.Encoding().EncodeWithMaxLength(stream, &ethpb.DataColumnSidecar{
-			SignedBlockHeader: &ethpb.SignedBeaconBlockHeader{
-				Header: &ethpb.BeaconBlockHeader{
-					ParentRoot: make([]byte, fieldparams.RootLength),
-					StateRoot:  make([]byte, fieldparams.RootLength),
-					BodyRoot:   make([]byte, fieldparams.RootLength),
-				},
-				Signature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-		})
-		require.NoError(t, err)
-
-		if util.WaitTimeout(&wg, time.Minute) {
-			t.Fatal("Did not receive stream within 1 sec")
-		}
-	})
-
-	t.Run("nominal", func(t *testing.T) {
-		p1, p2 := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
-
-		const count = 4
-		kzgCommitmentsInclusionProof := make([][]byte, 0, count)
-		for range count {
-			kzgCommitmentsInclusionProof = append(kzgCommitmentsInclusionProof, make([]byte, 32))
-		}
-
-		expected := &ethpb.DataColumnSidecar{
-			SignedBlockHeader: &ethpb.SignedBeaconBlockHeader{
-				Header: &ethpb.BeaconBlockHeader{
-					ParentRoot: make([]byte, fieldparams.RootLength),
-					StateRoot:  make([]byte, fieldparams.RootLength),
-					BodyRoot:   make([]byte, fieldparams.RootLength),
-				},
-				Signature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-		}
-
-		var wg sync.WaitGroup
-		wg.Add(1)
-		p2.SetStreamHandler(p2p.RPCDataColumnSidecarsByRootTopicV1, func(stream network.Stream) {
-			defer wg.Done()
-
-			actual, err := readChunkedDataColumnSidecar(stream, p2, ContextByteVersions{[4]byte{1, 2, 3, 4}: version.Fulu})
-			require.NoError(t, err)
-			require.DeepSSZEqual(t, expected, actual.DataColumnSidecar)
-		})
-
-		p1.Connect(p2)
-
-		stream, err := p1.BHost.NewStream(t.Context(), p2.PeerID(), p2p.RPCDataColumnSidecarsByRootTopicV1)
-		require.NoError(t, err)
-
-		// Success response code.
-		_, err = stream.Write([]byte{responseCodeSuccess})
-		require.NoError(t, err)
-
-		// Fork digest.
-		err = writeContextToStream([]byte{1, 2, 3, 4}, stream)
-		require.NoError(t, err)
-
-		// Sidecar.
-		_, err = p1.Encoding().EncodeWithMaxLength(stream, expected)
-		require.NoError(t, err)
-
-		if util.WaitTimeout(&wg, time.Minute) {
-			t.Fatal("Did not receive stream within 1 sec")
-		}
-	})
-}

beacon-chain/sync/sync_test.go

@@ -15,12 +15,10 @@ func TestMain(m *testing.M) {
 
 	resetFlags := flags.Get()
 	flags.Init(&flags.GlobalFlags{
-		BlockBatchLimit:                 64,
-		BlockBatchLimitBurstFactor:      10,
-		BlobBatchLimit:                  32,
-		BlobBatchLimitBurstFactor:       2,
-		DataColumnBatchLimit:            4096,
-		DataColumnBatchLimitBurstFactor: 2,
+		BlockBatchLimit:            64,
+		BlockBatchLimitBurstFactor: 10,
+		BlobBatchLimit:             32,
+		BlobBatchLimitBurstFactor:  2,
 	})
 	defer func() {
 		flags.Init(resetFlags)

beacon-chain/verification/error.go

@@ -30,16 +30,16 @@ var (
 	ErrBlobIndexInvalid = errors.Join(ErrBlobInvalid, errors.New("incorrect blob sidecar index"))
 
 	// errFromFutureSlot means RequireSlotNotTooEarly failed.
-	errFromFutureSlot = errors.New("slot is too far in the future")
+	errFromFutureSlot = errors.Join(ErrBlobInvalid, errors.New("slot is too far in the future"))
 
 	// errSlotNotAfterFinalized means RequireSlotAboveFinalized failed.
-	errSlotNotAfterFinalized = errors.New("slot <= finalized checkpoint")
+	errSlotNotAfterFinalized = errors.Join(ErrBlobInvalid, errors.New("slot <= finalized checkpoint"))
 
 	// ErrInvalidProposerSignature means RequireValidProposerSignature failed.
 	ErrInvalidProposerSignature = errors.Join(ErrBlobInvalid, errors.New("proposer signature could not be verified"))
 
 	// errSidecarParentNotSeen means RequireSidecarParentSeen failed.
-	errSidecarParentNotSeen = errors.New("parent root has not been seen")
+	errSidecarParentNotSeen = errors.Join(ErrBlobInvalid, errors.New("parent root has not been seen"))
 
 	// errSidecarParentInvalid means RequireSidecarParentValid failed.
 	errSidecarParentInvalid = errors.Join(ErrBlobInvalid, errors.New("parent block is not valid"))

changelog/james-prysm_ssz-validator-block.md

@@ -1,7 +0,0 @@
-### Added
-
-- New ssz-only flag for validator client to enable calling rest apis in SSZ, starting with get block endpoint.
-
-### Changed
-
-- when REST api is enabled the get Block api defaults to requesting and receiving SSZ instead of JSON, JSON is the fallback.

changelog/kasey_customize-http-accept-header.md

@@ -1,2 +0,0 @@
-## Added
-- env var to force beacon api client to use a custom accept header (eg force json responses).

changelog/manu-peerdas-beacon-api.md

@@ -1,2 +0,0 @@
-### Added 
-- Implement beacon API blob sidecar enpoint for Fulu.

changelog/manu-peerdas-columns-by-range-handler.md

@@ -1,2 +0,0 @@
-### Added 
-- Implement `dataColumnSidecarsByRangeRPCHandler`.

changelog/manu-peerdas-dataColumnSidecarByRootRPCHandler.md

@@ -1,2 +0,0 @@
-### Fixed 
-- Non deterministic output order of `dataColumnSidecarByRootRPCHandler`. 

changelog/manu-peerdas-send-data-column-requests.md

@@ -1,3 +0,0 @@
-### Added 
-- Implement `SendDataColumnSidecarsByRangeRequest`.
-- Implement `SendDataColumnSidecarsByRootRequest`.

changelog/manu-peerdas-variou.md

@@ -1,9 +0,0 @@
-### Changed 
-- In `TopicFromMessage`: Do not assume anymore that all Fulu specific topic are V3 only.
-- `readChunkedDataColumnSidecar`: Add `validationFunctions` parameter and add tests.
-
-### Added
-- New `StatusV2` proto message.
-
-### Removed
-- Unused `DataColumnIdentifier` proto message.

changelog/rose2221-develop.md

@@ -0,0 +1,5 @@
+### Added
+
+- **Gzip Compression for Beacon API:**  
+  Fixed an issue where the beacon chain server ignored the `Accept-Encoding: gzip` header and returned uncompressed JSON responses. With this change, endpoints that use the `AcceptHeaderHandler` now also compress responses when a client requests gzip encoding. 
+  Fixes [#14593](https://github.com/prysmaticlabs/prysm/issues/14593).

changelog/tt_steak.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Remove "invalid" from logs for incoming blob sidecar that is missing parent or out of range slot

cmd/beacon-chain/flags/base.go

@@ -212,18 +212,11 @@ var (
 		Usage: "The factor by which blob batch limit may increase on burst.",
 		Value: 3,
 	}
-	// DataColumnBatchLimit specifies the requested data column batch size.
 	DataColumnBatchLimit = &cli.IntFlag{
 		Name:  "data-column-batch-limit",
 		Usage: "The amount of data columns the local peer is bounded to request and respond to in a batch.",
 		Value: 4096,
 	}
-	// DataColumnBatchLimitBurstFactor specifies the factor by which data column batch size may increase.
-	DataColumnBatchLimitBurstFactor = &cli.IntFlag{
-		Name:  "data-column-batch-limit-burst-factor",
-		Usage: "The factor by which data column batch limit may increase on burst.",
-		Value: 2,
-	}
 	// DisableDebugRPCEndpoints disables the debug Beacon API namespace.
 	DisableDebugRPCEndpoints = &cli.BoolFlag{
 		Name:  "disable-debug-rpc-endpoints",

cmd/beacon-chain/flags/config.go

@@ -8,17 +8,16 @@ import (
 // GlobalFlags specifies all the global flags for the
 // beacon node.
 type GlobalFlags struct {
-	SubscribeToAllSubnets           bool
-	SubscribeAllDataSubnets         bool
-	MinimumSyncPeers                int
-	MinimumPeersPerSubnet           int
-	MaxConcurrentDials              int
-	BlockBatchLimit                 int
-	BlockBatchLimitBurstFactor      int
-	BlobBatchLimit                  int
-	BlobBatchLimitBurstFactor       int
-	DataColumnBatchLimit            int
-	DataColumnBatchLimitBurstFactor int
+	SubscribeToAllSubnets      bool
+	SubscribeAllDataSubnets    bool
+	MinimumSyncPeers           int
+	MinimumPeersPerSubnet      int
+	MaxConcurrentDials         int
+	BlockBatchLimit            int
+	BlockBatchLimitBurstFactor int
+	BlobBatchLimit             int
+	DataColumnBatchLimit       int
+	BlobBatchLimitBurstFactor  int
 }
 
 var globalConfig *GlobalFlags
@@ -56,10 +55,8 @@ func ConfigureGlobalFlags(ctx *cli.Context) {
 	cfg.BlobBatchLimit = ctx.Int(BlobBatchLimit.Name)
 	cfg.BlobBatchLimitBurstFactor = ctx.Int(BlobBatchLimitBurstFactor.Name)
 	cfg.DataColumnBatchLimit = ctx.Int(DataColumnBatchLimit.Name)
-	cfg.DataColumnBatchLimitBurstFactor = ctx.Int(DataColumnBatchLimitBurstFactor.Name)
 	cfg.MinimumPeersPerSubnet = ctx.Int(MinPeersPerSubnet.Name)
 	cfg.MaxConcurrentDials = ctx.Int(MaxConcurrentDials.Name)
-
 	configureMinimumPeers(ctx, cfg)
 
 	Init(cfg)

config/features/config.go

@@ -52,7 +52,6 @@ type Flags struct {
 	EnableExperimentalAttestationPool   bool // EnableExperimentalAttestationPool enables an experimental attestation pool design.
 	EnableDutiesV2                      bool // EnableDutiesV2 sets validator client to use the get Duties V2 endpoint
 	EnableWeb                           bool // EnableWeb enables the webui on the validator client
-	SSZOnly                             bool // SSZOnly forces the validator client to use SSZ for communication with the beacon node when REST mode is enabled (useful for debugging)
 	// Logging related toggles.
 	DisableGRPCConnectionLogs bool // Disables logging when a new grpc client has connected.
 	EnableFullSSZDataLogging  bool // Enables logging for full ssz data on rejected gossip messages
@@ -345,11 +344,6 @@ func ConfigureValidator(ctx *cli.Context) error {
 		logEnabled(EnableWebFlag)
 		cfg.EnableWeb = true
 	}
-	if ctx.Bool(SSZOnly.Name) {
-		logEnabled(SSZOnly)
-		cfg.SSZOnly = true
-	}
-
 	cfg.KeystoreImportDebounceInterval = ctx.Duration(dynamicKeyReloadDebounceInterval.Name)
 	Init(cfg)
 	return nil

config/features/flags.go

@@ -201,12 +201,6 @@ var (
 		Usage: "(Work in progress): Enables the web portal for the validator client.",
 		Value: false,
 	}
-
-	// SSZOnly forces the validator client to use SSZ for communication with the beacon node when REST mode is enabled
-	SSZOnly = &cli.BoolFlag{
-		Name:  "ssz-only",
-		Usage: "(debug): Forces the validator client to use SSZ for communication with the beacon node when REST mode is enabled",
-	}
 )
 
 // devModeFlags holds list of flags that are set when development mode is on.
@@ -229,7 +223,6 @@ var ValidatorFlags = append(deprecatedFlags, []cli.Flag{
 	EnableBeaconRESTApi,
 	EnableDutiesV2,
 	EnableWebFlag,
-	SSZOnly,
 }...)
 
 // E2EValidatorFlags contains a list of the validator feature flags to be tested in E2E.

proto/prysm/v1alpha1/BUILD.bazel

@@ -2,13 +2,14 @@
 # Common
 ##############################################################################
 
+load("@rules_proto//proto:defs.bzl", "proto_library")
+
 ##############################################################################
 # Go
 ##############################################################################
 # gazelle:ignore
 load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 load("@io_bazel_rules_go//proto:def.bzl", "go_proto_library")
-load("@rules_proto//proto:defs.bzl", "proto_library")
 load("//proto:ssz_proto_library.bzl", "ssz_proto_files")
 load("//tools:ssz.bzl", "SSZ_DEPS", "ssz_gen_marshal")
 
@@ -188,7 +189,6 @@ ssz_fulu_objs = [
     "DataColumnIdentifier",
     "DataColumnsByRootIdentifier",
     "DataColumnSidecar",
-    "StatusV2",
     "SignedBeaconBlockContentsFulu",
     "SignedBeaconBlockFulu",
     "SignedBlindedBeaconBlockFulu",
@@ -359,17 +359,15 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1",
     visibility = ["//visibility:public"],
     deps = SSZ_DEPS + [
-        "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/ext:go_default_library",
         "//runtime/version:go_default_library",
-        "@com_github_golang_protobuf//proto:go_default_library",
+        "//consensus-types/primitives:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_golang_protobuf//proto:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",  # keep
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@googleapis//google/api:annotations_go_proto",
         "@io_bazel_rules_go//proto/wkt:descriptor_go_proto",
         "@io_bazel_rules_go//proto/wkt:empty_go_proto",
@@ -384,6 +382,8 @@ go_library(
         "@org_golang_google_protobuf//runtime/protoimpl:go_default_library",
         "@org_golang_google_protobuf//types/descriptorpb:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
     ],
 )
 

proto/prysm/v1alpha1/beacon_block.go

@@ -5,12 +5,6 @@ import (
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 )
 
-// GenericConverter defines any struct that can be converted to a generic beacon block.
-// We assume all your versioned block structs implement this method.
-type GenericConverter interface {
-	ToGeneric() (*GenericBeaconBlock, error)
-}
-
 // ----------------------------------------------------------------------------
 // Phase 0
 // ----------------------------------------------------------------------------

proto/prysm/v1alpha1/data_columns.pb.go

@@ -109,6 +109,61 @@ func (x *DataColumnSidecar) GetKzgCommitmentsInclusionProof() [][]byte {
 	return nil
 }
 
+type DataColumnIdentifier struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	BlockRoot []byte `protobuf:"bytes,1,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty" ssz-size:"32"`
+	Index     uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
+}
+
+func (x *DataColumnIdentifier) Reset() {
+	*x = DataColumnIdentifier{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DataColumnIdentifier) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DataColumnIdentifier) ProtoMessage() {}
+
+func (x *DataColumnIdentifier) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_prysm_v1alpha1_data_columns_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 DataColumnIdentifier.ProtoReflect.Descriptor instead.
+func (*DataColumnIdentifier) Descriptor() ([]byte, []int) {
+	return file_proto_prysm_v1alpha1_data_columns_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *DataColumnIdentifier) GetBlockRoot() []byte {
+	if x != nil {
+		return x.BlockRoot
+	}
+	return nil
+}
+
+func (x *DataColumnIdentifier) GetIndex() uint64 {
+	if x != nil {
+		return x.Index
+	}
+	return 0
+}
+
 type DataColumnsByRootIdentifier struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -121,7 +176,7 @@ type DataColumnsByRootIdentifier struct {
 func (x *DataColumnsByRootIdentifier) Reset() {
 	*x = DataColumnsByRootIdentifier{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[1]
+		mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[2]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -134,7 +189,7 @@ func (x *DataColumnsByRootIdentifier) String() string {
 func (*DataColumnsByRootIdentifier) ProtoMessage() {}
 
 func (x *DataColumnsByRootIdentifier) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[1]
+	mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[2]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -147,7 +202,7 @@ func (x *DataColumnsByRootIdentifier) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DataColumnsByRootIdentifier.ProtoReflect.Descriptor instead.
 func (*DataColumnsByRootIdentifier) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_data_columns_proto_rawDescGZIP(), []int{1}
+	return file_proto_prysm_v1alpha1_data_columns_proto_rawDescGZIP(), []int{2}
 }
 
 func (x *DataColumnsByRootIdentifier) GetBlockRoot() []byte {
@@ -198,24 +253,29 @@ var file_proto_prysm_v1alpha1_data_columns_proto_rawDesc = []byte{
 	0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x06, 0x20,
 	0x03, 0x28, 0x0c, 0x42, 0x08, 0x8a, 0xb5, 0x18, 0x04, 0x34, 0x2c, 0x33, 0x32, 0x52, 0x1c, 0x6b,
 	0x7a, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e, 0x63,
-	0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x67, 0x0a, 0x1b, 0x44,
-	0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x42, 0x79, 0x52, 0x6f, 0x6f, 0x74,
-	0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x25, 0x0a, 0x0a, 0x62, 0x6c,
-	0x6f, 0x63, 0x6b, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06,
-	0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f,
-	0x74, 0x12, 0x21, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03,
-	0x28, 0x04, 0x42, 0x07, 0x92, 0xb5, 0x18, 0x03, 0x31, 0x32, 0x38, 0x52, 0x07, 0x63, 0x6f, 0x6c,
-	0x75, 0x6d, 0x6e, 0x73, 0x42, 0x9a, 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, 0x10, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x50,
-	0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
-	0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f,
-	0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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,
+	0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0x53, 0x0a, 0x14, 0x44,
+	0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66,
+	0x69, 0x65, 0x72, 0x12, 0x25, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x72, 0x6f, 0x6f,
+	0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52,
+	0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e,
+	0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78,
+	0x22, 0x67, 0x0a, 0x1b, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x42,
+	0x79, 0x52, 0x6f, 0x6f, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12,
+	0x25, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x09, 0x62, 0x6c, 0x6f,
+	0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x21, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
+	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x04, 0x42, 0x07, 0x92, 0xb5, 0x18, 0x03, 0x31, 0x32, 0x38,
+	0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x42, 0x9a, 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, 0x10, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c,
+	0x75, 0x6d, 0x6e, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x39, 0x67, 0x69, 0x74,
+	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e,
+	0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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 (
@@ -230,14 +290,15 @@ func file_proto_prysm_v1alpha1_data_columns_proto_rawDescGZIP() []byte {
 	return file_proto_prysm_v1alpha1_data_columns_proto_rawDescData
 }
 
-var file_proto_prysm_v1alpha1_data_columns_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_proto_prysm_v1alpha1_data_columns_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
 var file_proto_prysm_v1alpha1_data_columns_proto_goTypes = []interface{}{
 	(*DataColumnSidecar)(nil),           // 0: ethereum.eth.v1alpha1.DataColumnSidecar
-	(*DataColumnsByRootIdentifier)(nil), // 1: ethereum.eth.v1alpha1.DataColumnsByRootIdentifier
-	(*SignedBeaconBlockHeader)(nil),     // 2: ethereum.eth.v1alpha1.SignedBeaconBlockHeader
+	(*DataColumnIdentifier)(nil),        // 1: ethereum.eth.v1alpha1.DataColumnIdentifier
+	(*DataColumnsByRootIdentifier)(nil), // 2: ethereum.eth.v1alpha1.DataColumnsByRootIdentifier
+	(*SignedBeaconBlockHeader)(nil),     // 3: ethereum.eth.v1alpha1.SignedBeaconBlockHeader
 }
 var file_proto_prysm_v1alpha1_data_columns_proto_depIdxs = []int32{
-	2, // 0: ethereum.eth.v1alpha1.DataColumnSidecar.signed_block_header:type_name -> ethereum.eth.v1alpha1.SignedBeaconBlockHeader
+	3, // 0: ethereum.eth.v1alpha1.DataColumnSidecar.signed_block_header:type_name -> ethereum.eth.v1alpha1.SignedBeaconBlockHeader
 	1, // [1:1] is the sub-list for method output_type
 	1, // [1:1] is the sub-list for method input_type
 	1, // [1:1] is the sub-list for extension type_name
@@ -265,6 +326,18 @@ func file_proto_prysm_v1alpha1_data_columns_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DataColumnIdentifier); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DataColumnsByRootIdentifier); i {
 			case 0:
 				return &v.state
@@ -283,7 +356,7 @@ func file_proto_prysm_v1alpha1_data_columns_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_prysm_v1alpha1_data_columns_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   2,
+			NumMessages:   3,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

proto/prysm/v1alpha1/data_columns.proto

@@ -45,6 +45,11 @@ message DataColumnSidecar {
             "kzg_commitments_inclusion_proof_depth.size,32" ];
 }
 
+message DataColumnIdentifier {
+  bytes block_root = 1 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  uint64 index = 2;
+}
+
 message DataColumnsByRootIdentifier {
   bytes block_root = 1 [ (ethereum.eth.ext.ssz_size) = "32" ];
   repeated uint64 columns = 2  [ (ethereum.eth.ext.ssz_max) = "128" ];

proto/prysm/v1alpha1/fulu.ssz.go

@@ -2246,6 +2246,77 @@ func (d *DataColumnSidecar) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 	return
 }
 
+// MarshalSSZ ssz marshals the DataColumnIdentifier object
+func (d *DataColumnIdentifier) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(d)
+}
+
+// MarshalSSZTo ssz marshals the DataColumnIdentifier object to a target array
+func (d *DataColumnIdentifier) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+
+	// Field (0) 'BlockRoot'
+	if size := len(d.BlockRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockRoot", size, 32)
+		return
+	}
+	dst = append(dst, d.BlockRoot...)
+
+	// Field (1) 'Index'
+	dst = ssz.MarshalUint64(dst, d.Index)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the DataColumnIdentifier object
+func (d *DataColumnIdentifier) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size != 40 {
+		return ssz.ErrSize
+	}
+
+	// Field (0) 'BlockRoot'
+	if cap(d.BlockRoot) == 0 {
+		d.BlockRoot = make([]byte, 0, len(buf[0:32]))
+	}
+	d.BlockRoot = append(d.BlockRoot, buf[0:32]...)
+
+	// Field (1) 'Index'
+	d.Index = ssz.UnmarshallUint64(buf[32:40])
+
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the DataColumnIdentifier object
+func (d *DataColumnIdentifier) SizeSSZ() (size int) {
+	size = 40
+	return
+}
+
+// HashTreeRoot ssz hashes the DataColumnIdentifier object
+func (d *DataColumnIdentifier) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(d)
+}
+
+// HashTreeRootWith ssz hashes the DataColumnIdentifier object with a hasher
+func (d *DataColumnIdentifier) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'BlockRoot'
+	if size := len(d.BlockRoot); size != 32 {
+		err = ssz.ErrBytesLengthFn("--.BlockRoot", size, 32)
+		return
+	}
+	hh.PutBytes(d.BlockRoot)
+
+	// Field (1) 'Index'
+	hh.PutUint64(d.Index)
+
+	hh.Merkleize(indx)
+	return
+}
+
 // MarshalSSZ ssz marshals the DataColumnsByRootIdentifier object
 func (d *DataColumnsByRootIdentifier) MarshalSSZ() ([]byte, error) {
 	return ssz.MarshalSSZ(d)
@@ -2365,132 +2436,3 @@ func (d *DataColumnsByRootIdentifier) HashTreeRootWith(hh *ssz.Hasher) (err erro
 	hh.Merkleize(indx)
 	return
 }
-
-// MarshalSSZ ssz marshals the StatusV2 object
-func (s *StatusV2) MarshalSSZ() ([]byte, error) {
-	return ssz.MarshalSSZ(s)
-}
-
-// MarshalSSZTo ssz marshals the StatusV2 object to a target array
-func (s *StatusV2) MarshalSSZTo(buf []byte) (dst []byte, err error) {
-	dst = buf
-
-	// Field (0) 'ForkDigest'
-	if size := len(s.ForkDigest); size != 4 {
-		err = ssz.ErrBytesLengthFn("--.ForkDigest", size, 4)
-		return
-	}
-	dst = append(dst, s.ForkDigest...)
-
-	// Field (1) 'FinalizedRoot'
-	if size := len(s.FinalizedRoot); size != 32 {
-		err = ssz.ErrBytesLengthFn("--.FinalizedRoot", size, 32)
-		return
-	}
-	dst = append(dst, s.FinalizedRoot...)
-
-	// Field (2) 'FinalizedEpoch'
-	dst = ssz.MarshalUint64(dst, uint64(s.FinalizedEpoch))
-
-	// Field (3) 'HeadRoot'
-	if size := len(s.HeadRoot); size != 32 {
-		err = ssz.ErrBytesLengthFn("--.HeadRoot", size, 32)
-		return
-	}
-	dst = append(dst, s.HeadRoot...)
-
-	// Field (4) 'HeadSlot'
-	dst = ssz.MarshalUint64(dst, uint64(s.HeadSlot))
-
-	// Field (5) 'EarliestAvailableSlot'
-	dst = ssz.MarshalUint64(dst, uint64(s.EarliestAvailableSlot))
-
-	return
-}
-
-// UnmarshalSSZ ssz unmarshals the StatusV2 object
-func (s *StatusV2) UnmarshalSSZ(buf []byte) error {
-	var err error
-	size := uint64(len(buf))
-	if size != 92 {
-		return ssz.ErrSize
-	}
-
-	// Field (0) 'ForkDigest'
-	if cap(s.ForkDigest) == 0 {
-		s.ForkDigest = make([]byte, 0, len(buf[0:4]))
-	}
-	s.ForkDigest = append(s.ForkDigest, buf[0:4]...)
-
-	// Field (1) 'FinalizedRoot'
-	if cap(s.FinalizedRoot) == 0 {
-		s.FinalizedRoot = make([]byte, 0, len(buf[4:36]))
-	}
-	s.FinalizedRoot = append(s.FinalizedRoot, buf[4:36]...)
-
-	// Field (2) 'FinalizedEpoch'
-	s.FinalizedEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[36:44]))
-
-	// Field (3) 'HeadRoot'
-	if cap(s.HeadRoot) == 0 {
-		s.HeadRoot = make([]byte, 0, len(buf[44:76]))
-	}
-	s.HeadRoot = append(s.HeadRoot, buf[44:76]...)
-
-	// Field (4) 'HeadSlot'
-	s.HeadSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[76:84]))
-
-	// Field (5) 'EarliestAvailableSlot'
-	s.EarliestAvailableSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[84:92]))
-
-	return err
-}
-
-// SizeSSZ returns the ssz encoded size in bytes for the StatusV2 object
-func (s *StatusV2) SizeSSZ() (size int) {
-	size = 92
-	return
-}
-
-// HashTreeRoot ssz hashes the StatusV2 object
-func (s *StatusV2) HashTreeRoot() ([32]byte, error) {
-	return ssz.HashWithDefaultHasher(s)
-}
-
-// HashTreeRootWith ssz hashes the StatusV2 object with a hasher
-func (s *StatusV2) HashTreeRootWith(hh *ssz.Hasher) (err error) {
-	indx := hh.Index()
-
-	// Field (0) 'ForkDigest'
-	if size := len(s.ForkDigest); size != 4 {
-		err = ssz.ErrBytesLengthFn("--.ForkDigest", size, 4)
-		return
-	}
-	hh.PutBytes(s.ForkDigest)
-
-	// Field (1) 'FinalizedRoot'
-	if size := len(s.FinalizedRoot); size != 32 {
-		err = ssz.ErrBytesLengthFn("--.FinalizedRoot", size, 32)
-		return
-	}
-	hh.PutBytes(s.FinalizedRoot)
-
-	// Field (2) 'FinalizedEpoch'
-	hh.PutUint64(uint64(s.FinalizedEpoch))
-
-	// Field (3) 'HeadRoot'
-	if size := len(s.HeadRoot); size != 32 {
-		err = ssz.ErrBytesLengthFn("--.HeadRoot", size, 32)
-		return
-	}
-	hh.PutBytes(s.HeadRoot)
-
-	// Field (4) 'HeadSlot'
-	hh.PutUint64(uint64(s.HeadSlot))
-
-	// Field (5) 'EarliestAvailableSlot'
-	hh.PutUint64(uint64(s.EarliestAvailableSlot))
-
-	hh.Merkleize(indx)
-	return
-}

proto/prysm/v1alpha1/p2p_messages.pb.go

@@ -104,93 +104,6 @@ func (x *Status) GetHeadSlot() github_com_OffchainLabs_prysm_v6_consensus_types_
 	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(0)
 }
 
-type StatusV2 struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	ForkDigest            []byte                                                            `protobuf:"bytes,1,opt,name=fork_digest,json=forkDigest,proto3" json:"fork_digest,omitempty" ssz-size:"4"`
-	FinalizedRoot         []byte                                                            `protobuf:"bytes,2,opt,name=finalized_root,json=finalizedRoot,proto3" json:"finalized_root,omitempty" ssz-size:"32"`
-	FinalizedEpoch        github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch `protobuf:"varint,3,opt,name=finalized_epoch,json=finalizedEpoch,proto3" json:"finalized_epoch,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Epoch"`
-	HeadRoot              []byte                                                            `protobuf:"bytes,4,opt,name=head_root,json=headRoot,proto3" json:"head_root,omitempty" ssz-size:"32"`
-	HeadSlot              github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot  `protobuf:"varint,5,opt,name=head_slot,json=headSlot,proto3" json:"head_slot,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Slot"`
-	EarliestAvailableSlot github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot  `protobuf:"varint,6,opt,name=earliest_available_slot,json=earliestAvailableSlot,proto3" json:"earliest_available_slot,omitempty" cast-type:"github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Slot"`
-}
-
-func (x *StatusV2) Reset() {
-	*x = StatusV2{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *StatusV2) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*StatusV2) ProtoMessage() {}
-
-func (x *StatusV2) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_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 StatusV2.ProtoReflect.Descriptor instead.
-func (*StatusV2) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *StatusV2) GetForkDigest() []byte {
-	if x != nil {
-		return x.ForkDigest
-	}
-	return nil
-}
-
-func (x *StatusV2) GetFinalizedRoot() []byte {
-	if x != nil {
-		return x.FinalizedRoot
-	}
-	return nil
-}
-
-func (x *StatusV2) GetFinalizedEpoch() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch {
-	if x != nil {
-		return x.FinalizedEpoch
-	}
-	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(0)
-}
-
-func (x *StatusV2) GetHeadRoot() []byte {
-	if x != nil {
-		return x.HeadRoot
-	}
-	return nil
-}
-
-func (x *StatusV2) GetHeadSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
-	if x != nil {
-		return x.HeadSlot
-	}
-	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(0)
-}
-
-func (x *StatusV2) GetEarliestAvailableSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
-	if x != nil {
-		return x.EarliestAvailableSlot
-	}
-	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(0)
-}
-
 type BeaconBlocksByRangeRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -204,7 +117,7 @@ type BeaconBlocksByRangeRequest struct {
 func (x *BeaconBlocksByRangeRequest) Reset() {
 	*x = BeaconBlocksByRangeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[1]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -217,7 +130,7 @@ func (x *BeaconBlocksByRangeRequest) String() string {
 func (*BeaconBlocksByRangeRequest) ProtoMessage() {}
 
 func (x *BeaconBlocksByRangeRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2]
+	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[1]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -230,7 +143,7 @@ func (x *BeaconBlocksByRangeRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use BeaconBlocksByRangeRequest.ProtoReflect.Descriptor instead.
 func (*BeaconBlocksByRangeRequest) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{2}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{1}
 }
 
 func (x *BeaconBlocksByRangeRequest) GetStartSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
@@ -267,7 +180,7 @@ type ENRForkID struct {
 func (x *ENRForkID) Reset() {
 	*x = ENRForkID{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -280,7 +193,7 @@ func (x *ENRForkID) String() string {
 func (*ENRForkID) ProtoMessage() {}
 
 func (x *ENRForkID) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3]
+	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -293,7 +206,7 @@ func (x *ENRForkID) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ENRForkID.ProtoReflect.Descriptor instead.
 func (*ENRForkID) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{3}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{2}
 }
 
 func (x *ENRForkID) GetCurrentForkDigest() []byte {
@@ -329,7 +242,7 @@ type MetaDataV0 struct {
 func (x *MetaDataV0) Reset() {
 	*x = MetaDataV0{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -342,7 +255,7 @@ func (x *MetaDataV0) String() string {
 func (*MetaDataV0) ProtoMessage() {}
 
 func (x *MetaDataV0) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4]
+	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -355,7 +268,7 @@ func (x *MetaDataV0) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use MetaDataV0.ProtoReflect.Descriptor instead.
 func (*MetaDataV0) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{4}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{3}
 }
 
 func (x *MetaDataV0) GetSeqNumber() uint64 {
@@ -385,7 +298,7 @@ type MetaDataV1 struct {
 func (x *MetaDataV1) Reset() {
 	*x = MetaDataV1{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -398,7 +311,7 @@ func (x *MetaDataV1) String() string {
 func (*MetaDataV1) ProtoMessage() {}
 
 func (x *MetaDataV1) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5]
+	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -411,7 +324,7 @@ func (x *MetaDataV1) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use MetaDataV1.ProtoReflect.Descriptor instead.
 func (*MetaDataV1) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{5}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{4}
 }
 
 func (x *MetaDataV1) GetSeqNumber() uint64 {
@@ -449,7 +362,7 @@ type MetaDataV2 struct {
 func (x *MetaDataV2) Reset() {
 	*x = MetaDataV2{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -462,7 +375,7 @@ func (x *MetaDataV2) String() string {
 func (*MetaDataV2) ProtoMessage() {}
 
 func (x *MetaDataV2) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6]
+	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -475,7 +388,7 @@ func (x *MetaDataV2) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use MetaDataV2.ProtoReflect.Descriptor instead.
 func (*MetaDataV2) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{6}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{5}
 }
 
 func (x *MetaDataV2) GetSeqNumber() uint64 {
@@ -518,7 +431,7 @@ type BlobSidecarsByRangeRequest struct {
 func (x *BlobSidecarsByRangeRequest) Reset() {
 	*x = BlobSidecarsByRangeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -531,7 +444,7 @@ func (x *BlobSidecarsByRangeRequest) String() string {
 func (*BlobSidecarsByRangeRequest) ProtoMessage() {}
 
 func (x *BlobSidecarsByRangeRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7]
+	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -544,7 +457,7 @@ func (x *BlobSidecarsByRangeRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use BlobSidecarsByRangeRequest.ProtoReflect.Descriptor instead.
 func (*BlobSidecarsByRangeRequest) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{7}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{6}
 }
 
 func (x *BlobSidecarsByRangeRequest) GetStartSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
@@ -574,7 +487,7 @@ type DataColumnSidecarsByRangeRequest struct {
 func (x *DataColumnSidecarsByRangeRequest) Reset() {
 	*x = DataColumnSidecarsByRangeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -587,7 +500,7 @@ func (x *DataColumnSidecarsByRangeRequest) String() string {
 func (*DataColumnSidecarsByRangeRequest) ProtoMessage() {}
 
 func (x *DataColumnSidecarsByRangeRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8]
+	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -600,7 +513,7 @@ func (x *DataColumnSidecarsByRangeRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DataColumnSidecarsByRangeRequest.ProtoReflect.Descriptor instead.
 func (*DataColumnSidecarsByRangeRequest) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{8}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{7}
 }
 
 func (x *DataColumnSidecarsByRangeRequest) GetStartSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
@@ -636,7 +549,7 @@ type LightClientUpdatesByRangeRequest struct {
 func (x *LightClientUpdatesByRangeRequest) Reset() {
 	*x = LightClientUpdatesByRangeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[9]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -649,7 +562,7 @@ func (x *LightClientUpdatesByRangeRequest) String() string {
 func (*LightClientUpdatesByRangeRequest) ProtoMessage() {}
 
 func (x *LightClientUpdatesByRangeRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[9]
+	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -662,7 +575,7 @@ func (x *LightClientUpdatesByRangeRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LightClientUpdatesByRangeRequest.ProtoReflect.Descriptor instead.
 func (*LightClientUpdatesByRangeRequest) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{9}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{8}
 }
 
 func (x *LightClientUpdatesByRangeRequest) GetStartPeriod() uint64 {
@@ -711,38 +624,72 @@ var file_proto_prysm_v1alpha1_p2p_messages_proto_rawDesc = []byte{
 	0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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,
-	0x08, 0x68, 0x65, 0x61, 0x64, 0x53, 0x6c, 0x6f, 0x74, 0x22, 0xd7, 0x03, 0x0a, 0x08, 0x53, 0x74,
-	0x61, 0x74, 0x75, 0x73, 0x56, 0x32, 0x12, 0x26, 0x0a, 0x0b, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x64,
-	0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x05, 0x8a, 0xb5, 0x18,
-	0x01, 0x34, 0x52, 0x0a, 0x66, 0x6f, 0x72, 0x6b, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x2d,
-	0x0a, 0x0e, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x72, 0x6f, 0x6f, 0x74,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x0d,
-	0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x6e, 0x0a,
-	0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68,
-	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c,
-	0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x0e, 0x66,
-	0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x23, 0x0a,
-	0x09, 0x68, 0x65, 0x61, 0x64, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c,
-	0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x08, 0x68, 0x65, 0x61, 0x64, 0x52, 0x6f,
-	0x6f, 0x74, 0x12, 0x61, 0x0a, 0x09, 0x68, 0x65, 0x61, 0x64, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18,
-	0x05, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68, 0x75,
-	0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61,
-	0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x08, 0x68, 0x65, 0x61,
-	0x64, 0x53, 0x6c, 0x6f, 0x74, 0x12, 0x7c, 0x0a, 0x17, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x73,
-	0x74, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x73, 0x6c, 0x6f, 0x74,
-	0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68,
-	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c,
-	0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x15, 0x65, 0x61,
-	0x72, 0x6c, 0x69, 0x65, 0x73, 0x74, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x53,
-	0x6c, 0x6f, 0x74, 0x22, 0xab, 0x01, 0x0a, 0x1a, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c,
-	0x6f, 0x63, 0x6b, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x08, 0x68, 0x65, 0x61, 0x64, 0x53, 0x6c, 0x6f, 0x74, 0x22, 0xab, 0x01, 0x0a, 0x1a, 0x42, 0x65,
+	0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67,
+	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x63, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72,
+	0x74, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5,
+	0x18, 0x40, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66,
+	0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f,
+	0x76, 0x36, 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, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x53, 0x6c, 0x6f, 0x74, 0x12, 0x14, 0x0a,
+	0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f,
+	0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x74, 0x65, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x04, 0x73, 0x74, 0x65, 0x70, 0x22, 0xe4, 0x01, 0x0a, 0x09, 0x45, 0x4e, 0x52, 0x46,
+	0x6f, 0x72, 0x6b, 0x49, 0x44, 0x12, 0x35, 0x0a, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+	0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0c, 0x42, 0x05, 0x8a, 0xb5, 0x18, 0x01, 0x34, 0x52, 0x11, 0x63, 0x75, 0x72, 0x72, 0x65,
+	0x6e, 0x74, 0x46, 0x6f, 0x72, 0x6b, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x31, 0x0a, 0x11,
+	0x6e, 0x65, 0x78, 0x74, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+	0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x05, 0x8a, 0xb5, 0x18, 0x01, 0x34, 0x52, 0x0f,
+	0x6e, 0x65, 0x78, 0x74, 0x46, 0x6f, 0x72, 0x6b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12,
+	0x6d, 0x0a, 0x0f, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x65, 0x70, 0x6f,
+	0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69,
+	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69,
+	0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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,
+	0x0d, 0x6e, 0x65, 0x78, 0x74, 0x46, 0x6f, 0x72, 0x6b, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x22, 0x80,
+	0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74, 0x61, 0x56, 0x30, 0x12, 0x1d, 0x0a,
+	0x0a, 0x73, 0x65, 0x71, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x09, 0x73, 0x65, 0x71, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x53, 0x0a, 0x07,
+	0x61, 0x74, 0x74, 0x6e, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x39, 0x82,
+	0xb5, 0x18, 0x30, 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, 0x36, 0x34, 0x8a, 0xb5, 0x18, 0x01, 0x38, 0x52, 0x07, 0x61, 0x74, 0x74, 0x6e, 0x65, 0x74,
+	0x73, 0x22, 0xd6, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74, 0x61, 0x56, 0x31,
+	0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x71, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x73, 0x65, 0x71, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12,
+	0x53, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x6e, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c,
+	0x42, 0x39, 0x82, 0xb5, 0x18, 0x30, 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, 0x36, 0x34, 0x8a, 0xb5, 0x18, 0x01, 0x38, 0x52, 0x07, 0x61, 0x74, 0x74,
+	0x6e, 0x65, 0x74, 0x73, 0x12, 0x54, 0x0a, 0x08, 0x73, 0x79, 0x6e, 0x63, 0x6e, 0x65, 0x74, 0x73,
+	0x18, 0x03, 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, 0x08, 0x73, 0x79, 0x6e, 0x63, 0x6e, 0x65, 0x74, 0x73, 0x22, 0x86, 0x02, 0x0a, 0x0a, 0x4d,
+	0x65, 0x74, 0x61, 0x44, 0x61, 0x74, 0x61, 0x56, 0x32, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x71,
+	0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x73,
+	0x65, 0x71, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x53, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x6e,
+	0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x39, 0x82, 0xb5, 0x18, 0x30, 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, 0x36, 0x34, 0x8a,
+	0xb5, 0x18, 0x01, 0x38, 0x52, 0x07, 0x61, 0x74, 0x74, 0x6e, 0x65, 0x74, 0x73, 0x12, 0x54, 0x0a,
+	0x08, 0x73, 0x79, 0x6e, 0x63, 0x6e, 0x65, 0x74, 0x73, 0x18, 0x03, 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, 0x08, 0x73, 0x79, 0x6e, 0x63, 0x6e,
+	0x65, 0x74, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x64, 0x79, 0x5f, 0x67,
+	0x72, 0x6f, 0x75, 0x70, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x11, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x64, 0x79, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f,
+	0x75, 0x6e, 0x74, 0x22, 0x97, 0x01, 0x0a, 0x1a, 0x42, 0x6c, 0x6f, 0x62, 0x53, 0x69, 0x64, 0x65,
+	0x63, 0x61, 0x72, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
 	0x73, 0x74, 0x12, 0x63, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x73, 0x6c, 0x6f, 0x74,
 	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68,
 	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c,
@@ -750,99 +697,36 @@ var file_proto_prysm_v1alpha1_p2p_messages_proto_rawDesc = []byte{
 	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, 0x09, 0x73, 0x74,
 	0x61, 0x72, 0x74, 0x53, 0x6c, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a,
-	0x04, 0x73, 0x74, 0x65, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x73, 0x74, 0x65,
-	0x70, 0x22, 0xe4, 0x01, 0x0a, 0x09, 0x45, 0x4e, 0x52, 0x46, 0x6f, 0x72, 0x6b, 0x49, 0x44, 0x12,
-	0x35, 0x0a, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x5f,
-	0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x05, 0x8a, 0xb5,
-	0x18, 0x01, 0x34, 0x52, 0x11, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x46, 0x6f, 0x72, 0x6b,
-	0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x31, 0x0a, 0x11, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x66,
-	0x6f, 0x72, 0x6b, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x0c, 0x42, 0x05, 0x8a, 0xb5, 0x18, 0x01, 0x34, 0x52, 0x0f, 0x6e, 0x65, 0x78, 0x74, 0x46, 0x6f,
-	0x72, 0x6b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x6d, 0x0a, 0x0f, 0x6e, 0x65, 0x78,
-	0x74, 0x5f, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
-	0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f,
-	0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x0d, 0x6e, 0x65, 0x78, 0x74, 0x46,
-	0x6f, 0x72, 0x6b, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x22, 0x80, 0x01, 0x0a, 0x0a, 0x4d, 0x65, 0x74,
-	0x61, 0x44, 0x61, 0x74, 0x61, 0x56, 0x30, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x71, 0x5f, 0x6e,
-	0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x73, 0x65, 0x71,
-	0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x53, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x6e, 0x65, 0x74,
-	0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x39, 0x82, 0xb5, 0x18, 0x30, 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, 0x36, 0x34, 0x8a, 0xb5, 0x18,
-	0x01, 0x38, 0x52, 0x07, 0x61, 0x74, 0x74, 0x6e, 0x65, 0x74, 0x73, 0x22, 0xd6, 0x01, 0x0a, 0x0a,
-	0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74, 0x61, 0x56, 0x31, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65,
-	0x71, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09,
-	0x73, 0x65, 0x71, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x53, 0x0a, 0x07, 0x61, 0x74, 0x74,
-	0x6e, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x39, 0x82, 0xb5, 0x18, 0x30,
-	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, 0x36, 0x34,
-	0x8a, 0xb5, 0x18, 0x01, 0x38, 0x52, 0x07, 0x61, 0x74, 0x74, 0x6e, 0x65, 0x74, 0x73, 0x12, 0x54,
-	0x0a, 0x08, 0x73, 0x79, 0x6e, 0x63, 0x6e, 0x65, 0x74, 0x73, 0x18, 0x03, 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, 0x08, 0x73, 0x79, 0x6e, 0x63,
-	0x6e, 0x65, 0x74, 0x73, 0x22, 0x86, 0x02, 0x0a, 0x0a, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74,
-	0x61, 0x56, 0x32, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x71, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65,
-	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x73, 0x65, 0x71, 0x4e, 0x75, 0x6d, 0x62,
-	0x65, 0x72, 0x12, 0x53, 0x0a, 0x07, 0x61, 0x74, 0x74, 0x6e, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x0c, 0x42, 0x39, 0x82, 0xb5, 0x18, 0x30, 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, 0x36, 0x34, 0x8a, 0xb5, 0x18, 0x01, 0x38, 0x52, 0x07,
-	0x61, 0x74, 0x74, 0x6e, 0x65, 0x74, 0x73, 0x12, 0x54, 0x0a, 0x08, 0x73, 0x79, 0x6e, 0x63, 0x6e,
-	0x65, 0x74, 0x73, 0x18, 0x03, 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, 0x08, 0x73, 0x79, 0x6e, 0x63, 0x6e, 0x65, 0x74, 0x73, 0x12, 0x2e, 0x0a,
-	0x13, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x64, 0x79, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x63,
-	0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x63, 0x75, 0x73, 0x74,
-	0x6f, 0x64, 0x79, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x97, 0x01,
-	0x0a, 0x1a, 0x42, 0x6c, 0x6f, 0x62, 0x53, 0x69, 0x64, 0x65, 0x63, 0x61, 0x72, 0x73, 0x42, 0x79,
-	0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x63, 0x0a, 0x0a,
-	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
-	0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
-	0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72,
-	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x53, 0x6c, 0x6f,
-	0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xc0, 0x01, 0x0a, 0x20, 0x44, 0x61, 0x74, 0x61,
-	0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x53, 0x69, 0x64, 0x65, 0x63, 0x61, 0x72, 0x73, 0x42, 0x79,
-	0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x63, 0x0a, 0x0a,
-	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
-	0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
-	0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72,
-	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x53, 0x6c, 0x6f,
-	0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d,
-	0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x04, 0x42, 0x07, 0x92, 0xb5, 0x18, 0x03, 0x31, 0x32,
-	0x38, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x22, 0x5b, 0x0a, 0x20, 0x4c, 0x69,
-	0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73,
-	0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21,
-	0x0a, 0x0c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x65, 0x72, 0x69, 0x6f,
-	0x64, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x9a, 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, 0x10, 0x50, 0x32, 0x50, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75,
-	0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61,
-	0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x56, 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,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xc0, 0x01,
+	0x0a, 0x20, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x53, 0x69, 0x64, 0x65,
+	0x63, 0x61, 0x72, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x63, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x73, 0x6c, 0x6f, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68,
+	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c,
+	0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 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, 0x09, 0x73, 0x74,
+	0x61, 0x72, 0x74, 0x53, 0x6c, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x21, 0x0a,
+	0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x04, 0x42, 0x07,
+	0x92, 0xb5, 0x18, 0x03, 0x31, 0x32, 0x38, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73,
+	0x22, 0x5b, 0x0a, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55,
+	0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x65,
+	0x72, 0x69, 0x6f, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x72,
+	0x74, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x9a, 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, 0x10, 0x50, 0x32, 0x50,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a,
+	0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63,
+	0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76,
+	0x36, 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, 0x56, 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 (
@@ -857,18 +741,17 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP() []byte {
 	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescData
 }
 
-var file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
+var file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
 var file_proto_prysm_v1alpha1_p2p_messages_proto_goTypes = []interface{}{
 	(*Status)(nil),                           // 0: ethereum.eth.v1alpha1.Status
-	(*StatusV2)(nil),                         // 1: ethereum.eth.v1alpha1.StatusV2
-	(*BeaconBlocksByRangeRequest)(nil),       // 2: ethereum.eth.v1alpha1.BeaconBlocksByRangeRequest
-	(*ENRForkID)(nil),                        // 3: ethereum.eth.v1alpha1.ENRForkID
-	(*MetaDataV0)(nil),                       // 4: ethereum.eth.v1alpha1.MetaDataV0
-	(*MetaDataV1)(nil),                       // 5: ethereum.eth.v1alpha1.MetaDataV1
-	(*MetaDataV2)(nil),                       // 6: ethereum.eth.v1alpha1.MetaDataV2
-	(*BlobSidecarsByRangeRequest)(nil),       // 7: ethereum.eth.v1alpha1.BlobSidecarsByRangeRequest
-	(*DataColumnSidecarsByRangeRequest)(nil), // 8: ethereum.eth.v1alpha1.DataColumnSidecarsByRangeRequest
-	(*LightClientUpdatesByRangeRequest)(nil), // 9: ethereum.eth.v1alpha1.LightClientUpdatesByRangeRequest
+	(*BeaconBlocksByRangeRequest)(nil),       // 1: ethereum.eth.v1alpha1.BeaconBlocksByRangeRequest
+	(*ENRForkID)(nil),                        // 2: ethereum.eth.v1alpha1.ENRForkID
+	(*MetaDataV0)(nil),                       // 3: ethereum.eth.v1alpha1.MetaDataV0
+	(*MetaDataV1)(nil),                       // 4: ethereum.eth.v1alpha1.MetaDataV1
+	(*MetaDataV2)(nil),                       // 5: ethereum.eth.v1alpha1.MetaDataV2
+	(*BlobSidecarsByRangeRequest)(nil),       // 6: ethereum.eth.v1alpha1.BlobSidecarsByRangeRequest
+	(*DataColumnSidecarsByRangeRequest)(nil), // 7: ethereum.eth.v1alpha1.DataColumnSidecarsByRangeRequest
+	(*LightClientUpdatesByRangeRequest)(nil), // 8: ethereum.eth.v1alpha1.LightClientUpdatesByRangeRequest
 }
 var file_proto_prysm_v1alpha1_p2p_messages_proto_depIdxs = []int32{
 	0, // [0:0] is the sub-list for method output_type
@@ -897,18 +780,6 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*StatusV2); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*BeaconBlocksByRangeRequest); i {
 			case 0:
 				return &v.state
@@ -920,7 +791,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 				return nil
 			}
 		}
-		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ENRForkID); i {
 			case 0:
 				return &v.state
@@ -932,7 +803,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 				return nil
 			}
 		}
-		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*MetaDataV0); i {
 			case 0:
 				return &v.state
@@ -944,7 +815,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 				return nil
 			}
 		}
-		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*MetaDataV1); i {
 			case 0:
 				return &v.state
@@ -956,7 +827,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 				return nil
 			}
 		}
-		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*MetaDataV2); i {
 			case 0:
 				return &v.state
@@ -968,7 +839,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 				return nil
 			}
 		}
-		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*BlobSidecarsByRangeRequest); i {
 			case 0:
 				return &v.state
@@ -980,7 +851,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 				return nil
 			}
 		}
-		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DataColumnSidecarsByRangeRequest); i {
 			case 0:
 				return &v.state
@@ -992,7 +863,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 				return nil
 			}
 		}
-		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LightClientUpdatesByRangeRequest); i {
 			case 0:
 				return &v.state
@@ -1011,7 +882,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_prysm_v1alpha1_p2p_messages_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   10,
+			NumMessages:   9,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

proto/prysm/v1alpha1/p2p_messages.proto

@@ -26,24 +26,6 @@ message Status {
   ];
 }
 
-message StatusV2 {
-  bytes fork_digest = 1 [(ethereum.eth.ext.ssz_size) = "4"];
-  bytes finalized_root = 2 [(ethereum.eth.ext.ssz_size) = "32"];
-  uint64 finalized_epoch = 3 [
-    (ethereum.eth.ext.cast_type) =
-        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Epoch"
-  ];
-  bytes head_root = 4 [(ethereum.eth.ext.ssz_size) = "32"];
-  uint64 head_slot = 5 [
-    (ethereum.eth.ext.cast_type) =
-        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Slot"
-  ];
-   uint64 earliest_available_slot = 6 [
-    (ethereum.eth.ext.cast_type) =
-        "github.com/OffchainLabs/prysm/v6/consensus-types/primitives.Slot"
-  ];
-}
-
 message BeaconBlocksByRangeRequest {
   uint64 start_slot = 1 [
     (ethereum.eth.ext.cast_type) =

testing/endtoend/components/validator.go

@@ -248,9 +248,6 @@ func (v *ValidatorNode) Start(ctx context.Context) error {
 		args = append(args,
 			fmt.Sprintf("--%s=http://localhost:%d", flags.BeaconRESTApiProviderFlag.Name, beaconRestApiPort),
 			fmt.Sprintf("--%s", features.EnableBeaconRESTApi.Name))
-		if v.config.UseSSZOnly {
-			args = append(args, fmt.Sprintf("--%s", features.SSZOnly.Name))
-		}
 	}
 
 	// Only apply e2e flags to the current branch. New flags may not exist in previous release.

testing/endtoend/minimal_scenario_e2e_test.go

@@ -29,10 +29,6 @@ func TestEndToEnd_MinimalConfig_ValidatorRESTApi(t *testing.T) {
 	e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithValidatorRESTApi()).run()
 }
 
-func TestEndToEnd_MinimalConfig_ValidatorRESTApi_SSZ(t *testing.T) {
-	e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithValidatorRESTApi(), types.WithSSZOnly()).run()
-}
-
 func TestEndToEnd_ScenarioRun_EEOffline(t *testing.T) {
 	t.Skip("TODO(#10242) Prysm is current unable to handle an offline e2e")
 	cfg := types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2ETestConfig())

testing/endtoend/types/types.go

@@ -51,12 +51,6 @@ func WithValidatorRESTApi() E2EConfigOpt {
 	}
 }
 
-func WithSSZOnly() E2EConfigOpt {
-	return func(cfg *E2EConfig) {
-		cfg.UseSSZOnly = true
-	}
-}
-
 func WithBuilder() E2EConfigOpt {
 	return func(cfg *E2EConfig) {
 		cfg.UseBuilder = true
@@ -76,7 +70,6 @@ type E2EConfig struct {
 	UseFixedPeerIDs         bool
 	UseValidatorCrossClient bool
 	UseBeaconRestApi        bool
-	UseSSZOnly              bool
 	UseBuilder              bool
 	EpochsToRun             uint64
 	Seed                    int64

testing/util/fulu.go

@@ -1,6 +1,7 @@
 package util
 
 import (
+	"encoding/binary"
 	"math/big"
 	"testing"
 
@@ -109,21 +110,14 @@ func GenerateTestFuluBlockWithSidecars(t *testing.T, blobCount int, options ...F
 	block.Block.ParentRoot = generator.parent[:]
 	block.Block.ProposerIndex = generator.proposer
 
-	blobs := make([]kzg.Blob, 0, generator.blobCount)
-	commitments := make([][]byte, 0, generator.blobCount)
-
-	for i := range generator.blobCount {
-		blob := kzg.Blob{uint8(i)}
-
-		commitment, err := kzg.BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-
-		blobs = append(blobs, blob)
-		commitments = append(commitments, commitment[:])
+	block.Block.Body.BlobKzgCommitments = make([][]byte, blobCount)
+	for i := range blobCount {
+		var commitment [fieldparams.KzgCommitmentSize]byte
+		binary.LittleEndian.PutUint16(commitment[:16], uint16(i))
+		binary.LittleEndian.PutUint16(commitment[16:32], uint16(generator.slot))
+		block.Block.Body.BlobKzgCommitments[i] = commitment[:]
 	}
 
-	block.Block.Body.BlobKzgCommitments = commitments
-
 	body, err := blocks.NewBeaconBlockBody(block.Block.Body)
 	require.NoError(t, err)
 
@@ -155,30 +149,39 @@ func GenerateTestFuluBlockWithSidecars(t *testing.T, blobCount int, options ...F
 	root, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(block)
+	sbb, err := blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
 
+	sh, err := sbb.Header()
+	require.NoError(t, err)
+
+	blobs := make([]kzg.Blob, blobCount)
+	for i, commitment := range block.Block.Body.BlobKzgCommitments {
+		roSidecars := GenerateTestDenebBlobSidecar(t, root, sh, i, commitment, inclusion[i])
+		blobs[i] = kzg.Blob(roSidecars.Blob)
+	}
+
 	cellsAndProofs := GenerateCellsAndProofs(t, blobs)
 
-	sidecars, err := peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
+	dataColumns, err := peerdas.DataColumnSidecars(sbb, cellsAndProofs)
 	require.NoError(t, err)
 
-	roSidecars := make([]blocks.RODataColumn, 0, len(sidecars))
-	verifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(sidecars))
-	for _, sidecar := range sidecars {
-		roSidecar, err := blocks.NewRODataColumnWithRoot(sidecar, root)
+	roSidecars := make([]blocks.RODataColumn, 0, len(dataColumns))
+	roVerifiedSidecars := make([]blocks.VerifiedRODataColumn, 0, len(dataColumns))
+	for _, dataColumn := range dataColumns {
+		roSidecar, err := blocks.NewRODataColumnWithRoot(dataColumn, root)
 		require.NoError(t, err)
 
 		roVerifiedSidecar := blocks.NewVerifiedRODataColumn(roSidecar)
 
 		roSidecars = append(roSidecars, roSidecar)
-		verifiedRoSidecars = append(verifiedRoSidecars, roVerifiedSidecar)
+		roVerifiedSidecars = append(roVerifiedSidecars, roVerifiedSidecar)
 	}
 
-	roBlock, err := blocks.NewROBlockWithRoot(signedBeaconBlock, root)
+	rob, err := blocks.NewROBlockWithRoot(sbb, root)
 	require.NoError(t, err)
 
-	return roBlock, roSidecars, verifiedRoSidecars
+	return rob, roSidecars, roVerifiedSidecars
 }
 
 func GenerateCellsAndProofs(t testing.TB, blobs []kzg.Blob) []kzg.CellsAndProofs {

validator/accounts/cli_manager.go

@@ -87,7 +87,7 @@ func (acm *CLIManager) prepareBeaconClients(ctx context.Context) (*iface.Validat
 		acm.beaconApiTimeout,
 	)
 
-	restHandler := beaconApi.NewBeaconApiRestHandler(
+	restHandler := beaconApi.NewBeaconApiJsonRestHandler(
 		http.Client{Timeout: acm.beaconApiTimeout},
 		acm.beaconApiEndpoint,
 	)

validator/client/beacon-api/BUILD.bazel

@@ -18,6 +18,7 @@ go_library(
         "genesis.go",
         "get_beacon_block.go",
         "index.go",
+        "json_rest_handler.go",
         "log.go",
         "metrics.go",
         "prepare_beacon_proposer.go",
@@ -26,7 +27,6 @@ go_library(
         "propose_exit.go",
         "prysm_beacon_chain_client.go",
         "registration.go",
-        "rest_handler_client.go",
         "state_validators.go",
         "status.go",
         "stream_blocks.go",
@@ -47,7 +47,6 @@ go_library(
         "//api/server/structs:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
-        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
@@ -92,6 +91,7 @@ go_test(
         "genesis_test.go",
         "get_beacon_block_test.go",
         "index_test.go",
+        "json_rest_handler_test.go",
         "prepare_beacon_proposer_test.go",
         "propose_attestation_test.go",
         "propose_beacon_block_altair_test.go",
@@ -110,7 +110,6 @@ go_test(
         "propose_exit_test.go",
         "prysm_beacon_chain_client_test.go",
         "registration_test.go",
-        "rest_handler_client_test.go",
         "state_validators_test.go",
         "status_test.go",
         "stream_blocks_test.go",
@@ -129,7 +128,6 @@ go_test(
         "//api/server/structs:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/rpc/eth/shared/testing:go_default_library",
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
@@ -147,8 +145,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//: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_beacon_chain_client.go

@@ -17,7 +17,7 @@ import (
 
 type beaconApiChainClient struct {
 	fallbackClient          iface.ChainClient
-	jsonRestHandler         RestHandler
+	jsonRestHandler         JsonRestHandler
 	stateValidatorsProvider StateValidatorsProvider
 }
 
@@ -333,7 +333,7 @@ func (c beaconApiChainClient) ValidatorParticipation(ctx context.Context, in *et
 	return nil, errors.New("beaconApiChainClient.ValidatorParticipation is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiChainClientWithFallback.")
 }
 
-func NewBeaconApiChainClientWithFallback(jsonRestHandler RestHandler, fallbackClient iface.ChainClient) iface.ChainClient {
+func NewBeaconApiChainClientWithFallback(jsonRestHandler JsonRestHandler, fallbackClient iface.ChainClient) iface.ChainClient {
 	return &beaconApiChainClient{
 		jsonRestHandler:         jsonRestHandler,
 		fallbackClient:          fallbackClient,

validator/client/beacon-api/beacon_api_node_client.go

@@ -20,7 +20,7 @@ var (
 
 type beaconApiNodeClient struct {
 	fallbackClient  iface.NodeClient
-	jsonRestHandler RestHandler
+	jsonRestHandler JsonRestHandler
 	genesisProvider GenesisProvider
 	healthTracker   health.Tracker
 }
@@ -111,7 +111,7 @@ func (c *beaconApiNodeClient) HealthTracker() health.Tracker {
 	return c.healthTracker
 }
 
-func NewNodeClientWithFallback(jsonRestHandler RestHandler, fallbackClient iface.NodeClient) iface.NodeClient {
+func NewNodeClientWithFallback(jsonRestHandler JsonRestHandler, fallbackClient iface.NodeClient) iface.NodeClient {
 	b := &beaconApiNodeClient{
 		jsonRestHandler: jsonRestHandler,
 		fallbackClient:  fallbackClient,

validator/client/beacon-api/beacon_api_validator_client.go

@@ -22,13 +22,13 @@ type beaconApiValidatorClient struct {
 	genesisProvider         GenesisProvider
 	dutiesProvider          dutiesProvider
 	stateValidatorsProvider StateValidatorsProvider
-	jsonRestHandler         RestHandler
+	jsonRestHandler         JsonRestHandler
 	beaconBlockConverter    BeaconBlockConverter
 	prysmChainClient        iface.PrysmChainClient
 	isEventStreamRunning    bool
 }
 
-func NewBeaconApiValidatorClient(jsonRestHandler RestHandler, opts ...ValidatorClientOpt) iface.ValidatorClient {
+func NewBeaconApiValidatorClient(jsonRestHandler JsonRestHandler, opts ...ValidatorClientOpt) iface.ValidatorClient {
 	c := &beaconApiValidatorClient{
 		genesisProvider:         &beaconApiGenesisProvider{jsonRestHandler: jsonRestHandler},
 		dutiesProvider:          beaconApiDutiesProvider{jsonRestHandler: jsonRestHandler},

validator/client/beacon-api/duties.go

@@ -27,7 +27,7 @@ type dutiesProvider interface {
 }
 
 type beaconApiDutiesProvider struct {
-	jsonRestHandler RestHandler
+	jsonRestHandler JsonRestHandler
 }
 
 type attesterDuty struct {

validator/client/beacon-api/genesis.go

@@ -20,7 +20,7 @@ type GenesisProvider interface {
 }
 
 type beaconApiGenesisProvider struct {
-	jsonRestHandler RestHandler
+	jsonRestHandler JsonRestHandler
 	genesis         *structs.Genesis
 	once            sync.Once
 }

validator/client/beacon-api/get_beacon_block.go

@@ -6,10 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	neturl "net/url"
-	"strconv"
-	"strings"
 
-	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/OffchainLabs/prysm/v6/api/apiutil"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -25,224 +22,160 @@ func (c *beaconApiValidatorClient) beaconBlock(ctx context.Context, slot primiti
 	if len(graffiti) > 0 {
 		queryParams.Add("graffiti", hexutil.Encode(graffiti))
 	}
+
 	queryUrl := apiutil.BuildURL(fmt.Sprintf("/eth/v3/validator/blocks/%d", slot), queryParams)
-	data, header, err := c.jsonRestHandler.GetSSZ(ctx, queryUrl)
+	produceBlockV3ResponseJson := structs.ProduceBlockV3Response{}
+	err := c.jsonRestHandler.Get(ctx, queryUrl, &produceBlockV3ResponseJson)
 	if err != nil {
 		return nil, err
 	}
-	if strings.Contains(header.Get("Content-Type"), api.OctetStreamMediaType) {
-		ver, err := version.FromString(header.Get(api.VersionHeader))
-		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("unsupported header version %s", header.Get(api.VersionHeader)))
-		}
-		isBlindedRaw := header.Get(api.ExecutionPayloadBlindedHeader)
-		isBlinded, err := strconv.ParseBool(isBlindedRaw)
-		if err != nil {
-			return nil, err
-		}
-		return processBlockSSZResponse(ver, data, isBlinded)
-	} else {
-		decoder := json.NewDecoder(bytes.NewBuffer(data))
-		produceBlockV3ResponseJson := structs.ProduceBlockV3Response{}
-		if err = decoder.Decode(&produceBlockV3ResponseJson); err != nil {
-			return nil, errors.Wrapf(err, "failed to decode response body into json for %s", queryUrl)
-		}
-		return processBlockJSONResponse(
-			produceBlockV3ResponseJson.Version,
-			produceBlockV3ResponseJson.ExecutionPayloadBlinded,
-			json.NewDecoder(bytes.NewReader(produceBlockV3ResponseJson.Data)),
-		)
-	}
+
+	return processBlockResponse(
+		produceBlockV3ResponseJson.Version,
+		produceBlockV3ResponseJson.ExecutionPayloadBlinded,
+		json.NewDecoder(bytes.NewReader(produceBlockV3ResponseJson.Data)),
+	)
 }
 
-func processBlockSSZResponse(ver int, data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if ver >= version.Fulu {
-		return processBlockSSZResponseFulu(data, isBlinded)
-	}
-	if ver >= version.Electra {
-		return processBlockSSZResponseElectra(data, isBlinded)
-	}
-	if ver >= version.Deneb {
-		return processBlockSSZResponseDeneb(data, isBlinded)
-	}
-	if ver >= version.Capella {
-		return processBlockSSZResponseCapella(data, isBlinded)
-	}
-	if ver >= version.Bellatrix {
-		return processBlockSSZResponseBellatrix(data, isBlinded)
-	}
-	if ver >= version.Altair {
-		block := &ethpb.BeaconBlockAltair{}
-		if err := block.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Altair{Altair: block}}, nil
-	}
-	if ver >= version.Phase0 {
-		block := &ethpb.BeaconBlock{}
-		if err := block.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Phase0{Phase0: block}}, nil
-	}
-	return nil, fmt.Errorf("unsupported block version %s", version.String(ver))
-}
-
-func processBlockSSZResponseFulu(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockFulu{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedFulu{BlindedFulu: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockContentsFulu{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Fulu{Fulu: block}}, nil
-}
-
-func processBlockSSZResponseElectra(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockElectra{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedElectra{BlindedElectra: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockContentsElectra{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Electra{Electra: block}}, nil
-}
-
-func processBlockSSZResponseDeneb(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockDeneb{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedDeneb{BlindedDeneb: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockContentsDeneb{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Deneb{Deneb: block}}, nil
-}
-
-func processBlockSSZResponseCapella(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockCapella{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedCapella{BlindedCapella: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockCapella{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Capella{Capella: block}}, nil
-}
-
-func processBlockSSZResponseBellatrix(data []byte, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		blindedBlock := &ethpb.BlindedBeaconBlockBellatrix{}
-		if err := blindedBlock.UnmarshalSSZ(data); err != nil {
-			return nil, err
-		}
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedBellatrix{BlindedBellatrix: blindedBlock}, IsBlinded: true}, nil
-	}
-	block := &ethpb.BeaconBlockBellatrix{}
-	if err := block.UnmarshalSSZ(data); err != nil {
-		return nil, err
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Bellatrix{Bellatrix: block}}, nil
-}
-
-func convertBlockToGeneric(decoder *json.Decoder, dest ethpb.GenericConverter, version string, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	typeName := version
-	if isBlinded {
-		typeName = "blinded " + typeName
-	}
-
-	if err := decoder.Decode(dest); err != nil {
-		return nil, errors.Wrapf(err, "failed to decode %s block response json", typeName)
-	}
-
-	genericBlock, err := dest.ToGeneric()
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to convert %s block", typeName)
-	}
-	return genericBlock, nil
-}
-
-func processBlockJSONResponse(ver string, isBlinded bool, decoder *json.Decoder) (*ethpb.GenericBeaconBlock, error) {
+// nolint: gocognit
+func processBlockResponse(ver string, isBlinded bool, decoder *json.Decoder) (*ethpb.GenericBeaconBlock, error) {
+	var response *ethpb.GenericBeaconBlock
 	if decoder == nil {
 		return nil, errors.New("no produce block json decoder found")
 	}
-
 	switch ver {
 	case version.String(version.Phase0):
-		return convertBlockToGeneric(decoder, &structs.BeaconBlock{}, version.String(version.Phase0), false)
-
+		jsonPhase0Block := structs.BeaconBlock{}
+		if err := decoder.Decode(&jsonPhase0Block); err != nil {
+			return nil, errors.Wrap(err, "failed to decode phase0 block response json")
+		}
+		genericBlock, err := jsonPhase0Block.ToGeneric()
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to get phase0 block")
+		}
+		response = genericBlock
 	case version.String(version.Altair):
-		return convertBlockToGeneric(decoder, &structs.BeaconBlockAltair{}, "altair", false)
-
+		jsonAltairBlock := structs.BeaconBlockAltair{}
+		if err := decoder.Decode(&jsonAltairBlock); err != nil {
+			return nil, errors.Wrap(err, "failed to decode altair block response json")
+		}
+		genericBlock, err := jsonAltairBlock.ToGeneric()
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to get altair block")
+		}
+		response = genericBlock
 	case version.String(version.Bellatrix):
-		return processBellatrixBlock(decoder, isBlinded)
-
+		if isBlinded {
+			jsonBellatrixBlock := structs.BlindedBeaconBlockBellatrix{}
+			if err := decoder.Decode(&jsonBellatrixBlock); err != nil {
+				return nil, errors.Wrap(err, "failed to decode blinded bellatrix block response json")
+			}
+			genericBlock, err := jsonBellatrixBlock.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get blinded bellatrix block")
+			}
+			response = genericBlock
+		} else {
+			jsonBellatrixBlock := structs.BeaconBlockBellatrix{}
+			if err := decoder.Decode(&jsonBellatrixBlock); err != nil {
+				return nil, errors.Wrap(err, "failed to decode bellatrix block response json")
+			}
+			genericBlock, err := jsonBellatrixBlock.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get bellatrix block")
+			}
+			response = genericBlock
+		}
 	case version.String(version.Capella):
-		return processCapellaBlock(decoder, isBlinded)
-
+		if isBlinded {
+			jsonCapellaBlock := structs.BlindedBeaconBlockCapella{}
+			if err := decoder.Decode(&jsonCapellaBlock); err != nil {
+				return nil, errors.Wrap(err, "failed to decode blinded capella block response json")
+			}
+			genericBlock, err := jsonCapellaBlock.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get blinded capella block")
+			}
+			response = genericBlock
+		} else {
+			jsonCapellaBlock := structs.BeaconBlockCapella{}
+			if err := decoder.Decode(&jsonCapellaBlock); err != nil {
+				return nil, errors.Wrap(err, "failed to decode capella block response json")
+			}
+			genericBlock, err := jsonCapellaBlock.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get capella block")
+			}
+			response = genericBlock
+		}
 	case version.String(version.Deneb):
-		return processDenebBlock(decoder, isBlinded)
-
+		if isBlinded {
+			jsonDenebBlock := structs.BlindedBeaconBlockDeneb{}
+			if err := decoder.Decode(&jsonDenebBlock); err != nil {
+				return nil, errors.Wrap(err, "failed to decode blinded deneb block response json")
+			}
+			genericBlock, err := jsonDenebBlock.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get blinded deneb block")
+			}
+			response = genericBlock
+		} else {
+			jsonDenebBlockContents := structs.BeaconBlockContentsDeneb{}
+			if err := decoder.Decode(&jsonDenebBlockContents); err != nil {
+				return nil, errors.Wrap(err, "failed to decode deneb block response json")
+			}
+			genericBlock, err := jsonDenebBlockContents.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get deneb block")
+			}
+			response = genericBlock
+		}
 	case version.String(version.Electra):
-		return processElectraBlock(decoder, isBlinded)
-
+		if isBlinded {
+			jsonElectraBlock := structs.BlindedBeaconBlockElectra{}
+			if err := decoder.Decode(&jsonElectraBlock); err != nil {
+				return nil, errors.Wrap(err, "failed to decode blinded electra block response json")
+			}
+			genericBlock, err := jsonElectraBlock.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get blinded electra block")
+			}
+			response = genericBlock
+		} else {
+			jsonElectraBlockContents := structs.BeaconBlockContentsElectra{}
+			if err := decoder.Decode(&jsonElectraBlockContents); err != nil {
+				return nil, errors.Wrap(err, "failed to decode electra block response json")
+			}
+			genericBlock, err := jsonElectraBlockContents.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get electra block")
+			}
+			response = genericBlock
+		}
 	case version.String(version.Fulu):
-		return processFuluBlock(decoder, isBlinded)
-
+		if isBlinded {
+			jsonFuluBlock := structs.BlindedBeaconBlockFulu{}
+			if err := decoder.Decode(&jsonFuluBlock); err != nil {
+				return nil, errors.Wrap(err, "failed to decode blinded fulu block response json")
+			}
+			genericBlock, err := jsonFuluBlock.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get blinded fulu block")
+			}
+			response = genericBlock
+		} else {
+			jsonFuluBlockContents := structs.BeaconBlockContentsFulu{}
+			if err := decoder.Decode(&jsonFuluBlockContents); err != nil {
+				return nil, errors.Wrap(err, "failed to decode fulu block response json")
+			}
+			genericBlock, err := jsonFuluBlockContents.ToGeneric()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to get fulu block")
+			}
+			response = genericBlock
+		}
 	default:
 		return nil, errors.Errorf("unsupported consensus version `%s`", ver)
 	}
-}
-
-func processBellatrixBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockBellatrix{}, "bellatrix", true)
-	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockBellatrix{}, "bellatrix", false)
-}
-
-func processCapellaBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockCapella{}, "capella", true)
-	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockCapella{}, "capella", false)
-}
-
-func processDenebBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockDeneb{}, "deneb", true)
-	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockContentsDeneb{}, "deneb", false)
-}
-
-func processElectraBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockElectra{}, "electra", true)
-	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockContentsElectra{}, "electra", false)
-}
-
-func processFuluBlock(decoder *json.Decoder, isBlinded bool) (*ethpb.GenericBeaconBlock, error) {
-	if isBlinded {
-		return convertBlockToGeneric(decoder, &structs.BlindedBeaconBlockFulu{}, "fulu", true)
-	}
-	return convertBlockToGeneric(decoder, &structs.BeaconBlockContentsFulu{}, "fulu", false)
+	return response, nil
 }

validator/client/beacon-api/json_rest_handler.go

@@ -4,53 +4,49 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
 	"io"
 	"net/http"
 	"strings"
 
 	"github.com/OffchainLabs/prysm/v6/api"
-	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/network/httputil"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 )
 
-type RestHandler interface {
+type JsonRestHandler interface {
 	Get(ctx context.Context, endpoint string, resp interface{}) error
-	GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error)
 	Post(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer, resp interface{}) error
 	HttpClient() *http.Client
 	Host() string
 	SetHost(host string)
 }
 
-type BeaconApiRestHandler struct {
+type BeaconApiJsonRestHandler struct {
 	client http.Client
 	host   string
 }
 
-// NewBeaconApiRestHandler returns a RestHandler
-func NewBeaconApiRestHandler(client http.Client, host string) RestHandler {
-	return &BeaconApiRestHandler{
+// NewBeaconApiJsonRestHandler returns a JsonRestHandler
+func NewBeaconApiJsonRestHandler(client http.Client, host string) JsonRestHandler {
+	return &BeaconApiJsonRestHandler{
 		client: client,
 		host:   host,
 	}
 }
 
 // HttpClient returns the underlying HTTP client of the handler
-func (c *BeaconApiRestHandler) HttpClient() *http.Client {
+func (c *BeaconApiJsonRestHandler) HttpClient() *http.Client {
 	return &c.client
 }
 
 // Host returns the underlying HTTP host
-func (c *BeaconApiRestHandler) Host() string {
+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 *BeaconApiRestHandler) Get(ctx context.Context, endpoint string, resp interface{}) error {
+func (c *BeaconApiJsonRestHandler) Get(ctx context.Context, endpoint string, resp interface{}) error {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -70,61 +66,9 @@ func (c *BeaconApiRestHandler) Get(ctx context.Context, endpoint string, resp in
 	return decodeResp(httpResp, resp)
 }
 
-func (c *BeaconApiRestHandler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
-	url := c.host + endpoint
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return nil, nil, errors.Wrapf(err, "failed to create request for endpoint %s", url)
-	}
-	primaryAcceptType := fmt.Sprintf("%s;q=%s", api.OctetStreamMediaType, "0.95")
-	secondaryAcceptType := fmt.Sprintf("%s;q=%s", api.JsonMediaType, "0.9")
-	acceptHeaderString := fmt.Sprintf("%s,%s", primaryAcceptType, secondaryAcceptType)
-	if features.Get().SSZOnly {
-		acceptHeaderString = api.OctetStreamMediaType
-	}
-	req.Header.Set("Accept", acceptHeaderString)
-	httpResp, err := c.client.Do(req)
-	if err != nil {
-		return nil, nil, errors.Wrapf(err, "failed to perform request for endpoint %s", url)
-	}
-	defer func() {
-		if err := httpResp.Body.Close(); err != nil {
-			return
-		}
-	}()
-	contentType := httpResp.Header.Get("Content-Type")
-	body, err := io.ReadAll(httpResp.Body)
-	if err != nil {
-		return nil, nil, errors.Wrapf(err, "failed to read response body for %s", httpResp.Request.URL)
-	}
-	if !strings.Contains(primaryAcceptType, contentType) {
-		log.WithFields(logrus.Fields{
-			"primaryAcceptType":   primaryAcceptType,
-			"secondaryAcceptType": secondaryAcceptType,
-			"receivedAcceptType":  contentType,
-		}).Debug("Server responded with non primary accept type")
-	}
-
-	// non-2XX codes are a failure
-	if !strings.HasPrefix(httpResp.Status, "2") {
-		decoder := json.NewDecoder(bytes.NewBuffer(body))
-		errorJson := &httputil.DefaultJsonError{}
-		if err = decoder.Decode(errorJson); err != nil {
-			return nil, nil, errors.Wrapf(err, "failed to decode response body into error json for %s", httpResp.Request.URL)
-		}
-		return nil, nil, errorJson
-	}
-
-	if features.Get().SSZOnly && contentType != api.OctetStreamMediaType {
-		return nil, nil, errors.Errorf("server responded with non primary accept type %s", contentType)
-	}
-
-	return body, httpResp.Header, nil
-}
-
 // Post sends a POST request and decodes the response body as a JSON object into the passed in object.
 // If an HTTP error is returned, the body is decoded as a DefaultJsonError JSON object and returned as the first return value.
-func (c *BeaconApiRestHandler) Post(
+func (c *BeaconApiJsonRestHandler) Post(
 	ctx context.Context,
 	apiEndpoint string,
 	headers map[string]string,
@@ -192,6 +136,6 @@ func decodeResp(httpResp *http.Response, resp interface{}) error {
 	return nil
 }
 
-func (c *BeaconApiRestHandler) SetHost(host string) {
+func (c *BeaconApiJsonRestHandler) SetHost(host string) {
 	c.host = host
 }

validator/client/beacon-api/json_rest_handler_test.go

@@ -2,7 +2,6 @@ package beacon_api
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"io"
 	"net/http"
@@ -16,8 +15,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"github.com/sirupsen/logrus/hooks/test"
 )
 
 func TestGet(t *testing.T) {
@@ -42,7 +39,7 @@ func TestGet(t *testing.T) {
 	server := httptest.NewServer(mux)
 	defer server.Close()
 
-	jsonRestHandler := BeaconApiRestHandler{
+	jsonRestHandler := BeaconApiJsonRestHandler{
 		client: http.Client{Timeout: time.Second * 5},
 		host:   server.URL,
 	}
@@ -51,98 +48,6 @@ func TestGet(t *testing.T) {
 	assert.DeepEqual(t, genesisJson, resp)
 }
 
-func TestGetSSZ(t *testing.T) {
-	ctx := context.Background()
-	const endpoint = "/example/rest/api/ssz"
-	genesisJson := &structs.GetGenesisResponse{
-		Data: &structs.Genesis{
-			GenesisTime:           "123",
-			GenesisValidatorsRoot: "0x456",
-			GenesisForkVersion:    "0x789",
-		},
-	}
-
-	t.Run("Successful SSZ response", func(t *testing.T) {
-		expectedBody := []byte{10, 20, 30, 40}
-
-		mux := http.NewServeMux()
-		mux.HandleFunc(endpoint, func(w http.ResponseWriter, r *http.Request) {
-			assert.StringContains(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-			w.Header().Set("Content-Type", api.OctetStreamMediaType)
-			_, err := w.Write(expectedBody)
-			require.NoError(t, err)
-		})
-		server := httptest.NewServer(mux)
-		defer server.Close()
-
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Second * 5},
-			host:   server.URL,
-		}
-
-		body, header, err := jsonRestHandler.GetSSZ(ctx, endpoint)
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedBody, body)
-		require.StringContains(t, api.OctetStreamMediaType, header.Get("Content-Type"))
-	})
-
-	t.Run("Json Content-Type response", func(t *testing.T) {
-		logrus.SetLevel(logrus.DebugLevel)
-		defer logrus.SetLevel(logrus.InfoLevel) // reset it afterwards
-		logHook := test.NewGlobal()
-		mux := http.NewServeMux()
-		mux.HandleFunc(endpoint, func(w http.ResponseWriter, r *http.Request) {
-			assert.StringContains(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-			w.Header().Set("Content-Type", api.JsonMediaType)
-
-			marshalledJson, err := json.Marshal(genesisJson)
-			require.NoError(t, err)
-
-			_, err = w.Write(marshalledJson)
-			require.NoError(t, err)
-		})
-		server := httptest.NewServer(mux)
-		defer server.Close()
-
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Second * 5},
-			host:   server.URL,
-		}
-
-		body, header, err := jsonRestHandler.GetSSZ(ctx, endpoint)
-		require.NoError(t, err)
-		assert.LogsContain(t, logHook, "Server responded with non primary accept type")
-		require.Equal(t, api.JsonMediaType, header.Get("Content-Type"))
-		resp := &structs.GetGenesisResponse{}
-		require.NoError(t, json.Unmarshal(body, resp))
-		require.Equal(t, "123", resp.Data.GenesisTime)
-	})
-
-	t.Run("Wrong Content-Type response, doesn't error out and instead handled downstream", func(t *testing.T) {
-		logrus.SetLevel(logrus.DebugLevel)
-		defer logrus.SetLevel(logrus.InfoLevel) // reset it afterwards
-		logHook := test.NewGlobal()
-		mux := http.NewServeMux()
-		mux.HandleFunc(endpoint, func(w http.ResponseWriter, r *http.Request) {
-			assert.StringContains(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-			w.Header().Set("Content-Type", "text/plain") // Invalid content type
-			_, err := w.Write([]byte("some text"))
-			require.NoError(t, err)
-		})
-		server := httptest.NewServer(mux)
-		defer server.Close()
-
-		jsonRestHandler := BeaconApiRestHandler{
-			client: http.Client{Timeout: time.Second * 5},
-			host:   server.URL,
-		}
-
-		_, _, err := jsonRestHandler.GetSSZ(ctx, endpoint)
-		require.NoError(t, err)
-		assert.LogsContain(t, logHook, "Server responded with non primary accept type")
-	})
-}
-
 func TestPost(t *testing.T) {
 	ctx := t.Context()
 	const endpoint = "/example/rest/api/endpoint"
@@ -180,7 +85,7 @@ func TestPost(t *testing.T) {
 	server := httptest.NewServer(mux)
 	defer server.Close()
 
-	jsonRestHandler := BeaconApiRestHandler{
+	jsonRestHandler := BeaconApiJsonRestHandler{
 		client: http.Client{Timeout: time.Second * 5},
 		host:   server.URL,
 	}

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

@@ -56,23 +56,6 @@ func (mr *MockJsonRestHandlerMockRecorder) Get(ctx, endpoint, resp any) *gomock.
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockJsonRestHandler)(nil).Get), ctx, endpoint, resp)
 }
 
-
-// GetSSZ mocks base method.
-func (m *MockJsonRestHandler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSSZ", ctx, endpoint)
-	ret0, _ := ret[0].([]byte)
-	ret1, _ := ret[1].(http.Header)
-	ret2, _ := ret[2].(error)
-	return ret0, ret1, ret2
-}
-
-// GetSSZ indicates an expected call of GetSSZ.
-func (mr *MockJsonRestHandlerMockRecorder) GetSSZ(ctx, endpoint any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSSZ", reflect.TypeOf((*MockJsonRestHandler)(nil).GetSSZ), ctx, endpoint)
-}
-
 // Host mocks base method.
 func (m *MockJsonRestHandler) Host() string {
 	m.ctrl.T.Helper()

validator/client/beacon-api/prysm_beacon_chain_client.go

@@ -18,7 +18,7 @@ import (
 )
 
 // NewPrysmChainClient returns implementation of iface.PrysmChainClient.
-func NewPrysmChainClient(jsonRestHandler RestHandler, nodeClient iface.NodeClient) iface.PrysmChainClient {
+func NewPrysmChainClient(jsonRestHandler JsonRestHandler, nodeClient iface.NodeClient) iface.PrysmChainClient {
 	return prysmChainClient{
 		jsonRestHandler: jsonRestHandler,
 		nodeClient:      nodeClient,
@@ -26,7 +26,7 @@ func NewPrysmChainClient(jsonRestHandler RestHandler, nodeClient iface.NodeClien
 }
 
 type prysmChainClient struct {
-	jsonRestHandler RestHandler
+	jsonRestHandler JsonRestHandler
 	nodeClient      iface.NodeClient
 }
 

validator/client/beacon-api/state_validators.go

@@ -21,7 +21,7 @@ type StateValidatorsProvider interface {
 }
 
 type beaconApiStateValidatorsProvider struct {
-	jsonRestHandler RestHandler
+	jsonRestHandler JsonRestHandler
 }
 
 func (c beaconApiStateValidatorsProvider) StateValidators(

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

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

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

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

validator/client/service.go

@@ -179,7 +179,7 @@ func (v *ValidatorService) Start() {
 		return
 	}
 
-	restHandler := beaconApi.NewBeaconApiRestHandler(
+	restHandler := beaconApi.NewBeaconApiJsonRestHandler(
 		http.Client{Timeout: v.conn.GetBeaconApiTimeout(), Transport: otelhttp.NewTransport(http.DefaultTransport)},
 		hosts[0],
 	)

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

@@ -10,7 +10,7 @@ import (
 
 func NewValidatorClient(
 	validatorConn validatorHelpers.NodeConnection,
-	jsonRestHandler beaconApi.RestHandler,
+	jsonRestHandler beaconApi.JsonRestHandler,
 	opt ...beaconApi.ValidatorClientOpt,
 ) iface.ValidatorClient {
 	if features.Get().EnableBeaconRESTApi {

validator/rpc/beacon.go

@@ -55,7 +55,7 @@ func (s *Server) registerBeaconClient() error {
 		s.beaconApiTimeout,
 	)
 
-	restHandler := beaconApi.NewBeaconApiRestHandler(
+	restHandler := beaconApi.NewBeaconApiJsonRestHandler(
 		http.Client{Timeout: s.beaconApiTimeout, Transport: otelhttp.NewTransport(http.DefaultTransport)},
 		s.beaconApiEndpoint,
 	)