Quick and dirty earliest_available_slot implementation (networking only).

* Add reconstruction metrics

* Fix time

* Fix format

* Fix format

* Update cells count function

* fix cells count

* Update reconstruction counter

* Fix peerDAS reconstruction counter metric

* Replace dataColumnSidecars with dataColumnSideCars

api/client/beacon/health/health_test.go

@@ -1,6 +1,7 @@
 package health
 
 import (
+	"context"
 	"sync"
 	"testing"
 
@@ -22,7 +23,7 @@ func TestNodeHealth_IsHealthy(t *testing.T) {
 				isHealthy:  &tt.isHealthy,
 				healthChan: make(chan bool, 1),
 			}
-			if got := n.IsHealthy(t.Context()); got != tt.want {
+			if got := n.IsHealthy(context.Background()); got != tt.want {
 				t.Errorf("IsHealthy() = %v, want %v", got, tt.want)
 			}
 		})
@@ -53,7 +54,7 @@ func TestNodeHealth_UpdateNodeHealth(t *testing.T) {
 				healthChan: make(chan bool, 1),
 			}
 
-			s := n.CheckHealth(t.Context())
+			s := n.CheckHealth(context.Background())
 			// Check if health status was updated
 			if s != tt.newStatus {
 				t.Errorf("UpdateNodeHealth() failed to update isHealthy from %v to %v", tt.initial, tt.newStatus)
@@ -92,9 +93,9 @@ func TestNodeHealth_Concurrency(t *testing.T) {
 		go func() {
 			defer wg.Done()
 			client.EXPECT().IsHealthy(gomock.Any()).Return(false).Times(1)
-			n.CheckHealth(t.Context())
+			n.CheckHealth(context.Background())
 			client.EXPECT().IsHealthy(gomock.Any()).Return(true).Times(1)
-			n.CheckHealth(t.Context())
+			n.CheckHealth(context.Background())
 		}()
 	}
 
@@ -102,7 +103,7 @@ func TestNodeHealth_Concurrency(t *testing.T) {
 	for i := 0; i < numGoroutines; i++ {
 		go func() {
 			defer wg.Done()
-			_ = n.IsHealthy(t.Context()) // Just read the value
+			_ = n.IsHealthy(context.Background()) // Just read the value
 		}()
 	}
 

api/client/builder/client_test.go

@@ -2,6 +2,7 @@ package builder
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -30,7 +31,7 @@ func (fn roundtrip) RoundTrip(r *http.Request) (*http.Response, error) {
 }
 
 func TestClient_Status(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	statusPath := "/eth/v1/builder/status"
 	hc := &http.Client{
 		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
@@ -83,7 +84,7 @@ func TestClient_Status(t *testing.T) {
 }
 
 func TestClient_RegisterValidator(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	expectedBody := `[{"message":{"fee_recipient":"0x0000000000000000000000000000000000000000","gas_limit":"23","timestamp":"42","pubkey":"0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}]`
 	expectedPath := "/eth/v1/builder/validators"
 	t.Run("JSON success", func(t *testing.T) {
@@ -167,7 +168,7 @@ func TestClient_RegisterValidator(t *testing.T) {
 }
 
 func TestClient_GetHeader(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	expectedPath := "/eth/v1/builder/header/23/0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2/0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
 	var slot primitives.Slot = 23
 	parentHash := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
@@ -600,7 +601,7 @@ func TestClient_GetHeader(t *testing.T) {
 }
 
 func TestSubmitBlindedBlock(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	t.Run("bellatrix", func(t *testing.T) {
 		hc := &http.Client{
@@ -1558,7 +1559,7 @@ func TestRequestLogger(t *testing.T) {
 	c, err := NewClient("localhost:3500", wo)
 	require.NoError(t, err)
 
-	ctx := t.Context()
+	ctx := context.Background()
 	hc := &http.Client{
 		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 			require.Equal(t, getStatus, r.URL.Path)

api/client/event/event_stream_test.go

@@ -1,6 +1,7 @@
 package event
 
 import (
+	"context"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
@@ -29,7 +30,7 @@ func TestNewEventStream(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			_, err := NewEventStream(t.Context(), &http.Client{}, tt.host, tt.topics)
+			_, err := NewEventStream(context.Background(), &http.Client{}, tt.host, tt.topics)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("NewEventStream() error = %v, wantErr %v", err, tt.wantErr)
 			}
@@ -55,7 +56,7 @@ func TestEventStream(t *testing.T) {
 
 	topics := []string{"head"}
 	eventsChannel := make(chan *Event, 1)
-	stream, err := NewEventStream(t.Context(), http.DefaultClient, server.URL, topics)
+	stream, err := NewEventStream(context.Background(), http.DefaultClient, server.URL, topics)
 	require.NoError(t, err)
 	go stream.Subscribe(eventsChannel)
 

api/grpc/grpcutils_test.go

@@ -1,6 +1,7 @@
 package grpc
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -15,7 +16,7 @@ type customErrorData struct {
 
 func TestAppendHeaders(t *testing.T) {
 	t.Run("one_header", func(t *testing.T) {
-		ctx := AppendHeaders(t.Context(), []string{"first=value1"})
+		ctx := AppendHeaders(context.Background(), []string{"first=value1"})
 		md, ok := metadata.FromOutgoingContext(ctx)
 		require.Equal(t, true, ok, "Failed to read context metadata")
 		require.Equal(t, 1, md.Len(), "MetadataV0 contains wrong number of values")
@@ -23,7 +24,7 @@ func TestAppendHeaders(t *testing.T) {
 	})
 
 	t.Run("multiple_headers", func(t *testing.T) {
-		ctx := AppendHeaders(t.Context(), []string{"first=value1", "second=value2"})
+		ctx := AppendHeaders(context.Background(), []string{"first=value1", "second=value2"})
 		md, ok := metadata.FromOutgoingContext(ctx)
 		require.Equal(t, true, ok, "Failed to read context metadata")
 		require.Equal(t, 2, md.Len(), "MetadataV0 contains wrong number of values")
@@ -32,7 +33,7 @@ func TestAppendHeaders(t *testing.T) {
 	})
 
 	t.Run("one_empty_header", func(t *testing.T) {
-		ctx := AppendHeaders(t.Context(), []string{"first=value1", ""})
+		ctx := AppendHeaders(context.Background(), []string{"first=value1", ""})
 		md, ok := metadata.FromOutgoingContext(ctx)
 		require.Equal(t, true, ok, "Failed to read context metadata")
 		require.Equal(t, 1, md.Len(), "MetadataV0 contains wrong number of values")
@@ -41,7 +42,7 @@ func TestAppendHeaders(t *testing.T) {
 
 	t.Run("incorrect_header", func(t *testing.T) {
 		logHook := logTest.NewGlobal()
-		ctx := AppendHeaders(t.Context(), []string{"first=value1", "second"})
+		ctx := AppendHeaders(context.Background(), []string{"first=value1", "second"})
 		md, ok := metadata.FromOutgoingContext(ctx)
 		require.Equal(t, true, ok, "Failed to read context metadata")
 		require.Equal(t, 1, md.Len(), "MetadataV0 contains wrong number of values")
@@ -50,7 +51,7 @@ func TestAppendHeaders(t *testing.T) {
 	})
 
 	t.Run("header_value_with_equal_sign", func(t *testing.T) {
-		ctx := AppendHeaders(t.Context(), []string{"first=value=1"})
+		ctx := AppendHeaders(context.Background(), []string{"first=value=1"})
 		md, ok := metadata.FromOutgoingContext(ctx)
 		require.Equal(t, true, ok, "Failed to read context metadata")
 		require.Equal(t, 1, md.Len(), "MetadataV0 contains wrong number of values")

api/server/httprest/server_test.go

@@ -1,6 +1,7 @@
 package httprest
 
 import (
+	"context"
 	"flag"
 	"fmt"
 	"net"
@@ -33,7 +34,7 @@ func TestServer_StartStop(t *testing.T) {
 		WithRouter(handler),
 	}
 
-	g, err := New(t.Context(), opts...)
+	g, err := New(context.Background(), opts...)
 	require.NoError(t, err)
 
 	g.Start()
@@ -61,7 +62,7 @@ func TestServer_NilHandler_NotFoundHandlerRegistered(t *testing.T) {
 		WithRouter(handler),
 	}
 
-	g, err := New(t.Context(), opts...)
+	g, err := New(context.Background(), opts...)
 	require.NoError(t, err)
 
 	writer := httptest.NewRecorder()

api/server/middleware/BUILD.bazel

@@ -8,11 +8,7 @@ go_library(
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/api/server/middleware",
     visibility = ["//visibility:public"],
-    deps = [
-        "//api:go_default_library",
-        "@com_github_rs_cors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
+    deps = ["@com_github_rs_cors//:go_default_library"],
 )
 
 go_test(
@@ -26,6 +22,5 @@ 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,14 +1,11 @@
 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
@@ -115,46 +112,6 @@ 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,16 +1,12 @@
 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) {
@@ -128,89 +124,6 @@ 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"}
 

api/server/structs/endpoints_events.go

@@ -25,13 +25,6 @@ type BlockGossipEvent struct {
 	Block string `json:"block"`
 }
 
-type DataColumnGossipEvent struct {
-	Slot           string   `json:"slot"`
-	Index          string   `json:"index"`
-	BlockRoot      string   `json:"block_root"`
-	KzgCommitments []string `json:"kzg_commitments"`
-}
-
 type AggregatedAttEventSource struct {
 	Aggregate *Attestation `json:"aggregate"`
 }

async/debounce_test.go

@@ -15,7 +15,7 @@ import (
 
 func TestDebounce_NoEvents(t *testing.T) {
 	eventsChan := make(chan interface{}, 100)
-	ctx, cancel := context.WithCancel(t.Context())
+	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
 	timesHandled := int32(0)
 	wg := &sync.WaitGroup{}
@@ -39,7 +39,7 @@ func TestDebounce_NoEvents(t *testing.T) {
 
 func TestDebounce_CtxClosing(t *testing.T) {
 	eventsChan := make(chan interface{}, 100)
-	ctx, cancel := context.WithCancel(t.Context())
+	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
 	timesHandled := int32(0)
 	wg := &sync.WaitGroup{}
@@ -75,7 +75,7 @@ func TestDebounce_CtxClosing(t *testing.T) {
 
 func TestDebounce_SingleHandlerInvocation(t *testing.T) {
 	eventsChan := make(chan interface{}, 100)
-	ctx, cancel := context.WithCancel(t.Context())
+	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
 	timesHandled := int32(0)
 	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
@@ -93,7 +93,7 @@ func TestDebounce_SingleHandlerInvocation(t *testing.T) {
 
 func TestDebounce_MultipleHandlerInvocation(t *testing.T) {
 	eventsChan := make(chan interface{}, 100)
-	ctx, cancel := context.WithCancel(t.Context())
+	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
 	timesHandled := int32(0)
 	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {

async/every_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func TestEveryRuns(t *testing.T) {
-	ctx, cancel := context.WithCancel(t.Context())
+	ctx, cancel := context.WithCancel(context.Background())
 
 	i := int32(0)
 	async.RunEvery(ctx, 100*time.Millisecond, func() {

beacon-chain/blockchain/chain_info_norace_test.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"context"
 	"testing"
 
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
@@ -24,7 +25,7 @@ func TestHeadSlot_DataRace(t *testing.T) {
 	wait := make(chan struct{})
 	go func() {
 		defer close(wait)
-		require.NoError(t, s.saveHead(t.Context(), [32]byte{}, b, st))
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
 	}()
 	s.HeadSlot()
 	<-wait
@@ -42,10 +43,10 @@ func TestHeadRoot_DataRace(t *testing.T) {
 	st, _ := util.DeterministicGenesisState(t, 1)
 	go func() {
 		defer close(wait)
-		require.NoError(t, s.saveHead(t.Context(), [32]byte{}, b, st))
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
 
 	}()
-	_, err = s.HeadRoot(t.Context())
+	_, err = s.HeadRoot(context.Background())
 	require.NoError(t, err)
 	<-wait
 }
@@ -64,10 +65,10 @@ func TestHeadBlock_DataRace(t *testing.T) {
 	st, _ := util.DeterministicGenesisState(t, 1)
 	go func() {
 		defer close(wait)
-		require.NoError(t, s.saveHead(t.Context(), [32]byte{}, b, st))
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
 
 	}()
-	_, err = s.HeadBlock(t.Context())
+	_, err = s.HeadBlock(context.Background())
 	require.NoError(t, err)
 	<-wait
 }
@@ -82,14 +83,14 @@ func TestHeadState_DataRace(t *testing.T) {
 	wait := make(chan struct{})
 	st, _ := util.DeterministicGenesisState(t, 1)
 	root := bytesutil.ToBytes32(bytesutil.PadTo([]byte{'s'}, 32))
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(t.Context(), root))
-	require.NoError(t, beaconDB.SaveState(t.Context(), st, root))
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(context.Background(), root))
+	require.NoError(t, beaconDB.SaveState(context.Background(), st, root))
 	go func() {
 		defer close(wait)
-		require.NoError(t, s.saveHead(t.Context(), [32]byte{}, b, st))
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
 
 	}()
-	_, err = s.HeadState(t.Context())
+	_, err = s.HeadState(context.Background())
 	require.NoError(t, err)
 	<-wait
 }

beacon-chain/blockchain/chain_info_test.go

@@ -84,7 +84,7 @@ func prepareForkchoiceState(
 func TestHeadRoot_Nil(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	c := setupBeaconChain(t, beaconDB)
-	headRoot, err := c.HeadRoot(t.Context())
+	headRoot, err := c.HeadRoot(context.Background())
 	require.NoError(t, err)
 	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], headRoot, "Incorrect pre chain start value")
 }
@@ -137,7 +137,7 @@ func TestFinalizedBlockHash(t *testing.T) {
 }
 
 func TestUnrealizedJustifiedBlockHash(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	service := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
 	ojc := &ethpb.Checkpoint{Root: []byte{'j'}}
 	ofc := &ethpb.Checkpoint{Root: []byte{'f'}}
@@ -203,7 +203,7 @@ func TestHeadBlock_CanRetrieve(t *testing.T) {
 	c := &Service{}
 	c.head = &head{block: wsb, state: s}
 
-	received, err := c.HeadBlock(t.Context())
+	received, err := c.HeadBlock(context.Background())
 	require.NoError(t, err)
 	pb, err := received.Proto()
 	require.NoError(t, err)
@@ -215,7 +215,7 @@ func TestHeadState_CanRetrieve(t *testing.T) {
 	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{state: s}
-	headState, err := c.HeadState(t.Context())
+	headState, err := c.HeadState(context.Background())
 	require.NoError(t, err)
 	assert.DeepEqual(t, headState.ToProtoUnsafe(), s.ToProtoUnsafe(), "Incorrect head state received")
 }
@@ -277,7 +277,7 @@ func TestHeadETH1Data_CanRetrieve(t *testing.T) {
 }
 
 func TestIsCanonical_Ok(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	c := setupBeaconChain(t, beaconDB)
 
@@ -301,12 +301,12 @@ func TestService_HeadValidatorsIndices(t *testing.T) {
 	c := &Service{}
 
 	c.head = &head{}
-	indices, err := c.HeadValidatorsIndices(t.Context(), 0)
+	indices, err := c.HeadValidatorsIndices(context.Background(), 0)
 	require.NoError(t, err)
 	require.Equal(t, 0, len(indices))
 
 	c.head = &head{state: s}
-	indices, err = c.HeadValidatorsIndices(t.Context(), 0)
+	indices, err = c.HeadValidatorsIndices(context.Background(), 0)
 	require.NoError(t, err)
 	require.Equal(t, 10, len(indices))
 }
@@ -331,7 +331,7 @@ func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
 //     ---------- D
 
 func TestService_ChainHeads(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
@@ -399,7 +399,7 @@ func TestService_HeadValidatorIndexToPublicKey(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	p, err := c.HeadValidatorIndexToPublicKey(t.Context(), 0)
+	p, err := c.HeadValidatorIndexToPublicKey(context.Background(), 0)
 	require.NoError(t, err)
 
 	v, err := s.ValidatorAtIndex(0)
@@ -412,12 +412,12 @@ func TestService_HeadValidatorIndexToPublicKeyNil(t *testing.T) {
 	c := &Service{}
 	c.head = nil
 
-	p, err := c.HeadValidatorIndexToPublicKey(t.Context(), 0)
+	p, err := c.HeadValidatorIndexToPublicKey(context.Background(), 0)
 	require.NoError(t, err)
 	require.Equal(t, [fieldparams.BLSPubkeyLength]byte{}, p)
 
 	c.head = &head{state: nil}
-	p, err = c.HeadValidatorIndexToPublicKey(t.Context(), 0)
+	p, err = c.HeadValidatorIndexToPublicKey(context.Background(), 0)
 	require.NoError(t, err)
 	require.Equal(t, [fieldparams.BLSPubkeyLength]byte{}, p)
 }
@@ -428,7 +428,7 @@ func TestService_IsOptimistic(t *testing.T) {
 	cfg.BellatrixForkEpoch = 0
 	params.OverrideBeaconConfig(cfg)
 
-	ctx := t.Context()
+	ctx := context.Background()
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
@@ -456,7 +456,7 @@ func TestService_IsOptimistic(t *testing.T) {
 }
 
 func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	c := &Service{genesisTime: time.Now()}
 	opt, err := c.IsOptimistic(ctx)
 	require.NoError(t, err)
@@ -464,7 +464,7 @@ func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
 }
 
 func TestService_IsOptimisticForRoot(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
@@ -482,27 +482,27 @@ func TestService_IsOptimisticForRoot(t *testing.T) {
 
 func TestService_IsOptimisticForRoot_DB(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	ctx := t.Context()
+	ctx := context.Background()
 	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, t.Context(), beaconDB, b)
-	require.NoError(t, beaconDB.SaveStateSummary(t.Context(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
+	util.SaveBlock(t, context.Background(), beaconDB, b)
+	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
 
 	optimisticBlock := util.NewBeaconBlock()
 	optimisticBlock.Block.Slot = 97
 	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, t.Context(), beaconDB, optimisticBlock)
+	util.SaveBlock(t, context.Background(), beaconDB, optimisticBlock)
 
 	validatedBlock := util.NewBeaconBlock()
 	validatedBlock.Block.Slot = 9
 	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, t.Context(), beaconDB, validatedBlock)
+	util.SaveBlock(t, context.Background(), beaconDB, validatedBlock)
 
 	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
 	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
@@ -524,10 +524,10 @@ func TestService_IsOptimisticForRoot_DB(t *testing.T) {
 	// Before the first finalized epoch, finalized root could be zeros.
 	validatedCheckpoint = &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, br))
-	require.NoError(t, beaconDB.SaveStateSummary(t.Context(), &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:], Slot: 10}))
+	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:], Slot: 10}))
 	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
 
-	require.NoError(t, beaconDB.SaveStateSummary(t.Context(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
+	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
 	optimistic, err = c.IsOptimisticForRoot(ctx, optimisticRoot)
 	require.NoError(t, err)
 	require.Equal(t, true, optimistic)
@@ -535,37 +535,37 @@ func TestService_IsOptimisticForRoot_DB(t *testing.T) {
 
 func TestService_IsOptimisticForRoot_DB_non_canonical(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	ctx := t.Context()
+	ctx := context.Background()
 	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, t.Context(), beaconDB, b)
-	require.NoError(t, beaconDB.SaveStateSummary(t.Context(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
+	util.SaveBlock(t, context.Background(), beaconDB, b)
+	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
 
 	optimisticBlock := util.NewBeaconBlock()
 	optimisticBlock.Block.Slot = 97
 	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, t.Context(), beaconDB, optimisticBlock)
+	util.SaveBlock(t, context.Background(), beaconDB, optimisticBlock)
 
 	validatedBlock := util.NewBeaconBlock()
 	validatedBlock.Block.Slot = 9
 	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, t.Context(), beaconDB, validatedBlock)
+	util.SaveBlock(t, context.Background(), beaconDB, validatedBlock)
 
 	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
 	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
 
-	require.NoError(t, beaconDB.SaveStateSummary(t.Context(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
+	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
 	optimistic, err := c.IsOptimisticForRoot(ctx, optimisticRoot)
 	require.NoError(t, err)
 	require.Equal(t, true, optimistic)
 
-	require.NoError(t, beaconDB.SaveStateSummary(t.Context(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
+	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
 	validated, err := c.IsOptimisticForRoot(ctx, validatedRoot)
 	require.NoError(t, err)
 	require.Equal(t, true, validated)
@@ -574,14 +574,14 @@ func TestService_IsOptimisticForRoot_DB_non_canonical(t *testing.T) {
 
 func TestService_IsOptimisticForRoot_StateSummaryRecovered(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	ctx := t.Context()
+	ctx := context.Background()
 	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	util.SaveBlock(t, t.Context(), beaconDB, b)
+	util.SaveBlock(t, context.Background(), beaconDB, b)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, [32]byte{}))
 	_, err = c.IsOptimisticForRoot(ctx, br)
 	assert.NoError(t, err)
@@ -594,7 +594,7 @@ func TestService_IsOptimisticForRoot_StateSummaryRecovered(t *testing.T) {
 
 func TestService_IsFinalized(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	ctx := t.Context()
+	ctx := context.Background()
 	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}}
 	r1 := [32]byte{'a'}
 	require.NoError(t, c.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{
@@ -616,7 +616,7 @@ func TestService_IsFinalized(t *testing.T) {
 
 func Test_hashForGenesisRoot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	ctx := t.Context()
+	ctx := context.Background()
 	c := setupBeaconChain(t, beaconDB)
 	st, _ := util.DeterministicGenesisStateElectra(t, 10)
 	require.NoError(t, c.cfg.BeaconDB.SaveGenesisData(ctx, st))

beacon-chain/blockchain/forkchoice_update_execution_test.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"context"
 	"testing"
 	"time"
 
@@ -35,29 +36,29 @@ func TestService_isNewHead(t *testing.T) {
 func TestService_getHeadStateAndBlock(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
-	_, _, err := service.getStateAndBlock(t.Context(), [32]byte{})
+	_, _, err := service.getStateAndBlock(context.Background(), [32]byte{})
 	require.ErrorContains(t, "block does not exist", err)
 
 	blk, err := blocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{Signature: []byte{1}}))
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(t.Context(), blk))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), blk))
 
 	st, _ := util.DeterministicGenesisState(t, 1)
 	r, err := blk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(t.Context(), st, r))
+	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), st, r))
 
-	gotState, err := service.cfg.BeaconDB.State(t.Context(), r)
+	gotState, err := service.cfg.BeaconDB.State(context.Background(), r)
 	require.NoError(t, err)
 	require.DeepEqual(t, st.ToProto(), gotState.ToProto())
 
-	gotBlk, err := service.cfg.BeaconDB.Block(t.Context(), r)
+	gotBlk, err := service.cfg.BeaconDB.Block(context.Background(), r)
 	require.NoError(t, err)
 	require.DeepEqual(t, blk, gotBlk)
 }
 
 func TestService_forkchoiceUpdateWithExecution_exceptionalCases(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	opts := testServiceOptsWithDB(t)
 
 	service, err := NewService(ctx, opts...)

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
@@ -20,18 +21,18 @@ func TestService_HeadSyncCommitteeIndices(t *testing.T) {
 
 	// Current period
 	slot := 2*uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	a, err := c.HeadSyncCommitteeIndices(t.Context(), 0, primitives.Slot(slot))
+	a, err := c.HeadSyncCommitteeIndices(context.Background(), 0, primitives.Slot(slot))
 	require.NoError(t, err)
 
 	// Current period where slot-2 across EPOCHS_PER_SYNC_COMMITTEE_PERIOD
 	slot = 3*uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) - 2
-	b, err := c.HeadSyncCommitteeIndices(t.Context(), 0, primitives.Slot(slot))
+	b, err := c.HeadSyncCommitteeIndices(context.Background(), 0, primitives.Slot(slot))
 	require.NoError(t, err)
 	require.DeepEqual(t, a, b)
 
 	// Next period where slot-1 across EPOCHS_PER_SYNC_COMMITTEE_PERIOD
 	slot = 3*uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) - 1
-	b, err = c.HeadSyncCommitteeIndices(t.Context(), 0, primitives.Slot(slot))
+	b, err = c.HeadSyncCommitteeIndices(context.Background(), 0, primitives.Slot(slot))
 	require.NoError(t, err)
 	require.DeepNotEqual(t, a, b)
 }
@@ -43,7 +44,7 @@ func TestService_headCurrentSyncCommitteeIndices(t *testing.T) {
 
 	// Process slot up to `EpochsPerSyncCommitteePeriod` so it can `ProcessSyncCommitteeUpdates`.
 	slot := uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	indices, err := c.headCurrentSyncCommitteeIndices(t.Context(), 0, primitives.Slot(slot))
+	indices, err := c.headCurrentSyncCommitteeIndices(context.Background(), 0, primitives.Slot(slot))
 	require.NoError(t, err)
 
 	// NextSyncCommittee becomes CurrentSyncCommittee so it should be empty by default.
@@ -57,7 +58,7 @@ func TestService_headNextSyncCommitteeIndices(t *testing.T) {
 
 	// Process slot up to `EpochsPerSyncCommitteePeriod` so it can `ProcessSyncCommitteeUpdates`.
 	slot := uint64(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	indices, err := c.headNextSyncCommitteeIndices(t.Context(), 0, primitives.Slot(slot))
+	indices, err := c.headNextSyncCommitteeIndices(context.Background(), 0, primitives.Slot(slot))
 	require.NoError(t, err)
 
 	// NextSyncCommittee should be empty after `ProcessSyncCommitteeUpdates`. Validator should get indices.
@@ -71,7 +72,7 @@ func TestService_HeadSyncCommitteePubKeys(t *testing.T) {
 
 	// Process slot up to 2 * `EpochsPerSyncCommitteePeriod` so it can run `ProcessSyncCommitteeUpdates` twice.
 	slot := uint64(2*params.BeaconConfig().EpochsPerSyncCommitteePeriod)*uint64(params.BeaconConfig().SlotsPerEpoch) + 1
-	pubkeys, err := c.HeadSyncCommitteePubKeys(t.Context(), primitives.Slot(slot), 0)
+	pubkeys, err := c.HeadSyncCommitteePubKeys(context.Background(), primitives.Slot(slot), 0)
 	require.NoError(t, err)
 
 	// Any subcommittee should match the subcommittee size.
@@ -87,7 +88,7 @@ func TestService_HeadSyncCommitteeDomain(t *testing.T) {
 	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 
-	d, err := c.HeadSyncCommitteeDomain(t.Context(), 0)
+	d, err := c.HeadSyncCommitteeDomain(context.Background(), 0)
 	require.NoError(t, err)
 
 	require.DeepEqual(t, wanted, d)
@@ -101,7 +102,7 @@ func TestService_HeadSyncContributionProofDomain(t *testing.T) {
 	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 
-	d, err := c.HeadSyncContributionProofDomain(t.Context(), 0)
+	d, err := c.HeadSyncContributionProofDomain(context.Background(), 0)
 	require.NoError(t, err)
 
 	require.DeepEqual(t, wanted, d)
@@ -115,7 +116,7 @@ func TestService_HeadSyncSelectionProofDomain(t *testing.T) {
 	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 
-	d, err := c.HeadSyncSelectionProofDomain(t.Context(), 0)
+	d, err := c.HeadSyncSelectionProofDomain(context.Background(), 0)
 	require.NoError(t, err)
 
 	require.DeepEqual(t, wanted, d)

beacon-chain/blockchain/head_test.go

@@ -34,17 +34,17 @@ func TestSaveHead_Same(t *testing.T) {
 	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	st, _ := util.DeterministicGenesisState(t, 1)
-	require.NoError(t, service.saveHead(t.Context(), r, b, st))
+	require.NoError(t, service.saveHead(context.Background(), r, b, st))
 	assert.Equal(t, primitives.Slot(0), service.headSlot(), "Head did not stay the same")
 	assert.Equal(t, r, service.headRoot(), "Head did not stay the same")
 }
 
 func TestSaveHead_Different(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	oldBlock := util.SaveBlock(t, t.Context(), service.cfg.BeaconDB, util.NewBeaconBlock())
+	oldBlock := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, util.NewBeaconBlock())
 	oldRoot, err := oldBlock.Block().HashTreeRoot()
 	require.NoError(t, err)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
@@ -61,7 +61,7 @@ func TestSaveHead_Different(t *testing.T) {
 	newHeadSignedBlock.Block.Slot = 1
 	newHeadBlock := newHeadSignedBlock.Block
 
-	wsb := util.SaveBlock(t, t.Context(), service.cfg.BeaconDB, newHeadSignedBlock)
+	wsb := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, newHeadSignedBlock)
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
 	state, blkRoot, err = prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, ojc, ofc)
@@ -74,13 +74,13 @@ func TestSaveHead_Different(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(1))
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(t.Context(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(t.Context(), headState, newRoot))
-	require.NoError(t, service.saveHead(t.Context(), newRoot, wsb, headState))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), headState, newRoot))
+	require.NoError(t, service.saveHead(context.Background(), newRoot, wsb, headState))
 
 	assert.Equal(t, primitives.Slot(1), service.HeadSlot(), "Head did not change")
 
-	cachedRoot, err := service.HeadRoot(t.Context())
+	cachedRoot, err := service.HeadRoot(context.Background())
 	require.NoError(t, err)
 	assert.DeepEqual(t, cachedRoot, newRoot[:], "Head did not change")
 	headBlock, err := service.headBlock()
@@ -92,12 +92,12 @@ func TestSaveHead_Different(t *testing.T) {
 }
 
 func TestSaveHead_Different_Reorg(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	hook := logTest.NewGlobal()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	oldBlock := util.SaveBlock(t, t.Context(), service.cfg.BeaconDB, util.NewBeaconBlock())
+	oldBlock := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, util.NewBeaconBlock())
 	oldRoot, err := oldBlock.Block().HashTreeRoot()
 	require.NoError(t, err)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
@@ -120,7 +120,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:]
 	newHeadBlock := newHeadSignedBlock.Block
 
-	wsb := util.SaveBlock(t, t.Context(), service.cfg.BeaconDB, newHeadSignedBlock)
+	wsb := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, newHeadSignedBlock)
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
 	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, ojc, ofc)
@@ -129,13 +129,13 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(1))
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(t.Context(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(t.Context(), headState, newRoot))
-	require.NoError(t, service.saveHead(t.Context(), newRoot, wsb, headState))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), headState, newRoot))
+	require.NoError(t, service.saveHead(context.Background(), newRoot, wsb, headState))
 
 	assert.Equal(t, primitives.Slot(1), service.HeadSlot(), "Head did not change")
 
-	cachedRoot, err := service.HeadRoot(t.Context())
+	cachedRoot, err := service.HeadRoot(context.Background())
 	require.NoError(t, err)
 	if !bytes.Equal(cachedRoot, newRoot[:]) {
 		t.Error("Head did not change")
@@ -162,12 +162,12 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			},
 			originBlockRoot: [32]byte{1},
 		}
-		st, blk, err := prepareForkchoiceState(t.Context(), 0, [32]byte{}, [32]byte{}, [32]byte{}, &ethpb.Checkpoint{}, &ethpb.Checkpoint{})
+		st, blk, err := prepareForkchoiceState(context.Background(), 0, [32]byte{}, [32]byte{}, [32]byte{}, &ethpb.Checkpoint{}, &ethpb.Checkpoint{})
 		require.NoError(t, err)
-		require.NoError(t, srv.cfg.ForkChoiceStore.InsertNode(t.Context(), st, blk))
+		require.NoError(t, srv.cfg.ForkChoiceStore.InsertNode(context.Background(), st, blk))
 		newHeadStateRoot := [32]byte{2}
 		newHeadRoot := [32]byte{3}
-		require.NoError(t, srv.notifyNewHeadEvent(t.Context(), 1, bState, newHeadStateRoot[:], newHeadRoot[:]))
+		require.NoError(t, srv.notifyNewHeadEvent(context.Background(), 1, bState, newHeadStateRoot[:], newHeadRoot[:]))
 		events := notifier.ReceivedEvents()
 		require.Equal(t, 1, len(events))
 
@@ -194,9 +194,9 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 			},
 			originBlockRoot: genesisRoot,
 		}
-		st, blk, err := prepareForkchoiceState(t.Context(), 0, [32]byte{}, [32]byte{}, [32]byte{}, &ethpb.Checkpoint{}, &ethpb.Checkpoint{})
+		st, blk, err := prepareForkchoiceState(context.Background(), 0, [32]byte{}, [32]byte{}, [32]byte{}, &ethpb.Checkpoint{}, &ethpb.Checkpoint{})
 		require.NoError(t, err)
-		require.NoError(t, srv.cfg.ForkChoiceStore.InsertNode(t.Context(), st, blk))
+		require.NoError(t, srv.cfg.ForkChoiceStore.InsertNode(context.Background(), st, blk))
 		epoch1Start, err := slots.EpochStart(1)
 		require.NoError(t, err)
 		epoch2Start, err := slots.EpochStart(1)
@@ -205,7 +205,7 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 
 		newHeadStateRoot := [32]byte{2}
 		newHeadRoot := [32]byte{3}
-		err = srv.notifyNewHeadEvent(t.Context(), epoch2Start, bState, newHeadStateRoot[:], newHeadRoot[:])
+		err = srv.notifyNewHeadEvent(context.Background(), epoch2Start, bState, newHeadStateRoot[:], newHeadRoot[:])
 		require.NoError(t, err)
 		events := notifier.ReceivedEvents()
 		require.Equal(t, 1, len(events))
@@ -225,11 +225,11 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 }
 
 func TestRetrieveHead_ReadOnly(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	oldBlock := util.SaveBlock(t, t.Context(), service.cfg.BeaconDB, util.NewBeaconBlock())
+	oldBlock := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, util.NewBeaconBlock())
 	oldRoot, err := oldBlock.Block().HashTreeRoot()
 	require.NoError(t, err)
 	service.head = &head{
@@ -243,7 +243,7 @@ func TestRetrieveHead_ReadOnly(t *testing.T) {
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 
-	wsb := util.SaveBlock(t, t.Context(), service.cfg.BeaconDB, newHeadSignedBlock)
+	wsb := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, newHeadSignedBlock)
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
 	state, blkRoot, err := prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, ojc, ofc)
@@ -256,9 +256,9 @@ func TestRetrieveHead_ReadOnly(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(1))
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(t.Context(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(t.Context(), headState, newRoot))
-	require.NoError(t, service.saveHead(t.Context(), newRoot, wsb, headState))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Slot: 1, Root: newRoot[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), headState, newRoot))
+	require.NoError(t, service.saveHead(context.Background(), newRoot, wsb, headState))
 
 	rOnlyState, err := service.HeadStateReadOnly(ctx)
 	require.NoError(t, err)
@@ -267,7 +267,7 @@ func TestRetrieveHead_ReadOnly(t *testing.T) {
 }
 
 func TestSaveOrphanedAtts(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 	service.genesisTime = time.Now().Add(time.Duration(-10*int64(1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
@@ -333,7 +333,7 @@ func TestSaveOrphanedAtts(t *testing.T) {
 }
 
 func TestSaveOrphanedAttsElectra(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 	service.genesisTime = time.Now().Add(time.Duration(-10*int64(1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
@@ -404,7 +404,7 @@ func TestSaveOrphanedOps(t *testing.T) {
 	config.ShardCommitteePeriod = 0
 	params.OverrideBeaconConfig(config)
 
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 	service.genesisTime = time.Now().Add(time.Duration(-10*int64(1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
@@ -481,7 +481,7 @@ func TestSaveOrphanedOps(t *testing.T) {
 }
 
 func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 	service.cfg.BLSToExecPool = blstoexec.NewPool()
@@ -539,7 +539,7 @@ func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
 }
 
 func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 	service.genesisTime = time.Now().Add(time.Duration(-10*int64(1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
@@ -604,7 +604,7 @@ func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
 }
 
 func TestSaveOrphanedAtts_CanFilter_DoublyLinkedTrie(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 	service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+2)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)

beacon-chain/blockchain/init_sync_process_block_test.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"context"
 	"testing"
 
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
@@ -10,7 +11,7 @@ import (
 )
 
 func TestService_getBlock(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	s := setupBeaconChain(t, beaconDB)
 	b1 := util.NewBeaconBlock()
@@ -41,7 +42,7 @@ func TestService_getBlock(t *testing.T) {
 }
 
 func TestService_hasBlockInInitSyncOrDB(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	s := setupBeaconChain(t, beaconDB)
 	b1 := util.NewBeaconBlock()

beacon-chain/blockchain/log.go

@@ -26,6 +26,9 @@ 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()))
 	}
@@ -108,6 +111,7 @@ 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 {
@@ -155,9 +159,7 @@ func logPayload(block interfaces.ReadOnlyBeaconBlock) error {
 		if err != nil {
 			return errors.Wrap(err, "could not get BLSToExecutionChanges")
 		}
-		if len(changes) > 0 {
-			fields["blsToExecutionChanges"] = len(changes)
-		}
+		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 prefix=blockchain slot=0",
+			want: "\"Finished applying state transition\" attestations=1 deposits=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 prefix=blockchain proposerSlashings=1 slot=0 voluntaryExits=1",
+			want: "\"Finished applying state transition\" attestations=1 attesterSlashings=1 deposits=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,6 +1,7 @@
 package blockchain
 
 import (
+	"context"
 	"testing"
 
 	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -14,7 +15,7 @@ func TestReportEpochMetrics_BadHeadState(t *testing.T) {
 	h, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, h.SetValidators(nil))
-	err = reportEpochMetrics(t.Context(), s, h)
+	err = reportEpochMetrics(context.Background(), s, h)
 	require.ErrorContains(t, "failed to initialize precompute: state has nil validator slice", err)
 }
 
@@ -24,7 +25,7 @@ func TestReportEpochMetrics_BadAttestation(t *testing.T) {
 	h, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, h.AppendCurrentEpochAttestations(&eth.PendingAttestation{InclusionDelay: 0}))
-	err = reportEpochMetrics(t.Context(), s, h)
+	err = reportEpochMetrics(context.Background(), s, h)
 	require.ErrorContains(t, "attestation with inclusion delay of 0", err)
 }
 
@@ -35,6 +36,6 @@ func TestReportEpochMetrics_SlashedValidatorOutOfBound(t *testing.T) {
 	v.Slashed = true
 	require.NoError(t, h.UpdateValidatorAtIndex(0, v))
 	require.NoError(t, h.AppendCurrentEpochAttestations(&eth.PendingAttestation{InclusionDelay: 1, Data: util.HydrateAttestationData(&eth.AttestationData{})}))
-	err = reportEpochMetrics(t.Context(), h, h)
+	err = reportEpochMetrics(context.Background(), h, h)
 	require.ErrorContains(t, "slot 0 out of bounds", err)
 }

beacon-chain/blockchain/options.go

@@ -258,12 +258,3 @@ 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_attestation.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -89,7 +88,7 @@ func (s *Service) OnAttestation(ctx context.Context, a ethpb.Att, disparity time
 	if err != nil {
 		return err
 	}
-	if err := attestation.IsValidAttestationIndices(ctx, indexedAtt, params.BeaconConfig().MaxValidatorsPerCommittee, params.BeaconConfig().MaxCommitteesPerSlot); err != nil {
+	if err := attestation.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
 		return err
 	}
 

beacon-chain/blockchain/process_attestation_test.go

@@ -161,7 +161,7 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 
 func TestService_GetRecentPreState(t *testing.T) {
 	service, _ := minimalTestService(t)
-	ctx := t.Context()
+	ctx := context.Background()
 
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -183,7 +183,7 @@ func TestService_GetRecentPreState(t *testing.T) {
 
 func TestService_GetAttPreState_Concurrency(t *testing.T) {
 	service, _ := minimalTestService(t)
-	ctx := t.Context()
+	ctx := context.Background()
 
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -353,21 +353,21 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 }
 
 func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	require.NoError(t, verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)}))
 }
 
 func TestAttEpoch_MatchCurrentEpoch(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	nowTime := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	require.NoError(t, verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Epoch: 1}))
 }
 
 func TestAttEpoch_NotMatch(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	nowTime := 2 * uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
 	err := verifyAttTargetEpoch(ctx, 0, nowTime, &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)})
@@ -375,7 +375,7 @@ func TestAttEpoch_NotMatch(t *testing.T) {
 }
 
 func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -385,7 +385,7 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 }
 
 func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
@@ -402,7 +402,7 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 }
 
 func TestVerifyBeaconBlock_OK(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)

beacon-chain/blockchain/process_block.go

@@ -72,6 +72,8 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	}
 	if features.Get().EnableLightClient && slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().AltairForkEpoch {
 		defer s.processLightClientUpdates(cfg)
+		defer s.saveLightClientUpdate(cfg)
+		defer s.saveLightClientBootstrap(cfg)
 	}
 	defer s.sendStateFeedOnBlock(cfg)
 	defer reportProcessingTime(startTime)
@@ -641,6 +643,7 @@ func (s *Service) isDataAvailable(
 	ctx context.Context,
 	root [fieldparams.RootLength]byte,
 	signedBlock interfaces.ReadOnlySignedBeaconBlock,
+	startWaiting ...chan<- bool, // For tests purposes only
 ) error {
 	block := signedBlock.Block()
 	if block == nil {
@@ -649,7 +652,7 @@ func (s *Service) isDataAvailable(
 
 	blockVersion := block.Version()
 	if blockVersion >= version.Fulu {
-		return s.areDataColumnsAvailable(ctx, root, block)
+		return s.areDataColumnsAvailable(ctx, root, block, startWaiting...)
 	}
 
 	if blockVersion >= version.Deneb {
@@ -665,6 +668,7 @@ func (s *Service) areDataColumnsAvailable(
 	ctx context.Context,
 	root [fieldparams.RootLength]byte,
 	block interfaces.ReadOnlyBeaconBlock,
+	startWaiting ...chan<- bool, // For tests purposes only
 ) error {
 	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
 	blockSlot, currentSlot := block.Slot(), s.CurrentSlot()
@@ -732,8 +736,9 @@ func (s *Service) areDataColumnsAvailable(
 		return nil
 	}
 
-	if s.startWaitingDataColumnSidecars != nil {
-		s.startWaitingDataColumnSidecars <- true
+	// Notify the caller that we are waiting for data columns.
+	if len(startWaiting) > 0 && startWaiting[0] != nil {
+		startWaiting[0] <- true
 	}
 
 	// Log for DA checks that cross over into the next slot; helpful for debugging.

beacon-chain/blockchain/process_block_helpers.go

@@ -131,12 +131,6 @@ func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
 }
 
 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.processLightClientBootstrap(cfg); err != nil {
-		log.WithError(err).Error("Failed to process light client bootstrap")
-	}
 	if err := s.processLightClientOptimisticUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
 		log.WithError(err).Error("Failed to process light client optimistic update")
 	}
@@ -145,33 +139,38 @@ func (s *Service) processLightClientUpdates(cfg *postBlockProcessConfig) {
 	}
 }
 
-// processLightClientUpdate saves the light client update for this block
+// saveLightClientUpdate 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 {
+func (s *Service) saveLightClientUpdate(cfg *postBlockProcessConfig) {
 	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).Errorf("Saving light client update failed: Could not get attested block for root %#x", attestedRoot)
+		return
 	}
 	if attestedBlock == nil || attestedBlock.IsNil() {
-		return errors.New("attested block is nil")
+		log.Error("Saving light client update failed: Attested block is nil")
+		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).Errorf("Saving light client update failed: Could not get attested state for root %#x", attestedRoot)
+		return
 	}
 	if attestedState == nil || attestedState.IsNil() {
-		return errors.New("attested state is nil")
+		log.Error("Saving light client update failed: Attested state is nil")
+		return
 	}
 
 	finalizedRoot := attestedState.FinalizedCheckpoint().Root
 	finalizedBlock, err := s.getBlock(cfg.ctx, [32]byte(finalizedRoot))
 	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
+			log.Debugf("Skipping saving light client update: Finalized block is nil for root %#x", finalizedRoot)
+		} else {
+			log.WithError(err).Errorf("Saving light client update failed: Could not get finalized block for root %#x", finalizedRoot)
 		}
-		return errors.Wrapf(err, "could not get finalized block for root %#x", finalizedRoot)
+		return
 	}
 
 	update, err := lightclient.NewLightClientUpdateFromBeaconState(
@@ -184,52 +183,57 @@ func (s *Service) processLightClientUpdate(cfg *postBlockProcessConfig) error {
 		finalizedBlock,
 	)
 	if err != nil {
-		return errors.Wrapf(err, "could not create light client update")
+		log.WithError(err).Error("Saving light client update failed: Could not create light client update")
+		return
 	}
 
 	period := slots.SyncCommitteePeriod(slots.ToEpoch(attestedState.Slot()))
 
 	oldUpdate, err := s.cfg.BeaconDB.LightClientUpdate(cfg.ctx, period)
 	if err != nil {
-		return errors.Wrapf(err, "could not get current light client update")
+		log.WithError(err).Error("Saving light client update failed: Could not get current light client update")
+		return
 	}
 
 	if oldUpdate == nil {
 		if err := s.cfg.BeaconDB.SaveLightClientUpdate(cfg.ctx, period, update); err != nil {
-			return errors.Wrapf(err, "could not save light client update")
+			log.WithError(err).Error("Saving light client update failed: Could not save light client update")
+		} else {
+			log.WithField("period", period).Debug("Saving light client update: Saved new update")
 		}
-		log.WithField("period", period).Debug("Saved new light client update")
-		return nil
+		return
 	}
 
 	isNewUpdateBetter, err := lightclient.IsBetterUpdate(update, oldUpdate)
 	if err != nil {
-		return errors.Wrapf(err, "could not compare light client updates")
+		log.WithError(err).Error("Saving light client update failed: Could not compare light client updates")
+		return
 	}
 
 	if isNewUpdateBetter {
 		if err := s.cfg.BeaconDB.SaveLightClientUpdate(cfg.ctx, period, update); err != nil {
-			return errors.Wrapf(err, "could not save light client update")
+			log.WithError(err).Error("Saving light client update failed: Could not save light client update")
+		} else {
+			log.WithField("period", period).Debug("Saving light client update: Saved new update")
 		}
-		log.WithField("period", period).Debug("Saved new light client update")
-		return nil
+	} else {
+		log.WithField("period", period).Debug("Saving light client update: New update is not better than the current one. Skipping save.")
 	}
-	log.WithField("period", period).Debug("New light client update is not better than the current one, skipping save")
-	return nil
 }
 
-// processLightClientBootstrap saves a light client bootstrap for this block
+// saveLightClientBootstrap saves a light client bootstrap for this block
 // when feature flag is enabled.
-func (s *Service) processLightClientBootstrap(cfg *postBlockProcessConfig) error {
+func (s *Service) saveLightClientBootstrap(cfg *postBlockProcessConfig) {
 	blockRoot := cfg.roblock.Root()
 	bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(cfg.ctx, s.CurrentSlot(), cfg.postState, cfg.roblock)
 	if err != nil {
-		return errors.Wrapf(err, "could not create light client bootstrap")
+		log.WithError(err).Error("Saving light client bootstrap failed: Could not create light client bootstrap")
+		return
 	}
-	if err := s.cfg.BeaconDB.SaveLightClientBootstrap(cfg.ctx, blockRoot[:], bootstrap); err != nil {
-		return errors.Wrapf(err, "could not save light client bootstrap")
+	err = s.cfg.BeaconDB.SaveLightClientBootstrap(cfg.ctx, blockRoot[:], bootstrap)
+	if err != nil {
+		log.WithError(err).Error("Saving light client bootstrap failed: Could not save light client bootstrap in DB")
 	}
-	return nil
 }
 
 func (s *Service) processLightClientFinalityUpdate(

beacon-chain/blockchain/process_block_test.go

@@ -51,7 +51,7 @@ import (
 )
 
 func Test_pruneAttsFromPool_Electra(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	logHook := logTest.NewGlobal()
 
 	params.SetupTestConfigCleanup(t)
@@ -241,7 +241,7 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	fcp2 := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r0}
 	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(fcp2))
 	err = service.fillInForkChoiceMissingBlocks(
-		t.Context(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -284,7 +284,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(fcp2))
 
 	err = service.fillInForkChoiceMissingBlocks(
-		t.Context(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -294,7 +294,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	wantedRoots := [][]byte{roots[0], roots[3], roots[4], roots[6], roots[8]}
 	for i, rt := range wantedRoots {
 		assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(bytesutil.ToBytes32(rt)), fmt.Sprintf("Didn't save node: %d", i))
-		assert.Equal(t, true, service.cfg.BeaconDB.HasBlock(t.Context(), bytesutil.ToBytes32(rt)))
+		assert.Equal(t, true, service.cfg.BeaconDB.HasBlock(context.Background(), bytesutil.ToBytes32(rt)))
 	}
 }
 
@@ -340,7 +340,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	// Set finalized epoch to 2.
 	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 2, Root: r64}))
 	err = service.fillInForkChoiceMissingBlocks(
-		t.Context(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// There should be 1 node: block 65
@@ -373,7 +373,7 @@ func TestFillForkChoiceMissingBlocks_FinalizedSibling(t *testing.T) {
 	require.NoError(t, err)
 
 	err = service.fillInForkChoiceMissingBlocks(
-		t.Context(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.Equal(t, ErrNotDescendantOfFinalized.Error(), err.Error())
 }
 
@@ -451,20 +451,20 @@ func blockTree1(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][]byt
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		wsb, err := consensusblocks.NewSignedBeaconBlock(beaconBlock)
 		require.NoError(t, err)
-		if err := beaconDB.SaveBlock(t.Context(), wsb); err != nil {
+		if err := beaconDB.SaveBlock(context.Background(), wsb); err != nil {
 			return nil, err
 		}
-		if err := beaconDB.SaveState(t.Context(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
+		if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
 			return nil, errors.Wrap(err, "could not save state")
 		}
 	}
-	if err := beaconDB.SaveState(t.Context(), st.Copy(), r1); err != nil {
+	if err := beaconDB.SaveState(context.Background(), st.Copy(), r1); err != nil {
 		return nil, err
 	}
-	if err := beaconDB.SaveState(t.Context(), st.Copy(), r7); err != nil {
+	if err := beaconDB.SaveState(context.Background(), st.Copy(), r7); err != nil {
 		return nil, err
 	}
-	if err := beaconDB.SaveState(t.Context(), st.Copy(), r8); err != nil {
+	if err := beaconDB.SaveState(context.Background(), st.Copy(), r8); err != nil {
 		return nil, err
 	}
 	return [][]byte{r0[:], r1[:], nil, r3[:], r4[:], r5[:], r6[:], r7[:], r8[:]}, nil
@@ -477,7 +477,7 @@ func TestCurrentSlot_HandlesOverflow(t *testing.T) {
 	require.Equal(t, primitives.Slot(0), slot, "Unexpected slot")
 }
 func TestAncestorByDB_CtxErr(t *testing.T) {
-	ctx, cancel := context.WithCancel(t.Context())
+	ctx, cancel := context.WithCancel(context.Background())
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -510,18 +510,18 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
-		util.SaveBlock(t, t.Context(), beaconDB, beaconBlock)
+		util.SaveBlock(t, context.Background(), beaconDB, beaconBlock)
 	}
 
 	// Slots 100 to 200 are skip slots. Requesting root at 150 will yield root at 100. The last physical block.
-	r, err := service.Ancestor(t.Context(), r200[:], 150)
+	r, err := service.Ancestor(context.Background(), r200[:], 150)
 	require.NoError(t, err)
 	if bytesutil.ToBytes32(r) != r100 {
 		t.Error("Did not get correct root")
 	}
 
 	// Slots 1 to 100 are skip slots. Requesting root at 50 will yield root at 1. The last physical block.
-	r, err = service.Ancestor(t.Context(), r200[:], 50)
+	r, err = service.Ancestor(context.Background(), r200[:], 50)
 	require.NoError(t, err)
 	if bytesutil.ToBytes32(r) != r1 {
 		t.Error("Did not get correct root")
@@ -529,7 +529,7 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 }
 
 func TestAncestor_CanUseForkchoice(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -557,12 +557,12 @@ func TestAncestor_CanUseForkchoice(t *testing.T) {
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		st, blkRoot, err := prepareForkchoiceState(t.Context(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, ojc, ofc)
+		st, blkRoot, err := prepareForkchoiceState(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 	}
 
-	r, err := service.Ancestor(t.Context(), r200[:], 150)
+	r, err := service.Ancestor(context.Background(), r200[:], 150)
 	require.NoError(t, err)
 	if bytesutil.ToBytes32(r) != r100 {
 		t.Error("Did not get correct root")
@@ -594,14 +594,14 @@ func TestAncestor_CanUseDB(t *testing.T) {
 		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
-		util.SaveBlock(t, t.Context(), beaconDB, beaconBlock)
+		util.SaveBlock(t, context.Background(), beaconDB, beaconBlock)
 	}
 
-	st, blkRoot, err := prepareForkchoiceState(t.Context(), 200, r200, r200, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
-	r, err := service.Ancestor(t.Context(), r200[:], 150)
+	r, err := service.Ancestor(context.Background(), r200[:], 150)
 	require.NoError(t, err)
 	if bytesutil.ToBytes32(r) != r100 {
 		t.Error("Did not get correct root")
@@ -609,7 +609,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 }
 
 func TestEnsureRootNotZeroHashes(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	opts := testServiceOptsNoDB()
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -623,7 +623,7 @@ func TestEnsureRootNotZeroHashes(t *testing.T) {
 }
 
 func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	opts := testServiceOptsNoDB()
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -922,7 +922,7 @@ func TestRemoveBlockAttestationsInPool(t *testing.T) {
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: r[:]}))
@@ -935,7 +935,7 @@ func TestRemoveBlockAttestationsInPool(t *testing.T) {
 	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
 	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	service.pruneAttsFromPool(t.Context(), nil /* state not needed pre-Electra */, wsb)
+	service.pruneAttsFromPool(context.Background(), nil /* state not needed pre-Electra */, wsb)
 	require.LogsDoNotContain(t, logHook, "Could not prune attestations")
 	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
 }
@@ -2667,7 +2667,7 @@ func TestRollbackBlock_ContextDeadline(t *testing.T) {
 	require.Equal(t, true, hasState)
 
 	// Set deadlined context when processing the block
-	cancCtx, canc := context.WithCancel(t.Context())
+	cancCtx, canc := context.WithCancel(context.Background())
 	canc()
 	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
@@ -2706,7 +2706,7 @@ func fakeResult(missing []uint64) map[uint64]struct{} {
 	return r
 }
 
-func TestProcessLightClientUpdate(t *testing.T) {
+func TestSaveLightClientUpdate(t *testing.T) {
 	featCfg := &features.Flags{}
 	featCfg.EnableLightClient = true
 	reset := features.InitWithReset(featCfg)
@@ -2747,7 +2747,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 				isValidPayload: true,
 			}
 
-			require.NoError(t, s.processLightClientUpdate(cfg))
+			s.saveLightClientUpdate(cfg)
 
 			// Check that the light client update is saved
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
@@ -2796,13 +2796,13 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
 			require.NoError(t, err)
 
 			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
 			require.NoError(t, err)
 
-			require.NoError(t, s.processLightClientUpdate(cfg))
+			s.saveLightClientUpdate(cfg)
 
 			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
 			require.NoError(t, err)
@@ -2848,7 +2848,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
 			require.NoError(t, err)
 
 			scb := make([]byte, 64)
@@ -2863,7 +2863,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
 			require.NoError(t, err)
 
-			require.NoError(t, s.processLightClientUpdate(cfg))
+			s.saveLightClientUpdate(cfg)
 
 			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
 			require.NoError(t, err)
@@ -2906,7 +2906,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 				isValidPayload: true,
 			}
 
-			require.NoError(t, s.processLightClientUpdate(cfg))
+			s.saveLightClientUpdate(cfg)
 
 			// Check that the light client update is saved
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
@@ -2954,13 +2954,13 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
 			require.NoError(t, err)
 
 			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
 			require.NoError(t, err)
 
-			require.NoError(t, s.processLightClientUpdate(cfg))
+			s.saveLightClientUpdate(cfg)
 
 			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
 			require.NoError(t, err)
@@ -3006,7 +3006,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
 			require.NoError(t, err)
 
 			scb := make([]byte, 64)
@@ -3021,7 +3021,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
 			require.NoError(t, err)
 
-			require.NoError(t, s.processLightClientUpdate(cfg))
+			s.saveLightClientUpdate(cfg)
 
 			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
 			require.NoError(t, err)
@@ -3064,7 +3064,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 				isValidPayload: true,
 			}
 
-			require.NoError(t, s.processLightClientUpdate(cfg))
+			s.saveLightClientUpdate(cfg)
 
 			// Check that the light client update is saved
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
@@ -3112,13 +3112,13 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
 			require.NoError(t, err)
 
 			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
 			require.NoError(t, err)
 
-			require.NoError(t, s.processLightClientUpdate(cfg))
+			s.saveLightClientUpdate(cfg)
 
 			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
 			require.NoError(t, err)
@@ -3164,7 +3164,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
 			require.NoError(t, err)
 
 			scb := make([]byte, 64)
@@ -3179,7 +3179,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
 			require.NoError(t, err)
 
-			require.NoError(t, s.processLightClientUpdate(cfg))
+			s.saveLightClientUpdate(cfg)
 
 			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
 			require.NoError(t, err)
@@ -3192,7 +3192,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 	reset()
 }
 
-func TestProcessLightClientBootstrap(t *testing.T) {
+func TestSaveLightClientBootstrap(t *testing.T) {
 	featCfg := &features.Flags{}
 	featCfg.EnableLightClient = true
 	reset := features.InitWithReset(featCfg)
@@ -3222,7 +3222,7 @@ func TestProcessLightClientBootstrap(t *testing.T) {
 			isValidPayload: true,
 		}
 
-		require.NoError(t, s.processLightClientBootstrap(cfg))
+		s.saveLightClientBootstrap(cfg)
 
 		// Check that the light client bootstrap is saved
 		b, err := s.cfg.BeaconDB.LightClientBootstrap(ctx, currentBlockRoot[:])
@@ -3257,7 +3257,7 @@ func TestProcessLightClientBootstrap(t *testing.T) {
 			isValidPayload: true,
 		}
 
-		require.NoError(t, s.processLightClientBootstrap(cfg))
+		s.saveLightClientBootstrap(cfg)
 
 		// Check that the light client bootstrap is saved
 		b, err := s.cfg.BeaconDB.LightClientBootstrap(ctx, currentBlockRoot[:])
@@ -3292,7 +3292,7 @@ func TestProcessLightClientBootstrap(t *testing.T) {
 			isValidPayload: true,
 		}
 
-		require.NoError(t, s.processLightClientBootstrap(cfg))
+		s.saveLightClientBootstrap(cfg)
 
 		// Check that the light client bootstrap is saved
 		b, err := s.cfg.BeaconDB.LightClientBootstrap(ctx, currentBlockRoot[:])
@@ -3315,7 +3315,7 @@ type testIsAvailableParams struct {
 }
 
 func testIsAvailableSetup(t *testing.T, params testIsAvailableParams) (context.Context, context.CancelFunc, *Service, [fieldparams.RootLength]byte, interfaces.SignedBeaconBlock) {
-	ctx, cancel := context.WithCancel(t.Context())
+	ctx, cancel := context.WithCancel(context.Background())
 	dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
 
 	options := append(params.options, WithDataColumnStorage(dataColumnStorage))
@@ -3412,10 +3412,8 @@ 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{}), WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:       []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
 			columnsToSave: []uint64{1, 17, 19, 75, 102, 117, 119}, // 119 is not needed, 42 and 87 are missing
 
 			blobKzgCommitmentsCount: 3,
@@ -3442,6 +3440,8 @@ func TestIsDataAvailable(t *testing.T) {
 			{Index: 42, Slot: slot, ProposerIndex: proposerIndex, ParentRoot: parentRoot[:], StateRoot: stateRoot[:], BodyRoot: bodyRoot[:]}, // Needed index
 		})
 
+		startWaiting := make(chan bool)
+
 		go func() {
 			<-startWaiting
 
@@ -3452,7 +3452,7 @@ func TestIsDataAvailable(t *testing.T) {
 			require.NoError(t, err)
 		}()
 
-		err = service.isDataAvailable(ctx, root, signed)
+		err = service.isDataAvailable(ctx, root, signed, startWaiting)
 		require.NoError(t, err)
 	})
 
@@ -3461,9 +3461,6 @@ 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)
@@ -3476,7 +3473,7 @@ func TestIsDataAvailable(t *testing.T) {
 		}
 
 		testParams := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&custodyInfo), WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:                 []Option{WithCustodyInfo(&custodyInfo)},
 			columnsToSave:           indices,
 			blobKzgCommitmentsCount: 3,
 		}
@@ -3506,6 +3503,8 @@ func TestIsDataAvailable(t *testing.T) {
 
 		_, verifiedSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParams)
 
+		startWaiting := make(chan bool)
+
 		go func() {
 			<-startWaiting
 
@@ -3513,26 +3512,25 @@ func TestIsDataAvailable(t *testing.T) {
 			require.NoError(t, err)
 		}()
 
-		err = service.isDataAvailable(ctx, root, signed)
+		err = service.isDataAvailable(ctx, root, signed, startWaiting)
 		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{}), WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
 			blobKzgCommitmentsCount: 3,
 		}
 
 		ctx, cancel, service, root, signed := testIsAvailableSetup(t, params)
 
+		startWaiting := make(chan bool)
 		go func() {
 			<-startWaiting
 			cancel()
 		}()
 
-		err := service.isDataAvailable(ctx, root, signed)
+		err := service.isDataAvailable(ctx, root, signed, startWaiting)
 		require.NotNil(t, err)
 	})
 }
@@ -3647,7 +3645,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 				expectedVersion = version.Altair
 			case 2:
 				forkEpoch = uint64(params.BeaconConfig().BellatrixForkEpoch)
-				expectedVersion = version.Bellatrix
+				expectedVersion = version.Altair
 			case 3:
 				forkEpoch = uint64(params.BeaconConfig().CapellaForkEpoch)
 				expectedVersion = version.Capella
@@ -3656,7 +3654,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 				expectedVersion = version.Deneb
 			case 5:
 				forkEpoch = uint64(params.BeaconConfig().ElectraForkEpoch)
-				expectedVersion = version.Electra
+				expectedVersion = version.Deneb
 			default:
 				t.Errorf("Unsupported fork version %s", version.String(testVersion))
 			}
@@ -3801,7 +3799,7 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 				expectedVersion = version.Altair
 			case 2:
 				forkEpoch = uint64(params.BeaconConfig().BellatrixForkEpoch)
-				expectedVersion = version.Bellatrix
+				expectedVersion = version.Altair
 			case 3:
 				forkEpoch = uint64(params.BeaconConfig().CapellaForkEpoch)
 				expectedVersion = version.Capella

beacon-chain/blockchain/receive_attestation_test.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"context"
 	"testing"
 	"time"
 
@@ -31,7 +32,7 @@ func TestAttestationCheckPtState_FarFutureSlot(t *testing.T) {
 	service.genesisTime = time.Now()
 
 	e := primitives.Epoch(slots.MaxSlotBuffer/uint64(params.BeaconConfig().SlotsPerEpoch) + 1)
-	_, err := service.AttestationTargetState(t.Context(), &ethpb.Checkpoint{Epoch: e})
+	_, err := service.AttestationTargetState(context.Background(), &ethpb.Checkpoint{Epoch: e})
 	require.ErrorContains(t, "exceeds max allowed value relative to the local clock", err)
 }
 
@@ -55,11 +56,11 @@ func TestVerifyLMDFFGConsistent(t *testing.T) {
 	a.Data.Target.Root = []byte{'c'}
 	r33Root := r33.Root()
 	a.Data.BeaconBlockRoot = r33Root[:]
-	require.ErrorContains(t, wanted, service.VerifyLmdFfgConsistency(t.Context(), a))
+	require.ErrorContains(t, wanted, service.VerifyLmdFfgConsistency(context.Background(), a))
 
 	r32Root := r32.Root()
 	a.Data.Target.Root = r32Root[:]
-	err = service.VerifyLmdFfgConsistency(t.Context(), a)
+	err = service.VerifyLmdFfgConsistency(context.Background(), a)
 	require.NoError(t, err, "Could not verify LMD and FFG votes to be consistent")
 }
 

beacon-chain/blockchain/receive_block_test.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"context"
 	"sync"
 	"testing"
 	"time"
@@ -27,7 +28,7 @@ import (
 )
 
 func TestService_ReceiveBlock(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	genesis, keys := util.DeterministicGenesisState(t, 64)
 	copiedGen := genesis.Copy()
@@ -188,7 +189,7 @@ func TestHandleDA(t *testing.T) {
 	require.NoError(t, err)
 
 	s, _ := minimalTestService(t)
-	elapsed, err := s.handleDA(t.Context(), signedBeaconBlock, [fieldparams.RootLength]byte{}, nil)
+	elapsed, err := s.handleDA(context.Background(), signedBeaconBlock, [fieldparams.RootLength]byte{}, nil)
 	require.NoError(t, err)
 	require.Equal(t, true, elapsed > 0, "Elapsed time should be greater than 0")
 }
@@ -227,7 +228,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 }
 
 func TestService_ReceiveBlockBatch(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	genesis, keys := util.DeterministicGenesisState(t, 64)
 	genFullBlock := func(t *testing.T, conf *util.BlockGenConfig, slot primitives.Slot) *ethpb.SignedBeaconBlock {
@@ -292,23 +293,23 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 func TestService_HasBlock(t *testing.T) {
 	s, _ := minimalTestService(t)
 	r := [32]byte{'a'}
-	if s.HasBlock(t.Context(), r) {
+	if s.HasBlock(context.Background(), r) {
 		t.Error("Should not have block")
 	}
 	wsb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
-	require.NoError(t, s.saveInitSyncBlock(t.Context(), r, wsb))
-	if !s.HasBlock(t.Context(), r) {
+	require.NoError(t, s.saveInitSyncBlock(context.Background(), r, wsb))
+	if !s.HasBlock(context.Background(), r) {
 		t.Error("Should have block")
 	}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
-	util.SaveBlock(t, t.Context(), s.cfg.BeaconDB, b)
+	util.SaveBlock(t, context.Background(), s.cfg.BeaconDB, b)
 	r, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.Equal(t, true, s.HasBlock(t.Context(), r))
+	require.Equal(t, true, s.HasBlock(context.Background(), r))
 	s.blockBeingSynced.set(r)
-	require.Equal(t, false, s.HasBlock(t.Context(), r))
+	require.Equal(t, false, s.HasBlock(context.Background(), r))
 }
 
 func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
@@ -317,7 +318,7 @@ func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
 	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
 	s.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
 
-	require.NoError(t, s.checkSaveHotStateDB(t.Context()))
+	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	assert.LogsContain(t, hook, "Entering mode to save hot states in DB")
 }
 
@@ -328,10 +329,10 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 
 	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
 	s.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
-	require.NoError(t, s.checkSaveHotStateDB(t.Context()))
+	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	s.genesisTime = time.Now()
 
-	require.NoError(t, s.checkSaveHotStateDB(t.Context()))
+	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	assert.LogsContain(t, hook, "Exiting mode to save hot states in DB")
 }
 
@@ -340,7 +341,7 @@ func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
 	s, _ := minimalTestService(t)
 	s.genesisTime = time.Now()
 
-	require.NoError(t, s.checkSaveHotStateDB(t.Context()))
+	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	assert.LogsDoNotContain(t, hook, "Entering mode to save hot states in DB")
 }
 
@@ -455,7 +456,7 @@ func Test_executePostFinalizationTasks(t *testing.T) {
 
 	headState, err := util.NewBeaconStateElectra()
 	require.NoError(t, err)
-	finalizedStRoot, err := headState.HashTreeRoot(t.Context())
+	finalizedStRoot, err := headState.HashTreeRoot(context.Background())
 	require.NoError(t, err)
 
 	genesis := util.NewBeaconBlock()

beacon-chain/blockchain/service.go

@@ -31,6 +31,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"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"
@@ -47,28 +48,27 @@ 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
-	startWaitingDataColumnSidecars chan bool // for testing purposes only
+	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
 }
 
 // config options for the service.
@@ -110,22 +110,26 @@ var ErrMissingClockSetter = errors.New("blockchain Service initialized without a
 type blobNotifierMap struct {
 	sync.RWMutex
 	notifiers map[[32]byte]chan uint64
-	seenIndex map[[32]byte][]bool
+	// TODO: Separate blobs from data columns
+	// seenIndex map[[32]byte][]bool
+	seenIndex map[[32]byte][fieldparams.NumberOfColumns]bool
 }
 
 // notifyIndex notifies a blob by its index for a given root.
 // It uses internal maps to keep track of seen indices and notifier channels.
 func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitives.Slot) {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
-	if idx >= uint64(maxBlobsPerBlock) {
-		return
-	}
+	// TODO: Separate blobs from data columns
+	// maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+	// if idx >= uint64(maxBlobsPerBlock) {
+	// 	return
+	// }
 
 	bn.Lock()
 	seen := bn.seenIndex[root]
-	if seen == nil {
-		seen = make([]bool, maxBlobsPerBlock)
-	}
+	// TODO: Separate blobs from data columns
+	// if seen == nil {
+	// seen = make([]bool, maxBlobsPerBlock)
+	// }
 	if seen[idx] {
 		bn.Unlock()
 		return
@@ -136,7 +140,9 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitive
 	// Retrieve or create the notifier channel for the given root.
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, maxBlobsPerBlock)
+		// TODO: Separate blobs from data columns
+		// c = make(chan uint64, maxBlobsPerBlock)
+		c = make(chan uint64, fieldparams.NumberOfColumns)
 		bn.notifiers[root] = c
 	}
 
@@ -146,12 +152,15 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitive
 }
 
 func (bn *blobNotifierMap) forRoot(root [32]byte, slot primitives.Slot) chan uint64 {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+	// TODO: Separate blobs from data columns
+	// maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
 	bn.Lock()
 	defer bn.Unlock()
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, maxBlobsPerBlock)
+		// TODO: Separate blobs from data columns
+		// c = make(chan uint64, maxBlobsPerBlock)
+		c = make(chan uint64, fieldparams.NumberOfColumns)
 		bn.notifiers[root] = c
 	}
 	return c
@@ -177,7 +186,9 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	bn := &blobNotifierMap{
 		notifiers: make(map[[32]byte]chan uint64),
-		seenIndex: make(map[[32]byte][]bool),
+		// TODO: Separate blobs from data columns
+		// seenIndex: make(map[[32]byte][]bool),
+		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
 	}
 	srv := &Service{
 		ctx:                  ctx,

beacon-chain/blockchain/service_norace_test.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"context"
 	"io"
 	"testing"
 
@@ -25,7 +26,7 @@ func TestChainService_SaveHead_DataRace(t *testing.T) {
 	st, _ := util.DeterministicGenesisState(t, 1)
 	require.NoError(t, err)
 	go func() {
-		require.NoError(t, s.saveHead(t.Context(), [32]byte{}, b, st))
+		require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
 	}()
-	require.NoError(t, s.saveHead(t.Context(), [32]byte{}, b, st))
+	require.NoError(t, s.saveHead(context.Background(), [32]byte{}, b, st))
 }

beacon-chain/blockchain/service_test.go

@@ -42,7 +42,7 @@ import (
 )
 
 func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
-	ctx := t.Context()
+	ctx := context.Background()
 	var web3Service *execution.Service
 	var err error
 	srv, endpoint, err := mockExecution.SetupRPCServer()
@@ -115,7 +115,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 
 func TestChainStartStop_Initialized(t *testing.T) {
 	hook := logTest.NewGlobal()
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
 	chainService := setupBeaconChain(t, beaconDB)
@@ -152,7 +152,7 @@ func TestChainStartStop_Initialized(t *testing.T) {
 
 func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 	hook := logTest.NewGlobal()
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
 	chainService := setupBeaconChain(t, beaconDB)
@@ -184,7 +184,7 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 func TestChainService_InitializeBeaconChain(t *testing.T) {
 	helpers.ClearCache()
 	beaconDB := testDB.SetupDB(t)
-	ctx := t.Context()
+	ctx := context.Background()
 
 	bc := setupBeaconChain(t, beaconDB)
 	var err error
@@ -226,7 +226,7 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 }
 
 func TestChainService_CorrectGenesisRoots(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
 	chainService := setupBeaconChain(t, beaconDB)
@@ -295,7 +295,7 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.ToProtoUnsafe(), s.ToProtoUnsafe(), "Head state incorrect")
 	assert.Equal(t, c.HeadSlot(), headBlock.Block.Slot, "Head slot incorrect")
-	r, err := c.HeadRoot(t.Context())
+	r, err := c.HeadRoot(context.Background())
 	require.NoError(t, err)
 	if !bytes.Equal(headRoot[:], r) {
 		t.Error("head slot incorrect")
@@ -346,7 +346,7 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 
 func TestChainService_SaveHeadNoDB(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	ctx := t.Context()
+	ctx := context.Background()
 	fc := doublylinkedtree.New()
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB, fc), ForkChoiceStore: fc},
@@ -370,7 +370,7 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 }
 
 func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
 		cfg: &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
@@ -391,7 +391,7 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 }
 
 func TestServiceStop_SaveCachedBlocks(t *testing.T) {
-	ctx, cancel := context.WithCancel(t.Context())
+	ctx, cancel := context.WithCancel(context.Background())
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
 		cfg:            &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB, doublylinkedtree.New())},
@@ -410,13 +410,13 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 }
 
 func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 	mgs := &MockClockSetter{}
 	service.clockSetter = mgs
 	gt := time.Now()
-	service.onExecutionChainStart(t.Context(), gt)
+	service.onExecutionChainStart(context.Background(), gt)
 	gs, err := beaconDB.GenesisState(ctx)
 	require.NoError(t, err)
 	require.NotEqual(t, nil, gs)
@@ -429,7 +429,7 @@ func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
 
 func BenchmarkHasBlockDB(b *testing.B) {
 	beaconDB := testDB.SetupDB(b)
-	ctx := b.Context()
+	ctx := context.Background()
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB},
 	}
@@ -447,7 +447,7 @@ func BenchmarkHasBlockDB(b *testing.B) {
 }
 
 func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
-	ctx := b.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(b)
 	s := &Service{
 		cfg: &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
@@ -587,7 +587,9 @@ func (s *MockClockSetter) SetClock(g *startup.Clock) error {
 func TestNotifyIndex(t *testing.T) {
 	// Initialize a blobNotifierMap
 	bn := &blobNotifierMap{
-		seenIndex: make(map[[32]byte][]bool),
+		// TODO: Separate blobs from data columns
+		// seenIndex: make(map[[32]byte][]bool),
+		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
 		notifiers: make(map[[32]byte]chan uint64),
 	}
 

beacon-chain/blockchain/setup_test.go

@@ -108,7 +108,7 @@ type testServiceRequirements struct {
 }
 
 func minimalTestService(t *testing.T, opts ...Option) (*Service, *testServiceRequirements) {
-	ctx := t.Context()
+	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	fcs := doublylinkedtree.New()
 	sg := stategen.New(beaconDB, fcs)

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"context"
 	"testing"
 
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
@@ -21,7 +22,7 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1792480
-	util.SaveBlock(t, t.Context(), beaconDB, b)
+	util.SaveBlock(t, context.Background(), beaconDB, b)
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -78,7 +79,7 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 			}
 			require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: tt.finalizedEpoch}))
 			cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
-			err = s.wsVerifier.VerifyWeakSubjectivity(t.Context(), cp.Epoch)
+			err = s.wsVerifier.VerifyWeakSubjectivity(context.Background(), cp.Epoch)
 			if tt.wantErr == nil {
 				require.NoError(t, err)
 			} else {

beacon-chain/builder/service_test.go

@@ -1,6 +1,7 @@
 package builder
 
 import (
+	"context"
 	"testing"
 	"time"
 
@@ -14,19 +15,19 @@ import (
 )
 
 func Test_NewServiceWithBuilder(t *testing.T) {
-	s, err := NewService(t.Context(), WithBuilderClient(&buildertesting.MockClient{}))
+	s, err := NewService(context.Background(), WithBuilderClient(&buildertesting.MockClient{}))
 	require.NoError(t, err)
 	assert.Equal(t, true, s.Configured())
 }
 
 func Test_NewServiceWithoutBuilder(t *testing.T) {
-	s, err := NewService(t.Context())
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
 	assert.Equal(t, false, s.Configured())
 }
 
 func Test_RegisterValidator(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	db := dbtesting.SetupDB(t)
 	headFetcher := &blockchainTesting.ChainService{}
 	builder := buildertesting.NewClient()
@@ -39,7 +40,7 @@ func Test_RegisterValidator(t *testing.T) {
 }
 
 func Test_RegisterValidator_WithCache(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	headFetcher := &blockchainTesting.ChainService{}
 	builder := buildertesting.NewClient()
 	s, err := NewService(ctx, WithRegistrationCache(), WithHeadFetcher(headFetcher), WithBuilderClient(&builder))
@@ -54,16 +55,16 @@ func Test_RegisterValidator_WithCache(t *testing.T) {
 }
 
 func Test_BuilderMethodsWithouClient(t *testing.T) {
-	s, err := NewService(t.Context())
+	s, err := NewService(context.Background())
 	require.NoError(t, err)
 	assert.Equal(t, false, s.Configured())
 
-	_, err = s.GetHeader(t.Context(), 0, [32]byte{}, [48]byte{})
+	_, err = s.GetHeader(context.Background(), 0, [32]byte{}, [48]byte{})
 	assert.ErrorContains(t, ErrNoBuilder.Error(), err)
 
-	_, _, err = s.SubmitBlindedBlock(t.Context(), nil)
+	_, _, err = s.SubmitBlindedBlock(context.Background(), nil)
 	assert.ErrorContains(t, ErrNoBuilder.Error(), err)
 
-	err = s.RegisterValidator(t.Context(), nil)
+	err = s.RegisterValidator(context.Background(), nil)
 	assert.ErrorContains(t, ErrNoBuilder.Error(), err)
 }

beacon-chain/cache/committee_fuzz_test.go

@@ -3,6 +3,7 @@
 package cache
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -29,8 +30,8 @@ func TestCommitteeCache_FuzzCommitteesByEpoch(t *testing.T) {
 
 	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(c)
-		require.NoError(t, cache.AddCommitteeShuffledList(t.Context(), c))
-		_, err := cache.Committee(t.Context(), 0, c.Seed, 0)
+		require.NoError(t, cache.AddCommitteeShuffledList(context.Background(), c))
+		_, err := cache.Committee(context.Background(), 0, c.Seed, 0)
 		require.NoError(t, err)
 	}
 
@@ -44,9 +45,9 @@ func TestCommitteeCache_FuzzActiveIndices(t *testing.T) {
 
 	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(c)
-		require.NoError(t, cache.AddCommitteeShuffledList(t.Context(), c))
+		require.NoError(t, cache.AddCommitteeShuffledList(context.Background(), c))
 
-		indices, err := cache.ActiveIndices(t.Context(), c.Seed)
+		indices, err := cache.ActiveIndices(context.Background(), c.Seed)
 		require.NoError(t, err)
 		assert.DeepEqual(t, c.SortedIndices, indices)
 	}

beacon-chain/cache/committee_test.go

@@ -44,15 +44,15 @@ func TestCommitteeCache_CommitteesByEpoch(t *testing.T) {
 
 	slot := params.BeaconConfig().SlotsPerEpoch
 	committeeIndex := primitives.CommitteeIndex(1)
-	indices, err := cache.Committee(t.Context(), slot, item.Seed, committeeIndex)
+	indices, err := cache.Committee(context.Background(), slot, item.Seed, committeeIndex)
 	require.NoError(t, err)
 	if indices != nil {
 		t.Error("Expected committee not to exist in empty cache")
 	}
-	require.NoError(t, cache.AddCommitteeShuffledList(t.Context(), item))
+	require.NoError(t, cache.AddCommitteeShuffledList(context.Background(), item))
 
 	wantedIndex := primitives.CommitteeIndex(0)
-	indices, err = cache.Committee(t.Context(), slot, item.Seed, wantedIndex)
+	indices, err = cache.Committee(context.Background(), slot, item.Seed, wantedIndex)
 	require.NoError(t, err)
 
 	start, end := startEndIndices(item, uint64(wantedIndex))
@@ -63,15 +63,15 @@ func TestCommitteeCache_ActiveIndices(t *testing.T) {
 	cache := NewCommitteesCache()
 
 	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6}}
-	indices, err := cache.ActiveIndices(t.Context(), item.Seed)
+	indices, err := cache.ActiveIndices(context.Background(), item.Seed)
 	require.NoError(t, err)
 	if indices != nil {
 		t.Error("Expected committee not to exist in empty cache")
 	}
 
-	require.NoError(t, cache.AddCommitteeShuffledList(t.Context(), item))
+	require.NoError(t, cache.AddCommitteeShuffledList(context.Background(), item))
 
-	indices, err = cache.ActiveIndices(t.Context(), item.Seed)
+	indices, err = cache.ActiveIndices(context.Background(), item.Seed)
 	require.NoError(t, err)
 	assert.DeepEqual(t, item.SortedIndices, indices)
 }
@@ -80,13 +80,13 @@ func TestCommitteeCache_ActiveCount(t *testing.T) {
 	cache := NewCommitteesCache()
 
 	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6}}
-	count, err := cache.ActiveIndicesCount(t.Context(), item.Seed)
+	count, err := cache.ActiveIndicesCount(context.Background(), item.Seed)
 	require.NoError(t, err)
 	assert.Equal(t, 0, count, "Expected active count not to exist in empty cache")
 
-	require.NoError(t, cache.AddCommitteeShuffledList(t.Context(), item))
+	require.NoError(t, cache.AddCommitteeShuffledList(context.Background(), item))
 
-	count, err = cache.ActiveIndicesCount(t.Context(), item.Seed)
+	count, err = cache.ActiveIndicesCount(context.Background(), item.Seed)
 	require.NoError(t, err)
 	assert.Equal(t, len(item.SortedIndices), count)
 }
@@ -100,7 +100,7 @@ func TestCommitteeCache_CanRotate(t *testing.T) {
 	for i := start; i < end; i++ {
 		s := []byte(strconv.Itoa(i))
 		item := &Committees{Seed: bytesutil.ToBytes32(s)}
-		require.NoError(t, cache.AddCommitteeShuffledList(t.Context(), item))
+		require.NoError(t, cache.AddCommitteeShuffledList(context.Background(), item))
 	}
 
 	k := cache.CommitteeCache.Keys()
@@ -130,7 +130,7 @@ func TestCommitteeCacheOutOfRange(t *testing.T) {
 	assert.NoError(t, err)
 	_ = cache.CommitteeCache.Add(key, comms)
 
-	_, err = cache.Committee(t.Context(), 0, seed, math.MaxUint64) // Overflow!
+	_, err = cache.Committee(context.Background(), 0, seed, math.MaxUint64) // Overflow!
 	require.NotNil(t, err, "Did not fail as expected")
 }
 
@@ -138,15 +138,15 @@ func TestCommitteeCache_DoesNothingWhenCancelledContext(t *testing.T) {
 	cache := NewCommitteesCache()
 
 	item := &Committees{Seed: [32]byte{'A'}, SortedIndices: []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6}}
-	count, err := cache.ActiveIndicesCount(t.Context(), item.Seed)
+	count, err := cache.ActiveIndicesCount(context.Background(), item.Seed)
 	require.NoError(t, err)
 	assert.Equal(t, 0, count, "Expected active count not to exist in empty cache")
 
-	cancelled, cancel := context.WithCancel(t.Context())
+	cancelled, cancel := context.WithCancel(context.Background())
 	cancel()
 	require.ErrorIs(t, cache.AddCommitteeShuffledList(cancelled, item), context.Canceled)
 
-	count, err = cache.ActiveIndicesCount(t.Context(), item.Seed)
+	count, err = cache.ActiveIndicesCount(context.Background(), item.Seed)
 	require.NoError(t, err)
 	assert.Equal(t, 0, count)
 }

beacon-chain/cache/depositsnapshot/deposit_cache_test.go

@@ -2,6 +2,7 @@ package depositsnapshot
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"math/big"
 	"testing"
@@ -54,7 +55,7 @@ func TestAllDeposits_ReturnsAllDeposits(t *testing.T) {
 	}
 	dc.deposits = deposits
 
-	d := dc.AllDeposits(t.Context(), nil)
+	d := dc.AllDeposits(context.Background(), nil)
 	assert.Equal(t, len(deposits), len(d))
 }
 
@@ -94,7 +95,7 @@ func TestAllDeposits_FiltersDepositUpToAndIncludingBlockNumber(t *testing.T) {
 	}
 	dc.deposits = deposits
 
-	d := dc.AllDeposits(t.Context(), big.NewInt(11))
+	d := dc.AllDeposits(context.Background(), big.NewInt(11))
 	assert.Equal(t, 5, len(d))
 }
 
@@ -126,7 +127,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 				DepositRoot:     wantedRoot,
 			},
 		}
-		n, root := dc.DepositsNumberAndRootAtHeight(t.Context(), big.NewInt(13))
+		n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(13))
 		assert.Equal(t, 4, int(n))
 		require.DeepEqual(t, wantedRoot, root[:])
 	})
@@ -142,7 +143,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 				DepositRoot:     wantedRoot,
 			},
 		}
-		n, root := dc.DepositsNumberAndRootAtHeight(t.Context(), big.NewInt(10))
+		n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(10))
 		assert.Equal(t, 1, int(n))
 		require.DeepEqual(t, wantedRoot, root[:])
 	})
@@ -168,7 +169,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 				Deposit:         &ethpb.Deposit{},
 			},
 		}
-		n, root := dc.DepositsNumberAndRootAtHeight(t.Context(), big.NewInt(10))
+		n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(10))
 		assert.Equal(t, 2, int(n))
 		require.DeepEqual(t, wantedRoot, root[:])
 	})
@@ -184,7 +185,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 				DepositRoot:     wantedRoot,
 			},
 		}
-		n, root := dc.DepositsNumberAndRootAtHeight(t.Context(), big.NewInt(7))
+		n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(7))
 		assert.Equal(t, 0, int(n))
 		require.DeepEqual(t, params.BeaconConfig().ZeroHash, root)
 	})
@@ -200,7 +201,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 				DepositRoot:     wantedRoot,
 			},
 		}
-		n, root := dc.DepositsNumberAndRootAtHeight(t.Context(), big.NewInt(10))
+		n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(10))
 		assert.Equal(t, 1, int(n))
 		require.DeepEqual(t, wantedRoot, root[:])
 	})
@@ -236,7 +237,7 @@ func TestDepositsNumberAndRootAtHeight(t *testing.T) {
 				Deposit:         &ethpb.Deposit{},
 			},
 		}
-		n, root := dc.DepositsNumberAndRootAtHeight(t.Context(), big.NewInt(9))
+		n, root := dc.DepositsNumberAndRootAtHeight(context.Background(), big.NewInt(9))
 		assert.Equal(t, 3, int(n))
 		require.DeepEqual(t, wantedRoot, root[:])
 	})
@@ -287,10 +288,10 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 			},
 		},
 	}
-	dc.InsertDepositContainers(t.Context(), ctrs)
+	dc.InsertDepositContainers(context.Background(), ctrs)
 
 	pk1 := bytesutil.PadTo([]byte("pk1"), 48)
-	dep, blkNum := dc.DepositByPubkey(t.Context(), pk1)
+	dep, blkNum := dc.DepositByPubkey(context.Background(), pk1)
 
 	if dep == nil || !bytes.Equal(dep.Data.PublicKey, pk1) {
 		t.Error("Returned wrong deposit")
@@ -302,7 +303,7 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
 func TestInsertDepositContainers_NotNil(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
-	dc.InsertDepositContainers(t.Context(), nil)
+	dc.InsertDepositContainers(context.Background(), nil)
 	assert.DeepEqual(t, []*ethpb.DepositContainer{}, dc.deposits)
 }
 
@@ -358,10 +359,10 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
 		err = dc.finalizedDeposits.depositTree.pushLeaf(root)
 		require.NoError(t, err)
 	}
-	err = dc.InsertFinalizedDeposits(t.Context(), 2, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0)
 	require.NoError(t, err)
 
-	cachedDeposits, err := dc.FinalizedDeposits(t.Context())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
 	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
 	assert.Equal(t, int64(2), cachedDeposits.MerkleTrieIndex())
@@ -424,15 +425,15 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
 		err = dc.finalizedDeposits.Deposits().Insert(root[:], 0)
 		require.NoError(t, err)
 	}
-	err = dc.InsertFinalizedDeposits(t.Context(), 1, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 1, [32]byte{}, 0)
 	require.NoError(t, err)
 
-	err = dc.InsertFinalizedDeposits(t.Context(), 2, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0)
 	require.NoError(t, err)
 
 	dc.deposits = append(dc.deposits, []*ethpb.DepositContainer{newFinalizedDeposit}...)
 
-	cachedDeposits, err := dc.FinalizedDeposits(t.Context())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
 	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
 	require.Equal(t, int64(1), cachedDeposits.MerkleTrieIndex())
@@ -458,10 +459,10 @@ func TestFinalizedDeposits_HandleZeroDeposits(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
 
-	err = dc.InsertFinalizedDeposits(t.Context(), 2, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0)
 	require.NoError(t, err)
 
-	cachedDeposits, err := dc.FinalizedDeposits(t.Context())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
 	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
 	assert.Equal(t, int64(-1), cachedDeposits.MerkleTrieIndex())
@@ -508,10 +509,10 @@ func TestFinalizedDeposits_HandleSmallerThanExpectedDeposits(t *testing.T) {
 	}
 	dc.deposits = finalizedDeposits
 
-	err = dc.InsertFinalizedDeposits(t.Context(), 5, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 5, [32]byte{}, 0)
 	require.NoError(t, err)
 
-	cachedDeposits, err := dc.FinalizedDeposits(t.Context())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
 	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
 	assert.Equal(t, int64(2), cachedDeposits.MerkleTrieIndex())
@@ -591,14 +592,14 @@ func TestFinalizedDeposits_HandleLowerEth1DepositIndex(t *testing.T) {
 	}
 	dc.deposits = finalizedDeposits
 
-	err = dc.InsertFinalizedDeposits(t.Context(), 5, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 5, [32]byte{}, 0)
 	require.NoError(t, err)
 
 	// Reinsert finalized deposits with a lower index.
-	err = dc.InsertFinalizedDeposits(t.Context(), 2, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0)
 	require.NoError(t, err)
 
-	cachedDeposits, err := dc.FinalizedDeposits(t.Context())
+	cachedDeposits, err := dc.FinalizedDeposits(context.Background())
 	require.NoError(t, err)
 	require.NotNil(t, cachedDeposits, "Deposits not cached")
 	assert.Equal(t, int64(5), cachedDeposits.MerkleTrieIndex())
@@ -669,10 +670,10 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
 			Index:       3,
 			DepositRoot: rootCreator('D'),
 		})
-	err = dc.InsertFinalizedDeposits(t.Context(), 1, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 1, [32]byte{}, 0)
 	require.NoError(t, err)
 
-	deps := dc.NonFinalizedDeposits(t.Context(), 1, nil)
+	deps := dc.NonFinalizedDeposits(context.Background(), 1, nil)
 	assert.Equal(t, 2, len(deps))
 }
 
@@ -680,7 +681,7 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits_Nil(t *testing.T) {
 	dc, err := New()
 	require.NoError(t, err)
 
-	deps := dc.NonFinalizedDeposits(t.Context(), 0, nil)
+	deps := dc.NonFinalizedDeposits(context.Background(), 0, nil)
 	assert.Equal(t, 0, len(deps))
 }
 
@@ -739,10 +740,10 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
 			Index:       3,
 			DepositRoot: rootCreator('D'),
 		})
-	err = dc.InsertFinalizedDeposits(t.Context(), 1, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 1, [32]byte{}, 0)
 	require.NoError(t, err)
 
-	deps := dc.NonFinalizedDeposits(t.Context(), 1, big.NewInt(10))
+	deps := dc.NonFinalizedDeposits(context.Background(), 1, big.NewInt(10))
 	assert.Equal(t, 1, len(deps))
 }
 
@@ -784,21 +785,21 @@ func TestFinalizedDeposits_ReturnsTrieCorrectly(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Perform this in a nonsensical ordering
-	err = dc.InsertFinalizedDeposits(t.Context(), 1, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 1, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 2, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 2, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 3, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 3, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 4, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 4, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 4, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 4, [32]byte{}, 0)
 	require.NoError(t, err)
 
 	// Mimic finalized deposit trie fetch.
-	fd, err := dc.FinalizedDeposits(t.Context())
+	fd, err := dc.FinalizedDeposits(context.Background())
 	require.NoError(t, err)
-	deps := dc.NonFinalizedDeposits(t.Context(), fd.MerkleTrieIndex(), nil)
+	deps := dc.NonFinalizedDeposits(context.Background(), fd.MerkleTrieIndex(), nil)
 	insertIndex := fd.MerkleTrieIndex() + 1
 
 	for _, dep := range deps {
@@ -809,24 +810,24 @@ func TestFinalizedDeposits_ReturnsTrieCorrectly(t *testing.T) {
 		}
 		insertIndex++
 	}
-	err = dc.InsertFinalizedDeposits(t.Context(), 5, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 5, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 6, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 6, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 9, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 9, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 12, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 12, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 15, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 15, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 15, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 15, [32]byte{}, 0)
 	require.NoError(t, err)
-	err = dc.InsertFinalizedDeposits(t.Context(), 14, [32]byte{}, 0)
+	err = dc.InsertFinalizedDeposits(context.Background(), 14, [32]byte{}, 0)
 	require.NoError(t, err)
 
-	fd, err = dc.FinalizedDeposits(t.Context())
+	fd, err = dc.FinalizedDeposits(context.Background())
 	require.NoError(t, err)
-	deps = dc.NonFinalizedDeposits(t.Context(), fd.MerkleTrieIndex(), nil)
+	deps = dc.NonFinalizedDeposits(context.Background(), fd.MerkleTrieIndex(), nil)
 	insertIndex = fd.MerkleTrieIndex() + 1
 
 	for _, dep := range dc.deposits {
@@ -887,9 +888,9 @@ func TestMin(t *testing.T) {
 	}
 	dc.deposits = finalizedDeposits
 
-	fd, err := dc.FinalizedDeposits(t.Context())
+	fd, err := dc.FinalizedDeposits(context.Background())
 	require.NoError(t, err)
-	deps := dc.NonFinalizedDeposits(t.Context(), fd.MerkleTrieIndex(), big.NewInt(16))
+	deps := dc.NonFinalizedDeposits(context.Background(), fd.MerkleTrieIndex(), big.NewInt(16))
 	insertIndex := fd.MerkleTrieIndex() + 1
 	for _, dep := range deps {
 		depHash, err := dep.Data.HashTreeRoot()
@@ -907,28 +908,28 @@ func TestDepositMap_WorksCorrectly(t *testing.T) {
 	require.NoError(t, err)
 
 	pk0 := bytesutil.PadTo([]byte("pk0"), 48)
-	dep, _ := dc.DepositByPubkey(t.Context(), pk0)
+	dep, _ := dc.DepositByPubkey(context.Background(), pk0)
 	var nilDep *ethpb.Deposit
 	assert.DeepEqual(t, nilDep, dep)
 
 	dep = &ethpb.Deposit{Proof: makeDepositProof(), Data: &ethpb.Deposit_Data{PublicKey: pk0, Amount: 1000}}
-	assert.NoError(t, dc.InsertDeposit(t.Context(), dep, 1000, 0, [32]byte{}))
+	assert.NoError(t, dc.InsertDeposit(context.Background(), dep, 1000, 0, [32]byte{}))
 
-	dep, _ = dc.DepositByPubkey(t.Context(), pk0)
+	dep, _ = dc.DepositByPubkey(context.Background(), pk0)
 	assert.NotEqual(t, nilDep, dep)
 	assert.Equal(t, uint64(1000), dep.Data.Amount)
 
 	dep = &ethpb.Deposit{Proof: makeDepositProof(), Data: &ethpb.Deposit_Data{PublicKey: pk0, Amount: 10000}}
-	assert.NoError(t, dc.InsertDeposit(t.Context(), dep, 1000, 1, [32]byte{}))
+	assert.NoError(t, dc.InsertDeposit(context.Background(), dep, 1000, 1, [32]byte{}))
 
 	// Make sure we have the same deposit returned over here.
-	dep, _ = dc.DepositByPubkey(t.Context(), pk0)
+	dep, _ = dc.DepositByPubkey(context.Background(), pk0)
 	assert.NotEqual(t, nilDep, dep)
 	assert.Equal(t, uint64(1000), dep.Data.Amount)
 
 	// Make sure another key doesn't work.
 	pk1 := bytesutil.PadTo([]byte("pk1"), 48)
-	dep, _ = dc.DepositByPubkey(t.Context(), pk1)
+	dep, _ = dc.DepositByPubkey(context.Background(), pk1)
 	assert.DeepEqual(t, nilDep, dep)
 }
 

beacon-chain/cache/depositsnapshot/deposit_fetcher_test.go

@@ -1,6 +1,7 @@
 package depositsnapshot
 
 import (
+	"context"
 	"math/big"
 	"testing"
 
@@ -12,14 +13,14 @@ var _ PendingDepositsFetcher = (*Cache)(nil)
 
 func TestInsertPendingDeposit_OK(t *testing.T) {
 	dc := Cache{}
-	dc.InsertPendingDeposit(t.Context(), &ethpb.Deposit{}, 111, 100, [32]byte{})
+	dc.InsertPendingDeposit(context.Background(), &ethpb.Deposit{}, 111, 100, [32]byte{})
 
 	assert.Equal(t, 1, len(dc.pendingDeposits), "deposit not inserted")
 }
 
 func TestInsertPendingDeposit_ignoresNilDeposit(t *testing.T) {
 	dc := Cache{}
-	dc.InsertPendingDeposit(t.Context(), nil /*deposit*/, 0 /*blockNum*/, 0, [32]byte{})
+	dc.InsertPendingDeposit(context.Background(), nil /*deposit*/, 0 /*blockNum*/, 0, [32]byte{})
 
 	assert.Equal(t, 0, len(dc.pendingDeposits))
 }
@@ -33,13 +34,13 @@ func TestPendingDeposits_OK(t *testing.T) {
 		{Eth1BlockHeight: 6, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("c")}}},
 	}
 
-	deposits := dc.PendingDeposits(t.Context(), big.NewInt(4))
+	deposits := dc.PendingDeposits(context.Background(), big.NewInt(4))
 	expected := []*ethpb.Deposit{
 		{Proof: [][]byte{[]byte("A")}},
 		{Proof: [][]byte{[]byte("B")}},
 	}
 	assert.DeepSSZEqual(t, expected, deposits)
 
-	all := dc.PendingDeposits(t.Context(), nil)
+	all := dc.PendingDeposits(context.Background(), nil)
 	assert.Equal(t, len(dc.pendingDeposits), len(all), "PendingDeposits(ctx, nil) did not return all deposits")
 }

beacon-chain/cache/depositsnapshot/deposit_pruner_test.go

@@ -1,6 +1,7 @@
 package depositsnapshot
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
@@ -21,7 +22,7 @@ func TestPrunePendingDeposits_ZeroMerkleIndex(t *testing.T) {
 		{Eth1BlockHeight: 12, Index: 12},
 	}
 
-	dc.PrunePendingDeposits(t.Context(), 0)
+	dc.PrunePendingDeposits(context.Background(), 0)
 	expected := []*ethpb.DepositContainer{
 		{Eth1BlockHeight: 2, Index: 2},
 		{Eth1BlockHeight: 4, Index: 4},
@@ -45,7 +46,7 @@ func TestPrunePendingDeposits_OK(t *testing.T) {
 		{Eth1BlockHeight: 12, Index: 12},
 	}
 
-	dc.PrunePendingDeposits(t.Context(), 6)
+	dc.PrunePendingDeposits(context.Background(), 6)
 	expected := []*ethpb.DepositContainer{
 		{Eth1BlockHeight: 6, Index: 6},
 		{Eth1BlockHeight: 8, Index: 8},
@@ -64,7 +65,7 @@ func TestPrunePendingDeposits_OK(t *testing.T) {
 		{Eth1BlockHeight: 12, Index: 12},
 	}
 
-	dc.PrunePendingDeposits(t.Context(), 10)
+	dc.PrunePendingDeposits(context.Background(), 10)
 	expected = []*ethpb.DepositContainer{
 		{Eth1BlockHeight: 10, Index: 10},
 		{Eth1BlockHeight: 12, Index: 12},
@@ -85,7 +86,7 @@ func TestPruneAllPendingDeposits(t *testing.T) {
 		{Eth1BlockHeight: 12, Index: 12},
 	}
 
-	dc.PruneAllPendingDeposits(t.Context())
+	dc.PruneAllPendingDeposits(context.Background())
 	expected := []*ethpb.DepositContainer{}
 
 	assert.DeepEqual(t, expected, dc.pendingDeposits)
@@ -127,10 +128,10 @@ func TestPruneProofs_Ok(t *testing.T) {
 	}
 
 	for _, ins := range deposits {
-		assert.NoError(t, dc.InsertDeposit(t.Context(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
+		assert.NoError(t, dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
 	}
 
-	require.NoError(t, dc.PruneProofs(t.Context(), 1))
+	require.NoError(t, dc.PruneProofs(context.Background(), 1))
 
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[0].Deposit.Proof)
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[1].Deposit.Proof)
@@ -172,10 +173,10 @@ func TestPruneProofs_SomeAlreadyPruned(t *testing.T) {
 	}
 
 	for _, ins := range deposits {
-		assert.NoError(t, dc.InsertDeposit(t.Context(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
+		assert.NoError(t, dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
 	}
 
-	require.NoError(t, dc.PruneProofs(t.Context(), 2))
+	require.NoError(t, dc.PruneProofs(context.Background(), 2))
 
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[2].Deposit.Proof)
 }
@@ -216,10 +217,10 @@ func TestPruneProofs_PruneAllWhenDepositIndexTooBig(t *testing.T) {
 	}
 
 	for _, ins := range deposits {
-		assert.NoError(t, dc.InsertDeposit(t.Context(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
+		assert.NoError(t, dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
 	}
 
-	require.NoError(t, dc.PruneProofs(t.Context(), 99))
+	require.NoError(t, dc.PruneProofs(context.Background(), 99))
 
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[0].Deposit.Proof)
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[1].Deposit.Proof)
@@ -263,10 +264,10 @@ func TestPruneProofs_CorrectlyHandleLastIndex(t *testing.T) {
 	}
 
 	for _, ins := range deposits {
-		assert.NoError(t, dc.InsertDeposit(t.Context(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
+		assert.NoError(t, dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
 	}
 
-	require.NoError(t, dc.PruneProofs(t.Context(), 4))
+	require.NoError(t, dc.PruneProofs(context.Background(), 4))
 
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[0].Deposit.Proof)
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[1].Deposit.Proof)
@@ -310,10 +311,10 @@ func TestPruneAllProofs(t *testing.T) {
 	}
 
 	for _, ins := range deposits {
-		assert.NoError(t, dc.InsertDeposit(t.Context(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
+		assert.NoError(t, dc.InsertDeposit(context.Background(), ins.deposit, ins.blkNum, ins.index, [32]byte{}))
 	}
 
-	dc.PruneAllProofs(t.Context())
+	dc.PruneAllProofs(context.Background())
 
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[0].Deposit.Proof)
 	assert.DeepEqual(t, [][]byte(nil), dc.deposits[1].Deposit.Proof)

beacon-chain/cache/registration_test.go

@@ -1,6 +1,7 @@
 package cache
 
 import (
+	"context"
 	"testing"
 	"time"
 
@@ -23,7 +24,7 @@ func TestRegistrationCache(t *testing.T) {
 		Timestamp:    uint64(time.Now().Unix()),
 		Pubkey:       pubkey,
 	}
-	cache.UpdateIndexToRegisteredMap(t.Context(), m)
+	cache.UpdateIndexToRegisteredMap(context.Background(), m)
 	reg, err := cache.RegistrationByIndex(validatorIndex)
 	require.NoError(t, err)
 	require.Equal(t, string(reg.Pubkey), string(pubkey))
@@ -37,7 +38,7 @@ func TestRegistrationCache(t *testing.T) {
 			Timestamp:    uint64(time.Now().Unix()),
 			Pubkey:       pubkey,
 		}
-		cache.UpdateIndexToRegisteredMap(t.Context(), m)
+		cache.UpdateIndexToRegisteredMap(context.Background(), m)
 		reg, err := cache.RegistrationByIndex(validatorIndex2)
 		require.NoError(t, err)
 		require.Equal(t, string(reg.Pubkey), string(pubkey))

beacon-chain/cache/skip_slot_cache_test.go

@@ -1,6 +1,7 @@
 package cache_test
 
 import (
+	"context"
 	"sync"
 	"testing"
 
@@ -13,7 +14,7 @@ import (
 )
 
 func TestSkipSlotCache_RoundTrip(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	c := cache.NewSkipSlotCache()
 
 	r := [32]byte{'a'}
@@ -37,7 +38,7 @@ func TestSkipSlotCache_RoundTrip(t *testing.T) {
 }
 
 func TestSkipSlotCache_DisabledAndEnabled(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	c := cache.NewSkipSlotCache()
 
 	r := [32]byte{'a'}

beacon-chain/core/altair/BUILD.bazel

@@ -81,7 +81,6 @@ go_test(
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
-        "//testing/fuzz:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time:go_default_library",

beacon-chain/core/altair/attestation_test.go

@@ -1,6 +1,7 @@
 package altair_test
 
 import (
+	"context"
 	"fmt"
 	"testing"
 
@@ -18,10 +19,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/math"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/attestation"
-	"github.com/OffchainLabs/prysm/v6/testing/fuzz"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
-	gofuzz "github.com/google/gofuzz"
+	fuzz "github.com/google/gofuzz"
 	"github.com/prysmaticlabs/go-bitfield"
 )
 
@@ -50,7 +50,7 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 	)
 	wsb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(t.Context(), beaconState, wsb.Block())
+	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
 	require.ErrorContains(t, want, err)
 }
 
@@ -81,7 +81,7 @@ func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
 	)
 	wsb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(t.Context(), beaconState, wsb.Block())
+	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
 	require.ErrorContains(t, want, err)
 }
 
@@ -110,13 +110,13 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 	want := "source check point not equal to current justified checkpoint"
 	wsb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(t.Context(), beaconState, wsb.Block())
+	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
 	require.ErrorContains(t, want, err)
 	b.Block.Body.Attestations[0].Data.Source.Epoch = time.CurrentEpoch(beaconState)
 	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
 	wsb, err = blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(t.Context(), beaconState, wsb.Block())
+	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
 	require.ErrorContains(t, want, err)
 }
 
@@ -151,14 +151,14 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 	want := "source check point not equal to previous justified checkpoint"
 	wsb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(t.Context(), beaconState, wsb.Block())
+	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
 	require.ErrorContains(t, want, err)
 	b.Block.Body.Attestations[0].Data.Source.Epoch = time.PrevEpoch(beaconState)
 	b.Block.Body.Attestations[0].Data.Target.Epoch = time.PrevEpoch(beaconState)
 	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
 	wsb, err = blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(t.Context(), beaconState, wsb.Block())
+	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
 	require.ErrorContains(t, want, err)
 }
 
@@ -190,7 +190,7 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 	expected := "failed to verify aggregation bitfield: wanted participants bitfield length 3, got: 4"
 	wsb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	_, err = altair.ProcessAttestationsNoVerifySignature(t.Context(), beaconState, wsb.Block())
+	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
 	require.ErrorContains(t, expected, err)
 }
 
@@ -214,7 +214,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 		cfc.Root = mockRoot[:]
 		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
 
-		committee, err := helpers.BeaconCommitteeFromState(t.Context(), beaconState, att.Data.Slot, 0)
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, 0)
 		require.NoError(t, err)
 		attestingIndices, err := attestation.AttestingIndices(att, committee)
 		require.NoError(t, err)
@@ -235,7 +235,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 		require.NoError(t, err)
 		wsb, err := blocks.NewSignedBeaconBlock(block)
 		require.NoError(t, err)
-		_, err = altair.ProcessAttestationsNoVerifySignature(t.Context(), beaconState, wsb.Block())
+		_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
 		require.NoError(t, err)
 	})
 	t.Run("post-Electra", func(t *testing.T) {
@@ -260,7 +260,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 		cfc.Root = mockRoot[:]
 		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
 
-		committee, err := helpers.BeaconCommitteeFromState(t.Context(), beaconState, att.Data.Slot, 0)
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, 0)
 		require.NoError(t, err)
 		attestingIndices, err := attestation.AttestingIndices(att, committee)
 		require.NoError(t, err)
@@ -281,7 +281,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 		require.NoError(t, err)
 		wsb, err := blocks.NewSignedBeaconBlock(block)
 		require.NoError(t, err)
-		_, err = altair.ProcessAttestationsNoVerifySignature(t.Context(), beaconState, wsb.Block())
+		_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb.Block())
 		require.NoError(t, err)
 	})
 }
@@ -313,13 +313,13 @@ func TestProcessAttestationNoVerify_SourceTargetHead(t *testing.T) {
 
 	b, err := helpers.TotalActiveBalance(beaconState)
 	require.NoError(t, err)
-	beaconState, err = altair.ProcessAttestationNoVerifySignature(t.Context(), beaconState, att, b)
+	beaconState, err = altair.ProcessAttestationNoVerifySignature(context.Background(), beaconState, att, b)
 	require.NoError(t, err)
 
 	p, err := beaconState.CurrentEpochParticipation()
 	require.NoError(t, err)
 
-	committee, err := helpers.BeaconCommitteeFromState(t.Context(), beaconState, att.Data.Slot, att.Data.CommitteeIndex)
+	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, att.Data.CommitteeIndex)
 	require.NoError(t, err)
 	indices, err := attestation.AttestingIndices(att, committee)
 	require.NoError(t, err)
@@ -458,7 +458,7 @@ func TestValidatorFlag_Add_ExceedsLength(t *testing.T) {
 }
 
 func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	st := &ethpb.BeaconStateAltair{}
 	b := &ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}}
 	for i := 0; i < 10000; i++ {
@@ -474,11 +474,10 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 		}
 		wsb, err := blocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
-		r, err := altair.ProcessAttestationsNoVerifySignature(t.Context(), s, wsb.Block())
+		r, err := altair.ProcessAttestationsNoVerifySignature(context.Background(), s, wsb.Block())
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, s, b)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
@@ -556,10 +555,10 @@ func TestSetParticipationAndRewardProposer(t *testing.T) {
 
 			b, err := helpers.TotalActiveBalance(beaconState)
 			require.NoError(t, err)
-			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b)
+			st, err := altair.SetParticipationAndRewardProposer(context.Background(), beaconState, test.epoch, test.indices, test.participatedFlags, b)
 			require.NoError(t, err)
 
-			i, err := helpers.BeaconProposerIndex(t.Context(), st)
+			i, err := helpers.BeaconProposerIndex(context.Background(), st)
 			require.NoError(t, err)
 			b, err = beaconState.BalanceAtIndex(i)
 			require.NoError(t, err)
@@ -662,8 +661,8 @@ func TestRewardProposer(t *testing.T) {
 		{rewardNumerator: 1000000000000, want: 34234377253},
 	}
 	for _, test := range tests {
-		require.NoError(t, altair.RewardProposer(t.Context(), beaconState, test.rewardNumerator))
-		i, err := helpers.BeaconProposerIndex(t.Context(), beaconState)
+		require.NoError(t, altair.RewardProposer(context.Background(), beaconState, test.rewardNumerator))
+		i, err := helpers.BeaconProposerIndex(context.Background(), beaconState)
 		require.NoError(t, err)
 		b, err := beaconState.BalanceAtIndex(i)
 		require.NoError(t, err)

beacon-chain/core/altair/block_test.go

@@ -1,6 +1,7 @@
 package altair_test
 
 import (
+	"context"
 	"math"
 	"testing"
 
@@ -25,7 +26,7 @@ import (
 func TestProcessSyncCommittee_PerfectParticipation(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
 
@@ -33,7 +34,7 @@ func TestProcessSyncCommittee_PerfectParticipation(t *testing.T) {
 	for i := range syncBits {
 		syncBits[i] = 0xff
 	}
-	indices, err := altair.NextSyncCommitteeIndices(t.Context(), beaconState)
+	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
 	ps := slots.PrevSlot(beaconState.Slot())
 	pbr, err := helpers.BlockRootAtSlot(beaconState, ps)
@@ -54,7 +55,7 @@ func TestProcessSyncCommittee_PerfectParticipation(t *testing.T) {
 	}
 
 	var reward uint64
-	beaconState, reward, err = altair.ProcessSyncAggregate(t.Context(), beaconState, syncAggregate)
+	beaconState, reward, err = altair.ProcessSyncAggregate(context.Background(), beaconState, syncAggregate)
 	require.NoError(t, err)
 	assert.Equal(t, uint64(72192), reward)
 
@@ -76,7 +77,7 @@ func TestProcessSyncCommittee_PerfectParticipation(t *testing.T) {
 	require.Equal(t, true, balances[indices[0]] > balances[nonSyncIndex])
 
 	// Proposer should be more profitable than rest of the sync committee
-	proposerIndex, err := helpers.BeaconProposerIndex(t.Context(), beaconState)
+	proposerIndex, err := helpers.BeaconProposerIndex(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.Equal(t, true, balances[proposerIndex] > balances[indices[0]])
 
@@ -101,7 +102,7 @@ func TestProcessSyncCommittee_PerfectParticipation(t *testing.T) {
 func TestProcessSyncCommittee_MixParticipation_BadSignature(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
 
@@ -109,7 +110,7 @@ func TestProcessSyncCommittee_MixParticipation_BadSignature(t *testing.T) {
 	for i := range syncBits {
 		syncBits[i] = 0xAA
 	}
-	indices, err := altair.NextSyncCommitteeIndices(t.Context(), beaconState)
+	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
 	ps := slots.PrevSlot(beaconState.Slot())
 	pbr, err := helpers.BlockRootAtSlot(beaconState, ps)
@@ -129,14 +130,14 @@ func TestProcessSyncCommittee_MixParticipation_BadSignature(t *testing.T) {
 		SyncCommitteeSignature: aggregatedSig,
 	}
 
-	_, _, err = altair.ProcessSyncAggregate(t.Context(), beaconState, syncAggregate)
+	_, _, err = altair.ProcessSyncAggregate(context.Background(), beaconState, syncAggregate)
 	require.ErrorContains(t, "invalid sync committee signature", err)
 }
 
 func TestProcessSyncCommittee_MixParticipation_GoodSignature(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
 
@@ -144,7 +145,7 @@ func TestProcessSyncCommittee_MixParticipation_GoodSignature(t *testing.T) {
 	for i := range syncBits {
 		syncBits[i] = 0xAA
 	}
-	indices, err := altair.NextSyncCommitteeIndices(t.Context(), beaconState)
+	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
 	ps := slots.PrevSlot(beaconState.Slot())
 	pbr, err := helpers.BlockRootAtSlot(beaconState, ps)
@@ -166,7 +167,7 @@ func TestProcessSyncCommittee_MixParticipation_GoodSignature(t *testing.T) {
 		SyncCommitteeSignature: aggregatedSig,
 	}
 
-	_, _, err = altair.ProcessSyncAggregate(t.Context(), beaconState, syncAggregate)
+	_, _, err = altair.ProcessSyncAggregate(context.Background(), beaconState, syncAggregate)
 	require.NoError(t, err)
 }
 
@@ -174,7 +175,7 @@ func TestProcessSyncCommittee_MixParticipation_GoodSignature(t *testing.T) {
 func TestProcessSyncCommittee_DontPrecompute(t *testing.T) {
 	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	committeeKeys := committee.Pubkeys
 	committeeKeys[1] = committeeKeys[0]
@@ -191,7 +192,7 @@ func TestProcessSyncCommittee_DontPrecompute(t *testing.T) {
 		SyncCommitteeBits: syncBits,
 	}
 	require.NoError(t, beaconState.UpdateBalancesAtIndex(idx, 0))
-	st, votedKeys, _, err := altair.ProcessSyncAggregateEported(t.Context(), beaconState, syncAggregate)
+	st, votedKeys, _, err := altair.ProcessSyncAggregateEported(context.Background(), beaconState, syncAggregate)
 	require.NoError(t, err)
 	require.Equal(t, 511, len(votedKeys))
 	require.DeepEqual(t, committeeKeys[0], votedKeys[0].Marshal())
@@ -202,7 +203,7 @@ func TestProcessSyncCommittee_DontPrecompute(t *testing.T) {
 func TestProcessSyncCommittee_processSyncAggregate(t *testing.T) {
 	beaconState, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
 
@@ -214,7 +215,7 @@ func TestProcessSyncCommittee_processSyncAggregate(t *testing.T) {
 		SyncCommitteeBits: syncBits,
 	}
 
-	st, votedKeys, _, err := altair.ProcessSyncAggregateEported(t.Context(), beaconState, syncAggregate)
+	st, votedKeys, _, err := altair.ProcessSyncAggregateEported(context.Background(), beaconState, syncAggregate)
 	require.NoError(t, err)
 	votedMap := make(map[[fieldparams.BLSPubkeyLength]byte]bool)
 	for _, key := range votedKeys {
@@ -227,7 +228,7 @@ func TestProcessSyncCommittee_processSyncAggregate(t *testing.T) {
 	committeeKeys := currentSyncCommittee.Pubkeys
 	balances := st.Balances()
 
-	proposerIndex, err := helpers.BeaconProposerIndex(t.Context(), beaconState)
+	proposerIndex, err := helpers.BeaconProposerIndex(context.Background(), beaconState)
 	require.NoError(t, err)
 
 	for i := 0; i < len(syncBits); i++ {
@@ -253,7 +254,7 @@ func TestProcessSyncCommittee_processSyncAggregate(t *testing.T) {
 func Test_VerifySyncCommitteeSig(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, beaconState.SetSlot(1))
-	committee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	committee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetCurrentSyncCommittee(committee))
 
@@ -261,7 +262,7 @@ func Test_VerifySyncCommitteeSig(t *testing.T) {
 	for i := range syncBits {
 		syncBits[i] = 0xff
 	}
-	indices, err := altair.NextSyncCommitteeIndices(t.Context(), beaconState)
+	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
 	ps := slots.PrevSlot(beaconState.Slot())
 	pbr, err := helpers.BlockRootAtSlot(beaconState, ps)

beacon-chain/core/altair/deposit_fuzz_test.go

@@ -1,21 +1,21 @@
 package altair_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
 	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/fuzz"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
-	gofuzz "github.com/google/gofuzz"
+	fuzz "github.com/google/gofuzz"
 )
 
 func TestFuzzProcessDeposits_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconStateAltair{}
 	deposits := make([]*ethpb.Deposit, 100)
-	ctx := t.Context()
+	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		for i := range deposits {
@@ -27,15 +27,14 @@ func TestFuzzProcessDeposits_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposits)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconStateAltair{}
 	deposit := &ethpb.Deposit{}
-	ctx := t.Context()
+	ctx := context.Background()
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -46,15 +45,14 @@ func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessPreGenesisDeposit_Phase0_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	deposit := &ethpb.Deposit{}
-	ctx := t.Context()
+	ctx := context.Background()
 
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
@@ -65,12 +63,11 @@ func TestFuzzProcessPreGenesisDeposit_Phase0_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessDeposit_Phase0_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	deposit := &ethpb.Deposit{}
 
@@ -83,12 +80,11 @@ func TestFuzzProcessDeposit_Phase0_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessDeposit_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconStateAltair{}
 	deposit := &ethpb.Deposit{}
 
@@ -101,6 +97,5 @@ func TestFuzzProcessDeposit_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
 		}
-		fuzz.FreeMemory(i)
 	}
 }

beacon-chain/core/altair/deposit_test.go

@@ -1,6 +1,7 @@
 package altair_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
@@ -41,7 +42,7 @@ func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := altair.ProcessDeposits(t.Context(), beaconState, []*ethpb.Deposit{dep[0], dep[1], dep[2]})
+	newState, err := altair.ProcessDeposits(context.Background(), beaconState, []*ethpb.Deposit{dep[0], dep[1], dep[2]})
 	require.NoError(t, err, "Expected block deposits to process correctly")
 	require.Equal(t, 2, len(newState.Validators()), "Incorrect validator count")
 }
@@ -69,7 +70,7 @@ func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := altair.ProcessDeposits(t.Context(), beaconState, []*ethpb.Deposit{dep[0]})
+	newState, err := altair.ProcessDeposits(context.Background(), beaconState, []*ethpb.Deposit{dep[0]})
 	require.NoError(t, err, "Expected block deposits to process correctly")
 	if newState.Balances()[1] != dep[0].Data.Amount {
 		t.Errorf(
@@ -126,7 +127,7 @@ func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T)
 		},
 	})
 	require.NoError(t, err)
-	newState, err := altair.ProcessDeposits(t.Context(), beaconState, []*ethpb.Deposit{deposit})
+	newState, err := altair.ProcessDeposits(context.Background(), beaconState, []*ethpb.Deposit{deposit})
 	require.NoError(t, err, "Process deposit failed")
 	require.Equal(t, uint64(1000+50), newState.Balances()[1], "Expected balance at index 1 to be 1050")
 }
@@ -255,7 +256,7 @@ func TestPreGenesisDeposits_SkipInvalidDeposit(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := altair.ProcessPreGenesisDeposits(t.Context(), beaconState, dep)
+	newState, err := altair.ProcessPreGenesisDeposits(context.Background(), beaconState, dep)
 	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
 
 	_, ok := newState.ValidatorIndexByPubkey(bytesutil.ToBytes48(dep[0].Data.PublicKey))
@@ -369,6 +370,6 @@ func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
 	})
 	require.NoError(t, err)
 	want := "deposit root did not verify"
-	_, err = altair.ProcessDeposits(t.Context(), beaconState, b.Block.Body.Deposits)
+	_, err = altair.ProcessDeposits(context.Background(), beaconState, b.Block.Body.Deposits)
 	assert.ErrorContains(t, want, err)
 }

beacon-chain/core/altair/epoch_precompute_test.go

@@ -1,6 +1,7 @@
 package altair
 
 import (
+	"context"
 	"math"
 	"testing"
 
@@ -31,7 +32,7 @@ func TestInitializeEpochValidators_Ok(t *testing.T) {
 		InactivityScores: []uint64{0, 1, 2, 3},
 	})
 	require.NoError(t, err)
-	v, b, err := InitializePrecomputeValidators(t.Context(), s)
+	v, b, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 	assert.DeepEqual(t, &precompute.Validator{
 		IsSlashed:                    true,
@@ -73,7 +74,7 @@ func TestInitializeEpochValidators_Overflow(t *testing.T) {
 		InactivityScores: []uint64{0, 1},
 	})
 	require.NoError(t, err)
-	_, _, err = InitializePrecomputeValidators(t.Context(), s)
+	_, _, err = InitializePrecomputeValidators(context.Background(), s)
 	require.ErrorContains(t, "could not read every validator: addition overflows", err)
 }
 
@@ -83,16 +84,16 @@ func TestInitializeEpochValidators_BadState(t *testing.T) {
 		InactivityScores: []uint64{},
 	})
 	require.NoError(t, err)
-	_, _, err = InitializePrecomputeValidators(t.Context(), s)
+	_, _, err = InitializePrecomputeValidators(context.Background(), s)
 	require.ErrorContains(t, "num of validators is different than num of inactivity scores", err)
 }
 
 func TestProcessEpochParticipation(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
 	require.DeepEqual(t, &precompute.Validator{
 		IsActiveCurrentEpoch:         true,
@@ -168,9 +169,9 @@ func TestProcessEpochParticipation_InactiveValidator(t *testing.T) {
 		InactivityScores: []uint64{0, 0, 0},
 	})
 	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), st)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), st)
 	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(t.Context(), st, balance, validators)
+	validators, balance, err = ProcessEpochParticipation(context.Background(), st, balance, validators)
 	require.NoError(t, err)
 	require.DeepEqual(t, &precompute.Validator{
 		IsActiveCurrentEpoch:         false,
@@ -208,9 +209,9 @@ func TestProcessEpochParticipation_InactiveValidator(t *testing.T) {
 func TestAttestationsDelta(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
 	deltas, err := AttestationsDelta(s, balance, validators)
 	require.NoError(t, err)
@@ -246,9 +247,9 @@ func TestAttestationsDelta(t *testing.T) {
 func TestAttestationsDeltaBellatrix(t *testing.T) {
 	s, err := testStateBellatrix()
 	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
 	deltas, err := AttestationsDelta(s, balance, validators)
 	require.NoError(t, err)
@@ -284,9 +285,9 @@ func TestAttestationsDeltaBellatrix(t *testing.T) {
 func TestProcessRewardsAndPenaltiesPrecompute_Ok(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
 	s, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, validators)
 	require.NoError(t, err)
@@ -323,9 +324,9 @@ func TestProcessRewardsAndPenaltiesPrecompute_Ok(t *testing.T) {
 func TestProcessRewardsAndPenaltiesPrecompute_InactivityLeak(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
 	sCopy := s.Copy()
 	s, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, validators)
@@ -351,11 +352,11 @@ func TestProcessInactivityScores_CanProcessInactivityLeak(t *testing.T) {
 	defaultScore := uint64(5)
 	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
 	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch*primitives.Slot(params.BeaconConfig().MinEpochsToInactivityPenalty+2)))
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	validators, _, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	s, _, err = ProcessInactivityScores(t.Context(), s, validators)
+	s, _, err = ProcessInactivityScores(context.Background(), s, validators)
 	require.NoError(t, err)
 	inactivityScores, err := s.InactivityScores()
 	require.NoError(t, err)
@@ -372,11 +373,11 @@ func TestProcessInactivityScores_GenesisEpoch(t *testing.T) {
 	defaultScore := uint64(10)
 	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
 	require.NoError(t, s.SetSlot(params.BeaconConfig().GenesisSlot))
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	validators, _, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	s, _, err = ProcessInactivityScores(t.Context(), s, validators)
+	s, _, err = ProcessInactivityScores(context.Background(), s, validators)
 	require.NoError(t, err)
 	inactivityScores, err := s.InactivityScores()
 	require.NoError(t, err)
@@ -391,11 +392,11 @@ func TestProcessInactivityScores_CanProcessNonInactivityLeak(t *testing.T) {
 	require.NoError(t, err)
 	defaultScore := uint64(5)
 	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	validators, _, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	s, _, err = ProcessInactivityScores(t.Context(), s, validators)
+	s, _, err = ProcessInactivityScores(context.Background(), s, validators)
 	require.NoError(t, err)
 	inactivityScores, err := s.InactivityScores()
 	require.NoError(t, err)
@@ -409,9 +410,9 @@ func TestProcessInactivityScores_CanProcessNonInactivityLeak(t *testing.T) {
 func TestProcessRewardsAndPenaltiesPrecompute_GenesisEpoch(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	validators, balance, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(0))
 	s, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, validators)
@@ -428,9 +429,9 @@ func TestProcessRewardsAndPenaltiesPrecompute_GenesisEpoch(t *testing.T) {
 func TestProcessRewardsAndPenaltiesPrecompute_BadState(t *testing.T) {
 	s, err := testState()
 	require.NoError(t, err)
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	_, balance, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	_, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
 	_, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, []*precompute.Validator{})
 	require.ErrorContains(t, "validator registries not the same length as state's validator registries", err)
@@ -441,7 +442,7 @@ func TestProcessInactivityScores_NonEligibleValidator(t *testing.T) {
 	require.NoError(t, err)
 	defaultScore := uint64(5)
 	require.NoError(t, s.SetInactivityScores([]uint64{defaultScore, defaultScore, defaultScore, defaultScore}))
-	validators, balance, err := InitializePrecomputeValidators(t.Context(), s)
+	validators, balance, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
 
 	// v0 is eligible (not active previous epoch, slashed and not withdrawable)
@@ -462,9 +463,9 @@ func TestProcessInactivityScores_NonEligibleValidator(t *testing.T) {
 	// v3 is eligible (active previous epoch)
 	validators[3].IsActivePrevEpoch = true
 
-	validators, _, err = ProcessEpochParticipation(t.Context(), s, balance, validators)
+	validators, _, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	s, _, err = ProcessInactivityScores(t.Context(), s, validators)
+	s, _, err = ProcessInactivityScores(context.Background(), s, validators)
 	require.NoError(t, err)
 	inactivityScores, err := s.InactivityScores()
 	require.NoError(t, err)

beacon-chain/core/altair/epoch_spec_test.go

@@ -1,6 +1,7 @@
 package altair_test
 
 import (
+	"context"
 	"fmt"
 	"math"
 	"testing"
@@ -28,7 +29,7 @@ func TestProcessSyncCommitteeUpdates_CanRotate(t *testing.T) {
 		BodyRoot:   bytesutil.PadTo([]byte{'c'}, 32),
 	}
 	require.NoError(t, s.SetLatestBlockHeader(h))
-	postState, err := altair.ProcessSyncCommitteeUpdates(t.Context(), s)
+	postState, err := altair.ProcessSyncCommitteeUpdates(context.Background(), s)
 	require.NoError(t, err)
 	current, err := postState.CurrentSyncCommittee()
 	require.NoError(t, err)
@@ -37,7 +38,7 @@ func TestProcessSyncCommitteeUpdates_CanRotate(t *testing.T) {
 	require.DeepEqual(t, current, next)
 
 	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-	postState, err = altair.ProcessSyncCommitteeUpdates(t.Context(), s)
+	postState, err = altair.ProcessSyncCommitteeUpdates(context.Background(), s)
 	require.NoError(t, err)
 	c, err := postState.CurrentSyncCommittee()
 	require.NoError(t, err)
@@ -47,7 +48,7 @@ func TestProcessSyncCommitteeUpdates_CanRotate(t *testing.T) {
 	require.DeepEqual(t, next, n)
 
 	require.NoError(t, s.SetSlot(primitives.Slot(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*params.BeaconConfig().SlotsPerEpoch-1))
-	postState, err = altair.ProcessSyncCommitteeUpdates(t.Context(), s)
+	postState, err = altair.ProcessSyncCommitteeUpdates(context.Background(), s)
 	require.NoError(t, err)
 	c, err = postState.CurrentSyncCommittee()
 	require.NoError(t, err)
@@ -60,7 +61,7 @@ func TestProcessSyncCommitteeUpdates_CanRotate(t *testing.T) {
 	// Test boundary condition.
 	slot := params.BeaconConfig().SlotsPerEpoch * primitives.Slot(time.CurrentEpoch(s)+params.BeaconConfig().EpochsPerSyncCommitteePeriod)
 	require.NoError(t, s.SetSlot(slot))
-	boundaryCommittee, err := altair.NextSyncCommittee(t.Context(), s)
+	boundaryCommittee, err := altair.NextSyncCommittee(context.Background(), s)
 	require.NoError(t, err)
 	require.DeepNotEqual(t, boundaryCommittee, n)
 }

beacon-chain/core/altair/sync_committee_test.go

@@ -1,6 +1,7 @@
 package altair_test
 
 import (
+	"context"
 	"testing"
 	"time"
 
@@ -96,7 +97,7 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 				t.Run(version.String(v), func(t *testing.T) {
 					helpers.ClearCache()
 					st := getState(t, tt.args.validatorCount, v)
-					got, err := altair.NextSyncCommitteeIndices(t.Context(), st)
+					got, err := altair.NextSyncCommitteeIndices(context.Background(), st)
 					if tt.wantErr {
 						require.ErrorContains(t, tt.errString, err)
 					} else {
@@ -128,18 +129,18 @@ func TestSyncCommitteeIndices_DifferentPeriods(t *testing.T) {
 	}
 
 	st := getState(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	got1, err := altair.NextSyncCommitteeIndices(t.Context(), st)
+	got1, err := altair.NextSyncCommitteeIndices(context.Background(), st)
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch))
-	got2, err := altair.NextSyncCommitteeIndices(t.Context(), st)
+	got2, err := altair.NextSyncCommitteeIndices(context.Background(), st)
 	require.NoError(t, err)
 	require.DeepNotEqual(t, got1, got2)
 	require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*primitives.Slot(params.BeaconConfig().EpochsPerSyncCommitteePeriod)))
-	got2, err = altair.NextSyncCommitteeIndices(t.Context(), st)
+	got2, err = altair.NextSyncCommitteeIndices(context.Background(), st)
 	require.NoError(t, err)
 	require.DeepNotEqual(t, got1, got2)
 	require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*primitives.Slot(2*params.BeaconConfig().EpochsPerSyncCommitteePeriod)))
-	got2, err = altair.NextSyncCommitteeIndices(t.Context(), st)
+	got2, err = altair.NextSyncCommitteeIndices(context.Background(), st)
 	require.NoError(t, err)
 	require.DeepNotEqual(t, got1, got2)
 }
@@ -205,7 +206,7 @@ func TestSyncCommittee_CanGet(t *testing.T) {
 			if !tt.wantErr {
 				require.NoError(t, tt.args.state.SetSlot(primitives.Slot(tt.args.epoch)*params.BeaconConfig().SlotsPerEpoch))
 			}
-			got, err := altair.NextSyncCommittee(t.Context(), tt.args.state)
+			got, err := altair.NextSyncCommittee(context.Background(), tt.args.state)
 			if tt.wantErr {
 				require.ErrorContains(t, tt.errString, err)
 			} else {
@@ -269,7 +270,7 @@ func TestValidateNilSyncContribution(t *testing.T) {
 func TestSyncSubCommitteePubkeys_CanGet(t *testing.T) {
 	helpers.ClearCache()
 	st := getState(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	com, err := altair.NextSyncCommittee(t.Context(), st)
+	com, err := altair.NextSyncCommittee(context.Background(), st)
 	require.NoError(t, err)
 	sub, err := altair.SyncSubCommitteePubkeys(com, 0)
 	require.NoError(t, err)

beacon-chain/core/altair/transition_test.go

@@ -1,6 +1,7 @@
 package altair_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
@@ -12,7 +13,7 @@ import (
 func TestProcessEpoch_CanProcess(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch))
-	err := altair.ProcessEpoch(t.Context(), st)
+	err := altair.ProcessEpoch(context.Background(), st)
 	require.NoError(t, err)
 	require.Equal(t, uint64(0), st.Slashings()[2], "Unexpected slashed balance")
 
@@ -44,7 +45,7 @@ func TestProcessEpoch_CanProcess(t *testing.T) {
 func TestProcessEpoch_CanProcessBellatrix(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateBellatrix(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch))
-	err := altair.ProcessEpoch(t.Context(), st)
+	err := altair.ProcessEpoch(context.Background(), st)
 	require.NoError(t, err)
 	require.Equal(t, uint64(0), st.Slashings()[2], "Unexpected slashed balance")
 

beacon-chain/core/altair/upgrade_test.go

@@ -1,6 +1,7 @@
 package altair_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
@@ -16,7 +17,7 @@ import (
 )
 
 func TestTranslateParticipation(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	s, _ := util.DeterministicGenesisStateAltair(t, 64)
 	require.NoError(t, s.SetSlot(s.Slot()+params.BeaconConfig().MinAttestationInclusionDelay))
 
@@ -72,7 +73,7 @@ func TestTranslateParticipation(t *testing.T) {
 func TestUpgradeToAltair(t *testing.T) {
 	st, _ := util.DeterministicGenesisState(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	preForkState := st.Copy()
-	aState, err := altair.UpgradeToAltair(t.Context(), st)
+	aState, err := altair.UpgradeToAltair(context.Background(), st)
 	require.NoError(t, err)
 
 	require.Equal(t, preForkState.GenesisTime(), aState.GenesisTime())

beacon-chain/core/blocks/BUILD.bazel

@@ -105,7 +105,6 @@ go_test(
         "//proto/prysm/v1alpha1/attestation/aggregation/attestations:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
-        "//testing/fuzz:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",

beacon-chain/core/blocks/attestation.go

@@ -178,7 +178,7 @@ func VerifyAttestationNoVerifySignature(
 		}
 	}
 
-	return attestation.IsValidAttestationIndices(ctx, indexedAtt, params.BeaconConfig().MaxValidatorsPerCommittee, params.BeaconConfig().MaxCommitteesPerSlot)
+	return attestation.IsValidAttestationIndices(ctx, indexedAtt)
 }
 
 // ProcessAttestationNoVerifySignature processes the attestation without verifying the attestation signature. This
@@ -243,7 +243,7 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState state.ReadOnlyBea
 	ctx, span := trace.StartSpan(ctx, "core.VerifyIndexedAttestation")
 	defer span.End()
 
-	if err := attestation.IsValidAttestationIndices(ctx, indexedAtt, params.BeaconConfig().MaxValidatorsPerCommittee, params.BeaconConfig().MaxCommitteesPerSlot); err != nil {
+	if err := attestation.IsValidAttestationIndices(ctx, indexedAtt); err != nil {
 		return err
 	}
 	domain, err := signing.Domain(

beacon-chain/core/blocks/attestation_regression_test.go

@@ -41,7 +41,7 @@ func TestProcessAttestationNoVerifySignature_BeaconFuzzIssue78(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	ctx := t.Context()
+	ctx := context.Background()
 	_, err = blocks.ProcessAttestationNoVerifySignature(ctx, st, att)
 	require.ErrorContains(t, "committee index 1 >= committee count 1", err)
 }

beacon-chain/core/blocks/attestation_test.go

@@ -42,7 +42,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
 	require.NoError(t, beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{}))
 
-	committee, err := helpers.BeaconCommitteeFromState(t.Context(), beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
+	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
 	require.NoError(t, err)
 	attestingIndices1, err := attestation.AttestingIndices(att1, committee)
 	require.NoError(t, err)
@@ -64,7 +64,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 		AggregationBits: aggBits2,
 	}
 
-	committee, err = helpers.BeaconCommitteeFromState(t.Context(), beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
+	committee, err = helpers.BeaconCommitteeFromState(context.Background(), beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
 	require.NoError(t, err)
 	attestingIndices2, err := attestation.AttestingIndices(att2, committee)
 	require.NoError(t, err)
@@ -137,7 +137,7 @@ func TestProcessAttestationsNoVerify_OlderThanSlotsPerEpoch(t *testing.T) {
 		},
 		AggregationBits: aggBits,
 	}
-	ctx := t.Context()
+	ctx := context.Background()
 
 	t.Run("attestation older than slots per epoch", func(t *testing.T) {
 		beaconState, _ := util.DeterministicGenesisState(t, 100)
@@ -360,9 +360,9 @@ func TestConvertToIndexed_OK(t *testing.T) {
 			Signature:        att.Signature,
 		}
 
-		committee, err := helpers.BeaconCommitteeFromState(t.Context(), state, att.Data.Slot, att.Data.CommitteeIndex)
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, att.Data.Slot, att.Data.CommitteeIndex)
 		require.NoError(t, err)
-		ia, err := attestation.ConvertToIndexed(t.Context(), att, committee)
+		ia, err := attestation.ConvertToIndexed(context.Background(), att, committee)
 		require.NoError(t, err)
 		assert.DeepEqual(t, wanted, ia, "Convert attestation to indexed attestation didn't result as wanted")
 	}
@@ -448,7 +448,7 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 
 		tt.attestation.Signature = marshalledSig
 
-		err = blocks.VerifyIndexedAttestation(t.Context(), state, tt.attestation)
+		err = blocks.VerifyIndexedAttestation(context.Background(), state, tt.attestation)
 		assert.NoError(t, err, "Failed to verify indexed attestation")
 	}
 }
@@ -471,7 +471,7 @@ func TestValidateIndexedAttestation_AboveMaxLength(t *testing.T) {
 	want := "validator indices count exceeds MAX_VALIDATORS_PER_COMMITTEE"
 	st, err := state_native.InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	err = blocks.VerifyIndexedAttestation(t.Context(), st, indexedAtt1)
+	err = blocks.VerifyIndexedAttestation(context.Background(), st, indexedAtt1)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -493,7 +493,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	}
 
 	want := "nil or missing indexed attestation data"
-	_, err := blocks.AttestationSignatureBatch(t.Context(), beaconState, atts)
+	_, err := blocks.AttestationSignatureBatch(context.Background(), beaconState, atts)
 	assert.ErrorContains(t, want, err)
 
 	atts = []ethpb.Att{}
@@ -514,7 +514,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	}
 
 	want = "expected non-empty attesting indices"
-	_, err = blocks.AttestationSignatureBatch(t.Context(), beaconState, atts)
+	_, err = blocks.AttestationSignatureBatch(context.Background(), beaconState, atts)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -542,7 +542,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 	}))
 
-	comm1, err := helpers.BeaconCommitteeFromState(t.Context(), st, 1 /*slot*/, 0 /*committeeIndex*/)
+	comm1, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1 /*slot*/, 0 /*committeeIndex*/)
 	require.NoError(t, err)
 	att1 := util.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
@@ -561,7 +561,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 	}
 	att1.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	comm2, err := helpers.BeaconCommitteeFromState(t.Context(), st, 1*params.BeaconConfig().SlotsPerEpoch+1 /*slot*/, 1 /*committeeIndex*/)
+	comm2, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1*params.BeaconConfig().SlotsPerEpoch+1 /*slot*/, 1 /*committeeIndex*/)
 	require.NoError(t, err)
 	att2 := util.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
@@ -583,7 +583,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 }
 
 func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	numOfValidators := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))
 	validators := make([]*ethpb.Validator, numOfValidators)
 	_, keys, err := util.DeterministicDepositsAndKeys(numOfValidators)
@@ -602,7 +602,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 		require.NoError(t, st.SetSlot(5))
 		require.NoError(t, st.SetValidators(validators))
 
-		comm1, err := helpers.BeaconCommitteeFromState(t.Context(), st, 1 /*slot*/, 0 /*committeeIndex*/)
+		comm1, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1 /*slot*/, 0 /*committeeIndex*/)
 		require.NoError(t, err)
 		att1 := util.HydrateAttestation(&ethpb.Attestation{
 			AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
@@ -621,7 +621,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 		}
 		att1.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-		comm2, err := helpers.BeaconCommitteeFromState(t.Context(), st, 1 /*slot*/, 1 /*committeeIndex*/)
+		comm2, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1 /*slot*/, 1 /*committeeIndex*/)
 		require.NoError(t, err)
 		att2 := util.HydrateAttestation(&ethpb.Attestation{
 			AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
@@ -651,7 +651,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 		require.NoError(t, st.SetSlot(5))
 		require.NoError(t, st.SetValidators(validators))
 
-		comm1, err := helpers.BeaconCommitteeFromState(t.Context(), st, 1 /*slot*/, 0 /*committeeIndex*/)
+		comm1, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1 /*slot*/, 0 /*committeeIndex*/)
 		require.NoError(t, err)
 		commBits1 := primitives.NewAttestationCommitteeBits()
 		commBits1.SetBitAt(0, true)
@@ -673,7 +673,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 		}
 		att1.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-		comm2, err := helpers.BeaconCommitteeFromState(t.Context(), st, 1 /*slot*/, 1 /*committeeIndex*/)
+		comm2, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1 /*slot*/, 1 /*committeeIndex*/)
 		require.NoError(t, err)
 		commBits2 := primitives.NewAttestationCommitteeBits()
 		commBits2.SetBitAt(1, true)
@@ -702,7 +702,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 }
 
 func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 	numOfValidators := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))
 	validators := make([]*ethpb.Validator, numOfValidators)
 	_, keys, err := util.DeterministicDepositsAndKeys(numOfValidators)

beacon-chain/core/blocks/attester_slashing_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
@@ -62,7 +63,7 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
-	_, err = blocks.ProcessAttesterSlashings(t.Context(), beaconState, ss, v.SlashValidator)
+	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	assert.ErrorContains(t, "attestations are not slashable", err)
 }
 
@@ -101,7 +102,7 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
-	_, err = blocks.ProcessAttesterSlashings(t.Context(), beaconState, ss, v.SlashValidator)
+	_, err = blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	assert.ErrorContains(t, "validator indices count exceeds MAX_VALIDATORS_PER_COMMITTEE", err)
 }
 
@@ -243,7 +244,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 			currentSlot := 2 * params.BeaconConfig().SlotsPerEpoch
 			require.NoError(t, tc.st.SetSlot(currentSlot))
 
-			newState, err := blocks.ProcessAttesterSlashings(t.Context(), tc.st, []ethpb.AttSlashing{tc.slashing}, v.SlashValidator)
+			newState, err := blocks.ProcessAttesterSlashings(context.Background(), tc.st, []ethpb.AttSlashing{tc.slashing}, v.SlashValidator)
 			require.NoError(t, err)
 			newRegistry := newState.Validators()
 

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -1,6 +1,7 @@
 package blocks
 
 import (
+	"context"
 	"testing"
 
 	v "github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
@@ -10,14 +11,13 @@ import (
 	"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/fuzz"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
-	gofuzz "github.com/google/gofuzz"
+	fuzz "github.com/google/gofuzz"
 )
 
 func TestFuzzProcessAttestationNoVerify_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
-	ctx := t.Context()
+	fuzzer := fuzz.NewWithSeed(0)
+	ctx := context.Background()
 	state := &ethpb.BeaconState{}
 	att := &ethpb.Attestation{}
 
@@ -28,12 +28,11 @@ func TestFuzzProcessAttestationNoVerify_10000(t *testing.T) {
 		require.NoError(t, err)
 		_, err = ProcessAttestationNoVerifySignature(ctx, s, att)
 		_ = err
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessBlockHeader_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	block := &ethpb.SignedBeaconBlock{}
 
@@ -48,14 +47,13 @@ func TestFuzzProcessBlockHeader_10000(t *testing.T) {
 		}
 		wsb, err := blocks.NewSignedBeaconBlock(block)
 		require.NoError(t, err)
-		_, err = ProcessBlockHeader(t.Context(), s, wsb)
+		_, err = ProcessBlockHeader(context.Background(), s, wsb)
 		_ = err
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzverifyDepositDataSigningRoot_10000(_ *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	var ba []byte
 	var pubkey [fieldparams.BLSPubkeyLength]byte
 	var sig [96]byte
@@ -79,14 +77,14 @@ func TestFuzzverifyDepositDataSigningRoot_10000(_ *testing.T) {
 }
 
 func TestFuzzProcessEth1DataInBlock_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	e := &ethpb.Eth1Data{}
 	state, err := state_native.InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{})
 	require.NoError(t, err)
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(e)
-		s, err := ProcessEth1DataInBlock(t.Context(), state, e)
+		s, err := ProcessEth1DataInBlock(context.Background(), state, e)
 		if err != nil && s != nil {
 			t.Fatalf("state should be nil on err. found: %v on error: %v for state: %v and eth1data: %v", s, err, state, e)
 		}
@@ -94,7 +92,7 @@ func TestFuzzProcessEth1DataInBlock_10000(t *testing.T) {
 }
 
 func TestFuzzareEth1DataEqual_10000(_ *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	eth1data := &ethpb.Eth1Data{}
 	eth1data2 := &ethpb.Eth1Data{}
 
@@ -107,7 +105,7 @@ func TestFuzzareEth1DataEqual_10000(_ *testing.T) {
 }
 
 func TestFuzzEth1DataHasEnoughSupport_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	eth1data := &ethpb.Eth1Data{}
 	var stateVotes []*ethpb.Eth1Data
 	for i := 0; i < 100000; i++ {
@@ -124,7 +122,7 @@ func TestFuzzEth1DataHasEnoughSupport_10000(t *testing.T) {
 }
 
 func TestFuzzProcessBlockHeaderNoVerify_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	block := &ethpb.BeaconBlock{}
 
@@ -133,14 +131,13 @@ func TestFuzzProcessBlockHeaderNoVerify_10000(t *testing.T) {
 		fuzzer.Fuzz(block)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		_, err = ProcessBlockHeaderNoVerify(t.Context(), s, block.Slot, block.ProposerIndex, block.ParentRoot, []byte{})
+		_, err = ProcessBlockHeaderNoVerify(context.Background(), s, block.Slot, block.ProposerIndex, block.ParentRoot, []byte{})
 		_ = err
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessRandao_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	b := &ethpb.SignedBeaconBlock{}
 
@@ -154,16 +151,15 @@ func TestFuzzProcessRandao_10000(t *testing.T) {
 		}
 		wsb, err := blocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
-		r, err := ProcessRandao(t.Context(), s, wsb)
+		r, err := ProcessRandao(context.Background(), s, wsb)
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessRandaoNoVerify_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	blockBody := &ethpb.BeaconBlockBody{}
 
@@ -176,15 +172,14 @@ func TestFuzzProcessRandaoNoVerify_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, blockBody)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessProposerSlashings_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	p := &ethpb.ProposerSlashing{}
-	ctx := t.Context()
+	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(p)
@@ -194,12 +189,11 @@ func TestFuzzProcessProposerSlashings_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and slashing: %v", r, err, state, p)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzVerifyProposerSlashing_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	proposerSlashing := &ethpb.ProposerSlashing{}
 	for i := 0; i < 10000; i++ {
@@ -209,15 +203,14 @@ func TestFuzzVerifyProposerSlashing_10000(t *testing.T) {
 		require.NoError(t, err)
 		err = VerifyProposerSlashing(s, proposerSlashing)
 		_ = err
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessAttesterSlashings_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	a := &ethpb.AttesterSlashing{}
-	ctx := t.Context()
+	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(a)
@@ -227,15 +220,14 @@ func TestFuzzProcessAttesterSlashings_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and slashing: %v", r, err, state, a)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzVerifyAttesterSlashing_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	attesterSlashing := &ethpb.AttesterSlashing{}
-	ctx := t.Context()
+	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(attesterSlashing)
@@ -243,12 +235,11 @@ func TestFuzzVerifyAttesterSlashing_10000(t *testing.T) {
 		require.NoError(t, err)
 		err = VerifyAttesterSlashing(ctx, s, attesterSlashing)
 		_ = err
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzIsSlashableAttestationData_10000(_ *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	attestationData := &ethpb.AttestationData{}
 	attestationData2 := &ethpb.AttestationData{}
 
@@ -260,7 +251,7 @@ func TestFuzzIsSlashableAttestationData_10000(_ *testing.T) {
 }
 
 func TestFuzzslashableAttesterIndices_10000(_ *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	attesterSlashing := &ethpb.AttesterSlashing{}
 
 	for i := 0; i < 10000; i++ {
@@ -270,10 +261,10 @@ func TestFuzzslashableAttesterIndices_10000(_ *testing.T) {
 }
 
 func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	b := &ethpb.SignedBeaconBlock{}
-	ctx := t.Context()
+	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(b)
@@ -288,15 +279,14 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzVerifyIndexedAttestationn_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	idxAttestation := &ethpb.IndexedAttestation{}
-	ctx := t.Context()
+	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(idxAttestation)
@@ -304,12 +294,11 @@ func TestFuzzVerifyIndexedAttestationn_10000(t *testing.T) {
 		require.NoError(t, err)
 		err = VerifyIndexedAttestation(ctx, s, idxAttestation)
 		_ = err
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzverifyDeposit_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	deposit := &ethpb.Deposit{}
 	for i := 0; i < 10000; i++ {
@@ -323,10 +312,10 @@ func TestFuzzverifyDeposit_10000(t *testing.T) {
 }
 
 func TestFuzzProcessVoluntaryExits_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	e := &ethpb.SignedVoluntaryExit{}
-	ctx := t.Context()
+	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(e)
@@ -336,12 +325,11 @@ func TestFuzzProcessVoluntaryExits_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and exit: %v", r, err, state, e)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessVoluntaryExitsNoVerify_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	e := &ethpb.SignedVoluntaryExit{}
 	for i := 0; i < 10000; i++ {
@@ -349,16 +337,15 @@ func TestFuzzProcessVoluntaryExitsNoVerify_10000(t *testing.T) {
 		fuzzer.Fuzz(e)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		r, err := ProcessVoluntaryExits(t.Context(), s, []*ethpb.SignedVoluntaryExit{e})
+		r, err := ProcessVoluntaryExits(context.Background(), s, []*ethpb.SignedVoluntaryExit{e})
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, e)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzVerifyExit_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	ve := &ethpb.SignedVoluntaryExit{}
 	rawVal := &ethpb.Validator{}
 	fork := &ethpb.Fork{}

beacon-chain/core/blocks/block_regression_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
@@ -94,7 +95,7 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
-	newState, err := blocks.ProcessAttesterSlashings(t.Context(), beaconState, ss, v.SlashValidator)
+	newState, err := blocks.ProcessAttesterSlashings(context.Background(), beaconState, ss, v.SlashValidator)
 	require.NoError(t, err)
 	newRegistry := newState.Validators()
 	if !newRegistry[expectedSlashedVal].Slashed {

beacon-chain/core/blocks/deposit_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
@@ -45,7 +46,7 @@ func TestBatchVerifyDepositsSignatures_Ok(t *testing.T) {
 
 	deposit.Proof = proof
 	require.NoError(t, err)
-	verified, err := blocks.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
+	verified, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
 	require.NoError(t, err)
 	require.Equal(t, true, verified)
 }
@@ -68,7 +69,7 @@ func TestBatchVerifyDepositsSignatures_InvalidSignature(t *testing.T) {
 
 	deposit.Proof = proof
 	require.NoError(t, err)
-	verified, err := blocks.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
+	verified, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
 	require.NoError(t, err)
 	require.Equal(t, false, verified)
 }
@@ -163,7 +164,7 @@ func TestBatchVerifyPendingDepositsSignatures_Ok(t *testing.T) {
 	sig2 := sk2.Sign(sr2[:])
 	pendingDeposit2.Signature = sig2.Marshal()
 
-	verified, err := blocks.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit, pendingDeposit2})
+	verified, err := blocks.BatchVerifyPendingDepositsSignatures(context.Background(), []*ethpb.PendingDeposit{pendingDeposit, pendingDeposit2})
 	require.NoError(t, err)
 	require.Equal(t, true, verified)
 }
@@ -174,7 +175,7 @@ func TestBatchVerifyPendingDepositsSignatures_InvalidSignature(t *testing.T) {
 		WithdrawalCredentials: make([]byte, 32),
 		Signature:             make([]byte, 96),
 	}
-	verified, err := blocks.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit})
+	verified, err := blocks.BatchVerifyPendingDepositsSignatures(context.Background(), []*ethpb.PendingDeposit{pendingDeposit})
 	require.NoError(t, err)
 	require.Equal(t, false, verified)
 }

beacon-chain/core/blocks/eth1_data_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"context"
 	"fmt"
 	"testing"
 
@@ -176,7 +177,7 @@ func TestProcessEth1Data_SetsCorrectly(t *testing.T) {
 
 	period := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().EpochsPerEth1VotingPeriod)))
 	for i := uint64(0); i < period; i++ {
-		processedState, err := blocks.ProcessEth1DataInBlock(t.Context(), beaconState, b.Block.Body.Eth1Data)
+		processedState, err := blocks.ProcessEth1DataInBlock(context.Background(), beaconState, b.Block.Body.Eth1Data)
 		require.NoError(t, err)
 		require.Equal(t, true, processedState.Version() == version.Phase0)
 	}

beacon-chain/core/blocks/exit_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
@@ -46,7 +47,7 @@ func TestProcessVoluntaryExits_NotActiveLongEnoughToExit(t *testing.T) {
 	}
 
 	want := "validator has not been active long enough to exit"
-	_, err = blocks.ProcessVoluntaryExits(t.Context(), state, b.Block.Body.VoluntaryExits)
+	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b.Block.Body.VoluntaryExits)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -76,7 +77,7 @@ func TestProcessVoluntaryExits_ExitAlreadySubmitted(t *testing.T) {
 	}
 
 	want := "validator with index 0 has already submitted an exit, which will take place at epoch: 10"
-	_, err = blocks.ProcessVoluntaryExits(t.Context(), state, b.Block.Body.VoluntaryExits)
+	_, err = blocks.ProcessVoluntaryExits(context.Background(), state, b.Block.Body.VoluntaryExits)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -124,7 +125,7 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 		},
 	}
 
-	newState, err := blocks.ProcessVoluntaryExits(t.Context(), state, b.Block.Body.VoluntaryExits)
+	newState, err := blocks.ProcessVoluntaryExits(context.Background(), state, b.Block.Body.VoluntaryExits)
 	require.NoError(t, err, "Could not process exits")
 	newRegistry := newState.Validators()
 	if newRegistry[0].ExitEpoch != helpers.ActivationExitEpoch(primitives.Epoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch)) {

beacon-chain/core/blocks/header_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"context"
 	"io"
 	"testing"
 
@@ -50,7 +51,7 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	currentEpoch := time.CurrentEpoch(state)
 	priv, err := bls.RandKey()
 	require.NoError(t, err)
-	pID, err := helpers.BeaconProposerIndex(t.Context(), state)
+	pID, err := helpers.BeaconProposerIndex(context.Background(), state)
 	require.NoError(t, err)
 	block := util.NewBeaconBlock()
 	block.Block.ProposerIndex = pID
@@ -60,7 +61,7 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	block.Signature, err = signing.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), state)
+	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), state)
 	require.NoError(t, err)
 	validators[proposerIdx].Slashed = false
 	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
@@ -69,7 +70,7 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 
 	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(t.Context(), state, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	assert.ErrorContains(t, "block.Slot 10 must be greater than state.LatestBlockHeader.Slot 10", err)
 }
 
@@ -84,7 +85,7 @@ func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
 	lbhdr, err := beaconState.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
 
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), beaconState)
+	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), beaconState)
 	require.NoError(t, err)
 
 	block := util.NewBeaconBlock()
@@ -97,7 +98,7 @@ func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
 
 	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(t.Context(), beaconState, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), beaconState, wsb)
 	want := "signature did not verify"
 	assert.ErrorContains(t, want, err)
 }
@@ -141,7 +142,7 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 
 	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(t.Context(), state, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	want := "is different than block slot"
 	assert.ErrorContains(t, want, err)
 }
@@ -171,7 +172,7 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 	blockSig, err := signing.ComputeDomainAndSign(state, currentEpoch, &sszBytes, params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
 	validators[5896].PublicKey = priv.PublicKey().Marshal()
-	pID, err := helpers.BeaconProposerIndex(t.Context(), state)
+	pID, err := helpers.BeaconProposerIndex(context.Background(), state)
 	require.NoError(t, err)
 	block := util.NewBeaconBlock()
 	block.Block.Slot = 10
@@ -182,7 +183,7 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 
 	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(t.Context(), state, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	want := "does not match"
 	assert.ErrorContains(t, want, err)
 }
@@ -215,7 +216,7 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 	require.NoError(t, err)
 
 	validators[12683].PublicKey = priv.PublicKey().Marshal()
-	pID, err := helpers.BeaconProposerIndex(t.Context(), state)
+	pID, err := helpers.BeaconProposerIndex(context.Background(), state)
 	require.NoError(t, err)
 	block := util.NewBeaconBlock()
 	block.Block.Slot = 10
@@ -226,7 +227,7 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 
 	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(t.Context(), state, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	want := "was previously slashed"
 	assert.ErrorContains(t, want, err)
 }
@@ -256,7 +257,7 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	currentEpoch := time.CurrentEpoch(state)
 	priv, err := bls.RandKey()
 	require.NoError(t, err)
-	pID, err := helpers.BeaconProposerIndex(t.Context(), state)
+	pID, err := helpers.BeaconProposerIndex(context.Background(), state)
 	require.NoError(t, err)
 	block := util.NewBeaconBlock()
 	block.Block.ProposerIndex = pID
@@ -268,7 +269,7 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	bodyRoot, err := block.Block.Body.HashTreeRoot()
 	require.NoError(t, err, "Failed to hash block bytes got")
 
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), state)
+	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), state)
 	require.NoError(t, err)
 	validators[proposerIdx].Slashed = false
 	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
@@ -277,7 +278,7 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 
 	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	newState, err := blocks.ProcessBlockHeader(t.Context(), state, wsb)
+	newState, err := blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	require.NoError(t, err, "Failed to process block header got")
 	var zeroHash [32]byte
 	nsh := newState.LatestBlockHeader()
@@ -317,7 +318,7 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 	currentEpoch := time.CurrentEpoch(state)
 	priv, err := bls.RandKey()
 	require.NoError(t, err)
-	pID, err := helpers.BeaconProposerIndex(t.Context(), state)
+	pID, err := helpers.BeaconProposerIndex(context.Background(), state)
 	require.NoError(t, err)
 	block := util.NewBeaconBlock()
 	block.Block.Slot = 10
@@ -326,7 +327,7 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 	block.Block.ParentRoot = latestBlockSignedRoot[:]
 	block.Signature, err = signing.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
 	require.NoError(t, err)
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), state)
+	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), state)
 	require.NoError(t, err)
 	validators[proposerIdx].Slashed = false
 	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"context"
 	"fmt"
 	"testing"
 
@@ -50,7 +51,7 @@ func TestProcessProposerSlashings_UnmatchedHeaderSlots(t *testing.T) {
 		},
 	}
 	want := "mismatched header slots"
-	_, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, b.Block.Body.ProposerSlashings, v.SlashValidator)
+	_, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, b.Block.Body.ProposerSlashings, v.SlashValidator)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -83,7 +84,7 @@ func TestProcessProposerSlashings_SameHeaders(t *testing.T) {
 		},
 	}
 	want := "expected slashing headers to differ"
