zip only json

* Remove deposit count from sync new block log

* Fix tests

api/client/beacon/health/health_test.go

@@ -1,7 +1,6 @@
 package health
 
 import (
-	"context"
 	"sync"
 	"testing"
 

api/client/builder/client_test.go

@@ -2,7 +2,6 @@ package builder
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"

api/client/event/event_stream_test.go

@@ -1,7 +1,6 @@
 package event
 
 import (
-	"context"
 	"fmt"
 	"net/http"
 	"net/http/httptest"

api/grpc/grpcutils_test.go

@@ -1,7 +1,6 @@
 package grpc
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/testing/assert"

api/server/httprest/server_test.go

@@ -1,7 +1,6 @@
 package httprest
 
 import (
-	"context"
 	"flag"
 	"fmt"
 	"net"

api/server/middleware/BUILD.bazel

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

api/server/middleware/middleware.go

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

api/server/middleware/middleware_test.go

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

beacon-chain/blockchain/chain_info_norace_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"context"
 	"testing"
 
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"

beacon-chain/blockchain/forkchoice_update_execution_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"context"
 	"testing"
 	"time"
 

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"

beacon-chain/blockchain/init_sync_process_block_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"context"
 	"testing"
 
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"

beacon-chain/blockchain/log.go

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

beacon-chain/blockchain/log_test.go

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

beacon-chain/blockchain/metrics_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"context"
 	"testing"
 
 	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"

beacon-chain/blockchain/options.go

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

beacon-chain/blockchain/process_block.go

@@ -637,7 +637,11 @@ func missingDataColumnIndices(bs *filesystem.DataColumnStorage, root [fieldparam
 // The function will first check the database to see if all sidecars have been persisted. If any
 // sidecars are missing, it will then read from the sidecar notifier channel for the given root until the channel is
 // closed, the context hits cancellation/timeout, or notifications have been received for all the missing sidecars.
-func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signedBlock interfaces.ReadOnlySignedBeaconBlock) error {
+func (s *Service) isDataAvailable(
+	ctx context.Context,
+	root [fieldparams.RootLength]byte,
+	signedBlock interfaces.ReadOnlySignedBeaconBlock,
+) error {
 	block := signedBlock.Block()
 	if block == nil {
 		return errors.New("invalid nil beacon block")
@@ -657,7 +661,11 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signedBloc
 
 // areDataColumnsAvailable blocks until all data columns committed to in the block are available,
 // or an error or context cancellation occurs. A nil result means that the data availability check is successful.
-func (s *Service) areDataColumnsAvailable(ctx context.Context, root [fieldparams.RootLength]byte, block interfaces.ReadOnlyBeaconBlock) error {
+func (s *Service) areDataColumnsAvailable(
+	ctx context.Context,
+	root [fieldparams.RootLength]byte,
+	block interfaces.ReadOnlyBeaconBlock,
+) error {
 	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
 	blockSlot, currentSlot := block.Slot(), s.CurrentSlot()
 	blockEpoch, currentEpoch := slots.ToEpoch(blockSlot), slots.ToEpoch(currentSlot)
@@ -724,6 +732,10 @@ func (s *Service) areDataColumnsAvailable(ctx context.Context, root [fieldparams
 		return nil
 	}
 
+	if s.startWaitingDataColumnSidecars != nil {
+		s.startWaitingDataColumnSidecars <- true
+	}
+
 	// Log for DA checks that cross over into the next slot; helpful for debugging.
 	nextSlot := slots.BeginsAt(block.Slot()+1, s.genesisTime)
 

beacon-chain/blockchain/process_block_test.go

@@ -3332,17 +3332,27 @@ func testIsAvailableSetup(t *testing.T, params testIsAvailableParams) (context.C
 	signedBeaconBlock, err := util.GenerateFullBlockFulu(genesisState, secretKeys, conf, 10 /*block slot*/)
 	require.NoError(t, err)
 
-	root, err := signedBeaconBlock.Block.HashTreeRoot()
+	block := signedBeaconBlock.Block
+	bodyRoot, err := block.Body.HashTreeRoot()
 	require.NoError(t, err)
 
-	dataColumnsParams := make([]util.DataColumnParams, 0, len(params.columnsToSave))
+	root, err := block.HashTreeRoot()
+	require.NoError(t, err)
+
+	dataColumnsParams := make([]util.DataColumnParam, 0, len(params.columnsToSave))
 	for _, i := range params.columnsToSave {
-		dataColumnParam := util.DataColumnParams{ColumnIndex: i}
+		dataColumnParam := util.DataColumnParam{
+			Index:         i,
+			Slot:          block.Slot,
+			ProposerIndex: block.ProposerIndex,
+			ParentRoot:    block.ParentRoot,
+			StateRoot:     block.StateRoot,
+			BodyRoot:      bodyRoot[:],
+		}
 		dataColumnsParams = append(dataColumnsParams, dataColumnParam)
 	}
 
-	dataColumnParamsByBlockRoot := util.DataColumnsParamsByRoot{root: dataColumnsParams}
-	_, verifiedRODataColumns := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParamsByBlockRoot)
+	_, verifiedRODataColumns := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnsParams)
 
 	err = dataColumnStorage.Save(verifiedRODataColumns)
 	require.NoError(t, err)
@@ -3402,38 +3412,47 @@ func TestIsDataAvailable(t *testing.T) {
 	})
 
 	t.Run("Fulu - some initially missing data columns (no reconstruction)", func(t *testing.T) {
+		startWaiting := make(chan bool)
+
 		testParams := testIsAvailableParams{
-			options:       []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
+			options:       []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave: []uint64{1, 17, 19, 75, 102, 117, 119}, // 119 is not needed, 42 and 87 are missing
 
 			blobKzgCommitmentsCount: 3,
 		}
 
 		ctx, _, service, root, signed := testIsAvailableSetup(t, testParams)
+		block := signed.Block()
+		slot := block.Slot()
+		proposerIndex := block.ProposerIndex()
+		parentRoot := block.ParentRoot()
+		stateRoot := block.StateRoot()
+		bodyRoot, err := block.Body().HashTreeRoot()
+		require.NoError(t, err)
 
-		var wrongRoot [fieldparams.RootLength]byte
-		copy(wrongRoot[:], root[:])
-		wrongRoot[0]++ // change the root to simulate a wrong root
+		_, verifiedSidecarsWrongRoot := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			[]util.DataColumnParam{
+				{Index: 42, Slot: slot + 1}, // Needed index, but not for this slot.
+			})
 
-		_, verifiedSidecarsWrongRoot := util.CreateTestVerifiedRoDataColumnSidecars(t, util.DataColumnsParamsByRoot{wrongRoot: {
-			{ColumnIndex: 42}, // needed
-		}})
+		_, verifiedSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, []util.DataColumnParam{
+			{Index: 87, Slot: slot, ProposerIndex: proposerIndex, ParentRoot: parentRoot[:], StateRoot: stateRoot[:], BodyRoot: bodyRoot[:]}, // Needed index
+			{Index: 1, Slot: slot, ProposerIndex: proposerIndex, ParentRoot: parentRoot[:], StateRoot: stateRoot[:], BodyRoot: bodyRoot[:]},  // Not needed index
+			{Index: 42, Slot: slot, ProposerIndex: proposerIndex, ParentRoot: parentRoot[:], StateRoot: stateRoot[:], BodyRoot: bodyRoot[:]}, // Needed index
+		})
 
-		_, verifiedSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, util.DataColumnsParamsByRoot{root: {
-			{ColumnIndex: 87}, // needed
-			{ColumnIndex: 1},  // not needed
-			{ColumnIndex: 42}, // needed
-		}})
+		go func() {
+			<-startWaiting
 
-		time.AfterFunc(10*time.Millisecond, func() {
 			err := service.dataColumnStorage.Save(verifiedSidecarsWrongRoot)
 			require.NoError(t, err)
 
 			err = service.dataColumnStorage.Save(verifiedSidecars)
 			require.NoError(t, err)
-		})
+		}()
 
-		err := service.isDataAvailable(ctx, root, signed)
+		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
 
@@ -3442,6 +3461,9 @@ func TestIsDataAvailable(t *testing.T) {
 			missingColumns = uint64(2)
 			cgc            = 128
 		)
+
+		startWaiting := make(chan bool)
+
 		var custodyInfo peerdas.CustodyInfo
 		custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(cgc)
 		custodyInfo.ToAdvertiseGroupCount.Set(cgc)
@@ -3454,41 +3476,61 @@ func TestIsDataAvailable(t *testing.T) {
 		}
 
 		testParams := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&custodyInfo)},
+			options:                 []Option{WithCustodyInfo(&custodyInfo), WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave:           indices,
 			blobKzgCommitmentsCount: 3,
 		}
 
 		ctx, _, service, root, signed := testIsAvailableSetup(t, testParams)
+		block := signed.Block()
+		slot := block.Slot()
+		proposerIndex := block.ProposerIndex()
+		parentRoot := block.ParentRoot()
+		stateRoot := block.StateRoot()
+		bodyRoot, err := block.Body().HashTreeRoot()
+		require.NoError(t, err)
 
-		dataColumnParams := make([]util.DataColumnParams, 0, missingColumns)
+		dataColumnParams := make([]util.DataColumnParam, 0, missingColumns)
 		for i := minimumColumnsCountToReconstruct - missingColumns; i < minimumColumnsCountToReconstruct; i++ {
-			dataColumnParam := util.DataColumnParams{ColumnIndex: i}
+			dataColumnParam := util.DataColumnParam{
+				Index:         i,
+				Slot:          slot,
+				ProposerIndex: proposerIndex,
+				ParentRoot:    parentRoot[:],
+				StateRoot:     stateRoot[:],
+				BodyRoot:      bodyRoot[:],
+			}
+
 			dataColumnParams = append(dataColumnParams, dataColumnParam)
 		}
 
-		_, verifiedSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, util.DataColumnsParamsByRoot{root: dataColumnParams})
+		_, verifiedSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParams)
+
+		go func() {
+			<-startWaiting
 
-		time.AfterFunc(10*time.Millisecond, func() {
 			err := service.dataColumnStorage.Save(verifiedSidecars)
 			require.NoError(t, err)
-		})
+		}()
 
-		err := service.isDataAvailable(ctx, root, signed)
+		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
 
 	t.Run("Fulu - some columns are definitively missing", func(t *testing.T) {
+		startWaiting := make(chan bool)
+
 		params := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
+			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
 			blobKzgCommitmentsCount: 3,
 		}
 
 		ctx, cancel, service, root, signed := testIsAvailableSetup(t, params)
 
-		time.AfterFunc(10*time.Millisecond, func() {
+		go func() {
+			<-startWaiting
 			cancel()
-		})
+		}()
 
 		err := service.isDataAvailable(ctx, root, signed)
 		require.NotNil(t, err)

beacon-chain/blockchain/receive_attestation_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"context"
 	"testing"
 	"time"
 

beacon-chain/blockchain/receive_block_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"context"
 	"sync"
 	"testing"
 	"time"

beacon-chain/blockchain/service.go

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

beacon-chain/blockchain/service_norace_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"context"
 	"io"
 	"testing"
 

beacon-chain/blockchain/service_test.go

@@ -429,7 +429,7 @@ func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
 
 func BenchmarkHasBlockDB(b *testing.B) {
 	beaconDB := testDB.SetupDB(b)
-	ctx := t.Context()
+	ctx := b.Context()
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB},
 	}
@@ -447,7 +447,7 @@ func BenchmarkHasBlockDB(b *testing.B) {
 }
 
 func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
-	ctx := t.Context()
+	ctx := b.Context()
 	beaconDB := testDB.SetupDB(b)
 	s := &Service{
 		cfg: &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"context"
 	"testing"
 
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"

beacon-chain/builder/service_test.go

@@ -1,7 +1,6 @@
 package builder
 
 import (
-	"context"
 	"testing"
 	"time"
 

beacon-chain/cache/committee_fuzz_test.go

@@ -3,7 +3,6 @@
 package cache
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/testing/assert"

beacon-chain/cache/depositsnapshot/deposit_cache_test.go

@@ -2,7 +2,6 @@ package depositsnapshot
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"math/big"
 	"testing"

beacon-chain/cache/depositsnapshot/deposit_fetcher_test.go

@@ -1,7 +1,6 @@
 package depositsnapshot
 
 import (
-	"context"
 	"math/big"
 	"testing"
 

beacon-chain/cache/depositsnapshot/deposit_pruner_test.go

@@ -1,7 +1,6 @@
 package depositsnapshot
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"

beacon-chain/cache/registration_test.go

@@ -1,7 +1,6 @@
 package cache
 
 import (
-	"context"
 	"testing"
 	"time"
 

beacon-chain/cache/skip_slot_cache_test.go

@@ -1,7 +1,6 @@
 package cache_test
 
 import (
-	"context"
 	"sync"
 	"testing"
 

beacon-chain/core/altair/attestation_test.go

@@ -1,7 +1,6 @@
 package altair_test
 
 import (
-	"context"
 	"fmt"
 	"testing"
 

beacon-chain/core/altair/block_test.go

@@ -1,7 +1,6 @@
 package altair_test
 
 import (
-	"context"
 	"math"
 	"testing"
 

beacon-chain/core/altair/deposit_fuzz_test.go

@@ -1,7 +1,6 @@
 package altair_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"

beacon-chain/core/altair/deposit_test.go

@@ -1,7 +1,6 @@
 package altair_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"

beacon-chain/core/altair/epoch_precompute_test.go

@@ -1,7 +1,6 @@
 package altair
 
 import (
-	"context"
 	"math"
 	"testing"
 

beacon-chain/core/altair/epoch_spec_test.go

@@ -1,7 +1,6 @@
 package altair_test
 
 import (
-	"context"
 	"fmt"
 	"math"
 	"testing"

beacon-chain/core/altair/sync_committee_test.go

@@ -1,7 +1,6 @@
 package altair_test
 
 import (
-	"context"
 	"testing"
 	"time"
 

beacon-chain/core/altair/transition_test.go

@@ -1,7 +1,6 @@
 package altair_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"

beacon-chain/core/altair/upgrade_test.go

@@ -1,7 +1,6 @@
 package altair_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"

beacon-chain/core/blocks/attester_slashing_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -1,7 +1,6 @@
 package blocks
 
 import (
-	"context"
 	"testing"
 
 	v "github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"

beacon-chain/core/blocks/block_regression_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"

beacon-chain/core/blocks/deposit_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"

beacon-chain/core/blocks/eth1_data_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"context"
 	"fmt"
 	"testing"
 

beacon-chain/core/blocks/exit_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"

beacon-chain/core/blocks/header_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"context"
 	"io"
 	"testing"
 

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"context"
 	"fmt"
 	"testing"
 

beacon-chain/core/blocks/randao_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"context"
 	"encoding/binary"
 	"testing"
 

beacon-chain/core/electra/deposit_fuzz_test.go

@@ -1,7 +1,6 @@
 package electra_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"

beacon-chain/core/electra/transition_no_verify_sig_test.go

@@ -1,7 +1,6 @@
 package electra_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"

beacon-chain/core/electra/transition_test.go

@@ -1,7 +1,6 @@
 package electra_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"

beacon-chain/core/electra/withdrawals_test.go

@@ -1,7 +1,6 @@
 package electra_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"

beacon-chain/core/epoch/epoch_processing_test.go

@@ -1,7 +1,6 @@
 package epoch_test
 
 import (
-	"context"
 	"fmt"
 	"math"
 	"testing"

beacon-chain/core/epoch/precompute/attestation_test.go

@@ -1,7 +1,6 @@
 package precompute_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epoch/precompute"

beacon-chain/core/epoch/precompute/justification_finalization_test.go

@@ -1,7 +1,6 @@
 package precompute_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"

beacon-chain/core/epoch/precompute/new_test.go

@@ -1,7 +1,6 @@
 package precompute_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epoch/precompute"

beacon-chain/core/epoch/precompute/reward_penalty_test.go

@@ -1,7 +1,6 @@
 package precompute
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"

beacon-chain/core/fulu/transition_test.go

@@ -1,7 +1,6 @@
 package fulu_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/fulu"

beacon-chain/core/helpers/attestation_test.go

@@ -1,7 +1,6 @@
 package helpers_test
 
 import (
-	"context"
 	"strconv"
 	"testing"
 	"time"

beacon-chain/core/helpers/beacon_committee_test.go

@@ -1,7 +1,6 @@
 package helpers_test
 
 import (
-	"context"
 	"fmt"
 	"strconv"
 	"testing"
@@ -502,7 +501,7 @@ func BenchmarkComputeCommittee300000_WithPreCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(t.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)
@@ -536,7 +535,7 @@ func BenchmarkComputeCommittee3000000_WithPreCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(t.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)
@@ -570,7 +569,7 @@ func BenchmarkComputeCommittee128000_WithOutPreCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(t.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)
@@ -605,7 +604,7 @@ func BenchmarkComputeCommittee1000000_WithOutCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(t.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)
@@ -640,7 +639,7 @@ func BenchmarkComputeCommittee4000000_WithOutCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(t.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)

beacon-chain/core/helpers/validators_test.go

@@ -1,7 +1,6 @@
 package helpers_test
 
 import (
-	"context"
 	"errors"
 	"testing"
 

beacon-chain/core/helpers/weak_subjectivity_test.go

@@ -1,7 +1,6 @@
 package helpers_test
 
 import (
-	"context"
 	"fmt"
 	"testing"
 

beacon-chain/core/signing/signing_root_test.go

@@ -2,7 +2,6 @@ package signing_test
 
 import (
 	"bytes"
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"

beacon-chain/core/transition/altair_transition_no_verify_sig_test.go

@@ -1,7 +1,6 @@
 package transition_test
 
 import (
-	"context"
 	"math"
 	"testing"
 

beacon-chain/core/transition/bellatrix_transition_no_verify_sig_test.go

@@ -1,7 +1,6 @@
 package transition_test
 
 import (
-	"context"
 	"math"
 	"testing"
 

beacon-chain/core/transition/benchmarks_test.go

@@ -1,7 +1,6 @@
 package transition_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
@@ -33,7 +32,7 @@ func BenchmarkExecuteStateTransition_FullBlock(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		wsb, err := blocks.NewSignedBeaconBlock(block)
 		require.NoError(b, err)
-		_, err = coreState.ExecuteStateTransition(t.Context(), cleanStates[i], wsb)
+		_, err = coreState.ExecuteStateTransition(b.Context(), cleanStates[i], wsb)
 		require.NoError(b, err)
 	}
 }
@@ -53,19 +52,19 @@ func BenchmarkExecuteStateTransition_WithCache(b *testing.B) {
 	// some attestations in block are from previous epoch
 	currentSlot := beaconState.Slot()
 	require.NoError(b, beaconState.SetSlot(beaconState.Slot()-params.BeaconConfig().SlotsPerEpoch))
-	require.NoError(b, helpers.UpdateCommitteeCache(t.Context(), beaconState, time.CurrentEpoch(beaconState)))
+	require.NoError(b, helpers.UpdateCommitteeCache(b.Context(), beaconState, time.CurrentEpoch(beaconState)))
 	require.NoError(b, beaconState.SetSlot(currentSlot))
 	// Run the state transition once to populate the cache.
 	wsb, err := blocks.NewSignedBeaconBlock(block)
 	require.NoError(b, err)
-	_, err = coreState.ExecuteStateTransition(t.Context(), beaconState, wsb)
+	_, err = coreState.ExecuteStateTransition(b.Context(), beaconState, wsb)
 	require.NoError(b, err, "Failed to process block, benchmarks will fail")
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		wsb, err := blocks.NewSignedBeaconBlock(block)
 		require.NoError(b, err)
-		_, err = coreState.ExecuteStateTransition(t.Context(), cleanStates[i], wsb)
+		_, err = coreState.ExecuteStateTransition(b.Context(), cleanStates[i], wsb)
 		require.NoError(b, err, "Failed to process block, benchmarks will fail")
 	}
 }
@@ -81,14 +80,14 @@ func BenchmarkProcessEpoch_2FullEpochs(b *testing.B) {
 	// some attestations in block are from previous epoch
 	currentSlot := beaconState.Slot()
 	require.NoError(b, beaconState.SetSlot(beaconState.Slot()-params.BeaconConfig().SlotsPerEpoch))
-	require.NoError(b, helpers.UpdateCommitteeCache(t.Context(), beaconState, time.CurrentEpoch(beaconState)))
+	require.NoError(b, helpers.UpdateCommitteeCache(b.Context(), beaconState, time.CurrentEpoch(beaconState)))
 	require.NoError(b, beaconState.SetSlot(currentSlot))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		// ProcessEpochPrecompute is the optimized version of process epoch. It's enabled by default
 		// at run time.
-		_, err := coreState.ProcessEpochPrecompute(t.Context(), beaconState.Copy())
+		_, err := coreState.ProcessEpochPrecompute(b.Context(), beaconState.Copy())
 		require.NoError(b, err)
 	}
 }
@@ -99,7 +98,7 @@ func BenchmarkHashTreeRoot_FullState(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_, err := beaconState.HashTreeRoot(t.Context())
+		_, err := beaconState.HashTreeRoot(b.Context())
 		require.NoError(b, err)
 	}
 }
@@ -108,7 +107,7 @@ func BenchmarkHashTreeRootState_FullState(b *testing.B) {
 	beaconState, err := benchmark.PreGenstateFullEpochs()
 	require.NoError(b, err)
 
-	ctx := t.Context()
+	ctx := b.Context()
 
 	// Hydrate the HashTreeRootState cache.
 	_, err = beaconState.HashTreeRoot(ctx)

beacon-chain/core/transition/skip_slot_cache_test.go

@@ -1,7 +1,6 @@
 package transition_test
 
 import (
-	"context"
 	"sync"
 	"testing"
 

beacon-chain/core/transition/state_fuzz_test.go

@@ -1,7 +1,6 @@
 package transition
 
 import (
-	"context"
 	"testing"
 
 	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"

beacon-chain/core/transition/state_test.go

@@ -1,7 +1,6 @@
 package transition_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"

beacon-chain/core/transition/trailing_slot_state_cache_test.go

@@ -1,7 +1,6 @@
 package transition_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"

beacon-chain/core/transition/transition_fuzz_test.go

@@ -1,7 +1,6 @@
 package transition
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -1,7 +1,6 @@
 package transition_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"

beacon-chain/core/transition/transition_test.go

@@ -1,7 +1,6 @@
 package transition_test
 
 import (
-	"context"
 	"fmt"
 	"testing"
 
@@ -757,7 +756,7 @@ func BenchmarkProcessSlots_Capella(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		st, err = transition.ProcessSlots(t.Context(), st, st.Slot()+1)
+		st, err = transition.ProcessSlots(b.Context(), st, st.Slot()+1)
 		if err != nil {
 			b.Fatalf("Failed to process slot %v", err)
 		}
@@ -771,7 +770,7 @@ func BenchmarkProcessSlots_Deneb(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		st, err = transition.ProcessSlots(t.Context(), st, st.Slot()+1)
+		st, err = transition.ProcessSlots(b.Context(), st, st.Slot()+1)
 		if err != nil {
 			b.Fatalf("Failed to process slot %v", err)
 		}
@@ -785,7 +784,7 @@ func BenchmarkProcessSlots_Electra(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		st, err = transition.ProcessSlots(t.Context(), st, st.Slot()+1)
+		st, err = transition.ProcessSlots(b.Context(), st, st.Slot()+1)
 		if err != nil {
 			b.Fatalf("Failed to process slot %v", err)
 		}

beacon-chain/core/validators/validator_test.go

@@ -1,7 +1,6 @@
 package validators_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"

beacon-chain/das/availability_columns_test.go

@@ -38,9 +38,9 @@ func TestPersist(t *testing.T) {
 	t.Run("mixed roots", func(t *testing.T) {
 		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
 
-		dataColumnParamsByBlockRoot := map[[fieldparams.RootLength]byte][]util.DataColumnParams{
-			{1}: {{ColumnIndex: 1}},
-			{2}: {{ColumnIndex: 2}},
+		dataColumnParamsByBlockRoot := []util.DataColumnParam{
+			{Slot: 1, Index: 1},
+			{Slot: 2, Index: 2},
 		}
 
 		roSidecars, _ := roSidecarsFromDataColumnParamsByBlockRoot(t, dataColumnParamsByBlockRoot)
@@ -54,8 +54,8 @@ func TestPersist(t *testing.T) {
 	t.Run("outside DA period", func(t *testing.T) {
 		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
 
-		dataColumnParamsByBlockRoot := map[[fieldparams.RootLength]byte][]util.DataColumnParams{
-			{1}: {{ColumnIndex: 1}},
+		dataColumnParamsByBlockRoot := []util.DataColumnParam{
+			{Slot: 1, Index: 1},
 		}
 
 		roSidecars, _ := roSidecarsFromDataColumnParamsByBlockRoot(t, dataColumnParamsByBlockRoot)
@@ -67,21 +67,24 @@ func TestPersist(t *testing.T) {
 	})
 
 	t.Run("nominal", func(t *testing.T) {
+		const slot = 42
 		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
 
-		dataColumnParamsByBlockRoot := map[[fieldparams.RootLength]byte][]util.DataColumnParams{
-			{}: {{ColumnIndex: 1}, {ColumnIndex: 5}},
+		dataColumnParamsByBlockRoot := []util.DataColumnParam{
+			{Slot: slot, Index: 1},
+			{Slot: slot, Index: 5},
 		}
 
 		roSidecars, roDataColumns := roSidecarsFromDataColumnParamsByBlockRoot(t, dataColumnParamsByBlockRoot)
 		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, &peerdas.CustodyInfo{})
 
-		err := lazilyPersistentStoreColumns.Persist(0, roSidecars...)
+		err := lazilyPersistentStoreColumns.Persist(slot, roSidecars...)
 		require.NoError(t, err)
 		require.Equal(t, 1, len(lazilyPersistentStoreColumns.cache.entries))
 
-		key := cacheKey{slot: 0, root: [fieldparams.RootLength]byte{}}
-		entry := lazilyPersistentStoreColumns.cache.entries[key]
+		key := cacheKey{slot: slot, root: roDataColumns[0].BlockRoot()}
+		entry, ok := lazilyPersistentStoreColumns.cache.entries[key]
+		require.Equal(t, true, ok)
 
 		// A call to Persist does NOT save the sidecars to disk.
 		require.Equal(t, uint64(0), entry.diskSummary.Count())
@@ -121,24 +124,37 @@ func TestIsDataAvailable(t *testing.T) {
 		signedBeaconBlockFulu := util.NewBeaconBlockFulu()
 		signedBeaconBlockFulu.Block.Body.BlobKzgCommitments = commitments
 		signedRoBlock := newSignedRoBlock(t, signedBeaconBlockFulu)
+		block := signedRoBlock.Block()
+		slot := block.Slot()
+		proposerIndex := block.ProposerIndex()
+		parentRoot := block.ParentRoot()
+		stateRoot := block.StateRoot()
+		bodyRoot, err := block.Body().HashTreeRoot()
+		require.NoError(t, err)
+
 		root := signedRoBlock.Root()
 
 		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
 		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, newDataColumnsVerifier, &peerdas.CustodyInfo{})
 
 		indices := [...]uint64{1, 17, 87, 102}
-		dataColumnsParams := make([]util.DataColumnParams, 0, len(indices))
+		dataColumnsParams := make([]util.DataColumnParam, 0, len(indices))
 		for _, index := range indices {
-			dataColumnParams := util.DataColumnParams{
-				ColumnIndex:    index,
+			dataColumnParams := util.DataColumnParam{
+				Index:          index,
 				KzgCommitments: commitments,
+
+				Slot:          slot,
+				ProposerIndex: proposerIndex,
+				ParentRoot:    parentRoot[:],
+				StateRoot:     stateRoot[:],
+				BodyRoot:      bodyRoot[:],
 			}
 
 			dataColumnsParams = append(dataColumnsParams, dataColumnParams)
 		}
 
-		dataColumnsParamsByBlockRoot := util.DataColumnsParamsByRoot{root: dataColumnsParams}
-		_, verifiedRoDataColumns := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnsParamsByBlockRoot)
+		_, verifiedRoDataColumns := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnsParams)
 
 		key := cacheKey{root: root}
 		entry := lazilyPersistentStoreColumns.cache.ensure(key)
@@ -149,7 +165,7 @@ func TestIsDataAvailable(t *testing.T) {
 			require.NoError(t, err)
 		}
 
-		err := lazilyPersistentStoreColumns.IsDataAvailable(ctx, 0 /*current slot*/, signedRoBlock)
+		err = lazilyPersistentStoreColumns.IsDataAvailable(ctx, slot, signedRoBlock)
 		require.NoError(t, err)
 
 		actual, err := dataColumnStorage.Get(root, indices[:])
@@ -224,8 +240,8 @@ func TestFullCommitmentsToCheck(t *testing.T) {
 	}
 }
 
-func roSidecarsFromDataColumnParamsByBlockRoot(t *testing.T, dataColumnParamsByBlockRoot util.DataColumnsParamsByRoot) ([]blocks.ROSidecar, []blocks.RODataColumn) {
-	roDataColumns, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParamsByBlockRoot)
+func roSidecarsFromDataColumnParamsByBlockRoot(t *testing.T, parameters []util.DataColumnParam) ([]blocks.ROSidecar, []blocks.RODataColumn) {
+	roDataColumns, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, parameters)
 
 	roSidecars := make([]blocks.ROSidecar, 0, len(roDataColumns))
 	for _, roDataColumn := range roDataColumns {

beacon-chain/das/data_column_cache_test.go

@@ -28,8 +28,7 @@ func TestEnsureDeleteSetDiskSummary(t *testing.T) {
 
 func TestStash(t *testing.T) {
 	t.Run("Index too high", func(t *testing.T) {
-		dataColumnParamsByBlockRoot := util.DataColumnsParamsByRoot{{1}: {{ColumnIndex: 10_000}}}
-		roDataColumns, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParamsByBlockRoot)
+		roDataColumns, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, []util.DataColumnParam{{Index: 10_000}})
 
 		var entry dataColumnCacheEntry
 		err := entry.stash(&roDataColumns[0])
@@ -37,8 +36,7 @@ func TestStash(t *testing.T) {
 	})
 
 	t.Run("Nominal and already existing", func(t *testing.T) {
-		dataColumnParamsByBlockRoot := util.DataColumnsParamsByRoot{{1}: {{ColumnIndex: 1}}}
-		roDataColumns, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParamsByBlockRoot)
+		roDataColumns, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, []util.DataColumnParam{{Index: 1}})
 
 		var entry dataColumnCacheEntry
 		err := entry.stash(&roDataColumns[0])
@@ -76,36 +74,30 @@ func TestFilterDataColumns(t *testing.T) {
 	})
 
 	t.Run("Commitments not equal", func(t *testing.T) {
-		root := [fieldparams.RootLength]byte{}
 		commitmentsArray := safeCommitmentsArray{nil, [][]byte{[]byte{1}}}
 
-		dataColumnParamsByBlockRoot := util.DataColumnsParamsByRoot{root: {{ColumnIndex: 1}}}
-		roDataColumns, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParamsByBlockRoot)
+		roDataColumns, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, []util.DataColumnParam{{Index: 1}})
 
 		var scs [fieldparams.NumberOfColumns]*blocks.RODataColumn
 		scs[1] = &roDataColumns[0]
 
 		dataColumnCacheEntry := dataColumnCacheEntry{scs: scs}
 
-		_, err := dataColumnCacheEntry.filter(root, &commitmentsArray)
+		_, err := dataColumnCacheEntry.filter(roDataColumns[0].BlockRoot(), &commitmentsArray)
 		require.NotNil(t, err)
 	})
 
 	t.Run("Nominal", func(t *testing.T) {
-		root := [fieldparams.RootLength]byte{}
 		commitmentsArray := safeCommitmentsArray{nil, [][]byte{[]byte{1}}, nil, [][]byte{[]byte{3}}}
-
 		diskSummary := filesystem.NewDataColumnStorageSummary(42, [fieldparams.NumberOfColumns]bool{false, true})
-
-		dataColumnParamsByBlockRoot := util.DataColumnsParamsByRoot{root: {{ColumnIndex: 3, KzgCommitments: [][]byte{[]byte{3}}}}}
-		expected, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParamsByBlockRoot)
+		expected, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, []util.DataColumnParam{{Index: 3, KzgCommitments: [][]byte{[]byte{3}}}})
 
 		var scs [fieldparams.NumberOfColumns]*blocks.RODataColumn
 		scs[3] = &expected[0]
 
 		dataColumnCacheEntry := dataColumnCacheEntry{scs: scs, diskSummary: diskSummary}
 
-		actual, err := dataColumnCacheEntry.filter(root, &commitmentsArray)
+		actual, err := dataColumnCacheEntry.filter(expected[0].BlockRoot(), &commitmentsArray)
 		require.NoError(t, err)
 
 		require.DeepEqual(t, expected, actual)

beacon-chain/db/filesystem/BUILD.bazel

@@ -59,6 +59,7 @@ go_test(
         "//beacon-chain/verification:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/db/filesystem/blob.go

@@ -25,7 +25,7 @@ func directoryPermissions() os.FileMode {
 var (
 	errIndexOutOfBounds    = errors.New("blob index in file name >= MAX_BLOBS_PER_BLOCK")
 	errSidecarEmptySSZData = errors.New("sidecar marshalled to an empty ssz byte slice")
-	errNoBasePath          = errors.New("BlobStorage base path not specified in init")
+	errNoBlobBasePath      = errors.New("BlobStorage base path not specified in init")
 )
 
 // BlobStorageOption is a functional option for configuring a BlobStorage.
@@ -85,7 +85,7 @@ func NewBlobStorage(opts ...BlobStorageOption) (*BlobStorage, error) {
 	// Allow tests to set up a different fs using WithFs.
 	if b.fs == nil {
 		if b.base == "" {
-			return nil, errNoBasePath
+			return nil, errNoBlobBasePath
 		}
 		b.base = path.Clean(b.base)
 		if err := file.MkdirAll(b.base); err != nil {

beacon-chain/db/filesystem/blob_test.go

@@ -160,7 +160,7 @@ func writeFakeSSZ(t *testing.T, fs afero.Fs, root [32]byte, slot primitives.Slot
 
 func TestNewBlobStorage(t *testing.T) {
 	_, err := NewBlobStorage()
-	require.ErrorIs(t, err, errNoBasePath)
+	require.ErrorIs(t, err, errNoBlobBasePath)
 	_, err = NewBlobStorage(WithBasePath(path.Join(t.TempDir(), "good")))
 	require.NoError(t, err)
 }

beacon-chain/db/filesystem/data_column.go

@@ -50,6 +50,7 @@ var (
 	errTooManyDataColumns                   = errors.New("too many data columns")
 	errWrongSszEncodedDataColumnSidecarSize = errors.New("wrong SSZ encoded data column sidecar size")
 	errDataColumnSidecarsFromDifferentSlots = errors.New("data column sidecars from different slots")
+	errNoDataColumnBasePath                 = errors.New("DataColumnStorage base path not specified in init")
 )
 
 type (
@@ -142,7 +143,7 @@ func NewDataColumnStorage(ctx context.Context, opts ...DataColumnStorageOption)
 	// Allow tests to set up a different fs using WithFs.
 	if storage.fs == nil {
 		if storage.base == "" {
-			return nil, errNoBasePath
+			return nil, errNoDataColumnBasePath
 		}
 
 		storage.base = path.Clean(storage.base)

beacon-chain/db/filesystem/data_column_test.go

@@ -1,13 +1,13 @@
 package filesystem
 
 import (
-	"context"
 	"encoding/binary"
 	"os"
 	"testing"
 
 	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/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
@@ -19,7 +19,7 @@ func TestNewDataColumnStorage(t *testing.T) {
 
 	t.Run("No base path", func(t *testing.T) {
 		_, err := NewDataColumnStorage(ctx)
-		require.ErrorIs(t, err, errNoBasePath)
+		require.ErrorIs(t, err, errNoDataColumnBasePath)
 	})
 
 	t.Run("Nominal", func(t *testing.T) {
@@ -41,32 +41,18 @@ func TestWarmCache(t *testing.T) {
 
 	_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 		t,
-		util.DataColumnsParamsByRoot{
-			{0}: {
-				{Slot: 33, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 1
-				{Slot: 33, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 1
-			},
-			{1}: {
-				{Slot: 128_002, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4000
-				{Slot: 128_002, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4000
-			},
-			{2}: {
-				{Slot: 128_003, ColumnIndex: 1, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4000
-				{Slot: 128_003, ColumnIndex: 3, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4000
-			},
-			{3}: {
-				{Slot: 128_034, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4001
-				{Slot: 128_034, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4001
-			},
-			{4}: {
-				{Slot: 131_138, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4098
-			},
-			{5}: {
-				{Slot: 131_138, ColumnIndex: 1, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4098
-			},
-			{6}: {
-				{Slot: 131_168, ColumnIndex: 0, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4099
-			},
+		[]util.DataColumnParam{
+			{Slot: 33, Index: 2, Column: [][]byte{{1}, {2}, {3}}},      // Period 0 - Epoch 1
+			{Slot: 33, Index: 4, Column: [][]byte{{2}, {3}, {4}}},      // Period 0 - Epoch 1
+			{Slot: 128_002, Index: 2, Column: [][]byte{{1}, {2}, {3}}}, // Period 0 - Epoch 4000
+			{Slot: 128_002, Index: 4, Column: [][]byte{{2}, {3}, {4}}}, // Period 0 - Epoch 4000
+			{Slot: 128_003, Index: 1, Column: [][]byte{{1}, {2}, {3}}}, // Period 0 - Epoch 4000
+			{Slot: 128_003, Index: 3, Column: [][]byte{{2}, {3}, {4}}}, // Period 0 - Epoch 4000
+			{Slot: 128_034, Index: 2, Column: [][]byte{{1}, {2}, {3}}}, // Period 0 - Epoch 4001
+			{Slot: 128_034, Index: 4, Column: [][]byte{{2}, {3}, {4}}}, // Period 0 - Epoch 4001
+			{Slot: 131_138, Index: 2, Column: [][]byte{{1}, {2}, {3}}}, // Period 1 - Epoch 4098
+			{Slot: 131_138, Index: 1, Column: [][]byte{{1}, {2}, {3}}}, // Period 1 - Epoch 4098
+			{Slot: 131_168, Index: 0, Column: [][]byte{{1}, {2}, {3}}}, // Period 1 - Epoch 4099
 		},
 	)
 
@@ -77,29 +63,25 @@ func TestWarmCache(t *testing.T) {
 
 	storage.WarmCache()
 	require.Equal(t, primitives.Epoch(4_000), storage.cache.lowestCachedEpoch)
-	require.Equal(t, 6, len(storage.cache.cache))
+	require.Equal(t, 5, len(storage.cache.cache))
 
-	summary, ok := storage.cache.get([fieldparams.RootLength]byte{1})
+	summary, ok := storage.cache.get(verifiedRoDataColumnSidecars[2].BlockRoot())
 	require.Equal(t, true, ok)
 	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_000, mask: [fieldparams.NumberOfColumns]bool{false, false, true, false, true}}, summary)
 
-	summary, ok = storage.cache.get([fieldparams.RootLength]byte{2})
+	summary, ok = storage.cache.get(verifiedRoDataColumnSidecars[4].BlockRoot())
 	require.Equal(t, true, ok)
 	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_000, mask: [fieldparams.NumberOfColumns]bool{false, true, false, true}}, summary)
 
-	summary, ok = storage.cache.get([fieldparams.RootLength]byte{3})
+	summary, ok = storage.cache.get(verifiedRoDataColumnSidecars[6].BlockRoot())
 	require.Equal(t, true, ok)
 	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_001, mask: [fieldparams.NumberOfColumns]bool{false, false, true, false, true}}, summary)
 
-	summary, ok = storage.cache.get([fieldparams.RootLength]byte{4})
+	summary, ok = storage.cache.get(verifiedRoDataColumnSidecars[8].BlockRoot())
 	require.Equal(t, true, ok)
-	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_098, mask: [fieldparams.NumberOfColumns]bool{false, false, true}}, summary)
+	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_098, mask: [fieldparams.NumberOfColumns]bool{false, true, true}}, summary)
 
-	summary, ok = storage.cache.get([fieldparams.RootLength]byte{5})
-	require.Equal(t, true, ok)
-	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_098, mask: [fieldparams.NumberOfColumns]bool{false, true}}, summary)
-
-	summary, ok = storage.cache.get([fieldparams.RootLength]byte{6})
+	summary, ok = storage.cache.get(verifiedRoDataColumnSidecars[10].BlockRoot())
 	require.Equal(t, true, ok)
 	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_099, mask: [fieldparams.NumberOfColumns]bool{true}}, summary)
 }
@@ -113,9 +95,7 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 
 		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{}: {{ColumnIndex: 12}, {ColumnIndex: 1_000_000}, {ColumnIndex: 48}},
-			},
+			[]util.DataColumnParam{{Index: 12}, {Index: 1_000_000}, {Index: 48}},
 		)
 
 		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
@@ -126,7 +106,7 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 	t.Run("one of the column index is too large", func(t *testing.T) {
 		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{{}: {{ColumnIndex: 12}, {ColumnIndex: 1_000_000}, {ColumnIndex: 48}}},
+			[]util.DataColumnParam{{Index: 12}, {Index: 1_000_000}, {Index: 48}},
 		)
 
 		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
@@ -137,23 +117,34 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 	t.Run("different slots", func(t *testing.T) {
 		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{}: {
-					{Slot: 1, ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
-					{Slot: 2, ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
-				},
+			[]util.DataColumnParam{
+				{Slot: 1, Index: 12, Column: [][]byte{{1}, {2}, {3}}},
+				{Slot: 2, Index: 12, Column: [][]byte{{1}, {2}, {3}}},
 			},
 		)
 
+		// Create a sidecar with a different slot but the same root.
+		alteredVerifiedRoDataColumnSidecars := make([]blocks.VerifiedRODataColumn, 0, 2)
+		alteredVerifiedRoDataColumnSidecars = append(alteredVerifiedRoDataColumnSidecars, verifiedRoDataColumnSidecars[0])
+
+		altered, err := blocks.NewRODataColumnWithRoot(
+			verifiedRoDataColumnSidecars[1].RODataColumn.DataColumnSidecar,
+			verifiedRoDataColumnSidecars[0].BlockRoot(),
+		)
+		require.NoError(t, err)
+
+		verifiedAltered := blocks.NewVerifiedRODataColumn(altered)
+		alteredVerifiedRoDataColumnSidecars = append(alteredVerifiedRoDataColumnSidecars, verifiedAltered)
+
 		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
-		err := dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		err = dataColumnStorage.Save(alteredVerifiedRoDataColumnSidecars)
 		require.ErrorIs(t, err, errDataColumnSidecarsFromDifferentSlots)
 	})
 
 	t.Run("new file - no data columns to save", func(t *testing.T) {
 		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{{}: {}},
+			[]util.DataColumnParam{},
 		)
 
 		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
@@ -164,11 +155,9 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 	t.Run("new file - different data column size", func(t *testing.T) {
 		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{}: {
-					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
-					{ColumnIndex: 11, DataColumn: []byte{1, 2, 3, 4}},
-				},
+			[]util.DataColumnParam{
+				{Slot: 1, Index: 12, Column: [][]byte{{1}, {2}, {3}}},
+				{Slot: 1, Index: 13, Column: [][]byte{{1}, {2}, {3}, {4}}},
 			},
 		)
 
@@ -180,7 +169,9 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 	t.Run("existing file - wrong incoming SSZ encoded size", func(t *testing.T) {
 		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{{1}: {{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}}},
+			[]util.DataColumnParam{
+				{Slot: 1, Index: 12, Column: [][]byte{{1}, {2}, {3}}},
+			},
 		)
 
 		// Save data columns into a file.
@@ -192,7 +183,9 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 		// column index and an different SSZ encoded size.
 		_, verifiedRoDataColumnSidecars = util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{{1}: {{ColumnIndex: 13, DataColumn: []byte{1, 2, 3, 4}}}},
+			[]util.DataColumnParam{
+				{Slot: 1, Index: 13, Column: [][]byte{{1}, {2}, {3}, {4}}},
+			},
 		)
 
 		// Try to rewrite the file.
@@ -203,17 +196,13 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 	t.Run("nominal", func(t *testing.T) {
 		_, inputVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{1}: {
-					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
-					{ColumnIndex: 11, DataColumn: []byte{3, 4, 5}},
-					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}, // OK if duplicate
-					{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}},
-				},
-				{2}: {
-					{ColumnIndex: 12, DataColumn: []byte{3, 4, 5}},
-					{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}},
-				},
+			[]util.DataColumnParam{
+				{Slot: 1, Index: 12, Column: [][]byte{{1}, {2}, {3}}},
+				{Slot: 1, Index: 11, Column: [][]byte{{3}, {4}, {5}}},
+				{Slot: 1, Index: 12, Column: [][]byte{{1}, {2}, {3}}}, // OK if duplicate
+				{Slot: 1, Index: 13, Column: [][]byte{{6}, {7}, {8}}},
+				{Slot: 2, Index: 12, Column: [][]byte{{3}, {4}, {5}}},
+				{Slot: 2, Index: 13, Column: [][]byte{{6}, {7}, {8}}},
 			},
 		)
 
@@ -223,16 +212,12 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 
 		_, inputVerifiedRoDataColumnSidecars = util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{1}: {
-					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}, // OK if duplicate
-					{ColumnIndex: 15, DataColumn: []byte{2, 3, 4}},
-					{ColumnIndex: 1, DataColumn: []byte{2, 3, 4}},
-				},
-				{3}: {
-					{ColumnIndex: 6, DataColumn: []byte{3, 4, 5}},
-					{ColumnIndex: 2, DataColumn: []byte{6, 7, 8}},
-				},
+			[]util.DataColumnParam{
+				{Slot: 1, Index: 12, Column: [][]byte{{1}, {2}, {3}}}, // OK if duplicate
+				{Slot: 1, Index: 15, Column: [][]byte{{2}, {3}, {4}}},
+				{Slot: 1, Index: 1, Column: [][]byte{{2}, {3}, {4}}},
+				{Slot: 3, Index: 6, Column: [][]byte{{3}, {4}, {5}}},
+				{Slot: 3, Index: 2, Column: [][]byte{{6}, {7}, {8}}},
 			},
 		)
 
@@ -241,51 +226,47 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 
 		type fixture struct {
 			fileName         string
-			blockRoot        [fieldparams.RootLength]byte
 			expectedIndices  [mandatoryNumberOfColumns]byte
-			dataColumnParams []util.DataColumnParams
+			dataColumnParams []util.DataColumnParam
 		}
 
 		fixtures := []fixture{
 			{
-				fileName:  "0/0/0x0100000000000000000000000000000000000000000000000000000000000000.sszs",
-				blockRoot: [fieldparams.RootLength]byte{1},
+				fileName: "0/0/0x8bb2f09de48c102635622dc27e6de03ae2b22639df7c33edbc8222b2ec423746.sszs",
 				expectedIndices: [mandatoryNumberOfColumns]byte{
 					0, nonZeroOffset + 4, 0, 0, 0, 0, 0, 0,
 					0, 0, 0, nonZeroOffset + 1, nonZeroOffset, nonZeroOffset + 2, 0, nonZeroOffset + 3,
 					// The rest is filled with zeroes.
 				},
-				dataColumnParams: []util.DataColumnParams{
-					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
-					{ColumnIndex: 11, DataColumn: []byte{3, 4, 5}},
-					{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}},
-					{ColumnIndex: 15, DataColumn: []byte{2, 3, 4}},
-					{ColumnIndex: 1, DataColumn: []byte{2, 3, 4}},
+				dataColumnParams: []util.DataColumnParam{
+					{Slot: 1, Index: 12, Column: [][]byte{{1}, {2}, {3}}},
+					{Slot: 1, Index: 11, Column: [][]byte{{3}, {4}, {5}}},
+					{Slot: 1, Index: 13, Column: [][]byte{{6}, {7}, {8}}},
+					{Slot: 1, Index: 15, Column: [][]byte{{2}, {3}, {4}}},
+					{Slot: 1, Index: 1, Column: [][]byte{{2}, {3}, {4}}},
 				},
 			},
 			{
-				fileName:  "0/0/0x0200000000000000000000000000000000000000000000000000000000000000.sszs",
-				blockRoot: [fieldparams.RootLength]byte{2},
+				fileName: "0/0/0x221f88cae2219050d4e9d8c2d0d83cb4c8ce4c84ab1bb3e0b89f3dec36077c4f.sszs",
 				expectedIndices: [mandatoryNumberOfColumns]byte{
 					0, 0, 0, 0, 0, 0, 0, 0,
 					0, 0, 0, 0, nonZeroOffset, nonZeroOffset + 1, 0, 0,
 					// The rest is filled with zeroes.
 				},
-				dataColumnParams: []util.DataColumnParams{
-					{ColumnIndex: 12, DataColumn: []byte{3, 4, 5}},
-					{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}},
+				dataColumnParams: []util.DataColumnParam{
+					{Slot: 2, Index: 12, Column: [][]byte{{3}, {4}, {5}}},
+					{Slot: 2, Index: 13, Column: [][]byte{{6}, {7}, {8}}},
 				},
 			},
 			{
-				fileName:  "0/0/0x0300000000000000000000000000000000000000000000000000000000000000.sszs",
-				blockRoot: [fieldparams.RootLength]byte{3},
+				fileName: "0/0/0x7b163bd57e1c4c8b5048c5389698098f4c957d62d7ce86f4ffa9bdc75c16a18b.sszs",
 				expectedIndices: [mandatoryNumberOfColumns]byte{
 					0, 0, nonZeroOffset + 1, 0, 0, 0, nonZeroOffset, 0,
 					// The rest is filled with zeroes.
 				},
-				dataColumnParams: []util.DataColumnParams{
-					{ColumnIndex: 6, DataColumn: []byte{3, 4, 5}},
-					{ColumnIndex: 2, DataColumn: []byte{6, 7, 8}},
+				dataColumnParams: []util.DataColumnParam{
+					{Slot: 3, Index: 6, Column: [][]byte{{3}, {4}, {5}}},
+					{Slot: 3, Index: 2, Column: [][]byte{{6}, {7}, {8}}},
 				},
 			},
 		}
@@ -294,7 +275,7 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 			// Build expected data column sidecars.
 			_, expectedDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 				t,
-				util.DataColumnsParamsByRoot{fixture.blockRoot: fixture.dataColumnParams},
+				fixture.dataColumnParams,
 			)
 
 			// Build expected bytes.
@@ -321,6 +302,8 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 			expectedBytes = append(expectedBytes, fixture.expectedIndices[:]...)
 			expectedBytes = append(expectedBytes, sszEncodedDataColumnSidecars...)
 
+			blockRoot := expectedDataColumnSidecars[0].BlockRoot()
+
 			// Check the actual content of the file.
 			actualBytes, err := afero.ReadFile(dataColumnStorage.fs, fixture.fileName)
 			require.NoError(t, err)
@@ -329,18 +312,18 @@ func TestSaveDataColumnsSidecars(t *testing.T) {
 			// Check the summary.
 			indices := map[uint64]bool{}
 			for _, dataColumnParam := range fixture.dataColumnParams {
-				indices[dataColumnParam.ColumnIndex] = true
+				indices[dataColumnParam.Index] = true
 			}
 
-			summary := dataColumnStorage.Summary(fixture.blockRoot)
+			summary := dataColumnStorage.Summary(blockRoot)
 			for index := range uint64(mandatoryNumberOfColumns) {
 				require.Equal(t, indices[index], summary.HasIndex(index))
 			}
 
-			err = dataColumnStorage.Remove(fixture.blockRoot)
+			err = dataColumnStorage.Remove(blockRoot)
 			require.NoError(t, err)
 
-			summary = dataColumnStorage.Summary(fixture.blockRoot)
+			summary = dataColumnStorage.Summary(blockRoot)
 			for index := range uint64(mandatoryNumberOfColumns) {
 				require.Equal(t, false, summary.HasIndex(index))
 			}
@@ -363,11 +346,9 @@ func TestGetDataColumnSidecars(t *testing.T) {
 	t.Run("indices not found", func(t *testing.T) {
 		_, savedVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{1}: {
-					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
-					{ColumnIndex: 14, DataColumn: []byte{2, 3, 4}},
-				},
+			[]util.DataColumnParam{
+				{Index: 12, Column: [][]byte{{1}, {2}, {3}}},
+				{Index: 14, Column: [][]byte{{2}, {3}, {4}}},
 			},
 		)
 
@@ -375,7 +356,7 @@ func TestGetDataColumnSidecars(t *testing.T) {
 		err := dataColumnStorage.Save(savedVerifiedRoDataColumnSidecars)
 		require.NoError(t, err)
 
-		verifiedRODataColumnSidecars, err := dataColumnStorage.Get([fieldparams.RootLength]byte{1}, []uint64{3, 1, 2})
+		verifiedRODataColumnSidecars, err := dataColumnStorage.Get(savedVerifiedRoDataColumnSidecars[0].BlockRoot(), []uint64{3, 1, 2})
 		require.NoError(t, err)
 		require.Equal(t, 0, len(verifiedRODataColumnSidecars))
 	})
@@ -383,11 +364,9 @@ func TestGetDataColumnSidecars(t *testing.T) {
 	t.Run("nominal", func(t *testing.T) {
 		_, expectedVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{1}: {
-					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
-					{ColumnIndex: 14, DataColumn: []byte{2, 3, 4}},
-				},
+			[]util.DataColumnParam{
+				{Index: 12, Column: [][]byte{{1}, {2}, {3}}},
+				{Index: 14, Column: [][]byte{{2}, {3}, {4}}},
 			},
 		)
 
@@ -395,11 +374,13 @@ func TestGetDataColumnSidecars(t *testing.T) {
 		err := dataColumnStorage.Save(expectedVerifiedRoDataColumnSidecars)
 		require.NoError(t, err)
 
-		verifiedRODataColumnSidecars, err := dataColumnStorage.Get([fieldparams.RootLength]byte{1}, nil)
+		root := expectedVerifiedRoDataColumnSidecars[0].BlockRoot()
+
+		verifiedRODataColumnSidecars, err := dataColumnStorage.Get(root, nil)
 		require.NoError(t, err)
 		require.DeepSSZEqual(t, expectedVerifiedRoDataColumnSidecars, verifiedRODataColumnSidecars)
 
-		verifiedRODataColumnSidecars, err = dataColumnStorage.Get([fieldparams.RootLength]byte{1}, []uint64{12, 13, 14})
+		verifiedRODataColumnSidecars, err = dataColumnStorage.Get(root, []uint64{12, 13, 14})
 		require.NoError(t, err)
 		require.DeepSSZEqual(t, expectedVerifiedRoDataColumnSidecars, verifiedRODataColumnSidecars)
 	})
@@ -415,15 +396,11 @@ func TestRemove(t *testing.T) {
 	t.Run("nominal", func(t *testing.T) {
 		_, inputVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{1}: {
-					{Slot: 32, ColumnIndex: 10, DataColumn: []byte{1, 2, 3}},
-					{Slot: 32, ColumnIndex: 11, DataColumn: []byte{2, 3, 4}},
-				},
-				{2}: {
-					{Slot: 33, ColumnIndex: 10, DataColumn: []byte{1, 2, 3}},
-					{Slot: 33, ColumnIndex: 11, DataColumn: []byte{2, 3, 4}},
-				},
+			[]util.DataColumnParam{
+				{Slot: 32, Index: 10, Column: [][]byte{{1}, {2}, {3}}},
+				{Slot: 32, Index: 11, Column: [][]byte{{2}, {3}, {4}}},
+				{Slot: 33, Index: 10, Column: [][]byte{{1}, {2}, {3}}},
+				{Slot: 33, Index: 11, Column: [][]byte{{2}, {3}, {4}}},
 			},
 		)
 
@@ -431,22 +408,22 @@ func TestRemove(t *testing.T) {
 		err := dataColumnStorage.Save(inputVerifiedRoDataColumnSidecars)
 		require.NoError(t, err)
 
-		err = dataColumnStorage.Remove([fieldparams.RootLength]byte{1})
+		err = dataColumnStorage.Remove(inputVerifiedRoDataColumnSidecars[0].BlockRoot())
 		require.NoError(t, err)
 
-		summary := dataColumnStorage.Summary([fieldparams.RootLength]byte{1})
+		summary := dataColumnStorage.Summary(inputVerifiedRoDataColumnSidecars[0].BlockRoot())
 		require.Equal(t, primitives.Epoch(0), summary.epoch)
 		require.Equal(t, uint64(0), summary.Count())
 
-		summary = dataColumnStorage.Summary([fieldparams.RootLength]byte{2})
+		summary = dataColumnStorage.Summary(inputVerifiedRoDataColumnSidecars[3].BlockRoot())
 		require.Equal(t, primitives.Epoch(1), summary.epoch)
 		require.Equal(t, uint64(2), summary.Count())
 
-		actual, err := dataColumnStorage.Get([fieldparams.RootLength]byte{1}, nil)
+		actual, err := dataColumnStorage.Get(inputVerifiedRoDataColumnSidecars[0].BlockRoot(), nil)
 		require.NoError(t, err)
 		require.Equal(t, 0, len(actual))
 
-		actual, err = dataColumnStorage.Get([fieldparams.RootLength]byte{2}, nil)
+		actual, err = dataColumnStorage.Get(inputVerifiedRoDataColumnSidecars[3].BlockRoot(), nil)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(actual))
 	})
@@ -455,9 +432,9 @@ func TestRemove(t *testing.T) {
 func TestClear(t *testing.T) {
 	_, inputVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 		t,
-		util.DataColumnsParamsByRoot{
-			{1}: {{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}},
-			{2}: {{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}}},
+		[]util.DataColumnParam{
+			{Slot: 1, Index: 12, Column: [][]byte{{1}, {2}, {3}}},
+			{Slot: 2, Index: 13, Column: [][]byte{{6}, {7}, {8}}},
 		},
 	)
 
@@ -466,8 +443,8 @@ func TestClear(t *testing.T) {
 	require.NoError(t, err)
 
 	filePaths := []string{
-		"0/0/0x0100000000000000000000000000000000000000000000000000000000000000.sszs",
-		"0/0/0x0200000000000000000000000000000000000000000000000000000000000000.sszs",
+		"0/0/0x8bb2f09de48c102635622dc27e6de03ae2b22639df7c33edbc8222b2ec423746.sszs",
+		"0/0/0x221f88cae2219050d4e9d8c2d0d83cb4c8ce4c84ab1bb3e0b89f3dec36077c4f.sszs",
 	}
 
 	for _, filePath := range filePaths {
@@ -493,8 +470,8 @@ func TestMetadata(t *testing.T) {
 	t.Run("wrong version", func(t *testing.T) {
 		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{1}: {{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}},
+			[]util.DataColumnParam{
+				{Slot: 1, Index: 12, Column: [][]byte{{1}, {2}, {3}}},
 			},
 		)
 
@@ -504,7 +481,7 @@ func TestMetadata(t *testing.T) {
 		require.NoError(t, err)
 
 		// Alter the version.
-		const filePath = "0/0/0x0100000000000000000000000000000000000000000000000000000000000000.sszs"
+		const filePath = "0/0/0x8bb2f09de48c102635622dc27e6de03ae2b22639df7c33edbc8222b2ec423746.sszs"
 		file, err := dataColumnStorage.fs.OpenFile(filePath, os.O_WRONLY, os.FileMode(0600))
 		require.NoError(t, err)
 
@@ -644,31 +621,19 @@ func TestPrune(t *testing.T) {
 		}
 		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{0}: {
-					{Slot: 33, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 1
-					{Slot: 33, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 1
-				},
-				{1}: {
-					{Slot: 128_002, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4000
-					{Slot: 128_002, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4000
-				},
-				{2}: {
-					{Slot: 128_003, ColumnIndex: 1, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4000
-					{Slot: 128_003, ColumnIndex: 3, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4000
-				},
-				{3}: {
-					{Slot: 131_138, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4098
-					{Slot: 131_138, ColumnIndex: 3, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4098
-				},
-				{4}: {
-					{Slot: 131_169, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4099
-					{Slot: 131_169, ColumnIndex: 3, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4099
-				},
-				{5}: {
-					{Slot: 262_144, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 2 - Epoch 8192
-					{Slot: 262_144, ColumnIndex: 3, DataColumn: []byte{1, 2, 3}}, // Period 2 - Epoch 8292
-				},
+			[]util.DataColumnParam{
+				{Slot: 33, Index: 2, Column: [][]byte{{1}, {2}, {3}}},      // Period 0 - Epoch 1
+				{Slot: 33, Index: 4, Column: [][]byte{{2}, {3}, {4}}},      // Period 0 - Epoch 1
+				{Slot: 128_002, Index: 2, Column: [][]byte{{1}, {2}, {3}}}, // Period 0 - Epoch 4000
+				{Slot: 128_002, Index: 4, Column: [][]byte{{2}, {3}, {4}}}, // Period 0 - Epoch 4000
+				{Slot: 128_003, Index: 1, Column: [][]byte{{1}, {2}, {3}}}, // Period 0 - Epoch 4000
+				{Slot: 128_003, Index: 3, Column: [][]byte{{2}, {3}, {4}}}, // Period 0 - Epoch 4000
+				{Slot: 131_138, Index: 2, Column: [][]byte{{1}, {2}, {3}}}, // Period 1 - Epoch 4098
+				{Slot: 131_138, Index: 3, Column: [][]byte{{1}, {2}, {3}}}, // Period 1 - Epoch 4098
+				{Slot: 131_169, Index: 2, Column: [][]byte{{1}, {2}, {3}}}, // Period 1 - Epoch 4099
+				{Slot: 131_169, Index: 3, Column: [][]byte{{1}, {2}, {3}}}, // Period 1 - Epoch 4099
+				{Slot: 262_144, Index: 2, Column: [][]byte{{1}, {2}, {3}}}, // Period 2 - Epoch 8192
+				{Slot: 262_144, Index: 3, Column: [][]byte{{1}, {2}, {3}}}, // Period 2 - Epoch 8292
 			},
 		)
 
@@ -697,31 +662,31 @@ func TestPrune(t *testing.T) {
 
 		dirs, err = listDir(dataColumnStorage.fs, "0/1")
 		require.NoError(t, err)
-		require.Equal(t, true, compareSlices([]string{"0x0000000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+		require.Equal(t, true, compareSlices([]string{"0x775283f428813c949b7e8af07f01fef9790137f021b3597ad2d0d81e8be8f0f0.sszs"}, dirs))
 
 		dirs, err = listDir(dataColumnStorage.fs, "0/4000")
 		require.NoError(t, err)
 		require.Equal(t, true, compareSlices([]string{
-			"0x0200000000000000000000000000000000000000000000000000000000000000.sszs",
-			"0x0100000000000000000000000000000000000000000000000000000000000000.sszs",
+			"0x9977031132157ebb9c81bce952003ce07a4f54e921ca63b7693d1562483fdf9f.sszs",
+			"0xb2b14d9d858fa99b70f0405e4e39f38e51e36dd9a70343c109e24eeb5f77e369.sszs",
 		}, dirs))
 
 		dirs, err = listDir(dataColumnStorage.fs, "1/4098")
 		require.NoError(t, err)
-		require.Equal(t, true, compareSlices([]string{"0x0300000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+		require.Equal(t, true, compareSlices([]string{"0x5106745cdd6b1aa3602ef4d000ef373af672019264c167fa4bd641a1094aa5c5.sszs"}, dirs))
 
 		dirs, err = listDir(dataColumnStorage.fs, "1/4099")
 		require.NoError(t, err)
-		require.Equal(t, true, compareSlices([]string{"0x0400000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+		require.Equal(t, true, compareSlices([]string{"0x4e5f2bd5bb84bf0422af8edd1cc5a52cc6cea85baf3d66d172fe41831ac1239c.sszs"}, dirs))
 
 		dirs, err = listDir(dataColumnStorage.fs, "2/8192")
 		require.NoError(t, err)
-		require.Equal(t, true, compareSlices([]string{"0x0500000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+		require.Equal(t, true, compareSlices([]string{"0xa8adba7446eb56a01a9dd6d55e9c3990b10c91d43afb77847b4a21ac4ee62527.sszs"}, dirs))
 
 		_, verifiedRoDataColumnSidecars = util.CreateTestVerifiedRoDataColumnSidecars(
 			t,
-			util.DataColumnsParamsByRoot{
-				{6}: {{Slot: 451_141, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}}, // Period 3 - Epoch 14_098
+			[]util.DataColumnParam{
+				{Slot: 451_141, Index: 2, Column: [][]byte{{1}, {2}, {3}}}, // Period 3 - Epoch 14_098
 			},
 		)
 
@@ -749,14 +714,14 @@ func TestPrune(t *testing.T) {
 
 		dirs, err = listDir(dataColumnStorage.fs, "1/4099")
 		require.NoError(t, err)
-		require.Equal(t, true, compareSlices([]string{"0x0400000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+		require.Equal(t, true, compareSlices([]string{"0x4e5f2bd5bb84bf0422af8edd1cc5a52cc6cea85baf3d66d172fe41831ac1239c.sszs"}, dirs))
 
 		dirs, err = listDir(dataColumnStorage.fs, "2/8192")
 		require.NoError(t, err)
-		require.Equal(t, true, compareSlices([]string{"0x0500000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+		require.Equal(t, true, compareSlices([]string{"0xa8adba7446eb56a01a9dd6d55e9c3990b10c91d43afb77847b4a21ac4ee62527.sszs"}, dirs))
 
 		dirs, err = listDir(dataColumnStorage.fs, "3/14098")
 		require.NoError(t, err)
-		require.Equal(t, true, compareSlices([]string{"0x0600000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+		require.Equal(t, true, compareSlices([]string{"0x0de28a18cae63cbc6f0b20dc1afb0b1df38da40824a5f09f92d485ade04de97f.sszs"}, dirs))
 	})
 }

beacon-chain/db/kv/archived_point_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"

beacon-chain/db/kv/backfill_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"

beacon-chain/db/kv/backup_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"os"
 	"path/filepath"
 	"testing"

beacon-chain/db/kv/blocks_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"fmt"
 	"testing"
 	"time"

beacon-chain/db/kv/checkpoint_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/config/params"

beacon-chain/db/kv/deposit_contract_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/testing/assert"

beacon-chain/db/kv/encoding_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	testpb "github.com/OffchainLabs/prysm/v6/proto/testing"

beacon-chain/db/kv/execution_chain_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	v2 "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"

beacon-chain/db/kv/genesis_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"encoding/hex"
 	"os"
 	"testing"

beacon-chain/db/kv/kv_test.go

@@ -19,7 +19,10 @@ func setupDB(t testing.TB) *Store {
 	db, err := NewKVStore(t.Context(), t.TempDir())
 	require.NoError(t, err, "Failed to instantiate DB")
 	t.Cleanup(func() {
-		require.NoError(t, db.Close(), "Failed to close database")
+		err := db.Close()
+		if err != context.Canceled {
+			require.NoError(t, err, "Failed to close database")
+		}
 	})
 	return db
 }

beacon-chain/db/kv/lightclient_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"fmt"
 	"math/rand"
 	"testing"

beacon-chain/db/kv/migration_archived_index_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"

beacon-chain/db/kv/migration_block_slot_index_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"

beacon-chain/db/kv/migration_state_validators_test.go

@@ -2,7 +2,6 @@ package kv
 
 import (
 	"bytes"
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"

beacon-chain/db/kv/state_summary_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"

beacon-chain/db/kv/state_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"crypto/rand"
 	"encoding/binary"
 	mathRand "math/rand"
@@ -914,7 +913,7 @@ func checkStateSaveTime(b *testing.B, saveCount int) {
 		mathRand.Shuffle(len(allValidators), func(i, j int) { allValidators[i], allValidators[j] = allValidators[j], allValidators[i] })
 
 		require.NoError(b, st.SetValidators(allValidators))
-		require.NoError(b, db.SaveState(t.Context(), st, bytesutil.ToBytes32(key)))
+		require.NoError(b, db.SaveState(b.Context(), st, bytesutil.ToBytes32(key)))
 	}
 
 	// create a state to save in benchmark
@@ -926,7 +925,7 @@ func checkStateSaveTime(b *testing.B, saveCount int) {
 	b.ReportAllocs()
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
-		require.NoError(b, db.SaveState(t.Context(), st, r))
+		require.NoError(b, db.SaveState(b.Context(), st, r))
 	}
 }
 
@@ -941,7 +940,7 @@ func checkStateReadTime(b *testing.B, saveCount int) {
 	st, err := util.NewBeaconState()
 	require.NoError(b, err)
 	require.NoError(b, st.SetValidators(initialSetOfValidators))
-	require.NoError(b, db.SaveState(t.Context(), st, r))
+	require.NoError(b, db.SaveState(b.Context(), st, r))
 
 	// construct some states and save to randomize benchmark.
 	for i := 0; i < saveCount; i++ {
@@ -960,13 +959,13 @@ func checkStateReadTime(b *testing.B, saveCount int) {
 		mathRand.Shuffle(len(allValidators), func(i, j int) { allValidators[i], allValidators[j] = allValidators[j], allValidators[i] })
 
 		require.NoError(b, st.SetValidators(allValidators))
-		require.NoError(b, db.SaveState(t.Context(), st, bytesutil.ToBytes32(key)))
+		require.NoError(b, db.SaveState(b.Context(), st, bytesutil.ToBytes32(key)))
 	}
 
 	b.ReportAllocs()
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
-		_, err := db.State(t.Context(), r)
+		_, err := db.State(b.Context(), r)
 		require.NoError(b, err)
 	}
 }

beacon-chain/db/kv/utils_test.go

@@ -2,7 +2,6 @@ package kv
 
 import (
 	"bytes"
-	"context"
 	"crypto/rand"
 	"testing"
 

beacon-chain/db/kv/validated_checkpoint_test.go

@@ -1,7 +1,6 @@
 package kv
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
@@ -53,7 +52,7 @@ func TestStore_LastValidatedCheckpoint_Recover(t *testing.T) {
 
 func BenchmarkStore_SaveLastValidatedCheckpoint(b *testing.B) {
 	db := setupDB(b)
-	ctx := t.Context()
+	ctx := b.Context()
 	root := bytesutil.ToBytes32([]byte{'A'})
 	cp := &ethpb.Checkpoint{
 		Epoch: 10,