only compute common info once, for all sidecars

* Fix misleading log msg on shutdown

gRPCServer.GracefulStop blocks until it has been shutdown. Logging
"Initiated graceful stop" after it has been completed is misleading.
Names are added to the message to discern services. Also, a minimum test
is added mainly to verify the change made with this commit.

* Add changelog fragment file

* Capitalize log messages

* Update endtoend test for fixed log messages

---------

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

api/client/builder/client.go

@@ -30,10 +30,11 @@ import (
 )
 
 const (
-	getExecHeaderPath          = "/eth/v1/builder/header/{{.Slot}}/{{.ParentHash}}/{{.Pubkey}}"
-	getStatus                  = "/eth/v1/builder/status"
-	postBlindedBeaconBlockPath = "/eth/v1/builder/blinded_blocks"
-	postRegisterValidatorPath  = "/eth/v1/builder/validators"
+	getExecHeaderPath            = "/eth/v1/builder/header/{{.Slot}}/{{.ParentHash}}/{{.Pubkey}}"
+	getStatus                    = "/eth/v1/builder/status"
+	postBlindedBeaconBlockPath   = "/eth/v1/builder/blinded_blocks"
+	postBlindedBeaconBlockV2Path = "/eth/v2/builder/blinded_blocks"
+	postRegisterValidatorPath    = "/eth/v1/builder/validators"
 )
 
 var (
@@ -512,7 +513,7 @@ func (c *Client) SubmitBlindedBlockPostFulu(ctx context.Context, sb interfaces.R
 	}
 
 	// Post the blinded block - the response should only contain a status code (no payload)
-	_, _, err = c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), http.StatusAccepted, postOpts)
+	_, _, err = c.do(ctx, http.MethodPost, postBlindedBeaconBlockV2Path, bytes.NewBuffer(body), http.StatusAccepted, postOpts)
 	if err != nil {
 		return errors.Wrap(err, "error posting the blinded block to the builder api post-Fulu")
 	}

api/client/builder/client_test.go

@@ -1561,7 +1561,7 @@ func TestSubmitBlindedBlockPostFulu(t *testing.T) {
 	t.Run("success", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
+				require.Equal(t, postBlindedBeaconBlockV2Path, r.URL.Path)
 				require.Equal(t, "bellatrix", r.Header.Get("Eth-Consensus-Version"))
 				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
 				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
@@ -1586,7 +1586,7 @@ func TestSubmitBlindedBlockPostFulu(t *testing.T) {
 	t.Run("success_ssz", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
+				require.Equal(t, postBlindedBeaconBlockV2Path, r.URL.Path)
 				require.Equal(t, "bellatrix", r.Header.Get(api.VersionHeader))
 				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Content-Type"))
 				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
@@ -1612,7 +1612,7 @@ func TestSubmitBlindedBlockPostFulu(t *testing.T) {
 	t.Run("error_response", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
+				require.Equal(t, postBlindedBeaconBlockV2Path, r.URL.Path)
 				require.Equal(t, "bellatrix", r.Header.Get("Eth-Consensus-Version"))
 				message := ErrorMessage{
 					Code:    400,

api/server/structs/endpoints_beacon.go

@@ -290,3 +290,9 @@ type GetProposerLookaheadResponse struct {
 	Finalized           bool     `json:"finalized"`
 	Data                []string `json:"data"` // validator indexes
 }
+
+type GetBlobsResponse struct {
+	ExecutionOptimistic bool     `json:"execution_optimistic"`
+	Finalized           bool     `json:"finalized"`
+	Data                []string `json:"data"` //blobs
+}

beacon-chain/blockchain/BUILD.bazel

@@ -50,7 +50,6 @@ go_library(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
@@ -63,6 +62,7 @@ go_library(
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
+        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
@@ -148,7 +148,6 @@ go_test(
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -161,6 +160,7 @@ go_test(
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
+        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/attestations/kv:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",

beacon-chain/blockchain/kzg/kzg.go

@@ -14,7 +14,10 @@ const BytesPerBlob = ckzg4844.BytesPerBlob
 type Blob [BytesPerBlob]byte
 
 // BytesPerCell is the number of bytes in a single cell.
-const BytesPerCell = ckzg4844.BytesPerCell
+const (
+	BytesPerCell  = ckzg4844.BytesPerCell
+	BytesPerProof = ckzg4844.BytesPerProof
+)
 
 // Cell represents a chunk of an encoded Blob.
 type Cell [BytesPerCell]byte
@@ -23,7 +26,7 @@ type Cell [BytesPerCell]byte
 type Commitment [48]byte
 
 // Proof represents a KZG proof that attests to the validity of a Blob or parts of it.
-type Proof [48]byte
+type Proof [BytesPerProof]byte
 
 // Bytes48 is a 48-byte array.
 type Bytes48 = ckzg4844.Bytes48

beacon-chain/blockchain/options.go

@@ -6,11 +6,11 @@ import (
 	"github.com/OffchainLabs/prysm/v6/async/event"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings"
@@ -35,7 +35,7 @@ func WithMaxGoroutines(x int) Option {
 // WithLCStore for light client store access.
 func WithLCStore() Option {
 	return func(s *Service) error {
-		s.lcStore = lightclient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
+		s.lcStore = lightclient.NewLightClientStore(s.cfg.P2P, s.cfg.StateNotifier.StateFeed(), s.cfg.BeaconDB)
 		return nil
 	}
 }

beacon-chain/blockchain/process_block.go

@@ -247,7 +247,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b,
 			JustifiedCheckpoint: jCheckpoints[i],
 			FinalizedCheckpoint: fCheckpoints[i]}
-		pendingNodes[len(blks)-i-1] = args
+		pendingNodes[i] = args
 		if err := s.saveInitSyncBlock(ctx, root, b); err != nil {
 			tracing.AnnotateError(span, err)
 			return err
@@ -284,14 +284,10 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	if err := s.cfg.StateGen.SaveState(ctx, lastBR, preState); err != nil {
 		return err
 	}
-	// Insert all nodes but the last one to forkchoice
+	// Insert all nodes to forkchoice
 	if err := s.cfg.ForkChoiceStore.InsertChain(ctx, pendingNodes); err != nil {
 		return errors.Wrap(err, "could not insert batch to forkchoice")
 	}
-	// Insert the last block to forkchoice
-	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, preState, lastB); err != nil {
-		return errors.Wrap(err, "could not insert last block in batch to forkchoice")
-	}
 	// Set their optimistic status
 	if isValidPayload {
 		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, lastBR); err != nil {
@@ -664,14 +660,14 @@ func missingDataColumnIndices(store *filesystem.DataColumnStorage, root [fieldpa
 // closed, the context hits cancellation/timeout, or notifications have been received for all the missing sidecars.
 func (s *Service) isDataAvailable(
 	ctx context.Context,
-	root [fieldparams.RootLength]byte,
-	signedBlock interfaces.ReadOnlySignedBeaconBlock,
+	roBlock consensusblocks.ROBlock,
 ) error {
-	block := signedBlock.Block()
+	block := roBlock.Block()
 	if block == nil {
 		return errors.New("invalid nil beacon block")
 	}
 
+	root := roBlock.Root()
 	blockVersion := block.Version()
 	if blockVersion >= version.Fulu {
 		return s.areDataColumnsAvailable(ctx, root, block)
@@ -691,8 +687,6 @@ func (s *Service) areDataColumnsAvailable(
 	root [fieldparams.RootLength]byte,
 	block interfaces.ReadOnlyBeaconBlock,
 ) error {
-	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
-
 	// We are only required to check within MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS
 	blockSlot, currentSlot := block.Slot(), s.CurrentSlot()
 	blockEpoch, currentEpoch := slots.ToEpoch(blockSlot), slots.ToEpoch(currentSlot)
@@ -726,6 +720,7 @@ func (s *Service) areDataColumnsAvailable(
 
 	// Compute the sampling size.
 	// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#custody-sampling
+	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
 	samplingSize := max(samplesPerSlot, custodyGroupCount)
 
 	// Get the peer info for the node.

beacon-chain/blockchain/process_block_helpers.go

@@ -3,14 +3,12 @@ package blockchain
 import (
 	"context"
 	"fmt"
-	"strings"
+	"slices"
 	"time"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
-
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
@@ -133,35 +131,26 @@ func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
 	})
 }
 
+// processLightClientUpdates saves the light client data in lcStore, when feature flag is enabled.
 func (s *Service) processLightClientUpdates(cfg *postBlockProcessConfig) {
-	if err := s.processLightClientUpdate(cfg); err != nil {
-		log.WithError(err).Error("Failed to process light client update")
-	}
-	if err := s.processLightClientOptimisticUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
-		log.WithError(err).Error("Failed to process light client optimistic update")
-	}
-	if err := s.processLightClientFinalityUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
-		log.WithError(err).Error("Failed to process light client finality update")
-	}
-}
-
-// processLightClientUpdate saves the light client update for this block
-// if it's better than the already saved one, when feature flag is enabled.
-func (s *Service) processLightClientUpdate(cfg *postBlockProcessConfig) error {
 	attestedRoot := cfg.roblock.Block().ParentRoot()
 	attestedBlock, err := s.getBlock(cfg.ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
+		log.WithError(err).Error("processLightClientUpdates: Could not get attested block")
+		return
 	}
 	if attestedBlock == nil || attestedBlock.IsNil() {
-		return errors.New("attested block is nil")
+		log.Error("processLightClientUpdates: Could not get attested block")
+		return
 	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(cfg.ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
+		log.WithError(err).Error("processLightClientUpdates: Could not get attested state")
+		return
 	}
 	if attestedState == nil || attestedState.IsNil() {
-		return errors.New("attested state is nil")
+		log.Error("processLightClientUpdates: Could not get attested state")
+		return
 	}
 
 	finalizedRoot := attestedState.FinalizedCheckpoint().Root
@@ -169,98 +158,17 @@ func (s *Service) processLightClientUpdate(cfg *postBlockProcessConfig) error {
 	if err != nil {
 		if errors.Is(err, errBlockNotFoundInCacheOrDB) {
 			log.Debugf("Skipping saving light client update because finalized block is nil for root %#x", finalizedRoot)
-			return nil
+			return
 		}
-		return errors.Wrapf(err, "could not get finalized block for root %#x", finalizedRoot)
+		log.WithError(err).Error("processLightClientUpdates: Could not get finalized block")
+		return
 	}
 
-	update, err := lightclient.NewLightClientUpdateFromBeaconState(cfg.ctx, cfg.postState, cfg.roblock, attestedState, attestedBlock, finalizedBlock)
+	err = s.lcStore.SaveLCData(cfg.ctx, cfg.postState, cfg.roblock, attestedState, attestedBlock, finalizedBlock, s.headRoot())
 	if err != nil {
-		return errors.Wrapf(err, "could not create light client update")
+		log.WithError(err).Error("processLightClientUpdates: Could not save light client data")
 	}
-
-	period := slots.SyncCommitteePeriod(slots.ToEpoch(attestedState.Slot()))
-
-	return s.lcStore.SaveLightClientUpdate(cfg.ctx, period, update)
-}
-
-func (s *Service) processLightClientFinalityUpdate(
-	ctx context.Context,
-	signed interfaces.ReadOnlySignedBeaconBlock,
-	postState state.BeaconState,
-) error {
-	attestedRoot := signed.Block().ParentRoot()
-	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
-	if err != nil {
-		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
-	}
-	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
-	if err != nil {
-		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
-	}
-
-	finalizedCheckpoint := attestedState.FinalizedCheckpoint()
-
-	if finalizedCheckpoint == nil {
-		return nil
-	}
-
-	finalizedRoot := bytesutil.ToBytes32(finalizedCheckpoint.Root)
-	finalizedBlock, err := s.cfg.BeaconDB.Block(ctx, finalizedRoot)
-	if err != nil {
-		if errors.Is(err, errBlockNotFoundInCacheOrDB) {
-			log.Debugf("Skipping processing light client finality update: Finalized block is nil for root %#x", finalizedRoot)
-			return nil
-		}
-		return errors.Wrapf(err, "could not get finalized block for root %#x", finalizedRoot)
-	}
-
-	newUpdate, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, postState, signed, attestedState, attestedBlock, finalizedBlock)
-
-	if err != nil {
-		return errors.Wrap(err, "could not create light client finality update")
-	}
-
-	if !lightclient.IsBetterFinalityUpdate(newUpdate, s.lcStore.LastFinalityUpdate()) {
-		log.Debug("Skip saving light client finality update: current update is better")
-		return nil
-	}
-
-	s.lcStore.SetLastFinalityUpdate(newUpdate, true)
-
-	return nil
-}
-
-func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
-	postState state.BeaconState) error {
-	attestedRoot := signed.Block().ParentRoot()
-	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
-	if err != nil {
-		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
-	}
-	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
-	if err != nil {
-		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
-	}
-
-	newUpdate, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, postState, signed, attestedState, attestedBlock)
-
-	if err != nil {
-		if strings.Contains(err.Error(), lightclient.ErrNotEnoughSyncCommitteeBits) {
-			log.WithError(err).Debug("Skipping processing light client optimistic update")
-			return nil
-		}
-		return errors.Wrap(err, "could not create light client optimistic update")
-	}
-
-	if !lightclient.IsBetterOptimisticUpdate(newUpdate, s.lcStore.LastOptimisticUpdate()) {
-		log.Debug("Skip saving light client optimistic update: current update is better")
-		return nil
-	}
-
-	s.lcStore.SetLastOptimisticUpdate(newUpdate, true)
-
-	return nil
+	log.Debug("Processed light client updates")
 }
 
 // updateCachesPostBlockProcessing updates the next slot cache and handles the epoch
@@ -469,15 +377,8 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed inte
 	if err != nil {
 		return err
 	}
-	// The first block can have a bogus root since the block is not inserted in forkchoice
-	roblock, err := consensus_blocks.NewROBlockWithRoot(signed, [32]byte{})
-	if err != nil {
-		return err
-	}
-	pendingNodes = append(pendingNodes, &forkchoicetypes.BlockAndCheckpoints{Block: roblock,
-		JustifiedCheckpoint: jCheckpoint, FinalizedCheckpoint: fCheckpoint})
+	root := signed.Block().ParentRoot()
 	// As long as parent node is not in fork choice store, and parent node is in DB.
-	root := roblock.Block().ParentRoot()
 	for !s.cfg.ForkChoiceStore.HasNode(root) && s.cfg.BeaconDB.HasBlock(ctx, root) {
 		b, err := s.getBlock(ctx, root)
 		if err != nil {
@@ -496,12 +397,13 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed inte
 			FinalizedCheckpoint: fCheckpoint}
 		pendingNodes = append(pendingNodes, args)
 	}
-	if len(pendingNodes) == 1 {
+	if len(pendingNodes) == 0 {
 		return nil
 	}
 	if root != s.ensureRootNotZeros(finalized.Root) && !s.cfg.ForkChoiceStore.HasNode(root) {
 		return ErrNotDescendantOfFinalized
 	}
+	slices.Reverse(pendingNodes)
 	return s.cfg.ForkChoiceStore.InsertChain(ctx, pendingNodes)
 }
 

beacon-chain/blockchain/process_block_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
@@ -24,6 +23,7 @@ import (
 	mockExecution "github.com/OffchainLabs/prysm/v6/beacon-chain/execution/testing"
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations/kv"
 	mockp2p "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
@@ -2795,6 +2795,11 @@ func TestProcessLightClientUpdate(t *testing.T) {
 	s, tr := minimalTestService(t, WithLCStore())
 	ctx := tr.ctx
 
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, s.cfg.BeaconDB.SaveState(ctx, headState, [32]byte{1, 2}))
+	require.NoError(t, s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, [32]byte{1, 2}))
+
 	for testVersion := version.Altair; testVersion <= version.Electra; testVersion++ {
 		t.Run(version.String(testVersion), func(t *testing.T) {
 			l := util.NewTestLightClient(t, testVersion)
@@ -2817,6 +2822,8 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			require.NoError(t, err)
 			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
 			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, currentBlockRoot)
+			require.NoError(t, err)
 
 			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
 			require.NoError(t, err)
@@ -2831,10 +2838,9 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			t.Run("no old update", func(t *testing.T) {
-				require.NoError(t, s.processLightClientUpdate(cfg))
-
+				s.processLightClientUpdates(cfg)
 				// Check that the light client update is saved
-				u, err := s.lcStore.LightClientUpdate(ctx, period)
+				u, err := s.lcStore.LightClientUpdate(ctx, period, l.Block)
 				require.NoError(t, err)
 				require.NotNil(t, u)
 				attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
@@ -2848,12 +2854,12 @@ func TestProcessLightClientUpdate(t *testing.T) {
 				oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
 				require.NoError(t, err)
 
-				err = s.lcStore.SaveLightClientUpdate(ctx, period, oldUpdate)
+				err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
 				require.NoError(t, err)
 
-				require.NoError(t, s.processLightClientUpdate(cfg))
+				s.processLightClientUpdates(cfg)
 
-				u, err := s.lcStore.LightClientUpdate(ctx, period)
+				u, err := s.lcStore.LightClientUpdate(ctx, period, l.Block)
 				require.NoError(t, err)
 				require.NotNil(t, u)
 				attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
@@ -2877,12 +2883,12 @@ func TestProcessLightClientUpdate(t *testing.T) {
 					SyncCommitteeSignature: make([]byte, 96),
 				})
 
-				err = s.lcStore.SaveLightClientUpdate(ctx, period, oldUpdate)
+				err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
 				require.NoError(t, err)
 
-				require.NoError(t, s.processLightClientUpdate(cfg))
+				s.processLightClientUpdates(cfg)
 
-				u, err := s.lcStore.LightClientUpdate(ctx, period)
+				u, err := s.lcStore.LightClientUpdate(ctx, period, l.Block)
 				require.NoError(t, err)
 				require.NotNil(t, u)
 				require.DeepEqual(t, oldUpdate, u)
@@ -2952,14 +2958,18 @@ func TestIsDataAvailable(t *testing.T) {
 		params := testIsAvailableParams{options: []Option{WithGenesisTime(time.Unix(0, 0))}}
 		ctx, _, service, root, signed := testIsAvailableSetup(t, params)
 
-		err := service.isDataAvailable(ctx, root, signed)
+		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
+		require.NoError(t, err)
+		err = service.isDataAvailable(ctx, roBlock)
 		require.NoError(t, err)
 	})
 
 	t.Run("Fulu - no commitment in blocks", func(t *testing.T) {
 		ctx, _, service, root, signed := testIsAvailableSetup(t, testIsAvailableParams{})
 
-		err := service.isDataAvailable(ctx, root, signed)
+		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
+		require.NoError(t, err)
+		err = service.isDataAvailable(ctx, roBlock)
 		require.NoError(t, err)
 	})
 
@@ -2977,7 +2987,9 @@ func TestIsDataAvailable(t *testing.T) {
 
 		ctx, _, service, root, signed := testIsAvailableSetup(t, params)
 
-		err := service.isDataAvailable(ctx, root, signed)
+		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
+		require.NoError(t, err)
+		err = service.isDataAvailable(ctx, roBlock)
 		require.NoError(t, err)
 	})
 
@@ -2989,7 +3001,9 @@ func TestIsDataAvailable(t *testing.T) {
 
 		ctx, _, service, root, signed := testIsAvailableSetup(t, params)
 
-		err := service.isDataAvailable(ctx, root, signed)
+		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
+		require.NoError(t, err)
+		err = service.isDataAvailable(ctx, roBlock)
 		require.NoError(t, err)
 	})
 
@@ -3037,7 +3051,9 @@ func TestIsDataAvailable(t *testing.T) {
 		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
 		defer cancel()
 
-		err = service.isDataAvailable(ctx, root, signed)
+		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
+		require.NoError(t, err)
+		err = service.isDataAvailable(ctx, roBlock)
 		require.NoError(t, err)
 	})
 
@@ -3099,7 +3115,9 @@ func TestIsDataAvailable(t *testing.T) {
 		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
 		defer cancel()
 
-		err = service.isDataAvailable(ctx, root, signed)
+		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
+		require.NoError(t, err)
+		err = service.isDataAvailable(ctx, roBlock)
 		require.NoError(t, err)
 	})
 
@@ -3118,7 +3136,9 @@ func TestIsDataAvailable(t *testing.T) {
 			cancel()
 		}()
 
-		err := service.isDataAvailable(ctx, root, signed)
+		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
+		require.NoError(t, err)
+		err = service.isDataAvailable(ctx, roBlock)
 		require.NotNil(t, err)
 	})
 }
@@ -3190,6 +3210,11 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 	s.cfg.P2P = &mockp2p.FakeP2P{}
 	ctx := tr.ctx
 
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, s.cfg.BeaconDB.SaveState(ctx, headState, [32]byte{1, 2}))
+	require.NoError(t, s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, [32]byte{1, 2}))
+
 	testCases := []struct {
 		name          string
 		oldOptions    []util.LightClientOption
@@ -3205,7 +3230,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 		{
 			name:          "Same age",
 			oldOptions:    []util.LightClientOption{},
-			newOptions:    []util.LightClientOption{util.WithSupermajority()}, // supermajority does not matter here and is only added to result in two different updates
+			newOptions:    []util.LightClientOption{util.WithSupermajority(0)}, // supermajority does not matter here and is only added to result in two different updates
 			expectReplace: false,
 		},
 		{
@@ -3249,14 +3274,14 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 
 			t.Run(version.String(testVersion)+"_"+tc.name, func(t *testing.T) {
 				s.genesisTime = time.Unix(time.Now().Unix()-(int64(forkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-				s.lcStore = lightClient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
+				s.lcStore = lightClient.NewLightClientStore(s.cfg.P2P, s.cfg.StateNotifier.StateFeed(), s.cfg.BeaconDB)
 
 				var oldActualUpdate interfaces.LightClientOptimisticUpdate
 				var err error
 				if tc.oldOptions != nil {
 					// config for old update
 					lOld, cfgOld := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.oldOptions...)
-					require.NoError(t, s.processLightClientOptimisticUpdate(cfgOld.ctx, cfgOld.roblock, cfgOld.postState))
+					s.processLightClientUpdates(cfgOld)
 
 					oldActualUpdate, err = lightClient.NewLightClientOptimisticUpdateFromBeaconState(lOld.Ctx, lOld.State, lOld.Block, lOld.AttestedState, lOld.AttestedBlock)
 					require.NoError(t, err)
@@ -3270,7 +3295,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 
 				// config for new update
 				lNew, cfgNew := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.newOptions...)
-				require.NoError(t, s.processLightClientOptimisticUpdate(cfgNew.ctx, cfgNew.roblock, cfgNew.postState))
+				s.processLightClientUpdates(cfgNew)
 
 				newActualUpdate, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(lNew.Ctx, lNew.State, lNew.Block, lNew.AttestedState, lNew.AttestedBlock)
 				require.NoError(t, err)
@@ -3311,6 +3336,7 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 	s, tr := minimalTestService(t)
 	s.cfg.P2P = &mockp2p.FakeP2P{}
 	ctx := tr.ctx
+	s.head = &head{}
 
 	testCases := []struct {
 		name          string
@@ -3389,15 +3415,18 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 
 			t.Run(version.String(testVersion)+"_"+tc.name, func(t *testing.T) {
 				s.genesisTime = time.Unix(time.Now().Unix()-(int64(forkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-				s.lcStore = lightClient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
+				s.lcStore = lightClient.NewLightClientStore(s.cfg.P2P, s.cfg.StateNotifier.StateFeed(), s.cfg.BeaconDB)
 
 				var actualOldUpdate, actualNewUpdate interfaces.LightClientFinalityUpdate
-				var err error
 
 				if tc.oldOptions != nil {
 					// config for old update
 					lOld, cfgOld := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.oldOptions...)
-					require.NoError(t, s.processLightClientFinalityUpdate(cfgOld.ctx, cfgOld.roblock, cfgOld.postState))
+					blkRoot, err := lOld.Block.Block().HashTreeRoot()
+					require.NoError(t, err)
+					s.head.block = lOld.Block
+					s.head.root = blkRoot
+					s.processLightClientUpdates(cfgOld)
 
 					// check that the old update is saved
 					actualOldUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(ctx, cfgOld.postState, cfgOld.roblock, lOld.AttestedState, lOld.AttestedBlock, lOld.FinalizedBlock)
@@ -3408,7 +3437,11 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 
 				// config for new update
 				lNew, cfgNew := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.newOptions...)
-				require.NoError(t, s.processLightClientFinalityUpdate(cfgNew.ctx, cfgNew.roblock, cfgNew.postState))
+				blkRoot, err := lNew.Block.Block().HashTreeRoot()
+				require.NoError(t, err)
+				s.head.block = lNew.Block
+				s.head.root = blkRoot
+				s.processLightClientUpdates(cfgNew)
 
 				// check that the actual old update and the actual new update are different
 				actualNewUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(ctx, cfgNew.postState, cfgNew.roblock, lNew.AttestedState, lNew.AttestedBlock, lNew.FinalizedBlock)

beacon-chain/blockchain/receive_block.go

@@ -16,7 +16,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/slasher/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/features"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -93,7 +92,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 
 	blockCopy, err := block.Copy()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "block copy")
 	}
 
 	preState, err := s.getBlockPreState(ctx, blockCopy.Block())
@@ -104,17 +103,17 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	currentCheckpoints := s.saveCurrentCheckpoints(preState)
 	roblock, err := blocks.NewROBlockWithRoot(blockCopy, blockRoot)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "new ro block with root")
 	}
 
 	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, roblock)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "validator execution and consensus")
 	}
 
-	daWaitedTime, err := s.handleDA(ctx, blockCopy, blockRoot, avs)
+	daWaitedTime, err := s.handleDA(ctx, avs, roblock)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "handle da")
 	}
 
 	// Defragment the state before continuing block processing.
@@ -135,10 +134,10 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err := s.postBlockProcess(args); err != nil {
 		err := errors.Wrap(err, "could not process block")
 		tracing.AnnotateError(span, err)
-		return err
+		return errors.Wrap(err, "post block process")
 	}
 	if err := s.updateCheckpoints(ctx, currentCheckpoints, preState, postState, blockRoot); err != nil {
-		return err
+		return errors.Wrap(err, "update checkpoints")
 	}
 	// If slasher is configured, forward the attestations in the block via an event feed for processing.
 	if s.slasherEnabled {
@@ -152,12 +151,12 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 
 	// Have we been finalizing? Should we start saving hot states to db?
 	if err := s.checkSaveHotStateDB(ctx); err != nil {
-		return err
+		return errors.Wrap(err, "check save hot state db")
 	}
 
 	// We apply the same heuristic to some of our more important caches.
 	if err := s.handleCaches(); err != nil {
-		return err
+		return errors.Wrap(err, "handle caches")
 	}
 	s.reportPostBlockProcessing(blockCopy, blockRoot, receivedTime, daWaitedTime)
 	return nil
@@ -240,37 +239,19 @@ func (s *Service) validateExecutionAndConsensus(
 	return postState, isValidPayload, nil
 }
 
-func (s *Service) handleDA(
-	ctx context.Context,
-	block interfaces.SignedBeaconBlock,
-	blockRoot [fieldparams.RootLength]byte,
-	avs das.AvailabilityStore,
-) (elapsed time.Duration, err error) {
-	defer func(start time.Time) {
-		elapsed = time.Since(start)
-
-		if err == nil {
-			dataAvailWaitedTime.Observe(float64(elapsed.Milliseconds()))
-		}
-	}(time.Now())
-
-	if avs == nil {
-		if err = s.isDataAvailable(ctx, blockRoot, block); err != nil {
-			return
-		}
-
-		return
+func (s *Service) handleDA(ctx context.Context, avs das.AvailabilityStore, block blocks.ROBlock) (time.Duration, error) {
+	var err error
+	start := time.Now()
+	if avs != nil {
+		err = avs.IsDataAvailable(ctx, s.CurrentSlot(), block)
+	} else {
+		err = s.isDataAvailable(ctx, block)
 	}
-
-	var rob blocks.ROBlock
-	rob, err = blocks.NewROBlockWithRoot(block, blockRoot)
+	elapsed := time.Since(start)
 	if err != nil {
-		return
+		dataAvailWaitedTime.Observe(float64(elapsed.Milliseconds()))
 	}
-
-	err = avs.IsDataAvailable(ctx, s.CurrentSlot(), rob)
-
-	return
+	return elapsed, err
 }
 
 func (s *Service) reportPostBlockProcessing(
@@ -320,13 +301,28 @@ func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedSta
 	if features.Get().EnableLightClient {
 		// Save a light client bootstrap for the finalized checkpoint
 		go func() {
-			err := s.lcStore.SaveLightClientBootstrap(s.ctx, finalized.Root)
+			st, err := s.cfg.StateGen.StateByRoot(ctx, finalized.Root)
+			if err != nil {
+				log.WithError(err).Error("Could not retrieve state for finalized root to save light client bootstrap")
+				return
+			}
+			err = s.lcStore.SaveLightClientBootstrap(s.ctx, finalized.Root, st)
 			if err != nil {
 				log.WithError(err).Error("Could not save light client bootstrap by block root")
 			} else {
 				log.Debugf("Saved light client bootstrap for finalized root %#x", finalized.Root)
 			}
 		}()
+
+		// Clean up the light client store caches
+		go func() {
+			err := s.lcStore.MigrateToCold(s.ctx, finalized.Root)
+			if err != nil {
+				log.WithError(err).Error("Could not migrate light client store to cold storage")
+			} else {
+				log.Debugf("Migrated light client store to cold storage for finalized root %#x", finalized.Root)
+			}
+		}()
 	}
 }
 

beacon-chain/blockchain/receive_block_test.go

@@ -9,9 +9,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/das"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/voluntaryexits"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
@@ -192,7 +192,9 @@ func TestHandleDA(t *testing.T) {
 	require.NoError(t, err)
 
 	s, _ := minimalTestService(t)
-	elapsed, err := s.handleDA(t.Context(), signedBeaconBlock, [fieldparams.RootLength]byte{}, nil)
+	block, err := blocks.NewROBlockWithRoot(signedBeaconBlock, [32]byte{})
+	require.NoError(t, err)
+	elapsed, err := s.handleDA(t.Context(), nil, block)
 	require.NoError(t, err)
 	require.Equal(t, true, elapsed > 0, "Elapsed time should be greater than 0")
 }
@@ -594,11 +596,7 @@ func TestProcessLightClientBootstrap(t *testing.T) {
 
 			require.NoError(t, s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: cp.Epoch, Root: [32]byte(cp.Root)}))
 
-			sss, err := s.cfg.BeaconDB.State(ctx, finalizedBlockRoot)
-			require.NoError(t, err)
-			require.NotNil(t, sss)
-
-			s.executePostFinalizationTasks(s.ctx, l.FinalizedState)
+			s.executePostFinalizationTasks(s.ctx, l.AttestedState)
 
 			// wait for the goroutine to finish processing
 			time.Sleep(1 * time.Second)

beacon-chain/blockchain/service.go

@@ -14,13 +14,13 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	coreTime "github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
 	f "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings"

beacon-chain/blockchain/setup_forkchoice.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"slices"
 
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
@@ -78,10 +79,7 @@ func (s *Service) setupForkchoiceTree(st state.BeaconState) error {
 	}
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	if err := s.cfg.ForkChoiceStore.InsertChain(s.ctx, chain); err != nil {
-		return errors.Wrap(err, "could not insert forkchoice chain")
-	}
-	return s.cfg.ForkChoiceStore.InsertNode(s.ctx, st, chain[0].Block)
+	return s.cfg.ForkChoiceStore.InsertChain(s.ctx, chain)
 }
 
 func (s *Service) buildForkchoiceChain(ctx context.Context, head interfaces.ReadOnlySignedBeaconBlock) ([]*forkchoicetypes.BlockAndCheckpoints, error) {
@@ -115,6 +113,7 @@ func (s *Service) buildForkchoiceChain(ctx context.Context, head interfaces.Read
 			return nil, errors.New("head block is not a descendant of the finalized checkpoint")
 		}
 	}
+	slices.Reverse(chain)
 	return chain, nil
 }
 

beacon-chain/blockchain/setup_test.go

@@ -11,21 +11,21 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache/depositsnapshot"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	mockExecution "github.com/OffchainLabs/prysm/v6/beacon-chain/execution/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	p2pTesting "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
-	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"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -89,7 +89,7 @@ func (mb *mockBroadcaster) BroadcastLightClientFinalityUpdate(_ context.Context,
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastDataColumnSidecar(_ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar) error {
+func (mb *mockBroadcaster) BroadcastDataColumnSidecar(_ uint64, _ blocks.VerifiedRODataColumn) error {
 	mb.broadcastCalled = true
 	return nil
 }

beacon-chain/blockchain/testing/mock.go

@@ -723,7 +723,8 @@ func (c *ChainService) ReceiveDataColumn(dc blocks.VerifiedRODataColumn) error {
 }
 
 // ReceiveDataColumns implements the same method in chain service
-func (*ChainService) ReceiveDataColumns(_ []blocks.VerifiedRODataColumn) error {
+func (c *ChainService) ReceiveDataColumns(dcs []blocks.VerifiedRODataColumn) error {
+	c.DataColumns = append(c.DataColumns, dcs...)
 	return nil
 }
 

beacon-chain/core/light-client/store.go

@@ -1,202 +0,0 @@
-package light_client
-
-import (
-	"context"
-	"sync"
-
-	"github.com/OffchainLabs/prysm/v6/async/event"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
-	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
-)
-
-var ErrLightClientBootstrapNotFound = errors.New("light client bootstrap not found")
-
-type Store struct {
-	mu sync.RWMutex
-
-	beaconDB             iface.HeadAccessDatabase
-	lastFinalityUpdate   interfaces.LightClientFinalityUpdate   // tracks the best finality update seen so far
-	lastOptimisticUpdate interfaces.LightClientOptimisticUpdate // tracks the best optimistic update seen so far
-	p2p                  p2p.Accessor
-	stateFeed            event.SubscriberSender
-}
-
-func NewLightClientStore(db iface.HeadAccessDatabase, p p2p.Accessor, e event.SubscriberSender) *Store {
-	return &Store{
-		beaconDB:  db,
-		p2p:       p,
-		stateFeed: e,
-	}
-}
-
-func (s *Store) LightClientBootstrap(ctx context.Context, blockRoot [32]byte) (interfaces.LightClientBootstrap, error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	// Fetch the light client bootstrap from the database
-	bootstrap, err := s.beaconDB.LightClientBootstrap(ctx, blockRoot[:])
-	if err != nil {
-		return nil, err
-	}
-	if bootstrap == nil { // not found
-		return nil, ErrLightClientBootstrapNotFound
-	}
-
-	return bootstrap, nil
-}
-
-func (s *Store) SaveLightClientBootstrap(ctx context.Context, blockRoot [32]byte) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	blk, err := s.beaconDB.Block(ctx, blockRoot)
-	if err != nil {
-		return errors.Wrapf(err, "failed to fetch block for root %x", blockRoot)
-	}
-	if blk == nil {
-		return errors.Errorf("failed to fetch block for root %x", blockRoot)
-	}
-
-	state, err := s.beaconDB.State(ctx, blockRoot)
-	if err != nil {
-		return errors.Wrapf(err, "failed to fetch state for block root %x", blockRoot)
-	}
-	if state == nil {
-		return errors.Errorf("failed to fetch state for block root %x", blockRoot)
-	}
-
-	bootstrap, err := NewLightClientBootstrapFromBeaconState(ctx, state.Slot(), state, blk)
-	if err != nil {
-		return errors.Wrapf(err, "failed to create light client bootstrap for block root %x", blockRoot)
-	}
-
-	// Save the light client bootstrap to the database
-	if err := s.beaconDB.SaveLightClientBootstrap(ctx, blockRoot[:], bootstrap); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) ([]interfaces.LightClientUpdate, error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	// Fetch the light client updatesMap from the database
-	updatesMap, err := s.beaconDB.LightClientUpdates(ctx, startPeriod, endPeriod)
-	if err != nil {
-		return nil, err
-	}
-
-	var updates []interfaces.LightClientUpdate
-	for i := startPeriod; i <= endPeriod; i++ {
-		update, ok := updatesMap[i]
-		if !ok {
-			// Only return the first contiguous range of updates
-			break
-		}
-		updates = append(updates, update)
-	}
-
-	return updates, nil
-}
-
-func (s *Store) LightClientUpdate(ctx context.Context, period uint64) (interfaces.LightClientUpdate, error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	// Fetch the light client update for the given period from the database
-	update, err := s.beaconDB.LightClientUpdate(ctx, period)
-	if err != nil {
-		return nil, err
-	}
-
-	return update, nil
-}
-
-func (s *Store) SaveLightClientUpdate(ctx context.Context, period uint64, update interfaces.LightClientUpdate) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	oldUpdate, err := s.beaconDB.LightClientUpdate(ctx, period)
-	if err != nil {
-		return errors.Wrapf(err, "could not get current light client update")
-	}
-
-	if oldUpdate == nil {
-		if err := s.beaconDB.SaveLightClientUpdate(ctx, period, update); err != nil {
-			return errors.Wrapf(err, "could not save light client update")
-		}
-		log.WithField("period", period).Debug("Saved new light client update")
-		return nil
-	}
-
-	isNewUpdateBetter, err := IsBetterUpdate(update, oldUpdate)
-	if err != nil {
-		return errors.Wrapf(err, "could not compare light client updates")
-	}
-
-	if isNewUpdateBetter {
-		if err := s.beaconDB.SaveLightClientUpdate(ctx, period, update); err != nil {
-			return errors.Wrapf(err, "could not save light client update")
-		}
-		log.WithField("period", period).Debug("Saved new light client update")
-		return nil
-	}
-	log.WithField("period", period).Debug("New light client update is not better than the current one, skipping save")
-	return nil
-}
-
-func (s *Store) SetLastFinalityUpdate(update interfaces.LightClientFinalityUpdate, broadcast bool) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	if broadcast && IsFinalityUpdateValidForBroadcast(update, s.lastFinalityUpdate) {
-		if err := s.p2p.BroadcastLightClientFinalityUpdate(context.Background(), update); err != nil {
-			log.WithError(err).Error("Could not broadcast light client finality update")
-		}
-	}
-
-	s.lastFinalityUpdate = update
-	log.Debug("Saved new light client finality update")
-
-	s.stateFeed.Send(&feed.Event{
-		Type: statefeed.LightClientFinalityUpdate,
-		Data: update,
-	})
-}
-
-func (s *Store) LastFinalityUpdate() interfaces.LightClientFinalityUpdate {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.lastFinalityUpdate
-}
-
-func (s *Store) SetLastOptimisticUpdate(update interfaces.LightClientOptimisticUpdate, broadcast bool) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	if broadcast {
-		if err := s.p2p.BroadcastLightClientOptimisticUpdate(context.Background(), update); err != nil {
-			log.WithError(err).Error("Could not broadcast light client optimistic update")
-		}
-	}
-
-	s.lastOptimisticUpdate = update
-	log.Debug("Saved new light client optimistic update")
-
-	s.stateFeed.Send(&feed.Event{
-		Type: statefeed.LightClientOptimisticUpdate,
-		Data: update,
-	})
-}
-
-func (s *Store) LastOptimisticUpdate() interfaces.LightClientOptimisticUpdate {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.lastOptimisticUpdate
-}

beacon-chain/core/light-client/store_test.go

@@ -1,165 +0,0 @@
-package light_client_test
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/async/event"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
-	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
-	p2pTesting "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
-)
-
-func TestLightClientStore(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.AltairForkEpoch = 1
-	cfg.BellatrixForkEpoch = 2
-	cfg.CapellaForkEpoch = 3
-	cfg.DenebForkEpoch = 4
-	cfg.ElectraForkEpoch = 5
-	params.OverrideBeaconConfig(cfg)
-
-	// Initialize the light client store
-	lcStore := lightClient.NewLightClientStore(testDB.SetupDB(t), &p2pTesting.FakeP2P{}, new(event.Feed))
-
-	// Create test light client updates for Capella and Deneb
-	lCapella := util.NewTestLightClient(t, version.Capella)
-	opUpdateCapella, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(lCapella.Ctx, lCapella.State, lCapella.Block, lCapella.AttestedState, lCapella.AttestedBlock)
-	require.NoError(t, err)
-	require.NotNil(t, opUpdateCapella, "OptimisticUpdateCapella is nil")
-	finUpdateCapella, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(lCapella.Ctx, lCapella.State, lCapella.Block, lCapella.AttestedState, lCapella.AttestedBlock, lCapella.FinalizedBlock)
-	require.NoError(t, err)
-	require.NotNil(t, finUpdateCapella, "FinalityUpdateCapella is nil")
-
-	lDeneb := util.NewTestLightClient(t, version.Deneb)
-	opUpdateDeneb, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(lDeneb.Ctx, lDeneb.State, lDeneb.Block, lDeneb.AttestedState, lDeneb.AttestedBlock)
-	require.NoError(t, err)
-	require.NotNil(t, opUpdateDeneb, "OptimisticUpdateDeneb is nil")
-	finUpdateDeneb, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(lDeneb.Ctx, lDeneb.State, lDeneb.Block, lDeneb.AttestedState, lDeneb.AttestedBlock, lDeneb.FinalizedBlock)
-	require.NoError(t, err)
-	require.NotNil(t, finUpdateDeneb, "FinalityUpdateDeneb is nil")
-
-	// Initially the store should have nil values for both updates
-	require.IsNil(t, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should be nil")
-	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
-
-	// Set and get finality with Capella update. Optimistic update should be nil
-	lcStore.SetLastFinalityUpdate(finUpdateCapella, false)
-	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
-	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
-
-	// Set and get optimistic with Capella update. Finality update should be Capella
-	lcStore.SetLastOptimisticUpdate(opUpdateCapella, false)
-	require.Equal(t, opUpdateCapella, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
-	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
-
-	// Set and get finality and optimistic with Deneb update
-	lcStore.SetLastFinalityUpdate(finUpdateDeneb, false)
-	lcStore.SetLastOptimisticUpdate(opUpdateDeneb, false)
-	require.Equal(t, finUpdateDeneb, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
-	require.Equal(t, opUpdateDeneb, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
-}
-
-func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
-	p2p := p2pTesting.NewTestP2P(t)
-	lcStore := lightClient.NewLightClientStore(testDB.SetupDB(t), p2p, new(event.Feed))
-
-	// update 0 with basic data and no supermajority following an empty lastFinalityUpdate - should save and broadcast
-	l0 := util.NewTestLightClient(t, version.Altair)
-	update0, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l0.Ctx, l0.State, l0.Block, l0.AttestedState, l0.AttestedBlock, l0.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update0, lcStore.LastFinalityUpdate()), "update0 should be better than nil")
-	// update0 should be valid for broadcast - meaning it should be broadcasted
-	require.Equal(t, true, lightClient.IsFinalityUpdateValidForBroadcast(update0, lcStore.LastFinalityUpdate()), "update0 should be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update0, true)
-	require.Equal(t, update0, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update when previous is nil")
-	p2p.BroadcastCalled.Store(false) // Reset for next test
-
-	// update 1 with same finality slot, increased attested slot, and no supermajority - should save but not broadcast
-	l1 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1))
-	update1, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l1.Ctx, l1.State, l1.Block, l1.AttestedState, l1.AttestedBlock, l1.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update1, update0), "update1 should be better than update0")
-	// update1 should not be valid for broadcast - meaning it should not be broadcasted
-	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update1, lcStore.LastFinalityUpdate()), "update1 should not be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update1, true)
-	require.Equal(t, update1, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called after setting a new last finality update without supermajority")
-	p2p.BroadcastCalled.Store(false) // Reset for next test
-
-	// update 2 with same finality slot, increased attested slot, and supermajority - should save and broadcast
-	l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(2), util.WithSupermajority())
-	update2, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update2, update1), "update2 should be better than update1")
-	// update2 should be valid for broadcast - meaning it should be broadcasted
-	require.Equal(t, true, lightClient.IsFinalityUpdateValidForBroadcast(update2, lcStore.LastFinalityUpdate()), "update2 should be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update2, true)
-	require.Equal(t, update2, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update with supermajority")
-	p2p.BroadcastCalled.Store(false) // Reset for next test
-
-	// update 3 with same finality slot, increased attested slot, and supermajority - should save but not broadcast
-	l3 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(3), util.WithSupermajority())
-	update3, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l3.Ctx, l3.State, l3.Block, l3.AttestedState, l3.AttestedBlock, l3.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update3, update2), "update3 should be better than update2")
-	// update3 should not be valid for broadcast - meaning it should not be broadcasted
-	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update3, lcStore.LastFinalityUpdate()), "update3 should not be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update3, true)
-	require.Equal(t, update3, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been when previous was already broadcast")
-
-	// update 4 with increased finality slot, increased attested slot, and supermajority - should save and broadcast
-	l4 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(1), util.WithSupermajority())
-	update4, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l4.Ctx, l4.State, l4.Block, l4.AttestedState, l4.AttestedBlock, l4.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update4, update3), "update4 should be better than update3")
-	// update4 should be valid for broadcast - meaning it should be broadcasted
-	require.Equal(t, true, lightClient.IsFinalityUpdateValidForBroadcast(update4, lcStore.LastFinalityUpdate()), "update4 should be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update4, true)
-	require.Equal(t, update4, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after a new finality update with increased finality slot")
-	p2p.BroadcastCalled.Store(false) // Reset for next test
-
-	// update 5 with the same new finality slot, increased attested slot, and supermajority - should save but not broadcast
-	l5 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(2), util.WithSupermajority())
-	update5, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l5.Ctx, l5.State, l5.Block, l5.AttestedState, l5.AttestedBlock, l5.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update5, update4), "update5 should be better than update4")
-	// update5 should not be valid for broadcast - meaning it should not be broadcasted
-	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update5, lcStore.LastFinalityUpdate()), "update5 should not be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update5, true)
-	require.Equal(t, update5, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
-
-	// update 6 with the same new finality slot, increased attested slot, and no supermajority - should save but not broadcast
-	l6 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(3))
-	update6, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l6.Ctx, l6.State, l6.Block, l6.AttestedState, l6.AttestedBlock, l6.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update6, update5), "update6 should be better than update5")
-	// update6 should not be valid for broadcast - meaning it should not be broadcasted
-	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update6, lcStore.LastFinalityUpdate()), "update6 should not be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update6, true)
-	require.Equal(t, update6, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
-}

