support env var to customize Accept header

dataColumnSidecarByRootRPCHandler: Do not rely any more on map iteration, which does not produce reproducible output order. (#15441 )
PeerDAS: Implement beacon API blob sidecar endpoint for Fulu (#15436 )
2026-01-10 13:58:09 -05:00 · 2025-06-26 12:08:23 -05:00 · 2025-06-26 13:07:19 +00:00 · 2025-06-26 10:05:22 +00:00 · 2025-06-24 21:40:16 +00:00 · 2025-06-23 14:47:02 +00:00
27 changed files with 2145 additions and 644 deletions
--- a/api/client/client.go
+++ b/api/client/client.go
@@ -6,6 +6,7 @@ import (
 	"net"
 	"net/http"
 	"net/url"
+	"os"

 	"github.com/pkg/errors"
 )
@@ -14,14 +15,17 @@ 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
+	hc           *http.Client
+	baseURL      *url.URL
+	token        string
+	maxBodySize  int64
+	reqOverrides []ReqOption
 }

 // NewClient constructs a new client with the provided options (ex WithTimeout).
@@ -40,9 +44,21 @@ 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
@@ -55,6 +71,9 @@ 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)
 }

@@ -87,7 +106,7 @@ func (c *Client) Get(ctx context.Context, path string, opts ...ReqOption) ([]byt
 	for _, o := range opts {
 		o(req)
 	}
-	r, err := c.hc.Do(req)
+	r, err := c.Do(req)
 	if err != nil {
 		return nil, err
 	}
--- a/api/client/client_test.go
+++ b/api/client/client_test.go
@@ -1,7 +1,10 @@
 package client

 import (
+	"net/http"
+	"net/http/httptest"
 	"net/url"
+	"os"
 	"testing"

 	"github.com/OffchainLabs/prysm/v6/testing/require"
@@ -46,3 +49,23 @@ 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))
+}
--- a/beacon-chain/p2p/rpc_topic_mappings.go
+++ b/beacon-chain/p2p/rpc_topic_mappings.go
@@ -22,50 +22,52 @@ const (
 	SchemaVersionV3 = "/3"
 )