-	_, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, b.Block.Body.ProposerSlashings, v.SlashValidator)
+	_, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, b.Block.Body.ProposerSlashings, v.SlashValidator)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -133,7 +134,7 @@ func TestProcessProposerSlashings_ValidatorNotSlashable(t *testing.T) {
 		"validator with key %#x is not slashable",
 		bytesutil.ToBytes48(beaconState.Validators()[0].PublicKey),
 	)
-	_, err = blocks.ProcessProposerSlashings(t.Context(), beaconState, b.Block.Body.ProposerSlashings, v.SlashValidator)
+	_, err = blocks.ProcessProposerSlashings(context.Background(), beaconState, b.Block.Body.ProposerSlashings, v.SlashValidator)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -172,7 +173,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 	block := util.NewBeaconBlock()
 	block.Block.Body.ProposerSlashings = slashings
 
-	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
+	newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
 	require.NoError(t, err)
 
 	newStateVals := newState.Validators()
@@ -220,7 +221,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 	block := util.NewBeaconBlock()
 	block.Block.Body.ProposerSlashings = slashings
 
-	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
+	newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
 	require.NoError(t, err)
 
 	newStateVals := newState.Validators()
@@ -268,7 +269,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 	block := util.NewBeaconBlock()
 	block.Block.Body.ProposerSlashings = slashings
 