beacon-chain/core/peerdas/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "das_core.go",
         "info.go",
+        "log.go",
         "metrics.go",
         "p2p_interface.go",
         "reconstruction.go",
@@ -19,11 +20,11 @@ go_library(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/trie:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
@@ -33,6 +34,7 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )

beacon-chain/core/peerdas/das_core.go

@@ -4,15 +4,10 @@ import (
 	"encoding/binary"
 	"math"
 	"slices"
-	"time"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
@@ -20,12 +15,9 @@ import (
 
 var (
 	// Custom errors
-	ErrCustodyGroupTooLarge               = errors.New("custody group too large")
-	ErrCustodyGroupCountTooLarge          = errors.New("custody group count too large")
-	ErrSizeMismatch                       = errors.New("mismatch in the number of blob KZG commitments and cellsAndProofs")
-	ErrNotEnoughDataColumnSidecars        = errors.New("not enough columns")
-	ErrDataColumnSidecarsNotSortedByIndex = errors.New("data column sidecars are not sorted by index")
-	errWrongComputedCustodyGroupCount     = errors.New("wrong computed custody group count, should never happen")
+	ErrCustodyGroupTooLarge           = errors.New("custody group too large")
+	ErrCustodyGroupCountTooLarge      = errors.New("custody group count too large")
+	errWrongComputedCustodyGroupCount = errors.New("wrong computed custody group count, should never happen")
 
 	// maxUint256 is the maximum value of an uint256.
 	maxUint256 = &uint256.Int{math.MaxUint64, math.MaxUint64, math.MaxUint64, math.MaxUint64}
@@ -117,44 +109,6 @@ func ComputeColumnsForCustodyGroup(custodyGroup uint64) ([]uint64, error) {
 	return columns, nil
 }
 
-// DataColumnSidecars computes the data column sidecars from the signed block, cells and cell proofs.
-// The returned value contains pointers to function parameters.
-// (If the caller alterates `cellsAndProofs` afterwards, the returned value will be modified as well.)
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_block
-func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, cellsAndProofs []kzg.CellsAndProofs) ([]*ethpb.DataColumnSidecar, error) {
-	if signedBlock == nil || signedBlock.IsNil() || len(cellsAndProofs) == 0 {
-		return nil, nil
-	}
-
-	block := signedBlock.Block()
-	blockBody := block.Body()
-	blobKzgCommitments, err := blockBody.BlobKzgCommitments()
-	if err != nil {
-		return nil, errors.Wrap(err, "blob KZG commitments")
-	}
-
-	if len(blobKzgCommitments) != len(cellsAndProofs) {
-		return nil, ErrSizeMismatch
-	}
-
-	signedBlockHeader, err := signedBlock.Header()
-	if err != nil {
-		return nil, errors.Wrap(err, "signed block header")
-	}
-
-	kzgCommitmentsInclusionProof, err := blocks.MerkleProofKZGCommitments(blockBody)
-	if err != nil {
-		return nil, errors.Wrap(err, "merkle proof KZG commitments")
-	}
-
-	dataColumnSidecars, err := dataColumnsSidecars(signedBlockHeader, blobKzgCommitments, kzgCommitmentsInclusionProof, cellsAndProofs)
-	if err != nil {
-		return nil, errors.Wrap(err, "data column sidecars")
-	}
-
-	return dataColumnSidecars, nil
-}
-
 // ComputeCustodyGroupForColumn computes the custody group for a given column.
 // It is the reciprocal function of ComputeColumnsForCustodyGroup.
 func ComputeCustodyGroupForColumn(columnIndex uint64) (uint64, error) {
@@ -194,72 +148,3 @@ func CustodyColumns(custodyGroups []uint64) (map[uint64]bool, error) {
 
 	return columns, nil
 }
-
-// dataColumnsSidecars computes the data column sidecars from the signed block header, the blob KZG commiments,
-// the KZG commitment includion proofs and cells and cell proofs.
-// The returned value contains pointers to function parameters.
-// (If the caller alterates input parameters afterwards, the returned value will be modified as well.)
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars
-func dataColumnsSidecars(
-	signedBlockHeader *ethpb.SignedBeaconBlockHeader,
-	blobKzgCommitments [][]byte,
-	kzgCommitmentsInclusionProof [][]byte,
-	cellsAndProofs []kzg.CellsAndProofs,
-) ([]*ethpb.DataColumnSidecar, error) {
-	start := time.Now()
-	if len(blobKzgCommitments) != len(cellsAndProofs) {
-		return nil, ErrSizeMismatch
-	}
-
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-
-	blobsCount := len(cellsAndProofs)
-	sidecars := make([]*ethpb.DataColumnSidecar, 0, numberOfColumns)
-	for columnIndex := range numberOfColumns {
-		column := make([]kzg.Cell, 0, blobsCount)
-		kzgProofOfColumn := make([]kzg.Proof, 0, blobsCount)
-
-		for rowIndex := range blobsCount {
-			cellsForRow := cellsAndProofs[rowIndex].Cells
-			proofsForRow := cellsAndProofs[rowIndex].Proofs
-
-			// Validate that we have enough cells and proofs for this column index
-			if columnIndex >= uint64(len(cellsForRow)) {
-				return nil, errors.Errorf("column index %d exceeds cells length %d for blob %d", columnIndex, len(cellsForRow), rowIndex)
-			}
-			if columnIndex >= uint64(len(proofsForRow)) {
-				return nil, errors.Errorf("column index %d exceeds proofs length %d for blob %d", columnIndex, len(proofsForRow), rowIndex)
-			}
-
-			cell := cellsForRow[columnIndex]
-			column = append(column, cell)
-
-			kzgProof := proofsForRow[columnIndex]
-			kzgProofOfColumn = append(kzgProofOfColumn, kzgProof)
-		}
-
-		columnBytes := make([][]byte, 0, blobsCount)
-		for i := range column {
-			columnBytes = append(columnBytes, column[i][:])
-		}
-
-		kzgProofOfColumnBytes := make([][]byte, 0, blobsCount)
-		for _, kzgProof := range kzgProofOfColumn {
-			kzgProofOfColumnBytes = append(kzgProofOfColumnBytes, kzgProof[:])
-		}
-
-		sidecar := &ethpb.DataColumnSidecar{
-			Index:                        columnIndex,
-			Column:                       columnBytes,
-			KzgCommitments:               blobKzgCommitments,
-			KzgProofs:                    kzgProofOfColumnBytes,
-			SignedBlockHeader:            signedBlockHeader,
-			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-		}
-
-		sidecars = append(sidecars, sidecar)
-	}
-
-	dataColumnComputationTime.Observe(float64(time.Since(start).Milliseconds()))
-	return sidecars, nil
-}

beacon-chain/core/peerdas/das_core_test.go

@@ -3,13 +3,9 @@ package peerdas_test
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 )
 
@@ -31,93 +27,6 @@ func TestComputeColumnsForCustodyGroup(t *testing.T) {
 	require.ErrorIs(t, err, peerdas.ErrCustodyGroupTooLarge)
 }
 
-func TestDataColumnSidecars(t *testing.T) {
-	t.Run("nil signed block", func(t *testing.T) {
-		var expected []*ethpb.DataColumnSidecar = nil
-		actual, err := peerdas.DataColumnSidecars(nil, []kzg.CellsAndProofs{})
-		require.NoError(t, err)
-
-		require.DeepSSZEqual(t, expected, actual)
-	})
-
-	t.Run("empty cells and proofs", func(t *testing.T) {
-		// Create a protobuf signed beacon block.
-		signedBeaconBlockPb := util.NewBeaconBlockDeneb()
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		actual, err := peerdas.DataColumnSidecars(signedBeaconBlock, []kzg.CellsAndProofs{})
-		require.NoError(t, err)
-		require.IsNil(t, actual)
-	})
-
-	t.Run("sizes mismatch", func(t *testing.T) {
-		// Create a protobuf signed beacon block.
-		signedBeaconBlockPb := util.NewBeaconBlockDeneb()
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		// Create cells and proofs.
-		cellsAndProofs := make([]kzg.CellsAndProofs, 1)
-
-		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
-		require.ErrorIs(t, err, peerdas.ErrSizeMismatch)
-	})
-
-	t.Run("cells array too short for column index", func(t *testing.T) {
-		// Create a Fulu block with a blob commitment.
-		signedBeaconBlockPb := util.NewBeaconBlockFulu()
-		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		// Create cells and proofs with insufficient cells for the number of columns.
-		// This simulates a scenario where cellsAndProofs has fewer cells than expected columns.
-		cellsAndProofs := []kzg.CellsAndProofs{
-			{
-				Cells:  make([]kzg.Cell, 10),  // Only 10 cells
-				Proofs: make([]kzg.Proof, 10), // Only 10 proofs
-			},
-		}
-
-		// This should fail because the function will try to access columns up to NumberOfColumns
-		// but we only have 10 cells/proofs.
-		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
-		require.ErrorContains(t, "column index", err)
-		require.ErrorContains(t, "exceeds cells length", err)
-	})
-
-	t.Run("proofs array too short for column index", func(t *testing.T) {
-		// Create a Fulu block with a blob commitment.
-		signedBeaconBlockPb := util.NewBeaconBlockFulu()
-		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		// Create cells and proofs with sufficient cells but insufficient proofs.
-		numberOfColumns := params.BeaconConfig().NumberOfColumns
-		cellsAndProofs := []kzg.CellsAndProofs{
-			{
-				Cells:  make([]kzg.Cell, numberOfColumns),
-				Proofs: make([]kzg.Proof, 5), // Only 5 proofs, less than columns
-			},
-		}
-
-		// This should fail when trying to access proof beyond index 4.
-		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
-		require.ErrorContains(t, "column index", err)
-		require.ErrorContains(t, "exceeds proofs length", err)
-	})
-}
-
 func TestComputeCustodyGroupForColumn(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	config := params.BeaconConfig()

beacon-chain/core/peerdas/log.go

@@ -0,0 +1,5 @@
+package peerdas
+
+import "github.com/sirupsen/logrus"
+
+var log = logrus.WithField("prefix", "peerdas")

beacon-chain/core/peerdas/p2p_interface_test.go

@@ -63,17 +63,14 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
 	t.Run("invalid proof", func(t *testing.T) {
 		sidecars := generateRandomSidecars(t, seed, blobCount)
 		sidecars[0].Column[0][0]++ // It is OK to overflow
-		roDataColumnSidecars := generateRODataColumnSidecars(t, sidecars)
 
-		err := peerdas.VerifyDataColumnsSidecarKZGProofs(roDataColumnSidecars)
+		err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
 		require.ErrorIs(t, err, peerdas.ErrInvalidKZGProof)
 	})
 
 	t.Run("nominal", func(t *testing.T) {
 		sidecars := generateRandomSidecars(t, seed, blobCount)
-		roDataColumnSidecars := generateRODataColumnSidecars(t, sidecars)
-
-		err := peerdas.VerifyDataColumnsSidecarKZGProofs(roDataColumnSidecars)
+		err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
 		require.NoError(t, err)
 	})
 }
@@ -256,9 +253,8 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_SameCommitments_NoBatch(b *testin
 	for i := range int64(b.N) {
 		// Generate new random sidecars to ensure the KZG backend does not cache anything.
 		sidecars := generateRandomSidecars(b, i, blobCount)
-		roDataColumnSidecars := generateRODataColumnSidecars(b, sidecars)
 
-		for _, sidecar := range roDataColumnSidecars {
+		for _, sidecar := range sidecars {
 			sidecars := []blocks.RODataColumn{sidecar}
 			b.StartTimer()
 			err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
@@ -282,7 +278,7 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch(b *testing.
 			b.ResetTimer()
 
 			for j := range int64(b.N) {
-				allSidecars := make([]*ethpb.DataColumnSidecar, 0, numberOfColumns)
+				allSidecars := make([]blocks.RODataColumn, 0, numberOfColumns)
 				for k := int64(0); k < numberOfColumns; k += columnsCount {
 					// Use different seeds to generate different blobs/commitments
 					seed := int64(b.N*i) + numberOfColumns*j + blobCount*k
@@ -292,10 +288,8 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch(b *testing.
 					allSidecars = append(allSidecars, sidecars[k:k+columnsCount]...)
 				}
 
-				roDataColumnSidecars := generateRODataColumnSidecars(b, allSidecars)
-
 				b.StartTimer()
-				err := peerdas.VerifyDataColumnsSidecarKZGProofs(roDataColumnSidecars)
+				err := peerdas.VerifyDataColumnsSidecarKZGProofs(allSidecars)
 				b.StopTimer()
 				require.NoError(b, err)
 			}
@@ -323,8 +317,7 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch4(b *testing
 		for j := range int64(batchCount) {
 			// Use different seeds to generate different blobs/commitments
 			sidecars := generateRandomSidecars(b, int64(batchCount)*i+j*blobCount, blobCount)
-			roDataColumnSidecars := generateRODataColumnSidecars(b, sidecars[:columnsCount])
-			allSidecars = append(allSidecars, roDataColumnSidecars)
+			allSidecars = append(allSidecars, sidecars)
 		}
 
 		for _, sidecars := range allSidecars {
@@ -358,7 +351,7 @@ func createTestSidecar(t *testing.T, index uint64, column, kzgCommitments, kzgPr
 	return roSidecar
 }
 
-func generateRandomSidecars(t testing.TB, seed, blobCount int64) []*ethpb.DataColumnSidecar {
+func generateRandomSidecars(t testing.TB, seed, blobCount int64) []blocks.RODataColumn {
 	dbBlock := util.NewBeaconBlockDeneb()
 
 	commitments := make([][]byte, 0, blobCount)
@@ -379,20 +372,10 @@ func generateRandomSidecars(t testing.TB, seed, blobCount int64) []*ethpb.DataCo
 	require.NoError(t, err)
 
 	cellsAndProofs := util.GenerateCellsAndProofs(t, blobs)
-	sidecars, err := peerdas.DataColumnSidecars(sBlock, cellsAndProofs)
+	rob, err := blocks.NewROBlock(sBlock)
+	require.NoError(t, err)
+	sidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
 	require.NoError(t, err)
 
 	return sidecars
 }
-
-func generateRODataColumnSidecars(t testing.TB, sidecars []*ethpb.DataColumnSidecar) []blocks.RODataColumn {
-	roDataColumnSidecars := make([]blocks.RODataColumn, 0, len(sidecars))
-	for _, sidecar := range sidecars {
-		roCol, err := blocks.NewRODataColumn(sidecar)
-		require.NoError(t, err)
-
-		roDataColumnSidecars = append(roDataColumnSidecars, roCol)
-	}
-
-	return roDataColumnSidecars
-}

beacon-chain/core/peerdas/reconstruction.go

@@ -5,7 +5,7 @@ import (
 	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"
+	pb "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 	"golang.org/x/sync/errgroup"
@@ -16,6 +16,7 @@ var (
 	ErrBlobIndexTooHigh         = errors.New("blob index is too high")
 	ErrBlockRootMismatch        = errors.New("block root mismatch")
 	ErrBlobsCellsProofsMismatch = errors.New("blobs and cells proofs mismatch")
+	ErrNilBlobAndProof          = errors.New("nil blob and proof")
 )
 
 // MinimumColumnCountToReconstruct return the minimum number of columns needed to proceed to a reconstruction.
@@ -62,12 +63,6 @@ func ReconstructDataColumnSidecars(verifiedRoSidecars []blocks.VerifiedRODataCol
 		return nil, ErrNotEnoughDataColumnSidecars
 	}
 
-	// Sidecars are verified and are committed to the same block.
-	// All signed block headers, KZG commitments, and inclusion proofs are the same.
-	signedBlockHeader := referenceSidecar.SignedBlockHeader
-	kzgCommitments := referenceSidecar.KzgCommitments
-	kzgCommitmentsInclusionProof := referenceSidecar.KzgCommitmentsInclusionProof
-
 	// Recover cells and compute proofs in parallel.
 	var wg errgroup.Group
 	cellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
@@ -100,80 +95,22 @@ func ReconstructDataColumnSidecars(verifiedRoSidecars []blocks.VerifiedRODataCol
 		return nil, errors.Wrap(err, "wait for RecoverCellsAndKZGProofs")
 	}
 
-	reconstructedSidecars, err := dataColumnsSidecars(signedBlockHeader, kzgCommitments, kzgCommitmentsInclusionProof, cellsAndProofs)
+	outSidecars, err := DataColumnSidecars(cellsAndProofs, PopulateFromSidecar(referenceSidecar))
 	if err != nil {
 		return nil, errors.Wrap(err, "data column sidecars from items")
 	}
 
 	// Input sidecars are verified, and we reconstructed ourselves the missing sidecars.
 	// As a consequence, reconstructed sidecars are also verified.
-	reconstructedVerifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(reconstructedSidecars))
-	for _, sidecar := range reconstructedSidecars {
-		roSidecar, err := blocks.NewRODataColumnWithRoot(sidecar, blockRoot)
-		if err != nil {
-			return nil, errors.Wrap(err, "new RO data column with root")
-		}
-
-		verifiedRoSidecar := blocks.NewVerifiedRODataColumn(roSidecar)
+	reconstructedVerifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(outSidecars))
+	for _, sidecar := range outSidecars {
+		verifiedRoSidecar := blocks.NewVerifiedRODataColumn(sidecar)
 		reconstructedVerifiedRoSidecars = append(reconstructedVerifiedRoSidecars, verifiedRoSidecar)
 	}
 
 	return reconstructedVerifiedRoSidecars, nil
 }
 
-// ConstructDataColumnSidecars constructs data column sidecars from a block, (un-extended) blobs and
-// cell proofs corresponding the extended blobs. The main purpose of this function is to
-// construct data column sidecars from data obtained from the execution client via:
-// - `engine_getBlobsV2` - https://github.com/ethereum/execution-apis/blob/main/src/engine/osaka.md#engine_getblobsv2, or
-// - `engine_getPayloadV5` - https://github.com/ethereum/execution-apis/blob/main/src/engine/osaka.md#engine_getpayloadv5
-// Note: In this function, to stick with the `BlobsBundleV2` format returned by the execution client in `engine_getPayloadV5`,
-// cell proofs are "flattened".
-func ConstructDataColumnSidecars(block interfaces.ReadOnlySignedBeaconBlock, blobs [][]byte, cellProofs [][]byte) ([]*ethpb.DataColumnSidecar, error) {
-	// Check if the cells count is equal to the cell proofs count.
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-	blobCount := uint64(len(blobs))
-	cellProofsCount := uint64(len(cellProofs))
-
-	cellsCount := blobCount * numberOfColumns
-	if cellsCount != cellProofsCount {
-		return nil, ErrBlobsCellsProofsMismatch
-	}
-
-	cellsAndProofs := make([]kzg.CellsAndProofs, 0, blobCount)
-	for i, blob := range blobs {
-		var kzgBlob kzg.Blob
-		if copy(kzgBlob[:], blob) != len(kzgBlob) {
-			return nil, errors.New("wrong blob size - should never happen")
-		}
-
-		// Compute the extended cells from the (non-extended) blob.
-		cells, err := kzg.ComputeCells(&kzgBlob)
-		if err != nil {
-			return nil, errors.Wrap(err, "compute cells")
-		}
-
-		var proofs []kzg.Proof
-		for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
-			var kzgProof kzg.Proof
-			if copy(kzgProof[:], cellProofs[idx]) != len(kzgProof) {
-				return nil, errors.New("wrong KZG proof size - should never happen")
-			}
-
-			proofs = append(proofs, kzgProof)
-		}
-
-		cellsProofs := kzg.CellsAndProofs{Cells: cells, Proofs: proofs}
-		cellsAndProofs = append(cellsAndProofs, cellsProofs)
-	}
-
-	dataColumnSidecars, err := DataColumnSidecars(block, cellsAndProofs)
-	if err != nil {
-		return nil, errors.Wrap(err, "data column sidcars")
-	}
-
-	return dataColumnSidecars, nil
-}
-
 // ReconstructBlobs constructs verified read only blobs sidecars from verified read only blob sidecars.
 // The following constraints must be satisfied:
 //   - All `dataColumnSidecars` has to be committed to the same block, and
@@ -256,6 +193,103 @@ func ReconstructBlobs(block blocks.ROBlock, verifiedDataColumnSidecars []blocks.
 	return blobSidecars, nil
 }
 
+// ComputeCellsAndProofsFromFlat computes the cells and proofs from blobs and cell flat proofs.
+func ComputeCellsAndProofsFromFlat(blobs [][]byte, cellProofs [][]byte) ([]kzg.CellsAndProofs, error) {
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+	blobCount := uint64(len(blobs))
+	cellProofsCount := uint64(len(cellProofs))
+
+	cellsCount := blobCount * numberOfColumns
+	if cellsCount != cellProofsCount {
+		return nil, ErrBlobsCellsProofsMismatch
+	}
+
+	cellsAndProofs := make([]kzg.CellsAndProofs, 0, blobCount)
+	log.Debug("TIME MARKER ZETA")
+	for i, blob := range blobs {
+		log.WithField("index", i).Debug("TIME MARKER EPSILON")
+
+		var kzgBlob kzg.Blob
+		if copy(kzgBlob[:], blob) != len(kzgBlob) {
+			return nil, errors.New("wrong blob size - should never happen")
+		}
+
+		log.WithField("index", i).Debug("TIME MARKER ETA")
+
+		// Compute the extended cells from the (non-extended) blob.
+		cells, err := kzg.ComputeCells(&kzgBlob)
+		if err != nil {
+			return nil, errors.Wrap(err, "compute cells")
+		}
+
+		log.WithField("index", i).Debug("TIME MARKER THETA")
+
+		var proofs []kzg.Proof
+		for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
+			var kzgProof kzg.Proof
+			if copy(kzgProof[:], cellProofs[idx]) != len(kzgProof) {
+				return nil, errors.New("wrong KZG proof size - should never happen")
+			}
+
+			proofs = append(proofs, kzgProof)
+		}
+
+		log.WithField("index", i).Debug("TIME MARKER IOTA")
+
+		cellsProofs := kzg.CellsAndProofs{Cells: cells, Proofs: proofs}
+		cellsAndProofs = append(cellsAndProofs, cellsProofs)
+
+		log.WithField("index", i).Debug("TIME MARKER KAPPA")
+
+	}
+
+	log.Debug("TIME MARKER LAMBDA")
+
+	return cellsAndProofs, nil
+}
+
+// ComputeCellsAndProofs computes the cells and proofs from blobs and cell proofs.
+func ComputeCellsAndProofsFromStructured(blobsAndProofs []*pb.BlobAndProofV2) ([]kzg.CellsAndProofs, error) {
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+	cellsAndProofs := make([]kzg.CellsAndProofs, 0, len(blobsAndProofs))
+	for _, blobAndProof := range blobsAndProofs {
+		if blobAndProof == nil {
+			return nil, ErrNilBlobAndProof
+		}
+
+		var kzgBlob kzg.Blob
+		if copy(kzgBlob[:], blobAndProof.Blob) != len(kzgBlob) {
+			return nil, errors.New("wrong blob size - should never happen")
+		}
+
+		// Compute the extended cells from the (non-extended) blob.
+		cells, err := kzg.ComputeCells(&kzgBlob)
+		if err != nil {
+			return nil, errors.Wrap(err, "compute cells")
+		}
+
+		kzgProofs := make([]kzg.Proof, 0, numberOfColumns*kzg.BytesPerProof)
+		for _, kzgProofBytes := range blobAndProof.KzgProofs {
+			if len(kzgProofBytes) != kzg.BytesPerProof {
+				return nil, errors.New("wrong KZG proof size - should never happen")
+			}
+
+			var kzgProof kzg.Proof
+			if copy(kzgProof[:], kzgProofBytes) != len(kzgProof) {
+				return nil, errors.New("wrong copied KZG proof size - should never happen")
+			}
+
+			kzgProofs = append(kzgProofs, kzgProof)
+		}
+
+		cellsProofs := kzg.CellsAndProofs{Cells: cells, Proofs: kzgProofs}
+		cellsAndProofs = append(cellsAndProofs, cellsProofs)
+	}
+
+	return cellsAndProofs, nil
+}
+
 // blobSidecarsFromDataColumnSidecars converts verified data column sidecars to verified blob sidecars.
 func blobSidecarsFromDataColumnSidecars(roBlock blocks.ROBlock, dataColumnSidecars []blocks.VerifiedRODataColumn, indices []int) ([]*blocks.VerifiedROBlob, error) {
 	referenceSidecar := dataColumnSidecars[0]

beacon-chain/core/peerdas/reconstruction_test.go

@@ -9,7 +9,7 @@ import (
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	pb "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
 	"github.com/pkg/errors"
@@ -124,50 +124,6 @@ func TestReconstructDataColumnSidecars(t *testing.T) {
 	})
 }
 
-func TestConstructDataColumnSidecars(t *testing.T) {
-	const (
-		blobCount    = 3
-		cellsPerBlob = fieldparams.CellsPerBlob
-	)
-
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-
-	// Start the trusted setup.
-	err := kzg.Start()
-	require.NoError(t, err)
-
-	roBlock, _, baseVerifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, blobCount)
-
-	// Extract blobs and proofs from the sidecars.
-	blobs := make([][]byte, 0, blobCount)
-	cellProofs := make([][]byte, 0, cellsPerBlob)
-	for blobIndex := range blobCount {
-		blob := make([]byte, 0, cellsPerBlob)
-		for columnIndex := range cellsPerBlob {
-			cell := baseVerifiedRoSidecars[columnIndex].Column[blobIndex]
-			blob = append(blob, cell...)
-		}
-
-		blobs = append(blobs, blob)
-
-		for columnIndex := range numberOfColumns {
-			cellProof := baseVerifiedRoSidecars[columnIndex].KzgProofs[blobIndex]
-			cellProofs = append(cellProofs, cellProof)
-		}
-	}
-
-	actual, err := peerdas.ConstructDataColumnSidecars(roBlock, blobs, cellProofs)
-	require.NoError(t, err)
-
-	// Extract the base verified ro sidecars into sidecars.
-	expected := make([]*ethpb.DataColumnSidecar, 0, len(baseVerifiedRoSidecars))
-	for _, verifiedRoSidecar := range baseVerifiedRoSidecars {
-		expected = append(expected, verifiedRoSidecar.DataColumnSidecar)
-	}
-
-	require.DeepSSZEqual(t, expected, actual)
-}
-
 func TestReconstructBlobs(t *testing.T) {
 	// Start the trusted setup.
 	err := kzg.Start()
@@ -250,7 +206,7 @@ func TestReconstructBlobs(t *testing.T) {
 		// Compute cells and proofs from blob sidecars.
 		var wg errgroup.Group
 		blobs := make([][]byte, blobCount)
-		cellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
+		inputCellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
 		for i := range blobCount {
 			blob := roBlobSidecars[i].Blob
 			blobs[i] = blob
@@ -267,7 +223,7 @@ func TestReconstructBlobs(t *testing.T) {
 
 				// It is safe for multiple goroutines to concurrently write to the same slice,
 				// as long as they are writing to different indices, which is the case here.
-				cellsAndProofs[i] = cp
+				inputCellsAndProofs[i] = cp
 
 				return nil
 			})
@@ -278,25 +234,24 @@ func TestReconstructBlobs(t *testing.T) {
 
 		// Flatten proofs.
 		cellProofs := make([][]byte, 0, blobCount*numberOfColumns)
-		for _, cp := range cellsAndProofs {
+		for _, cp := range inputCellsAndProofs {
 			for _, proof := range cp.Proofs {
 				cellProofs = append(cellProofs, proof[:])
 			}
 		}
 
-		// Construct data column sidecars.
-		// It is OK to use the public function `ConstructDataColumnSidecars`, as long as
-		// `TestConstructDataColumnSidecars` tests pass.
-		dataColumnSidecars, err := peerdas.ConstructDataColumnSidecars(roBlock, blobs, cellProofs)
+		// Compute celles and proofs from the blobs and cell proofs.
+		cellsAndProofs, err := peerdas.ComputeCellsAndProofsFromFlat(blobs, cellProofs)
+		require.NoError(t, err)
+
+		// Construct data column sidears from the signed block and cells and proofs.
+		roDataColumnSidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(roBlock))
 		require.NoError(t, err)
 
 		// Convert to verified data column sidecars.
-		verifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecars))
-		for _, dataColumnSidecar := range dataColumnSidecars {
-			roSidecar, err := blocks.NewRODataColumn(dataColumnSidecar)
-			require.NoError(t, err)
-
-			verifiedRoSidecar := blocks.NewVerifiedRODataColumn(roSidecar)
+		verifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(roDataColumnSidecars))
+		for _, roDataColumnSidecar := range roDataColumnSidecars {
+			verifiedRoSidecar := blocks.NewVerifiedRODataColumn(roDataColumnSidecar)
 			verifiedRoSidecars = append(verifiedRoSidecars, verifiedRoSidecar)
 		}
 
@@ -339,3 +294,162 @@ func TestReconstructBlobs(t *testing.T) {
 	})
 
 }
+
+func TestComputeCellsAndProofsFromFlat(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	t.Run("mismatched blob and proof counts", func(t *testing.T) {
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+		// Create one blob but proofs for two blobs
+		blobs := [][]byte{{}}
+
+		// Create proofs for 2 blobs worth of columns
+		cellProofs := make([][]byte, 2*numberOfColumns)
+
+		_, err := peerdas.ComputeCellsAndProofsFromFlat(blobs, cellProofs)
+		require.ErrorIs(t, err, peerdas.ErrBlobsCellsProofsMismatch)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		const blobCount = 2
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+		// Generate test blobs
+		_, roBlobSidecars := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, 42, blobCount)
+
+		// Extract blobs and compute expected cells and proofs
+		blobs := make([][]byte, blobCount)
+		expectedCellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
+		var wg errgroup.Group
+
+		for i := range blobCount {
+			blob := roBlobSidecars[i].Blob
+			blobs[i] = blob
+
+			wg.Go(func() error {
+				var kzgBlob kzg.Blob
+				count := copy(kzgBlob[:], blob)
+				require.Equal(t, len(kzgBlob), count)
+
+				cp, err := kzg.ComputeCellsAndKZGProofs(&kzgBlob)
+				if err != nil {
+					return errors.Wrapf(err, "compute cells and kzg proofs for blob %d", i)
+				}
+
+				expectedCellsAndProofs[i] = cp
+				return nil
+			})
+		}
+
+		err := wg.Wait()
+		require.NoError(t, err)
+
+		// Flatten proofs
+		cellProofs := make([][]byte, 0, blobCount*numberOfColumns)
+		for _, cp := range expectedCellsAndProofs {
+			for _, proof := range cp.Proofs {
+				cellProofs = append(cellProofs, proof[:])
+			}
+		}
+
+		// Test ComputeCellsAndProofs
+		actualCellsAndProofs, err := peerdas.ComputeCellsAndProofsFromFlat(blobs, cellProofs)
+		require.NoError(t, err)
+		require.Equal(t, blobCount, len(actualCellsAndProofs))
+
+		// Verify the results match expected
+		for i := range blobCount {
+			require.Equal(t, len(expectedCellsAndProofs[i].Cells), len(actualCellsAndProofs[i].Cells))
+			require.Equal(t, len(expectedCellsAndProofs[i].Proofs), len(actualCellsAndProofs[i].Proofs))
+
+			// Compare cells
+			for j, expectedCell := range expectedCellsAndProofs[i].Cells {
+				require.Equal(t, expectedCell, actualCellsAndProofs[i].Cells[j])
+			}
+
+			// Compare proofs
+			for j, expectedProof := range expectedCellsAndProofs[i].Proofs {
+				require.Equal(t, expectedProof, actualCellsAndProofs[i].Proofs[j])
+			}
+		}
+	})
+}
+
+func TestComputeCellsAndProofsFromStructured(t *testing.T) {
+	t.Run("nil blob and proof", func(t *testing.T) {
+		_, err := peerdas.ComputeCellsAndProofsFromStructured([]*pb.BlobAndProofV2{nil})
+		require.ErrorIs(t, err, peerdas.ErrNilBlobAndProof)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		// Start the trusted setup.
+		err := kzg.Start()
+		require.NoError(t, err)
+
+		const blobCount = 2
+
+		// Generate test blobs
+		_, roBlobSidecars := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, 42, blobCount)
+
+		// Extract blobs and compute expected cells and proofs
+		blobsAndProofs := make([]*pb.BlobAndProofV2, blobCount)
+		expectedCellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
+
+		var wg errgroup.Group
+		for i := range blobCount {
+			blob := roBlobSidecars[i].Blob
+
+			wg.Go(func() error {
+				var kzgBlob kzg.Blob
+				count := copy(kzgBlob[:], blob)
+				require.Equal(t, len(kzgBlob), count)
+
+				cellsAndProofs, err := kzg.ComputeCellsAndKZGProofs(&kzgBlob)
+				if err != nil {
+					return errors.Wrapf(err, "compute cells and kzg proofs for blob %d", i)
+				}
+				expectedCellsAndProofs[i] = cellsAndProofs
+
+				kzgProofs := make([][]byte, 0, len(cellsAndProofs.Proofs))
+				for _, proof := range cellsAndProofs.Proofs {
+					kzgProofs = append(kzgProofs, proof[:])
+				}
+
+				blobAndProof := &pb.BlobAndProofV2{
+					Blob:      blob,
+					KzgProofs: kzgProofs,
+				}
+				blobsAndProofs[i] = blobAndProof
+
+				return nil
+			})
+		}
+
+		err = wg.Wait()
+		require.NoError(t, err)
+
+		// Test ComputeCellsAndProofs
+		actualCellsAndProofs, err := peerdas.ComputeCellsAndProofsFromStructured(blobsAndProofs)
+		require.NoError(t, err)
+		require.Equal(t, blobCount, len(actualCellsAndProofs))
+
+		// Verify the results match expected
+		for i := range blobCount {
+			require.Equal(t, len(expectedCellsAndProofs[i].Cells), len(actualCellsAndProofs[i].Cells))
+			require.Equal(t, len(expectedCellsAndProofs[i].Proofs), len(actualCellsAndProofs[i].Proofs))
+
+			// Compare cells
+			for j, expectedCell := range expectedCellsAndProofs[i].Cells {
+				require.Equal(t, expectedCell, actualCellsAndProofs[i].Cells[j])
+			}
+
+			// Compare proofs
+			for j, expectedProof := range expectedCellsAndProofs[i].Proofs {
+				require.Equal(t, expectedProof, actualCellsAndProofs[i].Proofs[j])
+			}
+		}
+	})
+}

beacon-chain/core/peerdas/validator.go

@@ -1,12 +1,76 @@
 package peerdas
 
 import (
+	"time"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	beaconState "github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	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/primitives"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 )
 
+var (
+	ErrNilSignedBlockOrEmptyCellsAndProofs = errors.New("nil signed block or empty cells and proofs")
+	ErrSizeMismatch                        = errors.New("mismatch in the number of blob KZG commitments and cellsAndProofs")
+	ErrNotEnoughDataColumnSidecars         = errors.New("not enough columns")
+	ErrDataColumnSidecarsNotSortedByIndex  = errors.New("data column sidecars are not sorted by index")
+)
+
+var (
+	_ ConstructionPopulator = (*BlockReconstructionSource)(nil)
+	_ ConstructionPopulator = (*SidecarReconstructionSource)(nil)
+)
+
+const (
+	BlockType   = "BeaconBlock"
+	SidecarType = "DataColumnSidecar"
+)
+
+type (
+	// ConstructionPopulator is an interface that can be satisfied by a type that can use data from a struct
+	// like a DataColumnSidecar or a BeaconBlock to set the fields in a data column sidecar that cannot
+	// be obtained from the engine api.
+	ConstructionPopulator interface {
+		Slot() primitives.Slot
+		Root() [fieldparams.RootLength]byte
+		ProposerIndex() primitives.ValidatorIndex
+		Commitments() ([][]byte, error)
+		Type() string
+
+		extract() (*blockInfo, error)
+	}
+
+	// BlockReconstructionSource is a ConstructionPopulator that uses a beacon block as the source of data
+	BlockReconstructionSource struct {
+		blocks.ROBlock
+	}
+
+	// DataColumnSidecar is a ConstructionPopulator that uses a data column sidecar as the source of data
+	SidecarReconstructionSource struct {
+		blocks.VerifiedRODataColumn
+	}
+
+	blockInfo struct {
+		signedBlockHeader *ethpb.SignedBeaconBlockHeader
+		kzgCommitments    [][]byte
+		kzgInclusionProof [][]byte
+	}
+)
+
+// PopulateFromBlock creates a BlockReconstructionSource from a beacon block
+func PopulateFromBlock(block blocks.ROBlock) *BlockReconstructionSource {
+	return &BlockReconstructionSource{ROBlock: block}
+}
+
+// PopulateFromSidecar creates a SidecarReconstructionSource from a data column sidecar
+func PopulateFromSidecar(sidecar blocks.VerifiedRODataColumn) *SidecarReconstructionSource {
+	return &SidecarReconstructionSource{VerifiedRODataColumn: sidecar}
+}
+
 // ValidatorsCustodyRequirement returns the number of custody groups regarding the validator indices attached to the beacon node.
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#validator-custody
 func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
@@ -28,3 +92,158 @@ func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validat
 	count := totalNodeBalance / balancePerAdditionalCustodyGroup
 	return min(max(count, validatorCustodyRequirement), numberOfCustodyGroups), nil
 }
+
+// DataColumnSidecars, given ConstructionPopulator and the cells/proofs associated with each blob in the
+// block, assembles sidecars which can be distributed to peers.
+// This is an adapted version of
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars,
+// which is designed to be used both when constructing sidecars from a block and from a sidecar, replacing
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_block and
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_column_sidecar
+func DataColumnSidecars(rows []kzg.CellsAndProofs, src ConstructionPopulator) ([]blocks.RODataColumn, error) {
+	if len(rows) == 0 {
+		return nil, nil
+	}
+	start := time.Now()
+	cells, proofs, err := rotateRowsToCols(rows, params.BeaconConfig().NumberOfColumns)
+	if err != nil {
+		return nil, errors.Wrap(err, "rotate cells and proofs")
+	}
+	info, err := src.extract()
+	if err != nil {
+		return nil, errors.Wrap(err, "extract block info")
+	}
+
+	maxIdx := params.BeaconConfig().NumberOfColumns
+	roSidecars := make([]blocks.RODataColumn, 0, maxIdx)
+	for idx := range maxIdx {
+		sidecar := &ethpb.DataColumnSidecar{
+			Index:                        idx,
+			Column:                       cells[idx],
+			KzgCommitments:               info.kzgCommitments,
+			KzgProofs:                    proofs[idx],
+			SignedBlockHeader:            info.signedBlockHeader,
+			KzgCommitmentsInclusionProof: info.kzgInclusionProof,
+		}
+
+		if len(sidecar.KzgCommitments) != len(sidecar.Column) || len(sidecar.KzgCommitments) != len(sidecar.KzgProofs) {
+			return nil, ErrSizeMismatch
+		}
+
+		roSidecar, err := blocks.NewRODataColumnWithRoot(sidecar, src.Root())
+		if err != nil {
+			return nil, errors.Wrap(err, "new ro data column")
+		}
+		roSidecars = append(roSidecars, roSidecar)
+	}
+
+	dataColumnComputationTime.Observe(float64(time.Since(start).Milliseconds()))
+	return roSidecars, nil
+}
+
+// Slot returns the slot of the source
+func (s *BlockReconstructionSource) Slot() primitives.Slot {
+	return s.Block().Slot()
+}
+
+// ProposerIndex returns the proposer index of the source
+func (s *BlockReconstructionSource) ProposerIndex() primitives.ValidatorIndex {
+	return s.Block().ProposerIndex()
+}
+
+// Commitments returns the blob KZG commitments of the source
+func (s *BlockReconstructionSource) Commitments() ([][]byte, error) {
+	c, err := s.Block().Body().BlobKzgCommitments()
+
+	if err != nil {
+		return nil, errors.Wrap(err, "blob KZG commitments")
+	}
+
+	return c, nil
+}
+
+// Type returns the type of the source
+func (s *BlockReconstructionSource) Type() string {
+	return BlockType
+}
+
+// extract extracts the block information from the source
+func (b *BlockReconstructionSource) extract() (*blockInfo, error) {
+	block := b.Block()
+
+	header, err := b.Header()
+	if err != nil {
+		return nil, errors.Wrap(err, "header")
+	}
+
+	commitments, err := block.Body().BlobKzgCommitments()
+	if err != nil {
+		return nil, errors.Wrap(err, "commitments")
+	}
+
+	inclusionProof, err := blocks.MerkleProofKZGCommitments(block.Body())
+	if err != nil {
+		return nil, errors.Wrap(err, "merkle proof kzg commitments")
+	}
+
+	info := &blockInfo{
+		signedBlockHeader: header,
+		kzgCommitments:    commitments,
+		kzgInclusionProof: inclusionProof,
+	}
+
+	return info, nil
+}
+
+// rotateRowsToCols takes a 2D slice of cells and proofs, where the x is rows (blobs) and y is columns,
+// and returns a 2D slice where x is columns and y is rows.
+func rotateRowsToCols(rows []kzg.CellsAndProofs, numCols uint64) ([][][]byte, [][][]byte, error) {
+	if len(rows) == 0 {
+		return nil, nil, nil
+	}
+	cellCols := make([][][]byte, numCols)
+	proofCols := make([][][]byte, numCols)
+	for i, cp := range rows {
+		if uint64(len(cp.Cells)) != numCols {
+			return nil, nil, errors.Wrap(ErrNotEnoughDataColumnSidecars, "not enough cells")
+		}
+		if len(cp.Cells) != len(cp.Proofs) {
+			return nil, nil, errors.Wrap(ErrNotEnoughDataColumnSidecars, "not enough proofs")
+		}
+		for j := uint64(0); j < numCols; j++ {
+			if i == 0 {
+				cellCols[j] = make([][]byte, len(rows))
+				proofCols[j] = make([][]byte, len(rows))
+			}
+			cellCols[j][i] = cp.Cells[j][:]
+			proofCols[j][i] = cp.Proofs[j][:]
+		}
+	}
+	return cellCols, proofCols, nil
+}
+
+// Root returns the block root of the source
+func (s *SidecarReconstructionSource) Root() [fieldparams.RootLength]byte {
+	return s.BlockRoot()
+}
+
+// Commmitments returns the blob KZG commitments of the source
+func (s *SidecarReconstructionSource) Commitments() ([][]byte, error) {
+	return s.KzgCommitments, nil
+}
+
+// Type returns the type of the source
+func (s *SidecarReconstructionSource) Type() string {
+	return SidecarType
+}
+
+// extract extracts the block information from the source
+func (s *SidecarReconstructionSource) extract() (*blockInfo, error) {
+	info := &blockInfo{
+		signedBlockHeader: s.SignedBlockHeader,
+		kzgCommitments:    s.KzgCommitments,
+		kzgInclusionProof: s.KzgCommitmentsInclusionProof,
+	}
+
+	return info, nil
+}

beacon-chain/core/peerdas/validator_test.go

@@ -3,11 +3,15 @@ package peerdas_test
 import (
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
 )
 
 func TestValidatorsCustodyRequirement(t *testing.T) {
@@ -53,3 +57,218 @@ func TestValidatorsCustodyRequirement(t *testing.T) {
 		})
 	}
 }
+
+func TestDataColumnSidecars(t *testing.T) {
+	t.Run("sizes mismatch", func(t *testing.T) {
+		// Create a protobuf signed beacon block.
+		signedBeaconBlockPb := util.NewBeaconBlockDeneb()
+
+		// Create a signed beacon block from the protobuf.
+		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
+		require.NoError(t, err)
+
+		// Create cells and proofs.
+		cellsAndProofs := []kzg.CellsAndProofs{
+			{
+				Cells:  make([]kzg.Cell, params.BeaconConfig().NumberOfColumns),
+				Proofs: make([]kzg.Proof, params.BeaconConfig().NumberOfColumns),
+			},
+		}
+
+		rob, err := blocks.NewROBlock(signedBeaconBlock)
+		require.NoError(t, err)
+		_, err = peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
+		require.ErrorIs(t, err, peerdas.ErrSizeMismatch)
+	})
+
+	t.Run("cells array too short for column index", func(t *testing.T) {
+		// Create a Fulu block with a blob commitment.
+		signedBeaconBlockPb := util.NewBeaconBlockFulu()
+		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
+
+		// Create a signed beacon block from the protobuf.
+		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
+		require.NoError(t, err)
+
+		// Create cells and proofs with insufficient cells for the number of columns.
+		// This simulates a scenario where cellsAndProofs has fewer cells than expected columns.
+		cellsAndProofs := []kzg.CellsAndProofs{
+			{
+				Cells:  make([]kzg.Cell, 10),  // Only 10 cells
+				Proofs: make([]kzg.Proof, 10), // Only 10 proofs
+			},
+		}
+
+		// This should fail because the function will try to access columns up to NumberOfColumns
+		// but we only have 10 cells/proofs.
+		rob, err := blocks.NewROBlock(signedBeaconBlock)
+		require.NoError(t, err)
+		_, err = peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
+		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
+	})
+
+	t.Run("proofs array too short for column index", func(t *testing.T) {
+		// Create a Fulu block with a blob commitment.
+		signedBeaconBlockPb := util.NewBeaconBlockFulu()
+		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
+
+		// Create a signed beacon block from the protobuf.
+		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
+		require.NoError(t, err)
+
+		// Create cells and proofs with sufficient cells but insufficient proofs.
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
+		cellsAndProofs := []kzg.CellsAndProofs{
+			{
+				Cells:  make([]kzg.Cell, numberOfColumns),
+				Proofs: make([]kzg.Proof, 5), // Only 5 proofs, less than columns
+			},
+		}
+
+		// This should fail when trying to access proof beyond index 4.
+		rob, err := blocks.NewROBlock(signedBeaconBlock)
+		require.NoError(t, err)
+		_, err = peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
+		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
+		require.ErrorContains(t, "not enough proofs", err)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		// Create a Fulu block with blob commitments.
+		signedBeaconBlockPb := util.NewBeaconBlockFulu()
+		commitment1 := make([]byte, 48)
+		commitment2 := make([]byte, 48)
+
+		// Set different values to distinguish commitments
+		commitment1[0] = 0x01
+		commitment2[0] = 0x02
+		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{commitment1, commitment2}
+
+		// Create a signed beacon block from the protobuf.
+		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
+		require.NoError(t, err)
+
+		// Create cells and proofs with correct dimensions.
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
+		cellsAndProofs := []kzg.CellsAndProofs{
+			{
+				Cells:  make([]kzg.Cell, numberOfColumns),
+				Proofs: make([]kzg.Proof, numberOfColumns),
+			},
+			{
+				Cells:  make([]kzg.Cell, numberOfColumns),
+				Proofs: make([]kzg.Proof, numberOfColumns),
+			},
+		}
+
+		// Set distinct values in cells and proofs for testing
+		for i := range numberOfColumns {
+			cellsAndProofs[0].Cells[i][0] = byte(i)
+			cellsAndProofs[0].Proofs[i][0] = byte(i)
+			cellsAndProofs[1].Cells[i][0] = byte(i + 128)
+			cellsAndProofs[1].Proofs[i][0] = byte(i + 128)
+		}
+
+		rob, err := blocks.NewROBlock(signedBeaconBlock)
+		require.NoError(t, err)
+		sidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
+		require.NoError(t, err)
+		require.NotNil(t, sidecars)
+		require.Equal(t, int(numberOfColumns), len(sidecars))
+
+		// Verify each sidecar has the expected structure
+		for i, sidecar := range sidecars {
+			require.Equal(t, uint64(i), sidecar.Index)
+			require.Equal(t, 2, len(sidecar.Column))
+			require.Equal(t, 2, len(sidecar.KzgCommitments))
+			require.Equal(t, 2, len(sidecar.KzgProofs))
+
+			// Verify commitments match what we set
+			require.DeepEqual(t, commitment1, sidecar.KzgCommitments[0])
+			require.DeepEqual(t, commitment2, sidecar.KzgCommitments[1])
+
+			// Verify column data comes from the correct cells
+			require.Equal(t, byte(i), sidecar.Column[0][0])
+			require.Equal(t, byte(i+128), sidecar.Column[1][0])
+
+			// Verify proofs come from the correct proofs
+			require.Equal(t, byte(i), sidecar.KzgProofs[0][0])
+			require.Equal(t, byte(i+128), sidecar.KzgProofs[1][0])
+		}
+	})
+}
+
+func TestReconstructionSource(t *testing.T) {
+	// Create a Fulu block with blob commitments.
+	signedBeaconBlockPb := util.NewBeaconBlockFulu()
+	commitment1 := make([]byte, 48)
+	commitment2 := make([]byte, 48)
+
+	// Set different values to distinguish commitments
+	commitment1[0] = 0x01
+	commitment2[0] = 0x02
+	signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{commitment1, commitment2}
+
+	// Create a signed beacon block from the protobuf.
+	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
+	require.NoError(t, err)
+
+	// Create cells and proofs with correct dimensions.
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+	cellsAndProofs := []kzg.CellsAndProofs{
+		{
+			Cells:  make([]kzg.Cell, numberOfColumns),
+			Proofs: make([]kzg.Proof, numberOfColumns),
+		},
+		{
+			Cells:  make([]kzg.Cell, numberOfColumns),
+			Proofs: make([]kzg.Proof, numberOfColumns),
+		},
+	}
+
+	// Set distinct values in cells and proofs for testing
+	for i := range numberOfColumns {
+		cellsAndProofs[0].Cells[i][0] = byte(i)
+		cellsAndProofs[0].Proofs[i][0] = byte(i)
+		cellsAndProofs[1].Cells[i][0] = byte(i + 128)
+		cellsAndProofs[1].Proofs[i][0] = byte(i + 128)
+	}
+
+	rob, err := blocks.NewROBlock(signedBeaconBlock)
+	require.NoError(t, err)
+	sidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
+	require.NoError(t, err)
+	require.NotNil(t, sidecars)
+	require.Equal(t, int(numberOfColumns), len(sidecars))
+
+	t.Run("from block", func(t *testing.T) {
+		src := peerdas.PopulateFromBlock(rob)
+		require.Equal(t, rob.Block().Slot(), src.Slot())
+		require.Equal(t, rob.Root(), src.Root())
+		require.Equal(t, rob.Block().ProposerIndex(), src.ProposerIndex())
+
+		commitments, err := src.Commitments()
+		require.NoError(t, err)
+		require.Equal(t, 2, len(commitments))
+		require.DeepEqual(t, commitment1, commitments[0])
+		require.DeepEqual(t, commitment2, commitments[1])
+
+		require.Equal(t, peerdas.BlockType, src.Type())
+	})
+
+	t.Run("from sidecar", func(t *testing.T) {
+		referenceSidecar := blocks.NewVerifiedRODataColumn(sidecars[0])
+		src := peerdas.PopulateFromSidecar(referenceSidecar)
+		require.Equal(t, referenceSidecar.Slot(), src.Slot())
+		require.Equal(t, referenceSidecar.BlockRoot(), src.Root())
+		require.Equal(t, referenceSidecar.ProposerIndex(), src.ProposerIndex())
+
+		commitments, err := src.Commitments()
+		require.NoError(t, err)
+		require.Equal(t, 2, len(commitments))
+		require.DeepEqual(t, commitment1, commitments[0])
+		require.DeepEqual(t, commitment2, commitments[1])
+
+		require.Equal(t, peerdas.SidecarType, src.Type())
+	})
+}

beacon-chain/db/filesystem/data_column.go

@@ -259,7 +259,6 @@ func (dcs *DataColumnStorage) Summary(root [fieldparams.RootLength]byte) DataCol
 }
 
 // Save saves data column sidecars into the database and asynchronously performs pruning.