-// Specifies the protocol prefix for all our Req/Resp topics.
-const protocolPrefix = "/eth2/beacon_chain/req"
+const (
+	// Specifies the protocol prefix for all our Req/Resp topics.
+	protocolPrefix = "/eth2/beacon_chain/req"

-// StatusMessageName specifies the name for the status message topic.
-const StatusMessageName = "/status"
+	// StatusMessageName specifies the name for the status message topic.
+	StatusMessageName = "/status"

-// GoodbyeMessageName specifies the name for the goodbye message topic.
-const GoodbyeMessageName = "/goodbye"
+	// GoodbyeMessageName specifies the name for the goodbye message topic.
+	GoodbyeMessageName = "/goodbye"

-// BeaconBlocksByRangeMessageName specifies the name for the beacon blocks by range message topic.
-const BeaconBlocksByRangeMessageName = "/beacon_blocks_by_range"
+	// BeaconBlocksByRangeMessageName specifies the name for the beacon blocks by range message topic.
+	BeaconBlocksByRangeMessageName = "/beacon_blocks_by_range"

-// BeaconBlocksByRootsMessageName specifies the name for the beacon blocks by root message topic.
-const BeaconBlocksByRootsMessageName = "/beacon_blocks_by_root"
+	// BeaconBlocksByRootsMessageName specifies the name for the beacon blocks by root message topic.
+	BeaconBlocksByRootsMessageName = "/beacon_blocks_by_root"

-// PingMessageName Specifies the name for the ping message topic.
-const PingMessageName = "/ping"
+	// PingMessageName Specifies the name for the ping message topic.
+	PingMessageName = "/ping"

-// MetadataMessageName specifies the name for the metadata message topic.
-const MetadataMessageName = "/metadata"
+	// MetadataMessageName specifies the name for the metadata message topic.
+	MetadataMessageName = "/metadata"

-// BlobSidecarsByRangeName is the name for the BlobSidecarsByRange v1 message topic.
-const BlobSidecarsByRangeName = "/blob_sidecars_by_range"
+	// BlobSidecarsByRangeName is the name for the BlobSidecarsByRange v1 message topic.
+	BlobSidecarsByRangeName = "/blob_sidecars_by_range"

-// BlobSidecarsByRootName is the name for the BlobSidecarsByRoot v1 message topic.
-const BlobSidecarsByRootName = "/blob_sidecars_by_root"
+	// BlobSidecarsByRootName is the name for the BlobSidecarsByRoot v1 message topic.
+	BlobSidecarsByRootName = "/blob_sidecars_by_root"

-// LightClientBootstrapName is the name for the LightClientBootstrap message topic,
-const LightClientBootstrapName = "/light_client_bootstrap"
+	// LightClientBootstrapName is the name for the LightClientBootstrap message topic,
+	LightClientBootstrapName = "/light_client_bootstrap"

-// LightClientUpdatesByRangeName is the name for the LightClientUpdatesByRange topic.
-const LightClientUpdatesByRangeName = "/light_client_updates_by_range"
+	// LightClientUpdatesByRangeName is the name for the LightClientUpdatesByRange topic.
+	LightClientUpdatesByRangeName = "/light_client_updates_by_range"

-// LightClientFinalityUpdateName is the name for the LightClientFinalityUpdate topic.
-const LightClientFinalityUpdateName = "/light_client_finality_update"
+	// LightClientFinalityUpdateName is the name for the LightClientFinalityUpdate topic.
+	LightClientFinalityUpdateName = "/light_client_finality_update"

-// LightClientOptimisticUpdateName is the name for the LightClientOptimisticUpdate topic.
-const LightClientOptimisticUpdateName = "/light_client_optimistic_update"
+	// LightClientOptimisticUpdateName is the name for the LightClientOptimisticUpdate topic.
+	LightClientOptimisticUpdateName = "/light_client_optimistic_update"

-// DataColumnSidecarsByRootName is the name for the DataColumnSidecarsByRoot v1 message topic.
-const DataColumnSidecarsByRootName = "/data_column_sidecars_by_root"
+	// DataColumnSidecarsByRootName is the name for the DataColumnSidecarsByRoot v1 message topic.
+	DataColumnSidecarsByRootName = "/data_column_sidecars_by_root"

-// DataColumnSidecarsByRangeName is the name for the DataColumnSidecarsByRange v1 message topic.
-const DataColumnSidecarsByRangeName = "/data_column_sidecars_by_range"
+	// DataColumnSidecarsByRangeName is the name for the DataColumnSidecarsByRange v1 message topic.
+	DataColumnSidecarsByRangeName = "/data_column_sidecars_by_range"
+)

 const (
 	// V1 RPC Topics
@@ -124,94 +126,103 @@ const (
 )

 // RPCTopicMappings map the base message type to the rpc request.
-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),
+var (
+	RPCTopicMappings = map[string]interface{}{
+		// RPC Status Message
+		RPCStatusTopicV1: new(pb.Status),

-	// Light client
-	RPCLightClientBootstrapTopicV1:        new([fieldparams.RootLength]byte),
-	RPCLightClientUpdatesByRangeTopicV1:   new(pb.LightClientUpdatesByRangeRequest),
-	RPCLightClientFinalityUpdateTopicV1:   new(interface{}),
-	RPCLightClientOptimisticUpdateTopicV1: new(interface{}),
+		// RPC Goodbye Message
+		RPCGoodByeTopicV1: new(primitives.SSZUint64),

-	// DataColumnSidecarsByRange v1 Message
-	RPCDataColumnSidecarsByRangeTopicV1: new(pb.DataColumnSidecarsByRangeRequest),
-	// DataColumnSidecarsByRoot v1 Message
-	RPCDataColumnSidecarsByRootTopicV1: new(p2ptypes.DataColumnsByRootIdentifiers),
-}
+		// RPC Block By Range Message
+		RPCBlocksByRangeTopicV1: new(pb.BeaconBlocksByRangeRequest),
+		RPCBlocksByRangeTopicV2: new(pb.BeaconBlocksByRangeRequest),

-// Maps all registered protocol prefixes.
-var protocolMapping = map[string]bool{
-	protocolPrefix: true,
-}
+		// RPC Block By Root Message
+		RPCBlocksByRootTopicV1: new(p2ptypes.BeaconBlockByRootsReq),
+		RPCBlocksByRootTopicV2: new(p2ptypes.BeaconBlockByRootsReq),

-// 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,
-	DataColumnSidecarsByRangeName:   true,
-}
+		// RPC Ping Message
+		RPCPingTopicV1: new(primitives.SSZUint64),

-// Maps all the RPC messages which are to updated in altair.
-var altairMapping = map[string]bool{
-	BeaconBlocksByRangeMessageName: true,
-	BeaconBlocksByRootsMessageName: true,
-	MetadataMessageName:            true,
-}
+		// RPC Metadata Message
+		RPCMetaDataTopicV1: new(interface{}),
+		RPCMetaDataTopicV2: new(interface{}),
+		RPCMetaDataTopicV3: new(interface{}),

-// Maps all the RPC messages which are to updated in fulu.
-var fuluMapping = map[string]bool{
-	MetadataMessageName: true,
-}
+		// BlobSidecarsByRange v1 Message
+		RPCBlobSidecarsByRangeTopicV1: new(pb.BlobSidecarsByRangeRequest),

-var versionMapping = map[string]bool{
-	SchemaVersionV1: true,
-	SchemaVersionV2: true,
-	SchemaVersionV3: true,
-}
+		// BlobSidecarsByRoot v1 Message
+		RPCBlobSidecarsByRootTopicV1: new(p2ptypes.BlobSidecarsByRootReq),

-// 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,
-}
+		// 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,
+	}
+)

 // VerifyTopicMapping verifies that the topic and its accompanying
 // message type is correct.