-	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
+	newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
 	require.NoError(t, err)
 
 	newStateVals := newState.Validators()
@@ -316,7 +317,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatusCapella(t *testing.T) {
 	block := util.NewBeaconBlock()
 	block.Block.Body.ProposerSlashings = slashings
 
-	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
+	newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
 	require.NoError(t, err)
 
 	newStateVals := newState.Validators()

beacon-chain/core/blocks/randao_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"context"
 	"encoding/binary"
 	"testing"
 
@@ -20,7 +21,7 @@ import (
 func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisState(t, 100)
 	// We fetch the proposer's index as that is whom the RANDAO will be verified against.
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), beaconState)
+	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), beaconState)
 	require.NoError(t, err)
 	epoch := primitives.Epoch(0)
 	buf := make([]byte, 32)
@@ -41,7 +42,7 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	want := "block randao: signature did not verify"
 	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	_, err = blocks.ProcessRandao(t.Context(), beaconState, wsb)
+	_, err = blocks.ProcessRandao(context.Background(), beaconState, wsb)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -61,7 +62,7 @@ func TestProcessRandao_SignatureVerifiesAndUpdatesLatestStateMixes(t *testing.T)
 	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
 	newState, err := blocks.ProcessRandao(
-		t.Context(),
+		context.Background(),
 		beaconState,
 		wsb,
 	)