-// The returned channel is closed when the pruning is complete.
 func (dcs *DataColumnStorage) Save(dataColumnSidecars []blocks.VerifiedRODataColumn) error {
 	startTime := time.Now()
 

beacon-chain/execution/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
         "//testing/spectest:__subpackages__",
     ],
     deps = [
+        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
@@ -103,6 +104,7 @@ go_test(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",

beacon-chain/execution/engine_client.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
@@ -101,10 +102,7 @@ const (
 	defaultEngineTimeout = time.Second
 )
 
-var (
-	errInvalidPayloadBodyResponse  = errors.New("engine api payload body response is invalid")
-	errMissingBlobsAndProofsFromEL = errors.New("engine api payload body response is missing blobs and proofs")
-)
+var errInvalidPayloadBodyResponse = errors.New("engine api payload body response is invalid")
 
 // ForkchoiceUpdatedResponse is the response kind received by the
 // engine_forkchoiceUpdatedV1 endpoint.
@@ -123,7 +121,7 @@ type Reconstructor interface {
 		ctx context.Context, blindedBlocks []interfaces.ReadOnlySignedBeaconBlock,
 	) ([]interfaces.SignedBeaconBlock, error)
 	ReconstructBlobSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte, hi func(uint64) bool) ([]blocks.VerifiedROBlob, error)
-	ReconstructDataColumnSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error)
+	ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error)
 }
 
 // EngineCaller defines a client that can interact with an Ethereum
@@ -651,22 +649,40 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 	return verifiedBlobs, nil
 }
 