@@ -333,13 +344,17 @@ 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 && fuluMapping[msg] {
-		return protocolPrefix + msg + SchemaVersionV3, nil
+	if epoch >= beaconConfig.FuluForkEpoch {
+		if version, ok := fuluMapping[msg]; ok {
+			return protocolPrefix + msg + version, nil
+		}
 	}

 	// Check if the message is to be updated in altair.
-	if epoch >= beaconConfig.AltairForkEpoch && altairMapping[msg] {
-		return protocolPrefix + msg + SchemaVersionV2, nil
+	if epoch >= beaconConfig.AltairForkEpoch {
+		if version, ok := altairMapping[msg]; ok {
+			return protocolPrefix + msg + version, nil
+		}
 	}

 	return protocolPrefix + msg + SchemaVersionV1, nil
--- a/beacon-chain/p2p/rpc_topic_mappings_test.go
+++ b/beacon-chain/p2p/rpc_topic_mappings_test.go
@@ -119,50 +119,31 @@ func TestTopicFromMessage_CorrectType(t *testing.T) {
 	})

 	t.Run("after altair fork but before fulu fork", func(t *testing.T) {
-		for m := range messageMapping {
-			topic, err := TopicFromMessage(m, altairForkEpoch)
-			require.NoError(t, err)
+		// Not modified in altair fork.
+		topic, err := TopicFromMessage(GoodbyeMessageName, altairForkEpoch)
+		require.NoError(t, err)
+		require.Equal(t, "/eth2/beacon_chain/req/goodbye/1", 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)
-		}
+		// Modified in altair fork.
+		topic, err = TopicFromMessage(MetadataMessageName, altairForkEpoch)
+		require.NoError(t, err)
+		require.Equal(t, "/eth2/beacon_chain/req/metadata/2", topic)
 	})

 	t.Run("after fulu fork", func(t *testing.T) {
-		for m := range messageMapping {
-			topic, err := TopicFromMessage(m, fuluForkEpoch)
-			require.NoError(t, err)
+		// Not modified in any fork.
+		topic, err := TopicFromMessage(GoodbyeMessageName, fuluForkEpoch)
+		require.NoError(t, err)
+		require.Equal(t, "/eth2/beacon_chain/req/goodbye/1", 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 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 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)
-		}
+		// 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)
 	})
 }
--- a/beacon-chain/p2p/types/types.go
+++ b/beacon-chain/p2p/types/types.go
@@ -213,7 +213,7 @@ func (s BlobSidecarsByRootReq) Len() int {
 // ====================================
 // DataColumnsByRootIdentifiers section
 // ====================================
-var _ ssz.Marshaler = (*DataColumnsByRootIdentifiers)(nil)
+var _ ssz.Marshaler = DataColumnsByRootIdentifiers{}
 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
 }
--- a/beacon-chain/rpc/lookup/BUILD.bazel
+++ b/beacon-chain/rpc/lookup/BUILD.bazel
@@ -10,11 +10,13 @@ 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",
@@ -36,7 +38,9 @@ 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",
@@ -45,6 +49,7 @@ 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",
--- a/beacon-chain/rpc/lookup/blocker.go
+++ b/beacon-chain/rpc/lookup/blocker.go
@@ -3,12 +3,15 @@ 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"
@@ -49,6 +52,7 @@ 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:
@@ -212,64 +216,190 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []int) (

 	root := bytesutil.ToBytes32(rootSlice)

-	b, err := p.BeaconDB.Block(ctx, root)
+	roSignedBlock, 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 b == nil {
+
+	if roSignedBlock == 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(b.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(roSignedBlock.Block().Slot()), slots.ToEpoch(p.GenesisTimeFetcher.CurrentSlot())) {
 		return make([]*blocks.VerifiedROBlob, 0), nil
 	}

-	commitments, err := b.Block().Body().BlobKzgCommitments()
+	roBlock := roSignedBlock.Block()
+
+	commitments, err := roBlock.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
 	}

-	sum := p.BlobStorage.Summary(root)
+	// 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}
+		}
+	}

-	if len(indices) == 0 {
-		for i := range commitments {
-			if sum.HasIndex(uint64(i)) {
-				indices = append(indices, i)
+	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,
 			}
 		}
-	} 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,
-				}
+
+		if !summary.HasIndex(uint64(index)) {
+			return nil, &core.RpcError{
+				Err:    fmt.Errorf("requested index %d not found", index),
+				Reason: core.NotFound,
 			}
 		}
 	}

-	blobs := make([]*blocks.VerifiedROBlob, len(indices))
-	for i, index := range indices {
-		vblob, err := p.BlobStorage.Get(root, uint64(index))
+	// 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)
+			}
+		}
+	}
+
+	// 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))
 		if err != nil {
 			return nil, &core.RpcError{
-				Err:    fmt.Errorf("could not retrieve blob for block root %#x at index %d", rootSlice, index),
+				Err:    fmt.Errorf("could not retrieve blob for block root %#x at index %d", root, index),
 				Reason: core.Internal,
 			}
 		}