@@ -84,7 +85,7 @@ func TestRandaoSignatureSet_OK(t *testing.T) {
 		},
 	}
 
-	set, err := blocks.RandaoSignatureBatch(t.Context(), beaconState, block.Body.RandaoReveal)
+	set, err := blocks.RandaoSignatureBatch(context.Background(), beaconState, block.Body.RandaoReveal)
 	require.NoError(t, err)
 	verified, err := set.Verify()
 	require.NoError(t, err)

beacon-chain/core/blocks/signature.go

@@ -96,6 +96,24 @@ func VerifyBlockHeaderSignature(beaconState state.BeaconState, header *ethpb.Sig
 	return signing.VerifyBlockHeaderSigningRoot(header.Header, proposerPubKey, header.Signature, domain)
 }
 
+func VerifyBlockHeaderSignatureUsingCurrentFork(beaconState state.BeaconState, header *ethpb.SignedBeaconBlockHeader) error {
+	currentEpoch := slots.ToEpoch(header.Header.Slot)
+	fork, err := forks.Fork(currentEpoch)
+	if err != nil {
+		return err
+	}
+	domain, err := signing.Domain(fork, currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
+	if err != nil {
+		return err
+	}
+	proposer, err := beaconState.ValidatorAtIndex(header.Header.ProposerIndex)
+	if err != nil {
+		return err
+	}
+	proposerPubKey := proposer.PublicKey
+	return signing.VerifyBlockHeaderSigningRoot(header.Header, proposerPubKey, header.Signature, domain)
+}
+
 // VerifyBlockSignatureUsingCurrentFork verifies the proposer signature of a beacon block. This differs
 // from the above method by not using fork data from the state and instead retrieving it
 // via the respective epoch.
@@ -200,7 +218,7 @@ func createAttestationSignatureBatch(
 		if err != nil {
 			return nil, err
 		}
-		if err := attestation.IsValidAttestationIndices(ctx, ia, params.BeaconConfig().MaxValidatorsPerCommittee, params.BeaconConfig().MaxCommitteesPerSlot); err != nil {
+		if err := attestation.IsValidAttestationIndices(ctx, ia); err != nil {
 			return nil, err
 		}
 		indices := ia.GetAttestingIndices()

beacon-chain/core/electra/BUILD.bazel

@@ -85,7 +85,6 @@ go_test(
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
-        "//testing/fuzz:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",

beacon-chain/core/electra/deposit_fuzz_test.go

@@ -1,21 +1,21 @@
 package electra_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"
 	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/fuzz"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
-	gofuzz "github.com/google/gofuzz"
+	fuzz "github.com/google/gofuzz"
 )
 
 func TestFuzzProcessDeposits_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconStateElectra{}
 	deposits := make([]*ethpb.Deposit, 100)
-	ctx := t.Context()
+	ctx := context.Background()
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		for i := range deposits {
@@ -27,12 +27,11 @@ func TestFuzzProcessDeposits_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposits)
 		}
-		fuzz.FreeMemory(i)
 	}
 }
 
 func TestFuzzProcessDeposit_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	state := &ethpb.BeaconStateElectra{}
 	deposit := &ethpb.Deposit{}
 