-// ReconstructDataColumnSidecars reconstructs the verified data column sidecars for a given beacon block.
-// It retrieves the KZG commitments from the block body, fetches the associated blobs and cell proofs from the EL,
-// and constructs the corresponding verified read-only data column sidecars.
-func (s *Service) ReconstructDataColumnSidecars(ctx context.Context, signedROBlock interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error) {
-	block := signedROBlock.Block()
+func (s *Service) ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error) {
+	root := populator.Root()
 
-	log := log.WithFields(logrus.Fields{
-		"root": fmt.Sprintf("%#x", blockRoot),
-		"slot": block.Slot(),
-	})
-
-	kzgCommitments, err := block.Body().BlobKzgCommitments()
+	// Fetch cells and proofs from the execution client using the KZG commitments from the sidecar.
+	commitments, err := populator.Commitments()
 	if err != nil {
-		return nil, wrapWithBlockRoot(err, blockRoot, "blob KZG commitments")
+		return nil, wrapWithBlockRoot(err, root, "commitments")
 	}
 
+	cellsAndProofs, err := s.fetchCellsAndProofsFromExecution(ctx, commitments)
+	if err != nil {
+		return nil, wrapWithBlockRoot(err, root, "fetch cells and proofs from execution client")
+	}
+
+	// Return early if nothing is returned from the EL.
+	if len(cellsAndProofs) == 0 {
+		return nil, nil
+	}
+
+	// Construct data column sidears from the signed block and cells and proofs.
+	roSidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, populator)
+	if err != nil {
+		return nil, wrapWithBlockRoot(err, populator.Root(), "data column sidcars from column sidecar")
+	}
+
+	// Upgrade the sidecars to verified sidecars.
+	// We trust the execution layer we are connected to, so we can upgrade the sidecar into a verified one.
+	verifiedROSidecars := upgradeSidecarsToVerifiedSidecars(roSidecars)
+
+	return verifiedROSidecars, nil
+}
+
+// fetchCellsAndProofsFromExecution fetches cells and proofs from the execution client (using engine_getBlobsV2 execution API method)
+func (s *Service) fetchCellsAndProofsFromExecution(ctx context.Context, kzgCommitments [][]byte) ([]kzg.CellsAndProofs, error) {
 	// Collect KZG hashes for all blobs.
 	versionedHashes := make([]common.Hash, 0, len(kzgCommitments))
 	for _, commitment := range kzgCommitments {
@@ -677,47 +693,32 @@ func (s *Service) ReconstructDataColumnSidecars(ctx context.Context, signedROBlo
 	// Fetch all blobsAndCellsProofs from the execution client.
 	blobAndProofV2s, err := s.GetBlobsV2(ctx, versionedHashes)
 	if err != nil {
-		return nil, wrapWithBlockRoot(err, blockRoot, "get blobs V2")
+		return nil, errors.Wrapf(err, "get blobs V2")
 	}
 
 	// Return early if nothing is returned from the EL.
 	if len(blobAndProofV2s) == 0 {
-		log.Debug("No blobs returned from execution client")
 		return nil, nil
 	}
 
-	// Extract the blobs and proofs from the blobAndProofV2s.
-	blobs, cellProofs := make([][]byte, 0, len(blobAndProofV2s)), make([][]byte, 0, len(blobAndProofV2s))
-	for _, blobsAndProofs := range blobAndProofV2s {
-		if blobsAndProofs == nil {
-			return nil, wrapWithBlockRoot(errMissingBlobsAndProofsFromEL, blockRoot, "")
-		}
-
-		blobs, cellProofs = append(blobs, blobsAndProofs.Blob), append(cellProofs, blobsAndProofs.KzgProofs...)
-	}
-
-	// Construct the data column sidcars from the blobs and cell proofs provided by the execution client.
-	dataColumnSidecars, err := peerdas.ConstructDataColumnSidecars(signedROBlock, blobs, cellProofs)
+	// Compute cells and proofs from the blobs and cell proofs.
+	cellsAndProofs, err := peerdas.ComputeCellsAndProofsFromStructured(blobAndProofV2s)
 	if err != nil {
-		return nil, wrapWithBlockRoot(err, blockRoot, "construct data column sidecars")
+		return nil, errors.Wrap(err, "compute cells and proofs")
 	}
 
-	// Finally, construct verified RO data column sidecars.
-	// We trust the execution layer we are connected to, so we can upgrade the read only data column sidecar into a verified one.
-	verifiedRODataColumns := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecars))
-	for _, dataColumnSidecar := range dataColumnSidecars {
-		roDataColumn, err := blocks.NewRODataColumnWithRoot(dataColumnSidecar, blockRoot)
-		if err != nil {
-			return nil, wrapWithBlockRoot(err, blockRoot, "new read-only data column with root")
-		}
+	return cellsAndProofs, nil
+}
 
-		verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
+// upgradeSidecarsToVerifiedSidecars upgrades a list of data column sidecars into verified data column sidecars.
+func upgradeSidecarsToVerifiedSidecars(roSidecars []blocks.RODataColumn) []blocks.VerifiedRODataColumn {
+	verifiedRODataColumns := make([]blocks.VerifiedRODataColumn, 0, len(roSidecars))
+	for _, roSidecar := range roSidecars {
+		verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roSidecar)
 		verifiedRODataColumns = append(verifiedRODataColumns, verifiedRODataColumn)
 	}
 
-	log.Debug("Data columns successfully reconstructed from the execution client")
-
-	return verifiedRODataColumns, nil
+	return verifiedRODataColumns
 }
 
 func fullPayloadFromPayloadBody(
@@ -1009,6 +1010,6 @@ func toBlockNumArg(number *big.Int) string {
 }
 
 // wrapWithBlockRoot returns a new error with the given block root.
-func wrapWithBlockRoot(err error, blockRoot [32]byte, message string) error {
+func wrapWithBlockRoot(err error, blockRoot [fieldparams.RootLength]byte, message string) error {
 	return errors.Wrap(err, fmt.Sprintf("%s for block %#x", message, blockRoot))
 }

beacon-chain/execution/engine_client_test.go

@@ -14,6 +14,7 @@ import (
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	mocks "github.com/OffchainLabs/prysm/v6/beacon-chain/execution/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
@@ -2556,7 +2557,7 @@ func TestReconstructBlobSidecars(t *testing.T) {
 	})
 }
 
-func TestReconstructDataColumnSidecars(t *testing.T) {
+func TestConstructDataColumnSidecars(t *testing.T) {
 	// Start the trusted setup.
 	err := kzg.Start()
 	require.NoError(t, err)
@@ -2580,11 +2581,14 @@ func TestReconstructDataColumnSidecars(t *testing.T) {
 	sb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
 
+	roBlock, err := blocks.NewROBlockWithRoot(sb, r)
+	require.NoError(t, err)
+
 	ctx := context.Background()
 
 	t.Run("GetBlobsV2 is not supported", func(t *testing.T) {
-		_, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
-		require.ErrorContains(t, "get blobs V2 for block", err)
+		_, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
+		require.ErrorContains(t, "engine_getBlobsV2 is not supported", err)
 	})
 
 	t.Run("nothing received", func(t *testing.T) {
@@ -2594,7 +2598,7 @@ func TestReconstructDataColumnSidecars(t *testing.T) {
 		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
 		defer rpcClient.Close()
 
-		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
+		dataColumns, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
 		require.NoError(t, err)
 		require.Equal(t, 0, len(dataColumns))
 	})
@@ -2607,23 +2611,22 @@ func TestReconstructDataColumnSidecars(t *testing.T) {
 		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
 		defer rpcClient.Close()
 
-		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
+		dataColumns, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
 		require.NoError(t, err)
 		require.Equal(t, 128, len(dataColumns))
 	})
 
-	t.Run("missing some blobs", func(t *testing.T) {
-		blobMasks := []bool{false, true, true, true, true, true}
-		srv := createBlobServerV2(t, 6, blobMasks)
-		defer srv.Close()
+	// t.Run("missing some blobs", func(t *testing.T) {
+	// 	blobMasks := []bool{false, true, true, true, true, true}
+	// 	srv := createBlobServerV2(t, 6, blobMasks)
+	// 	defer srv.Close()
 
-		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
-		defer rpcClient.Close()
+	// 	rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+	// 	defer rpcClient.Close()
 
-		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
-		require.ErrorContains(t, errMissingBlobsAndProofsFromEL.Error(), err)
-		require.Equal(t, 0, len(dataColumns))
-	})
+	// 	_, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
+	// 	require.ErrorContains(t, "fetch cells and proofs from execution client", err)
+	// })
 }
 
 func createRandomKzgCommitments(t *testing.T, num int) [][]byte {

beacon-chain/execution/testing/BUILD.bazel

@@ -14,6 +14,7 @@ go_library(
     ],
     deps = [
         "//async/event:go_default_library",
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/execution/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",

beacon-chain/execution/testing/mock_engine_client.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"math/big"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
@@ -116,7 +117,8 @@ func (e *EngineClient) ReconstructBlobSidecars(context.Context, interfaces.ReadO
 	return e.BlobSidecars, e.ErrorBlobSidecars
 }
 
-func (e *EngineClient) ReconstructDataColumnSidecars(context.Context, interfaces.ReadOnlySignedBeaconBlock, [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error) {
+// ConstructDataColumnSidecars is a mock implementation of the ConstructDataColumnSidecars method.
+func (e *EngineClient) ConstructDataColumnSidecars(context.Context, peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error) {
 	return e.DataColumnSidecars, e.ErrorDataColumnSidecars
 }
 

beacon-chain/forkchoice/doubly-linked-tree/forkchoice.go

@@ -463,22 +463,20 @@ func (f *ForkChoice) CommonAncestor(ctx context.Context, r1 [32]byte, r2 [32]byt
 }
 
 // InsertChain inserts all nodes corresponding to blocks in the slice
-// `blocks`. This slice must be ordered from child to parent. It includes all
-// blocks **except** the first one (that is the one with the highest slot
-// number). All blocks are assumed to be a strict chain
-// where blocks[i].Parent = blocks[i+1]. Also, we assume that the parent of the
-// last block in this list is already included in forkchoice store.
+// `blocks`. This slice must be ordered in increasing slot order and
+// each consecutive entry must be a child of the previous one.
+// The parent of the first block in this list must already be present in forkchoice.
 func (f *ForkChoice) InsertChain(ctx context.Context, chain []*forkchoicetypes.BlockAndCheckpoints) error {
 	if len(chain) == 0 {
 		return nil
 	}
-	for i := len(chain) - 1; i > 0; i-- {
+	for _, bcp := range chain {
 		if _, err := f.store.insert(ctx,
-			chain[i].Block,
-			chain[i].JustifiedCheckpoint.Epoch, chain[i].FinalizedCheckpoint.Epoch); err != nil {
+			bcp.Block,
+			bcp.JustifiedCheckpoint.Epoch, bcp.FinalizedCheckpoint.Epoch); err != nil {
 			return err
 		}
-		if err := f.updateCheckpoints(ctx, chain[i].JustifiedCheckpoint, chain[i].FinalizedCheckpoint); err != nil {
+		if err := f.updateCheckpoints(ctx, bcp.JustifiedCheckpoint, bcp.FinalizedCheckpoint); err != nil {
 			return err
 		}
 	}

beacon-chain/forkchoice/doubly-linked-tree/forkchoice_test.go

@@ -630,14 +630,15 @@ func TestStore_InsertChain(t *testing.T) {
 			FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
 		})
 	}
-	args := make([]*forkchoicetypes.BlockAndCheckpoints, 10)
-	for i := 0; i < len(blks); i++ {
-		args[i] = blks[10-i-1]
-	}
-	require.NoError(t, f.InsertChain(t.Context(), args))
+	// InsertChain now expects blocks in increasing slot order
+	require.NoError(t, f.InsertChain(t.Context(), blks))
 
+	// Test partial insertion: first insert the foundation blocks, then a subset
 	f = setup(1, 1)
-	require.NoError(t, f.InsertChain(t.Context(), args[2:]))
+	// Insert first 2 blocks to establish a chain from genesis
+	require.NoError(t, f.InsertChain(t.Context(), blks[:2]))
+	// Then insert the remaining blocks
+	require.NoError(t, f.InsertChain(t.Context(), blks[2:]))
 }
 
 func TestForkChoice_UpdateCheckpoints(t *testing.T) {

beacon-chain/light-client/BUILD.bazel

@@ -3,11 +3,12 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "cache.go",
         "helpers.go",
         "lightclient.go",
         "store.go",
     ],
-    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client",
+    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client",
     visibility = ["//visibility:public"],
     deps = [
         "//async/event:go_default_library",
@@ -38,25 +39,30 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
+        "cache_test.go",
         "lightclient_test.go",
         "store_test.go",
     ],
+    embed = [":go_default_library"],
     deps = [
-        ":go_default_library",
         "//async/event:go_default_library",
+        "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/p2p/testing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/light-client:go_default_library",
+        "//consensus-types/primitives:go_default_library",
         "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
 )

beacon-chain/light-client/cache.go

@@ -0,0 +1,26 @@
+package light_client
+
+import (
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+)
+
+// cache tracks LC data over the non finalized chain for different branches.
+type cache struct {
+	items map[[32]byte]*cacheItem
+}
+
+// cacheItem represents the LC data for a block. It tracks the best update and finality update seen in that branch.
+type cacheItem struct {
+	parent             *cacheItem      // parent item in the cache, can be nil
+	period             uint64          // sync committee period
+	slot               primitives.Slot // slot of the signature block
+	bestUpdate         interfaces.LightClientUpdate
+	bestFinalityUpdate interfaces.LightClientFinalityUpdate
+}
+
+func newLightClientCache() *cache {
+	return &cache{
+		items: make(map[[32]byte]*cacheItem),
+	}
+}

beacon-chain/light-client/cache_test.go

@@ -0,0 +1,24 @@
+package light_client
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+)
+
+func TestLCCache(t *testing.T) {
+	lcCache := newLightClientCache()
+	require.NotNil(t, lcCache)
+
+	item := &cacheItem{
+		period:             5,
+		bestUpdate:         nil,
+		bestFinalityUpdate: nil,
+	}
+
+	blkRoot := [32]byte{4, 5, 6}
+
+	lcCache.items[blkRoot] = item
+
+	require.Equal(t, item, lcCache.items[blkRoot], "Expected to find the item in the cache")
+}

beacon-chain/light-client/lightclient.go

@@ -592,6 +592,10 @@ func HasFinality(update interfaces.LightClientUpdate) (bool, error) {
 }
 
 func IsBetterUpdate(newUpdate, oldUpdate interfaces.LightClientUpdate) (bool, error) {
+	if oldUpdate == nil || oldUpdate.IsNil() {
+		return true, nil
+	}
+
 	maxActiveParticipants := newUpdate.SyncAggregate().SyncCommitteeBits.Len()
 	newNumActiveParticipants := newUpdate.SyncAggregate().SyncCommitteeBits.Count()
 	oldNumActiveParticipants := oldUpdate.SyncAggregate().SyncCommitteeBits.Count()
@@ -778,7 +782,7 @@ func IsFinalityUpdateValidForBroadcast(newUpdate, oldUpdate interfaces.LightClie
 // This does not concern broadcasting, but rather the decision of whether to save the new update.
 // For broadcasting checks, use IsFinalityUpdateValidForBroadcast.
 func IsBetterFinalityUpdate(newUpdate, oldUpdate interfaces.LightClientFinalityUpdate) bool {
-	if oldUpdate == nil {
+	if oldUpdate == nil || oldUpdate.IsNil() {
 		return true
 	}
 
@@ -804,7 +808,7 @@ func IsBetterFinalityUpdate(newUpdate, oldUpdate interfaces.LightClientFinalityU
 }
 
 func IsBetterOptimisticUpdate(newUpdate, oldUpdate interfaces.LightClientOptimisticUpdate) bool {
-	if oldUpdate == nil {
+	if oldUpdate == nil || oldUpdate.IsNil() {
 		return true
 	}
 	// The attested_header.beacon.slot is greater than that of all previously forwarded optimistic updates

beacon-chain/light-client/lightclient_test.go

@@ -9,7 +9,7 @@ import (
 	light_client "github.com/OffchainLabs/prysm/v6/consensus-types/light-client"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	consensustypes "github.com/OffchainLabs/prysm/v6/consensus-types"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"

beacon-chain/light-client/store.go

@@ -0,0 +1,383 @@
+package light_client
+
+import (
+	"context"
+	"sync"
+
+	"github.com/OffchainLabs/prysm/v6/async/event"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
+	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
+	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
+)
+
+var ErrLightClientBootstrapNotFound = errors.New("light client bootstrap not found")
+
+type Store struct {
+	mu sync.RWMutex
+
+	beaconDB             iface.HeadAccessDatabase
+	lastFinalityUpdate   interfaces.LightClientFinalityUpdate   // tracks the best finality update seen so far
+	lastOptimisticUpdate interfaces.LightClientOptimisticUpdate // tracks the best optimistic update seen so far
+	p2p                  p2p.Accessor
+	stateFeed            event.SubscriberSender
+	cache                *cache // non finality cache
+}
+
+func NewLightClientStore(p p2p.Accessor, e event.SubscriberSender, db iface.HeadAccessDatabase) *Store {
+	return &Store{
+		beaconDB:  db,
+		p2p:       p,
+		stateFeed: e,
+		cache:     newLightClientCache(),
+	}
+}
+
+func (s *Store) SaveLCData(ctx context.Context,
+	state state.BeaconState,
+	block interfaces.ReadOnlySignedBeaconBlock,
+	attestedState state.BeaconState,
+	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
+	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
+	headBlockRoot [32]byte) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// compute required data
+	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create light client update")
+	}
+	finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create light client finality update")
+	}
+	optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create light client optimistic update")
+	}
+	period := slots.SyncCommitteePeriod(slots.ToEpoch(update.AttestedHeader().Beacon().Slot))
+	blockRoot, err := attestedBlock.Block().HashTreeRoot()
+	if err != nil {
+		return errors.Wrapf(err, "failed to compute attested block root")
+	}
+	parentRoot := [32]byte(update.AttestedHeader().Beacon().ParentRoot)
+	signatureBlockRoot, err := block.Block().HashTreeRoot()
+	if err != nil {
+		return errors.Wrapf(err, "failed to compute signature block root")
+	}
+
+	newBlockIsHead := signatureBlockRoot == headBlockRoot
+
+	// create the new cache item
+	newCacheItem := &cacheItem{
+		period: period,
+		slot:   attestedBlock.Block().Slot(),
+	}
+
+	// check if parent exists in cache
+	parentItem, ok := s.cache.items[parentRoot]
+	if ok {
+		newCacheItem.parent = parentItem
+	} else {
+		// if not, create an item for the parent, but don't need to save it since it's the accumulated best update and is just used for comparison
+		bestUpdateSoFar, err := s.beaconDB.LightClientUpdate(ctx, period)
+		if err != nil {
+			return errors.Wrapf(err, "could not get best light client update for period %d", period)
+		}
+		parentItem = &cacheItem{
+			period:             period,
+			bestUpdate:         bestUpdateSoFar,
+			bestFinalityUpdate: s.lastFinalityUpdate,
+		}
+	}
+
+	// if at a period boundary, no need to compare data, just save new ones
+	if parentItem.period != period {
+		newCacheItem.bestUpdate = update
+		newCacheItem.bestFinalityUpdate = finalityUpdate
+		s.cache.items[blockRoot] = newCacheItem
+
+		s.setLastOptimisticUpdate(optimisticUpdate, true)
+
+		// if the new block is not head, we don't want to change our lastFinalityUpdate
+		if newBlockIsHead {
+			s.setLastFinalityUpdate(finalityUpdate, true)
+		}
+
+		return nil
+	}
+
+	// if in the same period, compare updates
+	isUpdateBetter, err := IsBetterUpdate(update, parentItem.bestUpdate)
+	if err != nil {
+		return errors.Wrapf(err, "could not compare light client updates")
+	}
+	if isUpdateBetter {
+		newCacheItem.bestUpdate = update
+	} else {
+		newCacheItem.bestUpdate = parentItem.bestUpdate
+	}
+
+	isBetterFinalityUpdate := IsBetterFinalityUpdate(finalityUpdate, parentItem.bestFinalityUpdate)
+	if isBetterFinalityUpdate {
+		newCacheItem.bestFinalityUpdate = finalityUpdate
+	} else {
+		newCacheItem.bestFinalityUpdate = parentItem.bestFinalityUpdate
+	}
+
+	// save new item in cache
+	s.cache.items[blockRoot] = newCacheItem
+
+	// save lastOptimisticUpdate if better
+	if isBetterOptimisticUpdate := IsBetterOptimisticUpdate(optimisticUpdate, s.lastOptimisticUpdate); isBetterOptimisticUpdate {
+		s.setLastOptimisticUpdate(optimisticUpdate, true)
+	}
+
+	// if the new block is considered the head, set the last finality update
+	if newBlockIsHead {
+		s.setLastFinalityUpdate(newCacheItem.bestFinalityUpdate, isBetterFinalityUpdate)
+	}
+
+	return nil
+}
+
+func (s *Store) LightClientBootstrap(ctx context.Context, blockRoot [32]byte) (interfaces.LightClientBootstrap, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	// Fetch the light client bootstrap from the database
+	bootstrap, err := s.beaconDB.LightClientBootstrap(ctx, blockRoot[:])
+	if err != nil {
+		return nil, err
+	}
+	if bootstrap == nil { // not found
+		return nil, ErrLightClientBootstrapNotFound
+	}
+
+	return bootstrap, nil
+}
+
+func (s *Store) SaveLightClientBootstrap(ctx context.Context, blockRoot [32]byte, state state.BeaconState) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	blk, err := s.beaconDB.Block(ctx, blockRoot)
+	if err != nil {
+		return errors.Wrapf(err, "failed to fetch block for root %x", blockRoot)
+	}
+	if blk == nil {
+		return errors.Errorf("nil block for root %x", blockRoot)
+	}
+
+	bootstrap, err := NewLightClientBootstrapFromBeaconState(ctx, state.Slot(), state, blk)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create light client bootstrap for block root %x", blockRoot)
+	}
+
+	// Save the light client bootstrap to the database
+	if err := s.beaconDB.SaveLightClientBootstrap(ctx, blockRoot[:], bootstrap); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64, headBlock interfaces.ReadOnlySignedBeaconBlock) ([]interfaces.LightClientUpdate, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	// Fetch the light client updatesMap from the database
+	updatesMap, err := s.beaconDB.LightClientUpdates(ctx, startPeriod, endPeriod)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get updates from the database")
+	}
+
+	cacheUpdatesByPeriod, err := s.getCacheUpdatesByPeriod(headBlock)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get updates from cache")
+	}
+
+	for period, update := range cacheUpdatesByPeriod {
+		updatesMap[period] = update
+	}
+
+	var updates []interfaces.LightClientUpdate
+
+	for i := startPeriod; i <= endPeriod; i++ {
+		update, ok := updatesMap[i]
+		if !ok {
+			// Only return the first contiguous range of updates
+			break
+		}
+		updates = append(updates, update)
+	}
+
+	return updates, nil
+}
+
+func (s *Store) LightClientUpdate(ctx context.Context, period uint64, headBlock interfaces.ReadOnlySignedBeaconBlock) (interfaces.LightClientUpdate, error) {
+	// we don't need to lock here because the LightClientUpdates method locks the store
+	updates, err := s.LightClientUpdates(ctx, period, period, headBlock)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get light client update for period %d", period)
+	}
+	if len(updates) == 0 {
+		return nil, nil
+	}
+	return updates[0], nil
+}
+
+func (s *Store) getCacheUpdatesByPeriod(headBlock interfaces.ReadOnlySignedBeaconBlock) (map[uint64]interfaces.LightClientUpdate, error) {
+	updatesByPeriod := make(map[uint64]interfaces.LightClientUpdate)
+
+	cacheHeadRoot := headBlock.Block().ParentRoot()
+
+	cacheHeadItem, ok := s.cache.items[cacheHeadRoot]
+	if !ok {
+		log.Debugf("Head root %x not found in light client cache. Returning empty updates map for non finality cache.", cacheHeadRoot)
+		return updatesByPeriod, nil
+	}
+
+	for cacheHeadItem != nil {
+		if _, exists := updatesByPeriod[cacheHeadItem.period]; !exists {
+			updatesByPeriod[cacheHeadItem.period] = cacheHeadItem.bestUpdate
+		}
+		cacheHeadItem = cacheHeadItem.parent
+	}
+
+	return updatesByPeriod, nil
+}
+
+func (s *Store) SetLastFinalityUpdate(update interfaces.LightClientFinalityUpdate, broadcast bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.setLastFinalityUpdate(update, broadcast)
+}
+
+func (s *Store) setLastFinalityUpdate(update interfaces.LightClientFinalityUpdate, broadcast bool) {
+	if broadcast && IsFinalityUpdateValidForBroadcast(update, s.lastFinalityUpdate) {
+		if err := s.p2p.BroadcastLightClientFinalityUpdate(context.Background(), update); err != nil {
+			log.WithError(err).Error("Could not broadcast light client finality update")
+		}
+	}
+
+	s.lastFinalityUpdate = update
+	log.Debug("Saved new light client finality update")
+
+	s.stateFeed.Send(&feed.Event{
+		Type: statefeed.LightClientFinalityUpdate,
+		Data: update,
+	})
+}
+
+func (s *Store) LastFinalityUpdate() interfaces.LightClientFinalityUpdate {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.lastFinalityUpdate
+}
+
+func (s *Store) SetLastOptimisticUpdate(update interfaces.LightClientOptimisticUpdate, broadcast bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.setLastOptimisticUpdate(update, broadcast)
+}
+
+func (s *Store) setLastOptimisticUpdate(update interfaces.LightClientOptimisticUpdate, broadcast bool) {
+	if broadcast {
+		if err := s.p2p.BroadcastLightClientOptimisticUpdate(context.Background(), update); err != nil {
+			log.WithError(err).Error("Could not broadcast light client optimistic update")
+		}
+	}
+
+	s.lastOptimisticUpdate = update
+	log.Debug("Saved new light client optimistic update")
+
+	s.stateFeed.Send(&feed.Event{
+		Type: statefeed.LightClientOptimisticUpdate,
+		Data: update,
+	})
+}
+
+func (s *Store) LastOptimisticUpdate() interfaces.LightClientOptimisticUpdate {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.lastOptimisticUpdate
+}
+
+func (s *Store) MigrateToCold(ctx context.Context, finalizedRoot [32]byte) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// If there cache is empty (some problem in processing data), we can skip migration.
+	// This is a safety check and should not happen in normal operation.
+	if len(s.cache.items) == 0 {
+		log.Debug("Non-finality cache is empty. Skipping migration.")
+		return nil
+	}
+
+	blk, err := s.beaconDB.Block(ctx, finalizedRoot)
+	if err != nil {
+		return errors.Wrapf(err, "failed to fetch block for finalized root %x", finalizedRoot)
+	}
+	if blk == nil {
+		return errors.Errorf("nil block for finalized root %x", finalizedRoot)
+	}
+	finalizedSlot := blk.Block().Slot()
+	finalizedCacheHeadRoot := blk.Block().ParentRoot()
+
+	var finalizedCacheHead *cacheItem
+	var ok bool
+
+	finalizedCacheHead, ok = s.cache.items[finalizedCacheHeadRoot]
+	if !ok {
+		log.Debugf("Finalized block's parent root %x not found in light client cache. Cleaning the broken part of the cache.", finalizedCacheHeadRoot)
+
+		// delete non-finality cache items older than finalized slot
+		s.cleanCache(finalizedSlot)
+
+		return nil
+	}
+
+	updateByPeriod := make(map[uint64]interfaces.LightClientUpdate)
+	// Traverse the cache from the head item to the tail, collecting updates
+	for item := finalizedCacheHead; item != nil; item = item.parent {
+		if _, seen := updateByPeriod[item.period]; seen {
+			// We already have an update for this period, skip this item
+			continue
+		}
+		updateByPeriod[item.period] = item.bestUpdate
+	}
+
+	// save updates to db
+	for period, update := range updateByPeriod {
+		err = s.beaconDB.SaveLightClientUpdate(ctx, period, update)
+		if err != nil {
+			log.WithError(err).Errorf("failed to save light client update for period %d. Skipping this period.", period)
+		}
+	}
+
+	// delete non-finality cache items older than finalized slot
+	s.cleanCache(finalizedSlot)
+
+	return nil
+}
+
+func (s *Store) cleanCache(finalizedSlot primitives.Slot) {
+	// delete non-finality cache items older than finalized slot
+	for k, v := range s.cache.items {
+		if v.slot < finalizedSlot {
+			delete(s.cache.items, k)
+		}
+		if v.parent != nil && v.parent.slot < finalizedSlot {
+			v.parent = nil // remove parent reference
+		}
+	}
+}

beacon-chain/light-client/store_test.go

@@ -0,0 +1,959 @@
+package light_client
+
+import (
+	"context"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/async/event"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
+	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
+	p2pTesting "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
+)
+
+func TestLightClientStore(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig()
+	cfg.AltairForkEpoch = 1
+	cfg.BellatrixForkEpoch = 2
+	cfg.CapellaForkEpoch = 3
+	cfg.DenebForkEpoch = 4
+	cfg.ElectraForkEpoch = 5
+	params.OverrideBeaconConfig(cfg)
+
+	// Initialize the light client store
+	lcStore := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), testDB.SetupDB(t))
+
+	// Create test light client updates for Capella and Deneb
+	lCapella := util.NewTestLightClient(t, version.Capella)
+	opUpdateCapella, err := NewLightClientOptimisticUpdateFromBeaconState(lCapella.Ctx, lCapella.State, lCapella.Block, lCapella.AttestedState, lCapella.AttestedBlock)
+	require.NoError(t, err)
+	require.NotNil(t, opUpdateCapella, "OptimisticUpdateCapella is nil")
+	finUpdateCapella, err := NewLightClientFinalityUpdateFromBeaconState(lCapella.Ctx, lCapella.State, lCapella.Block, lCapella.AttestedState, lCapella.AttestedBlock, lCapella.FinalizedBlock)
+	require.NoError(t, err)
+	require.NotNil(t, finUpdateCapella, "FinalityUpdateCapella is nil")
+
+	lDeneb := util.NewTestLightClient(t, version.Deneb)
+	opUpdateDeneb, err := NewLightClientOptimisticUpdateFromBeaconState(lDeneb.Ctx, lDeneb.State, lDeneb.Block, lDeneb.AttestedState, lDeneb.AttestedBlock)
+	require.NoError(t, err)
+	require.NotNil(t, opUpdateDeneb, "OptimisticUpdateDeneb is nil")
+	finUpdateDeneb, err := NewLightClientFinalityUpdateFromBeaconState(lDeneb.Ctx, lDeneb.State, lDeneb.Block, lDeneb.AttestedState, lDeneb.AttestedBlock, lDeneb.FinalizedBlock)
+	require.NoError(t, err)
+	require.NotNil(t, finUpdateDeneb, "FinalityUpdateDeneb is nil")
+
+	// Initially the store should have nil values for both updates
+	require.IsNil(t, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should be nil")
+	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
+
+	// Set and get finality with Capella update. Optimistic update should be nil
+	lcStore.SetLastFinalityUpdate(finUpdateCapella, false)
+	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
+	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
+
+	// Set and get optimistic with Capella update. Finality update should be Capella
+	lcStore.SetLastOptimisticUpdate(opUpdateCapella, false)
+	require.Equal(t, opUpdateCapella, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
+	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
+
+	// Set and get finality and optimistic with Deneb update
+	lcStore.SetLastFinalityUpdate(finUpdateDeneb, false)
+	lcStore.SetLastOptimisticUpdate(opUpdateDeneb, false)
+	require.Equal(t, finUpdateDeneb, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
+	require.Equal(t, opUpdateDeneb, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
+}
+
+func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
+	p2p := p2pTesting.NewTestP2P(t)
+	lcStore := NewLightClientStore(p2p, new(event.Feed), testDB.SetupDB(t))
+
+	// update 0 with basic data and no supermajority following an empty lastFinalityUpdate - should save and broadcast
+	l0 := util.NewTestLightClient(t, version.Altair)
+	update0, err := NewLightClientFinalityUpdateFromBeaconState(l0.Ctx, l0.State, l0.Block, l0.AttestedState, l0.AttestedBlock, l0.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, IsBetterFinalityUpdate(update0, lcStore.LastFinalityUpdate()), "update0 should be better than nil")
+	// update0 should be valid for broadcast - meaning it should be broadcasted
+	require.Equal(t, true, IsFinalityUpdateValidForBroadcast(update0, lcStore.LastFinalityUpdate()), "update0 should be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update0, true)
+	require.Equal(t, update0, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update when previous is nil")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 1 with same finality slot, increased attested slot, and no supermajority - should save but not broadcast
+	l1 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1))
+	update1, err := NewLightClientFinalityUpdateFromBeaconState(l1.Ctx, l1.State, l1.Block, l1.AttestedState, l1.AttestedBlock, l1.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, IsBetterFinalityUpdate(update1, update0), "update1 should be better than update0")
+	// update1 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, IsFinalityUpdateValidForBroadcast(update1, lcStore.LastFinalityUpdate()), "update1 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update1, true)
+	require.Equal(t, update1, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called after setting a new last finality update without supermajority")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 2 with same finality slot, increased attested slot, and supermajority - should save and broadcast
+	l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(2), util.WithSupermajority(0))
+	update2, err := NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, IsBetterFinalityUpdate(update2, update1), "update2 should be better than update1")
+	// update2 should be valid for broadcast - meaning it should be broadcasted
+	require.Equal(t, true, IsFinalityUpdateValidForBroadcast(update2, lcStore.LastFinalityUpdate()), "update2 should be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update2, true)
+	require.Equal(t, update2, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update with supermajority")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 3 with same finality slot, increased attested slot, and supermajority - should save but not broadcast
+	l3 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(3), util.WithSupermajority(0))
+	update3, err := NewLightClientFinalityUpdateFromBeaconState(l3.Ctx, l3.State, l3.Block, l3.AttestedState, l3.AttestedBlock, l3.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, IsBetterFinalityUpdate(update3, update2), "update3 should be better than update2")
+	// update3 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, IsFinalityUpdateValidForBroadcast(update3, lcStore.LastFinalityUpdate()), "update3 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update3, true)
+	require.Equal(t, update3, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been when previous was already broadcast")
+
+	// update 4 with increased finality slot, increased attested slot, and supermajority - should save and broadcast
+	l4 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(1), util.WithSupermajority(0))
+	update4, err := NewLightClientFinalityUpdateFromBeaconState(l4.Ctx, l4.State, l4.Block, l4.AttestedState, l4.AttestedBlock, l4.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, IsBetterFinalityUpdate(update4, update3), "update4 should be better than update3")
+	// update4 should be valid for broadcast - meaning it should be broadcasted
+	require.Equal(t, true, IsFinalityUpdateValidForBroadcast(update4, lcStore.LastFinalityUpdate()), "update4 should be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update4, true)
+	require.Equal(t, update4, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after a new finality update with increased finality slot")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 5 with the same new finality slot, increased attested slot, and supermajority - should save but not broadcast
+	l5 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(2), util.WithSupermajority(0))
+	update5, err := NewLightClientFinalityUpdateFromBeaconState(l5.Ctx, l5.State, l5.Block, l5.AttestedState, l5.AttestedBlock, l5.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, IsBetterFinalityUpdate(update5, update4), "update5 should be better than update4")
+	// update5 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, IsFinalityUpdateValidForBroadcast(update5, lcStore.LastFinalityUpdate()), "update5 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update5, true)
+	require.Equal(t, update5, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
+
+	// update 6 with the same new finality slot, increased attested slot, and no supermajority - should save but not broadcast
+	l6 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(3))
+	update6, err := NewLightClientFinalityUpdateFromBeaconState(l6.Ctx, l6.State, l6.Block, l6.AttestedState, l6.AttestedBlock, l6.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, IsBetterFinalityUpdate(update6, update5), "update6 should be better than update5")
+	// update6 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, IsFinalityUpdateValidForBroadcast(update6, lcStore.LastFinalityUpdate()), "update6 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update6, true)
+	require.Equal(t, update6, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
+}
+
+func TestLightClientStore_SaveLCData(t *testing.T) {
+	t.Run("no parent in cache or db - new is head", func(t *testing.T) {
+		db := testDB.SetupDB(t)
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+
+		blkRoot, err := l.Block.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.NoError(t, s.SaveLCData(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, blkRoot), "Failed to save light client data")
+
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
+		require.NoError(t, err)
+		attstedBlkRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.DeepEqual(t, finalityUpdate, s.lastFinalityUpdate, "Expected to find the last finality update in the store")
+		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
+		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
+		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
+	})
+
+	t.Run("no parent in cache or db - new not head", func(t *testing.T) {
+		db := testDB.SetupDB(t)
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+
+		blkRoot, err := l.FinalizedBlock.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.NoError(t, s.SaveLCData(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, blkRoot), "Failed to save light client data")
+
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
+		require.NoError(t, err)
+		attstedBlkRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.IsNil(t, s.lastFinalityUpdate, "Expected to not find the last finality update in the store since the block is not head")
+		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
+		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
+		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
+	})
+
+	t.Run("parent in db", func(t *testing.T) {
+		db := testDB.SetupDB(t)
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+
+		// save an update for this period in db
+		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		require.NoError(t, db.SaveLightClientUpdate(l.Ctx, period, update), "Failed to save light client update in db")
+
+		l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1), util.WithSupermajority(0)) // updates from this setup should be all better
+
+		blkRoot, err := l2.Block.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.NoError(t, s.SaveLCData(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock, blkRoot), "Failed to save light client data")
+
+		update, err = NewLightClientUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+		require.NoError(t, err)
+		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+		require.NoError(t, err)
+		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock)
+		require.NoError(t, err)
+		attstedBlkRoot, err := l2.AttestedBlock.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.DeepEqual(t, finalityUpdate, s.lastFinalityUpdate, "Expected to find the last finality update in the store")
+		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
+		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
+		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
+	})
+
+	t.Run("parent in cache", func(t *testing.T) {
+		db := testDB.SetupDB(t)
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+		l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1), util.WithSupermajority(0)) // updates from this setup should be all better
+
+		// save the cache item for this period in cache
+		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		item := &cacheItem{
+			period:             period,
+			bestUpdate:         update,
+			bestFinalityUpdate: finalityUpdate,
+		}
+		attestedBlockRoot := l2.AttestedBlock.Block().ParentRoot() // we want this item to be the parent of the new block
+		s.cache.items[attestedBlockRoot] = item
+
+		blkRoot, err := l2.Block.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.NoError(t, s.SaveLCData(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock, blkRoot), "Failed to save light client data")
+
+		update, err = NewLightClientUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+		require.NoError(t, err)
+		finalityUpdate, err = NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+		require.NoError(t, err)
+		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock)
+		require.NoError(t, err)
+		attstedBlkRoot, err := l2.AttestedBlock.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.DeepEqual(t, finalityUpdate, s.lastFinalityUpdate, "Expected to find the last finality update in the store")
+		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
+		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
+		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
+	})
+
+	t.Run("parent in the previous period", func(t *testing.T) {
+		db := testDB.SetupDB(t)
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+		l2 := util.NewTestLightClient(t, version.Bellatrix, util.WithIncreasedAttestedSlot(1), util.WithSupermajority(0)) // updates from this setup should be all better
+
+		// save the cache item for this period1 in cache
+		period1 := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		item := &cacheItem{
+			period:             period1,
+			bestUpdate:         update,
+			bestFinalityUpdate: finalityUpdate,
+		}
+		attestedBlockRoot := l2.AttestedBlock.Block().ParentRoot() // we want this item to be the parent of the new block
+		s.cache.items[attestedBlockRoot] = item
+
+		blkRoot, err := l2.Block.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.NoError(t, s.SaveLCData(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock, blkRoot), "Failed to save light client data")
+
+		update, err = NewLightClientUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+		require.NoError(t, err)
+		finalityUpdate, err = NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+		require.NoError(t, err)
+		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock)
+		require.NoError(t, err)
+		attstedBlkRoot, err := l2.AttestedBlock.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		require.DeepEqual(t, finalityUpdate, s.lastFinalityUpdate, "Expected to find the last finality update in the store")
+		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
+		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
+		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
+	})
+}
+
+func TestLightClientStore_MigrateToCold(t *testing.T) {
+	// This tests the scenario where chain advances but the cache is empty.
+	// It should see that there is nothing in the cache to migrate and just update the tail to the new finalized root.
+	t.Run("empty cache", func(t *testing.T) {
+		beaconDB := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
+		require.NotNil(t, s)
+
+		for i := 0; i < 3; i++ {
+			newBlock := util.NewBeaconBlock()
+			newBlock.Block.Slot = primitives.Slot(32 + uint64(i))
+			newBlock.Block.ParentRoot = finalizedBlockRoot[:]
+			signedNewBlock, err := blocks.NewSignedBeaconBlock(newBlock)
+			require.NoError(t, err)
+			blockRoot, err := signedNewBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			require.NoError(t, beaconDB.SaveBlock(ctx, signedNewBlock))
+			finalizedBlockRoot = blockRoot
+		}
+
+		err := s.MigrateToCold(ctx, finalizedBlockRoot)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(s.cache.items))
+	})
+
+	// This tests the scenario where chain advances but the CANONICAL cache is empty.
+	// It should see that there is nothing in the canonical cache to migrate and just update the tail to the new finalized root AND delete anything non-canonical.
+	t.Run("non canonical cache", func(t *testing.T) {
+		beaconDB := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
+		require.NotNil(t, s)
+
+		for i := 0; i < 3; i++ {
+			newBlock := util.NewBeaconBlock()
+			newBlock.Block.Slot = primitives.Slot(32 + uint64(i))
+			newBlock.Block.ParentRoot = finalizedBlockRoot[:]
+			signedNewBlock, err := blocks.NewSignedBeaconBlock(newBlock)
+			require.NoError(t, err)
+			blockRoot, err := signedNewBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			require.NoError(t, beaconDB.SaveBlock(ctx, signedNewBlock))
+			finalizedBlockRoot = blockRoot
+		}
+
+		// Add a non-canonical item to the cache
+		cacheItem := &cacheItem{
+			period: 0,
+			slot:   33,
+		}
+		nonCanonicalBlockRoot := [32]byte{1, 2, 3, 4}
+		s.cache.items[nonCanonicalBlockRoot] = cacheItem
+
+		require.Equal(t, 1, len(s.cache.items))
+
+		err := s.MigrateToCold(ctx, finalizedBlockRoot)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(s.cache.items), "Expected the non-canonical item in the cache to be deleted")
+	})
+
+	// db has update - cache has both canonical and non-canonical items.
+	// should update the update in db and delete cache.
+	t.Run("mixed cache - finality immediately after cache", func(t *testing.T) {
+		beaconDB := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
+		require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, finalizedBlockRoot))
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
+		require.NotNil(t, s)
+
+		// Save an update for this period in db
+		l := util.NewTestLightClient(t, version.Altair)
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
+		require.NoError(t, beaconDB.SaveLightClientUpdate(ctx, period, update))
+
+		lastBlockRoot := finalizedBlockRoot
+		lastAttestedRoot := finalizedBlockRoot
+		lastUpdate := update
+		for i := 1; i < 4; i++ {
+			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)), util.WithSupermajority(uint64(i)), util.WithAttestedParentRoot(lastAttestedRoot))
+			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
+			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
+			lastBlockRoot, err = l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			update, err = NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			require.NoError(t, err)
+			lastUpdate = update
+		}
+
+		require.Equal(t, 3, len(s.cache.items))
+
+		// Add a non-canonical item to the cache
+		cacheItem := &cacheItem{
+			period: 0,
+			slot:   33,
+		}
+		nonCanonicalBlockRoot := [32]byte{1, 2, 3, 4}
+		s.cache.items[nonCanonicalBlockRoot] = cacheItem
+
+		require.Equal(t, 4, len(s.cache.items))
+
+		err = s.MigrateToCold(ctx, lastBlockRoot)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(s.cache.items), "Expected the non-canonical item in the cache to be deleted")
+		u, err := beaconDB.LightClientUpdate(ctx, period)
+		require.NoError(t, err)
+		require.NotNil(t, u)
+		require.DeepEqual(t, lastUpdate, u)
+	})
+
+	// db has update - cache has both canonical and non-canonical items. finalized height is in the middle.
+	// should update the update in db and delete items in cache before finalized slot.
+	t.Run("mixed cache - finality middle of cache", func(t *testing.T) {
+		beaconDB := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
+		require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, finalizedBlockRoot))
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
+		require.NotNil(t, s)
+
+		// Save an update for this period in db
+		l := util.NewTestLightClient(t, version.Altair)
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
+		require.NoError(t, beaconDB.SaveLightClientUpdate(ctx, period, update))
+
+		lastBlockRoot := finalizedBlockRoot
+		lastUpdate := update
+		lastAttestedRoot := [32]byte{}
+		for i := 1; i < 4; i++ {
+			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)), util.WithSupermajority(uint64(i)), util.WithAttestedParentRoot(lastAttestedRoot))
+			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
+			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
+			root, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			lastBlockRoot = root
+			update, err = NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			require.NoError(t, err)
+			lastUpdate = update
+			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+		}
+
+		require.Equal(t, 3, len(s.cache.items))
+
+		// Add a non-canonical item to the cache
+		cacheItem := &cacheItem{
+			period: 0,
+			slot:   33,
+		}
+		nonCanonicalBlockRoot := [32]byte{1, 2, 3, 4}
+		s.cache.items[nonCanonicalBlockRoot] = cacheItem
+
+		require.Equal(t, 4, len(s.cache.items))
+
+		for i := 4; i < 7; i++ {
+			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)), util.WithSupermajority(0), util.WithAttestedParentRoot(lastAttestedRoot))
+			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
+			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
+			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+		}
+
+		require.Equal(t, 7, len(s.cache.items))
+
+		err = s.MigrateToCold(ctx, lastBlockRoot)
+		require.NoError(t, err)
+		require.Equal(t, 3, len(s.cache.items), "Expected the non-canonical item in the cache to be deleted")
+		u, err := beaconDB.LightClientUpdate(ctx, period)
+		require.NoError(t, err)
+		require.NotNil(t, u)
+		require.DeepEqual(t, lastUpdate, u)
+	})
+
+	// we have multiple periods in the cache before finalization happens. we expect all of them to be saved in db.
+	t.Run("finality after multiple periods in cache", func(t *testing.T) {
+		beaconDB := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		cfg := params.BeaconConfig().Copy()
+		cfg.EpochsPerSyncCommitteePeriod = 1
+		params.OverrideBeaconConfig(cfg)
+
+		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
+		require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, finalizedBlockRoot))
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
+		require.NotNil(t, s)
+
+		// Save an update for this period1 in db
+		l := util.NewTestLightClient(t, version.Altair)
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+		period1 := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
+		require.NoError(t, beaconDB.SaveLightClientUpdate(ctx, period1, update))
+
+		lastBlockRoot := finalizedBlockRoot
+		lastUpdatePeriod1 := update
+		lastAttestedRoot := [32]byte{}
+		for i := 1; i < 4; i++ {
+			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)), util.WithSupermajority(uint64(i)), util.WithAttestedParentRoot(lastAttestedRoot))
+			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
+			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
+			root, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			lastBlockRoot = root
+			lastUpdatePeriod1, err = NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			require.NoError(t, err)
+			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+		}
+
+		period2 := period1
+		var lastUpdatePeriod2 interfaces.LightClientUpdate
+		for i := 1; i < 4; i++ {
+			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)+33), util.WithSupermajority(uint64(i)), util.WithAttestedParentRoot(lastAttestedRoot))
+			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
+			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
+			root, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			lastBlockRoot = root
+			lastUpdatePeriod2, err = NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+			require.NoError(t, err)
+			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			period2 = slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
+		}
+
+		require.Equal(t, 6, len(s.cache.items))
+
+		// Add a non-canonical item to the cache
+		cacheItem := &cacheItem{
+			period: 0,
+			slot:   33,
+		}
+		nonCanonicalBlockRoot := [32]byte{1, 2, 3, 4}
+		s.cache.items[nonCanonicalBlockRoot] = cacheItem
+
+		require.Equal(t, 7, len(s.cache.items))
+
+		for i := 4; i < 7; i++ {
+			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)+33), util.WithSupermajority(0), util.WithAttestedParentRoot(lastAttestedRoot))
+			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
+			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
+			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+		}
+
+		require.Equal(t, 10, len(s.cache.items))
+
+		err = s.MigrateToCold(ctx, lastBlockRoot)
+		require.NoError(t, err)
+		require.Equal(t, 3, len(s.cache.items), "Expected the non-canonical item in the cache to be deleted")
+		u, err := beaconDB.LightClientUpdate(ctx, period2)
+		require.NoError(t, err)
+		require.NotNil(t, u)
+		require.DeepEqual(t, lastUpdatePeriod2, u)
+		u, err = beaconDB.LightClientUpdate(ctx, period1)
+		require.NoError(t, err)
+		require.NotNil(t, u)
+		require.DeepEqual(t, lastUpdatePeriod1, u)
+	})
+}
+
+func saveInitialFinalizedCheckpointData(t *testing.T, ctx context.Context, beaconDB db.Database) ([32]byte, interfaces.SignedBeaconBlock) {
+	genesis := util.NewBeaconBlock()
+	genesisRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
+	util.SaveBlock(t, ctx, beaconDB, genesis)
+	genesisState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveState(ctx, genesisState, genesisRoot))
+
+	finalizedState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	finalizedBlock := util.NewBeaconBlock()
+	finalizedBlock.Block.Slot = 32
+	finalizedBlock.Block.ParentRoot = genesisRoot[:]
+	signedFinalizedBlock, err := blocks.NewSignedBeaconBlock(finalizedBlock)
+	require.NoError(t, err)
+	finalizedBlockHeader, err := signedFinalizedBlock.Header()
+	require.NoError(t, err)
+	require.NoError(t, finalizedState.SetLatestBlockHeader(finalizedBlockHeader.Header))
+	finalizedStateRoot, err := finalizedState.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	finalizedBlock.Block.StateRoot = finalizedStateRoot[:]
+	signedFinalizedBlock, err = blocks.NewSignedBeaconBlock(finalizedBlock)
+	require.NoError(t, err)
+	finalizedBlockRoot, err := signedFinalizedBlock.Block().HashTreeRoot()
+	require.NoError(t, err)
+	cp := ethpb.Checkpoint{
+		Epoch: 1,
+		Root:  finalizedBlockRoot[:],
+	}
+	require.NoError(t, beaconDB.SaveBlock(ctx, signedFinalizedBlock))
+	require.NoError(t, beaconDB.SaveState(ctx, finalizedState, finalizedBlockRoot))
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &cp))
+
+	return finalizedBlockRoot, signedFinalizedBlock
+}
+
+func TestLightClientStore_LightClientUpdatesByRange(t *testing.T) {
+	t.Run("no updates", func(t *testing.T) {
+		d := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		_, finalizedBlock := saveInitialFinalizedCheckpointData(t, ctx, d)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
+		require.NotNil(t, s)
+
+		updates, err := s.LightClientUpdates(ctx, 2, 5, finalizedBlock)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(updates))
+	})
+
+	t.Run("single update from db", func(t *testing.T) {
+		d := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		_, finalizedBlock := saveInitialFinalizedCheckpointData(t, ctx, d)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 3, update))
+
+		updates, err := s.LightClientUpdates(ctx, 3, 3, finalizedBlock)
+		require.NoError(t, err)
+		require.Equal(t, 1, len(updates))
+		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
+	})
+
+	t.Run("multiple updates from db", func(t *testing.T) {
+		d := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		_, finalizedBlock := saveInitialFinalizedCheckpointData(t, ctx, d)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 3, update))
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 4, update))
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 5, update))
+
+		updates, err := s.LightClientUpdates(ctx, 3, 5, finalizedBlock)
+		require.NoError(t, err)
+		require.Equal(t, 3, len(updates))
+		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
+		require.DeepEqual(t, update, updates[1], "Expected to find the update in the store")
+		require.DeepEqual(t, update, updates[2], "Expected to find the update in the store")
+	})
+
+	t.Run("single update from cache", func(t *testing.T) {
+		d := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+
+		cacheItem := &cacheItem{
+			period:     3,
+			bestUpdate: update,
+		}
+		s.cache.items[[32]byte{3}] = cacheItem
+
+		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{3})
+
+		updates, err := s.LightClientUpdates(ctx, 3, 3, headBlock)
+		require.NoError(t, err)
+		require.Equal(t, 1, len(updates))
+		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
+	})
+
+	t.Run("multiple updates from cache", func(t *testing.T) {
+		d := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+
+		cacheItemP3 := &cacheItem{
+			period:     3,
+			bestUpdate: update,
+		}
+		s.cache.items[[32]byte{3}] = cacheItemP3
+
+		cacheItemP4 := &cacheItem{
+			period:     4,
+			bestUpdate: update,
+			parent:     cacheItemP3,
+		}
+		s.cache.items[[32]byte{4}] = cacheItemP4
+
+		cacheItemP5 := &cacheItem{
+			period:     5,
+			bestUpdate: update,
+			parent:     cacheItemP4,
+		}
+		s.cache.items[[32]byte{5}] = cacheItemP5
+
+		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{5})
+
+		updates, err := s.LightClientUpdates(ctx, 3, 5, headBlock)
+		require.NoError(t, err)
+		require.Equal(t, 3, len(updates))
+		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
+		require.DeepEqual(t, update, updates[1], "Expected to find the update in the store")
+		require.DeepEqual(t, update, updates[2], "Expected to find the update in the store")
+	})
+
+	t.Run("multiple updates from both db and cache - no overlap", func(t *testing.T) {
+		d := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
+		require.NotNil(t, s)
+
+		l := util.NewTestLightClient(t, version.Altair)
+		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+		require.NoError(t, err)
+
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 1, update))
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 2, update))
+
+		cacheItemP3 := &cacheItem{
+			period:     3,
+			bestUpdate: update,
+		}
+		s.cache.items[[32]byte{3}] = cacheItemP3
+
+		cacheItemP4 := &cacheItem{
+			period:     4,
+			bestUpdate: update,
+			parent:     cacheItemP3,
+		}
+		s.cache.items[[32]byte{4}] = cacheItemP4
+
+		cacheItemP5 := &cacheItem{
+			period:     5,
+			bestUpdate: update,
+			parent:     cacheItemP4,
+		}
+		s.cache.items[[32]byte{5}] = cacheItemP5
+
+		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{5})
+
+		updates, err := s.LightClientUpdates(ctx, 1, 5, headBlock)
+		require.NoError(t, err)
+		require.Equal(t, 5, len(updates))
+		for i := 0; i < 5; i++ {
+			require.DeepEqual(t, update, updates[i], "Expected to find the update in the store")
+		}
+	})
+
+	t.Run("multiple updates from both db and cache - overlap", func(t *testing.T) {
+		d := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
+		require.NotNil(t, s)
+
+		l1 := util.NewTestLightClient(t, version.Altair)
+		update1, err := NewLightClientUpdateFromBeaconState(l1.Ctx, l1.State, l1.Block, l1.AttestedState, l1.AttestedBlock, l1.FinalizedBlock)
+		require.NoError(t, err)
+
+		l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1))
+		update2, err := NewLightClientUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+		require.NoError(t, err)
+
+		require.DeepNotEqual(t, update1, update2)
+
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 1, update1))
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 2, update1))
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 3, update1))
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 4, update1))
+
+		cacheItemP3 := &cacheItem{
+			period:     3,
+			bestUpdate: update2,
+		}
+		s.cache.items[[32]byte{3}] = cacheItemP3
+
+		cacheItemP4 := &cacheItem{
+			period:     4,
+			bestUpdate: update2,
+			parent:     cacheItemP3,
+		}
+		s.cache.items[[32]byte{4}] = cacheItemP4
+
+		cacheItemP5 := &cacheItem{
+			period:     5,
+			bestUpdate: update2,
+			parent:     cacheItemP4,
+		}
+		s.cache.items[[32]byte{5}] = cacheItemP5
+
+		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{5})
+
+		updates, err := s.LightClientUpdates(ctx, 1, 5, headBlock)
+		require.NoError(t, err)
+		require.Equal(t, 5, len(updates))
+		// first two updates should be update1
+		for i := 0; i < 2; i++ {
+			require.DeepEqual(t, update1, updates[i], "Expected to find the update in the store")
+		}
+		// next three updates should be update2 - as cache overrides db
+		for i := 2; i < 5; i++ {
+			require.DeepEqual(t, update2, updates[i], "Expected to find the update in the store")
+		}
+	})
+
+	t.Run("first continuous range", func(t *testing.T) {
+		d := testDB.SetupDB(t)
+		ctx := context.Background()
+
+		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
+
+		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
+		require.NotNil(t, s)
+
+		l1 := util.NewTestLightClient(t, version.Altair)
+		update, err := NewLightClientUpdateFromBeaconState(l1.Ctx, l1.State, l1.Block, l1.AttestedState, l1.AttestedBlock, l1.FinalizedBlock)
+		require.NoError(t, err)
+
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 1, update))
+		require.NoError(t, d.SaveLightClientUpdate(ctx, 2, update))
+
+		cacheItemP4 := &cacheItem{
+			period:     4,
+			bestUpdate: update,
+		}
+		s.cache.items[[32]byte{4}] = cacheItemP4
+
+		cacheItemP5 := &cacheItem{
+			period:     5,
+			bestUpdate: update,
+			parent:     cacheItemP4,
+		}
+		s.cache.items[[32]byte{5}] = cacheItemP5
+
+		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{5})
+
+		updates, err := s.LightClientUpdates(ctx, 1, 5, headBlock)
+		require.NoError(t, err)
+		require.Equal(t, 2, len(updates))
+		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
+		require.DeepEqual(t, update, updates[1], "Expected to find the update in the store")
+	})
+
+}
+
+func saveStateAndBlockWithParentRoot(t *testing.T, ctx context.Context, d db.Database, parentRoot [32]byte) ([32]byte, interfaces.SignedBeaconBlock) {
+	blk := util.NewBeaconBlock()
+	blk.Block.ParentRoot = parentRoot[:]
+
+	blkRoot, err := blk.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	util.SaveBlock(t, ctx, d, blk)
+
+	st, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, d.SaveState(ctx, st, blkRoot))
+
+	signedFinalizedBlock, err := blocks.NewSignedBeaconBlock(blk)
+	require.NoError(t, err)
+
+	return blkRoot, signedFinalizedBlock
+}