-		blobs[i] = &vblob
+
+		blobs = append(blobs, &blobSidecar)
 	}

 	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
+}
--- a/beacon-chain/rpc/lookup/blocker_test.go
+++ b/beacon-chain/rpc/lookup/blocker_test.go
@@ -8,12 +8,15 @@ 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"
@@ -158,172 +161,335 @@ func TestGetBlock(t *testing.T) {
 }

 func TestGetBlob(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.DenebForkEpoch = 1
-	params.OverrideBeaconConfig(cfg)
+	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)
+	}
+
 	ctx := t.Context()
 	db := testDB.SetupDB(t)
-	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]))
+
+	// 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)
 	}
-	blockRoot := blobs[0].BlockRoot()
+
+	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)
+
 	t.Run("genesis", func(t *testing.T) {
+		setupDeneb(t)
+
 		blocker := &BeaconDbBlocker{}
 		_, rpcErr := blocker.Blobs(ctx, "genesis", nil)
-		assert.Equal(t, http.StatusBadRequest, core.ErrorReasonToHTTP(rpcErr.Reason))
-		assert.StringContains(t, "blobs are not supported for Phase 0 fork", rpcErr.Err.Error())
+		require.Equal(t, http.StatusBadRequest, core.ErrorReasonToHTTP(rpcErr.Reason))
+		require.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: blockRoot[:]},
+			ChainInfoFetcher: &mockChain.ChainService{Root: denebBlockRoot[:]},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: bs,
+			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)
 		}
-		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: blockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: bs,
+			BlobStorage: blobStorage,
 		}

-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "finalized", nil)
-		assert.Equal(t, rpcErr == nil, true)
-		require.Equal(t, 4, len(verifiedBlobs))
+		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "finalized", nil)
+		require.IsNil(t, rpcErr)
+		require.Equal(t, blobCount, len(verifiedSidecars))
 	})
+
 	t.Run("justified", func(t *testing.T) {
+		setupDeneb(t)
+
 		blocker := &BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{CurrentJustifiedCheckPoint: &ethpb.Checkpoint{Root: blockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{CurrentJustifiedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: bs,
+			BlobStorage: blobStorage,
 		}

-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "justified", nil)
-		assert.Equal(t, rpcErr == nil, true)
-		require.Equal(t, 4, len(verifiedBlobs))
+		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "justified", nil)
+		require.IsNil(t, rpcErr)
+		require.Equal(t, blobCount, len(verifiedSidecars))
 	})
+
 	t.Run("root", func(t *testing.T) {
+		setupDeneb(t)
+
 		blocker := &BeaconDbBlocker{
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: bs,
+			BlobStorage: blobStorage,
 		}
-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(blockRoot[:]), nil)
-		assert.Equal(t, rpcErr == nil, true)
-		require.Equal(t, 4, len(verifiedBlobs))
+
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(denebBlockRoot[:]), nil)
+		require.IsNil(t, rpcErr)
+		require.Equal(t, blobCount, len(verifiedBlobs))
 	})
+
 	t.Run("slot", func(t *testing.T) {
+		setupDeneb(t)
+
 		blocker := &BeaconDbBlocker{
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: bs,
+			BlobStorage: blobStorage,
 		}
+
 		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123", nil)
-		assert.Equal(t, rpcErr == nil, true)
-		require.Equal(t, 4, len(verifiedBlobs))
+		require.IsNil(t, rpcErr)
+		require.Equal(t, blobCount, 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: blockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: bs,
+			BlobStorage: blobStorage,
 		}
-		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)
+
+		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)
 	})
+
 	t.Run("no blobs returns an empty array", func(t *testing.T) {
+		setupDeneb(t)
+
 		blocker := &BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: blockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
 			BlobStorage: filesystem.NewEphemeralBlobStorage(t),
 		}
+
 		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123", nil)
-		assert.Equal(t, rpcErr == nil, true)
+		require.IsNil(t, rpcErr)
 		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: blockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: bs,
+			BlobStorage: blobStorage,
 		}
-		noBlobIndex := len(blobs) + 1
+
+		noBlobIndex := len(storedBlobSidecars) + 1
 		_, rpcErr := blocker.Blobs(ctx, "123", []int{0, noBlobIndex})
 		require.NotNil(t, rpcErr)
-		assert.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
+		require.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: blockRoot[:]}},
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: denebBlockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
-			BlobStorage: bs,
+			BlobStorage: blobStorage,
 		}
 		_, rpcErr := blocker.Blobs(ctx, "123", []int{0, math.MaxInt})
 		require.NotNil(t, rpcErr)
-		assert.Equal(t, core.ErrorReason(core.BadRequest), rpcErr.Reason)
+		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)
+		}
 	})
 }