@@ -45,6 +44,5 @@ func TestFuzzProcessDeposit_10000(t *testing.T) {
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, deposit)
 		}
-		fuzz.FreeMemory(i)
 	}
 }

beacon-chain/core/electra/deposits_test.go

@@ -319,7 +319,7 @@ func TestBatchProcessNewPendingDeposits(t *testing.T) {
 		validDep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
 		invalidDep := &eth.PendingDeposit{PublicKey: make([]byte, 48)}
 		deps := []*eth.PendingDeposit{validDep, invalidDep}
-		require.NoError(t, electra.BatchProcessNewPendingDeposits(t.Context(), st, deps))
+		require.NoError(t, electra.BatchProcessNewPendingDeposits(context.Background(), st, deps))
 		require.Equal(t, 1, len(st.Validators()))
 		require.Equal(t, 1, len(st.Balances()))
 	})
@@ -335,7 +335,7 @@ func TestBatchProcessNewPendingDeposits(t *testing.T) {
 		wc[31] = byte(0)
 		validDep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
 		deps := []*eth.PendingDeposit{validDep, validDep}
-		require.NoError(t, electra.BatchProcessNewPendingDeposits(t.Context(), st, deps))
+		require.NoError(t, electra.BatchProcessNewPendingDeposits(context.Background(), st, deps))
 		require.Equal(t, 1, len(st.Validators()))
 		require.Equal(t, 1, len(st.Balances()))
 		require.Equal(t, params.BeaconConfig().MinActivationBalance*2, st.Balances()[0])
@@ -354,7 +354,7 @@ func TestBatchProcessNewPendingDeposits(t *testing.T) {
 		invalidSigDep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
 		invalidSigDep.Signature = make([]byte, 96)
 		deps := []*eth.PendingDeposit{validDep, invalidSigDep}
-		require.NoError(t, electra.BatchProcessNewPendingDeposits(t.Context(), st, deps))
+		require.NoError(t, electra.BatchProcessNewPendingDeposits(context.Background(), st, deps))
 		require.Equal(t, 1, len(st.Validators()))
 		require.Equal(t, 1, len(st.Balances()))
 		require.Equal(t, 2*params.BeaconConfig().MinActivationBalance, st.Balances()[0])
@@ -368,12 +368,12 @@ func TestProcessDepositRequests(t *testing.T) {
 	require.NoError(t, st.SetDepositRequestsStartIndex(1))
 
 	t.Run("empty requests continues", func(t *testing.T) {
-		newSt, err := electra.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{})
+		newSt, err := electra.ProcessDepositRequests(context.Background(), st, []*enginev1.DepositRequest{})
 		require.NoError(t, err)
 		require.DeepEqual(t, newSt, st)
 	})
 	t.Run("nil request errors", func(t *testing.T) {
-		_, err = electra.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{nil})
+		_, err = electra.ProcessDepositRequests(context.Background(), st, []*enginev1.DepositRequest{nil})
 		require.ErrorContains(t, "nil deposit request", err)
 	})
 
@@ -406,7 +406,7 @@ func TestProcessDepositRequests(t *testing.T) {
 			Signature:             sig.Marshal(),
 		},
 	}