beacon-chain/node/BUILD.bazel

@@ -23,7 +23,6 @@ go_library(
         "//beacon-chain/builder:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
-        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
@@ -32,6 +31,7 @@ go_library(
         "//beacon-chain/execution:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
+        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/monitor:go_default_library",
         "//beacon-chain/node/registration:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",

beacon-chain/node/node.go

@@ -25,7 +25,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/builder"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache/depositsnapshot"
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/kv"
@@ -34,6 +33,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/monitor"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/node/registration"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
@@ -253,10 +253,6 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 	// their initialization.
 	beacon.finalizedStateAtStartUp = nil
 
-	if features.Get().EnableLightClient {
-		beacon.lcStore = lightclient.NewLightClientStore(beacon.db, beacon.fetchP2P(), beacon.StateFeed())
-	}
-
 	return beacon, nil
 }
 
@@ -349,6 +345,11 @@ func registerServices(cliCtx *cli.Context, beacon *BeaconNode, synchronizer *sta
 		return errors.Wrap(err, "could not register P2P service")
 	}
 
+	if features.Get().EnableLightClient {
+		log.Debugln("Registering Light Client Store")
+		beacon.registerLightClientStore()
+	}
+
 	log.Debugln("Registering Backfill Service")
 	if err := beacon.RegisterBackfillService(cliCtx, bfs); err != nil {
 		return errors.Wrap(err, "could not register Back Fill service")
@@ -1139,6 +1140,11 @@ func (b *BeaconNode) RegisterBackfillService(cliCtx *cli.Context, bfs *backfill.
 	return b.services.RegisterService(bf)
 }
 
+func (b *BeaconNode) registerLightClientStore() {
+	lcs := lightclient.NewLightClientStore(b.fetchP2P(), b.StateFeed(), b.db)
+	b.lcStore = lcs
+}
+
 func hasNetworkFlag(cliCtx *cli.Context) bool {
 	for _, flag := range features.NetworkFlags {
 		for _, name := range flag.Names() {

beacon-chain/node/node_test.go

@@ -74,7 +74,9 @@ func TestNodeStart_Ok(t *testing.T) {
 	set := flag.NewFlagSet("test", 0)
 	set.String("datadir", tmp, "node data directory")
 	set.String("suggested-fee-recipient", "0x6e35733c5af9B61374A128e6F85f553aF09ff89A", "fee recipient")
+	set.Bool("enable-light-client", true, "enable light client")
 	require.NoError(t, set.Set("suggested-fee-recipient", "0x6e35733c5af9B61374A128e6F85f553aF09ff89A"))
+	require.NoError(t, set.Set("enable-light-client", "true"))
 
 	ctx, cancel := newCliContextWithCancel(&app, set)
 
@@ -88,6 +90,7 @@ func TestNodeStart_Ok(t *testing.T) {
 
 	node, err := New(ctx, cancel, options...)
 	require.NoError(t, err)
+	require.NotNil(t, node.lcStore)
 	node.services = &runtime.ServiceRegistry{}
 	go func() {
 		node.Start()

beacon-chain/p2p/BUILD.bazel

@@ -60,6 +60,7 @@ go_library(
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",

beacon-chain/p2p/broadcaster.go

@@ -5,12 +5,14 @@ import (
 	"context"
 	"fmt"
 	"reflect"
+	"strings"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	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"
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
@@ -51,6 +53,7 @@ func (s *Service) Broadcast(ctx context.Context, msg proto.Message) error {
 		tracing.AnnotateError(span, ErrMessageNotMapped)
 		return ErrMessageNotMapped
 	}
+
 	castMsg, ok := msg.(ssz.Marshaler)
 	if !ok {
 		return errors.Errorf("message of %T does not support marshaller interface", msg)
@@ -308,19 +311,13 @@ func (s *Service) BroadcastLightClientFinalityUpdate(ctx context.Context, update
 // BroadcastDataColumnSidecar broadcasts a data column to the p2p network, the message is assumed to be
 // broadcasted to the current fork and to the input column subnet.
 func (s *Service) BroadcastDataColumnSidecar(
-	root [fieldparams.RootLength]byte,
 	dataColumnSubnet uint64,
-	dataColumnSidecar *ethpb.DataColumnSidecar,
+	dataColumnSidecar blocks.VerifiedRODataColumn,
 ) error {
 	// Add tracing to the function.
 	ctx, span := trace.StartSpan(s.ctx, "p2p.BroadcastDataColumnSidecar")
 	defer span.End()
 
-	// Ensure the data column sidecar is not nil.
-	if dataColumnSidecar == nil {
-		return errors.Errorf("attempted to broadcast nil data column sidecar at subnet %d", dataColumnSubnet)
-	}
-
 	// Retrieve the current fork digest.
 	forkDigest, err := s.currentForkDigest()
 	if err != nil {
@@ -330,16 +327,15 @@ func (s *Service) BroadcastDataColumnSidecar(
 	}
 
 	// Non-blocking broadcast, with attempts to discover a column subnet peer if none available.
-	go s.internalBroadcastDataColumnSidecar(ctx, root, dataColumnSubnet, dataColumnSidecar, forkDigest)
+	go s.internalBroadcastDataColumnSidecar(ctx, dataColumnSubnet, dataColumnSidecar, forkDigest)
 
 	return nil
 }
 
 func (s *Service) internalBroadcastDataColumnSidecar(
 	ctx context.Context,
-	root [fieldparams.RootLength]byte,
 	columnSubnet uint64,
-	dataColumnSidecar *ethpb.DataColumnSidecar,
+	dataColumnSidecar blocks.VerifiedRODataColumn,
 	forkDigest [fieldparams.VersionLength]byte,
 ) {
 	// Add tracing to the function.
@@ -385,8 +381,9 @@ func (s *Service) internalBroadcastDataColumnSidecar(
 	log.WithFields(logrus.Fields{
 		"slot":               slot,
 		"timeSinceSlotStart": time.Since(slotStartTime),
-		"root":               fmt.Sprintf("%#x", root),
+		"root":               fmt.Sprintf("%#x", dataColumnSidecar.BlockRoot()),
 		"columnSubnet":       columnSubnet,
+		"blobCount":          len(dataColumnSidecar.Column),
 	}).Debug("Broadcasted data column sidecar")
 
 	// Increase the number of successful broadcasts.
@@ -415,6 +412,10 @@ func (s *Service) findPeersIfNeeded(
 
 // method to broadcast messages to other peers in our gossip mesh.
 func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic string) error {
+	if strings.Contains(topic, "beacon_block") {
+		log.Debug("TIME MARKER D")
+	}
+
 	ctx, span := trace.StartSpan(ctx, "p2p.broadcastObject")
 	defer span.End()
 
@@ -427,6 +428,10 @@ func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic
 		return err
 	}
 
+	if strings.Contains(topic, "beacon_block") {
+		log.Debug("TIME MARKER E")
+	}
+
 	if span.IsRecording() {
 		id := hash.FastSum64(buf.Bytes())
 		messageLen := int64(buf.Len())
@@ -439,6 +444,10 @@ func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic
 		tracing.AnnotateError(span, err)
 		return err
 	}
+
+	if strings.Contains(topic, "beacon_block") {
+		log.Debug("TIME MARKER L")
+	}
 	return nil
 }
 

beacon-chain/p2p/broadcaster_test.go

@@ -711,13 +711,8 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 	subnet := peerdas.ComputeSubnetForDataColumnSidecar(columnIndex)
 	topic := fmt.Sprintf(topicFormat, digest, subnet) + service.Encoding().ProtocolSuffix()
 
-	roSidecars, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, []util.DataColumnParam{{Index: columnIndex}})
-	sidecar := roSidecars[0].DataColumnSidecar
-
-	// Attempt to broadcast nil object should fail.
-	var emptyRoot [fieldparams.RootLength]byte
-	err = service.BroadcastDataColumnSidecar(emptyRoot, subnet, nil)
-	require.ErrorContains(t, "attempted to broadcast nil", err)
+	_, verifiedRoSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, []util.DataColumnParam{{Index: columnIndex}})
+	verifiedRoSidecar := verifiedRoSidecars[0]
 
 	// Subscribe to the topic.
 	sub, err := p2.SubscribeToTopic(topic)
@@ -727,7 +722,7 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 	time.Sleep(50 * time.Millisecond)
 
 	// Broadcast to peers and wait.
-	err = service.BroadcastDataColumnSidecar(emptyRoot, subnet, sidecar)
+	err = service.BroadcastDataColumnSidecar(subnet, verifiedRoSidecar)
 	require.NoError(t, err)
 
 	// Receive the message.
@@ -739,5 +734,5 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 
 	var result ethpb.DataColumnSidecar
 	require.NoError(t, service.Encoding().DecodeGossip(msg.Data, &result))
-	require.DeepEqual(t, &result, sidecar)
+	require.DeepEqual(t, &result, verifiedRoSidecar)
 }

beacon-chain/p2p/interfaces.go

@@ -6,6 +6,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -51,7 +52,7 @@ type (
 		BroadcastBlob(ctx context.Context, subnet uint64, blob *ethpb.BlobSidecar) error
 		BroadcastLightClientOptimisticUpdate(ctx context.Context, update interfaces.LightClientOptimisticUpdate) error
 		BroadcastLightClientFinalityUpdate(ctx context.Context, update interfaces.LightClientFinalityUpdate) error
-		BroadcastDataColumnSidecar(root [fieldparams.RootLength]byte, columnSubnet uint64, dataColumnSidecar *ethpb.DataColumnSidecar) error
+		BroadcastDataColumnSidecar(columnSubnet uint64, dataColumnSidecar blocks.VerifiedRODataColumn) error
 	}
 
 	// SetStreamHandler configures p2p to handle streams of a certain topic ID.

beacon-chain/p2p/pubsub.go

@@ -81,20 +81,46 @@ func (s *Service) LeaveTopic(topic string) error {
 
 // PublishToTopic joins (if necessary) and publishes a message to a PubSub topic.
 func (s *Service) PublishToTopic(ctx context.Context, topic string, data []byte, opts ...pubsub.PubOpt) error {
+	if strings.Contains(topic, "beacon_block") {
+		log.Debug("TIME MARKER F")
+	}
 	topicHandle, err := s.JoinTopic(topic)
 	if err != nil {
 		return err
 	}
 
+	if strings.Contains(topic, "beacon_block") {
+		log.Debug("TIME MARKER G")
+	}
+
 	// Wait for at least 1 peer to be available to receive the published message.
 	for {
-		if len(topicHandle.ListPeers()) > 0 || flags.Get().MinimumSyncPeers == 0 {
+		if strings.Contains(topic, "beacon_block") {
+			log.Debug("TIME MARKER H <--- main suspect after")
+		}
+
+		peers := topicHandle.ListPeers()
+
+		if strings.Contains(topic, "beacon_block") {
+			log.Debug("TIME MARKER I <--- main suspect before")
+		}
+
+		if len(peers) > 0 || flags.Get().MinimumSyncPeers == 0 {
 			return topicHandle.Publish(ctx, data, opts...)
 		}
+
+		if strings.Contains(topic, "beacon_block") {
+			log.Debug("TIME MARKER J")
+		}
+
 		select {
 		case <-ctx.Done():
 			return errors.Wrapf(ctx.Err(), "unable to find requisite number of peers for topic %s, 0 peers found to publish to", topic)
 		default:
+			if strings.Contains(topic, "beacon_block") {
+				log.Debug("TIME MARKER K")
+			}
+
 			time.Sleep(100 * time.Millisecond)
 		}
 	}

beacon-chain/p2p/testing/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
         "//beacon-chain/p2p/peers/scorers:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/p2p/testing/fuzz_p2p.go

@@ -6,6 +6,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -168,7 +169,7 @@ func (*FakeP2P) BroadcastLightClientFinalityUpdate(_ context.Context, _ interfac
 }
 
 // BroadcastDataColumnSidecar -- fake.
-func (*FakeP2P) BroadcastDataColumnSidecar(_ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar) error {
+func (*FakeP2P) BroadcastDataColumnSidecar(_ uint64, _ blocks.VerifiedRODataColumn) error {
 	return nil
 }
 

beacon-chain/p2p/testing/mock_broadcaster.go

@@ -5,7 +5,7 @@ import (
 	"sync"
 	"sync/atomic"
 
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"google.golang.org/protobuf/proto"
@@ -63,7 +63,7 @@ func (m *MockBroadcaster) BroadcastLightClientFinalityUpdate(_ context.Context,
 }
 
 // BroadcastDataColumnSidecar broadcasts a data column for mock.
-func (m *MockBroadcaster) BroadcastDataColumnSidecar([fieldparams.RootLength]byte, uint64, *ethpb.DataColumnSidecar) error {
+func (m *MockBroadcaster) BroadcastDataColumnSidecar(uint64, blocks.VerifiedRODataColumn) error {
 	m.BroadcastCalled.Store(true)
 	return nil
 }

beacon-chain/p2p/testing/p2p.go

@@ -17,6 +17,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
 	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"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -232,7 +233,7 @@ func (p *TestP2P) BroadcastLightClientFinalityUpdate(_ context.Context, _ interf
 }
 
 // BroadcastDataColumnSidecar broadcasts a data column for mock.
-func (p *TestP2P) BroadcastDataColumnSidecar([fieldparams.RootLength]byte, uint64, *ethpb.DataColumnSidecar) error {
+func (p *TestP2P) BroadcastDataColumnSidecar(uint64, blocks.VerifiedRODataColumn) error {
 	p.BroadcastCalled.Store(true)
 	return nil
 }

beacon-chain/rpc/BUILD.bazel

@@ -20,10 +20,10 @@ go_library(
         "//beacon-chain/core/feed/block:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
-        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/execution:go_default_library",
+        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",

beacon-chain/rpc/endpoints.go

@@ -102,7 +102,7 @@ func (s *Service) endpoints(
 	endpoints = append(endpoints, s.prysmValidatorEndpoints(stater, coreService)...)
 
 	if features.Get().EnableLightClient {
-		endpoints = append(endpoints, s.lightClientEndpoints(blocker, stater)...)
+		endpoints = append(endpoints, s.lightClientEndpoints()...)
 	}
 
 	if enableDebug {
@@ -194,6 +194,8 @@ func (s *Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
 	const namespace = "blob"
 	return []endpoint{
 		{
+			// Deprecated: /eth/v1/beacon/blob_sidecars/{block_id} in favor of /eth/v1/beacon/blobs/{block_id}
+			// the endpoint will continue to work post fulu for some time however
 			template: "/eth/v1/beacon/blob_sidecars/{block_id}",
 			name:     namespace + ".Blobs",
 			middleware: []middleware.Middleware{
@@ -203,6 +205,16 @@ func (s *Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
 			handler: server.Blobs,
 			methods: []string{http.MethodGet},
 		},
+		{
+			template: "/eth/v1/beacon/blobs/{block_id}",
+			name:     namespace + ".GetBlobs",
+			middleware: []middleware.Middleware{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
+			},
+			handler: server.GetBlobs,
+			methods: []string{http.MethodGet},
+		},
 	}
 }
 
@@ -1034,9 +1046,10 @@ func (*Service) configEndpoints() []endpoint {
 	}
 }
 
-func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Stater) []endpoint {
+func (s *Service) lightClientEndpoints() []endpoint {
 	server := &lightclient.Server{
-		LCStore: s.cfg.LCStore,
+		LCStore:     s.cfg.LCStore,
+		HeadFetcher: s.cfg.HeadFetcher,
 	}
 
 	const namespace = "lightclient"

beacon-chain/rpc/endpoints_test.go

@@ -70,6 +70,7 @@ func Test_endpoints(t *testing.T) {
 
 	blobRoutes := map[string][]string{
 		"/eth/v1/beacon/blob_sidecars/{block_id}": {http.MethodGet},
+		"/eth/v1/beacon/blobs/{block_id}":         {http.MethodGet},
 	}
 
 	configRoutes := map[string][]string{

beacon-chain/rpc/eth/blob/BUILD.bazel

@@ -13,7 +13,9 @@ go_library(
         "//api/server/structs:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/eth/shared:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",
+        "//beacon-chain/rpc/options:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -33,6 +35,7 @@ go_test(
     deps = [
         "//api:go_default_library",
         "//api/server/structs:go_default_library",
+        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
@@ -41,6 +44,7 @@ go_test(
         "//beacon-chain/verification:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",

beacon-chain/rpc/eth/blob/handlers.go

@@ -10,7 +10,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/core"
-	field_params "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/options"
+	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/primitives"
@@ -22,6 +24,8 @@ import (
 )
 
 // Blobs is an HTTP handler for Beacon API getBlobs.
+// Deprecated: /eth/v1/beacon/blob_sidecars/{block_id} in favor of /eth/v1/beacon/blobs/{block_id}
+// the endpoint will continue to work post fulu for some time however
 func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.Blobs")
 	defer span.End()
@@ -34,7 +38,7 @@ func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 	segments := strings.Split(r.URL.Path, "/")
 	blockId := segments[len(segments)-1]
 
-	verifiedBlobs, rpcErr := s.Blocker.Blobs(ctx, blockId, indices)
+	verifiedBlobs, rpcErr := s.Blocker.Blobs(ctx, blockId, options.WithIndices(indices))
 	if rpcErr != nil {
 		code := core.ErrorReasonToHTTP(rpcErr.Reason)
 		switch code {
@@ -127,6 +131,94 @@ loop:
 	return indices, nil
 }
 
+// GetBlobs retrieves blobs for a given block id. ( this is the new handler that replaces func (s *Server) Blobs )
+func (s *Server) GetBlobs(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlobs")
+	defer span.End()
+
+	segments := strings.Split(r.URL.Path, "/")
+	blockId := segments[len(segments)-1]
+
+	var verifiedBlobs []*blocks.VerifiedROBlob
+	var rpcErr *core.RpcError
+
+	// Check if versioned_hashes parameter is provided
+	versionedHashesStr := r.URL.Query()["versioned_hashes"]
+	versionedHashes := make([][]byte, len(versionedHashesStr))
+	if len(versionedHashesStr) > 0 {
+		for i, hashStr := range versionedHashesStr {
+			hash, ok := shared.ValidateHex(w, fmt.Sprintf("versioned_hashes[%d]", i), hashStr, 32)
+			if !ok {
+				return
+			}
+			versionedHashes[i] = hash
+		}
+	}
+	verifiedBlobs, rpcErr = s.Blocker.Blobs(ctx, blockId, options.WithVersionedHashes(versionedHashes))
+	if rpcErr != nil {
+		code := core.ErrorReasonToHTTP(rpcErr.Reason)
+		switch code {
+		case http.StatusBadRequest:
+			httputil.HandleError(w, "Bad Request: "+rpcErr.Err.Error(), code)
+			return
+		case http.StatusNotFound:
+			httputil.HandleError(w, "Not found: "+rpcErr.Err.Error(), code)
+			return
+		case http.StatusInternalServerError:
+			httputil.HandleError(w, "Internal server error: "+rpcErr.Err.Error(), code)
+			return
+		default:
+			httputil.HandleError(w, rpcErr.Err.Error(), code)
+			return
+		}
+	}
+
+	blk, err := s.Blocker.Block(ctx, []byte(blockId))
+	if err != nil {
+		httputil.HandleError(w, "Could not fetch block: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if blk == nil {
+		httputil.HandleError(w, "Block not found", http.StatusNotFound)
+		return
+	}
+
+	if httputil.RespondWithSsz(r) {
+		sszLen := fieldparams.BlobSize
+		sszData := make([]byte, len(verifiedBlobs)*sszLen)
+		for i := range verifiedBlobs {
+			copy(sszData[i*sszLen:(i+1)*sszLen], verifiedBlobs[i].Blob)
+		}
+
+		w.Header().Set(api.VersionHeader, version.String(blk.Version()))
+		httputil.WriteSsz(w, sszData)
+		return
+	}
+
+	blkRoot, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		httputil.HandleError(w, "Could not hash block: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, blkRoot)
+	if err != nil {
+		httputil.HandleError(w, "Could not check if block is optimistic: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	data := make([]string, len(verifiedBlobs))
+	for i, v := range verifiedBlobs {
+		data[i] = hexutil.Encode(v.Blob)
+	}
+	resp := &structs.GetBlobsResponse{
+		Data:                data,
+		ExecutionOptimistic: isOptimistic,
+		Finalized:           s.FinalizationFetcher.IsFinalized(ctx, blkRoot),
+	}
+	w.Header().Set(api.VersionHeader, version.String(blk.Version()))
+	httputil.WriteJson(w, resp)
+}
+
 func buildSidecarsJsonResponse(verifiedBlobs []*blocks.VerifiedROBlob) []*structs.Sidecar {
 	sidecars := make([]*structs.Sidecar, len(verifiedBlobs))
 	for i, sc := range verifiedBlobs {
@@ -147,13 +239,13 @@ func buildSidecarsJsonResponse(verifiedBlobs []*blocks.VerifiedROBlob) []*struct
 }
 
 func buildSidecarsSSZResponse(verifiedBlobs []*blocks.VerifiedROBlob) ([]byte, error) {
-	ssz := make([]byte, field_params.BlobSidecarSize*len(verifiedBlobs))
+	ssz := make([]byte, fieldparams.BlobSidecarSize*len(verifiedBlobs))
 	for i, sidecar := range verifiedBlobs {
 		sszrep, err := sidecar.MarshalSSZ()
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to marshal sidecar ssz")
 		}
-		copy(ssz[i*field_params.BlobSidecarSize:(i+1)*field_params.BlobSidecarSize], sszrep)
+		copy(ssz[i*fieldparams.BlobSidecarSize:(i+1)*fieldparams.BlobSidecarSize], sszrep)
 	}
 	return ssz, nil
 }

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

@@ -14,6 +14,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
+	"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/db/filesystem"
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
@@ -22,6 +23,7 @@ import (
 	"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/primitives"
 	"github.com/OffchainLabs/prysm/v6/network/httputil"
 	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -278,7 +280,7 @@ func TestBlobs(t *testing.T) {
 		assert.Equal(t, http.StatusBadRequest, e.Code)
 		assert.Equal(t, true, strings.Contains(e.Message, fmt.Sprintf("requested blob indices [%d] are invalid", overLimit)))
 	})
-	t.Run("outside retention period returns 200 w/ empty list ", func(t *testing.T) {
+	t.Run("outside retention period returns 200 with what we have", func(t *testing.T) {
 		u := "http://foo.example/123"
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
@@ -296,7 +298,7 @@ func TestBlobs(t *testing.T) {
 		assert.Equal(t, http.StatusOK, writer.Code)
 		resp := &structs.SidecarsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		require.Equal(t, 0, len(resp.Data))
+		require.Equal(t, 4, len(resp.Data))
 
 		require.Equal(t, "deneb", resp.Version)
 		require.Equal(t, false, resp.ExecutionOptimistic)
@@ -558,7 +560,573 @@ func Test_parseIndices(t *testing.T) {
 	}
 }
 
+func TestGetBlobs(t *testing.T) {
+	// Start the trusted setup for KZG operations (needed for data columns)
+	require.NoError(t, kzg.Start())
+
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.DenebForkEpoch = 1
+	cfg.ElectraForkEpoch = 10
+	cfg.FuluForkEpoch = 20
+	cfg.BlobSchedule = []params.BlobScheduleEntry{
+		{Epoch: 0, MaxBlobsPerBlock: 0},
+		{Epoch: 1, MaxBlobsPerBlock: 6},   // Deneb
+		{Epoch: 10, MaxBlobsPerBlock: 9},  // Electra
+		{Epoch: 20, MaxBlobsPerBlock: 12}, // Fulu
+	}
+	params.OverrideBeaconConfig(cfg)
+
+	db := testDB.SetupDB(t)
+	denebBlock, blobs := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 123, 4)
+	require.NoError(t, db.SaveBlock(t.Context(), denebBlock))
+	bs := filesystem.NewEphemeralBlobStorage(t)
+	testSidecars := verification.FakeVerifySliceForTest(t, blobs)
+	for i := range testSidecars {
+		require.NoError(t, bs.Save(testSidecars[i]))
+	}
+	blockRoot := blobs[0].BlockRoot()
+
+	mockChainService := &mockChain.ChainService{
+		FinalizedRoots: map[[32]byte]bool{},
+		Genesis:        time.Now().Add(-time.Duration(uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SecondsPerSlot) * time.Second),
+	}
+	s := &Server{
+		OptimisticModeFetcher: mockChainService,
+		FinalizationFetcher:   mockChainService,
+		TimeFetcher:           mockChainService,
+	}
+
+	t.Run("genesis", func(t *testing.T) {
+		u := "http://foo.example/genesis"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.StringContains(t, "blobs are not supported for Phase 0 fork", e.Message)
+	})
+	t.Run("head", func(t *testing.T) {
+		u := "http://foo.example/head"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Root: blockRoot[:], Block: denebBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+		blob := resp.Data[0]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[0].Blob), blob)
+		blob = resp.Data[1]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[1].Blob), blob)
+		blob = resp.Data[2]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[2].Blob), blob)
+		blob = resp.Data[3]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[3].Blob), blob)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("finalized", func(t *testing.T) {
+		u := "http://foo.example/finalized"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("root", func(t *testing.T) {
+		u := "http://foo.example/" + hexutil.Encode(blockRoot[:])
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Block: denebBlock},
+			BeaconDB:         db,
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("slot", func(t *testing.T) {
+		u := "http://foo.example/123"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Block: denebBlock},
+			BeaconDB:         db,
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("slot not found", func(t *testing.T) {
+		u := "http://foo.example/122"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Block: denebBlock},
+			BeaconDB:         db,
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusNotFound, writer.Code)
+	})
+	t.Run("no blobs returns an empty array", func(t *testing.T) {
+		u := "http://foo.example/123"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: filesystem.NewEphemeralBlobStorage(t), // new ephemeral storage
+		}
+
+		s.GetBlobs(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, len(resp.Data), 0)
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("outside retention period still returns 200 what we have in db ", func(t *testing.T) {
+		u := "http://foo.example/123"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		moc := &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher:   moc,
+			GenesisTimeFetcher: moc, // genesis time is set to 0 here, so it results in current epoch being extremely large
+			BeaconDB:           db,
+			BlobStorage:        bs,
+		}
+
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("block without commitments returns 200 w/empty list ", func(t *testing.T) {
+		denebBlock, _ := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 333, 0)
+		commitments, err := denebBlock.Block().Body().BlobKzgCommitments()
+		require.NoError(t, err)
+		require.Equal(t, len(commitments), 0)
+		require.NoError(t, db.SaveBlock(t.Context(), denebBlock))
+
+		u := "http://foo.example/333"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 0, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("slot before Deneb fork", func(t *testing.T) {
+		u := "http://foo.example/31"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{}
+
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.StringContains(t, "blobs are not supported before Deneb fork", e.Message)
+	})
+	t.Run("malformed block ID", func(t *testing.T) {
+		u := "http://foo.example/foo"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.Equal(t, true, strings.Contains(e.Message, "could not parse block ID"))
+	})
+	t.Run("ssz", func(t *testing.T) {
+		u := "http://foo.example/finalized"
+		request := httptest.NewRequest("GET", u, nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+		assert.Equal(t, version.String(version.Deneb), writer.Header().Get(api.VersionHeader))
+		assert.Equal(t, http.StatusOK, writer.Code)
+		require.Equal(t, fieldparams.BlobSize*4, len(writer.Body.Bytes())) // size of 4 sidecars
+		// unmarshal all 4 blobs
+		blbs := unmarshalBlobs(t, writer.Body.Bytes())
+		require.Equal(t, 4, len(blbs))
+	})
+	t.Run("ssz multiple blobs", func(t *testing.T) {
+		u := "http://foo.example/finalized"
+		request := httptest.NewRequest("GET", u, nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		blbs := unmarshalBlobs(t, writer.Body.Bytes())
+		require.Equal(t, 4, len(blbs))
+	})
+
+	t.Run("versioned_hashes invalid hex", func(t *testing.T) {
+		u := "http://foo.example/finalized?versioned_hashes=invalidhex,invalid2hex"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.StringContains(t, "versioned_hashes[0] is invalid", e.Message)
+		assert.StringContains(t, "hex string without 0x prefix", e.Message)
+	})
+
+	t.Run("versioned_hashes invalid length", func(t *testing.T) {
+		// Using 16 bytes instead of 32
+		shortHash := "0x1234567890abcdef1234567890abcdef"
+		u := fmt.Sprintf("http://foo.example/finalized?versioned_hashes=%s", shortHash)
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.StringContains(t, "Invalid versioned_hashes[0]:", e.Message)
+		assert.StringContains(t, "is not length 32", e.Message)
+	})
+
+	t.Run("versioned_hashes valid single hash", func(t *testing.T) {
+		// Get the first blob's commitment and convert to versioned hash
+		versionedHash := primitives.ConvertKzgCommitmentToVersionedHash(blobs[0].KzgCommitment)
+
+		u := fmt.Sprintf("http://foo.example/finalized?versioned_hashes=%s", hexutil.Encode(versionedHash[:]))
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 1, len(resp.Data)) // Should return only the requested blob
+		blob := resp.Data[0]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[0].Blob), blob)
+	})
+
+	t.Run("versioned_hashes multiple hashes", func(t *testing.T) {
+		// Get commitments for blobs 1 and 3 and convert to versioned hashes
+		versionedHash1 := primitives.ConvertKzgCommitmentToVersionedHash(blobs[1].KzgCommitment)
+		versionedHash3 := primitives.ConvertKzgCommitmentToVersionedHash(blobs[3].KzgCommitment)
+
+		u := fmt.Sprintf("http://foo.example/finalized?versioned_hashes=%s&versioned_hashes=%s",
+			hexutil.Encode(versionedHash1[:]), hexutil.Encode(versionedHash3[:]))
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 2, len(resp.Data)) // Should return 2 requested blobs
+		// Verify blobs are returned in KZG commitment order from the block (1, 3)
+		// not in the requested order
+		assert.Equal(t, hexutil.Encode(blobs[1].Blob), resp.Data[0])
+		assert.Equal(t, hexutil.Encode(blobs[3].Blob), resp.Data[1])
+	})
+
+	// Test for Electra fork
+	t.Run("electra max blobs", func(t *testing.T) {
+		electraBlock, electraBlobs := util.GenerateTestElectraBlockWithSidecar(t, [32]byte{}, 323, maxBlobsPerBlockByVersion(version.Electra))
+		require.NoError(t, db.SaveBlock(t.Context(), electraBlock))
+		electraBs := filesystem.NewEphemeralBlobStorage(t)
+		electraSidecars := verification.FakeVerifySliceForTest(t, electraBlobs)
+		for i := range electraSidecars {
+			require.NoError(t, electraBs.Save(electraSidecars[i]))
+		}
+		electraBlockRoot := electraBlobs[0].BlockRoot()
+
+		u := "http://foo.example/323"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: electraBlockRoot[:]}, Block: electraBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: electraBs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, version.String(version.Electra), writer.Header().Get(api.VersionHeader))
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, maxBlobsPerBlockByVersion(version.Electra), len(resp.Data))
+		blob := resp.Data[0]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(electraBlobs[0].Blob), blob)
+	})
+
+	// Test for Fulu fork with data columns
+	t.Run("fulu with data columns", func(t *testing.T) {
+		// Generate a Fulu block with data columns
+		fuluForkSlot := primitives.Slot(20 * params.BeaconConfig().SlotsPerEpoch) // Fulu is at epoch 20
+		fuluBlock, _, verifiedRoDataColumnSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithSlot(fuluForkSlot))
+		require.NoError(t, db.SaveBlock(t.Context(), fuluBlock.ReadOnlySignedBeaconBlock))
+		fuluBlockRoot := fuluBlock.Root()
+
+		// Store data columns
+		_, dataColumnStorage := filesystem.NewEphemeralDataColumnStorageAndFs(t)
+		require.NoError(t, dataColumnStorage.Save(verifiedRoDataColumnSidecars))
+
+		u := fmt.Sprintf("http://foo.example/%d", fuluForkSlot)
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		// Create an empty blob storage (won't be used but needs to be non-nil)
+		_, emptyBlobStorage := filesystem.NewEphemeralBlobStorageAndFs(t)
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: fuluBlockRoot[:]}, Block: fuluBlock.ReadOnlySignedBeaconBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:          db,
+			BlobStorage:       emptyBlobStorage,
+			DataColumnStorage: dataColumnStorage,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, version.String(version.Fulu), writer.Header().Get(api.VersionHeader))
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 3, len(resp.Data))
+
+		// Verify that we got blobs back (they were reconstructed from data columns)
+		for i := range resp.Data {
+			require.NotNil(t, resp.Data[i])
+		}
+	})
+
+	// Test for Fulu with versioned hashes and data columns
+	t.Run("fulu versioned_hashes with data columns", func(t *testing.T) {
+		// Generate a Fulu block with data columns
+		fuluForkSlot2 := primitives.Slot(20*params.BeaconConfig().SlotsPerEpoch + 10) // Fulu is at epoch 20
+		fuluBlock2, _, verifiedRoDataColumnSidecars2 := util.GenerateTestFuluBlockWithSidecars(t, 4, util.WithSlot(fuluForkSlot2))
+		require.NoError(t, db.SaveBlock(t.Context(), fuluBlock2.ReadOnlySignedBeaconBlock))
+		fuluBlockRoot2 := fuluBlock2.Root()
+
+		// Store data columns
+		_, dataColumnStorage := filesystem.NewEphemeralDataColumnStorageAndFs(t)
+		require.NoError(t, dataColumnStorage.Save(verifiedRoDataColumnSidecars2))
+
+		// Get the commitments from the block to derive versioned hashes
+		commitments, err := fuluBlock2.Block().Body().BlobKzgCommitments()
+		require.NoError(t, err)
+		require.Equal(t, true, len(commitments) >= 3)
+
+		// Request specific blobs by versioned hashes in reverse order
+		// We request commitments[2] and commitments[0], but they should be returned
+		// in commitment order from the block (0, 2), not in the requested order
+		versionedHash1 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[2])
+		versionedHash2 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[0])
+
+		u := fmt.Sprintf("http://foo.example/%d?versioned_hashes=%s&versioned_hashes=%s", fuluForkSlot2,
+			hexutil.Encode(versionedHash1[:]),
+			hexutil.Encode(versionedHash2[:]))
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		// Create an empty blob storage (won't be used but needs to be non-nil)
+		_, emptyBlobStorage := filesystem.NewEphemeralBlobStorageAndFs(t)
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: fuluBlockRoot2[:]}, Block: fuluBlock2.ReadOnlySignedBeaconBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:          db,
+			BlobStorage:       emptyBlobStorage,
+			DataColumnStorage: dataColumnStorage,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, version.String(version.Fulu), writer.Header().Get(api.VersionHeader))
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 2, len(resp.Data))
+		// Blobs are returned in commitment order, regardless of request order
+	})
+}
+
+func unmarshalBlobs(t *testing.T, response []byte) [][]byte {
+	require.Equal(t, 0, len(response)%fieldparams.BlobSize)
+	if len(response) == fieldparams.BlobSize {
+		return [][]byte{response}
+	}
+	blobs := make([][]byte, len(response)/fieldparams.BlobSize)
+	for i := range blobs {
+		blobs[i] = response[i*fieldparams.BlobSize : (i+1)*fieldparams.BlobSize]
+	}
+	return blobs
+}
+
 func maxBlobsPerBlockByVersion(v int) int {
+	if v >= version.Fulu {
+		return params.BeaconConfig().DeprecatedMaxBlobsPerBlockFulu
+	}
 	if v >= version.Electra {
 		return params.BeaconConfig().DeprecatedMaxBlobsPerBlockElectra
 	}

beacon-chain/rpc/eth/light-client/BUILD.bazel

@@ -11,7 +11,8 @@ go_library(
     deps = [
         "//api:go_default_library",
         "//api/server/structs:go_default_library",
-        "//beacon-chain/core/light-client:go_default_library",
+        "//beacon-chain/blockchain:go_default_library",
+        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/rpc/eth/shared:go_default_library",
         "//config/params:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -32,9 +33,11 @@ go_test(
     deps = [
         "//api/server/structs:go_default_library",
         "//async/event:go_default_library",
+        "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/light-client:go_default_library",
+        "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
+        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/p2p/testing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

beacon-chain/rpc/eth/light-client/handlers.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
@@ -90,10 +90,21 @@ func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.R
 		return
 	}
 
+	if startPeriod*uint64(config.EpochsPerSyncCommitteePeriod) < uint64(config.AltairForkEpoch) {
+		httputil.HandleError(w, "Invalid 'start_period': before Altair fork", http.StatusBadRequest)
+		return
+	}
+
 	endPeriod := startPeriod + count - 1
 
+	headBlock, err := s.HeadFetcher.HeadBlock(ctx)
+	if err != nil {
+		httputil.HandleError(w, "Could not get head block: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
 	// get updates
-	updates, err := s.LCStore.LightClientUpdates(ctx, startPeriod, endPeriod)
+	updates, err := s.LCStore.LightClientUpdates(ctx, startPeriod, endPeriod, headBlock)
 	if err != nil {
 		httputil.HandleError(w, "Could not get light client updates from DB: "+err.Error(), http.StatusInternalServerError)
 		return

beacon-chain/rpc/eth/light-client/handlers_test.go

@@ -2,6 +2,7 @@ package lightclient
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"math/rand"
@@ -12,9 +13,11 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	"github.com/OffchainLabs/prysm/v6/async/event"
+	blockchainTest "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	dbtesting "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	p2ptesting "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
@@ -55,7 +58,8 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 			require.NoError(t, err)
 
 			db := dbtesting.SetupDB(t)
-			lcStore := lightclient.NewLightClientStore(db, &p2ptesting.FakeP2P{}, new(event.Feed))
+			lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), db)
+			require.NoError(t, err)
 
 			err = db.SaveLightClientBootstrap(l.Ctx, blockRoot[:], bootstrap)
 			require.NoError(t, err)
@@ -99,7 +103,8 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 			require.NoError(t, err)
 
 			db := dbtesting.SetupDB(t)
-			lcStore := lightclient.NewLightClientStore(db, &p2ptesting.FakeP2P{}, new(event.Feed))
+			lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), db)
+			require.NoError(t, err)
 
 			err = db.SaveLightClientBootstrap(l.Ctx, blockRoot[:], bootstrap)
 			require.NoError(t, err)
@@ -142,8 +147,9 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 	}
 
 	t.Run("no bootstrap found", func(t *testing.T) {
+		lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), dbtesting.SetupDB(t))
 		s := &Server{
-			LCStore: lightclient.NewLightClientStore(dbtesting.SetupDB(t), &p2ptesting.FakeP2P{}, new(event.Feed)),
+			LCStore: lcStore,
 		}
 		request := httptest.NewRequest("GET", "http://foo.com/", nil)
 		request.SetPathValue("block_root", hexutil.Encode([]byte{0x00, 0x01, 0x02}))
@@ -185,13 +191,24 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 					updates = append(updates, update)
 				}
 
+				lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), db)
+
+				blk := util.NewBeaconBlock()
+				signedBlk, err := blocks.NewSignedBeaconBlock(blk)
+				require.NoError(t, err)
+
 				s := &Server{
-					LCStore: lightclient.NewLightClientStore(db, &p2ptesting.FakeP2P{}, new(event.Feed)),
+					LCStore: lcStore,
+					HeadFetcher: &blockchainTest.ChainService{
+						Block: signedBlk,
+					},
 				}
 
+				saveHead(t, ctx, db)
+
 				updatePeriod := startPeriod
 				for _, update := range updates {
-					err := s.LCStore.SaveLightClientUpdate(ctx, updatePeriod, update)
+					err := db.SaveLightClientUpdate(ctx, updatePeriod, update)
 					require.NoError(t, err)
 					updatePeriod++
 				}
@@ -326,20 +343,30 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 				secondForkSlot := primitives.Slot(params.BeaconConfig().VersionToForkEpochMap()[testVersion+1] * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 
 				db := dbtesting.SetupDB(t)
+				lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), db)
+
+				blk := util.NewBeaconBlock()
+				signedBlk, err := blocks.NewSignedBeaconBlock(blk)
+				require.NoError(t, err)
+
 				s := &Server{
-					LCStore: lightclient.NewLightClientStore(db, &p2ptesting.FakeP2P{}, new(event.Feed)),
+					LCStore: lcStore,
+					HeadFetcher: &blockchainTest.ChainService{
+						Block: signedBlk,
+					},
 				}
 
+				saveHead(t, ctx, db)
+
 				updates := make([]interfaces.LightClientUpdate, 2)
 
 				updatePeriod := firstForkSlot.Div(uint64(config.EpochsPerSyncCommitteePeriod)).Div(uint64(config.SlotsPerEpoch))
 				startPeriod := updatePeriod
 
-				var err error
 				updates[0], err = createUpdate(t, testVersion)
 				require.NoError(t, err)
 
-				err = s.LCStore.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[0])
+				err = db.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[0])
 				require.NoError(t, err)
 
 				updatePeriod = secondForkSlot.Div(uint64(config.EpochsPerSyncCommitteePeriod)).Div(uint64(config.SlotsPerEpoch))
@@ -347,7 +374,7 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 				updates[1], err = createUpdate(t, testVersion+1)
 				require.NoError(t, err)
 
-				err = s.LCStore.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[1])
+				err = db.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[1])
 				require.NoError(t, err)
 
 				t.Run("json", func(t *testing.T) {
@@ -446,19 +473,30 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 		slot := primitives.Slot(config.AltairForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 
 		db := dbtesting.SetupDB(t)
+		lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), db)
+
+		blk := util.NewBeaconBlock()
+		signedBlk, err := blocks.NewSignedBeaconBlock(blk)
+		require.NoError(t, err)
+
 		s := &Server{
-			LCStore: lightclient.NewLightClientStore(db, &p2ptesting.FakeP2P{}, new(event.Feed)),
+			LCStore: lcStore,
+			HeadFetcher: &blockchainTest.ChainService{
+				Block: signedBlk,
+			},
 		}
 
+		saveHead(t, ctx, db)
+
 		updates := make([]interfaces.LightClientUpdate, 3)
 
 		updatePeriod := slot.Div(uint64(config.EpochsPerSyncCommitteePeriod)).Div(uint64(config.SlotsPerEpoch))
-		var err error
+
 		for i := 0; i < 3; i++ {
 			updates[i], err = createUpdate(t, version.Altair)
 			require.NoError(t, err)
 
-			err = s.LCStore.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[i])
+			err = db.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[i])
 			require.NoError(t, err)
 
 			updatePeriod++
@@ -493,20 +531,30 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 		slot := primitives.Slot(config.AltairForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 
 		db := dbtesting.SetupDB(t)
+		lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), db)
+
+		blk := util.NewBeaconBlock()
+		signedBlk, err := blocks.NewSignedBeaconBlock(blk)
+		require.NoError(t, err)
+
 		s := &Server{
-			LCStore: lightclient.NewLightClientStore(db, &p2ptesting.FakeP2P{}, new(event.Feed)),
+			LCStore: lcStore,
+			HeadFetcher: &blockchainTest.ChainService{
+				Block: signedBlk,
+			},
 		}
 
+		saveHead(t, ctx, db)
+
 		updates := make([]interfaces.LightClientUpdate, 3)
 
 		updatePeriod := slot.Div(uint64(config.EpochsPerSyncCommitteePeriod)).Div(uint64(config.SlotsPerEpoch))
 
-		var err error
 		for i := 0; i < 3; i++ {
 			updates[i], err = createUpdate(t, version.Altair)
 			require.NoError(t, err)
 
-			err = s.LCStore.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[i])
+			err = db.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[i])
 			require.NoError(t, err)
 
 			updatePeriod++
@@ -536,10 +584,16 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 	})
 
 	t.Run("start period before altair", func(t *testing.T) {
+		config.AltairForkEpoch = 1
+		params.OverrideBeaconConfig(config)
+
 		db := dbtesting.SetupDB(t)
+		lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), db)
+
 		s := &Server{
-			LCStore: lightclient.NewLightClientStore(db, &p2ptesting.FakeP2P{}, new(event.Feed)),
+			LCStore: lcStore,
 		}
+
 		startPeriod := 0
 		url := fmt.Sprintf("http://foo.com/?count=128&start_period=%d", startPeriod)
 		request := httptest.NewRequest("GET", url, nil)
@@ -548,11 +602,10 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 
 		s.GetLightClientUpdatesByRange(writer, request)
 
-		require.Equal(t, http.StatusOK, writer.Code)
-		var resp structs.LightClientUpdatesByRangeResponse
-		err := json.Unmarshal(writer.Body.Bytes(), &resp.Updates)
-		require.NoError(t, err)
-		require.Equal(t, 0, len(resp.Updates))
+		require.Equal(t, http.StatusBadRequest, writer.Code)
+
+		config.AltairForkEpoch = 0
+		params.OverrideBeaconConfig(config)
 	})
 
 	t.Run("missing updates", func(t *testing.T) {
@@ -560,15 +613,25 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 
 		t.Run("missing update in the middle", func(t *testing.T) {
 			db := dbtesting.SetupDB(t)
+			lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), db)
+
+			blk := util.NewBeaconBlock()
+			signedBlk, err := blocks.NewSignedBeaconBlock(blk)
+			require.NoError(t, err)
+
 			s := &Server{
-				LCStore: lightclient.NewLightClientStore(db, &p2ptesting.FakeP2P{}, new(event.Feed)),
+				LCStore: lcStore,
+				HeadFetcher: &blockchainTest.ChainService{
+					Block: signedBlk,
+				},
 			}
 
+			saveHead(t, ctx, db)
+
 			updates := make([]interfaces.LightClientUpdate, 3)
 
 			updatePeriod := slot.Div(uint64(config.EpochsPerSyncCommitteePeriod)).Div(uint64(config.SlotsPerEpoch))
 
-			var err error
 			for i := 0; i < 3; i++ {
 				if i == 1 { // skip this update
 					updatePeriod++
@@ -577,7 +640,7 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 				updates[i], err = createUpdate(t, version.Altair)
 				require.NoError(t, err)
 
-				err = s.LCStore.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[i])
+				err = db.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[i])
 				require.NoError(t, err)
 
 				updatePeriod++
@@ -604,15 +667,25 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 
 		t.Run("missing update at the beginning", func(t *testing.T) {
 			db := dbtesting.SetupDB(t)
+			lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), db)
+
+			blk := util.NewBeaconBlock()
+			signedBlk, err := blocks.NewSignedBeaconBlock(blk)
+			require.NoError(t, err)
+
 			s := &Server{
-				LCStore: lightclient.NewLightClientStore(db, &p2ptesting.FakeP2P{}, new(event.Feed)),
+				LCStore: lcStore,
+				HeadFetcher: &blockchainTest.ChainService{
+					Block: signedBlk,
+				},
 			}
 
+			saveHead(t, ctx, db)
+
 			updates := make([]interfaces.LightClientUpdate, 3)
 
 			updatePeriod := slot.Div(uint64(config.EpochsPerSyncCommitteePeriod)).Div(uint64(config.SlotsPerEpoch))
 
-			var err error
 			for i := 0; i < 3; i++ {
 				if i == 0 { // skip this update
 					updatePeriod++
@@ -622,7 +695,7 @@ func TestLightClientHandler_GetLightClientByRange(t *testing.T) {
 				updates[i], err = createUpdate(t, version.Altair)
 				require.NoError(t, err)
 
-				err = s.LCStore.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[i])
+				err = db.SaveLightClientUpdate(ctx, uint64(updatePeriod), updates[i])
 				require.NoError(t, err)
 
 				updatePeriod++
@@ -665,7 +738,12 @@ func TestLightClientHandler_GetLightClientFinalityUpdate(t *testing.T) {
 			update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 
-			s := &Server{LCStore: lightclient.NewLightClientStore(dbtesting.SetupDB(t), &p2ptesting.FakeP2P{}, new(event.Feed))}
+			lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), dbtesting.SetupDB(t))
+			require.NoError(t, err)
+
+			s := &Server{
+				LCStore: lcStore,
+			}
 			s.LCStore.SetLastFinalityUpdate(update, false)
 
 			request := httptest.NewRequest("GET", "http://foo.com", nil)
@@ -690,7 +768,12 @@ func TestLightClientHandler_GetLightClientFinalityUpdate(t *testing.T) {
 			update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 
-			s := &Server{LCStore: lightclient.NewLightClientStore(dbtesting.SetupDB(t), &p2ptesting.FakeP2P{}, new(event.Feed))}
+			lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), dbtesting.SetupDB(t))
+			require.NoError(t, err)
+
+			s := &Server{
+				LCStore: lcStore,
+			}
 			s.LCStore.SetLastFinalityUpdate(update, false)
 
 			request := httptest.NewRequest("GET", "http://foo.com", nil)
@@ -729,7 +812,11 @@ func TestLightClientHandler_GetLightClientOptimisticUpdate(t *testing.T) {
 	helpers.ClearCache()
 
 	t.Run("no update", func(t *testing.T) {
-		s := &Server{LCStore: lightclient.NewLightClientStore(dbtesting.SetupDB(t), &p2ptesting.FakeP2P{}, new(event.Feed))}
+		lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), dbtesting.SetupDB(t))
+
+		s := &Server{
+			LCStore: lcStore,
+		}
 
 		request := httptest.NewRequest("GET", "http://foo.com", nil)
 		writer := httptest.NewRecorder()
@@ -745,7 +832,12 @@ func TestLightClientHandler_GetLightClientOptimisticUpdate(t *testing.T) {
 			update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
 			require.NoError(t, err)
 
-			s := &Server{LCStore: lightclient.NewLightClientStore(dbtesting.SetupDB(t), &p2ptesting.FakeP2P{}, new(event.Feed))}
+			lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), dbtesting.SetupDB(t))
+			require.NoError(t, err)
+
+			s := &Server{
+				LCStore: lcStore,
+			}
 			s.LCStore.SetLastOptimisticUpdate(update, false)
 
 			request := httptest.NewRequest("GET", "http://foo.com", nil)
@@ -769,7 +861,12 @@ func TestLightClientHandler_GetLightClientOptimisticUpdate(t *testing.T) {
 			update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
 			require.NoError(t, err)
 
-			s := &Server{LCStore: lightclient.NewLightClientStore(dbtesting.SetupDB(t), &p2ptesting.FakeP2P{}, new(event.Feed))}
+			lcStore := lightclient.NewLightClientStore(&p2ptesting.FakeP2P{}, new(event.Feed), dbtesting.SetupDB(t))
+			require.NoError(t, err)
+
+			s := &Server{
+				LCStore: lcStore,
+			}
 			s.LCStore.SetLastOptimisticUpdate(update, false)
 
 			request := httptest.NewRequest("GET", "http://foo.com", nil)
@@ -984,3 +1081,14 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 
 	return update, nil
 }
+
+func saveHead(t *testing.T, ctx context.Context, d db.Database) {
+	blk := util.NewBeaconBlock()
+	blkRoot, err := blk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	util.SaveBlock(t, ctx, d, blk)
+	st, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, d.SaveState(ctx, st, blkRoot))
+	require.NoError(t, d.SaveHeadBlockRoot(ctx, blkRoot))
+}

beacon-chain/rpc/eth/light-client/server.go

@@ -1,9 +1,11 @@
 package lightclient
 
 import (
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 )
 
 type Server struct {
-	LCStore *lightClient.Store
+	LCStore     *lightClient.Store
+	HeadFetcher blockchain.HeadFetcher
 }

beacon-chain/rpc/lookup/BUILD.bazel

@@ -14,6 +14,7 @@ go_library(
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/options:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
@@ -44,6 +45,7 @@ go_test(
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/options:go_default_library",
         "//beacon-chain/rpc/testutil:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",

beacon-chain/rpc/lookup/blocker.go

@@ -11,6 +11,7 @@ import (
 	"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/beacon-chain/rpc/options"
 	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
@@ -57,7 +58,7 @@ func (e BlockIdParseError) Error() string {
 // Blocker is responsible for retrieving blocks.
 type Blocker interface {
 	Block(ctx context.Context, id []byte) (interfaces.ReadOnlySignedBeaconBlock, error)
-	Blobs(ctx context.Context, id string, indices []int) ([]*blocks.VerifiedROBlob, *core.RpcError)
+	Blobs(ctx context.Context, id string, opts ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError)
 }
 
 // BeaconDbBlocker is an implementation of Blocker. It retrieves blocks from the beacon chain database.
@@ -147,7 +148,9 @@ func (p *BeaconDbBlocker) Block(ctx context.Context, id []byte) (interfaces.Read
 	return blk, nil
 }
 
-// Blobs returns the blobs for a given block id identifier and blob indices. The identifier can be one of:
+// Blobs returns the fetched blobs for a given block ID with configurable options.
+// Options can specify either blob indices or versioned hashes for retrieval.
+// The identifier can be one of:
 //   - "head" (canonical head in node's view)
 //   - "genesis"
 //   - "finalized"
@@ -158,11 +161,17 @@ func (p *BeaconDbBlocker) Block(ctx context.Context, id []byte) (interfaces.Read
 //
 // cases:
 //   - no block, 404
-//   - block exists, no commitment, 200 w/ empty list
 //   - block exists, has commitments, inside retention period (greater of protocol- or user-specified) serve then w/ 200 unless we hit an error reading them.
 //     we are technically not supposed to import a block to forkchoice unless we have the blobs, so the nuance here is if we can't find the file and we are inside the protocol-defined retention period, then it's actually a 500.
 //   - block exists, has commitments, outside retention period (greater of protocol- or user-specified) - ie just like block exists, no commitment
-func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []int) ([]*blocks.VerifiedROBlob, *core.RpcError) {
+func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, opts ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError) {
+	// Apply options
+	cfg := &options.BlobsConfig{}
+	for _, opt := range opts {
+		opt(cfg)
+	}
+
+	// Resolve block ID to root
 	var rootSlice []byte
 	switch id {
 	case "genesis":
@@ -239,11 +248,6 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []int) (
 		return nil, &core.RpcError{Err: fmt.Errorf("block %#x not found in db", rootSlice), Reason: core.NotFound}
 	}
 
-	// If block is not in the retention window, return 200 w/ empty list
-	if !p.BlobStorage.WithinRetentionPeriod(slots.ToEpoch(roSignedBlock.Block().Slot()), slots.ToEpoch(p.GenesisTimeFetcher.CurrentSlot())) {
-		return make([]*blocks.VerifiedROBlob, 0), nil
-	}
-
 	roBlock := roSignedBlock.Block()
 
 	commitments, err := roBlock.Body().BlobKzgCommitments()
@@ -266,6 +270,46 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []int) (
 		}
 	}
 
+	// Convert versioned hashes to indices if provided
+	indices := cfg.Indices
+	if len(cfg.VersionedHashes) > 0 {
+		// Build a map of requested versioned hashes for fast lookup and tracking
+		requestedHashes := make(map[string]bool)
+		for _, versionedHash := range cfg.VersionedHashes {
+			requestedHashes[string(versionedHash)] = true
+		}
+
+		// Create indices array and track which hashes we found
+		indices = make([]int, 0, len(cfg.VersionedHashes))
+		foundHashes := make(map[string]bool)
+
+		for i, commitment := range commitments {
+			versionedHash := primitives.ConvertKzgCommitmentToVersionedHash(commitment)
+			hashStr := string(versionedHash[:])
+			if requestedHashes[hashStr] {
+				indices = append(indices, i)
+				foundHashes[hashStr] = true
+			}
+		}
+
+		// Check if all requested hashes were found
+		if len(indices) != len(cfg.VersionedHashes) {
+			// Collect missing hashes
+			missingHashes := make([]string, 0, len(cfg.VersionedHashes)-len(indices))
+			for _, requestedHash := range cfg.VersionedHashes {
+				if !foundHashes[string(requestedHash)] {
+					missingHashes = append(missingHashes, hexutil.Encode(requestedHash))
+				}
+			}
+
+			// Create detailed error message
+			errMsg := fmt.Sprintf("versioned hash(es) not found in block (requested %d hashes, found %d, missing: %v)",
+				len(cfg.VersionedHashes), len(indices), missingHashes)
+
+			return nil, &core.RpcError{Err: errors.New(errMsg), Reason: core.NotFound}
+		}
+	}
+
 	if roBlock.Slot() >= fuluForkSlot {
 		roBlock, err := blocks.NewROBlockWithRoot(roSignedBlock, root)
 		if err != nil {

beacon-chain/rpc/lookup/blocker_test.go

@@ -14,11 +14,13 @@ import (
 	"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/options"
 	"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/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -220,16 +222,13 @@ func TestGetBlob(t *testing.T) {
 		cellsAndProofsList = append(cellsAndProofsList, cellsAndProogs)
 	}
 
-	dataColumnSidecarPb, err := peerdas.DataColumnSidecars(fuluBlock, cellsAndProofsList)
+	roDataColumnSidecars, err := peerdas.DataColumnSidecars(cellsAndProofsList, peerdas.PopulateFromBlock(fuluBlock))
 	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)
+	verifiedRoDataColumnSidecars := make([]blocks.VerifiedRODataColumn, 0, len(roDataColumnSidecars))
+	for _, roDataColumnSidecar := range roDataColumnSidecars {
+		verifiedRoDataColumnSidecar := blocks.NewVerifiedRODataColumn(roDataColumnSidecar)
+		verifiedRoDataColumnSidecars = append(verifiedRoDataColumnSidecars, verifiedRoDataColumnSidecar)
 	}
 
 	err = db.SaveBlock(t.Context(), fuluBlock)
@@ -239,7 +238,7 @@ func TestGetBlob(t *testing.T) {
 		setupDeneb(t)
 
 		blocker := &BeaconDbBlocker{}
-		_, rpcErr := blocker.Blobs(ctx, "genesis", nil)
+		_, rpcErr := blocker.Blobs(ctx, "genesis")
 		require.Equal(t, http.StatusBadRequest, core.ErrorReasonToHTTP(rpcErr.Reason))
 		require.StringContains(t, "blobs are not supported for Phase 0 fork", rpcErr.Err.Error())
 	})
@@ -256,7 +255,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}
 
-		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "head", nil)
+		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "head")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(retrievedVerifiedSidecars))
 
@@ -285,7 +284,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}
 
-		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "finalized", nil)
+		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "finalized")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(verifiedSidecars))
 	})