--- a/beacon-chain/sync/rpc_data_column_sidecars_by_range_test.go
+++ b/beacon-chain/sync/rpc_data_column_sidecars_by_range_test.go
@@ -169,7 +169,7 @@ func TestDataColumnSidecarsByRangeRPCHandler(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
--- a/beacon-chain/sync/rpc_data_column_sidecars_by_root.go
+++ b/beacon-chain/sync/rpc_data_column_sidecars_by_root.go
@@ -12,6 +12,7 @@ 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"
@@ -98,12 +99,15 @@ func (s *Service) dataColumnSidecarByRootRPCHandler(ctx context.Context, msg int
 	log.Debug("Serving data column sidecar by root request")

 	count := 0
-	for root, columns := range requestedColumnsByRoot {
+	for _, ident := range requestedColumnIdents {
 		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 {
--- a/beacon-chain/sync/rpc_data_column_sidecars_by_root_test.go
+++ b/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
--- a/beacon-chain/sync/rpc_send_request.go
+++ b/beacon-chain/sync/rpc_send_request.go
@@ -4,12 +4,14 @@ 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"
@@ -30,18 +32,24 @@ 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")
+	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")
 )

+// ------
+// 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
@@ -155,6 +163,14 @@ 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 {
@@ -216,10 +232,6 @@ 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 {
@@ -385,10 +397,258 @@ func readChunkedBlobSidecar(stream network.Stream, encoding encoder.NetworkEncod
 	return rob, nil
 }

-func readChunkedDataColumnSideCar(
+// --------------------
+// 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(
 	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())
@@ -432,5 +692,12 @@ 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
 }
--- a/beacon-chain/sync/rpc_send_request_test.go
+++ b/beacon-chain/sync/rpc_send_request_test.go
@@ -5,12 +5,15 @@ 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"
@@ -20,6 +23,7 @@ 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"
@@ -882,3 +886,745 @@ 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")
+		}
+	})
+}
--- a/beacon-chain/verification/error.go
+++ b/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.Join(ErrBlobInvalid, errors.New("slot is too far in the future"))
+	errFromFutureSlot = errors.New("slot is too far in the future")

 	// errSlotNotAfterFinalized means RequireSlotAboveFinalized failed.
-	errSlotNotAfterFinalized = errors.Join(ErrBlobInvalid, errors.New("slot <= finalized checkpoint"))
+	errSlotNotAfterFinalized = 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.Join(ErrBlobInvalid, errors.New("parent root has not been seen"))
+	errSidecarParentNotSeen = errors.New("parent root has not been seen")

 	// errSidecarParentInvalid means RequireSidecarParentValid failed.
 	errSidecarParentInvalid = errors.Join(ErrBlobInvalid, errors.New("parent block is not valid"))
--- a/changelog/kasey_customize-http-accept-header.md
+++ b/changelog/kasey_customize-http-accept-header.md
@@ -0,0 +1,2 @@
+## Added
+- env var to force beacon api client to use a custom accept header (eg force json responses).
--- a/changelog/manu-peerdas-beacon-api.md
+++ b/changelog/manu-peerdas-beacon-api.md
@@ -0,0 +1,2 @@
+### Added 
+- Implement beacon API blob sidecar enpoint for Fulu.
--- a/changelog/manu-peerdas-dataColumnSidecarByRootRPCHandler.md
+++ b/changelog/manu-peerdas-dataColumnSidecarByRootRPCHandler.md
@@ -0,0 +1,2 @@
+### Fixed 
+- Non deterministic output order of `dataColumnSidecarByRootRPCHandler`. 
--- a/changelog/manu-peerdas-send-data-column-requests.md
+++ b/changelog/manu-peerdas-send-data-column-requests.md
@@ -0,0 +1,3 @@
+### Added 
+- Implement `SendDataColumnSidecarsByRangeRequest`.
+- Implement `SendDataColumnSidecarsByRootRequest`.
--- a/changelog/manu-peerdas-variou.md
+++ b/changelog/manu-peerdas-variou.md
@@ -0,0 +1,9 @@
+### 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.
--- a/changelog/tt_steak.md
+++ b/changelog/tt_steak.md
@@ -0,0 +1,3 @@
+### Changed
+
+- Remove "invalid" from logs for incoming blob sidecar that is missing parent or out of range slot
--- a/proto/prysm/v1alpha1/BUILD.bazel
+++ b/proto/prysm/v1alpha1/BUILD.bazel
@@ -2,14 +2,13 @@
 # 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")

@@ -189,6 +188,7 @@ ssz_fulu_objs = [
    "DataColumnIdentifier",
    "DataColumnsByRootIdentifier",
    "DataColumnSidecar",
+    "StatusV2",
    "SignedBeaconBlockContentsFulu",
    "SignedBeaconBlockFulu",
    "SignedBlindedBeaconBlockFulu",
@@ -359,15 +359,17 @@ 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",
-        "//consensus-types/primitives:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
        "@com_github_golang_protobuf//proto:go_default_library",
+        "@com_github_pkg_errors//: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",
@@ -382,8 +384,6 @@ 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",
    ],
 )