-	st, err = electra.ProcessDepositRequests(t.Context(), st, requests)
+	st, err = electra.ProcessDepositRequests(context.Background(), st, requests)
 	require.NoError(t, err)
 
 	pbd, err := st.PendingDeposits()
@@ -437,7 +437,7 @@ func TestProcessDeposit_Electra_Simple(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	pdSt, err := electra.ProcessDeposits(t.Context(), st, deps)
+	pdSt, err := electra.ProcessDeposits(context.Background(), st, deps)
 	require.NoError(t, err)
 	pbd, err := pdSt.PendingDeposits()
 	require.NoError(t, err)
@@ -592,7 +592,7 @@ func TestApplyPendingDeposit_TopUp(t *testing.T) {
 	dep := stateTesting.GeneratePendingDeposit(t, sk, excessBalance, bytesutil.ToBytes32(wc), 0)
 	require.NoError(t, st.SetValidators(validators))
 
-	require.NoError(t, electra.ApplyPendingDeposit(t.Context(), st, dep))
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep))
 
 	b, err := st.BalanceAtIndex(0)
 	require.NoError(t, err)
@@ -608,7 +608,7 @@ func TestApplyPendingDeposit_UnknownKey(t *testing.T) {
 	wc[31] = byte(0)
 	dep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
 	require.Equal(t, 0, len(st.Validators()))
-	require.NoError(t, electra.ApplyPendingDeposit(t.Context(), st, dep))
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep))
 	// activates new validator
 	require.Equal(t, 1, len(st.Validators()))
 	b, err := st.BalanceAtIndex(0)
@@ -630,7 +630,7 @@ func TestApplyPendingDeposit_InvalidSignature(t *testing.T) {
 		Amount:                100,
 	}
 	require.Equal(t, 0, len(st.Validators()))
-	require.NoError(t, electra.ApplyPendingDeposit(t.Context(), st, dep))
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep))
 	// no validator added
 	require.Equal(t, 0, len(st.Validators()))
 	// no topup either

beacon-chain/core/electra/transition_no_verify_sig_test.go

@@ -1,6 +1,7 @@
 package electra_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"
@@ -53,7 +54,7 @@ func TestProcessOperationsWithNilRequests(t *testing.T) {
 
 			require.NoError(t, st.SetSlot(1))
 
-			_, err = electra.ProcessOperations(t.Context(), st, b.Block())
+			_, err = electra.ProcessOperations(context.Background(), st, b.Block())
 			require.ErrorContains(t, tc.errMsg, err)
 		})
 	}

beacon-chain/core/electra/transition_test.go

@@ -1,6 +1,7 @@
 package electra_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"
@@ -77,7 +78,7 @@ func TestProcessEpoch_CanProcessElectra(t *testing.T) {
 			TargetIndex: 1,
 		},
 	}))
-	err := electra.ProcessEpoch(t.Context(), st)
+	err := electra.ProcessEpoch(context.Background(), st)
 	require.NoError(t, err)
 	require.Equal(t, uint64(0), st.Slashings()[2], "Unexpected slashed balance")
 

beacon-chain/core/electra/withdrawals_test.go

@@ -1,6 +1,7 @@
 package electra_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"
@@ -289,7 +290,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 
-			got, err := electra.ProcessWithdrawalRequests(t.Context(), tt.args.st, tt.args.wrs)
+			got, err := electra.ProcessWithdrawalRequests(context.Background(), tt.args.st, tt.args.wrs)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
 				return

beacon-chain/core/epoch/BUILD.bazel