@@ -302,7 +301,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}
 
-		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "justified", nil)
+		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "justified")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(verifiedSidecars))
 	})
@@ -318,7 +317,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}
 
-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(denebBlockRoot[:]), nil)
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(denebBlockRoot[:]))
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(verifiedBlobs))
 	})
@@ -334,7 +333,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}
 
-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123", nil)
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(verifiedBlobs))
 	})
@@ -353,7 +352,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}
 
-		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "123", []int{index})
+		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "123", options.WithIndices([]int{index}))
 		require.IsNil(t, rpcErr)
 		require.Equal(t, 1, len(retrievedVerifiedSidecars))
 
@@ -379,7 +378,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: filesystem.NewEphemeralBlobStorage(t),
 		}
 
-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123", nil)
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, 0, len(verifiedBlobs))
 	})
@@ -397,7 +396,7 @@ func TestGetBlob(t *testing.T) {
 		}
 
 		noBlobIndex := len(storedBlobSidecars) + 1
-		_, rpcErr := blocker.Blobs(ctx, "123", []int{0, noBlobIndex})
+		_, rpcErr := blocker.Blobs(ctx, "123", options.WithIndices([]int{0, noBlobIndex}))
 		require.NotNil(t, rpcErr)
 		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
 	})
@@ -413,7 +412,7 @@ func TestGetBlob(t *testing.T) {
 			BeaconDB:    db,
 			BlobStorage: blobStorage,
 		}
-		_, rpcErr := blocker.Blobs(ctx, "123", []int{0, math.MaxInt})
+		_, rpcErr := blocker.Blobs(ctx, "123", options.WithIndices([]int{0, math.MaxInt}))
 		require.NotNil(t, rpcErr)
 		require.Equal(t, core.ErrorReason(core.BadRequest), rpcErr.Reason)
 	})
@@ -434,7 +433,7 @@ func TestGetBlob(t *testing.T) {
 			DataColumnStorage: dataColumnStorage,
 		}
 
-		_, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]), nil)
+		_, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]))
 		require.NotNil(t, rpcErr)
 		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
 	})
@@ -455,7 +454,7 @@ func TestGetBlob(t *testing.T) {
 			DataColumnStorage: dataColumnStorage,
 		}
 
-		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]), nil)
+		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]))
 		require.IsNil(t, rpcErr)
 		require.Equal(t, len(fuluBlobSidecars), len(retrievedVerifiedRoBlobs))
 
@@ -482,7 +481,7 @@ func TestGetBlob(t *testing.T) {
 			DataColumnStorage: dataColumnStorage,
 		}
 
-		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]), nil)
+		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]))
 		require.IsNil(t, rpcErr)
 		require.Equal(t, len(fuluBlobSidecars), len(retrievedVerifiedRoBlobs))
 
@@ -493,3 +492,164 @@ func TestGetBlob(t *testing.T) {
 		}
 	})
 }
+
+func TestBlobs_CommitmentOrdering(t *testing.T) {
+	// Set up Fulu fork configuration
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.DenebForkEpoch = 1
+	cfg.FuluForkEpoch = 2
+	params.OverrideBeaconConfig(cfg)
+
+	beaconDB := testDB.SetupDB(t)
+	ctx := t.Context()
+
+	// Start the trusted setup for KZG
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	// Create Fulu/Electra block with multiple blob commitments
+	fuluForkSlot := primitives.Slot(cfg.FuluForkEpoch) * params.BeaconConfig().SlotsPerEpoch
+	parent := [32]byte{}
+	fuluBlock, fuluBlobs := util.GenerateTestElectraBlockWithSidecar(t, parent, fuluForkSlot, 3)
+
+	// Save the block
+	err = beaconDB.SaveBlock(ctx, fuluBlock)
+	require.NoError(t, err)
+	fuluBlockRoot := fuluBlock.Root()
+
+	// Get the commitments from the generated block
+	commitments, err := fuluBlock.Block().Body().BlobKzgCommitments()
+	require.NoError(t, err)
+	require.Equal(t, 3, len(commitments))
+
+	// Convert blob sidecars to data column sidecars for Fulu
+	cellsAndProofsList := make([]kzg.CellsAndProofs, 0, len(fuluBlobs))
+	for _, blob := range fuluBlobs {
+		var kzgBlob kzg.Blob
+		copy(kzgBlob[:], blob.Blob)
+		cellsAndProofs, err := kzg.ComputeCellsAndKZGProofs(&kzgBlob)
+		require.NoError(t, err)
+		cellsAndProofsList = append(cellsAndProofsList, cellsAndProofs)
+	}
+
+	dataColumnSidecarPb, err := peerdas.DataColumnSidecars(cellsAndProofsList, peerdas.PopulateFromBlock(fuluBlock))
+	require.NoError(t, err)
+
+	verifiedRoDataColumnSidecars := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecarPb))
+	for _, roDataColumn := range dataColumnSidecarPb {
+		verifiedRoDataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
+		verifiedRoDataColumnSidecars = append(verifiedRoDataColumnSidecars, verifiedRoDataColumn)
+	}
+
+	// Set up data column storage and save data columns
+	_, dataColumnStorage := filesystem.NewEphemeralDataColumnStorageAndFs(t)
+	err = dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+	require.NoError(t, err)
+
+	// Set up the blocker
+	chainService := &mockChain.ChainService{
+		Genesis: time.Now(),
+		FinalizedCheckPoint: &ethpb.Checkpoint{
+			Epoch: 0,
+			Root:  fuluBlockRoot[:],
+		},
+	}
+	blocker := &BeaconDbBlocker{
+		BeaconDB:           beaconDB,
+		ChainInfoFetcher:   chainService,
+		GenesisTimeFetcher: chainService,
+		BlobStorage:        filesystem.NewEphemeralBlobStorage(t),
+		DataColumnStorage:  dataColumnStorage,
+	}
+
+	// Compute versioned hashes for commitments in their block order
+	hash0 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[0])
+	hash1 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[1])
+	hash2 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[2])
+
+	t.Run("blobs returned in commitment order regardless of request order", func(t *testing.T) {
+		// Request versioned hashes in reverse order: 2, 1, 0
+		requestedHashes := [][]byte{hash2[:], hash1[:], hash0[:]}
+
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "finalized", options.WithVersionedHashes(requestedHashes))
+		if rpcErr != nil {
+			t.Errorf("RPC Error: %v (reason: %v)", rpcErr.Err, rpcErr.Reason)
+			return
+		}
+		require.Equal(t, 3, len(verifiedBlobs))
+
+		// Verify blobs are returned in commitment order from the block (0, 1, 2)
+		// In Fulu, blobs are reconstructed from data columns
+		assert.Equal(t, uint64(0), verifiedBlobs[0].Index) // First commitment in block
+		assert.Equal(t, uint64(1), verifiedBlobs[1].Index) // Second commitment in block
+		assert.Equal(t, uint64(2), verifiedBlobs[2].Index) // Third commitment in block
+
+		// Verify the blob content matches what we expect
+		for i, verifiedBlob := range verifiedBlobs {
+			require.NotNil(t, verifiedBlob.BlobSidecar)
+			require.DeepEqual(t, fuluBlobs[i].Blob, verifiedBlob.Blob)
+			require.DeepEqual(t, fuluBlobs[i].KzgCommitment, verifiedBlob.KzgCommitment)
+		}
+	})
+
+	t.Run("subset of blobs maintains commitment order", func(t *testing.T) {
+		// Request hashes for indices 1 and 0 (out of order)
+		requestedHashes := [][]byte{hash1[:], hash0[:]}
+
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "finalized", options.WithVersionedHashes(requestedHashes))
+		if rpcErr != nil {
+			t.Errorf("RPC Error: %v (reason: %v)", rpcErr.Err, rpcErr.Reason)
+			return
+		}
+		require.Equal(t, 2, len(verifiedBlobs))
+
+		// Verify blobs are returned in commitment order from the block
+		assert.Equal(t, uint64(0), verifiedBlobs[0].Index) // First commitment in block
+		assert.Equal(t, uint64(1), verifiedBlobs[1].Index) // Second commitment in block
+
+		// Verify the blob content matches what we expect
+		require.DeepEqual(t, fuluBlobs[0].Blob, verifiedBlobs[0].Blob)
+		require.DeepEqual(t, fuluBlobs[1].Blob, verifiedBlobs[1].Blob)
+	})
+
+	t.Run("request non-existent hash", func(t *testing.T) {
+		// Create a fake versioned hash
+		fakeHash := make([]byte, 32)
+		for i := 0; i < 32; i++ {
+			fakeHash[i] = 0xFF
+		}
+
+		// Request only the fake hash
+		requestedHashes := [][]byte{fakeHash}
+
+		_, rpcErr := blocker.Blobs(ctx, "finalized", options.WithVersionedHashes(requestedHashes))
+		require.NotNil(t, rpcErr)
+		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
+		require.StringContains(t, "versioned hash(es) not found in block", rpcErr.Err.Error())
+		require.StringContains(t, "requested 1 hashes, found 0", rpcErr.Err.Error())
+		require.StringContains(t, "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", rpcErr.Err.Error())
+	})
+
+	t.Run("request multiple non-existent hashes", func(t *testing.T) {
+		// Create two fake versioned hashes
+		fakeHash1 := make([]byte, 32)
+		fakeHash2 := make([]byte, 32)
+		for i := 0; i < 32; i++ {
+			fakeHash1[i] = 0xAA
+			fakeHash2[i] = 0xBB
+		}
+
+		// Request valid hash with two fake hashes
+		requestedHashes := [][]byte{fakeHash1, hash0[:], fakeHash2}
+
+		_, rpcErr := blocker.Blobs(ctx, "finalized", options.WithVersionedHashes(requestedHashes))
+		require.NotNil(t, rpcErr)
+		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
+		require.StringContains(t, "versioned hash(es) not found in block", rpcErr.Err.Error())
+		require.StringContains(t, "requested 3 hashes, found 1", rpcErr.Err.Error())
+		// Check that both missing hashes are reported
+		require.StringContains(t, "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", rpcErr.Err.Error())
+		require.StringContains(t, "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", rpcErr.Err.Error())
+	})
+}