--- a/proto/prysm/v1alpha1/data_columns.pb.go
+++ b/proto/prysm/v1alpha1/data_columns.pb.go
@@ -109,61 +109,6 @@ 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
@@ -176,7 +121,7 @@ type DataColumnsByRootIdentifier struct {
 func (x *DataColumnsByRootIdentifier) Reset() {
 	*x = DataColumnsByRootIdentifier{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[2]
+		mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[1]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -189,7 +134,7 @@ func (x *DataColumnsByRootIdentifier) String() string {
 func (*DataColumnsByRootIdentifier) ProtoMessage() {}

 func (x *DataColumnsByRootIdentifier) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_data_columns_proto_msgTypes[2]
+	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 {
@@ -202,7 +147,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{2}
+	return file_proto_prysm_v1alpha1_data_columns_proto_rawDescGZIP(), []int{1}
 }

 func (x *DataColumnsByRootIdentifier) GetBlockRoot() []byte {
@@ -253,29 +198,24 @@ 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, 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,
+	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,
 }

 var (
@@ -290,15 +230,14 @@ 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, 3)
+var file_proto_prysm_v1alpha1_data_columns_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
 var file_proto_prysm_v1alpha1_data_columns_proto_goTypes = []interface{}{
 	(*DataColumnSidecar)(nil),           // 0: ethereum.eth.v1alpha1.DataColumnSidecar
-	(*DataColumnIdentifier)(nil),        // 1: ethereum.eth.v1alpha1.DataColumnIdentifier
-	(*DataColumnsByRootIdentifier)(nil), // 2: ethereum.eth.v1alpha1.DataColumnsByRootIdentifier
-	(*SignedBeaconBlockHeader)(nil),     // 3: ethereum.eth.v1alpha1.SignedBeaconBlockHeader
+	(*DataColumnsByRootIdentifier)(nil), // 1: ethereum.eth.v1alpha1.DataColumnsByRootIdentifier
+	(*SignedBeaconBlockHeader)(nil),     // 2: ethereum.eth.v1alpha1.SignedBeaconBlockHeader
 }
 var file_proto_prysm_v1alpha1_data_columns_proto_depIdxs = []int32{
-	3, // 0: ethereum.eth.v1alpha1.DataColumnSidecar.signed_block_header:type_name -> ethereum.eth.v1alpha1.SignedBeaconBlockHeader
+	2, // 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
@@ -326,18 +265,6 @@ 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
@@ -356,7 +283,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:   3,
+			NumMessages:   2,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
--- a/proto/prysm/v1alpha1/data_columns.proto
+++ b/proto/prysm/v1alpha1/data_columns.proto
@@ -45,11 +45,6 @@ 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" ];
--- a/proto/prysm/v1alpha1/fulu.ssz.go
+++ b/proto/prysm/v1alpha1/fulu.ssz.go
@@ -2246,77 +2246,6 @@ 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)
@@ -2436,3 +2365,132 @@ 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
+}
--- a/proto/prysm/v1alpha1/p2p_messages.pb.go
+++ b/proto/prysm/v1alpha1/p2p_messages.pb.go
@@ -104,6 +104,93 @@ 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
@@ -117,7 +204,7 @@ type BeaconBlocksByRangeRequest struct {
 func (x *BeaconBlocksByRangeRequest) Reset() {
 	*x = BeaconBlocksByRangeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[1]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -130,7 +217,7 @@ func (x *BeaconBlocksByRangeRequest) String() string {
 func (*BeaconBlocksByRangeRequest) ProtoMessage() {}

 func (x *BeaconBlocksByRangeRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[1]
+	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 {
@@ -143,7 +230,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{1}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{2}
 }

 func (x *BeaconBlocksByRangeRequest) GetStartSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
@@ -180,7 +267,7 @@ type ENRForkID struct {
 func (x *ENRForkID) Reset() {
 	*x = ENRForkID{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -193,7 +280,7 @@ func (x *ENRForkID) String() string {
 func (*ENRForkID) ProtoMessage() {}

 func (x *ENRForkID) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2]
+	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 {
@@ -206,7 +293,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{2}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{3}
 }

 func (x *ENRForkID) GetCurrentForkDigest() []byte {
@@ -242,7 +329,7 @@ type MetaDataV0 struct {
 func (x *MetaDataV0) Reset() {
 	*x = MetaDataV0{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -255,7 +342,7 @@ func (x *MetaDataV0) String() string {
 func (*MetaDataV0) ProtoMessage() {}

 func (x *MetaDataV0) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3]
+	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 {
@@ -268,7 +355,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{3}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{4}
 }

 func (x *MetaDataV0) GetSeqNumber() uint64 {
@@ -298,7 +385,7 @@ type MetaDataV1 struct {
 func (x *MetaDataV1) Reset() {
 	*x = MetaDataV1{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -311,7 +398,7 @@ func (x *MetaDataV1) String() string {
 func (*MetaDataV1) ProtoMessage() {}

 func (x *MetaDataV1) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4]
+	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 {
@@ -324,7 +411,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{4}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{5}
 }

 func (x *MetaDataV1) GetSeqNumber() uint64 {
@@ -362,7 +449,7 @@ type MetaDataV2 struct {
 func (x *MetaDataV2) Reset() {
 	*x = MetaDataV2{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -375,7 +462,7 @@ func (x *MetaDataV2) String() string {
 func (*MetaDataV2) ProtoMessage() {}

 func (x *MetaDataV2) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5]
+	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 {
@@ -388,7 +475,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{5}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{6}
 }

 func (x *MetaDataV2) GetSeqNumber() uint64 {
@@ -431,7 +518,7 @@ type BlobSidecarsByRangeRequest struct {
 func (x *BlobSidecarsByRangeRequest) Reset() {
 	*x = BlobSidecarsByRangeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -444,7 +531,7 @@ func (x *BlobSidecarsByRangeRequest) String() string {
 func (*BlobSidecarsByRangeRequest) ProtoMessage() {}

 func (x *BlobSidecarsByRangeRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6]
+	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 {
@@ -457,7 +544,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{6}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{7}
 }

 func (x *BlobSidecarsByRangeRequest) GetStartSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
@@ -487,7 +574,7 @@ type DataColumnSidecarsByRangeRequest struct {
 func (x *DataColumnSidecarsByRangeRequest) Reset() {
 	*x = DataColumnSidecarsByRangeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -500,7 +587,7 @@ func (x *DataColumnSidecarsByRangeRequest) String() string {
 func (*DataColumnSidecarsByRangeRequest) ProtoMessage() {}

 func (x *DataColumnSidecarsByRangeRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7]
+	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 {
@@ -513,7 +600,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{7}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{8}
 }

 func (x *DataColumnSidecarsByRangeRequest) GetStartSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
@@ -549,7 +636,7 @@ type LightClientUpdatesByRangeRequest struct {
 func (x *LightClientUpdatesByRangeRequest) Reset() {
 	*x = LightClientUpdatesByRangeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8]
+		mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[9]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -562,7 +649,7 @@ func (x *LightClientUpdatesByRangeRequest) String() string {
 func (*LightClientUpdatesByRangeRequest) ProtoMessage() {}

 func (x *LightClientUpdatesByRangeRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8]
+	mi := &file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[9]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -575,7 +662,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{8}
+	return file_proto_prysm_v1alpha1_p2p_messages_proto_rawDescGZIP(), []int{9}
 }

 func (x *LightClientUpdatesByRangeRequest) GetStartPeriod() uint64 {
@@ -624,109 +711,138 @@ 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, 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,
+	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,
+	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, 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,
+	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, 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,
+	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,
 }

 var (
@@ -741,17 +857,18 @@ 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, 9)
+var file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
 var file_proto_prysm_v1alpha1_p2p_messages_proto_goTypes = []interface{}{
 	(*Status)(nil),                           // 0: ethereum.eth.v1alpha1.Status
-	(*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
+	(*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
 }
 var file_proto_prysm_v1alpha1_p2p_messages_proto_depIdxs = []int32{
 	0, // [0:0] is the sub-list for method output_type
@@ -780,7 +897,7 @@ 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.(*BeaconBlocksByRangeRequest); i {
+			switch v := v.(*StatusV2); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -792,7 +909,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ENRForkID); i {
+			switch v := v.(*BeaconBlocksByRangeRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -804,7 +921,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MetaDataV0); i {
+			switch v := v.(*ENRForkID); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -816,7 +933,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MetaDataV1); i {
+			switch v := v.(*MetaDataV0); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -828,7 +945,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MetaDataV2); i {
+			switch v := v.(*MetaDataV1); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -840,7 +957,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*BlobSidecarsByRangeRequest); i {
+			switch v := v.(*MetaDataV2); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -852,7 +969,7 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DataColumnSidecarsByRangeRequest); i {
+			switch v := v.(*BlobSidecarsByRangeRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -864,6 +981,18 @@ func file_proto_prysm_v1alpha1_p2p_messages_proto_init() {
 			}
 		}
 		file_proto_prysm_v1alpha1_p2p_messages_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DataColumnSidecarsByRangeRequest); 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[9].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LightClientUpdatesByRangeRequest); i {
 			case 0:
 				return &v.state
@@ -882,7 +1011,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:   9,
+			NumMessages:   10,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
--- a/proto/prysm/v1alpha1/p2p_messages.proto
+++ b/proto/prysm/v1alpha1/p2p_messages.proto
@@ -26,6 +26,24 @@ 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) =
--- a/testing/util/fulu.go
+++ b/testing/util/fulu.go
@@ -1,7 +1,6 @@
 package util

 import (
-	"encoding/binary"
 	"math/big"
 	"testing"

@@ -110,14 +109,21 @@ func GenerateTestFuluBlockWithSidecars(t *testing.T, blobCount int, options ...F
 	block.Block.ParentRoot = generator.parent[:]
 	block.Block.ProposerIndex = generator.proposer

-	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[:]
+	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 = commitments
+
 	body, err := blocks.NewBeaconBlockBody(block.Block.Body)
 	require.NoError(t, err)

@@ -149,39 +155,30 @@ func GenerateTestFuluBlockWithSidecars(t *testing.T, blobCount int, options ...F
 	root, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)

-	sbb, err := blocks.NewSignedBeaconBlock(block)
+	signedBeaconBlock, 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)

-	dataColumns, err := peerdas.DataColumnSidecars(sbb, cellsAndProofs)
+	sidecars, err := peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
 	require.NoError(t, err)

-	roSidecars := make([]blocks.RODataColumn, 0, len(dataColumns))
-	roVerifiedSidecars := make([]blocks.VerifiedRODataColumn, 0, len(dataColumns))
-	for _, dataColumn := range dataColumns {
-		roSidecar, err := blocks.NewRODataColumnWithRoot(dataColumn, root)
+	roSidecars := make([]blocks.RODataColumn, 0, len(sidecars))
+	verifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(sidecars))
+	for _, sidecar := range sidecars {
+		roSidecar, err := blocks.NewRODataColumnWithRoot(sidecar, root)
 		require.NoError(t, err)

 		roVerifiedSidecar := blocks.NewVerifiedRODataColumn(roSidecar)

 		roSidecars = append(roSidecars, roSidecar)
-		roVerifiedSidecars = append(roVerifiedSidecars, roVerifiedSidecar)
+		verifiedRoSidecars = append(verifiedRoSidecars, roVerifiedSidecar)
 	}

-	rob, err := blocks.NewROBlockWithRoot(sbb, root)
+	roBlock, err := blocks.NewROBlockWithRoot(signedBeaconBlock, root)
 	require.NoError(t, err)

-	return rob, roSidecars, roVerifiedSidecars
+	return roBlock, roSidecars, verifiedRoSidecars
 }

 func GenerateCellsAndProofs(t testing.TB, blobs []kzg.Blob) []kzg.CellsAndProofs {
Author	SHA1	Message	Date
Kasey Kirkham	b1fc178b7d	support env var to customize Accept header	2025-06-26 12:08:23 -05:00
Manu NALEPA	97f416b3a7	`dataColumnSidecarByRootRPCHandler`: Do not rely any more on map iteration, which does not produce reproducible output order. (#15441 )	2025-06-26 13:07:19 +00:00
Manu NALEPA	1c1e0f38bb	PeerDAS: Implement beacon API blob sidecar endpoint for Fulu (#15436 ) * `TestGetBlob`: Refactor (no functional change). * `GenerateTestFuluBlockWithSidecars`: Generate commitments consistent with blobs. This is actually not needed for this PR, but it does not hurt. * Beacon API: Implement blob sidecars endpoint for Fulu. * Fix Radek's comment. * Update beacon-chain/rpc/lookup/blocker.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * Fix Radek's comment. * Update beacon-chain/rpc/lookup/blocker.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> --------- Co-authored-by: Radosław Kapka <rkapka@wp.pl>	2025-06-26 10:05:22 +00:00
Manu NALEPA	121914d0d7	Implement `SendDataColumnSidecarsByRangeRequest` and `SendDataColumnSidecarsByRootRequest`. (#15430 ) * Implement `SendDataColumnSidecarsByRangeRequest` and `SendDataColumnSidecarsByRootRequest`. * Fix James's comment. * Fix James's comment. * Fix James' comment. * Fix marshaller.	2025-06-24 21:40:16 +00:00
Manu NALEPA	e8625cd89d	Peerdas various (#15423 ) * Topic mapping: Groupe `const` and `var`. Cosmetic change, no functional change. * `TopicFromMessage`: Do not assume anymore that all Fulu specific topics are V3 only. * Proto: Remove unused `DataColumnIdentifier` and add new `StatusV2`. `DataColumnIdentifier` was removed in the spec here: https://github.com/ethereum/consensus-specs/pull/4284. Eventually, we stopped using it in Prysm, but never removed the corresponding proto message. The new `StatusV2` is introduced in the spec here: https://github.com/ethereum/consensus-specs/pull/4374 * `readChunkedDataColumnSideCar` ==> `readChunkedDataColumnSidecar`. * `rpc_send_request.go`: Reorganize file (no function change). * `readChunkedDataColumnSidecar`: Add `validationFunctions` parameter and add tests.	2025-06-23 14:47:02 +00:00
terence	667aaf1564	Remove invalid from logs for blob sidecars missing parent or out of range (#15428 )	2025-06-22 21:55:44 +00:00
Bastin	e020907d2a	Revert "SSZ support for submitAttestationsV2 (#15422 )" (#15426 ) This reverts commit `9927cea35a`.	2025-06-20 21:21:16 +00:00
Bastin	9927cea35a	SSZ support for submitAttestationsV2 (#15422 ) * ssz support for submitAttestationsV2 * changelog * lowercase errors * save 1 line * Update beacon-chain/rpc/eth/beacon/handlers_pool.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * add comment --------- Co-authored-by: Radosław Kapka <rkapka@wp.pl>	2025-06-20 17:21:48 +00:00