@@ -48,7 +48,6 @@ go_test(
         "//consensus-types/primitives:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
-        "//testing/fuzz:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_google_go_cmp//cmp:go_default_library",

beacon-chain/core/epoch/epoch_processing_fuzz_test.go

@@ -5,13 +5,12 @@ import (
 
 	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/fuzz"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
-	gofuzz "github.com/google/gofuzz"
+	fuzz "github.com/google/gofuzz"
 )
 
 func TestFuzzFinalUpdates_10000(t *testing.T) {
-	fuzzer := gofuzz.NewWithSeed(0)
+	fuzzer := fuzz.NewWithSeed(0)
 	base := &ethpb.BeaconState{}
 
 	for i := 0; i < 10000; i++ {
@@ -20,6 +19,5 @@ func TestFuzzFinalUpdates_10000(t *testing.T) {
 		require.NoError(t, err)
 		_, err = ProcessFinalUpdates(s)
 		_ = err
-		fuzz.FreeMemory(i)
 	}
 }

beacon-chain/core/epoch/epoch_processing_test.go

@@ -1,6 +1,7 @@
 package epoch_test
 
 import (
+	"context"
 	"fmt"
 	"math"
 	"testing"
@@ -169,7 +170,7 @@ func TestProcessRegistryUpdates_NoRotation(t *testing.T) {
 	}
 	beaconState, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	newState, err := epoch.ProcessRegistryUpdates(t.Context(), beaconState)
+	newState, err := epoch.ProcessRegistryUpdates(context.Background(), beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, params.BeaconConfig().MaxSeedLookahead, validator.ExitEpoch, "Could not update registry %d", i)
@@ -193,7 +194,7 @@ func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
 	beaconState, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
 	currentEpoch := time.CurrentEpoch(beaconState)
-	newState, err := epoch.ProcessRegistryUpdates(t.Context(), beaconState)
+	newState, err := epoch.ProcessRegistryUpdates(context.Background(), beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		if uint64(i) < limit && validator.ActivationEpoch != helpers.ActivationExitEpoch(currentEpoch) {
@@ -228,7 +229,7 @@ func TestProcessRegistryUpdates_EligibleToActivate_Cancun(t *testing.T) {
 	beaconState, err := state_native.InitializeFromProtoDeneb(base)
 	require.NoError(t, err)
 	currentEpoch := time.CurrentEpoch(beaconState)
-	newState, err := epoch.ProcessRegistryUpdates(t.Context(), beaconState)
+	newState, err := epoch.ProcessRegistryUpdates(context.Background(), beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		// Note: In Deneb, only validators indices before `MaxPerEpochActivationChurnLimit` should be activated.
@@ -256,7 +257,7 @@ func TestProcessRegistryUpdates_ActivationCompletes(t *testing.T) {
 	}
 	beaconState, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	newState, err := epoch.ProcessRegistryUpdates(t.Context(), beaconState)
+	newState, err := epoch.ProcessRegistryUpdates(context.Background(), beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, params.BeaconConfig().MaxSeedLookahead, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
@@ -280,7 +281,7 @@ func TestProcessRegistryUpdates_ValidatorsEjected(t *testing.T) {
 	}
 	beaconState, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	newState, err := epoch.ProcessRegistryUpdates(t.Context(), beaconState)
+	newState, err := epoch.ProcessRegistryUpdates(context.Background(), beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, params.BeaconConfig().MaxSeedLookahead+1, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
@@ -305,7 +306,7 @@ func TestProcessRegistryUpdates_CanExits(t *testing.T) {
 	}
 	beaconState, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	newState, err := epoch.ProcessRegistryUpdates(t.Context(), beaconState)
+	newState, err := epoch.ProcessRegistryUpdates(context.Background(), beaconState)
 	require.NoError(t, err)
 	for i, validator := range newState.Validators() {
 		assert.Equal(t, exitEpoch, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
@@ -385,7 +386,7 @@ func TestProcessHistoricalDataUpdate(t *testing.T) {
 			name: "before capella can process and get historical root",
 			st: func() state.BeaconState {
 				st, _ := util.DeterministicGenesisState(t, 1)
-				st, err := transition.ProcessSlots(t.Context(), st, params.BeaconConfig().SlotsPerHistoricalRoot-1)
+				st, err := transition.ProcessSlots(context.Background(), st, params.BeaconConfig().SlotsPerHistoricalRoot-1)
 				require.NoError(t, err)
 				return st
 			},
@@ -409,7 +410,7 @@ func TestProcessHistoricalDataUpdate(t *testing.T) {
 			name: "after capella can process and get historical summary",
 			st: func() state.BeaconState {
 				st, _ := util.DeterministicGenesisStateCapella(t, 1)
-				st, err := transition.ProcessSlots(t.Context(), st, params.BeaconConfig().SlotsPerHistoricalRoot-1)
+				st, err := transition.ProcessSlots(context.Background(), st, params.BeaconConfig().SlotsPerHistoricalRoot-1)
 				require.NoError(t, err)
 				return st
 			},

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

@@ -1,6 +1,7 @@
 package precompute_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epoch/precompute"
@@ -205,10 +206,10 @@ func TestProcessAttestations(t *testing.T) {
 	for i := 0; i < len(pVals); i++ {
 		pVals[i] = &precompute.Validator{CurrentEpochEffectiveBalance: 100}
 	}
-	pVals, _, err = precompute.ProcessAttestations(t.Context(), beaconState, pVals, &precompute.Balance{})
+	pVals, _, err = precompute.ProcessAttestations(context.Background(), beaconState, pVals, &precompute.Balance{})
 	require.NoError(t, err)
 
-	committee, err := helpers.BeaconCommitteeFromState(t.Context(), beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
+	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
 	require.NoError(t, err)
 	indices, err := attestation.AttestingIndices(att1, committee)
 	require.NoError(t, err)
@@ -217,7 +218,7 @@ func TestProcessAttestations(t *testing.T) {
 			t.Error("Not a prev epoch attester")
 		}
 	}
-	committee, err = helpers.BeaconCommitteeFromState(t.Context(), beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
+	committee, err = helpers.BeaconCommitteeFromState(context.Background(), beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
 	require.NoError(t, err)
 	indices, err = attestation.AttestingIndices(att2, committee)
 	require.NoError(t, err)

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

@@ -1,6 +1,7 @@
 package precompute_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
@@ -238,7 +239,7 @@ func TestUnrealizedCheckpoints(t *testing.T) {
 			state, err := state_native.InitializeFromProtoAltair(base)
 			require.NoError(t, err)
 
-			_, _, err = altair.InitializePrecomputeValidators(t.Context(), state)
+			_, _, err = altair.InitializePrecomputeValidators(context.Background(), state)
 			require.NoError(t, err)
 
 			jc, fc, err := precompute.UnrealizedCheckpoints(state)

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

@@ -1,6 +1,7 @@
 package precompute_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epoch/precompute"
@@ -28,7 +29,7 @@ func TestNew(t *testing.T) {
 	})
 	require.NoError(t, err)
 	e := params.BeaconConfig().FarFutureSlot
-	v, b, err := precompute.New(t.Context(), s)
+	v, b, err := precompute.New(context.Background(), s)
 	require.NoError(t, err)
 	assert.DeepEqual(t, &precompute.Validator{
 		IsSlashed:                    true,

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

@@ -1,6 +1,7 @@
 package precompute
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
@@ -39,9 +40,9 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
 	beaconState, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
 
-	vp, bp, err := New(t.Context(), beaconState)
+	vp, bp, err := New(context.Background(), beaconState)
 	require.NoError(t, err)
-	vp, bp, err = ProcessAttestations(t.Context(), beaconState, vp, bp)
+	vp, bp, err = ProcessAttestations(context.Background(), beaconState, vp, bp)
 	require.NoError(t, err)
 
 	processedState, err := ProcessRewardsAndPenaltiesPrecompute(beaconState, bp, vp, AttestationsDelta, ProposersDelta)
@@ -82,9 +83,9 @@ func TestAttestationDeltas_ZeroEpoch(t *testing.T) {
 	beaconState, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
 
-	pVals, pBal, err := New(t.Context(), beaconState)
+	pVals, pBal, err := New(context.Background(), beaconState)
 	assert.NoError(t, err)
-	pVals, pBal, err = ProcessAttestations(t.Context(), beaconState, pVals, pBal)
+	pVals, pBal, err = ProcessAttestations(context.Background(), beaconState, pVals, pBal)
 	require.NoError(t, err)
 
 	pBal.ActiveCurrentEpoch = 0 // Could cause a divide by zero panic.
@@ -120,9 +121,9 @@ func TestAttestationDeltas_ZeroInclusionDelay(t *testing.T) {
 	beaconState, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
 
-	pVals, pBal, err := New(t.Context(), beaconState)
+	pVals, pBal, err := New(context.Background(), beaconState)
 	require.NoError(t, err)
-	_, _, err = ProcessAttestations(t.Context(), beaconState, pVals, pBal)
+	_, _, err = ProcessAttestations(context.Background(), beaconState, pVals, pBal)
 	require.ErrorContains(t, "attestation with inclusion delay of 0", err)
 }
 
@@ -154,9 +155,9 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
 		require.NoError(t, beaconState.SetValidators(vs))
 	}
 
-	vp, bp, err := New(t.Context(), beaconState)
+	vp, bp, err := New(context.Background(), beaconState)
 	require.NoError(t, err)
-	vp, bp, err = ProcessAttestations(t.Context(), beaconState, vp, bp)
+	vp, bp, err = ProcessAttestations(context.Background(), beaconState, vp, bp)
 	require.NoError(t, err)
 	rewards, penalties, err := AttestationsDelta(beaconState, bp, vp)
 	require.NoError(t, err)

beacon-chain/core/feed/operation/BUILD.bazel

@@ -12,7 +12,6 @@ go_library(
         "//async/event: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/core/feed/operation/events.go

@@ -4,7 +4,6 @@ package operation
 import (
 	"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"
 )
 
@@ -43,9 +42,6 @@ const (
 
 	// BlockGossipReceived is sent after a block has been received from gossip or API that passes validation rules.
 	BlockGossipReceived = 11
-
-	// DataColumnReceived is sent after a data column has been seen after gossip validation rules.
-	DataColumnReceived = 12
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -107,10 +103,3 @@ type BlockGossipReceivedData struct {
 	// SignedBlock is the block that was received.
 	SignedBlock interfaces.ReadOnlySignedBeaconBlock
 }
-
-type DataColumnReceivedData struct {
-	Slot           primitives.Slot
-	Index          uint64
-	BlockRoot      [32]byte
-	KzgCommitments [][]byte
-}

beacon-chain/core/fulu/transition_test.go

@@ -1,6 +1,7 @@
 package fulu_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/fulu"
@@ -12,11 +13,11 @@ import (
 func TestProcessEpoch_CanProcessFulu(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch))
-	st, err := fulu.UpgradeToFulu(t.Context(), st)
+	st, err := fulu.UpgradeToFulu(context.Background(), st)
 	require.NoError(t, err)
 	preLookahead, err := st.ProposerLookahead()
 	require.NoError(t, err)
-	err = fulu.ProcessEpoch(t.Context(), st)
+	err = fulu.ProcessEpoch(context.Background(), st)
 	require.NoError(t, err)
 	postLookahead, err := st.ProposerLookahead()
 	require.NoError(t, err)

beacon-chain/core/helpers/attestation_test.go

@@ -1,6 +1,7 @@
 package helpers_test
 
 import (
+	"context"
 	"strconv"
 	"testing"
 	"time"
@@ -22,7 +23,7 @@ func TestAttestation_IsAggregator(t *testing.T) {
 		helpers.ClearCache()
 
 		beaconState, privKeys := util.DeterministicGenesisState(t, 100)
-		committee, err := helpers.BeaconCommitteeFromState(t.Context(), beaconState, 0, 0)
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, 0, 0)
 		require.NoError(t, err)
 		sig := privKeys[0].Sign([]byte{'A'})
 		agg, err := helpers.IsAggregator(uint64(len(committee)), sig.Marshal())
@@ -37,7 +38,7 @@ func TestAttestation_IsAggregator(t *testing.T) {
 		params.OverrideBeaconConfig(params.MinimalSpecConfig())
 		beaconState, privKeys := util.DeterministicGenesisState(t, 2048)
 
-		committee, err := helpers.BeaconCommitteeFromState(t.Context(), beaconState, 0, 0)
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, 0, 0)
 		require.NoError(t, err)
 		sig := privKeys[0].Sign([]byte{'A'})
 		agg, err := helpers.IsAggregator(uint64(len(committee)), sig.Marshal())
@@ -72,7 +73,7 @@ func TestAttestation_ComputeSubnetForAttestation(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	valCount, err := helpers.ActiveValidatorCount(t.Context(), state, slots.ToEpoch(34))
+	valCount, err := helpers.ActiveValidatorCount(context.Background(), state, slots.ToEpoch(34))
 	require.NoError(t, err)
 
 	t.Run("Phase 0", func(t *testing.T) {

beacon-chain/core/helpers/beacon_committee.go

@@ -403,7 +403,7 @@ func AssignmentForValidator(
 			}
 		}
 	}
-	return &LiteAssignment{} // validator is not scheduled this epoch
+	return nil // validator is not scheduled this epoch
 }
 
 // CommitteeAssignments calculates committee assignments for each validator during the specified epoch.

beacon-chain/core/helpers/beacon_committee_test.go

@@ -1,6 +1,7 @@
 package helpers_test
 
 import (
+	"context"
 	"fmt"
 	"strconv"
 	"testing"
@@ -49,7 +50,7 @@ func TestComputeCommittee_WithoutCache(t *testing.T) {
 	require.NoError(t, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(t.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch)
 	require.NoError(t, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
@@ -111,10 +112,10 @@ func TestCommitteeAssignments_CannotRetrieveFutureEpoch(t *testing.T) {
 		Slot: 0, // Epoch 0.
 	})
 	require.NoError(t, err)
-	_, err = helpers.CommitteeAssignments(t.Context(), state, epoch+1, nil)
+	_, err = helpers.CommitteeAssignments(context.Background(), state, epoch+1, nil)
 	assert.ErrorContains(t, "can't be greater than next epoch", err)
 
-	_, err = helpers.ProposerAssignments(t.Context(), state, epoch+1)
+	_, err = helpers.ProposerAssignments(context.Background(), state, epoch+1)
 	assert.ErrorContains(t, "can't be greater than next epoch", err)
 }
 
@@ -138,7 +139,7 @@ func TestCommitteeAssignments_NoProposerForSlot0(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	assignments, err := helpers.ProposerAssignments(t.Context(), state, 0)
+	assignments, err := helpers.ProposerAssignments(context.Background(), state, 0)
 	require.NoError(t, err, "Failed to determine Assignments")
 	for _, slots := range assignments {
 		for _, s := range slots {
@@ -213,12 +214,12 @@ func TestCommitteeAssignments_CanRetrieve(t *testing.T) {
 		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
 			helpers.ClearCache()
 
-			assignments, err := helpers.CommitteeAssignments(t.Context(), state, slots.ToEpoch(tt.slot), validatorIndices)
+			assignments, err := helpers.CommitteeAssignments(context.Background(), state, slots.ToEpoch(tt.slot), validatorIndices)
 			require.NoError(t, err, "Failed to determine Assignments")
 			cac := assignments[tt.index]
 			assert.Equal(t, tt.committeeIndex, cac.CommitteeIndex, "Unexpected committeeIndex for validator index %d", tt.index)
 			assert.Equal(t, tt.slot, cac.AttesterSlot, "Unexpected slot for validator index %d", tt.index)
-			proposerAssignments, err := helpers.ProposerAssignments(t.Context(), state, slots.ToEpoch(tt.slot))
+			proposerAssignments, err := helpers.ProposerAssignments(context.Background(), state, slots.ToEpoch(tt.slot))
 			require.NoError(t, err)
 			if len(proposerAssignments[tt.index]) > 0 && proposerAssignments[tt.index][0] != tt.proposerSlot {
 				t.Errorf("wanted proposer slot %d, got proposer slot %d for validator index %d",
@@ -252,11 +253,11 @@ func TestCommitteeAssignments_CannotRetrieveFuture(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	assignments, err := helpers.ProposerAssignments(t.Context(), state, time.CurrentEpoch(state))
+	assignments, err := helpers.ProposerAssignments(context.Background(), state, time.CurrentEpoch(state))
 	require.NoError(t, err)
 	require.NotEqual(t, 0, len(assignments), "wanted non-zero proposer index set")
 
-	assignments, err = helpers.ProposerAssignments(t.Context(), state, time.CurrentEpoch(state)+1)
+	assignments, err = helpers.ProposerAssignments(context.Background(), state, time.CurrentEpoch(state)+1)
 	require.NoError(t, err)
 	require.NotEqual(t, 0, len(assignments), "wanted non-zero proposer index set")
 }
@@ -278,7 +279,7 @@ func TestCommitteeAssignments_CannotRetrieveOlderThanSlotsPerHistoricalRoot(t *t
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	_, err = helpers.CommitteeAssignments(t.Context(), state, 0, nil)
+	_, err = helpers.CommitteeAssignments(context.Background(), state, 0, nil)
 	require.ErrorContains(t, "start slot 0 is smaller than the minimum valid start slot 1", err)
 }
 
@@ -300,7 +301,7 @@ func TestCommitteeAssignments_EverySlotHasMin1Proposer(t *testing.T) {
 	})
 	require.NoError(t, err)
 	epoch := primitives.Epoch(1)
-	assignments, err := helpers.ProposerAssignments(t.Context(), state, epoch)
+	assignments, err := helpers.ProposerAssignments(context.Background(), state, epoch)
 	require.NoError(t, err, "Failed to determine Assignments")
 
 	slotsWithProposers := make(map[primitives.Slot]bool)
@@ -411,7 +412,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
 		require.NoError(t, state.SetSlot(tt.stateSlot))
 		att := tt.attestation
 		// Verify attesting indices are correct.
-		committee, err := helpers.BeaconCommitteeFromState(t.Context(), state, att.GetData().Slot, att.GetData().CommitteeIndex)
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, att.GetData().Slot, att.GetData().CommitteeIndex)
 		require.NoError(t, err)
 		require.NotNil(t, committee)
 		err = helpers.VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee)))
@@ -441,14 +442,14 @@ func TestUpdateCommitteeCache_CanUpdate(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	require.NoError(t, helpers.UpdateCommitteeCache(t.Context(), state, time.CurrentEpoch(state)))
+	require.NoError(t, helpers.UpdateCommitteeCache(context.Background(), state, time.CurrentEpoch(state)))
 
 	epoch := primitives.Epoch(0)
 	idx := primitives.CommitteeIndex(1)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
 
-	indices, err = helpers.CommitteeCache().Committee(t.Context(), params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epoch)), seed, idx)
+	indices, err = helpers.CommitteeCache().Committee(context.Background(), params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epoch)), seed, idx)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(indices)), "Did not save correct indices lengths")
 }
@@ -472,7 +473,7 @@ func TestUpdateCommitteeCache_CanUpdateAcrossEpochs(t *testing.T) {
 	})
 	require.NoError(t, err)
 	e := time.CurrentEpoch(state)
-	require.NoError(t, helpers.UpdateCommitteeCache(t.Context(), state, e))
+	require.NoError(t, helpers.UpdateCommitteeCache(context.Background(), state, e))
 
 	seed, err := helpers.Seed(state, e, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
@@ -482,7 +483,7 @@ func TestUpdateCommitteeCache_CanUpdateAcrossEpochs(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, false, helpers.CommitteeCache().HasEntry(string(nextSeed[:])))
 
-	require.NoError(t, helpers.UpdateCommitteeCache(t.Context(), state, e+1))
+	require.NoError(t, helpers.UpdateCommitteeCache(context.Background(), state, e+1))
 
 	require.Equal(t, true, helpers.CommitteeCache().HasEntry(string(nextSeed[:])))
 }
@@ -501,7 +502,7 @@ func BenchmarkComputeCommittee300000_WithPreCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)
@@ -535,7 +536,7 @@ func BenchmarkComputeCommittee3000000_WithPreCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)
@@ -569,7 +570,7 @@ func BenchmarkComputeCommittee128000_WithOutPreCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)
@@ -604,7 +605,7 @@ func BenchmarkComputeCommittee1000000_WithOutCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)
@@ -639,7 +640,7 @@ func BenchmarkComputeCommittee4000000_WithOutCache(b *testing.B) {
 	require.NoError(b, err)
 
 	epoch := time.CurrentEpoch(state)
-	indices, err := helpers.ActiveValidatorIndices(b.Context(), state, epoch)
+	indices, err := helpers.ActiveValidatorIndices(context.Background(), state, epoch)
 	require.NoError(b, err)
 	seed, err := helpers.Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(b, err)
@@ -675,13 +676,13 @@ func TestBeaconCommitteeFromState_UpdateCacheForPreviousEpoch(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	_, err = helpers.BeaconCommitteeFromState(t.Context(), state, 1 /* previous epoch */, 0)
+	_, err = helpers.BeaconCommitteeFromState(context.Background(), state, 1 /* previous epoch */, 0)
 	require.NoError(t, err)
 
 	// Verify previous epoch is cached
 	seed, err := helpers.Seed(state, 0, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
-	activeIndices, err := helpers.CommitteeCache().ActiveIndices(t.Context(), seed)
+	activeIndices, err := helpers.CommitteeCache().ActiveIndices(context.Background(), seed)
 	require.NoError(t, err)
 	assert.NotNil(t, activeIndices, "Did not cache active indices")
 }
@@ -700,7 +701,7 @@ func TestPrecomputeProposerIndices_Ok(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	indices, err := helpers.ActiveValidatorIndices(t.Context(), state, 0)
+	indices, err := helpers.ActiveValidatorIndices(context.Background(), state, 0)
 	require.NoError(t, err)
 
 	proposerIndices, err := helpers.PrecomputeProposerIndices(state, indices, time.CurrentEpoch(state))
@@ -729,7 +730,7 @@ func TestCommitteeIndices(t *testing.T) {
 }
 
 func TestAttestationCommitteesFromState(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
 	for i := 0; i < len(validators); i++ {
@@ -765,7 +766,7 @@ func TestAttestationCommitteesFromState(t *testing.T) {
 }
 
 func TestAttestationCommitteesFromCache(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
 	for i := 0; i < len(validators); i++ {
@@ -813,7 +814,7 @@ func TestAttestationCommitteesFromCache(t *testing.T) {
 }
 
 func TestBeaconCommitteesFromState(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	params.SetupTestConfigCleanup(t)
 	c := params.BeaconConfig().Copy()
@@ -838,7 +839,7 @@ func TestBeaconCommitteesFromState(t *testing.T) {
 }
 
 func TestBeaconCommitteesFromCache(t *testing.T) {
-	ctx := t.Context()
+	ctx := context.Background()
 
 	params.SetupTestConfigCleanup(t)
 	c := params.BeaconConfig().Copy()
@@ -874,7 +875,7 @@ func TestBeaconCommitteesFromCache(t *testing.T) {
 func TestPrecomputeCommittees_HappyPath(t *testing.T) {
 	cfg := params.BeaconConfig()
 	start := primitives.Slot(100)
-	ctx := t.Context()
+	ctx := context.Background()
 	st, _ := util.DeterministicGenesisState(t, 256)
 
 	got, err := helpers.PrecomputeCommittees(ctx, st, start)
@@ -912,7 +913,6 @@ func TestAssignmentForValidator(t *testing.T) {
 			{{4, 5, 6}},
 		}
 		got = helpers.AssignmentForValidator(bySlot, start, primitives.ValidatorIndex(99))
-		// should be empty to be safe
-		require.DeepEqual(t, &helpers.LiteAssignment{}, got)
+		require.IsNil(t, got)
 	})
 }

beacon-chain/core/helpers/sync_committee_test.go

@@ -78,6 +78,7 @@ func TestIsCurrentEpochSyncCommittee_UsingCommittee(t *testing.T) {
 
 func TestIsCurrentEpochSyncCommittee_DoesNotExist(t *testing.T) {
 	helpers.ClearCache()
+	params.SetupTestConfigCleanup(t)
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)
 	syncCommittee := &ethpb.SyncCommittee{
@@ -264,6 +265,7 @@ func TestCurrentEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) {
 }
 
 func TestCurrentEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
 	helpers.ClearCache()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)

beacon-chain/core/helpers/validators_test.go

@@ -1,6 +1,7 @@
 package helpers_test
 
 import (
+	"context"
 	"errors"
 	"testing"
 
@@ -227,7 +228,7 @@ func TestBeaconProposerIndex_OK(t *testing.T) {
 		helpers.ClearCache()
 
 		require.NoError(t, state.SetSlot(tt.slot))
-		result, err := helpers.BeaconProposerIndex(t.Context(), state)
+		result, err := helpers.BeaconProposerIndex(context.Background(), state)
 		require.NoError(t, err, "Failed to get shard and committees at slot")
 		assert.Equal(t, tt.index, result, "Result index was an unexpected value")
 	}
@@ -262,7 +263,7 @@ func TestBeaconProposerIndex_BadState(t *testing.T) {
 	// Set a very high slot, so that retrieved block root will be
 	// non existent for the proposer cache.
 	require.NoError(t, state.SetSlot(100))
-	_, err = helpers.BeaconProposerIndex(t.Context(), state)
+	_, err = helpers.BeaconProposerIndex(context.Background(), state)
 	require.NoError(t, err)
 }
 
@@ -282,7 +283,7 @@ func TestComputeProposerIndex_Compatibility(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	indices, err := helpers.ActiveValidatorIndices(t.Context(), state, 0)
+	indices, err := helpers.ActiveValidatorIndices(context.Background(), state, 0)
 	require.NoError(t, err)
 
 	var proposerIndices []primitives.ValidatorIndex
@@ -337,8 +338,8 @@ func TestActiveValidatorCount_Genesis(t *testing.T) {
 	// Preset cache to a bad count.
 	seed, err := helpers.Seed(beaconState, 0, params.BeaconConfig().DomainBeaconAttester)
 	require.NoError(t, err)
-	require.NoError(t, helpers.CommitteeCache().AddCommitteeShuffledList(t.Context(), &cache.Committees{Seed: seed, ShuffledIndices: []primitives.ValidatorIndex{1, 2, 3}}))
-	validatorCount, err := helpers.ActiveValidatorCount(t.Context(), beaconState, time.CurrentEpoch(beaconState))
+	require.NoError(t, helpers.CommitteeCache().AddCommitteeShuffledList(context.Background(), &cache.Committees{Seed: seed, ShuffledIndices: []primitives.ValidatorIndex{1, 2, 3}}))
+	validatorCount, err := helpers.ActiveValidatorCount(context.Background(), beaconState, time.CurrentEpoch(beaconState))
 	require.NoError(t, err)
 	assert.Equal(t, uint64(c), validatorCount, "Did not get the correct validator count")
 }
@@ -369,7 +370,7 @@ func TestChurnLimit_OK(t *testing.T) {
 			RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 		})
 		require.NoError(t, err)
-		validatorCount, err := helpers.ActiveValidatorCount(t.Context(), beaconState, time.CurrentEpoch(beaconState))
+		validatorCount, err := helpers.ActiveValidatorCount(context.Background(), beaconState, time.CurrentEpoch(beaconState))
 		require.NoError(t, err)
 		resultChurn := helpers.ValidatorActivationChurnLimit(validatorCount)
 		assert.Equal(t, test.wantedChurn, resultChurn, "ValidatorActivationChurnLimit(%d)", test.validatorCount)
@@ -406,7 +407,7 @@ func TestChurnLimitDeneb_OK(t *testing.T) {
 		require.NoError(t, err)
 
 		// Get active validator count
-		validatorCount, err := helpers.ActiveValidatorCount(t.Context(), beaconState, time.CurrentEpoch(beaconState))
+		validatorCount, err := helpers.ActiveValidatorCount(context.Background(), beaconState, time.CurrentEpoch(beaconState))
 		require.NoError(t, err)
 
 		// Test churn limit calculation
@@ -579,7 +580,7 @@ func TestActiveValidatorIndices(t *testing.T) {
 
 			s, err := state_native.InitializeFromProtoPhase0(tt.args.state)
 			require.NoError(t, err)
-			got, err := helpers.ActiveValidatorIndices(t.Context(), s, tt.args.epoch)
+			got, err := helpers.ActiveValidatorIndices(context.Background(), s, tt.args.epoch)
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
 				return
@@ -884,7 +885,7 @@ func TestLastActivatedValidatorIndex_OK(t *testing.T) {
 	require.NoError(t, beaconState.SetValidators(validators))
 	require.NoError(t, beaconState.SetBalances(balances))
 
-	index, err := helpers.LastActivatedValidatorIndex(t.Context(), beaconState)
+	index, err := helpers.LastActivatedValidatorIndex(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.Equal(t, index, primitives.ValidatorIndex(3))
 }

beacon-chain/core/helpers/weak_subjectivity_test.go

@@ -1,6 +1,7 @@
 package helpers_test
 
 import (
+	"context"
 	"fmt"
 	"testing"
 
@@ -48,7 +49,7 @@ func TestWeakSubjectivity_ComputeWeakSubjectivityPeriod(t *testing.T) {
 			// Reset committee cache - as we need to recalculate active validator set for each test.
 			helpers.ClearCache()
 
-			got, err := helpers.ComputeWeakSubjectivityPeriod(t.Context(), genState(t, tt.valCount, tt.avgBalance), params.BeaconConfig())
+			got, err := helpers.ComputeWeakSubjectivityPeriod(context.Background(), genState(t, tt.valCount, tt.avgBalance), params.BeaconConfig())
 			require.NoError(t, err)
 			assert.Equal(t, tt.want, got, "valCount: %v, avgBalance: %v", tt.valCount, tt.avgBalance)
 		})
@@ -180,7 +181,7 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 			helpers.ClearCache()
 
 			sr, _, e := tt.genWsCheckpoint()
-			got, err := helpers.IsWithinWeakSubjectivityPeriod(t.Context(), tt.epoch, tt.genWsState(), sr, e, params.BeaconConfig())
+			got, err := helpers.IsWithinWeakSubjectivityPeriod(context.Background(), tt.epoch, tt.genWsState(), sr, e, params.BeaconConfig())
 			if tt.wantedErr != "" {
 				assert.Equal(t, false, got)
 				assert.ErrorContains(t, tt.wantedErr, err)

beacon-chain/core/light-client/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "helpers.go",
         "lightclient.go",
         "store.go",
     ],
@@ -42,6 +41,7 @@ go_test(
         "//consensus-types:go_default_library",
         "//consensus-types/blocks: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",

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

@@ -1,243 +0,0 @@
-package light_client
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
-	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"
-	light_client "github.com/OffchainLabs/prysm/v6/consensus-types/light-client"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
-	"github.com/pkg/errors"
-	"google.golang.org/protobuf/proto"
-)
-
-func createDefaultLightClientBootstrap(currentSlot primitives.Slot) (interfaces.LightClientBootstrap, error) {
-	currentEpoch := slots.ToEpoch(currentSlot)
-	syncCommitteeSize := params.BeaconConfig().SyncCommitteeSize
-	pubKeys := make([][]byte, syncCommitteeSize)
-	for i := uint64(0); i < syncCommitteeSize; i++ {
-		pubKeys[i] = make([]byte, fieldparams.BLSPubkeyLength)
-	}
-	currentSyncCommittee := &pb.SyncCommittee{
-		Pubkeys:         pubKeys,
-		AggregatePubkey: make([]byte, fieldparams.BLSPubkeyLength),
-	}
-
-	var currentSyncCommitteeBranch [][]byte
-	if currentEpoch >= params.BeaconConfig().ElectraForkEpoch {
-		currentSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepthElectra)
-	} else {
-		currentSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepth)
-	}
-	for i := 0; i < len(currentSyncCommitteeBranch); i++ {
-		currentSyncCommitteeBranch[i] = make([]byte, fieldparams.RootLength)
-	}
-
-	executionBranch := make([][]byte, fieldparams.ExecutionBranchDepth)
-	for i := 0; i < fieldparams.ExecutionBranchDepth; i++ {
-		executionBranch[i] = make([]byte, 32)
-	}
-
-	var m proto.Message
-	if currentEpoch < params.BeaconConfig().CapellaForkEpoch {
-		m = &pb.LightClientBootstrapAltair{
-			Header: &pb.LightClientHeaderAltair{
-				Beacon: &pb.BeaconBlockHeader{},
-			},
-			CurrentSyncCommittee:       currentSyncCommittee,
-			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
-		}
-	} else if currentEpoch < params.BeaconConfig().DenebForkEpoch {
-		m = &pb.LightClientBootstrapCapella{
-			Header: &pb.LightClientHeaderCapella{
-				Beacon:          &pb.BeaconBlockHeader{},
-				Execution:       &enginev1.ExecutionPayloadHeaderCapella{},
-				ExecutionBranch: executionBranch,
-			},
-			CurrentSyncCommittee:       currentSyncCommittee,
-			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
-		}
-	} else if currentEpoch < params.BeaconConfig().ElectraForkEpoch {
-		m = &pb.LightClientBootstrapDeneb{
-			Header: &pb.LightClientHeaderDeneb{
-				Beacon:          &pb.BeaconBlockHeader{},
-				Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
-				ExecutionBranch: executionBranch,
-			},
-			CurrentSyncCommittee:       currentSyncCommittee,
-			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
-		}
-	} else {
-		m = &pb.LightClientBootstrapElectra{
-			Header: &pb.LightClientHeaderDeneb{
-				Beacon:          &pb.BeaconBlockHeader{},
-				Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
-				ExecutionBranch: executionBranch,
-			},
-			CurrentSyncCommittee:       currentSyncCommittee,
-			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
-		}
-	}
-
-	return light_client.NewWrappedBootstrap(m)
-}
-
-func makeExecutionAndProofDeneb(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*enginev1.ExecutionPayloadHeaderDeneb, [][]byte, error) {
-	if blk.Version() < version.Capella {
-		p, err := execution.EmptyExecutionPayloadHeader(version.Deneb)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "could not get payload header")
-		}
-		payloadHeader, ok := p.(*enginev1.ExecutionPayloadHeaderDeneb)
-		if !ok {
-			return nil, nil, fmt.Errorf("payload header type %T is not %T", p, &enginev1.ExecutionPayloadHeaderDeneb{})
-		}
-		payloadProof := emptyPayloadProof()
-
-		return payloadHeader, payloadProof, nil
-	}
-
-	payload, err := blk.Block().Body().Execution()
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not get execution payload")
-	}
-	transactionsRoot, err := ComputeTransactionsRoot(payload)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not get transactions root")
-	}
-	withdrawalsRoot, err := ComputeWithdrawalsRoot(payload)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not get withdrawals root")
-	}
-
-	payloadHeader := &enginev1.ExecutionPayloadHeaderDeneb{
-		ParentHash:       payload.ParentHash(),
-		FeeRecipient:     payload.FeeRecipient(),
-		StateRoot:        payload.StateRoot(),
-		ReceiptsRoot:     payload.ReceiptsRoot(),
-		LogsBloom:        payload.LogsBloom(),
-		PrevRandao:       payload.PrevRandao(),
-		BlockNumber:      payload.BlockNumber(),
-		GasLimit:         payload.GasLimit(),
-		GasUsed:          payload.GasUsed(),
-		Timestamp:        payload.Timestamp(),
-		ExtraData:        payload.ExtraData(),
-		BaseFeePerGas:    payload.BaseFeePerGas(),
-		BlockHash:        payload.BlockHash(),
-		TransactionsRoot: transactionsRoot,
-		WithdrawalsRoot:  withdrawalsRoot,
-		BlobGasUsed:      0,
-		ExcessBlobGas:    0,
-	}
-
-	if blk.Version() >= version.Deneb {
-		blobGasUsed, err := payload.BlobGasUsed()
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "could not get blob gas used")
-		}
-		excessBlobGas, err := payload.ExcessBlobGas()
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "could not get excess blob gas")
-		}
-
-		payloadHeader.BlobGasUsed = blobGasUsed
-		payloadHeader.ExcessBlobGas = excessBlobGas
-	}
-
-	payloadProof, err := blocks.PayloadProof(ctx, blk.Block())
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not get execution payload proof")
-	}
-
-	return payloadHeader, payloadProof, nil
-}
-
-func makeExecutionAndProofCapella(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) (*enginev1.ExecutionPayloadHeaderCapella, [][]byte, error) {
-	if blk.Version() > version.Capella {
-		return nil, nil, fmt.Errorf("unsupported block version %s for capella execution payload", version.String(blk.Version()))
-	}
-	if blk.Version() < version.Capella {
-		p, err := execution.EmptyExecutionPayloadHeader(version.Capella)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "could not get payload header")
-		}
-		payloadHeader, ok := p.(*enginev1.ExecutionPayloadHeaderCapella)
-		if !ok {
-			return nil, nil, fmt.Errorf("payload header type %T is not %T", p, &enginev1.ExecutionPayloadHeaderCapella{})
-		}
-		payloadProof := emptyPayloadProof()
-
-		return payloadHeader, payloadProof, nil
-	}
-
-	payload, err := blk.Block().Body().Execution()
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not get execution payload")
-	}
-	transactionsRoot, err := ComputeTransactionsRoot(payload)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not get transactions root")
-	}
-	withdrawalsRoot, err := ComputeWithdrawalsRoot(payload)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not get withdrawals root")
-	}
-
-	payloadHeader := &enginev1.ExecutionPayloadHeaderCapella{
-		ParentHash:       payload.ParentHash(),
-		FeeRecipient:     payload.FeeRecipient(),
-		StateRoot:        payload.StateRoot(),
-		ReceiptsRoot:     payload.ReceiptsRoot(),
-		LogsBloom:        payload.LogsBloom(),
-		PrevRandao:       payload.PrevRandao(),
-		BlockNumber:      payload.BlockNumber(),
-		GasLimit:         payload.GasLimit(),
-		GasUsed:          payload.GasUsed(),
-		Timestamp:        payload.Timestamp(),
-		ExtraData:        payload.ExtraData(),
-		BaseFeePerGas:    payload.BaseFeePerGas(),
-		BlockHash:        payload.BlockHash(),
-		TransactionsRoot: transactionsRoot,
-		WithdrawalsRoot:  withdrawalsRoot,
-	}
-
-	payloadProof, err := blocks.PayloadProof(ctx, blk.Block())
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not get execution payload proof")
-	}
-
-	return payloadHeader, payloadProof, nil
-}
-
-func makeBeaconBlockHeader(blk interfaces.ReadOnlySignedBeaconBlock) (*pb.BeaconBlockHeader, error) {
-	parentRoot := blk.Block().ParentRoot()
-	stateRoot := blk.Block().StateRoot()
-	bodyRoot, err := blk.Block().Body().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get body root")
-	}
-	return &pb.BeaconBlockHeader{
-		Slot:          blk.Block().Slot(),
-		ProposerIndex: blk.Block().ProposerIndex(),
-		ParentRoot:    parentRoot[:],
-		StateRoot:     stateRoot[:],
-		BodyRoot:      bodyRoot[:],
-	}, nil
-}
-
-func emptyPayloadProof() [][]byte {
-	branch := interfaces.LightClientExecutionBranch{}
-	proof := make([][]byte, len(branch))
-	for i, b := range branch {
-		proof[i] = b[:]
-	}
-	return proof
-}

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

@@ -6,10 +6,12 @@ import (
 	"fmt"
 	"reflect"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	consensus_types "github.com/OffchainLabs/prysm/v6/consensus-types"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	light_client "github.com/OffchainLabs/prysm/v6/consensus-types/light-client"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -161,13 +163,13 @@ func NewLightClientUpdateFromBeaconState(
 	updateAttestedPeriod := slots.SyncCommitteePeriod(slots.ToEpoch(attestedBlock.Block().Slot()))
 
 	// update = LightClientUpdate()
-	result, err := CreateDefaultLightClientUpdate(attestedBlock)
+	result, err := CreateDefaultLightClientUpdate(currentSlot, attestedState)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not create default light client update")
 	}
 
 	// update.attested_header = block_to_light_client_header(attested_block)
-	attestedLightClientHeader, err := BlockToLightClientHeader(ctx, attestedBlock.Version(), attestedBlock)
+	attestedLightClientHeader, err := BlockToLightClientHeader(ctx, currentSlot, attestedBlock)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get attested light client header")
 	}
@@ -208,7 +210,7 @@ func NewLightClientUpdateFromBeaconState(
 		// if finalized_block.message.slot != GENESIS_SLOT
 		if finalizedBlock.Block().Slot() != 0 {
 			// update.finalized_header = block_to_light_client_header(finalized_block)
-			finalizedLightClientHeader, err := BlockToLightClientHeader(ctx, attestedBlock.Version(), finalizedBlock)
+			finalizedLightClientHeader, err := BlockToLightClientHeader(ctx, currentSlot, finalizedBlock)
 			if err != nil {
 				return nil, errors.Wrap(err, "could not get finalized light client header")
 			}
@@ -245,7 +247,9 @@ func NewLightClientUpdateFromBeaconState(
 	return result, nil
 }
 
-func CreateDefaultLightClientUpdate(attestedBlock interfaces.ReadOnlySignedBeaconBlock) (interfaces.LightClientUpdate, error) {
+func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState state.BeaconState) (interfaces.LightClientUpdate, error) {
+	currentEpoch := slots.ToEpoch(currentSlot)
+
 	syncCommitteeSize := params.BeaconConfig().SyncCommitteeSize
 	pubKeys := make([][]byte, syncCommitteeSize)
 	for i := uint64(0); i < syncCommitteeSize; i++ {
@@ -257,7 +261,7 @@ func CreateDefaultLightClientUpdate(attestedBlock interfaces.ReadOnlySignedBeaco
 	}
 
 	var nextSyncCommitteeBranch [][]byte
-	if attestedBlock.Version() >= version.Electra {
+	if attestedState.Version() >= version.Electra {
 		nextSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepthElectra)
 	} else {
 		nextSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepth)
@@ -272,7 +276,7 @@ func CreateDefaultLightClientUpdate(attestedBlock interfaces.ReadOnlySignedBeaco
 	}
 
 	var finalityBranch [][]byte
-	if attestedBlock.Version() >= version.Electra {
+	if attestedState.Version() >= version.Electra {
 		finalityBranch = make([][]byte, fieldparams.FinalityBranchDepthElectra)
 	} else {
 		finalityBranch = make([][]byte, fieldparams.FinalityBranchDepth)
@@ -282,12 +286,10 @@ func CreateDefaultLightClientUpdate(attestedBlock interfaces.ReadOnlySignedBeaco
 	}
 
 	var m proto.Message
-	switch attestedBlock.Version() {
-	case version.Altair, version.Bellatrix:
+	if currentEpoch < params.BeaconConfig().CapellaForkEpoch {
 		m = &pb.LightClientUpdateAltair{
 			AttestedHeader: &pb.LightClientHeaderAltair{
 				Beacon: &pb.BeaconBlockHeader{
-					Slot:       attestedBlock.Block().Slot(),
 					ParentRoot: make([]byte, 32),
 					StateRoot:  make([]byte, 32),
 					BodyRoot:   make([]byte, 32),
@@ -308,11 +310,10 @@ func CreateDefaultLightClientUpdate(attestedBlock interfaces.ReadOnlySignedBeaco
 				SyncCommitteeSignature: make([]byte, 96),
 			},
 		}
-	case version.Capella:
+	} else if currentEpoch < params.BeaconConfig().DenebForkEpoch {
 		m = &pb.LightClientUpdateCapella{
 			AttestedHeader: &pb.LightClientHeaderCapella{
 				Beacon: &pb.BeaconBlockHeader{
-					Slot:       attestedBlock.Block().Slot(),
 					ParentRoot: make([]byte, 32),
 					StateRoot:  make([]byte, 32),
 					BodyRoot:   make([]byte, 32),
@@ -361,11 +362,10 @@ func CreateDefaultLightClientUpdate(attestedBlock interfaces.ReadOnlySignedBeaco
 				SyncCommitteeSignature: make([]byte, 96),
 			},
 		}
-	case version.Deneb:
+	} else if currentEpoch < params.BeaconConfig().ElectraForkEpoch {
 		m = &pb.LightClientUpdateDeneb{
 			AttestedHeader: &pb.LightClientHeaderDeneb{
 				Beacon: &pb.BeaconBlockHeader{
-					Slot:       attestedBlock.Block().Slot(),
 					ParentRoot: make([]byte, 32),
 					StateRoot:  make([]byte, 32),
 					BodyRoot:   make([]byte, 32),
@@ -418,65 +418,120 @@ func CreateDefaultLightClientUpdate(attestedBlock interfaces.ReadOnlySignedBeaco
 				SyncCommitteeSignature: make([]byte, 96),
 			},
 		}
-	case version.Electra, version.Fulu:
-		m = &pb.LightClientUpdateElectra{
-			AttestedHeader: &pb.LightClientHeaderDeneb{
-				Beacon: &pb.BeaconBlockHeader{
-					Slot:       attestedBlock.Block().Slot(),
-					ParentRoot: make([]byte, 32),
-					StateRoot:  make([]byte, 32),
-					BodyRoot:   make([]byte, 32),
+	} else {
+		if attestedState.Version() >= version.Electra {
+			m = &pb.LightClientUpdateElectra{
+				AttestedHeader: &pb.LightClientHeaderDeneb{
+					Beacon: &pb.BeaconBlockHeader{
+						ParentRoot: make([]byte, 32),
+						StateRoot:  make([]byte, 32),
+						BodyRoot:   make([]byte, 32),
+					},
+					Execution: &enginev1.ExecutionPayloadHeaderDeneb{
+						ParentHash:       make([]byte, fieldparams.RootLength),
+						FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+						StateRoot:        make([]byte, fieldparams.RootLength),
+						ReceiptsRoot:     make([]byte, fieldparams.RootLength),
+						LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
+						PrevRandao:       make([]byte, fieldparams.RootLength),
+						ExtraData:        make([]byte, 0),
+						BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+						BlockHash:        make([]byte, fieldparams.RootLength),
+						TransactionsRoot: make([]byte, fieldparams.RootLength),
+						WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
+						GasLimit:         0,
+						GasUsed:          0,
+					},
+					ExecutionBranch: executionBranch,
 				},
-				Execution: &enginev1.ExecutionPayloadHeaderDeneb{
-					ParentHash:       make([]byte, fieldparams.RootLength),
-					FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
-					StateRoot:        make([]byte, fieldparams.RootLength),
-					ReceiptsRoot:     make([]byte, fieldparams.RootLength),
-					LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
-					PrevRandao:       make([]byte, fieldparams.RootLength),
-					ExtraData:        make([]byte, 0),
-					BaseFeePerGas:    make([]byte, fieldparams.RootLength),
-					BlockHash:        make([]byte, fieldparams.RootLength),
-					TransactionsRoot: make([]byte, fieldparams.RootLength),
-					WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
-					GasLimit:         0,
-					GasUsed:          0,
+				NextSyncCommittee:       nextSyncCommittee,
+				NextSyncCommitteeBranch: nextSyncCommitteeBranch,
+				FinalityBranch:          finalityBranch,
+				FinalizedHeader: &pb.LightClientHeaderDeneb{
+					Beacon: &pb.BeaconBlockHeader{
+						ParentRoot: make([]byte, 32),
+						StateRoot:  make([]byte, 32),
+						BodyRoot:   make([]byte, 32),
+					},
+					Execution: &enginev1.ExecutionPayloadHeaderDeneb{
+						ParentHash:       make([]byte, fieldparams.RootLength),
+						FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+						StateRoot:        make([]byte, fieldparams.RootLength),
+						ReceiptsRoot:     make([]byte, fieldparams.RootLength),
+						LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
+						PrevRandao:       make([]byte, fieldparams.RootLength),
+						ExtraData:        make([]byte, 0),
+						BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+						BlockHash:        make([]byte, fieldparams.RootLength),
+						TransactionsRoot: make([]byte, fieldparams.RootLength),
+						WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
+						GasLimit:         0,
+						GasUsed:          0,
+					},
+					ExecutionBranch: executionBranch,
 				},
-				ExecutionBranch: executionBranch,
-			},
-			NextSyncCommittee:       nextSyncCommittee,
-			NextSyncCommitteeBranch: nextSyncCommitteeBranch,
-			FinalityBranch:          finalityBranch,
-			FinalizedHeader: &pb.LightClientHeaderDeneb{
-				Beacon: &pb.BeaconBlockHeader{
-					ParentRoot: make([]byte, 32),
-					StateRoot:  make([]byte, 32),
-					BodyRoot:   make([]byte, 32),
+				SyncAggregate: &pb.SyncAggregate{
+					SyncCommitteeBits:      make([]byte, 64),
+					SyncCommitteeSignature: make([]byte, 96),
 				},
-				Execution: &enginev1.ExecutionPayloadHeaderDeneb{
-					ParentHash:       make([]byte, fieldparams.RootLength),
-					FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
-					StateRoot:        make([]byte, fieldparams.RootLength),
-					ReceiptsRoot:     make([]byte, fieldparams.RootLength),
-					LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
-					PrevRandao:       make([]byte, fieldparams.RootLength),
-					ExtraData:        make([]byte, 0),
-					BaseFeePerGas:    make([]byte, fieldparams.RootLength),
-					BlockHash:        make([]byte, fieldparams.RootLength),
-					TransactionsRoot: make([]byte, fieldparams.RootLength),
-					WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
-					GasLimit:         0,
-					GasUsed:          0,
+			}
+		} else {
+			m = &pb.LightClientUpdateDeneb{
+				AttestedHeader: &pb.LightClientHeaderDeneb{
+					Beacon: &pb.BeaconBlockHeader{
+						ParentRoot: make([]byte, 32),
+						StateRoot:  make([]byte, 32),
+						BodyRoot:   make([]byte, 32),
+					},
+					Execution: &enginev1.ExecutionPayloadHeaderDeneb{
+						ParentHash:       make([]byte, fieldparams.RootLength),
+						FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+						StateRoot:        make([]byte, fieldparams.RootLength),
+						ReceiptsRoot:     make([]byte, fieldparams.RootLength),
+						LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
+						PrevRandao:       make([]byte, fieldparams.RootLength),
+						ExtraData:        make([]byte, 0),
+						BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+						BlockHash:        make([]byte, fieldparams.RootLength),
+						TransactionsRoot: make([]byte, fieldparams.RootLength),
+						WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
+						GasLimit:         0,
+						GasUsed:          0,
+					},
+					ExecutionBranch: executionBranch,
 				},
-				ExecutionBranch: executionBranch,
-			},
-			SyncAggregate: &pb.SyncAggregate{
-				SyncCommitteeBits:      make([]byte, 64),
-				SyncCommitteeSignature: make([]byte, 96),
-			},
+				NextSyncCommittee:       nextSyncCommittee,
+				NextSyncCommitteeBranch: nextSyncCommitteeBranch,
+				FinalityBranch:          finalityBranch,
+				FinalizedHeader: &pb.LightClientHeaderDeneb{
+					Beacon: &pb.BeaconBlockHeader{
+						ParentRoot: make([]byte, 32),
+						StateRoot:  make([]byte, 32),
+						BodyRoot:   make([]byte, 32),
+					},
+					Execution: &enginev1.ExecutionPayloadHeaderDeneb{
+						ParentHash:       make([]byte, fieldparams.RootLength),
+						FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+						StateRoot:        make([]byte, fieldparams.RootLength),
+						ReceiptsRoot:     make([]byte, fieldparams.RootLength),
+						LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
+						PrevRandao:       make([]byte, fieldparams.RootLength),
+						ExtraData:        make([]byte, 0),
+						BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+						BlockHash:        make([]byte, fieldparams.RootLength),
+						TransactionsRoot: make([]byte, fieldparams.RootLength),
+						WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
+						GasLimit:         0,
+						GasUsed:          0,
+					},
+					ExecutionBranch: executionBranch,
+				},
+				SyncAggregate: &pb.SyncAggregate{
+					SyncCommitteeBits:      make([]byte, 64),
+					SyncCommitteeSignature: make([]byte, 96),
+				},
+			}
 		}
-	default:
-		return nil, errors.Errorf("unsupported beacon chain version %s", version.String(attestedBlock.Version()))
 	}
 
 	return light_client.NewWrappedUpdate(m)
@@ -520,52 +575,189 @@ func ComputeWithdrawalsRoot(payload interfaces.ExecutionData) ([]byte, error) {
 
 func BlockToLightClientHeader(
 	ctx context.Context,
-	attestedBlockVersion int, // this is the version that the light client header should be in, based on the attested block.
-	block interfaces.ReadOnlySignedBeaconBlock, // this block is either the attested block, or the finalized block.
-	// in case of the latter, we might need to upgrade it to the attested block's version.
+	currentSlot primitives.Slot,
+	block interfaces.ReadOnlySignedBeaconBlock,
 ) (interfaces.LightClientHeader, error) {
-	if block.Version() > attestedBlockVersion {
-		return nil, errors.Errorf("block version %s is greater than attested block version %s", version.String(block.Version()), version.String(attestedBlockVersion))
-	}
-
-	beacon, err := makeBeaconBlockHeader(block)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not make beacon block header")
-	}
-
 	var m proto.Message
-	switch attestedBlockVersion {
-	case version.Altair, version.Bellatrix:
+	currentEpoch := slots.ToEpoch(currentSlot)
+	blockEpoch := slots.ToEpoch(block.Block().Slot())
+	parentRoot := block.Block().ParentRoot()
+	stateRoot := block.Block().StateRoot()
+	bodyRoot, err := block.Block().Body().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get body root")
+	}
+
+	if currentEpoch < params.BeaconConfig().CapellaForkEpoch {
 		m = &pb.LightClientHeaderAltair{
-			Beacon: beacon,
+			Beacon: &pb.BeaconBlockHeader{
+				Slot:          block.Block().Slot(),
+				ProposerIndex: block.Block().ProposerIndex(),
+				ParentRoot:    parentRoot[:],
+				StateRoot:     stateRoot[:],
+				BodyRoot:      bodyRoot[:],
+			},
 		}
-	case version.Capella:
-		payloadHeader, payloadProof, err := makeExecutionAndProofCapella(ctx, block)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not make execution payload header and proof")
+	} else if currentEpoch < params.BeaconConfig().DenebForkEpoch {
+		var payloadHeader *enginev1.ExecutionPayloadHeaderCapella
+		var payloadProof [][]byte
+
+		if blockEpoch < params.BeaconConfig().CapellaForkEpoch {
+			var ok bool
+
+			p, err := execution.EmptyExecutionPayloadHeader(version.Capella)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get payload header")
+			}
+			payloadHeader, ok = p.(*enginev1.ExecutionPayloadHeaderCapella)
+			if !ok {
+				return nil, fmt.Errorf("payload header type %T is not %T", p, &enginev1.ExecutionPayloadHeaderCapella{})
+			}
+			payloadProof = emptyPayloadProof()
+		} else {
+			payload, err := block.Block().Body().Execution()
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get execution payload")
+			}
+			transactionsRoot, err := ComputeTransactionsRoot(payload)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get transactions root")
+			}
+			withdrawalsRoot, err := ComputeWithdrawalsRoot(payload)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get withdrawals root")
+			}
+
+			payloadHeader = &enginev1.ExecutionPayloadHeaderCapella{
+				ParentHash:       payload.ParentHash(),
+				FeeRecipient:     payload.FeeRecipient(),
+				StateRoot:        payload.StateRoot(),
+				ReceiptsRoot:     payload.ReceiptsRoot(),
+				LogsBloom:        payload.LogsBloom(),
+				PrevRandao:       payload.PrevRandao(),
+				BlockNumber:      payload.BlockNumber(),
+				GasLimit:         payload.GasLimit(),
+				GasUsed:          payload.GasUsed(),
+				Timestamp:        payload.Timestamp(),
+				ExtraData:        payload.ExtraData(),
+				BaseFeePerGas:    payload.BaseFeePerGas(),
+				BlockHash:        payload.BlockHash(),
+				TransactionsRoot: transactionsRoot,
+				WithdrawalsRoot:  withdrawalsRoot,
+			}
+
+			payloadProof, err = blocks.PayloadProof(ctx, block.Block())
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get execution payload proof")
+			}
 		}
+
 		m = &pb.LightClientHeaderCapella{
-			Beacon:          beacon,
+			Beacon: &pb.BeaconBlockHeader{
+				Slot:          block.Block().Slot(),
+				ProposerIndex: block.Block().ProposerIndex(),
+				ParentRoot:    parentRoot[:],
+				StateRoot:     stateRoot[:],
+				BodyRoot:      bodyRoot[:],
+			},
 			Execution:       payloadHeader,
 			ExecutionBranch: payloadProof,
 		}
-	case version.Deneb, version.Electra, version.Fulu:
-		payloadHeader, payloadProof, err := makeExecutionAndProofDeneb(ctx, block)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not make execution payload header and proof")
+	} else {
+		var payloadHeader *enginev1.ExecutionPayloadHeaderDeneb
+		var payloadProof [][]byte
+
+		if blockEpoch < params.BeaconConfig().CapellaForkEpoch {
+			var ok bool
+
+			p, err := execution.EmptyExecutionPayloadHeader(version.Deneb)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get payload header")
+			}
+			payloadHeader, ok = p.(*enginev1.ExecutionPayloadHeaderDeneb)
+			if !ok {
+				return nil, fmt.Errorf("payload header type %T is not %T", p, &enginev1.ExecutionPayloadHeaderDeneb{})
+			}
+			payloadProof = emptyPayloadProof()
+		} else {
+			payload, err := block.Block().Body().Execution()
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get execution payload")
+			}
+			transactionsRoot, err := ComputeTransactionsRoot(payload)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get transactions root")
+			}
+			withdrawalsRoot, err := ComputeWithdrawalsRoot(payload)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get withdrawals root")
+			}
+
+			var blobGasUsed uint64
+			var excessBlobGas uint64
+
+			if blockEpoch >= params.BeaconConfig().DenebForkEpoch {
+				blobGasUsed, err = payload.BlobGasUsed()
+				if err != nil {
+					return nil, errors.Wrap(err, "could not get blob gas used")
+				}
+				excessBlobGas, err = payload.ExcessBlobGas()
+				if err != nil {
+					return nil, errors.Wrap(err, "could not get excess blob gas")
+				}
+			}
+
+			payloadHeader = &enginev1.ExecutionPayloadHeaderDeneb{
+				ParentHash:       payload.ParentHash(),
+				FeeRecipient:     payload.FeeRecipient(),
+				StateRoot:        payload.StateRoot(),
+				ReceiptsRoot:     payload.ReceiptsRoot(),
+				LogsBloom:        payload.LogsBloom(),
+				PrevRandao:       payload.PrevRandao(),
+				BlockNumber:      payload.BlockNumber(),
+				GasLimit:         payload.GasLimit(),
+				GasUsed:          payload.GasUsed(),
+				Timestamp:        payload.Timestamp(),
+				ExtraData:        payload.ExtraData(),
+				BaseFeePerGas:    payload.BaseFeePerGas(),
+				BlockHash:        payload.BlockHash(),
+				TransactionsRoot: transactionsRoot,
+				WithdrawalsRoot:  withdrawalsRoot,
+				BlobGasUsed:      blobGasUsed,
+				ExcessBlobGas:    excessBlobGas,
+			}
+
+			payloadProof, err = blocks.PayloadProof(ctx, block.Block())
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get execution payload proof")
+			}
 		}
+
 		m = &pb.LightClientHeaderDeneb{
-			Beacon:          beacon,
+			Beacon: &pb.BeaconBlockHeader{
+				Slot:          block.Block().Slot(),
+				ProposerIndex: block.Block().ProposerIndex(),
+				ParentRoot:    parentRoot[:],
+				StateRoot:     stateRoot[:],
+				BodyRoot:      bodyRoot[:],
+			},
 			Execution:       payloadHeader,
 			ExecutionBranch: payloadProof,
 		}
-	default:
-		return nil, fmt.Errorf("unsupported attested block version %s", version.String(attestedBlockVersion))
 	}
 
 	return light_client.NewWrappedHeader(m)
 }
 
+func emptyPayloadProof() [][]byte {
+	branch := interfaces.LightClientExecutionBranch{}
+	proof := make([][]byte, len(branch))
+	for i, b := range branch {
+		proof[i] = b[:]
+	}
+	return proof
+}
+
 func HasRelevantSyncCommittee(update interfaces.LightClientUpdate) (bool, error) {
 	if update.Version() >= version.Electra {
 		branch, err := update.NextSyncCommitteeBranchElectra()
@@ -717,7 +909,7 @@ func NewLightClientBootstrapFromBeaconState(
 		return nil, errors.Wrap(err, "could not create default light client bootstrap")
 	}
 
-	lightClientHeader, err := BlockToLightClientHeader(ctx, state.Version(), block)
+	lightClientHeader, err := BlockToLightClientHeader(ctx, currentSlot, block)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert block to light client header")
 	}
@@ -750,6 +942,78 @@ func NewLightClientBootstrapFromBeaconState(
 	return bootstrap, nil
 }
 
+func createDefaultLightClientBootstrap(currentSlot primitives.Slot) (interfaces.LightClientBootstrap, error) {
+	currentEpoch := slots.ToEpoch(currentSlot)
+	syncCommitteeSize := params.BeaconConfig().SyncCommitteeSize
+	pubKeys := make([][]byte, syncCommitteeSize)
+	for i := uint64(0); i < syncCommitteeSize; i++ {
+		pubKeys[i] = make([]byte, fieldparams.BLSPubkeyLength)
+	}
+	currentSyncCommittee := &pb.SyncCommittee{
+		Pubkeys:         pubKeys,
+		AggregatePubkey: make([]byte, fieldparams.BLSPubkeyLength),
+	}
+
+	var currentSyncCommitteeBranch [][]byte
+	if currentEpoch >= params.BeaconConfig().ElectraForkEpoch {
+		currentSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepthElectra)
+	} else {
+		currentSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepth)
+	}
+	for i := 0; i < len(currentSyncCommitteeBranch); i++ {
+		currentSyncCommitteeBranch[i] = make([]byte, fieldparams.RootLength)
+	}
+
+	executionBranch := make([][]byte, fieldparams.ExecutionBranchDepth)
+	for i := 0; i < fieldparams.ExecutionBranchDepth; i++ {
+		executionBranch[i] = make([]byte, 32)
+	}
+
+	// TODO: can this be based on the current epoch?
+	var m proto.Message
+	if currentEpoch < params.BeaconConfig().CapellaForkEpoch {
+		m = &pb.LightClientBootstrapAltair{
+			Header: &pb.LightClientHeaderAltair{
+				Beacon: &pb.BeaconBlockHeader{},
+			},
+			CurrentSyncCommittee:       currentSyncCommittee,
+			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
+		}
+	} else if currentEpoch < params.BeaconConfig().DenebForkEpoch {
+		m = &pb.LightClientBootstrapCapella{
+			Header: &pb.LightClientHeaderCapella{
+				Beacon:          &pb.BeaconBlockHeader{},
+				Execution:       &enginev1.ExecutionPayloadHeaderCapella{},
+				ExecutionBranch: executionBranch,
+			},
+			CurrentSyncCommittee:       currentSyncCommittee,
+			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
+		}
+	} else if currentEpoch < params.BeaconConfig().ElectraForkEpoch {
+		m = &pb.LightClientBootstrapDeneb{
+			Header: &pb.LightClientHeaderDeneb{
+				Beacon:          &pb.BeaconBlockHeader{},
+				Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
+				ExecutionBranch: executionBranch,
+			},
+			CurrentSyncCommittee:       currentSyncCommittee,
+			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
+		}
+	} else {
+		m = &pb.LightClientBootstrapElectra{
+			Header: &pb.LightClientHeaderDeneb{
+				Beacon:          &pb.BeaconBlockHeader{},
+				Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
+				ExecutionBranch: executionBranch,
+			},
+			CurrentSyncCommittee:       currentSyncCommittee,
+			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
+		}
+	}
+
+	return light_client.NewWrappedBootstrap(m)
+}
+
 func UpdateHasSupermajority(syncAggregate *pb.SyncAggregate) bool {
 	maxActiveParticipants := syncAggregate.SyncCommitteeBits.Len()
 	numActiveParticipants := syncAggregate.SyncCommitteeBits.Count()

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

@@ -7,6 +7,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	light_client "github.com/OffchainLabs/prysm/v6/consensus-types/light-client"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 
 	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
@@ -546,7 +547,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 		header, err := lightClient.BlockToLightClientHeader(
 			l.Ctx,
-			version.Altair,
+			primitives.Slot(params.BeaconConfig().AltairForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 			l.Block,
 		)
 		require.NoError(t, err)
@@ -569,7 +570,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 		header, err := lightClient.BlockToLightClientHeader(
 			l.Ctx,
-			version.Bellatrix,
+			primitives.Slot(params.BeaconConfig().BellatrixForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 			l.Block,
 		)
 		require.NoError(t, err)
@@ -593,7 +594,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				version.Capella,
+				primitives.Slot(params.BeaconConfig().CapellaForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 				l.Block,
 			)
 			require.NoError(t, err)
@@ -654,7 +655,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				version.Capella,
+				primitives.Slot(params.BeaconConfig().CapellaForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 				l.Block,
 			)
 			require.NoError(t, err)
@@ -717,7 +718,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				version.Deneb,
+				primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 				l.Block,
 			)
 			require.NoError(t, err)
@@ -786,7 +787,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				version.Deneb,
+				primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 				l.Block,
 			)
 			require.NoError(t, err)
@@ -855,7 +856,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 		t.Run("Non-Blinded Beacon Block", func(t *testing.T) {
 			l := util.NewTestLightClient(t, version.Electra)
 
-			header, err := lightClient.BlockToLightClientHeader(l.Ctx, version.Electra, l.Block)
+			header, err := lightClient.BlockToLightClientHeader(l.Ctx, l.State.Slot(), l.Block)
 			require.NoError(t, err)
 			require.NotNil(t, header, "header is nil")
 
@@ -920,7 +921,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 		t.Run("Blinded Beacon Block", func(t *testing.T) {
 			l := util.NewTestLightClient(t, version.Electra, util.WithBlinded())
 
-			header, err := lightClient.BlockToLightClientHeader(l.Ctx, version.Electra, l.Block)
+			header, err := lightClient.BlockToLightClientHeader(l.Ctx, l.State.Slot(), l.Block)
 			require.NoError(t, err)
 			require.NotNil(t, header, "header is nil")
 
@@ -988,7 +989,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 		header, err := lightClient.BlockToLightClientHeader(
 			l.Ctx,
-			version.Capella,
+			primitives.Slot(params.BeaconConfig().CapellaForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 			l.Block)
 		require.NoError(t, err)
 		require.NotNil(t, header, "header is nil")
@@ -1010,7 +1011,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 		header, err := lightClient.BlockToLightClientHeader(
 			l.Ctx,
-			version.Deneb,
+			primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 			l.Block)
 		require.NoError(t, err)
 		require.NotNil(t, header, "header is nil")
@@ -1033,7 +1034,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				version.Deneb,
+				primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 				l.Block)
 			require.NoError(t, err)
 			require.NotNil(t, header, "header is nil")
@@ -1093,7 +1094,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				version.Deneb,
+				primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
 				l.Block)
 			require.NoError(t, err)
 			require.NotNil(t, header, "header is nil")
@@ -1179,13 +1180,14 @@ func createNonEmptyFinalityBranch() [][]byte {
 }
 
 func TestIsBetterUpdate(t *testing.T) {
-	blk, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockAltair())
+	config := params.BeaconConfig()
+	st, err := util.NewBeaconStateAltair()
 	require.NoError(t, err)
 
 	t.Run("new has supermajority but old doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1201,9 +1203,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("old has supermajority but new doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1219,9 +1221,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new doesn't have supermajority and newNumActiveParticipants is greater than oldNumActiveParticipants", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1237,9 +1239,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new doesn't have supermajority and newNumActiveParticipants is lesser than oldNumActiveParticipants", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1255,9 +1257,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new has relevant sync committee but old doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1294,9 +1296,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("old has relevant sync committee but new doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1333,9 +1335,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new has finality but old doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1376,9 +1378,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("old has finality but new doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1419,9 +1421,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new has finality and sync committee finality both but old doesn't have sync committee finality", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1480,9 +1482,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new has finality but doesn't have sync committee finality and old has sync committee finality", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1541,9 +1543,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new has more active participants than old", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1559,9 +1561,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new has less active participants than old", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1577,9 +1579,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new's attested header's slot is lesser than old's attested header's slot", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1638,9 +1640,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new's attested header's slot is greater than old's attested header's slot", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1699,9 +1701,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("none of the above conditions are met and new signature's slot is less than old signature's slot", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1760,9 +1762,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("none of the above conditions are met and new signature's slot is greater than old signature's slot", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{

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

@@ -13,10 +13,6 @@ type Store struct {
 	lastOptimisticUpdate interfaces.LightClientOptimisticUpdate
 }
 
-func NewLightClientStore() *Store {
-	return &Store{}
-}
-
 func (s *Store) SetLastFinalityUpdate(update interfaces.LightClientFinalityUpdate) {
 	s.mu.Lock()
 	defer s.mu.Unlock()

beacon-chain/core/peerdas/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
         "info.go",
         "metrics.go",
         "p2p_interface.go",
+        "peer_sampling.go",
         "reconstruction.go",
         "validator.go",
         "verification.go",
@@ -44,6 +45,7 @@ go_test(
         "das_core_test.go",
         "info_test.go",
         "p2p_interface_test.go",
+        "peer_sampling_test.go",
         "reconstruction_test.go",
         "utils_test.go",
         "validator_test.go",

beacon-chain/core/peerdas/peer_sampling.go

@@ -0,0 +1,56 @@
+package peerdas
+
+import (
+	"math/big"
+
+	"github.com/OffchainLabs/prysm/v6/config/params"
+)
+
+// ExtendedSampleCount computes, for a given number of samples per slot and allowed failures the
+// number of samples we should actually query from peers.
+// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/peer-sampling.md#get_extended_sample_count
+func ExtendedSampleCount(samplesPerSlot, allowedFailures uint64) uint64 {
+	// Retrieve the columns count
+	columnsCount := params.BeaconConfig().NumberOfColumns
+
+	// If half of the columns are missing, we are able to reconstruct the data.
+	// If half of the columns + 1 are missing, we are not able to reconstruct the data.
+	// This is the smallest worst case.
+	worstCaseMissing := columnsCount/2 + 1
+
+	// Compute the false positive threshold.
+	falsePositiveThreshold := HypergeomCDF(0, columnsCount, worstCaseMissing, samplesPerSlot)
+
+	var sampleCount uint64
+
+	// Finally, compute the extended sample count.
+	for sampleCount = samplesPerSlot; sampleCount < columnsCount+1; sampleCount++ {
+		if HypergeomCDF(allowedFailures, columnsCount, worstCaseMissing, sampleCount) <= falsePositiveThreshold {
+			break
+		}
+	}
+
+	return sampleCount
+}
+
+// HypergeomCDF computes the hypergeometric cumulative distribution function.
+// https://en.wikipedia.org/wiki/Hypergeometric_distribution
+func HypergeomCDF(k, M, n, N uint64) float64 {
+	denominatorInt := new(big.Int).Binomial(int64(M), int64(N)) // lint:ignore uintcast
+	denominator := new(big.Float).SetInt(denominatorInt)
+
+	rBig := big.NewFloat(0)
+
+	for i := uint64(0); i < k+1; i++ {
+		a := new(big.Int).Binomial(int64(n), int64(i)) // lint:ignore uintcast
+		b := new(big.Int).Binomial(int64(M-n), int64(N-i))
+		numeratorInt := new(big.Int).Mul(a, b)
+		numerator := new(big.Float).SetInt(numeratorInt)
+		item := new(big.Float).Quo(numerator, denominator)
+		rBig.Add(rBig, item)
+	}
+
+	r, _ := rBig.Float64()
+
+	return r
+}

beacon-chain/core/peerdas/peer_sampling_test.go

@@ -0,0 +1,60 @@
+package peerdas_test
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+)
+
+func TestExtendedSampleCount(t *testing.T) {
+	const samplesPerSlot = 16
+
+	testCases := []struct {
+		name                string
+		allowedMissings     uint64
+		extendedSampleCount uint64
+	}{
+		{name: "allowedMissings=0", allowedMissings: 0, extendedSampleCount: 16},
+		{name: "allowedMissings=1", allowedMissings: 1, extendedSampleCount: 20},
+		{name: "allowedMissings=2", allowedMissings: 2, extendedSampleCount: 24},
+		{name: "allowedMissings=3", allowedMissings: 3, extendedSampleCount: 27},
+		{name: "allowedMissings=4", allowedMissings: 4, extendedSampleCount: 29},
+		{name: "allowedMissings=5", allowedMissings: 5, extendedSampleCount: 32},
+		{name: "allowedMissings=6", allowedMissings: 6, extendedSampleCount: 35},
+		{name: "allowedMissings=7", allowedMissings: 7, extendedSampleCount: 37},
+		{name: "allowedMissings=8", allowedMissings: 8, extendedSampleCount: 40},
+		{name: "allowedMissings=9", allowedMissings: 9, extendedSampleCount: 42},
+		{name: "allowedMissings=10", allowedMissings: 10, extendedSampleCount: 44},
+		{name: "allowedMissings=11", allowedMissings: 11, extendedSampleCount: 47},
+		{name: "allowedMissings=12", allowedMissings: 12, extendedSampleCount: 49},
+		{name: "allowedMissings=13", allowedMissings: 13, extendedSampleCount: 51},
+		{name: "allowedMissings=14", allowedMissings: 14, extendedSampleCount: 53},
+		{name: "allowedMissings=15", allowedMissings: 15, extendedSampleCount: 55},
+		{name: "allowedMissings=16", allowedMissings: 16, extendedSampleCount: 57},
+		{name: "allowedMissings=17", allowedMissings: 17, extendedSampleCount: 59},
+		{name: "allowedMissings=18", allowedMissings: 18, extendedSampleCount: 61},
+		{name: "allowedMissings=19", allowedMissings: 19, extendedSampleCount: 63},
+		{name: "allowedMissings=20", allowedMissings: 20, extendedSampleCount: 65},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := peerdas.ExtendedSampleCount(samplesPerSlot, tc.allowedMissings)
+			require.Equal(t, tc.extendedSampleCount, result)
+		})
+	}
+}
+
+func TestHypergeomCDF(t *testing.T) {
+	// Test case from https://en.wikipedia.org/wiki/Hypergeometric_distribution
+	// Population size: 1000, number of successes in population: 500, sample size: 10, number of successes in sample: 5
+	// Expected result: 0.072
+	const (
+		expected = 0.0796665913283742
+		margin   = 0.000001
+	)
+
+	actual := peerdas.HypergeomCDF(5, 128, 65, 16)
+	require.Equal(t, true, expected-margin <= actual && actual <= expected+margin)
+}

beacon-chain/core/signing/signing_root_test.go

@@ -2,6 +2,7 @@ package signing_test
 
 import (
 	"bytes"
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
@@ -82,7 +83,7 @@ func TestSigningRoot_ComputeDomainAndSign(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			beaconState, privKeys := tt.genState(t)
-			idx, err := helpers.BeaconProposerIndex(t.Context(), beaconState)
+			idx, err := helpers.BeaconProposerIndex(context.Background(), beaconState)
 			require.NoError(t, err)
 			block := tt.genBlock(t, beaconState, privKeys)
 			got, err := signing.ComputeDomainAndSign(

beacon-chain/core/time/slot_epoch.go

@@ -53,6 +53,11 @@ func HigherEqualThanAltairVersionAndEpoch(s state.BeaconState, e primitives.Epoc
 	return s.Version() >= version.Altair && e >= params.BeaconConfig().AltairForkEpoch
 }
 
+// PeerDASIsActive checks whether peerDAS is active at the provided slot.
+func PeerDASIsActive(slot primitives.Slot) bool {
+	return params.FuluEnabled() && slots.ToEpoch(slot) >= params.BeaconConfig().FuluForkEpoch
+}
+
 // CanUpgradeToAltair returns true if the input `slot` can upgrade to Altair.
 // Spec code:
 // If state.slot % SLOTS_PER_EPOCH == 0 and compute_epoch_at_slot(state.slot) == ALTAIR_FORK_EPOCH

beacon-chain/core/transition/altair_transition_no_verify_sig_test.go

@@ -1,6 +1,7 @@
 package transition_test
 
 import (
+	"context"
 	"math"
 	"testing"
 
@@ -26,7 +27,7 @@ import (
 func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, 100)
 
-	syncCommittee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	syncCommittee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetCurrentSyncCommittee(syncCommittee))
 
@@ -50,11 +51,11 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetSlot(slots.PrevSlot(beaconState.Slot())))
 
-	nextSlotState, err := transition.ProcessSlots(t.Context(), beaconState.Copy(), beaconState.Slot()+1)
+	nextSlotState, err := transition.ProcessSlots(context.Background(), beaconState.Copy(), beaconState.Slot()+1)
 	require.NoError(t, err)
 	parentRoot, err := nextSlotState.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), nextSlotState)
+	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), nextSlotState)
 	require.NoError(t, err)
 	block := util.NewBeaconBlockAltair()
 	block.Block.ProposerIndex = proposerIdx
@@ -67,10 +68,10 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 	for i := range syncBits {
 		syncBits[i] = 0xff
 	}
-	indices, err := altair.NextSyncCommitteeIndices(t.Context(), beaconState)
+	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
 	h := beaconState.LatestBlockHeader().Copy()
-	prevStateRoot, err := beaconState.HashTreeRoot(t.Context())
+	prevStateRoot, err := beaconState.HashTreeRoot(context.Background())
 	require.NoError(t, err)
 	h.StateRoot = prevStateRoot[:]
 	pbr, err := h.HashTreeRoot()
@@ -92,7 +93,7 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 	block.Block.Body.SyncAggregate = syncAggregate
 	wsb, err := blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	stateRoot, err := transition.CalculateStateRoot(t.Context(), beaconState, wsb)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 	block.Block.StateRoot = stateRoot[:]
 
@@ -103,7 +104,7 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 
 	wsb, err = blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(t.Context(), beaconState, wsb)
+	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 	verified, err := set.Verify()
 	require.NoError(t, err)
@@ -113,7 +114,7 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, 100)
 
-	syncCommittee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	syncCommittee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetCurrentSyncCommittee(syncCommittee))
 
@@ -137,11 +138,11 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetSlot(slots.PrevSlot(beaconState.Slot())))
 
-	nextSlotState, err := transition.ProcessSlots(t.Context(), beaconState.Copy(), beaconState.Slot()+1)
+	nextSlotState, err := transition.ProcessSlots(context.Background(), beaconState.Copy(), beaconState.Slot()+1)
 	require.NoError(t, err)
 	parentRoot, err := nextSlotState.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), nextSlotState)
+	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), nextSlotState)
 	require.NoError(t, err)
 	block := util.NewBeaconBlockAltair()
 	block.Block.ProposerIndex = proposerIdx
@@ -154,10 +155,10 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
 	for i := range syncBits {
 		syncBits[i] = 0xff
 	}
-	indices, err := altair.NextSyncCommitteeIndices(t.Context(), beaconState)
+	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
 	h := beaconState.LatestBlockHeader().Copy()
-	prevStateRoot, err := beaconState.HashTreeRoot(t.Context())
+	prevStateRoot, err := beaconState.HashTreeRoot(context.Background())
 	require.NoError(t, err)
 	h.StateRoot = prevStateRoot[:]
 	pbr, err := h.HashTreeRoot()
@@ -180,7 +181,7 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
 
 	wsb, err := blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	stateRoot, err := transition.CalculateStateRoot(t.Context(), beaconState, wsb)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 	block.Block.StateRoot = stateRoot[:]
 
@@ -192,7 +193,7 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
 	block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
 	wsb, err = blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(t.Context(), beaconState, wsb)
+	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "could not validate state root", err)
 }
 
@@ -200,7 +201,7 @@ func TestExecuteStateTransitionNoVerifyAnySig_PassesProcessingConditions(t *test
 	beaconState, block := createFullAltairBlockWithOperations(t)
 	wsb, err := blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(t.Context(), beaconState, wsb)
+	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 	// Test Signature set verifies.
 	verified, err := set.Verify()
@@ -225,14 +226,14 @@ func TestProcessEpoch_BadBalanceAltair(t *testing.T) {
 	epochParticipation[0] = participation
 	assert.NoError(t, s.SetCurrentParticipationBits(epochParticipation))
 	assert.NoError(t, s.SetPreviousParticipationBits(epochParticipation))
-	err = altair.ProcessEpoch(t.Context(), s)
+	err = altair.ProcessEpoch(context.Background(), s)
 	assert.ErrorContains(t, "addition overflows", err)
 }
 
 func createFullAltairBlockWithOperations(t *testing.T) (state.BeaconState,
 	*ethpb.SignedBeaconBlockAltair) {
 	beaconState, privKeys := util.DeterministicGenesisStateAltair(t, 32)
-	sCom, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	sCom, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	assert.NoError(t, err)
 	assert.NoError(t, beaconState.SetCurrentSyncCommittee(sCom))
 	tState := beaconState.Copy()

beacon-chain/core/transition/bellatrix_transition_no_verify_sig_test.go

@@ -1,6 +1,7 @@
 package transition_test
 
 import (
+	"context"
 	"math"
 	"testing"
 
@@ -28,7 +29,7 @@ import (
 func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100)
 
-	syncCommittee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	syncCommittee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetCurrentSyncCommittee(syncCommittee))
 
@@ -52,11 +53,11 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetSlot(slots.PrevSlot(beaconState.Slot())))
 
-	nextSlotState, err := transition.ProcessSlots(t.Context(), beaconState.Copy(), beaconState.Slot()+1)
+	nextSlotState, err := transition.ProcessSlots(context.Background(), beaconState.Copy(), beaconState.Slot()+1)
 	require.NoError(t, err)
 	parentRoot, err := nextSlotState.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), nextSlotState)
+	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), nextSlotState)
 	require.NoError(t, err)
 	block := util.NewBeaconBlockBellatrix()
 	block.Block.ProposerIndex = proposerIdx
@@ -69,10 +70,10 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 	for i := range syncBits {
 		syncBits[i] = 0xff
 	}
-	indices, err := altair.NextSyncCommitteeIndices(t.Context(), beaconState)
+	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
 	h := beaconState.LatestBlockHeader().Copy()
-	prevStateRoot, err := beaconState.HashTreeRoot(t.Context())
+	prevStateRoot, err := beaconState.HashTreeRoot(context.Background())
 	require.NoError(t, err)
 	h.StateRoot = prevStateRoot[:]
 	pbr, err := h.HashTreeRoot()
@@ -94,7 +95,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 	block.Block.Body.SyncAggregate = syncAggregate
 	wsb, err := blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	stateRoot, err := transition.CalculateStateRoot(t.Context(), beaconState, wsb)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 	block.Block.StateRoot = stateRoot[:]
 
@@ -105,7 +106,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 
 	wsb, err = blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(t.Context(), beaconState, wsb)
+	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 	verified, err := set.Verify()
 	require.NoError(t, err)
@@ -115,7 +116,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100)
 
-	syncCommittee, err := altair.NextSyncCommittee(t.Context(), beaconState)
+	syncCommittee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetCurrentSyncCommittee(syncCommittee))
 
@@ -139,11 +140,11 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetSlot(slots.PrevSlot(beaconState.Slot())))
 
-	nextSlotState, err := transition.ProcessSlots(t.Context(), beaconState.Copy(), beaconState.Slot()+1)
+	nextSlotState, err := transition.ProcessSlots(context.Background(), beaconState.Copy(), beaconState.Slot()+1)
 	require.NoError(t, err)
 	parentRoot, err := nextSlotState.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
-	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), nextSlotState)
+	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), nextSlotState)
 	require.NoError(t, err)
 	block := util.NewBeaconBlockBellatrix()
 	block.Block.ProposerIndex = proposerIdx