beacon-chain/rpc/options/BUILD.bazel

@@ -0,0 +1,8 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["options.go"],
+    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/options",
+    visibility = ["//visibility:public"],
+)

beacon-chain/rpc/options/options.go

@@ -0,0 +1,24 @@
+package options
+
+// BlobsOption is a functional option for configuring blob retrieval
+type BlobsOption func(*BlobsConfig)
+
+// BlobsConfig holds configuration for blob retrieval
+type BlobsConfig struct {
+	Indices         []int
+	VersionedHashes [][]byte
+}
+
+// WithIndices specifies blob indices to retrieve
+func WithIndices(indices []int) BlobsOption {
+	return func(c *BlobsConfig) {
+		c.Indices = indices
+	}
+}
+
+// WithVersionedHashes specifies versioned hashes to retrieve blobs by
+func WithVersionedHashes(hashes [][]byte) BlobsOption {
+	return func(c *BlobsConfig) {
+		c.VersionedHashes = hashes
+	}
+}

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

@@ -281,9 +281,11 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
 	var (
 		blobSidecars       []*ethpb.BlobSidecar
-		dataColumnSidecars []*ethpb.DataColumnSidecar
+		dataColumnSidecars []blocks.RODataColumn
 	)
 
+	log.Debug("TIME MARKER 01")
+
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.ProposeBeaconBlock")
 	defer span.End()
 
@@ -291,15 +293,22 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 		return nil, status.Errorf(codes.InvalidArgument, "empty request")
 	}
 
+	log.Debug("TIME MARKER 02")
+
 	block, err := blocks.NewSignedBeaconBlock(req.Block)
 	if err != nil {
 		return nil, status.Errorf(codes.InvalidArgument, "%s: %v", "decode block failed", err)
 	}
+
+	log.Debug("TIME MARKER 03")
+
 	root, err := block.Block().HashTreeRoot()
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not hash tree root: %v", err)
 	}
 
+	log.Debug("TIME MARKER 04")
+
 	// For post-Fulu blinded blocks, submit to relay and return early
 	if block.IsBlinded() && slots.ToEpoch(block.Block().Slot()) >= params.BeaconConfig().FuluForkEpoch {
 		err := vs.BlockBuilder.SubmitBlindedBlockPostFulu(ctx, block)
@@ -309,36 +318,50 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 		return &ethpb.ProposeResponse{BlockRoot: root[:]}, nil
 	}
 
+	log.Debug("TIME MARKER 05")
+
+	rob, err := blocks.NewROBlockWithRoot(block, root)
 	if block.IsBlinded() {
 		block, blobSidecars, err = vs.handleBlindedBlock(ctx, block)
 	} else if block.Version() >= version.Deneb {
-		blobSidecars, dataColumnSidecars, err = vs.handleUnblindedBlock(block, req)
+		log.Debug("TIME MARKER 05A")
+		blobSidecars, dataColumnSidecars, err = vs.handleUnblindedBlock(rob, req)
+		log.Debug("TIME MARKER 05B")
 	}
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "%s: %v", "handle block failed", err)
 	}
 
+	log.Debug("TIME MARKER 06")
+
 	var wg sync.WaitGroup
 	errChan := make(chan error, 1)
 
 	wg.Add(1)
 	go func() {
-		defer wg.Done()
-		if err := vs.broadcastReceiveBlock(ctx, block, root); err != nil {
+		if err := vs.broadcastReceiveBlock(ctx, &wg, block, root); err != nil {
 			errChan <- errors.Wrap(err, "broadcast/receive block failed")
 			return
 		}
 		errChan <- nil
 	}()
 
+	wg.Wait()
+
+	log.Debug("TIME MARKER 07")
+
 	if err := vs.broadcastAndReceiveSidecars(ctx, block, root, blobSidecars, dataColumnSidecars); err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not broadcast/receive sidecars: %v", err)
 	}
-	wg.Wait()
+
+	log.Debug("TIME MARKER 08")
+
 	if err := <-errChan; err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not broadcast/receive block: %v", err)
 	}
 
+	log.Debug("TIME MARKER 09")
+
 	return &ethpb.ProposeResponse{BlockRoot: root[:]}, nil
 }
 
