Changelog fragment

* `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>

beacon-chain/blockchain/log.go

@@ -26,9 +26,6 @@ func logStateTransitionData(b interfaces.ReadOnlyBeaconBlock) error {
 	if len(b.Body().Attestations()) > 0 {
 		log = log.WithField("attestations", len(b.Body().Attestations()))
 	}
-	if len(b.Body().Deposits()) > 0 {
-		log = log.WithField("deposits", len(b.Body().Deposits()))
-	}
 	if len(b.Body().AttesterSlashings()) > 0 {
 		log = log.WithField("attesterSlashings", len(b.Body().AttesterSlashings()))
 	}
@@ -111,7 +108,6 @@ func logBlockSyncStatus(block interfaces.ReadOnlyBeaconBlock, blockRoot [32]byte
 			"sinceSlotStartTime":         prysmTime.Now().Sub(startTime),
 			"chainServiceProcessedTime":  prysmTime.Now().Sub(receivedTime) - daWaitedTime,
 			"dataAvailabilityWaitedTime": daWaitedTime,
-			"deposits":                   len(block.Body().Deposits()),
 		}
 		log.WithFields(lf).Debug("Synced new block")
 	} else {
@@ -159,7 +155,9 @@ func logPayload(block interfaces.ReadOnlyBeaconBlock) error {
 		if err != nil {
 			return errors.Wrap(err, "could not get BLSToExecutionChanges")
 		}
-		fields["blsToExecutionChanges"] = len(changes)
+		if len(changes) > 0 {
+			fields["blsToExecutionChanges"] = len(changes)
+		}
 	}
 	log.WithFields(fields).Debug("Synced new payload")
 	return nil

beacon-chain/blockchain/log_test.go

@@ -53,7 +53,7 @@ func Test_logStateTransitionData(t *testing.T) {
 				require.NoError(t, err)
 				return wb
 			},
-			want: "\"Finished applying state transition\" attestations=1 deposits=1 prefix=blockchain slot=0",
+			want: "\"Finished applying state transition\" attestations=1 prefix=blockchain slot=0",
 		},
 		{name: "has attester slashing",
 			b: func() interfaces.ReadOnlyBeaconBlock {
@@ -93,7 +93,7 @@ func Test_logStateTransitionData(t *testing.T) {
 				require.NoError(t, err)
 				return wb
 			},
-			want: "\"Finished applying state transition\" attestations=1 attesterSlashings=1 deposits=1 prefix=blockchain proposerSlashings=1 slot=0 voluntaryExits=1",
+			want: "\"Finished applying state transition\" attestations=1 attesterSlashings=1 prefix=blockchain proposerSlashings=1 slot=0 voluntaryExits=1",
 		},
 		{name: "has payload",
 			b:    func() interfaces.ReadOnlyBeaconBlock { return wrappedPayloadBlk },

beacon-chain/blockchain/options.go

@@ -258,3 +258,12 @@ func WithLightClientStore(lcs *lightclient.Store) Option {
 		return nil
 	}
 }
+
+// WithStartWaitingDataColumnSidecars sets a channel that the `areDataColumnsAvailable` function will fill
+// in when starting to wait for additional data columns.
+func WithStartWaitingDataColumnSidecars(c chan bool) Option {
+	return func(s *Service) error {
+		s.startWaitingDataColumnSidecars = c
+		return nil
+	}
+}

beacon-chain/blockchain/process_block.go

@@ -732,9 +732,8 @@ func (s *Service) areDataColumnsAvailable(
 		return nil
 	}
 
-	// Notify the caller that we are waiting for data columns.
-	if s.startWaitingChan != nil {
-		s.startWaitingChan <- true
+	if s.startWaitingDataColumnSidecars != nil {
+		s.startWaitingDataColumnSidecars <- true
 	}
 
 	// Log for DA checks that cross over into the next slot; helpful for debugging.

beacon-chain/blockchain/process_block_test.go

@@ -3412,8 +3412,10 @@ func TestIsDataAvailable(t *testing.T) {
 	})
 
 	t.Run("Fulu - some initially missing data columns (no reconstruction)", func(t *testing.T) {
+		startWaiting := make(chan bool)
+
 		testParams := testIsAvailableParams{
-			options:       []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
+			options:       []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave: []uint64{1, 17, 19, 75, 102, 117, 119}, // 119 is not needed, 42 and 87 are missing
 
 			blobKzgCommitmentsCount: 3,
@@ -3440,10 +3442,8 @@ func TestIsDataAvailable(t *testing.T) {
 			{Index: 42, Slot: slot, ProposerIndex: proposerIndex, ParentRoot: parentRoot[:], StateRoot: stateRoot[:], BodyRoot: bodyRoot[:]}, // Needed index
 		})
 
-		service.startWaitingChan = make(chan bool)
-
 		go func() {
-			<-service.startWaitingChan
+			<-startWaiting
 
 			err := service.dataColumnStorage.Save(verifiedSidecarsWrongRoot)
 			require.NoError(t, err)
@@ -3461,6 +3461,9 @@ func TestIsDataAvailable(t *testing.T) {
 			missingColumns = uint64(2)
 			cgc            = 128
 		)
+
+		startWaiting := make(chan bool)
+
 		var custodyInfo peerdas.CustodyInfo
 		custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(cgc)
 		custodyInfo.ToAdvertiseGroupCount.Set(cgc)
@@ -3473,7 +3476,7 @@ func TestIsDataAvailable(t *testing.T) {
 		}
 
 		testParams := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&custodyInfo)},
+			options:                 []Option{WithCustodyInfo(&custodyInfo), WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave:           indices,
 			blobKzgCommitmentsCount: 3,
 		}
@@ -3503,10 +3506,8 @@ func TestIsDataAvailable(t *testing.T) {
 
 		_, verifiedSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParams)
 
-		service.startWaitingChan = make(chan bool)
-
 		go func() {
-			<-service.startWaitingChan
+			<-startWaiting
 
 			err := service.dataColumnStorage.Save(verifiedSidecars)
 			require.NoError(t, err)
@@ -3517,16 +3518,17 @@ func TestIsDataAvailable(t *testing.T) {
 	})
 
 	t.Run("Fulu - some columns are definitively missing", func(t *testing.T) {
+		startWaiting := make(chan bool)
+
 		params := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
+			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
 			blobKzgCommitmentsCount: 3,
 		}
 
 		ctx, cancel, service, root, signed := testIsAvailableSetup(t, params)
 
-		service.startWaitingChan = make(chan bool)
 		go func() {
-			<-service.startWaitingChan
+			<-startWaiting
 			cancel()
 		}()
 

beacon-chain/blockchain/service.go

@@ -47,28 +47,28 @@ import (
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg                  *config
-	ctx                  context.Context
-	cancel               context.CancelFunc
-	genesisTime          time.Time
-	head                 *head
-	headLock             sync.RWMutex
-	originBlockRoot      [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
-	boundaryRoots        [][32]byte
-	checkpointStateCache *cache.CheckpointStateCache
-	initSyncBlocks       map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
-	initSyncBlocksLock   sync.RWMutex
-	wsVerifier           *WeakSubjectivityVerifier
-	clockSetter          startup.ClockSetter
-	clockWaiter          startup.ClockWaiter
-	syncComplete         chan struct{}
-	blobNotifiers        *blobNotifierMap
-	blockBeingSynced     *currentlySyncingBlock
-	blobStorage          *filesystem.BlobStorage
-	dataColumnStorage    *filesystem.DataColumnStorage
-	slasherEnabled       bool
-	lcStore              *lightClient.Store
-	startWaitingChan     chan bool // mostly for testing, only instantiated in tests
+	cfg                            *config
+	ctx                            context.Context
+	cancel                         context.CancelFunc
+	genesisTime                    time.Time
+	head                           *head
+	headLock                       sync.RWMutex
+	originBlockRoot                [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
+	boundaryRoots                  [][32]byte
+	checkpointStateCache           *cache.CheckpointStateCache
+	initSyncBlocks                 map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
+	initSyncBlocksLock             sync.RWMutex
+	wsVerifier                     *WeakSubjectivityVerifier
+	clockSetter                    startup.ClockSetter
+	clockWaiter                    startup.ClockWaiter
+	syncComplete                   chan struct{}
+	blobNotifiers                  *blobNotifierMap
+	blockBeingSynced               *currentlySyncingBlock
+	blobStorage                    *filesystem.BlobStorage
+	dataColumnStorage              *filesystem.DataColumnStorage
+	slasherEnabled                 bool
+	lcStore                        *lightClient.Store
+	startWaitingDataColumnSidecars chan bool // for testing purposes only
 }
 
 // config options for the service.

beacon-chain/execution/engine_client.go

@@ -2,6 +2,7 @@ package execution
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math/big"
 	"strings"
@@ -26,7 +27,6 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	gethRPC "github.com/ethereum/go-ethereum/rpc"
 	"github.com/holiman/uint256"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"google.golang.org/protobuf/proto"
 )
@@ -158,7 +158,7 @@ func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionDa
 		} else {
 			flattenedRequests, err := pb.EncodeExecutionRequests(executionRequests)
 			if err != nil {
-				return nil, errors.Wrap(err, "failed to encode execution requests")
+				return nil, fmt.Errorf("failed to encode execution requests: %w", err)
 			}
 			err = s.rpcClient.CallContext(ctx, result, NewPayloadMethodV4, payloadPb, versionedHashes, parentBlockRoot, flattenedRequests)
 			if err != nil {
@@ -346,14 +346,14 @@ func (s *Service) GetTerminalBlockHash(ctx context.Context, transitionTime uint6
 	ttd.SetString(params.BeaconConfig().TerminalTotalDifficulty, 10)
 	terminalTotalDifficulty, overflows := uint256.FromBig(ttd)
 	if overflows {
-		return nil, false, errors.New("could not convert terminal total difficulty to uint256")
+		return nil, false, fmt.Errorf("could not convert terminal total difficulty to uint256")
 	}
 	blk, err := s.LatestExecutionBlock(ctx)
 	if err != nil {
-		return nil, false, errors.Wrap(err, "could not get latest execution block")
+		return nil, false, fmt.Errorf("could not get latest execution block: %w", err)
 	}
 	if blk == nil {
-		return nil, false, errors.New("latest execution block is nil")
+		return nil, false, fmt.Errorf("latest execution block is nil")
 	}
 
 	for {
@@ -362,7 +362,7 @@ func (s *Service) GetTerminalBlockHash(ctx context.Context, transitionTime uint6
 		}
 		currentTotalDifficulty, err := tDStringToUint256(blk.TotalDifficulty)
 		if err != nil {
-			return nil, false, errors.Wrap(err, "could not convert total difficulty to uint256")
+			return nil, false, fmt.Errorf("could not convert total difficulty to uint256: %w", err)
 		}
 		blockReachedTTD := currentTotalDifficulty.Cmp(terminalTotalDifficulty) >= 0
 
@@ -372,16 +372,16 @@ func (s *Service) GetTerminalBlockHash(ctx context.Context, transitionTime uint6
 		}
 		parentBlk, err := s.ExecutionBlockByHash(ctx, parentHash, false /* no txs */)
 		if err != nil {
-			return nil, false, errors.Wrap(err, "could not get parent execution block")
+			return nil, false, fmt.Errorf("could not get parent execution block: %w", err)
 		}
 		if parentBlk == nil {
-			return nil, false, errors.New("parent execution block is nil")
+			return nil, false, fmt.Errorf("parent execution block is nil")
 		}
 
 		if blockReachedTTD {
 			parentTotalDifficulty, err := tDStringToUint256(parentBlk.TotalDifficulty)
 			if err != nil {
-				return nil, false, errors.Wrap(err, "could not convert total difficulty to uint256")
+				return nil, false, fmt.Errorf("could not convert total difficulty to uint256: %w", err)
 			}
 
 			// If terminal block has time same timestamp or greater than transition time,
@@ -515,7 +515,7 @@ func (s *Service) ReconstructFullBlock(
 		return nil, err
 	}
 	if len(reconstructed) != 1 {
-		return nil, errors.Errorf("could not retrieve the correct number of payload bodies: wanted 1 but got %d", len(reconstructed))
+		return nil, fmt.Errorf("could not retrieve the correct number of payload bodies: wanted 1 but got %d", len(reconstructed))
 	}
 	return reconstructed[0], nil
 }
@@ -544,7 +544,7 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 	blockBody := block.Block().Body()
 	kzgCommitments, err := blockBody.BlobKzgCommitments()
 	if err != nil {
-		return nil, errors.Wrap(err, "could not get blob KZG commitments")
+		return nil, fmt.Errorf("could not get blob KZG commitments: %w", err)
 	}
 
 	// Collect KZG hashes for non-existing blobs
@@ -563,7 +563,7 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 	// Fetch blobs from EL
 	blobs, err := s.GetBlobs(ctx, kzgHashes)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not get blobs")
+		return nil, fmt.Errorf("could not get blobs: %w", err)
 	}
 	if len(blobs) == 0 {
 		return nil, nil
@@ -571,7 +571,7 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 
 	header, err := block.Header()
 	if err != nil {
-		return nil, errors.Wrap(err, "could not get header")
+		return nil, fmt.Errorf("could not get header: %w", err)
 	}
 
 	// Reconstruct verified blob sidecars
@@ -619,17 +619,17 @@ func fullPayloadFromPayloadBody(
 	header interfaces.ExecutionData, body *pb.ExecutionPayloadBody, bVersion int,
 ) (interfaces.ExecutionData, error) {
 	if header == nil || header.IsNil() || body == nil {
-		return nil, errors.New("execution block and header cannot be nil")
+		return nil, fmt.Errorf("execution block and header cannot be nil")
 	}
 
 	if bVersion >= version.Deneb {
 		ebg, err := header.ExcessBlobGas()
 		if err != nil {
-			return nil, errors.Wrap(err, "unable to extract ExcessBlobGas attribute from execution payload header")
+			return nil, fmt.Errorf("unable to extract ExcessBlobGas attribute from execution payload header: %w", err)
 		}
 		bgu, err := header.BlobGasUsed()
 		if err != nil {
-			return nil, errors.Wrap(err, "unable to extract BlobGasUsed attribute from execution payload header")
+			return nil, fmt.Errorf("unable to extract BlobGasUsed attribute from execution payload header: %w", err)
 		}
 		return blocks.WrappedExecutionPayloadDeneb(
 			&pb.ExecutionPayloadDeneb{
@@ -713,45 +713,45 @@ func handleRPCError(err error) error {
 				"here https://docs.prylabs.network/docs/execution-node/authentication")
 			return fmt.Errorf("could not authenticate connection to execution client: %w", err)
 		}
-		return errors.Wrapf(err, "got an unexpected error in JSON-RPC response")
+		return fmt.Errorf("got an unexpected error in JSON-RPC response: %w", err)
 	}
 	switch e.ErrorCode() {
 	case -32700:
 		errParseCount.Inc()
-		return ErrParse
+		return errors.Join(errors.New(e.Error()), ErrParse)
 	case -32600:
 		errInvalidRequestCount.Inc()
-		return ErrInvalidRequest
+		return errors.Join(errors.New(e.Error()), ErrInvalidRequest)
 	case -32601:
 		errMethodNotFoundCount.Inc()
-		return ErrMethodNotFound
+		return errors.Join(errors.New(e.Error()), ErrMethodNotFound)
 	case -32602:
 		errInvalidParamsCount.Inc()
-		return ErrInvalidParams
+		return errors.Join(errors.New(e.Error()), ErrInvalidParams)
 	case -32603:
 		errInternalCount.Inc()
-		return ErrInternal
+		return errors.Join(errors.New(e.Error()), ErrInternal)
 	case -38001:
 		errUnknownPayloadCount.Inc()
-		return ErrUnknownPayload
+		return errors.Join(errors.New(e.Error()), ErrUnknownPayload)
 	case -38002:
 		errInvalidForkchoiceStateCount.Inc()
-		return ErrInvalidForkchoiceState
+		return errors.Join(errors.New(e.Error()), ErrInvalidForkchoiceState)
 	case -38003:
 		errInvalidPayloadAttributesCount.Inc()
-		return ErrInvalidPayloadAttributes
+		return errors.Join(errors.New(e.Error()), ErrInvalidPayloadAttributes)
 	case -38004:
 		errRequestTooLargeCount.Inc()
-		return ErrRequestTooLarge
+		return errors.Join(errors.New(e.Error()), ErrRequestTooLarge)
 	case -32000:
 		errServerErrorCount.Inc()
 		// Only -32000 status codes are data errors in the RPC specification.
 		var errWithData gethRPC.DataError
 		ok := errors.As(err, &errWithData)
 		if !ok {
-			return errors.Wrapf(err, "got an unexpected error in JSON-RPC response")
+			return fmt.Errorf("got an unexpected error in JSON-RPC response: %w", err)
 		}
-		return errors.Wrapf(ErrServer, "%v", errWithData.Error())
+		return fmt.Errorf("%v: %w", errWithData.Error(), ErrServer)
 	default:
 		return err
 	}
@@ -778,7 +778,7 @@ func tDStringToUint256(td string) (*uint256.Int, error) {
 	}
 	i, overflows := uint256.FromBig(b)
 	if overflows {
-		return nil, errors.New("total difficulty overflowed")
+		return nil, fmt.Errorf("total difficulty overflowed")
 	}
 	return i, nil
 }
@@ -831,7 +831,7 @@ func EmptyExecutionPayload(v int) (proto.Message, error) {
 		}, nil
 	}
 
-	return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
+	return nil, fmt.Errorf("version=%s: %w", version.String(v), ErrUnsupportedVersion)
 }
 
 func EmptyExecutionPayloadHeader(v int) (proto.Message, error) {
@@ -881,7 +881,7 @@ func EmptyExecutionPayloadHeader(v int) (proto.Message, error) {
 		}, nil
 	}
 
-	return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
+	return nil, fmt.Errorf("version=%s: %w", version.String(v), ErrUnsupportedVersion)
 }
 
 func toBlockNumArg(number *big.Int) string {

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
@@ -101,6 +103,9 @@ const (
 	// RPCDataColumnSidecarsByRootTopicV1 is a topic for requesting data column sidecars by their block root.
 	// /eth2/beacon_chain/req/data_column_sidecars_by_root/1 - New in Fulu.
 	RPCDataColumnSidecarsByRootTopicV1 = protocolPrefix + DataColumnSidecarsByRootName + SchemaVersionV1
+	// RPCDataColumnSidecarsByRangeTopicV1 is a topic for requesting data column sidecars by their slot.
+	// /eth2/beacon_chain/req/data_column_sidecars_by_range/1 - New in Fulu.
+	RPCDataColumnSidecarsByRangeTopicV1 = protocolPrefix + DataColumnSidecarsByRangeName + SchemaVersionV1
 
 	// V2 RPC Topics
 	// RPCBlocksByRangeTopicV2 defines v2 the topic for the blocks by range rpc method.
@@ -121,91 +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),
 
-	// 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,
-}
+		// 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.
@@ -327,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

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)
 	})
 }

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
 }

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",

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
+}

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

beacon-chain/sync/BUILD.bazel

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

beacon-chain/sync/metrics.go

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

beacon-chain/sync/rate_limiter.go

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

beacon-chain/sync/rate_limiter_test.go

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

beacon-chain/sync/rpc.go

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

beacon-chain/sync/rpc_data_column_sidecars_by_range.go

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

beacon-chain/sync/rpc_data_column_sidecars_by_range_test.go

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

beacon-chain/sync/rpc_data_column_sidecars_by_root.go

@@ -12,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 {
@@ -170,5 +174,10 @@ func dataColumnsRPCMinValidSlot(currentSlot primitives.Slot) (primitives.Slot, e
 		minStartEpoch = currEpoch - minReqEpochs
 	}
 
-	return slots.EpochStart(minStartEpoch)
+	epochStart, err := slots.EpochStart(minStartEpoch)
+	if err != nil {
+		return 0, errors.Wrapf(err, "epoch start for epoch %d", minStartEpoch)
+	}
+
+	return epochStart, nil
 }

beacon-chain/sync/rpc_data_column_sidecars_by_root_test.go

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

beacon-chain/sync/rpc_metadata.go

@@ -17,7 +17,7 @@ import (
 	"github.com/prysmaticlabs/go-bitfield"
 )
 
-// metaDataHandler reads the incoming metadata rpc request from the peer.
+// metaDataHandler reads the incoming metadata RPC request from the peer.
 func (s *Service) metaDataHandler(_ context.Context, _ interface{}, stream libp2pcore.Stream) error {
 	SetRPCStreamDeadlines(stream)
 
@@ -70,7 +70,9 @@ func (s *Service) metaDataHandler(_ context.Context, _ interface{}, stream libp2
 	switch streamVersion {
 	case p2p.SchemaVersionV1:
 		switch metadataVersion {
-		case version.Altair, version.Deneb:
+		case version.Altair, version.Fulu:
+			// If the stream version corresponds to Phase 0 but our metadata
+			// corresponds to Altair or Fulu, convert our metadata to the Phase 0 one.
 			metadata = wrapper.WrappedMetadataV0(
 				&pb.MetaDataV0{
 					Attnets:   metadata.AttnetsBitfield(),
@@ -81,13 +83,18 @@ func (s *Service) metaDataHandler(_ context.Context, _ interface{}, stream libp2
 	case p2p.SchemaVersionV2:
 		switch metadataVersion {
 		case version.Phase0:
+			// If the stream version corresponds to Altair but our metadata
+			// corresponds to Phase 0, convert our metadata to the Altair one,
+			// and use a zeroed syncnets bitfield.
 			metadata = wrapper.WrappedMetadataV1(
 				&pb.MetaDataV1{
 					Attnets:   metadata.AttnetsBitfield(),
 					SeqNumber: metadata.SequenceNumber(),
 					Syncnets:  bitfield.Bitvector4{byte(0x00)},
 				})
-		case version.Deneb:
+		case version.Fulu:
+			// If the stream version corresponds to Altair but our metadata
+			// corresponds to Fulu, convert our metadata to the Altair one.
 			metadata = wrapper.WrappedMetadataV1(
 				&pb.MetaDataV1{
 					Attnets:   metadata.AttnetsBitfield(),
@@ -95,6 +102,32 @@ func (s *Service) metaDataHandler(_ context.Context, _ interface{}, stream libp2
 					Syncnets:  metadata.SyncnetsBitfield(),
 				})
 		}
+
+	case p2p.SchemaVersionV3:
+		switch metadataVersion {
+		case version.Phase0:
+			// If the stream version corresponds to Fulu but our metadata
+			// corresponds to Phase 0, convert our metadata to the Fulu one,
+			// and use a zeroed syncnets bitfield and custody group count.
+			metadata = wrapper.WrappedMetadataV2(
+				&pb.MetaDataV2{
+					Attnets:           metadata.AttnetsBitfield(),
+					SeqNumber:         metadata.SequenceNumber(),
+					Syncnets:          bitfield.Bitvector4{byte(0x00)},
+					CustodyGroupCount: 0,
+				})
+		case version.Altair:
+			// If the stream version corresponds to Fulu but our metadata
+			// corresponds to Altair, convert our metadata to the Fulu one and
+			// use a zeroed custody group count.
+			metadata = wrapper.WrappedMetadataV2(
+				&pb.MetaDataV2{
+					Attnets:           metadata.AttnetsBitfield(),
+					SeqNumber:         metadata.SequenceNumber(),
+					Syncnets:          metadata.SyncnetsBitfield(),
+					CustodyGroupCount: 0,
+				})
+		}
 	}
 
 	// Write the METADATA response into the stream.
@@ -164,12 +197,14 @@ func (s *Service) sendMetaDataRequest(ctx context.Context, peerID peer.ID) (meta
 	}
 
 	// Defensive check to ensure valid objects are being sent.
-	topicVersion := ""
+	var topicVersion string
 	switch msg.Version() {
 	case version.Phase0:
 		topicVersion = p2p.SchemaVersionV1
 	case version.Altair:
 		topicVersion = p2p.SchemaVersionV2
+	case version.Fulu:
+		topicVersion = p2p.SchemaVersionV3
 	}
 
 	// Validate the version of the topic.

beacon-chain/sync/rpc_metadata_test.go

@@ -1,6 +1,7 @@
 package sync
 
 import (
+	"context"
 	"sync"
 	"testing"
 	"time"
@@ -15,6 +16,7 @@ import (
 	leakybucket "github.com/OffchainLabs/prysm/v6/container/leaky-bucket"
 	"github.com/OffchainLabs/prysm/v6/encoding/ssz/equality"
 	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/metadata"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
@@ -22,6 +24,7 @@ import (
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/protocol"
 	libp2pquic "github.com/libp2p/go-libp2p/p2p/transport/quic"
+	"github.com/prysmaticlabs/go-bitfield"
 )
 
 func TestMetaDataRPCHandler_ReceivesMetadata(t *testing.T) {
@@ -76,158 +79,241 @@ func TestMetaDataRPCHandler_ReceivesMetadata(t *testing.T) {
 	}
 }
 
-func TestMetadataRPCHandler_SendsMetadata(t *testing.T) {
-	p1 := p2ptest.NewTestP2P(t)
-	p2 := p2ptest.NewTestP2P(t)
-	p1.Connect(p2)
-	assert.Equal(t, 1, len(p1.BHost.Network().Peers()), "Expected peers to be connected")
-	bitfield := [8]byte{'A', 'B'}
-	p2.LocalMetadata = wrapper.WrappedMetadataV0(&pb.MetaDataV0{
-		SeqNumber: 2,
-		Attnets:   bitfield[:],
-	})
-
-	// Set up a head state in the database with data we expect.
-	chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
-	d := db.SetupDB(t)
-	r := &Service{
+func createService(peer p2p.P2P, chain *mock.ChainService) *Service {
+	return &Service{
 		cfg: &config{
-			beaconDB: d,
-			p2p:      p1,
-			chain:    chain,
-			clock:    startup.NewClock(chain.Genesis, chain.ValidatorsRoot),
+			p2p:   peer,
+			chain: chain,
+			clock: startup.NewClock(chain.Genesis, chain.ValidatorsRoot),
 		},
-		rateLimiter: newRateLimiter(p1),
-	}
-
-	r2 := &Service{
-		cfg: &config{
-			beaconDB: d,
-			p2p:      p2,
-			chain:    &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}},
-		},
-		rateLimiter: newRateLimiter(p2),
-	}
-
-	// Setup streams
-	pcl := protocol.ID(p2p.RPCMetaDataTopicV1 + r.cfg.p2p.Encoding().ProtocolSuffix())
-	topic := string(pcl)
-	r.rateLimiter.limiterMap[topic] = leakybucket.NewCollector(1, 1, time.Second, false)
-	r2.rateLimiter.limiterMap[topic] = leakybucket.NewCollector(1, 1, time.Second, false)
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-	p2.BHost.SetStreamHandler(pcl, func(stream network.Stream) {
-		defer wg.Done()
-		assert.NoError(t, r2.metaDataHandler(t.Context(), new(interface{}), stream))
-	})
-
-	md, err := r.sendMetaDataRequest(t.Context(), p2.BHost.ID())
-	assert.NoError(t, err)
-
-	if !equality.DeepEqual(md.InnerObject(), p2.LocalMetadata.InnerObject()) {
-		t.Fatalf("MetadataV0 unequal, received %v but wanted %v", md, p2.LocalMetadata)
-	}
-
-	if util.WaitTimeout(&wg, 1*time.Second) {
-		t.Fatal("Did not receive stream within 1 sec")
-	}
-
-	conns := p1.BHost.Network().ConnsToPeer(p2.BHost.ID())
-	if len(conns) == 0 {
-		t.Error("Peer is disconnected despite receiving a valid ping")
+		rateLimiter: newRateLimiter(peer),
 	}
 }
 
-func TestMetadataRPCHandler_SendsMetadataAltair(t *testing.T) {
+func TestMetadataRPCHandler_SendMetadataRequest(t *testing.T) {
+	const (
+		requestTimeout    = 1 * time.Second
+		seqNumber         = 2
+		custodyGroupCount = 4
+	)
+
+	attnets := []byte{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'}
+	syncnets := []byte{0x4}
+
+	// Configure the test beacon chain.
 	params.SetupTestConfigCleanup(t)
-	bCfg := params.BeaconConfig().Copy()
-	bCfg.AltairForkEpoch = 5
-	params.OverrideBeaconConfig(bCfg)
+	beaconChainConfig := params.BeaconConfig().Copy()
+	beaconChainConfig.AltairForkEpoch = 5
+	beaconChainConfig.FuluForkEpoch = 15
+	params.OverrideBeaconConfig(beaconChainConfig)
 	params.BeaconConfig().InitializeForkSchedule()
 
-	p1 := p2ptest.NewTestP2P(t)
-	p2 := p2ptest.NewTestP2P(t)
-	p1.Connect(p2)
-	assert.Equal(t, 1, len(p1.BHost.Network().Peers()), "Expected peers to be connected")
-	bitfield := [8]byte{'A', 'B'}
-	p2.LocalMetadata = wrapper.WrappedMetadataV0(&pb.MetaDataV0{
-		SeqNumber: 2,
-		Attnets:   bitfield[:],
-	})
+	// Compute the number of seconds in an epoch.
+	secondsPerEpoch := oneEpoch()
 
-	// Set up a head state in the database with data we expect.
-	d := db.SetupDB(t)
-	chain := &mock.ChainService{Genesis: time.Now().Add(-5 * oneEpoch()), ValidatorsRoot: [32]byte{}}
-	r := &Service{
-		cfg: &config{
-			beaconDB: d,
-			p2p:      p1,
-			chain:    chain,
-			clock:    startup.NewClock(chain.Genesis, chain.ValidatorsRoot),
+	testCases := []struct {
+		name                                             string
+		topic                                            string
+		epochsSinceGenesisPeer1, epochsSinceGenesisPeer2 int
+		metadataPeer2, expected                          metadata.Metadata
+	}{
+		{
+			name:                    "Phase0-Phase0",
+			topic:                   p2p.RPCMetaDataTopicV1,
+			epochsSinceGenesisPeer1: 0,
+			epochsSinceGenesisPeer2: 0,
+			metadataPeer2: wrapper.WrappedMetadataV0(&pb.MetaDataV0{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+			}),
+			expected: wrapper.WrappedMetadataV0(&pb.MetaDataV0{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+			}),
 		},
-		rateLimiter: newRateLimiter(p1),
-	}
-
-	chain2 := &mock.ChainService{Genesis: time.Now().Add(-5 * oneEpoch()), ValidatorsRoot: [32]byte{}}
-	r2 := &Service{
-		cfg: &config{
-			beaconDB: d,
-			p2p:      p2,
-			chain:    chain2,
-			clock:    startup.NewClock(chain2.Genesis, chain2.ValidatorsRoot),
+		{
+			name:                    "Phase0-Altair",
+			topic:                   p2p.RPCMetaDataTopicV1,
+			epochsSinceGenesisPeer1: 0,
+			epochsSinceGenesisPeer2: 5,
+			metadataPeer2: wrapper.WrappedMetadataV1(&pb.MetaDataV1{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+				Syncnets:  syncnets,
+			}),
+			expected: wrapper.WrappedMetadataV0(&pb.MetaDataV0{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+			}),
+		},
+		{
+			name:                    "Phase0-Fulu",
+			topic:                   p2p.RPCMetaDataTopicV1,
+			epochsSinceGenesisPeer1: 0,
+			epochsSinceGenesisPeer2: 15,
+			metadataPeer2: wrapper.WrappedMetadataV2(&pb.MetaDataV2{
+				SeqNumber:         seqNumber,
+				Attnets:           attnets,
+				Syncnets:          syncnets,
+				CustodyGroupCount: custodyGroupCount,
+			}),
+			expected: wrapper.WrappedMetadataV0(&pb.MetaDataV0{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+			}),
+		},
+		{
+			name:                    "Altair-Phase0",
+			topic:                   p2p.RPCMetaDataTopicV2,
+			epochsSinceGenesisPeer1: 5,
+			epochsSinceGenesisPeer2: 0,
+			metadataPeer2: wrapper.WrappedMetadataV0(&pb.MetaDataV0{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+			}),
+			expected: wrapper.WrappedMetadataV1(&pb.MetaDataV1{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+				Syncnets:  bitfield.Bitvector4{byte(0x00)},
+			}),
+		},
+		{
+			name:                    "Altair-Altair",
+			topic:                   p2p.RPCMetaDataTopicV2,
+			epochsSinceGenesisPeer1: 5,
+			epochsSinceGenesisPeer2: 5,
+			metadataPeer2: wrapper.WrappedMetadataV1(&pb.MetaDataV1{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+				Syncnets:  syncnets,
+			}),
+			expected: wrapper.WrappedMetadataV1(&pb.MetaDataV1{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+				Syncnets:  syncnets,
+			}),
+		},
+		{
+			name:                    "Altair-Fulu",
+			topic:                   p2p.RPCMetaDataTopicV2,
+			epochsSinceGenesisPeer1: 5,
+			epochsSinceGenesisPeer2: 15,
+			metadataPeer2: wrapper.WrappedMetadataV2(&pb.MetaDataV2{
+				SeqNumber:         seqNumber,
+				Attnets:           attnets,
+				Syncnets:          syncnets,
+				CustodyGroupCount: custodyGroupCount,
+			}),
+			expected: wrapper.WrappedMetadataV1(&pb.MetaDataV1{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+				Syncnets:  syncnets,
+			}),
+		},
+		{
+			name:                    "Fulu-Phase0",
+			topic:                   p2p.RPCMetaDataTopicV3,
+			epochsSinceGenesisPeer1: 15,
+			epochsSinceGenesisPeer2: 0,
+			metadataPeer2: wrapper.WrappedMetadataV0(&pb.MetaDataV0{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+			}),
+			expected: wrapper.WrappedMetadataV2(&pb.MetaDataV2{
+				SeqNumber:         seqNumber,
+				Attnets:           attnets,
+				Syncnets:          bitfield.Bitvector4{byte(0x00)},
+				CustodyGroupCount: 0,
+			}),
+		},
+		{
+			name:                    "Fulu-Altair",
+			topic:                   p2p.RPCMetaDataTopicV3,
+			epochsSinceGenesisPeer1: 15,
+			epochsSinceGenesisPeer2: 5,
+			metadataPeer2: wrapper.WrappedMetadataV1(&pb.MetaDataV1{
+				SeqNumber: seqNumber,
+				Attnets:   attnets,
+				Syncnets:  syncnets,
+			}),
+			expected: wrapper.WrappedMetadataV2(&pb.MetaDataV2{
+				SeqNumber:         seqNumber,
+				Attnets:           attnets,
+				Syncnets:          syncnets,
+				CustodyGroupCount: 0,
+			}),
+		},
+		{
+			name:                    "Fulu-Fulu",
+			topic:                   p2p.RPCMetaDataTopicV3,
+			epochsSinceGenesisPeer1: 15,
+			epochsSinceGenesisPeer2: 15,
+			metadataPeer2: wrapper.WrappedMetadataV2(&pb.MetaDataV2{
+				SeqNumber:         seqNumber,
+				Attnets:           attnets,
+				Syncnets:          syncnets,
+				CustodyGroupCount: custodyGroupCount,
+			}),
+			expected: wrapper.WrappedMetadataV2(&pb.MetaDataV2{
+				SeqNumber:         seqNumber,
+				Attnets:           attnets,
+				Syncnets:          syncnets,
+				CustodyGroupCount: custodyGroupCount,
+			}),
 		},
-		rateLimiter: newRateLimiter(p2),
 	}
 
-	// Setup streams
-	pcl := protocol.ID(p2p.RPCMetaDataTopicV2 + r.cfg.p2p.Encoding().ProtocolSuffix())
-	topic := string(pcl)
-	r.rateLimiter.limiterMap[topic] = leakybucket.NewCollector(2, 2, time.Second, false)
-	r2.rateLimiter.limiterMap[topic] = leakybucket.NewCollector(2, 2, time.Second, false)
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			var wg sync.WaitGroup
 
-	var wg sync.WaitGroup
-	wg.Add(1)
-	p2.BHost.SetStreamHandler(pcl, func(stream network.Stream) {
-		defer wg.Done()
-		err := r2.metaDataHandler(t.Context(), new(interface{}), stream)
-		assert.NoError(t, err)
-	})
+			ctx := context.Background()
 
-	_, err := r.sendMetaDataRequest(t.Context(), p2.BHost.ID())
-	assert.NoError(t, err)
+			// Setup and connect peers.
+			peer1, peer2 := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
+			peer1.Connect(peer2)
 
-	if util.WaitTimeout(&wg, 1*time.Second) {
-		t.Fatal("Did not receive stream within 1 sec")
-	}
+			// Ensure the peers are connected.
+			peersCount := len(peer1.BHost.Network().Peers())
+			require.Equal(t, 1, peersCount, "Expected peers to be connected")
 
-	// Fix up peer with the correct metadata.
-	p2.LocalMetadata = wrapper.WrappedMetadataV1(&pb.MetaDataV1{
-		SeqNumber: 2,
-		Attnets:   bitfield[:],
-		Syncnets:  []byte{0x0},
-	})
+			// Setup sync services.
+			genesisPeer1 := time.Now().Add(-time.Duration(tc.epochsSinceGenesisPeer1) * secondsPerEpoch)
+			genesisPeer2 := time.Now().Add(-time.Duration(tc.epochsSinceGenesisPeer2) * secondsPerEpoch)
 
-	wg.Add(1)
-	p2.BHost.SetStreamHandler(pcl, func(stream network.Stream) {
-		defer wg.Done()
-		assert.NoError(t, r2.metaDataHandler(t.Context(), new(interface{}), stream))
-	})
+			chainPeer1 := &mock.ChainService{Genesis: genesisPeer1, ValidatorsRoot: [32]byte{}}
+			chainPeer2 := &mock.ChainService{Genesis: genesisPeer2, ValidatorsRoot: [32]byte{}}
 
-	md, err := r.sendMetaDataRequest(t.Context(), p2.BHost.ID())
-	assert.NoError(t, err)
+			servicePeer1 := createService(peer1, chainPeer1)
+			servicePeer2 := createService(peer2, chainPeer2)
 
-	if !equality.DeepEqual(md.InnerObject(), p2.LocalMetadata.InnerObject()) {
-		t.Fatalf("MetadataV1 unequal, received %v but wanted %v", md, p2.LocalMetadata)
-	}
+			// Define the behavior of peer2 when receiving a METADATA request.
+			protocolSuffix := servicePeer2.cfg.p2p.Encoding().ProtocolSuffix()
+			protocolID := protocol.ID(tc.topic + protocolSuffix)
+			peer2.LocalMetadata = tc.metadataPeer2
 
-	if util.WaitTimeout(&wg, 1*time.Second) {
-		t.Fatal("Did not receive stream within 1 sec")
-	}
+			wg.Add(1)
+			peer2.BHost.SetStreamHandler(protocolID, func(stream network.Stream) {
+				defer wg.Done()
+				err := servicePeer2.metaDataHandler(ctx, new(interface{}), stream)
+				require.NoError(t, err)
+			})
 
-	conns := p1.BHost.Network().ConnsToPeer(p2.BHost.ID())
-	if len(conns) == 0 {
-		t.Error("Peer is disconnected despite receiving a valid ping")
+			// Send a METADATA request from peer1 to peer2.
+			actual, err := servicePeer1.sendMetaDataRequest(ctx, peer2.BHost.ID())
+			require.NoError(t, err)
+
+			// Wait until the METADATA request is received by peer2 or timeout.
+			timeOutReached := util.WaitTimeout(&wg, requestTimeout)
+			require.Equal(t, false, timeOutReached, "Did not receive METADATA request within timeout")
+
+			// Compare the received METADATA object with the expected METADATA object.
+			require.DeepSSZEqual(t, tc.expected.InnerObject(), actual.InnerObject(), "Metadata unequal")
+
+			// Ensure the peers are still connected.
+			peersCount = len(peer1.BHost.Network().Peers())
+			assert.Equal(t, 1, peersCount, "Expected peers to be connected")
+		})
 	}
 }
 

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
 }

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")
+		}
+	})
+}

beacon-chain/sync/sync_test.go

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

beacon-chain/verification/error.go

@@ -30,16 +30,16 @@ var (
 	ErrBlobIndexInvalid = errors.Join(ErrBlobInvalid, errors.New("incorrect blob sidecar index"))
 
 	// errFromFutureSlot means RequireSlotNotTooEarly failed.
-	errFromFutureSlot = errors.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"))

changelog/james-prysm_ssz-validator-block.md

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

changelog/manu-peerdas-beacon-api.md

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

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

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

changelog/manu-peerdas-dataColumnSidecarByRootRPCHandler.md

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

changelog/manu-peerdas-metadata.md

@@ -0,0 +1,2 @@
+### Added 
+- PeerDAS: Implement the new Fulu Metadata.

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

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

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.

changelog/pvl-join-errors.md

@@ -0,0 +1,3 @@
+### Changed
+
+-  Update beacon-chain/execution/engine_client.go to return the underlying error message from the EL

changelog/tt_milk.md

@@ -0,0 +1,3 @@
+### Removed
+
+- Remove deposit count from sync new block log

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

cmd/beacon-chain/flags/base.go

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

cmd/beacon-chain/flags/config.go

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

config/features/config.go

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

config/features/flags.go

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

proto/prysm/v1alpha1/BUILD.bazel

@@ -2,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",
     ],
 )
 

proto/prysm/v1alpha1/beacon_block.go

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

proto/prysm/v1alpha1/data_columns.pb.go

@@ -109,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,
 		},

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" ];

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
+}

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,
 		},

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) =

testing/endtoend/components/validator.go

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

testing/endtoend/minimal_scenario_e2e_test.go

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

testing/endtoend/types/types.go

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

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 {

validator/accounts/cli_manager.go

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

validator/client/beacon-api/BUILD.bazel

@@ -18,7 +18,6 @@ go_library(
         "genesis.go",
         "get_beacon_block.go",
         "index.go",
-        "json_rest_handler.go",
         "log.go",
         "metrics.go",
         "prepare_beacon_proposer.go",
@@ -27,6 +26,7 @@ go_library(
         "propose_exit.go",
         "prysm_beacon_chain_client.go",
         "registration.go",
+        "rest_handler_client.go",
         "state_validators.go",
         "status.go",
         "stream_blocks.go",
@@ -47,6 +47,7 @@ go_library(
         "//api/server/structs:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
+        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
@@ -91,7 +92,6 @@ go_test(
         "genesis_test.go",
         "get_beacon_block_test.go",
         "index_test.go",
-        "json_rest_handler_test.go",
         "prepare_beacon_proposer_test.go",
         "propose_attestation_test.go",
         "propose_beacon_block_altair_test.go",
@@ -110,6 +110,7 @@ go_test(
         "propose_exit_test.go",
         "prysm_beacon_chain_client_test.go",
         "registration_test.go",
+        "rest_handler_client_test.go",
         "state_validators_test.go",
         "status_test.go",
         "stream_blocks_test.go",
@@ -128,6 +129,7 @@ go_test(
         "//api/server/structs:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/rpc/eth/shared/testing:go_default_library",
+        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
@@ -145,6 +147,8 @@ go_test(
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_golang_protobuf//ptypes/empty",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",
         "@org_uber_go_mock//gomock:go_default_library",

validator/client/beacon-api/beacon_api_beacon_chain_client.go

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

validator/client/beacon-api/beacon_api_node_client.go

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

validator/client/beacon-api/beacon_api_validator_client.go

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

validator/client/beacon-api/duties.go

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

validator/client/beacon-api/genesis.go

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

validator/client/beacon-api/get_beacon_block.go

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

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

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

validator/client/beacon-api/prysm_beacon_chain_client.go

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

validator/client/beacon-api/rest_handler_client.go

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

validator/client/beacon-api/rest_handler_client_test.go

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

validator/client/beacon-api/state_validators.go

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

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

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

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

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

validator/client/service.go

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

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

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

validator/rpc/beacon.go

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