@@ -156,10 +157,10 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	for i := range syncBits {
 		syncBits[i] = 0xff
 	}
-	indices, err := altair.NextSyncCommitteeIndices(t.Context(), beaconState)
+	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
 	h := beaconState.LatestBlockHeader().Copy()
-	prevStateRoot, err := beaconState.HashTreeRoot(t.Context())
+	prevStateRoot, err := beaconState.HashTreeRoot(context.Background())
 	require.NoError(t, err)
 	h.StateRoot = prevStateRoot[:]
 	pbr, err := h.HashTreeRoot()
@@ -182,7 +183,7 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 
 	wsb, err := blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	stateRoot, err := transition.CalculateStateRoot(t.Context(), beaconState, wsb)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 	block.Block.StateRoot = stateRoot[:]
 
@@ -194,7 +195,7 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
 	wsb, err = blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(t.Context(), beaconState, wsb)
+	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "could not validate state root", err)
 }
 
@@ -215,7 +216,7 @@ func TestProcessEpoch_BadBalanceBellatrix(t *testing.T) {
 	epochParticipation[0] = participation
 	assert.NoError(t, s.SetCurrentParticipationBits(epochParticipation))
 	assert.NoError(t, s.SetPreviousParticipationBits(epochParticipation))
-	err = altair.ProcessEpoch(t.Context(), s)
+	err = altair.ProcessEpoch(context.Background(), s)
 	assert.ErrorContains(t, "addition overflows", err)
 }
 

beacon-chain/core/transition/benchmarks_test.go

@@ -1,6 +1,7 @@
 package transition_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
@@ -32,7 +33,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(b.Context(), cleanStates[i], wsb)
+		_, err = coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wsb)
 		require.NoError(b, err)
 	}
 }
@@ -52,19 +53,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(b.Context(), beaconState, time.CurrentEpoch(beaconState)))
+	require.NoError(b, helpers.UpdateCommitteeCache(context.Background(), 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(b.Context(), beaconState, wsb)
+	_, err = coreState.ExecuteStateTransition(context.Background(), 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(b.Context(), cleanStates[i], wsb)
+		_, err = coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wsb)
 		require.NoError(b, err, "Failed to process block, benchmarks will fail")
 	}
 }
@@ -80,14 +81,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(b.Context(), beaconState, time.CurrentEpoch(beaconState)))
+	require.NoError(b, helpers.UpdateCommitteeCache(context.Background(), 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(b.Context(), beaconState.Copy())
+		_, err := coreState.ProcessEpochPrecompute(context.Background(), beaconState.Copy())
 		require.NoError(b, err)
 	}
 }
@@ -98,7 +99,7 @@ func BenchmarkHashTreeRoot_FullState(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_, err := beaconState.HashTreeRoot(b.Context())
+		_, err := beaconState.HashTreeRoot(context.Background())
 		require.NoError(b, err)
 	}
 }
@@ -107,7 +108,7 @@ func BenchmarkHashTreeRootState_FullState(b *testing.B) {
 	beaconState, err := benchmark.PreGenstateFullEpochs()
 	require.NoError(b, err)
 
-	ctx := b.Context()
+	ctx := context.Background()
 
 	// Hydrate the HashTreeRootState cache.
 	_, err = beaconState.HashTreeRoot(ctx)