@@ -348,10 +371,10 @@ func (vs *Server) broadcastAndReceiveSidecars(
 	block interfaces.SignedBeaconBlock,
 	root [fieldparams.RootLength]byte,
 	blobSidecars []*ethpb.BlobSidecar,
-	dataColumnSideCars []*ethpb.DataColumnSidecar,
+	dataColumnSidecars []blocks.RODataColumn,
 ) error {
 	if block.Version() >= version.Fulu {
-		if err := vs.broadcastAndReceiveDataColumns(ctx, dataColumnSideCars, root); err != nil {
+		if err := vs.broadcastAndReceiveDataColumns(ctx, dataColumnSidecars, root); err != nil {
 			return errors.Wrap(err, "broadcast and receive data columns")
 		}
 		return nil
@@ -398,21 +421,36 @@ func (vs *Server) handleBlindedBlock(ctx context.Context, block interfaces.Signe
 }
 
 func (vs *Server) handleUnblindedBlock(
-	block interfaces.SignedBeaconBlock,
+	block blocks.ROBlock,
 	req *ethpb.GenericSignedBeaconBlock,
-) ([]*ethpb.BlobSidecar, []*ethpb.DataColumnSidecar, error) {
+) ([]*ethpb.BlobSidecar, []blocks.RODataColumn, error) {
+	log.Debug("TIME MARKER ALPHA")
 	rawBlobs, proofs, err := blobsAndProofs(req)
 	if err != nil {
 		return nil, nil, err
 	}
+	log.Debug("TIME MARKER BETA")
 
 	if block.Version() >= version.Fulu {
-		dataColumnSideCars, err := peerdas.ConstructDataColumnSidecars(block, rawBlobs, proofs)
+		log.Debug("TIME MARKER GAMMA")
+
+		// Compute cells and proofs from the blobs and cell proofs.
+		cellsAndProofs, err := peerdas.ComputeCellsAndProofsFromFlat(rawBlobs, proofs)
 		if err != nil {
-			return nil, nil, errors.Wrap(err, "construct data column sidecars")
+			return nil, nil, errors.Wrap(err, "compute cells and proofs")
 		}
 
-		return nil, dataColumnSideCars, nil
+		log.Debug("TIME MARKER DELTA")
+
+		// Construct data column sidecars from the signed block and cells and proofs.
+		roDataColumnSidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(block))
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "data column sidcars")
+		}
+
+		log.Debug("TIME MARKER EPSILON")
+
+		return nil, roDataColumnSidecars, nil
 	}
 
 	blobSidecars, err := BuildBlobSidecars(block, rawBlobs, proofs)
@@ -424,19 +462,46 @@ func (vs *Server) handleUnblindedBlock(
 }
 
 // broadcastReceiveBlock broadcasts a block and handles its reception.
-func (vs *Server) broadcastReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, root [fieldparams.RootLength]byte) error {
-	protoBlock, err := block.Proto()
-	if err != nil {
-		return errors.Wrap(err, "protobuf conversion failed")
-	}
-	if err := vs.P2P.Broadcast(ctx, protoBlock); err != nil {
-		return errors.Wrap(err, "broadcast failed")
+func (vs *Server) broadcastReceiveBlock(ctx context.Context, wg *sync.WaitGroup, block interfaces.SignedBeaconBlock, root [fieldparams.RootLength]byte) error {
+	log.Debug("TIME MARKER A")
+	if err := vs.broadcastBlock(ctx, wg, block, root); err != nil {
+		return errors.Wrap(err, "broadcast block")
 	}
+
 	vs.BlockNotifier.BlockFeed().Send(&feed.Event{
 		Type: blockfeed.ReceivedBlock,
 		Data: &blockfeed.ReceivedBlockData{SignedBlock: block},
 	})
-	return vs.BlockReceiver.ReceiveBlock(ctx, block, root, nil)
+
+	if err := vs.BlockReceiver.ReceiveBlock(ctx, block, root, nil); err != nil {
+		return errors.Wrap(err, "receive block")
+	}
+
+	return nil
+}
+
+func (vs *Server) broadcastBlock(ctx context.Context, wg *sync.WaitGroup, block interfaces.SignedBeaconBlock, root [fieldparams.RootLength]byte) error {
+	defer wg.Done()
+
+	log.Debug("TIME MARKER B")
+
+	protoBlock, err := block.Proto()
+	if err != nil {
+		return errors.Wrap(err, "protobuf conversion failed")
+	}
+
+	log.Debug("TIME MARKER C")
+
+	if err := vs.P2P.Broadcast(ctx, protoBlock); err != nil {
+		return errors.Wrap(err, "broadcast failed")
+	}
+
+	log.WithFields(logrus.Fields{
+		"slot": block.Block().Slot(),
+		"root": fmt.Sprintf("%#x", root),
+	}).Debug("Broadcasted block")
+
+	return nil
 }
 
 // broadcastAndReceiveBlobs handles the broadcasting and reception of blob sidecars.
@@ -468,26 +533,21 @@ func (vs *Server) broadcastAndReceiveBlobs(ctx context.Context, sidecars []*ethp
 // broadcastAndReceiveDataColumns handles the broadcasting and reception of data columns sidecars.
 func (vs *Server) broadcastAndReceiveDataColumns(
 	ctx context.Context,
-	sidecars []*ethpb.DataColumnSidecar,
+	roSidecars []blocks.RODataColumn,
 	root [fieldparams.RootLength]byte,
 ) error {
-	verifiedRODataColumns := make([]blocks.VerifiedRODataColumn, 0, len(sidecars))
+	verifiedRODataColumns := make([]blocks.VerifiedRODataColumn, 0, len(roSidecars))
 	eg, _ := errgroup.WithContext(ctx)
-	for _, sidecar := range sidecars {
-		roDataColumn, err := blocks.NewRODataColumnWithRoot(sidecar, root)
-		if err != nil {
-			return errors.Wrap(err, "new read-only data column with root")
-		}
-
+	for _, roSidecar := range roSidecars {
 		// We build this block ourselves, so we can upgrade the read only data column sidecar into a verified one.
-		verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
+		verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roSidecar)
 		verifiedRODataColumns = append(verifiedRODataColumns, verifiedRODataColumn)
 
 		eg.Go(func() error {
 			// Compute the subnet index based on the column index.
-			subnet := peerdas.ComputeSubnetForDataColumnSidecar(sidecar.Index)
+			subnet := peerdas.ComputeSubnetForDataColumnSidecar(roSidecar.Index)
 
-			if err := vs.P2P.BroadcastDataColumnSidecar(root, subnet, sidecar); err != nil {
+			if err := vs.P2P.BroadcastDataColumnSidecar(subnet, verifiedRODataColumn); err != nil {
 				return errors.Wrap(err, "broadcast data column")
 			}
 
@@ -495,10 +555,6 @@ func (vs *Server) broadcastAndReceiveDataColumns(
 		})
 	}
 
-	if err := eg.Wait(); err != nil {
-		return errors.Wrap(err, "wait for data columns to be broadcasted")
-	}
-
 	if err := vs.DataColumnReceiver.ReceiveDataColumns(verifiedRODataColumns); err != nil {
 		return errors.Wrap(err, "receive data column")
 	}
@@ -509,6 +565,11 @@ func (vs *Server) broadcastAndReceiveDataColumns(
 			Data: &operation.DataColumnSidecarReceivedData{DataColumn: &verifiedRODataColumn}, // #nosec G601
 		})
 	}
+
+	if err := eg.Wait(); err != nil {
+		return errors.Wrap(err, "wait for data columns to be broadcasted")
+	}
+
 	return nil
 }
 

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

@@ -10,7 +10,7 @@ import (
 )
 
 // BuildBlobSidecars given a block, builds the blob sidecars for the block.
-func BuildBlobSidecars(blk interfaces.SignedBeaconBlock, blobs [][]byte, kzgProofs [][]byte) ([]*ethpb.BlobSidecar, error) {
+func BuildBlobSidecars(blk interfaces.ReadOnlySignedBeaconBlock, blobs [][]byte, kzgProofs [][]byte) ([]*ethpb.BlobSidecar, error) {
 	if blk.Version() < version.Deneb {
 		return nil, nil // No blobs before deneb.
 	}

beacon-chain/rpc/service.go

@@ -16,10 +16,10 @@ import (
 	blockfeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/block"
 	opfeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings"
@@ -145,7 +145,7 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		log.WithError(err).Errorf("Could not listen to port in Start() %s", address)
 	}
 	s.listener = lis
-	log.WithField("address", address).Info("gRPC server listening on port")
+	log.WithField("address", address).Info("Beacon chain gRPC server listening")
 
 	opts := []grpc.ServerOption{
 		grpc.StatsHandler(otelgrpc.NewServerHandler()),
@@ -351,7 +351,7 @@ func (s *Service) Stop() error {
 	s.cancel()
 	if s.listener != nil {
 		s.grpcServer.GracefulStop()
-		log.Debug("Initiated graceful stop of gRPC server")
+		log.Debug("Completed graceful stop of beacon-chain gRPC server")
 	}
 	return nil
 }

beacon-chain/rpc/service_test.go

@@ -42,8 +42,9 @@ func TestLifecycle_OK(t *testing.T) {
 
 	rpcService.Start()
 
-	require.LogsContain(t, hook, "listening on port")
+	require.LogsContain(t, hook, "Beacon chain gRPC server listening")
 	assert.NoError(t, rpcService.Stop())
+	require.LogsContain(t, hook, "Completed graceful stop of beacon-chain gRPC server")
 }
 
 func TestStatus_CredentialError(t *testing.T) {
@@ -84,7 +85,7 @@ func TestRPC_InsecureEndpoint(t *testing.T) {
 
 	rpcService.Start()
 
-	require.LogsContain(t, hook, "listening on port")
+	require.LogsContain(t, hook, "Beacon chain gRPC server listening")
 	require.LogsContain(t, hook, "You are using an insecure gRPC server")
 	assert.NoError(t, rpcService.Stop())
 }

beacon-chain/rpc/testutil/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
     deps = [
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/options:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

beacon-chain/rpc/testutil/mock_blocker.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/core"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/options"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -36,6 +37,6 @@ func (m *MockBlocker) Block(_ context.Context, b []byte) (interfaces.ReadOnlySig
 }
 
 // Blobs --
-func (*MockBlocker) Blobs(_ context.Context, _ string, _ []int) ([]*blocks.VerifiedROBlob, *core.RpcError) {
+func (*MockBlocker) Blobs(_ context.Context, _ string, _ ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError) {
 	return nil, &core.RpcError{}
 }

beacon-chain/sync/BUILD.bazel

@@ -81,7 +81,6 @@ go_library(
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -90,6 +89,7 @@ go_library(
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/execution:go_default_library",
+        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
@@ -154,6 +154,8 @@ go_library(
         "@com_github_trailofbits_go_mutexasserts//:go_default_library",
         "@io_opentelemetry_go_otel_trace//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
+        "@org_golang_x_sync//errgroup:go_default_library",
+        "@org_golang_x_sync//singleflight:go_default_library",
     ],
 )
 
@@ -224,7 +226,6 @@ go_test(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
@@ -236,6 +237,7 @@ go_test(
         "//beacon-chain/execution:go_default_library",
         "//beacon-chain/execution/testing:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
+        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",

beacon-chain/sync/backfill/service.go

@@ -22,7 +22,7 @@ import (
 
 type Service struct {
 	ctx             context.Context
-	enabled         bool // service is disabled by default while feature is experimental
+	enabled         bool // service is disabled by default
 	clock           *startup.Clock
 	store           *Store
 	ms              minimumSlotter

beacon-chain/sync/data_columns_reconstruct.go

@@ -3,220 +3,131 @@ package sync
 import (
 	"context"
 	"fmt"
-	"slices"
+	"sync"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	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/primitives"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
-const (
-	broadcastMissingDataColumnsTimeIntoSlotMin = 1 * time.Second
-	broadcastMissingDataColumnsSlack           = 2 * time.Second
-)
+// processDataColumnSidecarsFromReconstruction, after a random delay, attempts to reconstruct,
+// broadcast and receive missing data column sidecars for the given block root.
+// https:github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#reconstruction-and-cross-seeding
+func (s *Service) processDataColumnSidecarsFromReconstruction(ctx context.Context, sidecar blocks.VerifiedRODataColumn) error {
+	key := fmt.Sprintf("%#x", sidecar.BlockRoot())
+	if _, err, _ := s.reconstructionSingleFlight.Do(key, func() (interface{}, error) {
+		var wg sync.WaitGroup
 
-// reconstructSaveBroadcastDataColumnSidecars reconstructs, if possible,
-// all data column sidecars. Then, it saves missing sidecars to the store.
-// After a delay, it broadcasts in the background not seen via gossip
-// (but reconstructed) sidecars.
-func (s *Service) reconstructSaveBroadcastDataColumnSidecars(
-	ctx context.Context,
-	slot primitives.Slot,
-	proposerIndex primitives.ValidatorIndex,
-	root [fieldparams.RootLength]byte,
-) error {
-	startTime := time.Now()
-	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
+		root := sidecar.BlockRoot()
+		slot := sidecar.Slot()
+		proposerIndex := sidecar.ProposerIndex()
 
-	// Lock to prevent concurrent reconstructions.
-	s.reconstructionLock.Lock()
-	defer s.reconstructionLock.Unlock()
+		// Return early if reconstruction is not needed.
+		if !s.shouldReconstruct(root) {
+			return nil, nil
+		}
+
+		// Compute the slot start time.
+		slotStartTime, err := slots.StartTime(s.cfg.clock.GenesisTime(), slot)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to calculate slot start time")
+		}
+
+		// Randomly choose value before starting reconstruction.
+		timeIntoSlot := s.computeRandomDelay(slotStartTime)
+		broadcastTime := slotStartTime.Add(timeIntoSlot)
+		waitingTime := time.Until(broadcastTime)
+
+		wg.Add(1)
+		time.AfterFunc(waitingTime, func() {
+			defer wg.Done()
+
+			// Return early if the context was canceled during the waiting time.
+			if err := ctx.Err(); err != nil {
+				return
+			}
+
+			// Return early if reconstruction is not needed anymore.
+			if !s.shouldReconstruct(root) {
+				return
+			}
+
+			// Load all the stored data column sidecars for this root.
+			verifiedSidecars, err := s.cfg.dataColumnStorage.Get(root, nil)
+			if err != nil {
+				log.WithError(err).Error("Failed to get data column sidecars")
+				return
+			}
+
+			// Reconstruct all the data column sidecars.
+			startTime := time.Now()
+			reconstructedSidecars, err := peerdas.ReconstructDataColumnSidecars(verifiedSidecars)
+			if err != nil {
+				log.WithError(err).Error("Failed to reconstruct data column sidecars")
+				return
+			}
+
+			duration := time.Since(startTime)
+			dataColumnReconstructionHistogram.Observe(float64(duration.Milliseconds()))
+			dataColumnReconstructionCounter.Add(float64(len(reconstructedSidecars) - len(verifiedSidecars)))
+
+			// Retrieve indices of data column sidecars to sample.
+			columnIndicesToSample, err := s.columnIndicesToSample()
+			if err != nil {
+				log.WithError(err).Error("Failed to get column indices to sample")
+				return
+			}
+
+			unseenIndices, err := s.broadcastAndReceiveUnseenDataColumnSidecars(ctx, slot, proposerIndex, columnIndicesToSample, reconstructedSidecars)
+			if err != nil {
+				log.WithError(err).Error("Failed to broadcast and receive unseen data column sidecars")
+				return
+			}
+
+			if len(unseenIndices) > 0 {
+				log.WithFields(logrus.Fields{
+					"root":          fmt.Sprintf("%#x", root),
+					"slot":          slot,
+					"proposerIndex": proposerIndex,
+					"count":         len(unseenIndices),
+					"indices":       sortedSliceFromMap(unseenIndices),
+					"duration":      duration,
+				}).Debug("Reconstructed data column sidecars")
+			}
+		})
+
+		wg.Wait()
+		return nil, nil
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// shouldReconstruct returns true if we should attempt to reconstruct the data columns for the given block root.
+func (s *Service) shouldReconstruct(root [fieldparams.RootLength]byte) bool {
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
 
 	// Get the columns we store.
 	storedDataColumns := s.cfg.dataColumnStorage.Summary(root)
 	storedColumnsCount := storedDataColumns.Count()
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
 
-	// If reconstruction is not possible or if all columns are already stored, exit early.
-	if storedColumnsCount < peerdas.MinimumColumnCountToReconstruct() || storedColumnsCount == numberOfColumns {
-		return nil
-	}
-
-	// Retrieve our local node info.
-	nodeID := s.cfg.p2p.NodeID()
-	custodyGroupCount, err := s.cfg.p2p.CustodyGroupCount()
-	if err != nil {
-		return errors.Wrap(err, "custody group count")
-	}
-
-	samplingSize := max(custodyGroupCount, samplesPerSlot)
-	localNodeInfo, _, err := peerdas.Info(nodeID, samplingSize)
-	if err != nil {
-		return errors.Wrap(err, "peer info")
-	}
-
-	// Load all the possible data column sidecars, to minimize reconstruction time.
-	verifiedSidecars, err := s.cfg.dataColumnStorage.Get(root, nil)
-	if err != nil {
-		return errors.Wrap(err, "get data column sidecars")
-	}
-
-	// Reconstruct all the data column sidecars.
-	reconstructedSidecars, err := peerdas.ReconstructDataColumnSidecars(verifiedSidecars)
-	if err != nil {
-		return errors.Wrap(err, "reconstruct data column sidecars")
-	}
-
-	// Filter reconstructed sidecars to save.
-	custodyColumns := localNodeInfo.CustodyColumns
-	toSaveSidecars := make([]blocks.VerifiedRODataColumn, 0, len(custodyColumns))
-	for _, sidecar := range reconstructedSidecars {
-		if custodyColumns[sidecar.Index] {
-			toSaveSidecars = append(toSaveSidecars, sidecar)
-		}
-	}
-
-	// Save the data column sidecars to the database.
-	// Note: We do not call `receiveDataColumn`, because it will ignore
-	// incoming data columns via gossip while we did not broadcast (yet) the reconstructed data columns.
-	if err := s.cfg.dataColumnStorage.Save(toSaveSidecars); err != nil {
-		return errors.Wrap(err, "save data column sidecars")
-	}
-
-	slotStartTime, err := slots.StartTime(s.cfg.clock.GenesisTime(), slot)
-	if err != nil {
-		return errors.Wrap(err, "failed to calculate slot start time")
-	}
-	log.WithFields(logrus.Fields{
-		"root":                          fmt.Sprintf("%#x", root),
-		"slot":                          slot,
-		"fromColumnsCount":              storedColumnsCount,
-		"sinceSlotStartTime":            time.Since(slotStartTime),
-		"reconstructionAndSaveDuration": time.Since(startTime),
-	}).Debug("Data columns reconstructed and saved")
-
-	// Update reconstruction metrics.
-	dataColumnReconstructionHistogram.Observe(float64(time.Since(startTime).Milliseconds()))
-	dataColumnReconstructionCounter.Add(float64(len(reconstructedSidecars) - len(verifiedSidecars)))
-
-	// Schedule the broadcast.
-	if err := s.scheduleMissingDataColumnSidecarsBroadcast(ctx, root, proposerIndex, slot); err != nil {
-		return errors.Wrap(err, "schedule reconstructed data columns broadcast")
-	}
-
-	return nil
+	// Reconstruct only if we have at least the minimum number of columns to reconstruct, but not all the columns.
+	// (If we have not enough columns, reconstruction is impossible. If we have all the columns, reconstruction is unnecessary.)
+	return storedColumnsCount >= peerdas.MinimumColumnCountToReconstruct() && storedColumnsCount != numberOfColumns
 }
 
-// scheduleMissingDataColumnSidecarsBroadcast schedules the broadcast of missing
-// (aka. not seen via gossip but reconstructed) sidecars.
-func (s *Service) scheduleMissingDataColumnSidecarsBroadcast(
-	ctx context.Context,
-	root [fieldparams.RootLength]byte,
-	proposerIndex primitives.ValidatorIndex,
-	slot primitives.Slot,
-) error {
-	log := log.WithFields(logrus.Fields{
-		"root": fmt.Sprintf("%x", root),
-		"slot": slot,
-	})
+// computeRandomDelay computes a random delay duration to wait before reconstructing data column sidecars.
+func (s *Service) computeRandomDelay(slotStartTime time.Time) time.Duration {
+	const maxReconstructionDelaySec = 2.
 
-	// Get the time corresponding to the start of the slot.
-	genesisTime := s.cfg.clock.GenesisTime()
-	slotStartTime, err := slots.StartTime(genesisTime, slot)
-	if err != nil {
-		return errors.Wrap(err, "failed to calculate slot start time")
-	}
-
-	// Compute the waiting time. This could be negative. In such a case, broadcast immediately.
 	randFloat := s.reconstructionRandGen.Float64()
-	timeIntoSlot := broadcastMissingDataColumnsTimeIntoSlotMin + time.Duration(float64(broadcastMissingDataColumnsSlack)*randFloat)
-	broadcastTime := slotStartTime.Add(timeIntoSlot)
-	waitingTime := time.Until(broadcastTime)
-	time.AfterFunc(waitingTime, func() {
-		// Return early if the context was canceled during the waiting time.
-		if err := ctx.Err(); err != nil {
-			return
-		}
-
-		if err := s.broadcastMissingDataColumnSidecars(slot, proposerIndex, root, timeIntoSlot); err != nil {
-			log.WithError(err).Error("Failed to broadcast missing data column sidecars")
-		}
-	})
-
-	return nil
-}
-
-func (s *Service) broadcastMissingDataColumnSidecars(
-	slot primitives.Slot,
-	proposerIndex primitives.ValidatorIndex,
-	root [fieldparams.RootLength]byte,
-	timeIntoSlot time.Duration,
-) error {
-	// Get the node ID.
-	nodeID := s.cfg.p2p.NodeID()
-
-	// Retrieve the local node info.
-	custodyGroupCount, err := s.cfg.p2p.CustodyGroupCount()
-	if err != nil {
-		return errors.Wrap(err, "custody group count")
-	}
-
-	localNodeInfo, _, err := peerdas.Info(nodeID, custodyGroupCount)
-	if err != nil {
-		return errors.Wrap(err, "peerdas info")
-	}
-
-	// Compute the missing data columns (data columns we should custody but we did not received via gossip.)
-	missingColumns := make([]uint64, 0, len(localNodeInfo.CustodyColumns))
-	for column := range localNodeInfo.CustodyColumns {
-		if !s.hasSeenDataColumnIndex(slot, proposerIndex, column) {
-			missingColumns = append(missingColumns, column)
-		}
-	}
-
-	// Return early if there are no missing data columns.
-	if len(missingColumns) == 0 {
-		return nil
-	}
-
-	// Load from the store the non received but reconstructed data column.
-	verifiedRODataColumnSidecars, err := s.cfg.dataColumnStorage.Get(root, missingColumns)
-	if err != nil {
-		return errors.Wrap(err, "data column storage get")
-	}
-
-	broadcastedColumns := make([]uint64, 0, len(verifiedRODataColumnSidecars))
-	for _, verifiedRODataColumn := range verifiedRODataColumnSidecars {
-		broadcastedColumns = append(broadcastedColumns, verifiedRODataColumn.Index)
-		// Compute the subnet for this column.
-		subnet := peerdas.ComputeSubnetForDataColumnSidecar(verifiedRODataColumn.Index)
-
-		// Broadcast the missing data column.
-		if err := s.cfg.p2p.BroadcastDataColumnSidecar(root, subnet, verifiedRODataColumn.DataColumnSidecar); err != nil {
-			log.WithError(err).Error("Broadcast data column")
-		}
-
-		// Now, we can set the data column as seen.
-		s.setSeenDataColumnIndex(slot, proposerIndex, verifiedRODataColumn.Index)
-	}
-
-	if logrus.GetLevel() >= logrus.DebugLevel {
-		// Sort for nice logging.
-		slices.Sort(broadcastedColumns)
-		slices.Sort(missingColumns)
-
-		log.WithFields(logrus.Fields{
-			"timeIntoSlot":   timeIntoSlot,
-			"missingColumns": missingColumns,
-			"broadcasted":    broadcastedColumns,
-		}).Debug("Start broadcasting not seen via gossip but reconstructed data columns")
-	}
-
-	return nil
+	timeIntoSlot := time.Duration(maxReconstructionDelaySec * randFloat * float64(time.Second))
+	return timeIntoSlot
 }

beacon-chain/sync/data_columns_reconstruct_test.go

@@ -1,7 +1,11 @@
 package sync
 
 import (
+	"fmt"
 	"testing"
+	"time"
+
+	"math/rand"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	mockChain "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
@@ -9,12 +13,11 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
 )
 
-func TestReconstructDataColumns(t *testing.T) {
+func TestProcessDataColumnSidecarsFromReconstruction(t *testing.T) {
 	const blobCount = 4
 	numberOfColumns := params.BeaconConfig().NumberOfColumns
 
@@ -27,9 +30,6 @@ func TestReconstructDataColumns(t *testing.T) {
 	roBlock, _, verifiedRoDataColumns := util.GenerateTestFuluBlockWithSidecars(t, blobCount)
 	require.Equal(t, numberOfColumns, uint64(len(verifiedRoDataColumns)))
 
-	root, block := roBlock.Root(), roBlock.Block()
-	slot, proposerIndex := block.Slot(), block.ProposerIndex()
-
 	minimumCount := peerdas.MinimumColumnCountToReconstruct()
 
 	t.Run("not enough stored sidecars", func(t *testing.T) {
@@ -38,7 +38,7 @@ func TestReconstructDataColumns(t *testing.T) {
 		require.NoError(t, err)
 
 		service := NewService(ctx, WithP2P(p2ptest.NewTestP2P(t)), WithDataColumnStorage(storage))
-		err = service.reconstructSaveBroadcastDataColumnSidecars(ctx, slot, proposerIndex, root)
+		err = service.processDataColumnSidecarsFromReconstruction(ctx, verifiedRoDataColumns[0])
 		require.NoError(t, err)
 	})
 
@@ -48,7 +48,7 @@ func TestReconstructDataColumns(t *testing.T) {
 		require.NoError(t, err)
 
 		service := NewService(ctx, WithP2P(p2ptest.NewTestP2P(t)), WithDataColumnStorage(storage))
-		err = service.reconstructSaveBroadcastDataColumnSidecars(ctx, slot, proposerIndex, root)
+		err = service.processDataColumnSidecarsFromReconstruction(ctx, verifiedRoDataColumns[0])
 		require.NoError(t, err)
 	})
 
@@ -60,19 +60,39 @@ func TestReconstructDataColumns(t *testing.T) {
 		// However, for the needs of this test, this is perfectly fine.
 		const cgc = 8
 
-		storage := filesystem.NewEphemeralDataColumnStorage(t)
-		minimumCount := peerdas.MinimumColumnCountToReconstruct()
-		err := storage.Save(verifiedRoDataColumns[:minimumCount])
 		require.NoError(t, err)
 
+		chainService := &mockChain.ChainService{}
+		p2p := p2ptest.NewTestP2P(t)
+		storage := filesystem.NewEphemeralDataColumnStorage(t)
+
 		service := NewService(
 			ctx,
-			WithP2P(p2ptest.NewTestP2P(t)),
+			WithP2P(p2p),
 			WithDataColumnStorage(storage),
-			WithChainService(&mockChain.ChainService{}),
+			WithChainService(chainService),
+			WithOperationNotifier(chainService.OperationNotifier()),
 		)
 
-		err = service.reconstructSaveBroadcastDataColumnSidecars(ctx, slot, proposerIndex, root)
+		minimumCount := peerdas.MinimumColumnCountToReconstruct()
+		receivedBeforeReconstruction := verifiedRoDataColumns[:minimumCount]
+
+		err = service.receiveDataColumnSidecars(ctx, receivedBeforeReconstruction)
+		require.NoError(t, err)
+
+		err = storage.Save(receivedBeforeReconstruction)
+		require.NoError(t, err)
+
+		require.Equal(t, false, p2p.BroadcastCalled.Load())
+
+		// Check received indices before reconstruction.
+		require.Equal(t, minimumCount, uint64(len(chainService.DataColumns)))
+		for i, actual := range chainService.DataColumns {
+			require.Equal(t, uint64(i), actual.Index)
+		}
+
+		// Run the reconstruction.
+		err = service.processDataColumnSidecarsFromReconstruction(ctx, verifiedRoDataColumns[0])
 		require.NoError(t, err)
 
 		expected := make(map[uint64]bool, minimumCount+cgc)
@@ -81,97 +101,38 @@ func TestReconstructDataColumns(t *testing.T) {
 		}
 
 		// The node should custody these indices.
-		for _, i := range [...]uint64{1, 17, 19, 42, 75, 87, 102, 117} {
+		for _, i := range [...]uint64{75, 87, 102, 117} {
 			expected[i] = true
 		}
 
-		summary := storage.Summary(root)
-		actual := summary.Stored()
+		block := roBlock.Block()
+		slot := block.Slot()
+		proposerIndex := block.ProposerIndex()
 
-		require.Equal(t, len(expected), len(actual))
-		for index := range expected {
-			require.Equal(t, true, actual[index])
-		}
-	})
-}
-
-func TestBroadcastMissingDataColumnSidecars(t *testing.T) {
-	const (
-		cgc          = 8
-		blobCount    = 4
-		timeIntoSlot = 0
-	)
-
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-	ctx := t.Context()
-
-	// Start the trusted setup.
-	err := kzg.Start()
-	require.NoError(t, err)
-
-	roBlock, _, verifiedRoDataColumns := util.GenerateTestFuluBlockWithSidecars(t, blobCount)
-	require.Equal(t, numberOfColumns, uint64(len(verifiedRoDataColumns)))
-
-	root, block := roBlock.Root(), roBlock.Block()
-	slot, proposerIndex := block.Slot(), block.ProposerIndex()
-
-	t.Run("no missing sidecars", func(t *testing.T) {
-		service := NewService(
-			ctx,
-			WithP2P(p2ptest.NewTestP2P(t)),
-		)
-
-		for _, index := range [...]uint64{1, 17, 19, 42, 75, 87, 102, 117} {
-			key := computeCacheKey(slot, proposerIndex, index)
-			service.seenDataColumnCache.Add(slot, key, true)
-		}
-
-		err := service.broadcastMissingDataColumnSidecars(slot, proposerIndex, root, timeIntoSlot)
-		require.NoError(t, err)
-	})
-
-	t.Run("some missing sidecars", func(t *testing.T) {
-		toSave := make([]blocks.VerifiedRODataColumn, 0, 2)
-		for _, index := range [...]uint64{42, 87} {
-			toSave = append(toSave, verifiedRoDataColumns[index])
-		}
-
-		p2p := p2ptest.NewTestP2P(t)
-		storage := filesystem.NewEphemeralDataColumnStorage(t)
-		err := storage.Save(toSave)
-		require.NoError(t, err)
-
-		service := NewService(
-			ctx,
-			WithP2P(p2p),
-			WithDataColumnStorage(storage),
-		)
-		_, _, err = service.cfg.p2p.UpdateCustodyInfo(0, cgc)
-		require.NoError(t, err)
-
-		for _, index := range [...]uint64{1, 17, 19, 102, 117} { // 42, 75 and 87 are missing
-			key := computeCacheKey(slot, proposerIndex, index)
-			service.seenDataColumnCache.Add(slot, key, true)
-		}
-
-		for _, index := range [...]uint64{42, 75, 87} {
-			seen := service.hasSeenDataColumnIndex(slot, proposerIndex, index)
-			require.Equal(t, false, seen)
-		}
-
-		require.Equal(t, false, p2p.BroadcastCalled.Load())
-
-		err = service.broadcastMissingDataColumnSidecars(slot, proposerIndex, root, timeIntoSlot)
-		require.NoError(t, err)
-
-		seen := service.hasSeenDataColumnIndex(slot, proposerIndex, 75)
-		require.Equal(t, false, seen)
-
-		for _, index := range [...]uint64{42, 87} {
-			seen := service.hasSeenDataColumnIndex(slot, proposerIndex, index)
-			require.Equal(t, true, seen)
+		require.Equal(t, len(expected), len(chainService.DataColumns))
+		for _, actual := range chainService.DataColumns {
+			require.Equal(t, true, expected[actual.Index])
+			require.Equal(t, true, service.hasSeenDataColumnIndex(slot, proposerIndex, actual.Index))
 		}
 
 		require.Equal(t, true, p2p.BroadcastCalled.Load())
 	})
 }
+
+func TestComputeRandomDelay(t *testing.T) {
+	const (
+		seed     = 42
+		expected = 746056722 * time.Nanosecond // = 0.746056722 seconds
+	)
+	slotStartTime := time.Date(2020, 12, 30, 0, 0, 0, 0, time.UTC)
+
+	service := NewService(
+		t.Context(),
+		WithP2P(p2ptest.NewTestP2P(t)),
+		WithReconstructionRandGen(rand.New(rand.NewSource(seed))),
+	)
+
+	waitingTime := service.computeRandomDelay(slotStartTime)
+	fmt.Print(waitingTime)
+	require.Equal(t, expected, waitingTime)
+}

beacon-chain/sync/options.go

@@ -6,10 +6,10 @@ import (
 	blockfeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/block"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings"
@@ -20,6 +20,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/sync/backfill/coverage"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
+	"github.com/OffchainLabs/prysm/v6/crypto/rand"
 )
 
 type Option func(s *Service) error
@@ -229,3 +230,11 @@ func WithBatchVerifierLimit(limit int) Option {
 		return nil
 	}
 }
+
+// WithReconstructionRandGen sets the random generator for reconstruction delays.
+func WithReconstructionRandGen(rg *rand.Rand) Option {
+	return func(s *Service) error {
+		s.reconstructionRandGen = rg
+		return nil
+	}
+}

beacon-chain/sync/rpc_light_client.go

@@ -112,7 +112,15 @@ func (s *Service) lightClientUpdatesByRangeRPCHandler(ctx context.Context, msg i
 
 	logger.Infof("LC: requesting updates by range (StartPeriod: %d, EndPeriod: %d)", r.StartPeriod, r.StartPeriod+r.Count-1)
 
-	updates, err := s.lcStore.LightClientUpdates(ctx, r.StartPeriod, endPeriod)
+	headBlock, err := s.cfg.chain.HeadBlock(ctx)
+	if err != nil {
+		s.writeErrorResponseToStream(responseCodeServerError, types.ErrGeneric.Error(), stream)
+		tracing.AnnotateError(span, err)
+		logger.WithError(err).Error("Cannot retrieve head block")
+		return err
+	}
+
+	updates, err := s.lcStore.LightClientUpdates(ctx, r.StartPeriod, endPeriod, headBlock)
 	if err != nil {
 		s.writeErrorResponseToStream(responseCodeServerError, types.ErrGeneric.Error(), stream)
 		tracing.AnnotateError(span, err)

beacon-chain/sync/rpc_light_client_test.go

@@ -8,14 +8,15 @@ import (
 	"github.com/OffchainLabs/prysm/v6/async/abool"
 	"github.com/OffchainLabs/prysm/v6/async/event"
 	mockChain "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	db "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"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/startup"
 	mockSync "github.com/OffchainLabs/prysm/v6/beacon-chain/sync/initial-sync/testing"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	leakybucket "github.com/OffchainLabs/prysm/v6/container/leaky-bucket"
 	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -43,6 +44,8 @@ func TestRPC_LightClientBootstrap(t *testing.T) {
 		Genesis:        time.Unix(time.Now().Unix(), 0),
 	}
 	d := db.SetupDB(t)
+	lcStore := lightClient.NewLightClientStore(&p2ptest.FakeP2P{}, new(event.Feed), d)
+
 	r := Service{
 		ctx: ctx,
 		cfg: &config{
@@ -54,7 +57,7 @@ func TestRPC_LightClientBootstrap(t *testing.T) {
 			stateNotifier: &mockChain.MockStateNotifier{},
 		},
 		chainStarted: abool.New(),
-		lcStore:      lightClient.NewLightClientStore(d, &p2ptest.FakeP2P{}, new(event.Feed)),
+		lcStore:      lcStore,
 		subHandler:   newSubTopicHandler(),
 		rateLimiter:  newRateLimiter(p1),
 	}
@@ -159,6 +162,8 @@ func TestRPC_LightClientOptimisticUpdate(t *testing.T) {
 		Genesis:        time.Unix(time.Now().Unix(), 0),
 	}
 	d := db.SetupDB(t)
+	lcStore := lightClient.NewLightClientStore(&p2ptest.FakeP2P{}, new(event.Feed), d)
+
 	r := Service{
 		ctx: ctx,
 		cfg: &config{
@@ -170,7 +175,7 @@ func TestRPC_LightClientOptimisticUpdate(t *testing.T) {
 			stateNotifier: &mockChain.MockStateNotifier{},
 		},
 		chainStarted: abool.New(),
-		lcStore:      lightClient.NewLightClientStore(d, &p2ptest.FakeP2P{}, new(event.Feed)),
+		lcStore:      lcStore,
 		subHandler:   newSubTopicHandler(),
 		rateLimiter:  newRateLimiter(p1),
 	}
@@ -274,6 +279,8 @@ func TestRPC_LightClientFinalityUpdate(t *testing.T) {
 		Genesis:        time.Unix(time.Now().Unix(), 0),
 	}
 	d := db.SetupDB(t)
+	lcStore := lightClient.NewLightClientStore(&p2ptest.FakeP2P{}, new(event.Feed), d)
+
 	r := Service{
 		ctx: ctx,
 		cfg: &config{
@@ -285,7 +292,7 @@ func TestRPC_LightClientFinalityUpdate(t *testing.T) {
 			stateNotifier: &mockChain.MockStateNotifier{},
 		},
 		chainStarted: abool.New(),
-		lcStore:      lightClient.NewLightClientStore(d, &p2ptest.FakeP2P{}, new(event.Feed)),
+		lcStore:      lcStore,
 		subHandler:   newSubTopicHandler(),
 		rateLimiter:  newRateLimiter(p1),
 	}
@@ -384,11 +391,19 @@ func TestRPC_LightClientUpdatesByRange(t *testing.T) {
 	p1.Connect(p2)
 	require.Equal(t, 1, len(p1.BHost.Network().Peers()), "Expected peers to be connected")
 
+	blk := util.NewBeaconBlock()
+	signedBlk, err := blocks.NewSignedBeaconBlock(blk)
+	require.NoError(t, err)
+
 	chainService := &mockChain.ChainService{
 		ValidatorsRoot: [32]byte{'A'},
 		Genesis:        time.Unix(time.Now().Unix(), 0),
+		Block:          signedBlk,
 	}
 	d := db.SetupDB(t)
+	lcStore := lightClient.NewLightClientStore(&p2ptest.FakeP2P{}, new(event.Feed), d)
+	require.NoError(t, err)
+
 	r := Service{
 		ctx: ctx,
 		cfg: &config{
@@ -400,7 +415,7 @@ func TestRPC_LightClientUpdatesByRange(t *testing.T) {
 			stateNotifier: &mockChain.MockStateNotifier{},
 		},
 		chainStarted: abool.New(),
-		lcStore:      lightClient.NewLightClientStore(d, &p2ptest.FakeP2P{}, new(event.Feed)),
+		lcStore:      lcStore,
 		subHandler:   newSubTopicHandler(),
 		rateLimiter:  newRateLimiter(p1),
 	}
@@ -472,7 +487,7 @@ func TestRPC_LightClientUpdatesByRange(t *testing.T) {
 					t.Fatalf("unsupported version %d", i)
 				}
 
-				updates, err := r.lcStore.LightClientUpdates(ctx, 0, 4)
+				updates, err := r.lcStore.LightClientUpdates(ctx, 0, 4, signedBlk)
 				require.NoError(t, err)
 				updateSSZ, err := updates[uint64(responseCounter)].MarshalSSZ()
 				require.NoError(t, err)

beacon-chain/sync/service.go

@@ -17,10 +17,10 @@ import (
 	blockfeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/block"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings"
@@ -50,6 +50,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/trailofbits/go-mutexasserts"
+	"golang.org/x/sync/singleflight"
 )
 
 var _ runtime.Service = (*Service)(nil)
@@ -170,8 +171,9 @@ type Service struct {
 	verifierWaiter                   *verification.InitializerWaiter
 	newBlobVerifier                  verification.NewBlobVerifier
 	newColumnsVerifier               verification.NewDataColumnsVerifier
+	columnSidecarsExecSingleFlight   singleflight.Group
+	reconstructionSingleFlight       singleflight.Group
 	availableBlocker                 coverage.AvailableBlocker
-	reconstructionLock               sync.Mutex
 	reconstructionRandGen            *rand.Rand
 	trackedValidatorsCache           *cache.TrackedValidatorsCache
 	ctxMap                           ContextByteVersions

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -5,16 +5,20 @@ import (
 	"fmt"
 	"os"
 	"path"
+	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition/interop"
 	"github.com/OffchainLabs/prysm/v6/config/features"
+	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/io/file"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
+	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"google.golang.org/protobuf/proto"
 )
@@ -37,7 +41,12 @@ func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 		return err
 	}
 
-	go s.processSidecarsFromExecution(ctx, signed)
+	roBlock, err := blocks.NewROBlockWithRoot(signed, root)
+	if err != nil {
+		return errors.Wrap(err, "new ro block with root")
+	}
+
+	go s.processSidecarsFromExecutionFromBlock(ctx, roBlock)
 
 	if err := s.cfg.chain.ReceiveBlock(ctx, signed, root, nil); err != nil {
 		if blockchain.IsInvalidBlock(err) {
@@ -61,103 +70,21 @@ func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 	return err
 }
 
-// processSidecarsFromExecution retrieves (if available) sidecars data from the execution client,
+// processSidecarsFromExecutionFromBlock retrieves (if available) sidecars data from the execution client,
 // builds corresponding sidecars, save them to the storage, and broadcasts them over P2P if necessary.
-func (s *Service) processSidecarsFromExecution(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) {
-	if block.Version() >= version.Fulu {
-		s.processDataColumnSidecarsFromExecution(ctx, block)
-		return
-	}
-
-	if block.Version() >= version.Deneb {
-		s.processBlobSidecarsFromExecution(ctx, block)
-		return
-	}
-}
-
-// processDataColumnSidecarsFromExecution retrieves (if available) data column sidecars data from the execution client,
-// builds corresponding sidecars, save them to the storage, and broadcasts them over P2P if necessary.
-func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, roSignedBlock interfaces.ReadOnlySignedBeaconBlock) {
-	block := roSignedBlock.Block()
-
-	log := log.WithFields(logrus.Fields{
-		"slot":          block.Slot(),
-		"proposerIndex": block.ProposerIndex(),
-	})
-
-	kzgCommitments, err := block.Body().BlobKzgCommitments()
-	if err != nil {
-		log.WithError(err).Error("Failed to read commitments from block")
-		return
-	}
-
-	if len(kzgCommitments) == 0 {
-		// No blobs to reconstruct.
-		return
-	}
-
-	blockRoot, err := block.HashTreeRoot()
-	if err != nil {
-		log.WithError(err).Error("Failed to calculate block root")
-		return
-	}
-
-	log = log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot))
-
-	if s.cfg.dataColumnStorage == nil {
-		log.Warning("Data column storage is not enabled, skip saving data column, but continue to reconstruct and broadcast data column")
-	}
-
-	// When this function is called, it's from the time when the block is received, so in almost all situations we need to get the data column from EL instead of the blob storage.
-	sidecars, err := s.cfg.executionReconstructor.ReconstructDataColumnSidecars(ctx, roSignedBlock, blockRoot)
-	if err != nil {
-		log.WithError(err).Debug("Cannot reconstruct data column sidecars after receiving the block")
-		return
-	}
-
-	// Return early if no blobs are retrieved from the EL.
-	if len(sidecars) == 0 {
-		return
-	}
-
-	nodeID := s.cfg.p2p.NodeID()
-	custodyGroupCount, err := s.cfg.p2p.CustodyGroupCount()
-	if err != nil {
-		log.WithError(err).Error("Failed to get custody group count")
-		return
-	}
-
-	info, _, err := peerdas.Info(nodeID, custodyGroupCount)
-	if err != nil {
-		log.WithError(err).Error("Failed to get peer info")
-		return
-	}
-
-	blockSlot := block.Slot()
-	proposerIndex := block.ProposerIndex()
-
-	// Broadcast and save data column sidecars to custody but not yet received.
-	sidecarCount := uint64(len(sidecars))
-	for columnIndex := range info.CustodyColumns {
-		log := log.WithField("columnIndex", columnIndex)
-		if columnIndex >= sidecarCount {
-			log.Error("Column custody index out of range - should never happen")
-			continue
+func (s *Service) processSidecarsFromExecutionFromBlock(ctx context.Context, roBlock blocks.ROBlock) {
+	if roBlock.Version() >= version.Fulu {
+		if err := s.processDataColumnSidecarsFromExecution(ctx, peerdas.PopulateFromBlock(roBlock)); err != nil {
+			log.WithError(err).Error("Failed to process data column sidecars from execution")
+			return
 		}
 
-		if s.hasSeenDataColumnIndex(blockSlot, proposerIndex, columnIndex) {
-			continue
-		}
+		return
+	}
 
-		sidecar := sidecars[columnIndex]
-
-		if err := s.cfg.p2p.BroadcastDataColumnSidecar(blockRoot, sidecar.Index, sidecar.DataColumnSidecar); err != nil {
-			log.WithError(err).Error("Failed to broadcast data column")
-		}
-
-		if err := s.receiveDataColumnSidecar(ctx, sidecar); err != nil {
-			log.WithError(err).Error("Failed to receive data column")
-		}
+	if roBlock.Version() >= version.Deneb {
+		s.processBlobSidecarsFromExecution(ctx, roBlock)
+		return
 	}
 }
 
@@ -230,6 +157,170 @@ func (s *Service) processBlobSidecarsFromExecution(ctx context.Context, block in
 	}
 }
 
+// processDataColumnSidecarsFromExecution retrieves (if available) data column sidecars data from the execution client,
+// builds corresponding sidecars, save them to the storage, and broadcasts them over P2P if necessary.
+func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, source peerdas.ConstructionPopulator) error {
+	key := fmt.Sprintf("%#x", source.Root())
+	if _, err, _ := s.columnSidecarsExecSingleFlight.Do(key, func() (interface{}, error) {
+		const delay = 250 * time.Millisecond
+		secondsPerHalfSlot := time.Duration(params.BeaconConfig().SecondsPerSlot/2) * time.Second
+
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+		commitments, err := source.Commitments()
+		if err != nil {
+			return nil, errors.Wrap(err, "blob kzg commitments")
+		}
+
+		// Exit early if there are no commitments.
+		if len(commitments) == 0 {
+			return nil, nil
+		}
+
+		// Retrieve the indices of sidecars we should sample.
+		columnIndicesToSample, err := s.columnIndicesToSample()
+		if err != nil {
+			return nil, errors.Wrap(err, "column indices to sample")
+		}
+
+		ctx, cancel := context.WithTimeout(ctx, secondsPerHalfSlot)
+		defer cancel()
+
+		for iteration := uint64(0); ; /*no stop condition*/ iteration++ {
+			// Exit early if all sidecars to sample have been seen.
+			if s.haveAllSidecarsBeenSeen(source.Slot(), source.ProposerIndex(), columnIndicesToSample) {
+				return nil, nil
+			}
+
+			// Try to reconstruct data column constructedSidecars from the execution client.
+			constructedSidecars, err := s.cfg.executionReconstructor.ConstructDataColumnSidecars(ctx, source)
+			if err != nil {
+				return nil, errors.Wrap(err, "reconstruct data column sidecars")
+			}
+
+			// No sidecars are retrieved from the EL, retry later
+			sidecarCount := uint64(len(constructedSidecars))
+			if sidecarCount == 0 {
+				if ctx.Err() != nil {
+					return nil, ctx.Err()
+				}
+
+				time.Sleep(delay)
+				continue
+			}
+
+			// Boundary check.
+			if sidecarCount != numberOfColumns {
+				return nil, errors.Errorf("reconstruct data column sidecars returned %d sidecars, expected %d - should never happen", sidecarCount, numberOfColumns)
+			}
+
+			unseenIndices, err := s.broadcastAndReceiveUnseenDataColumnSidecars(ctx, source.Slot(), source.ProposerIndex(), columnIndicesToSample, constructedSidecars)
+			if err != nil {
+				return nil, errors.Wrap(err, "broadcast and receive unseen data column sidecars")
+			}
+
+			if len(unseenIndices) > 0 {
+				log.WithFields(logrus.Fields{
+					"root":          fmt.Sprintf("%#x", source.Root()),
+					"slot":          source.Slot(),
+					"proposerIndex": source.ProposerIndex(),
+					"iteration":     iteration,
+					"type":          source.Type(),
+					"count":         len(unseenIndices),
+					"indices":       sortedSliceFromMap(unseenIndices),
+				}).Debug("Constructed data column sidecars from the execution client")
+			}
+
+			return nil, nil
+		}
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// broadcastAndReceiveUnseenDataColumnSidecars broadcasts and receives unseen data column sidecars.
+func (s *Service) broadcastAndReceiveUnseenDataColumnSidecars(
+	ctx context.Context,
+	slot primitives.Slot,
+	proposerIndex primitives.ValidatorIndex,
+	neededIndices map[uint64]bool,
+	sidecars []blocks.VerifiedRODataColumn,
+) (map[uint64]bool, error) {
+	// Compute sidecars we need to broadcast and receive.
+	unseenSidecars := make([]blocks.VerifiedRODataColumn, 0, len(sidecars))
+	unseenIndices := make(map[uint64]bool, len(sidecars))
+	for _, sidecar := range sidecars {
+		// Skip data column sidecars we don't need.
+		if !neededIndices[sidecar.Index] {
+			continue
+		}
+
+		// Skip already seen data column sidecars.
+		if s.hasSeenDataColumnIndex(slot, proposerIndex, sidecar.Index) {
+			continue
+		}
+
+		unseenSidecars = append(unseenSidecars, sidecar)
+		unseenIndices[sidecar.Index] = true
+	}
+
+	// Broadcast all the data column sidecars we reconstructed but did not see via gossip.
+	for _, sidecar := range unseenSidecars {
+		// Compute the subnet for this data column sidecar.
+		subnet := peerdas.ComputeSubnetForDataColumnSidecar(sidecar.Index)
+
+		// Broadcast the data column sidecar.
+		if err := s.cfg.p2p.BroadcastDataColumnSidecar(subnet, sidecar); err != nil {
+			// Don't return on error on broadcast failure, just log it.
+			log.WithError(err).Error("Broadcast data column")
+		}
+	}
+
+	// Receive data column sidecars.
+	if err := s.receiveDataColumnSidecars(ctx, unseenSidecars); err != nil {
+		return nil, errors.Wrap(err, "receive data column sidecars")
+	}
+
+	return unseenIndices, nil
+}
+
+// haveAllSidecarsBeenSeen checks if all sidecars for the given slot, proposer index, and data column indices have been seen.
+func (s *Service) haveAllSidecarsBeenSeen(slot primitives.Slot, proposerIndex primitives.ValidatorIndex, indices map[uint64]bool) bool {
+	for index := range indices {
+		if !s.hasSeenDataColumnIndex(slot, proposerIndex, index) {
+			return false
+		}
+	}
+	return true
+}
+
+// columnIndicesToSample returns the data column indices we should sample for the node.
+func (s *Service) columnIndicesToSample() (map[uint64]bool, error) {
+	// Retrieve our node ID.
+	nodeID := s.cfg.p2p.NodeID()
+
+	// Get the custody group sampling size for the node.
+	custodyGroupCount, err := s.cfg.p2p.CustodyGroupCount()
+	if err != nil {
+		return nil, errors.Wrap(err, "custody group count")
+	}
+
+	// Compute the sampling size.
+	// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#custody-sampling
+	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
+	samplingSize := max(samplesPerSlot, custodyGroupCount)
+
+	// Get the peer info for the node.
+	peerInfo, _, err := peerdas.Info(nodeID, samplingSize)
+	if err != nil {
+		return nil, errors.Wrap(err, "peer info")
+	}
+
+	return peerInfo.CustodyColumns, nil
+}
+
 // WriteInvalidBlockToDisk as a block ssz. Writes to temp directory.
 func saveInvalidBlockToTemp(block interfaces.ReadOnlySignedBeaconBlock) {
 	if !features.Get().SaveInvalidBlock {

beacon-chain/sync/subscriber_beacon_blocks_test.go

@@ -1,7 +1,6 @@
 package sync
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain"
@@ -135,7 +134,7 @@ func TestService_BeaconBlockSubscribe_UndefinedEeError(t *testing.T) {
 	require.Equal(t, 1, len(s.seenBlockCache.Keys()))
 }
 
-func TestReconstructAndBroadcastBlobs(t *testing.T) {
+func TestProcessSidecarsFromExecutionFromBlock(t *testing.T) {
 	t.Run("blobs", func(t *testing.T) {
 		rob, err := blocks.NewROBlob(
 			&ethpb.BlobSidecar{
@@ -158,6 +157,9 @@ func TestReconstructAndBroadcastBlobs(t *testing.T) {
 		sb, err := blocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
 
+		roBlock, err := blocks.NewROBlock(sb)
+		require.NoError(t, err)
+
 		tests := []struct {
 			name              string
 			blobSidecars      []blocks.VerifiedROBlob
@@ -192,7 +194,7 @@ func TestReconstructAndBroadcastBlobs(t *testing.T) {
 					},
 					seenBlobCache: lruwrpr.New(1),
 				}
-				s.processSidecarsFromExecution(context.Background(), sb)
+				s.processSidecarsFromExecutionFromBlock(t.Context(), roBlock)
 				require.Equal(t, tt.expectedBlobCount, len(chainService.Blobs))
 			})
 		}
@@ -253,7 +255,7 @@ func TestReconstructAndBroadcastBlobs(t *testing.T) {
 				name:                    "Constructed 128 data columns with all blobs",
 				blobCount:               1,
 				dataColumnSidecars:      allColumns,
-				expectedDataColumnCount: 4, // default is 4
+				expectedDataColumnCount: 8,
 			},
 		}
 
@@ -261,10 +263,10 @@ func TestReconstructAndBroadcastBlobs(t *testing.T) {
 			t.Run(tt.name, func(t *testing.T) {
 				s := Service{
 					cfg: &config{
-						p2p:         mockp2p.NewTestP2P(t),
-						chain:       chainService,
-						clock:       startup.NewClock(time.Now(), [32]byte{}),
-						blobStorage: filesystem.NewEphemeralBlobStorage(t),
+						p2p:               mockp2p.NewTestP2P(t),
+						chain:             chainService,
+						clock:             startup.NewClock(time.Now(), [32]byte{}),
+						dataColumnStorage: filesystem.NewEphemeralDataColumnStorage(t),
 						executionReconstructor: &mockExecution.EngineClient{
 							DataColumnSidecars: tt.dataColumnSidecars,
 						},
@@ -288,10 +290,91 @@ func TestReconstructAndBroadcastBlobs(t *testing.T) {
 				sb, err := blocks.NewSignedBeaconBlock(b)
 				require.NoError(t, err)
 
-				s.processSidecarsFromExecution(context.Background(), sb)
+				roBlock, err := blocks.NewROBlock(sb)
+				require.NoError(t, err)
+
+				s.processSidecarsFromExecutionFromBlock(t.Context(), roBlock)
 				require.Equal(t, tt.expectedDataColumnCount, len(chainService.DataColumns))
 			})
 		}
 	})
-
+}
+
+func TestHaveAllSidecarsBeenSeen(t *testing.T) {
+	const (
+		slot          = 42
+		proposerIndex = 1664
+	)
+	service := NewService(t.Context(), WithP2P(mockp2p.NewTestP2P(t)))
+	service.initCaches()
+
+	service.setSeenDataColumnIndex(slot, proposerIndex, 1)
+	service.setSeenDataColumnIndex(slot, proposerIndex, 3)
+
+	testCases := []struct {
+		name     string
+		toSample map[uint64]bool
+		expected bool
+	}{
+		{
+			name:     "all sidecars seen",
+			toSample: map[uint64]bool{1: true, 3: true},
+			expected: true,
+		},
+		{
+			name:     "not all sidecars seen",
+			toSample: map[uint64]bool{1: true, 2: true, 3: true},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := service.haveAllSidecarsBeenSeen(slot, proposerIndex, tc.toSample)
+			require.Equal(t, tc.expected, actual)
+		})
+	}
+}
+
+func TestColumnIndicesToSample(t *testing.T) {
+	const earliestAvailableSlot = 0
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig()
+	cfg.SamplesPerSlot = 4
+	params.OverrideBeaconConfig(cfg)
+
+	testCases := []struct {
+		name              string
+		custodyGroupCount uint64
+		expected          map[uint64]bool
+	}{
+		{
+			name:              "custody group count lower than samples per slot",
+			custodyGroupCount: 3,
+			expected:          map[uint64]bool{1: true, 17: true, 87: true, 102: true},
+		},
+		{
+			name:              "custody group count higher than samples per slot",
+			custodyGroupCount: 5,
+			expected:          map[uint64]bool{1: true, 17: true, 75: true, 87: true, 102: true},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			p2p := mockp2p.NewTestP2P(t)
+			_, _, err := p2p.UpdateCustodyInfo(earliestAvailableSlot, tc.custodyGroupCount)
+			require.NoError(t, err)
+
+			service := NewService(t.Context(), WithP2P(p2p))
+
+			actual, err := service.columnIndicesToSample()
+			require.NoError(t, err)
+
+			require.Equal(t, len(tc.expected), len(actual))
+			for index := range tc.expected {
+				require.Equal(t, true, actual[index])
+			}
+		})
+	}
 }

beacon-chain/sync/subscriber_data_column_sidecar.go

@@ -6,14 +6,19 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
 	opfeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/operation"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/pkg/errors"
+	"golang.org/x/sync/errgroup"
 	"google.golang.org/protobuf/proto"
 )
 
+// dataColumnSubscriber is the subscriber function for data column sidecars.
 func (s *Service) dataColumnSubscriber(ctx context.Context, msg proto.Message) error {
+	var wg errgroup.Group
+
 	sidecar, ok := msg.(blocks.VerifiedRODataColumn)
 	if !ok {
 		return fmt.Errorf("message was not type blocks.VerifiedRODataColumn, type=%T", msg)
@@ -23,34 +28,57 @@ func (s *Service) dataColumnSubscriber(ctx context.Context, msg proto.Message) e
 		return errors.Wrap(err, "receive data column sidecar")
 	}
 
-	slot := sidecar.Slot()
-	proposerIndex := sidecar.ProposerIndex()
-	root := sidecar.BlockRoot()
+	wg.Go(func() error {
+		if err := s.processDataColumnSidecarsFromReconstruction(ctx, sidecar); err != nil {
+			return errors.Wrap(err, "process data column sidecars from reconstruction")
+		}
 
-	if err := s.reconstructSaveBroadcastDataColumnSidecars(ctx, slot, proposerIndex, root); err != nil {
-		return errors.Wrap(err, "reconstruct/save/broadcast data column sidecars")
+		return nil
+	})
+
+	wg.Go(func() error {
+		if err := s.processDataColumnSidecarsFromExecution(ctx, peerdas.PopulateFromSidecar(sidecar)); err != nil {
+			return errors.Wrap(err, "process data column sidecars from execution")
+		}
+
+		return nil
+	})
+
+	if err := wg.Wait(); err != nil {
+		return err
 	}
 
 	return nil
 }
 
+// receiveDataColumnSidecar receives a single data column sidecar: marks it as seen and saves it to the chain.
+// Do not loop over this function to receive multiple sidecars, use receiveDataColumnSidecars instead.
 func (s *Service) receiveDataColumnSidecar(ctx context.Context, sidecar blocks.VerifiedRODataColumn) error {
-	slot := sidecar.SignedBlockHeader.Header.Slot
-	proposerIndex := sidecar.SignedBlockHeader.Header.ProposerIndex
-	columnIndex := sidecar.Index
+	return s.receiveDataColumnSidecars(ctx, []blocks.VerifiedRODataColumn{sidecar})
+}
 
-	s.setSeenDataColumnIndex(slot, proposerIndex, columnIndex)
+// receiveDataColumnSidecars receives multiple data column sidecars: marks them as seen and saves them to the chain.
+func (s *Service) receiveDataColumnSidecars(ctx context.Context, sidecars []blocks.VerifiedRODataColumn) error {
+	for _, sidecar := range sidecars {
+		slot := sidecar.SignedBlockHeader.Header.Slot
+		proposerIndex := sidecar.SignedBlockHeader.Header.ProposerIndex
+		columnIndex := sidecar.Index
 
-	if err := s.cfg.chain.ReceiveDataColumn(sidecar); err != nil {
+		s.setSeenDataColumnIndex(slot, proposerIndex, columnIndex)
+	}
+
+	if err := s.cfg.chain.ReceiveDataColumns(sidecars); err != nil {
 		return errors.Wrap(err, "receive data column")
 	}
 
-	s.cfg.operationNotifier.OperationFeed().Send(&feed.Event{
-		Type: opfeed.DataColumnSidecarReceived,
-		Data: &opfeed.DataColumnSidecarReceivedData{
-			DataColumn: &sidecar,
-		},
-	})
+	for _, sidecar := range sidecars {
+		s.cfg.operationNotifier.OperationFeed().Send(&feed.Event{
+			Type: opfeed.DataColumnSidecarReceived,
+			Data: &opfeed.DataColumnSidecarReceivedData{
+				DataColumn: &sidecar,
+			},
+		})
+	}
 
 	return nil
 }

beacon-chain/sync/subscriber_test.go

@@ -12,9 +12,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/async/event"
 	mockChain "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	db "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
@@ -702,6 +702,8 @@ func TestSubscribe_ReceivesLCOptimisticUpdate(t *testing.T) {
 		Genesis:        time.Unix(time.Now().Unix()-int64(genesisDrift), 0),
 	}
 	d := db.SetupDB(t)
+	lcStore := lightClient.NewLightClientStore(&p2ptest.FakeP2P{}, new(event.Feed), d)
+
 	r := Service{
 		ctx: ctx,
 		cfg: &config{
@@ -713,7 +715,7 @@ func TestSubscribe_ReceivesLCOptimisticUpdate(t *testing.T) {
 			stateNotifier: &mockChain.MockStateNotifier{},
 		},
 		chainStarted: abool.New(),
-		lcStore:      lightClient.NewLightClientStore(d, &p2ptest.FakeP2P{}, new(event.Feed)),
+		lcStore:      lcStore,
 		subHandler:   newSubTopicHandler(),
 	}
 	markInitSyncComplete(t, &r)
@@ -732,7 +734,7 @@ func TestSubscribe_ReceivesLCOptimisticUpdate(t *testing.T) {
 
 	r.markForChainStart()
 
-	l := util.NewTestLightClient(t, version.Altair, util.WithSupermajority())
+	l := util.NewTestLightClient(t, version.Altair, util.WithSupermajority(0))
 	update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
 	require.NoError(t, err, "Error generating light client optimistic update")
 
@@ -770,6 +772,8 @@ func TestSubscribe_ReceivesLCFinalityUpdate(t *testing.T) {
 		Genesis:        time.Unix(time.Now().Unix()-int64(genesisDrift), 0),
 	}
 	d := db.SetupDB(t)
+	lcStore := lightClient.NewLightClientStore(&p2ptest.FakeP2P{}, new(event.Feed), d)
+
 	r := Service{
 		ctx: ctx,
 		cfg: &config{
@@ -781,7 +785,7 @@ func TestSubscribe_ReceivesLCFinalityUpdate(t *testing.T) {
 			stateNotifier: &mockChain.MockStateNotifier{},
 		},
 		chainStarted: abool.New(),
-		lcStore:      lightClient.NewLightClientStore(d, &p2ptest.FakeP2P{}, new(event.Feed)),
+		lcStore:      lcStore,
 		subHandler:   newSubTopicHandler(),
 	}
 	markInitSyncComplete(t, &r)
@@ -800,7 +804,7 @@ func TestSubscribe_ReceivesLCFinalityUpdate(t *testing.T) {
 
 	r.markForChainStart()
 
-	l := util.NewTestLightClient(t, version.Altair, util.WithSupermajority())
+	l := util.NewTestLightClient(t, version.Altair, util.WithSupermajority(0))
 	update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 	require.NoError(t, err, "Error generating light client finality update")
 

beacon-chain/sync/validate_light_client.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"time"
 
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"

beacon-chain/sync/validate_light_client_test.go

@@ -7,7 +7,8 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/async/event"
 	mock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"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/startup"
@@ -103,12 +104,13 @@ func TestValidateLightClientOptimisticUpdate(t *testing.T) {
 				// drift back appropriate number of epochs based on fork + 2 slots for signature slot + time for gossip propagation + any extra drift
 				genesisDrift := v*slotsPerEpoch*secondsPerSlot + 2*secondsPerSlot + secondsPerSlot/slotIntervals + test.genesisDrift
 				chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(genesisDrift), 0)}
-				s := &Service{cfg: &config{p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}, lcStore: lightClient.NewLightClientStore(nil, &p2ptest.FakeP2P{}, new(event.Feed))}
+				lcStore := lightClient.NewLightClientStore(&p2ptest.FakeP2P{}, new(event.Feed), testDB.SetupDB(t))
+				s := &Service{cfg: &config{p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}, lcStore: lcStore}
 
 				var oldUpdate interfaces.LightClientOptimisticUpdate
-				var err error
 				if test.oldUpdateOptions != nil {
 					l := util.NewTestLightClient(t, v, test.oldUpdateOptions...)
+					var err error
 					oldUpdate, err = lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
 					require.NoError(t, err)
 
@@ -218,12 +220,12 @@ func TestValidateLightClientFinalityUpdate(t *testing.T) {
 		{
 			name:             "new update is better - supermajority",
 			oldUpdateOptions: []util.LightClientOption{},
-			newUpdateOptions: []util.LightClientOption{util.WithSupermajority()},
+			newUpdateOptions: []util.LightClientOption{util.WithSupermajority(0)},
 			expectedResult:   pubsub.ValidationAccept,
 		},
 		{
 			name:             "old update is better - supermajority",
-			oldUpdateOptions: []util.LightClientOption{util.WithSupermajority()},
+			oldUpdateOptions: []util.LightClientOption{util.WithSupermajority(0)},
 			newUpdateOptions: []util.LightClientOption{},
 			expectedResult:   pubsub.ValidationIgnore,
 		},
@@ -243,12 +245,13 @@ func TestValidateLightClientFinalityUpdate(t *testing.T) {
 				// drift back appropriate number of epochs based on fork + 2 slots for signature slot + time for gossip propagation + any extra drift
 				genesisDrift := v*slotsPerEpoch*secondsPerSlot + 2*secondsPerSlot + secondsPerSlot/slotIntervals + test.genesisDrift
 				chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(genesisDrift), 0)}
-				s := &Service{cfg: &config{p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}, lcStore: lightClient.NewLightClientStore(nil, &p2ptest.FakeP2P{}, new(event.Feed))}
+				lcStore := lightClient.NewLightClientStore(&p2ptest.FakeP2P{}, new(event.Feed), testDB.SetupDB(t))
+				s := &Service{cfg: &config{p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}, lcStore: lcStore}
 
 				var oldUpdate interfaces.LightClientFinalityUpdate
-				var err error
 				if test.oldUpdateOptions != nil {
 					l := util.NewTestLightClient(t, v, test.oldUpdateOptions...)
+					var err error
 					oldUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 					require.NoError(t, err)
 

beacon-chain/verification/data_column_test.go

@@ -30,17 +30,10 @@ func GenerateTestDataColumns(t *testing.T, parent [fieldparams.RootLength]byte,
 	}
 
 	cellsAndProofs := util.GenerateCellsAndProofs(t, blobs)
-	dataColumnSidecars, err := peerdas.DataColumnSidecars(roBlock, cellsAndProofs)
+	roDataColumnSidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(roBlock))
 	require.NoError(t, err)
 
-	roDataColumns := make([]blocks.RODataColumn, 0, len(dataColumnSidecars))
-	for i := range dataColumnSidecars {
-		roDataColumn, err := blocks.NewRODataColumn(dataColumnSidecars[i])
-		require.NoError(t, err)
-		roDataColumns = append(roDataColumns, roDataColumn)
-	}
-
-	return roDataColumns
+	return roDataColumnSidecars
 }
 
 func TestColumnSatisfyRequirement(t *testing.T) {

changelog/bastin_canonical-light-client-updates.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Restrict best LC update collection to canonical blocks.

changelog/bastin_lc-fulu-spectest.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Fulu spec tests coverage for light client tests.

changelog/bastin_move-lc-package-out-of-core.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Moved light-client package out of `beacon-chain/core/` and into `beacon-chain/`.

changelog/hyunchel_fix-misleading-log-msg.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Clarified misleading log messages in beacon-chain/rpc/service gRPC module.

changelog/james-prysm_get-blob-fulu.md

@@ -0,0 +1,3 @@
+### Added
+
+- Added new post fulu /eth/v1/beacon/blobs/{block_id} endpoint

changelog/kasey_fix-e2e-panic.md

@@ -0,0 +1,2 @@
+### Ignored
+- Fix a panic in e2e that is caused by poor context management leading to error assertions being called after test cleanup.

changelog/kasey_rename-backfill-flag.md

@@ -0,0 +1,2 @@
+### Changed
+- Renamed the `--enable-experimental-backfill` flag to `--enable-backfill` to signal that it is more mature.

changelog/manu-broadcast.md

@@ -0,0 +1,4 @@
+### Changed
+- Broadcast block then sidecars, instead block and sidecars concurrently
+- Broadcast and receive sidecars in concurrently, instead sequentially
+

changelog/manu-peerdas-reconstruction-delay.md

@@ -0,0 +1,2 @@
+### Changed 
+- PeerDAS: Wait for a random delay, then reconstruct data column sidecars and immediately reseed instead of immediately reconstructing, waiting and then reseeding.

changelog/muzry_fix_validator_client_committee_index.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Fixed incorrect attestation data request where the assigned committee index was used after Electra, instead of 0.