Reduce val index cache

* Reword DV selection proofs

* Add changelog

* Expect 1 call to DomainData in DV update duties test

---------

Co-authored-by: james-prysm <90280386+james-prysm@users.noreply.github.com>

BUILD.bazel

@@ -194,6 +194,7 @@ nogo(
         "//tools/analyzers/gocognit:go_default_library",
         "//tools/analyzers/ineffassign:go_default_library",
         "//tools/analyzers/interfacechecker:go_default_library",
+        "//tools/analyzers/logcapitalization:go_default_library",
         "//tools/analyzers/logruswitherror:go_default_library",
         "//tools/analyzers/maligned:go_default_library",
         "//tools/analyzers/nop:go_default_library",

api/client/beacon/health/BUILD.bazel

@@ -1,20 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "health.go",
-        "interfaces.go",
-        "mock.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v6/api/client/beacon/health",
-    visibility = ["//visibility:public"],
-    deps = ["@org_uber_go_mock//gomock:go_default_library"],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["health_test.go"],
-    embed = [":go_default_library"],
-    deps = ["@org_uber_go_mock//gomock:go_default_library"],
-)

api/client/beacon/health/health.go

@@ -1,58 +0,0 @@
-package health
-
-import (
-	"context"
-	"sync"
-)
-
-type NodeHealthTracker struct {
-	isHealthy  *bool
-	healthChan chan bool
-	node       Node
-	sync.RWMutex
-}
-
-func NewTracker(node Node) Tracker {
-	return &NodeHealthTracker{
-		node:       node,
-		healthChan: make(chan bool, 1),
-	}
-}
-
-// HealthUpdates provides a read-only channel for health updates.
-func (n *NodeHealthTracker) HealthUpdates() <-chan bool {
-	return n.healthChan
-}
-
-func (n *NodeHealthTracker) IsHealthy(_ context.Context) bool {
-	n.RLock()
-	defer n.RUnlock()
-	if n.isHealthy == nil {
-		return false
-	}
-	return *n.isHealthy
-}
-
-func (n *NodeHealthTracker) CheckHealth(ctx context.Context) bool {
-	n.Lock()
-	defer n.Unlock()
-
-	newStatus := n.node.IsHealthy(ctx)
-	if n.isHealthy == nil {
-		n.isHealthy = &newStatus
-	}
-
-	isStatusChanged := newStatus != *n.isHealthy
-	if isStatusChanged {
-		// Update the health status
-		n.isHealthy = &newStatus
-		// Send the new status to the health channel, potentially overwriting the existing value
-		select {
-		case <-n.healthChan:
-			n.healthChan <- newStatus
-		default:
-			n.healthChan <- newStatus
-		}
-	}
-	return newStatus
-}

api/client/beacon/health/health_test.go

@@ -1,110 +0,0 @@
-package health
-
-import (
-	"sync"
-	"testing"
-
-	"go.uber.org/mock/gomock"
-)
-
-func TestNodeHealth_IsHealthy(t *testing.T) {
-	tests := []struct {
-		name      string
-		isHealthy bool
-		want      bool
-	}{
-		{"initially healthy", true, true},
-		{"initially unhealthy", false, false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			n := &NodeHealthTracker{
-				isHealthy:  &tt.isHealthy,
-				healthChan: make(chan bool, 1),
-			}
-			if got := n.IsHealthy(t.Context()); got != tt.want {
-				t.Errorf("IsHealthy() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestNodeHealth_UpdateNodeHealth(t *testing.T) {
-	tests := []struct {
-		name       string
-		initial    bool // Initial health status
-		newStatus  bool // Status to update to
-		shouldSend bool // Should a message be sent through the channel
-	}{
-		{"healthy to unhealthy", true, false, true},
-		{"unhealthy to healthy", false, true, true},
-		{"remain healthy", true, true, false},
-		{"remain unhealthy", false, false, false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ctrl := gomock.NewController(t)
-			defer ctrl.Finish()
-			client := NewMockHealthClient(ctrl)
-			client.EXPECT().IsHealthy(gomock.Any()).Return(tt.newStatus)
-			n := &NodeHealthTracker{
-				isHealthy:  &tt.initial,
-				node:       client,
-				healthChan: make(chan bool, 1),
-			}
-
-			s := n.CheckHealth(t.Context())
-			// 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)
-			}
-
-			select {
-			case status := <-n.HealthUpdates():
-				if !tt.shouldSend {
-					t.Errorf("UpdateNodeHealth() unexpectedly sent status %v to HealthCh", status)
-				} else if status != tt.newStatus {
-					t.Errorf("UpdateNodeHealth() sent wrong status %v, want %v", status, tt.newStatus)
-				}
-			default:
-				if tt.shouldSend {
-					t.Error("UpdateNodeHealth() did not send any status to HealthCh when expected")
-				}
-			}
-		})
-	}
-}
-
-func TestNodeHealth_Concurrency(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	client := NewMockHealthClient(ctrl)
-	n := NewTracker(client)
-	var wg sync.WaitGroup
-
-	// Number of goroutines to spawn for both reading and writing
-	numGoroutines := 6
-
-	wg.Add(numGoroutines * 2) // for readers and writers
-
-	// Concurrently update health status
-	for i := 0; i < numGoroutines; i++ {
-		go func() {
-			defer wg.Done()
-			client.EXPECT().IsHealthy(gomock.Any()).Return(false).Times(1)
-			n.CheckHealth(t.Context())
-			client.EXPECT().IsHealthy(gomock.Any()).Return(true).Times(1)
-			n.CheckHealth(t.Context())
-		}()
-	}
-
-	// Concurrently read health status
-	for i := 0; i < numGoroutines; i++ {
-		go func() {
-			defer wg.Done()
-			_ = n.IsHealthy(t.Context()) // Just read the value
-		}()
-	}
-
-	wg.Wait() // Wait for all goroutines to finish
-}

api/client/beacon/health/interfaces.go

@@ -1,13 +0,0 @@
-package health
-
-import "context"
-
-type Tracker interface {
-	HealthUpdates() <-chan bool
-	CheckHealth(ctx context.Context) bool
-	Node
-}
-
-type Node interface {
-	IsHealthy(ctx context.Context) bool
-}

api/client/beacon/health/mock.go

@@ -1,58 +0,0 @@
-package health
-
-import (
-	"context"
-	"reflect"
-	"sync"
-
-	"go.uber.org/mock/gomock"
-)
-
-var (
-	_ = Node(&MockHealthClient{})
-)
-
-// MockHealthClient is a mock of HealthClient interface.
-type MockHealthClient struct {
-	ctrl     *gomock.Controller
-	recorder *MockHealthClientMockRecorder
-	sync.Mutex
-}
-
-// MockHealthClientMockRecorder is the mock recorder for MockHealthClient.
-type MockHealthClientMockRecorder struct {
-	mock *MockHealthClient
-}
-
-// IsHealthy mocks base method.
-func (m *MockHealthClient) IsHealthy(arg0 context.Context) bool {
-	m.Lock()
-	defer m.Unlock()
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IsHealthy", arg0)
-	ret0, ok := ret[0].(bool)
-	if !ok {
-		return false
-	}
-	return ret0
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockHealthClient) EXPECT() *MockHealthClientMockRecorder {
-	return m.recorder
-}
-
-// IsHealthy indicates an expected call of IsHealthy.
-func (mr *MockHealthClientMockRecorder) IsHealthy(arg0 any) *gomock.Call {
-	mr.mock.Lock()
-	defer mr.mock.Unlock()
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHealthy", reflect.TypeOf((*MockHealthClient)(nil).IsHealthy), arg0)
-}
-
-// NewMockHealthClient creates a new mock instance.
-func NewMockHealthClient(ctrl *gomock.Controller) *MockHealthClient {
-	mock := &MockHealthClient{ctrl: ctrl}
-	mock.recorder = &MockHealthClientMockRecorder{mock}
-	return mock
-}

api/client/builder/client.go

@@ -72,7 +72,7 @@ func (*requestLogger) observe(r *http.Request) (e error) {
 		log.WithFields(log.Fields{
 			"bodyBase64": "(nil value)",
 			"url":        r.URL.String(),
-		}).Info("builder http request")
+		}).Info("Builder http request")
 		return nil
 	}
 	t := io.TeeReader(r.Body, b)
@@ -89,7 +89,7 @@ func (*requestLogger) observe(r *http.Request) (e error) {
 	log.WithFields(log.Fields{
 		"bodyBase64": string(body),
 		"url":        r.URL.String(),
-	}).Info("builder http request")
+	}).Info("Builder http request")
 
 	return nil
 }

async/every.go

@@ -19,10 +19,10 @@ func RunEvery(ctx context.Context, period time.Duration, f func()) {
 		for {
 			select {
 			case <-ticker.C:
-				log.WithField("function", funcName).Trace("running")
+				log.WithField("function", funcName).Trace("Running")
 				f()
 			case <-ctx.Done():
-				log.WithField("function", funcName).Debug("context is closed, exiting")
+				log.WithField("function", funcName).Debug("Context is closed, exiting")
 				ticker.Stop()
 				return
 			}

beacon-chain/blockchain/chain_info_norace_test.go

@@ -3,9 +3,6 @@ package blockchain
 import (
 	"testing"
 
-	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
-	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -14,10 +11,7 @@ import (
 )
 
 func TestHeadSlot_DataRace(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg: &config{BeaconDB: beaconDB},
-	}
+	s := testServiceWithDB(t)
 	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	st, _ := util.DeterministicGenesisState(t, 1)
@@ -31,11 +25,8 @@ func TestHeadSlot_DataRace(t *testing.T) {
 }
 
 func TestHeadRoot_DataRace(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB, doublylinkedtree.New())},
-		head: &head{root: [32]byte{'A'}},
-	}
+	s := testServiceWithDB(t)
+	s.head = &head{root: [32]byte{'A'}}
 	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	wait := make(chan struct{})
@@ -51,13 +42,10 @@ func TestHeadRoot_DataRace(t *testing.T) {
 }
 
 func TestHeadBlock_DataRace(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
 	wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}})
 	require.NoError(t, err)
-	s := &Service{
-		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB, doublylinkedtree.New())},
-		head: &head{block: wsb},
-	}
+	s := testServiceWithDB(t)
+	s.head = &head{block: wsb}
 	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	wait := make(chan struct{})
@@ -73,10 +61,8 @@ func TestHeadBlock_DataRace(t *testing.T) {
 }
 
 func TestHeadState_DataRace(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB, doublylinkedtree.New())},
-	}
+	s := testServiceWithDB(t)
+	beaconDB := s.cfg.BeaconDB
 	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	wait := make(chan struct{})

beacon-chain/blockchain/chain_info_test.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
-	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
@@ -138,7 +137,7 @@ func TestFinalizedBlockHash(t *testing.T) {
 
 func TestUnrealizedJustifiedBlockHash(t *testing.T) {
 	ctx := t.Context()
-	service := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
+	service := testServiceWithDB(t)
 	ojc := &ethpb.Checkpoint{Root: []byte{'j'}}
 	ofc := &ethpb.Checkpoint{Root: []byte{'f'}}
 	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
@@ -153,7 +152,7 @@ func TestUnrealizedJustifiedBlockHash(t *testing.T) {
 }
 
 func TestHeadSlot_CanRetrieve(t *testing.T) {
-	c := &Service{}
+	c := testServiceNoDB(t)
 	s, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{})
 	require.NoError(t, err)
 	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
@@ -200,7 +199,7 @@ func TestHeadBlock_CanRetrieve(t *testing.T) {
 	require.NoError(t, err)
 	wsb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	c := &Service{}
+	c := testServiceNoDB(t)
 	c.head = &head{block: wsb, state: s}
 
 	received, err := c.HeadBlock(t.Context())
@@ -213,7 +212,7 @@ func TestHeadBlock_CanRetrieve(t *testing.T) {
 func TestHeadState_CanRetrieve(t *testing.T) {
 	s, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{Slot: 2, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
 	require.NoError(t, err)
-	c := &Service{}
+	c := testServiceNoDB(t)
 	c.head = &head{state: s}
 	headState, err := c.HeadState(t.Context())
 	require.NoError(t, err)
@@ -221,7 +220,8 @@ func TestHeadState_CanRetrieve(t *testing.T) {
 }
 
 func TestGenesisTime_CanRetrieve(t *testing.T) {
-	c := &Service{genesisTime: time.Unix(999, 0)}
+	c := testServiceNoDB(t)
+	c.genesisTime = time.Unix(999, 0)
 	wanted := time.Unix(999, 0)
 	assert.Equal(t, wanted, c.GenesisTime(), "Did not get wanted genesis time")
 }
@@ -230,7 +230,7 @@ func TestCurrentFork_CanRetrieve(t *testing.T) {
 	f := &ethpb.Fork{Epoch: 999}
 	s, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{Fork: f})
 	require.NoError(t, err)
-	c := &Service{}
+	c := testServiceNoDB(t)
 	c.head = &head{state: s}
 	if !proto.Equal(c.CurrentFork(), f) {
 		t.Error("Received incorrect fork version")
@@ -242,7 +242,7 @@ func TestCurrentFork_NilHeadSTate(t *testing.T) {
 		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
 	}
-	c := &Service{}
+	c := testServiceNoDB(t)
 	if !proto.Equal(c.CurrentFork(), f) {
 		t.Error("Received incorrect fork version")
 	}
@@ -250,7 +250,7 @@ func TestCurrentFork_NilHeadSTate(t *testing.T) {
 
 func TestGenesisValidatorsRoot_CanRetrieve(t *testing.T) {
 	// Should not panic if head state is nil.
-	c := &Service{}
+	c := testServiceNoDB(t)
 	assert.Equal(t, [32]byte{}, c.GenesisValidatorsRoot(), "Did not get correct genesis validators root")
 
 	s, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{GenesisValidatorsRoot: []byte{'a'}})
@@ -269,7 +269,7 @@ func TestHeadETH1Data_CanRetrieve(t *testing.T) {
 	d := &ethpb.Eth1Data{DepositCount: 999}
 	s, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{Eth1Data: d})
 	require.NoError(t, err)
-	c := &Service{}
+	c := testServiceNoDB(t)
 	c.head = &head{state: s}
 	if !proto.Equal(c.HeadETH1Data(), d) {
 		t.Error("Received incorrect eth1 data")
@@ -298,7 +298,7 @@ func TestIsCanonical_Ok(t *testing.T) {
 
 func TestService_HeadValidatorsIndices(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 10)
-	c := &Service{}
+	c := testServiceNoDB(t)
 
 	c.head = &head{}
 	indices, err := c.HeadValidatorsIndices(t.Context(), 0)
@@ -313,7 +313,7 @@ func TestService_HeadValidatorsIndices(t *testing.T) {
 
 func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 1)
-	c := &Service{}
+	c := testServiceNoDB(t)
 
 	c.head = &head{}
 	root := c.HeadGenesisValidatorsRoot()
@@ -332,7 +332,7 @@ func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
 
 func TestService_ChainHeads(t *testing.T) {
 	ctx := t.Context()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
+	c := testServiceWithDB(t)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
@@ -366,7 +366,7 @@ func TestService_ChainHeads(t *testing.T) {
 
 func TestService_HeadPublicKeyToValidatorIndex(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 10)
-	c := &Service{}
+	c := testServiceNoDB(t)
 	c.head = &head{state: s}
 
 	_, e := c.HeadPublicKeyToValidatorIndex([fieldparams.BLSPubkeyLength]byte{})
@@ -381,7 +381,7 @@ func TestService_HeadPublicKeyToValidatorIndex(t *testing.T) {
 }
 
 func TestService_HeadPublicKeyToValidatorIndexNil(t *testing.T) {
-	c := &Service{}
+	c := testServiceNoDB(t)
 	c.head = nil
 
 	idx, e := c.HeadPublicKeyToValidatorIndex([fieldparams.BLSPubkeyLength]byte{})
@@ -396,7 +396,7 @@ func TestService_HeadPublicKeyToValidatorIndexNil(t *testing.T) {
 
 func TestService_HeadValidatorIndexToPublicKey(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 10)
-	c := &Service{}
+	c := testServiceNoDB(t)
 	c.head = &head{state: s}
 
 	p, err := c.HeadValidatorIndexToPublicKey(t.Context(), 0)
@@ -409,7 +409,7 @@ func TestService_HeadValidatorIndexToPublicKey(t *testing.T) {
 }
 
 func TestService_HeadValidatorIndexToPublicKeyNil(t *testing.T) {
-	c := &Service{}
+	c := testServiceNoDB(t)
 	c.head = nil
 
 	p, err := c.HeadValidatorIndexToPublicKey(t.Context(), 0)
@@ -431,7 +431,8 @@ func TestService_IsOptimistic(t *testing.T) {
 	ctx := t.Context()
 	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'}}}
+	c := testServiceWithDB(t)
+	c.head = &head{root: [32]byte{'b'}}
 	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
@@ -450,14 +451,15 @@ func TestService_IsOptimistic(t *testing.T) {
 	require.Equal(t, true, opt)
 
 	// If head is nil, for some reason, an error should be returned rather than panic.
-	c = &Service{}
+	c = testServiceNoDB(t)
 	_, err = c.IsOptimistic(ctx)
 	require.ErrorIs(t, err, ErrNilHead)
 }
 
 func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
 	ctx := t.Context()
-	c := &Service{genesisTime: time.Now()}
+	c := testServiceNoDB(t)
+	c.genesisTime = time.Now()
 	opt, err := c.IsOptimistic(ctx)
 	require.NoError(t, err)
 	require.Equal(t, false, opt)
@@ -465,7 +467,8 @@ func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
 
 func TestService_IsOptimisticForRoot(t *testing.T) {
 	ctx := t.Context()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
+	c := testServiceWithDB(t)
+	c.head = &head{root: [32]byte{'b'}}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
@@ -481,9 +484,10 @@ func TestService_IsOptimisticForRoot(t *testing.T) {
 }
 
 func TestService_IsOptimisticForRoot_DB(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
 	ctx := t.Context()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
+	c := testServiceWithDB(t)
+	c.head = &head{root: [32]byte{'b'}}
+	beaconDB := c.cfg.BeaconDB
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
@@ -534,9 +538,9 @@ func TestService_IsOptimisticForRoot_DB(t *testing.T) {
 }
 
 func TestService_IsOptimisticForRoot_DB_non_canonical(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
 	ctx := t.Context()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
+	c := testServiceWithDB(t)
+	beaconDB := c.cfg.BeaconDB
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
@@ -573,9 +577,9 @@ func TestService_IsOptimisticForRoot_DB_non_canonical(t *testing.T) {
 }
 
 func TestService_IsOptimisticForRoot_StateSummaryRecovered(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
 	ctx := t.Context()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
+	c := testServiceWithDB(t)
+	beaconDB := c.cfg.BeaconDB
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
@@ -593,9 +597,9 @@ func TestService_IsOptimisticForRoot_StateSummaryRecovered(t *testing.T) {
 }
 
 func TestService_IsFinalized(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
 	ctx := t.Context()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}}
+	c := testServiceWithDB(t)
+	beaconDB := c.cfg.BeaconDB
 	r1 := [32]byte{'a'}
 	require.NoError(t, c.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{
 		Root: r1,

beacon-chain/blockchain/defragment.go

@@ -2,7 +2,6 @@ package blockchain
 
 import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/time"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
@@ -17,9 +16,6 @@ var stateDefragmentationTime = promauto.NewSummary(prometheus.SummaryOpts{
 // a higher number of fragmented indexes are reallocated to a new separate slice for
 // that field.
 func (s *Service) defragmentState(st state.BeaconState) {
-	if !features.Get().EnableExperimentalState {
-		return
-	}
 	startTime := time.Now()
 	st.Defragment()
 	elapsedTime := time.Since(startTime)

beacon-chain/blockchain/execution_engine.go

@@ -141,7 +141,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 			}
 
 			if err := s.saveHead(ctx, r, b, st); err != nil {
-				log.WithError(err).Error("could not save head after pruning invalid blocks")
+				log.WithError(err).Error("Could not save head after pruning invalid blocks")
 			}
 
 			log.WithFields(logrus.Fields{

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -76,14 +76,14 @@ func (s *Service) sendFCUWithAttributes(cfg *postBlockProcessConfig, fcuArgs *fc
 	s.cfg.ForkChoiceStore.RLock()
 	defer s.cfg.ForkChoiceStore.RUnlock()
 	if err := s.computePayloadAttributes(cfg, fcuArgs); err != nil {
-		log.WithError(err).Error("could not compute payload attributes")
+		log.WithError(err).Error("Could not compute payload attributes")
 		return
 	}
 	if fcuArgs.attributes.IsEmpty() {
 		return
 	}
 	if _, err := s.notifyForkchoiceUpdate(cfg.ctx, fcuArgs); err != nil {
-		log.WithError(err).Error("could not update forkchoice with payload attributes for proposal")
+		log.WithError(err).Error("Could not update forkchoice with payload attributes for proposal")
 	}
 }
 
@@ -99,7 +99,7 @@ func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuCo
 	}
 
 	if err := s.saveHead(ctx, args.headRoot, args.headBlock, args.headState); err != nil {
-		log.WithError(err).Error("could not save head")
+		log.WithError(err).Error("Could not save head")
 	}
 
 	go s.firePayloadAttributesEvent(s.cfg.StateNotifier.StateFeed(), args.headBlock, args.headRoot, s.CurrentSlot()+1)
@@ -114,7 +114,7 @@ func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuCo
 func (s *Service) shouldOverrideFCU(newHeadRoot [32]byte, proposingSlot primitives.Slot) bool {
 	headWeight, err := s.cfg.ForkChoiceStore.Weight(newHeadRoot)
 	if err != nil {
-		log.WithError(err).WithField("root", fmt.Sprintf("%#x", newHeadRoot)).Warn("could not determine node weight")
+		log.WithError(err).WithField("root", fmt.Sprintf("%#x", newHeadRoot)).Warn("Could not determine node weight")
 	}
 	currentSlot := s.CurrentSlot()
 	if proposingSlot == currentSlot {
@@ -135,7 +135,7 @@ func (s *Service) shouldOverrideFCU(newHeadRoot [32]byte, proposingSlot primitiv
 		secs, err := slots.SecondsSinceSlotStart(currentSlot,
 			uint64(s.genesisTime.Unix()), uint64(time.Now().Unix()))
 		if err != nil {
-			log.WithError(err).Error("could not compute seconds since slot start")
+			log.WithError(err).Error("Could not compute seconds since slot start")
 		}
 		if secs >= doublylinkedtree.ProcessAttestationsThreshold {
 			log.WithFields(logrus.Fields{

beacon-chain/blockchain/head.go

@@ -98,7 +98,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 	oldHeadRoot := bytesutil.ToBytes32(r)
 	isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(newHeadRoot)
 	if err != nil {
-		log.WithError(err).Error("could not check if node is optimistically synced")
+		log.WithError(err).Error("Could not check if node is optimistically synced")
 	}
 	if headBlock.Block().ParentRoot() != oldHeadRoot {
 		// A chain re-org occurred, so we fire an event notifying the rest of the services.
@@ -111,11 +111,11 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 		dep := math.Max(uint64(headSlot-forkSlot), uint64(newHeadSlot-forkSlot))
 		oldWeight, err := s.cfg.ForkChoiceStore.Weight(oldHeadRoot)
 		if err != nil {
-			log.WithField("root", fmt.Sprintf("%#x", oldHeadRoot)).Warn("could not determine node weight")
+			log.WithField("root", fmt.Sprintf("%#x", oldHeadRoot)).Warn("Could not determine node weight")
 		}
 		newWeight, err := s.cfg.ForkChoiceStore.Weight(newHeadRoot)
 		if err != nil {
-			log.WithField("root", fmt.Sprintf("%#x", newHeadRoot)).Warn("could not determine node weight")
+			log.WithField("root", fmt.Sprintf("%#x", newHeadRoot)).Warn("Could not determine node weight")
 		}
 		log.WithFields(logrus.Fields{
 			"newSlot":            fmt.Sprintf("%d", newHeadSlot),

beacon-chain/blockchain/head_sync_committee_info.go

@@ -18,9 +18,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-// Initialize the state cache for sync committees.
-var syncCommitteeHeadStateCache = cache.NewSyncCommitteeHeadState()
-
 // HeadSyncCommitteeFetcher is the interface that wraps the head sync committee related functions.
 // The head sync committee functions return callers sync committee indices and public keys with respect to current head state.
 type HeadSyncCommitteeFetcher interface {
@@ -143,7 +140,7 @@ func (s *Service) getSyncCommitteeHeadState(ctx context.Context, slot primitives
 	defer mLock.Unlock()
 
 	// If there's already a head state exists with the request slot, we don't need to process slots.
-	cachedState, err := syncCommitteeHeadStateCache.Get(slot)
+	cachedState, err := s.syncCommitteeHeadState.Get(slot)
 	switch {
 	case err == nil:
 		syncHeadStateHit.Inc()
@@ -166,7 +163,7 @@ func (s *Service) getSyncCommitteeHeadState(ctx context.Context, slot primitives
 			return nil, err
 		}
 		syncHeadStateMiss.Inc()
-		err = syncCommitteeHeadStateCache.Put(slot, headState)
+		err = s.syncCommitteeHeadState.Put(slot, headState)
 		return headState, err
 	default:
 		// In the event, we encounter another error

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
-	dbTest "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
@@ -15,7 +14,7 @@ import (
 
 func TestService_HeadSyncCommitteeIndices(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{cfg: &config{BeaconDB: dbTest.SetupDB(t)}}
+	c := testServiceWithDB(t)
 	c.head = &head{state: s}
 
 	// Current period
@@ -38,7 +37,7 @@ func TestService_HeadSyncCommitteeIndices(t *testing.T) {
 
 func TestService_headCurrentSyncCommitteeIndices(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{cfg: &config{BeaconDB: dbTest.SetupDB(t)}}
+	c := testServiceWithDB(t)
 	c.head = &head{state: s}
 
 	// Process slot up to `EpochsPerSyncCommitteePeriod` so it can `ProcessSyncCommitteeUpdates`.
@@ -52,7 +51,7 @@ func TestService_headCurrentSyncCommitteeIndices(t *testing.T) {
 
 func TestService_headNextSyncCommitteeIndices(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
+	c := testServiceWithDB(t)
 	c.head = &head{state: s}
 
 	// Process slot up to `EpochsPerSyncCommitteePeriod` so it can `ProcessSyncCommitteeUpdates`.
@@ -66,7 +65,7 @@ func TestService_headNextSyncCommitteeIndices(t *testing.T) {
 
 func TestService_HeadSyncCommitteePubKeys(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{cfg: &config{BeaconDB: dbTest.SetupDB(t)}}
+	c := testServiceWithDB(t)
 	c.head = &head{state: s}
 
 	// Process slot up to 2 * `EpochsPerSyncCommitteePeriod` so it can run `ProcessSyncCommitteeUpdates` twice.
@@ -81,7 +80,7 @@ func TestService_HeadSyncCommitteePubKeys(t *testing.T) {
 
 func TestService_HeadSyncCommitteeDomain(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{cfg: &config{BeaconDB: dbTest.SetupDB(t)}}
+	c := testServiceWithDB(t)
 	c.head = &head{state: s}
 
 	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())
@@ -95,7 +94,7 @@ func TestService_HeadSyncCommitteeDomain(t *testing.T) {
 
 func TestService_HeadSyncContributionProofDomain(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
+	c := testServiceWithDB(t)
 	c.head = &head{state: s}
 
 	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, s.GenesisValidatorsRoot())
@@ -109,7 +108,7 @@ func TestService_HeadSyncContributionProofDomain(t *testing.T) {
 
 func TestService_HeadSyncSelectionProofDomain(t *testing.T) {
 	s, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().TargetCommitteeSize)
-	c := &Service{}
+	c := testServiceWithDB(t)
 	c.head = &head{state: s}
 
 	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, s.GenesisValidatorsRoot())
@@ -122,17 +121,14 @@ func TestService_HeadSyncSelectionProofDomain(t *testing.T) {
 }
 
 func TestSyncCommitteeHeadStateCache_RoundTrip(t *testing.T) {
-	c := syncCommitteeHeadStateCache
-	t.Cleanup(func() {
-		syncCommitteeHeadStateCache = cache.NewSyncCommitteeHeadState()
-	})
+	s := testServiceNoDB(t)
 	beaconState, _ := util.DeterministicGenesisStateAltair(t, 100)
 	require.NoError(t, beaconState.SetSlot(100))
-	cachedState, err := c.Get(101)
+	cachedState, err := s.syncCommitteeHeadState.Get(101)
 	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
 	require.Equal(t, nil, cachedState)
-	require.NoError(t, c.Put(101, beaconState))
-	cachedState, err = c.Get(101)
+	require.NoError(t, s.syncCommitteeHeadState.Put(101, beaconState))
+	cachedState, err = s.syncCommitteeHeadState.Get(101)
 	require.NoError(t, err)
 	require.DeepEqual(t, beaconState, cachedState)
 }

beacon-chain/blockchain/head_test.go

@@ -9,7 +9,6 @@ import (
 
 	mock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
-	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/config/params"
@@ -154,14 +153,9 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 func Test_notifyNewHeadEvent(t *testing.T) {
 	t.Run("genesis_state_root", func(t *testing.T) {
 		bState, _ := util.DeterministicGenesisState(t, 10)
-		notifier := &mock.MockStateNotifier{RecordEvents: true}
-		srv := &Service{
-			cfg: &config{
-				StateNotifier:   notifier,
-				ForkChoiceStore: doublylinkedtree.New(),
-			},
-			originBlockRoot: [32]byte{1},
-		}
+		srv := testServiceWithDB(t)
+		notifier := srv.cfg.StateNotifier.(*mock.MockStateNotifier)
+		srv.originBlockRoot = [32]byte{1}
 		st, blk, err := prepareForkchoiceState(t.Context(), 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))
@@ -185,15 +179,11 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 	})
 	t.Run("non_genesis_values", func(t *testing.T) {
 		bState, _ := util.DeterministicGenesisState(t, 10)
-		notifier := &mock.MockStateNotifier{RecordEvents: true}
 		genesisRoot := [32]byte{1}
-		srv := &Service{
-			cfg: &config{
-				StateNotifier:   notifier,
-				ForkChoiceStore: doublylinkedtree.New(),
-			},
-			originBlockRoot: genesisRoot,
-		}
+
+		srv := testServiceWithDB(t)
+		srv.originBlockRoot = genesisRoot
+		notifier := srv.cfg.StateNotifier.(*mock.MockStateNotifier)
 		st, blk, err := prepareForkchoiceState(t.Context(), 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))

beacon-chain/blockchain/metrics_test.go

@@ -8,16 +8,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/testing/util"
 )
 
-func TestReportEpochMetrics_BadHeadState(t *testing.T) {
-	s, err := util.NewBeaconState()
-	require.NoError(t, err)
-	h, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, h.SetValidators(nil))
-	err = reportEpochMetrics(t.Context(), s, h)
-	require.ErrorContains(t, "failed to initialize precompute: state has nil validator slice", err)
-}
-
 func TestReportEpochMetrics_BadAttestation(t *testing.T) {
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)

beacon-chain/blockchain/mock_test.go

@@ -8,9 +8,10 @@ import (
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
 )
 
-func testServiceOptsWithDB(t *testing.T) []Option {
+func testServiceOptsWithDB(t testing.TB) []Option {
 	beaconDB := testDB.SetupDB(t)
 	fcs := doublylinkedtree.New()
 	cs := startup.NewClockSynchronizer()
@@ -31,3 +32,15 @@ func testServiceOptsNoDB() []Option {
 	cs := startup.NewClockSynchronizer()
 	return []Option{WithClockSynchronizer(cs)}
 }
+
+func testServiceNoDB(t testing.TB) *Service {
+	s, err := NewService(t.Context(), testServiceOptsNoDB()...)
+	require.NoError(t, err)
+	return s
+}
+
+func testServiceWithDB(t testing.TB) *Service {
+	s, err := NewService(t.Context(), testServiceOptsWithDB(t)...)
+	require.NoError(t, err)
+	return s
+}

beacon-chain/blockchain/options.go

@@ -33,6 +33,14 @@ func WithMaxGoroutines(x int) Option {
 	}
 }
 
+// WithLCStore for light client store access.
+func WithLCStore() Option {
+	return func(s *Service) error {
+		s.lcStore = lightclient.NewLightClientStore(s.cfg.BeaconDB)
+		return nil
+	}
+}
+
 // WithWeakSubjectivityCheckpoint for checkpoint sync.
 func WithWeakSubjectivityCheckpoint(c *ethpb.Checkpoint) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_block.go

@@ -329,7 +329,7 @@ func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.Beacon
 	// The latest block header is from the previous epoch
 	r, err := st.LatestBlockHeader().HashTreeRoot()
 	if err != nil {
-		log.WithError(err).Error("could not update proposer index state-root map")
+		log.WithError(err).Error("Could not update proposer index state-root map")
 		return nil
 	}
 	// The proposer indices cache takes the target root for the previous
@@ -339,12 +339,12 @@ func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.Beacon
 	}
 	target, err := s.cfg.ForkChoiceStore.TargetRootForEpoch(r, e)
 	if err != nil {
-		log.WithError(err).Error("could not update proposer index state-root map")
+		log.WithError(err).Error("Could not update proposer index state-root map")
 		return nil
 	}
 	err = helpers.UpdateCachedCheckpointToStateRoot(st, &forkchoicetypes.Checkpoint{Epoch: e, Root: target})
 	if err != nil {
-		log.WithError(err).Error("could not update proposer index state-root map")
+		log.WithError(err).Error("Could not update proposer index state-root map")
 	}
 	return nil
 }
@@ -562,7 +562,7 @@ func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion
 // If there is not, it will call forkchoice updated with the correct payload attribute then cache the payload ID.
 func (s *Service) runLateBlockTasks() {
 	if err := s.waitForSync(); err != nil {
-		log.WithError(err).Error("failed to wait for initial sync")
+		log.WithError(err).Error("Failed to wait for initial sync")
 		return
 	}
 
@@ -927,10 +927,10 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	// blocks.
 	lastState.CopyAllTries()
 	if err := transition.UpdateNextSlotCache(ctx, lastRoot, lastState); err != nil {
-		log.WithError(err).Debug("could not update next slot state cache")
+		log.WithError(err).Debug("Could not update next slot state cache")
 	}
 	if err := s.handleEpochBoundary(ctx, currentSlot, headState, headRoot[:]); err != nil {
-		log.WithError(err).Error("lateBlockTasks: could not update epoch boundary caches")
+		log.WithError(err).Error("Could not update epoch boundary caches")
 	}
 	// return early if we already started building a block for the current
 	// head root
@@ -944,7 +944,7 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if attribute.IsEmpty() {
 		headBlock, err := s.headBlock()
 		if err != nil {
-			log.WithError(err).WithField("head_root", headRoot).Error("unable to retrieve head block to fire payload attributes event")
+			log.WithError(err).WithField("head_root", headRoot).Error("Unable to retrieve head block to fire payload attributes event")
 		}
 		// notifyForkchoiceUpdate fires the payload attribute event. But in this case, we won't
 		// call notifyForkchoiceUpdate, so the event is fired here.

beacon-chain/blockchain/process_block_helpers.go

@@ -68,11 +68,11 @@ func (s *Service) getFCUArgsEarlyBlock(cfg *postBlockProcessConfig, fcuArgs *fcu
 func (s *Service) logNonCanonicalBlockReceived(blockRoot [32]byte, headRoot [32]byte) {
 	receivedWeight, err := s.cfg.ForkChoiceStore.Weight(blockRoot)
 	if err != nil {
-		log.WithField("root", fmt.Sprintf("%#x", blockRoot)).Warn("could not determine node weight")
+		log.WithField("root", fmt.Sprintf("%#x", blockRoot)).Warn("Could not determine node weight")
 	}
 	headWeight, err := s.cfg.ForkChoiceStore.Weight(headRoot)
 	if err != nil {
-		log.WithField("root", fmt.Sprintf("%#x", headRoot)).Warn("could not determine node weight")
+		log.WithField("root", fmt.Sprintf("%#x", headRoot)).Warn("Could not determine node weight")
 	}
 	log.WithFields(logrus.Fields{
 		"receivedRoot":   fmt.Sprintf("%#x", blockRoot),
@@ -226,7 +226,7 @@ func (s *Service) processLightClientBootstrap(cfg *postBlockProcessConfig) error
 	if err != nil {
 		return errors.Wrapf(err, "could not create light client bootstrap")
 	}
-	if err := s.cfg.BeaconDB.SaveLightClientBootstrap(cfg.ctx, blockRoot[:], bootstrap); err != nil {
+	if err := s.lcStore.SaveLightClientBootstrap(cfg.ctx, blockRoot, bootstrap); err != nil {
 		return errors.Wrapf(err, "could not save light client bootstrap")
 	}
 	return nil
@@ -527,7 +527,7 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 		// is meant to be asynchronous and run in the background rather than being
 		// tied to the execution of a block.
 		if err := s.cfg.StateGen.MigrateToCold(s.ctx, fRoot); err != nil {
-			log.WithError(err).Error("could not migrate to cold")
+			log.WithError(err).Error("Could not migrate to cold")
 		}
 	}()
 	return nil
@@ -616,7 +616,7 @@ func (s *Service) insertFinalizedDepositsAndPrune(ctx context.Context, fRoot [32
 	// Update deposit cache.
 	finalizedState, err := s.cfg.StateGen.StateByRoot(ctx, fRoot)
 	if err != nil {
-		log.WithError(err).Error("could not fetch finalized state")
+		log.WithError(err).Error("Could not fetch finalized state")
 		return
 	}
 
@@ -634,7 +634,7 @@ func (s *Service) insertFinalizedDepositsAndPrune(ctx context.Context, fRoot [32
 	// because the Eth1 follow distance makes such long-range reorgs extremely unlikely.
 	eth1DepositIndex, err := mathutil.Int(finalizedState.Eth1DepositIndex())
 	if err != nil {
-		log.WithError(err).Error("could not cast eth1 deposit index")
+		log.WithError(err).Error("Could not cast eth1 deposit index")
 		return
 	}
 	// The deposit index in the state is always the index of the next deposit
@@ -643,12 +643,12 @@ func (s *Service) insertFinalizedDepositsAndPrune(ctx context.Context, fRoot [32
 	finalizedEth1DepIdx := eth1DepositIndex - 1
 	if err = s.cfg.DepositCache.InsertFinalizedDeposits(ctx, int64(finalizedEth1DepIdx), common.Hash(finalizedState.Eth1Data().BlockHash),
 		0 /* Setting a zero value as we have no access to block height */); err != nil {
-		log.WithError(err).Error("could not insert finalized deposits")
+		log.WithError(err).Error("Could not insert finalized deposits")
 		return
 	}
 	// Deposit proofs are only used during state transition and can be safely removed to save space.
 	if err = s.cfg.DepositCache.PruneProofs(ctx, int64(finalizedEth1DepIdx)); err != nil {
-		log.WithError(err).Error("could not prune deposit proofs")
+		log.WithError(err).Error("Could not prune deposit proofs")
 	}
 	// Prune deposits which have already been finalized, the below method prunes all pending deposits (non-inclusive) up
 	// to the provided eth1 deposit index.

beacon-chain/blockchain/process_block_test.go

@@ -59,11 +59,8 @@ func Test_pruneAttsFromPool_Electra(t *testing.T) {
 	cfg.TargetCommitteeSize = 8
 	params.OverrideBeaconConfig(cfg)
 
-	s := Service{
-		cfg: &config{
-			AttPool: kv.NewAttCaches(),
-		},
-	}
+	s := testServiceNoDB(t)
+	s.cfg.AttPool = kv.NewAttCaches()
 
 	data := &ethpb.AttestationData{
 		BeaconBlockRoot: make([]byte, 32),
@@ -471,7 +468,8 @@ func blockTree1(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][]byt
 }
 
 func TestCurrentSlot_HandlesOverflow(t *testing.T) {
-	svc := Service{genesisTime: prysmTime.Now().Add(1 * time.Hour)}
+	svc := testServiceNoDB(t)
+	svc.genesisTime = prysmTime.Now().Add(1 * time.Hour)
 
 	slot := svc.CurrentSlot()
 	require.Equal(t, primitives.Slot(0), slot, "Unexpected slot")
@@ -2796,7 +2794,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
 			require.NoError(t, err)
 
 			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
@@ -2848,7 +2846,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
 			require.NoError(t, err)
 
 			scb := make([]byte, 64)
@@ -2954,7 +2952,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
 			require.NoError(t, err)
 
 			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
@@ -3006,7 +3004,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
 			require.NoError(t, err)
 
 			scb := make([]byte, 64)
@@ -3112,7 +3110,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
 			require.NoError(t, err)
 
 			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
@@ -3164,7 +3162,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			// create and save old update
-			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
 			require.NoError(t, err)
 
 			scb := make([]byte, 64)
@@ -3196,116 +3194,47 @@ func TestProcessLightClientBootstrap(t *testing.T) {
 	featCfg := &features.Flags{}
 	featCfg.EnableLightClient = true
 	reset := features.InitWithReset(featCfg)
+	defer reset()
 
-	s, tr := minimalTestService(t)
+	s, tr := minimalTestService(t, WithLCStore())
 	ctx := tr.ctx
 
-	t.Run("Altair", func(t *testing.T) {
-		l := util.NewTestLightClient(t, version.Altair)
+	for testVersion := version.Altair; testVersion <= version.Electra; testVersion++ {
+		t.Run(version.String(testVersion), func(t *testing.T) {
+			l := util.NewTestLightClient(t, testVersion)
 
-		s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().AltairForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().VersionToForkEpochMap()[testVersion])*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
 
-		currentBlockRoot, err := l.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-		roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
-		require.NoError(t, err)
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
 
-		err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
-		require.NoError(t, err)
-		err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
-		require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
 
-		cfg := &postBlockProcessConfig{
-			ctx:            ctx,
-			roblock:        roblock,
-			postState:      l.State,
-			isValidPayload: true,
-		}
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
 
-		require.NoError(t, s.processLightClientBootstrap(cfg))
+			require.NoError(t, s.processLightClientBootstrap(cfg))
 
-		// Check that the light client bootstrap is saved
-		b, err := s.cfg.BeaconDB.LightClientBootstrap(ctx, currentBlockRoot[:])
-		require.NoError(t, err)
-		require.NotNil(t, b)
+			// Check that the light client bootstrap is saved
+			b, err := s.lcStore.LightClientBootstrap(ctx, currentBlockRoot)
+			require.NoError(t, err)
+			require.NotNil(t, b)
 
-		stateRoot, err := l.State.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
-		require.Equal(t, b.Version(), version.Altair)
-	})
-
-	t.Run("Capella", func(t *testing.T) {
-		l := util.NewTestLightClient(t, version.Capella)
-
-		s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().CapellaForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-
-		currentBlockRoot, err := l.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-		roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
-		require.NoError(t, err)
-
-		err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
-		require.NoError(t, err)
-		err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
-		require.NoError(t, err)
-
-		cfg := &postBlockProcessConfig{
-			ctx:            ctx,
-			roblock:        roblock,
-			postState:      l.State,
-			isValidPayload: true,
-		}
-
-		require.NoError(t, s.processLightClientBootstrap(cfg))
-
-		// Check that the light client bootstrap is saved
-		b, err := s.cfg.BeaconDB.LightClientBootstrap(ctx, currentBlockRoot[:])
-		require.NoError(t, err)
-		require.NotNil(t, b)
-
-		stateRoot, err := l.State.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
-		require.Equal(t, b.Version(), version.Capella)
-	})
-
-	t.Run("Deneb", func(t *testing.T) {
-		l := util.NewTestLightClient(t, version.Deneb)
-
-		s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().DenebForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-
-		currentBlockRoot, err := l.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-		roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
-		require.NoError(t, err)
-
-		err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
-		require.NoError(t, err)
-		err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
-		require.NoError(t, err)
-
-		cfg := &postBlockProcessConfig{
-			ctx:            ctx,
-			roblock:        roblock,
-			postState:      l.State,
-			isValidPayload: true,
-		}
-
-		require.NoError(t, s.processLightClientBootstrap(cfg))
-
-		// Check that the light client bootstrap is saved
-		b, err := s.cfg.BeaconDB.LightClientBootstrap(ctx, currentBlockRoot[:])
-		require.NoError(t, err)
-		require.NotNil(t, b)
-
-		stateRoot, err := l.State.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
-		require.Equal(t, b.Version(), version.Deneb)
-	})
-
-	reset()
+			stateRoot, err := l.State.HashTreeRoot(ctx)
+			require.NoError(t, err)
+			require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
+			require.Equal(t, b.Version(), testVersion)
+		})
+	}
 }
 
 type testIsAvailableParams struct {
@@ -3647,7 +3576,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 				expectedVersion = version.Altair
 			case 2:
 				forkEpoch = uint64(params.BeaconConfig().BellatrixForkEpoch)
-				expectedVersion = version.Altair
+				expectedVersion = version.Bellatrix
 			case 3:
 				forkEpoch = uint64(params.BeaconConfig().CapellaForkEpoch)
 				expectedVersion = version.Capella
@@ -3656,7 +3585,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 				expectedVersion = version.Deneb
 			case 5:
 				forkEpoch = uint64(params.BeaconConfig().ElectraForkEpoch)
-				expectedVersion = version.Deneb
+				expectedVersion = version.Electra
 			default:
 				t.Errorf("Unsupported fork version %s", version.String(testVersion))
 			}
@@ -3801,7 +3730,7 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 				expectedVersion = version.Altair
 			case 2:
 				forkEpoch = uint64(params.BeaconConfig().BellatrixForkEpoch)
-				expectedVersion = version.Altair
+				expectedVersion = version.Bellatrix
 			case 3:
 				forkEpoch = uint64(params.BeaconConfig().CapellaForkEpoch)
 				expectedVersion = version.Capella

beacon-chain/blockchain/receive_attestation.go

@@ -69,7 +69,7 @@ func (s *Service) spawnProcessAttestationsRoutine() {
 	go func() {
 		_, err := s.clockWaiter.WaitForClock(s.ctx)
 		if err != nil {
-			log.WithError(err).Error("spawnProcessAttestationsRoutine failed to receive genesis data")
+			log.WithError(err).Error("Failed to receive genesis data")
 			return
 		}
 		if s.genesisTime.IsZero() {
@@ -103,7 +103,7 @@ func (s *Service) spawnProcessAttestationsRoutine() {
 				} else {
 					s.cfg.ForkChoiceStore.Lock()
 					if err := s.cfg.ForkChoiceStore.NewSlot(s.ctx, slotInterval.Slot); err != nil {
-						log.WithError(err).Error("could not process new slot")
+						log.WithError(err).Error("Could not process new slot")
 					}
 					s.cfg.ForkChoiceStore.Unlock()
 
@@ -144,7 +144,7 @@ func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot)
 	log.WithField("newHeadRoot", fmt.Sprintf("%#x", newHeadRoot)).Debug("Head changed due to attestations")
 	headState, headBlock, err := s.getStateAndBlock(ctx, newHeadRoot)
 	if err != nil {
-		log.WithError(err).Error("could not get head block")
+		log.WithError(err).Error("Could not get head block")
 		return
 	}
 	newAttHeadElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
@@ -161,7 +161,7 @@ func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot)
 		return
 	}
 	if err := s.forkchoiceUpdateWithExecution(s.ctx, fcuArgs); err != nil {
-		log.WithError(err).Error("could not update forkchoice")
+		log.WithError(err).Error("Could not update forkchoice")
 	}
 }
 

beacon-chain/blockchain/receive_block.go

@@ -183,7 +183,7 @@ func (s *Service) updateCheckpoints(
 			return errors.Wrap(err, "could not get head state")
 		}
 		if err := reportEpochMetrics(ctx, postState, headSt); err != nil {
-			log.WithError(err).Error("could not report epoch metrics")
+			log.WithError(err).Error("Could not report epoch metrics")
 		}
 	}
 	if err := s.updateJustificationOnBlock(ctx, preState, postState, cp.j); err != nil {

beacon-chain/blockchain/service.go

@@ -69,6 +69,7 @@ type Service struct {
 	slasherEnabled                 bool
 	lcStore                        *lightClient.Store
 	startWaitingDataColumnSidecars chan bool // for testing purposes only
+	syncCommitteeHeadState         *cache.SyncCommitteeHeadStateCache
 }
 
 // config options for the service.
@@ -180,14 +181,15 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		seenIndex: make(map[[32]byte][]bool),
 	}
 	srv := &Service{
-		ctx:                  ctx,
-		cancel:               cancel,
-		boundaryRoots:        [][32]byte{},
-		checkpointStateCache: cache.NewCheckpointStateCache(),
-		initSyncBlocks:       make(map[[32]byte]interfaces.ReadOnlySignedBeaconBlock),
-		blobNotifiers:        bn,
-		cfg:                  &config{},
-		blockBeingSynced:     &currentlySyncingBlock{roots: make(map[[32]byte]struct{})},
+		ctx:                    ctx,
+		cancel:                 cancel,
+		boundaryRoots:          [][32]byte{},
+		checkpointStateCache:   cache.NewCheckpointStateCache(),
+		initSyncBlocks:         make(map[[32]byte]interfaces.ReadOnlySignedBeaconBlock),
+		blobNotifiers:          bn,
+		cfg:                    &config{},
+		blockBeingSynced:       &currentlySyncingBlock{roots: make(map[[32]byte]struct{})},
+		syncCommitteeHeadState: cache.NewSyncCommitteeHeadState(),
 	}
 	for _, opt := range opts {
 		if err := opt(srv); err != nil {
@@ -371,7 +373,7 @@ func (s *Service) startFromExecutionChain() error {
 				if e.Type == statefeed.ChainStarted {
 					data, ok := e.Data.(*statefeed.ChainStartedData)
 					if !ok {
-						log.Error("event data is not type *statefeed.ChainStartedData")
+						log.Error("Event data is not type *statefeed.ChainStartedData")
 						return
 					}
 					log.WithField("startTime", data.StartTime).Debug("Received chain start event")
@@ -408,7 +410,7 @@ func (s *Service) onExecutionChainStart(ctx context.Context, genesisTime time.Ti
 
 	vr := bytesutil.ToBytes32(initializedState.GenesisValidatorsRoot())
 	if err := s.clockSetter.SetClock(startup.NewClock(genesisTime, vr)); err != nil {
-		log.WithError(err).Fatal("failed to initialize blockchain service from execution start event")
+		log.WithError(err).Fatal("Failed to initialize blockchain service from execution start event")
 	}
 }
 

beacon-chain/blockchain/service_norace_test.go

@@ -4,7 +4,6 @@ import (
 	"io"
 	"testing"
 
-	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
@@ -17,10 +16,7 @@ func init() {
 }
 
 func TestChainService_SaveHead_DataRace(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg: &config{BeaconDB: beaconDB},
-	}
+	s := testServiceWithDB(t)
 	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
 	st, _ := util.DeterministicGenesisState(t, 1)
 	require.NoError(t, err)

beacon-chain/blockchain/service_test.go

@@ -345,12 +345,8 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 }
 
 func TestChainService_SaveHeadNoDB(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
 	ctx := t.Context()
-	fc := doublylinkedtree.New()
-	s := &Service{
-		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB, fc), ForkChoiceStore: fc},
-	}
+	s := testServiceWithDB(t)
 	blk := util.NewBeaconBlock()
 	blk.Block.Slot = 1
 	r, err := blk.HashTreeRoot()
@@ -371,10 +367,7 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 
 func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	ctx := t.Context()
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg: &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
-	}
+	s := testServiceWithDB(t)
 	b := util.NewBeaconBlock()
 	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
@@ -391,22 +384,16 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 }
 
 func TestServiceStop_SaveCachedBlocks(t *testing.T) {
-	ctx, cancel := context.WithCancel(t.Context())
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg:            &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB, doublylinkedtree.New())},
-		ctx:            ctx,
-		cancel:         cancel,
-		initSyncBlocks: make(map[[32]byte]interfaces.ReadOnlySignedBeaconBlock),
-	}
+	s := testServiceWithDB(t)
+	s.initSyncBlocks = make(map[[32]byte]interfaces.ReadOnlySignedBeaconBlock)
 	bb := util.NewBeaconBlock()
 	r, err := bb.Block.HashTreeRoot()
 	require.NoError(t, err)
 	wsb, err := consensusblocks.NewSignedBeaconBlock(bb)
 	require.NoError(t, err)
-	require.NoError(t, s.saveInitSyncBlock(ctx, r, wsb))
+	require.NoError(t, s.saveInitSyncBlock(s.ctx, r, wsb))
 	require.NoError(t, s.Stop())
-	require.Equal(t, true, s.cfg.BeaconDB.HasBlock(ctx, r))
+	require.Equal(t, true, s.cfg.BeaconDB.HasBlock(s.ctx, r))
 }
 
 func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
@@ -428,11 +415,8 @@ func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
 }
 
 func BenchmarkHasBlockDB(b *testing.B) {
-	beaconDB := testDB.SetupDB(b)
 	ctx := b.Context()
-	s := &Service{
-		cfg: &config{BeaconDB: beaconDB},
-	}
+	s := testServiceWithDB(b)
 	blk := util.NewBeaconBlock()
 	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
 	require.NoError(b, err)
@@ -448,10 +432,7 @@ func BenchmarkHasBlockDB(b *testing.B) {
 
 func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 	ctx := b.Context()
-	beaconDB := testDB.SetupDB(b)
-	s := &Service{
-		cfg: &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
-	}
+	s := testServiceWithDB(b)
 	blk := util.NewBeaconBlock()
 	r, err := blk.Block.HashTreeRoot()
 	require.NoError(b, err)

beacon-chain/blockchain/setup_forchoice.go

@@ -38,7 +38,7 @@ func (s *Service) startupHeadRoot() [32]byte {
 	if headStr == "head" {
 		root, err := s.cfg.BeaconDB.HeadBlockRoot()
 		if err != nil {
-			log.WithError(err).Error("could not get head block root, starting with finalized block as head")
+			log.WithError(err).Error("Could not get head block root, starting with finalized block as head")
 			return fRoot
 		}
 		log.Infof("Using Head root of %#x", root)
@@ -46,7 +46,7 @@ func (s *Service) startupHeadRoot() [32]byte {
 	}
 	root, err := bytesutil.DecodeHexWithLength(headStr, 32)
 	if err != nil {
-		log.WithError(err).Error("could not parse head root, starting with finalized block as head")
+		log.WithError(err).Error("Could not parse head root, starting with finalized block as head")
 		return fRoot
 	}
 	return [32]byte(root)
@@ -64,16 +64,16 @@ func (s *Service) setupForkchoiceTree(st state.BeaconState) error {
 	}
 	blk, err := s.cfg.BeaconDB.Block(s.ctx, headRoot)
 	if err != nil {
-		log.WithError(err).Error("could not get head block, starting with finalized block as head")
+		log.WithError(err).Error("Could not get head block, starting with finalized block as head")
 		return nil
 	}
 	if slots.ToEpoch(blk.Block().Slot()) < cp.Epoch {
-		log.WithField("headRoot", fmt.Sprintf("%#x", headRoot)).Error("head block is older than finalized block, starting with finalized block as head")
+		log.WithField("headRoot", fmt.Sprintf("%#x", headRoot)).Error("Head block is older than finalized block, starting with finalized block as head")
 		return nil
 	}
 	chain, err := s.buildForkchoiceChain(s.ctx, blk)
 	if err != nil {
-		log.WithError(err).Error("could not build forkchoice chain, starting with finalized block as head")
+		log.WithError(err).Error("Could not build forkchoice chain, starting with finalized block as head")
 		return nil
 	}
 	s.cfg.ForkChoiceStore.Lock()

beacon-chain/blockchain/setup_forkchoice_test.go

@@ -32,7 +32,7 @@ func Test_startupHeadRoot(t *testing.T) {
 		})
 		defer resetCfg()
 		require.Equal(t, service.startupHeadRoot(), gr)
-		require.LogsContain(t, hook, "could not get head block root, starting with finalized block as head")
+		require.LogsContain(t, hook, "Could not get head block root, starting with finalized block as head")
 	})
 
 	st, _ := util.DeterministicGenesisState(t, 64)

beacon-chain/blockchain/testing/mock.go

@@ -555,11 +555,11 @@ func (s *ChainService) UpdateHead(ctx context.Context, slot primitives.Slot) {
 	ojc := &ethpb.Checkpoint{}
 	st, root, err := prepareForkchoiceState(ctx, slot, bytesutil.ToBytes32(s.Root), [32]byte{}, [32]byte{}, ojc, ojc)
 	if err != nil {
-		logrus.WithError(err).Error("could not update head")
+		logrus.WithError(err).Error("Could not update head")
 	}
 	err = s.ForkChoiceStore.InsertNode(ctx, st, root)
 	if err != nil {
-		logrus.WithError(err).Error("could not insert node to forkchoice")
+		logrus.WithError(err).Error("Could not insert node to forkchoice")
 	}
 }
 

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -3,8 +3,6 @@ package blockchain
 import (
 	"testing"
 
-	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
-	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -17,11 +15,8 @@ import (
 )
 
 func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1792480
-	util.SaveBlock(t, t.Context(), beaconDB, b)
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -68,15 +63,15 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			s := testServiceWithDB(t)
+			beaconDB := s.cfg.BeaconDB
+			util.SaveBlock(t, t.Context(), beaconDB, b)
 			wv, err := NewWeakSubjectivityVerifier(tt.checkpt, beaconDB)
-			require.Equal(t, !tt.disabled, wv.enabled)
 			require.NoError(t, err)
-			fcs := doublylinkedtree.New()
-			s := &Service{
-				cfg:        &config{BeaconDB: beaconDB, WeakSubjectivityCheckpt: tt.checkpt, ForkChoiceStore: fcs},
-				wsVerifier: wv,
-			}
-			require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: tt.finalizedEpoch}))
+			s.cfg.WeakSubjectivityCheckpt = tt.checkpt
+			s.wsVerifier = wv
+			require.Equal(t, !tt.disabled, wv.enabled)
+			require.NoError(t, s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: tt.finalizedEpoch}))
 			cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 			err = s.wsVerifier.VerifyWeakSubjectivity(t.Context(), cp.Epoch)
 			if tt.wantErr == nil {

beacon-chain/cache/sync_committee.go

@@ -178,7 +178,7 @@ func (s *SyncCommitteeCache) UpdatePositionsInCommittee(syncCommitteeBoundaryRoo
 	s.lock.Lock()
 	defer s.lock.Unlock()
 	if clearCount != s.cleared.Load() {
-		log.Warn("cache rotated during async committee update operation - abandoning cache update")
+		log.Warn("Cache rotated during async committee update operation - abandoning cache update")
 		return nil
 	}
 

beacon-chain/core/altair/reward_test.go

@@ -31,7 +31,7 @@ func Test_BaseReward(t *testing.T) {
 			valIdx:    2,
 			st:        genState(1),
 			want:      0,
-			errString: "validator index 2 does not exist",
+			errString: "index 2 out of bounds",
 		},
 		{
 			name:      "active balance is 32eth",
@@ -89,7 +89,7 @@ func Test_BaseRewardWithTotalBalance(t *testing.T) {
 			valIdx:        2,
 			activeBalance: 1,
 			want:          0,
-			errString:     "validator index 2 does not exist",
+			errString:     "index 2 out of bounds",
 		},
 		{
 			name:          "active balance is 1",

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -119,6 +119,7 @@ func TestFuzzEth1DataHasEnoughSupport_10000(t *testing.T) {
 		require.NoError(t, err)
 		_, err = Eth1DataHasEnoughSupport(s, eth1data)
 		_ = err
+		fuzz.FreeMemory(i)
 	}
 
 }
@@ -319,6 +320,7 @@ func TestFuzzverifyDeposit_10000(t *testing.T) {
 		require.NoError(t, err)
 		err = VerifyDeposit(s, deposit)
 		_ = err
+		fuzz.FreeMemory(i)
 	}
 }
 
@@ -382,5 +384,6 @@ func TestFuzzVerifyExit_10000(t *testing.T) {
 		_ = err
 		err = VerifyExitAndSignature(val, s, ve)
 		_ = err
+		fuzz.FreeMemory(i)
 	}
 }

beacon-chain/core/electra/consolidations.go

@@ -194,11 +194,11 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if IsValidSwitchToCompoundingRequest(st, cr) {
 			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
 			if !ok {
-				log.Error("failed to find source validator index")
+				log.Error("Failed to find source validator index")
 				continue
 			}
 			if err := SwitchToCompoundingValidator(st, srcIdx); err != nil {
-				log.WithError(err).Error("failed to switch to compounding validator")
+				log.WithError(err).Error("Failed to switch to compounding validator")
 			}
 			continue
 		}
@@ -280,7 +280,7 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		}
 		bal, err := st.PendingBalanceToWithdraw(srcIdx)
 		if err != nil {
-			log.WithError(err).Error("failed to fetch pending balance to withdraw")
+			log.WithError(err).Error("Failed to fetch pending balance to withdraw")
 			continue
 		}
 		if bal > 0 {
@@ -290,7 +290,7 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		// Initiate the exit of the source validator.
 		exitEpoch, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(srcV.EffectiveBalance))
 		if err != nil {
-			log.WithError(err).Error("failed to compute consolidation epoch")
+			log.WithError(err).Error("Failed to compute consolidation epoch")
 			continue
 		}
 		srcV.ExitEpoch = exitEpoch

beacon-chain/core/feed/operation/events.go

@@ -38,11 +38,14 @@ const (
 	// SingleAttReceived is sent after a single attestation object is received from gossip or rpc
 	SingleAttReceived = 9
 
+	// DataColumnSidecarReceived is sent after a data column sidecar is received from gossip or rpc.
+	DataColumnSidecarReceived = 10
+
 	// BlockGossipReceived is sent after a block has been received from gossip or API that passes validation rules.
-	BlockGossipReceived = 10
+	BlockGossipReceived = 11
 
 	// DataColumnReceived is sent after a data column has been seen after gossip validation rules.
-	DataColumnReceived = 11
+	DataColumnReceived = 12
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -94,6 +97,11 @@ type SingleAttReceivedData struct {
 	Attestation ethpb.Att
 }
 
+// DataColumnSidecarReceivedData is the data sent with DataColumnSidecarReceived events.
+type DataColumnSidecarReceivedData struct {
+	DataColumn *blocks.VerifiedRODataColumn
+}
+
 // BlockGossipReceivedData is the data sent with BlockGossipReceived events.
 type BlockGossipReceivedData struct {
 	// SignedBlock is the block that was received.

beacon-chain/core/helpers/beacon_committee.go

@@ -403,7 +403,7 @@ func AssignmentForValidator(
 			}
 		}
 	}
-	return nil // validator is not scheduled this epoch
+	return &LiteAssignment{} // 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

@@ -912,6 +912,7 @@ func TestAssignmentForValidator(t *testing.T) {
 			{{4, 5, 6}},
 		}
 		got = helpers.AssignmentForValidator(bySlot, start, primitives.ValidatorIndex(99))
-		require.IsNil(t, got)
+		// should be empty to be safe
+		require.DeepEqual(t, &helpers.LiteAssignment{}, got)
 	})
 }

beacon-chain/core/helpers/sync_committee_test.go

@@ -100,7 +100,7 @@ func TestIsCurrentEpochSyncCommittee_DoesNotExist(t *testing.T) {
 	require.NoError(t, state.SetNextSyncCommittee(syncCommittee))
 
 	ok, err := helpers.IsCurrentPeriodSyncCommittee(state, 12390192)
-	require.ErrorContains(t, "validator index 12390192 does not exist", err)
+	require.ErrorContains(t, "index 12390192 out of bounds", err)
 	require.Equal(t, false, ok)
 }
 
@@ -187,7 +187,7 @@ func TestIsNextEpochSyncCommittee_DoesNotExist(t *testing.T) {
 	require.NoError(t, state.SetNextSyncCommittee(syncCommittee))
 
 	ok, err := helpers.IsNextPeriodSyncCommittee(state, 120391029)
-	require.ErrorContains(t, "validator index 120391029 does not exist", err)
+	require.ErrorContains(t, "index 120391029 out of bounds", err)
 	require.Equal(t, false, ok)
 }
 
@@ -287,7 +287,7 @@ func TestCurrentEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) {
 	require.NoError(t, state.SetNextSyncCommittee(syncCommittee))
 
 	index, err := helpers.CurrentPeriodSyncSubcommitteeIndices(state, 129301923)
-	require.ErrorContains(t, "validator index 129301923 does not exist", err)
+	require.ErrorContains(t, "index 129301923 out of bounds", err)
 	require.DeepEqual(t, []primitives.CommitteeIndex(nil), index)
 }
 
@@ -374,7 +374,7 @@ func TestNextEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) {
 	require.NoError(t, state.SetNextSyncCommittee(syncCommittee))
 
 	index, err := helpers.NextPeriodSyncSubcommitteeIndices(state, 21093019)
-	require.ErrorContains(t, "validator index 21093019 does not exist", err)
+	require.ErrorContains(t, "index 21093019 out of bounds", err)
 	require.DeepEqual(t, []primitives.CommitteeIndex(nil), index)
 }
 

beacon-chain/core/helpers/validators_test.go

@@ -561,17 +561,6 @@ func TestActiveValidatorIndices(t *testing.T) {
 			},
 			want: []primitives.ValidatorIndex{0, 2, 3},
 		},*/
-		{
-			name: "impossible_zero_validators", // Regression test for issue #13051
-			args: args{
-				state: &ethpb.BeaconState{
-					RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-					Validators:  make([]*ethpb.Validator, 0),
-				},
-				epoch: 10,
-			},
-			wantedErr: "state has nil validator slice",
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

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

@@ -3,12 +3,14 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "helpers.go",
         "lightclient.go",
         "store.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/execution:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
@@ -41,7 +43,6 @@ 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

@@ -0,0 +1,243 @@
+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,12 +6,10 @@ 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"
@@ -163,13 +161,13 @@ func NewLightClientUpdateFromBeaconState(
 	updateAttestedPeriod := slots.SyncCommitteePeriod(slots.ToEpoch(attestedBlock.Block().Slot()))
 
 	// update = LightClientUpdate()
-	result, err := CreateDefaultLightClientUpdate(currentSlot, attestedState)
+	result, err := CreateDefaultLightClientUpdate(attestedBlock)
 	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, currentSlot, attestedBlock)
+	attestedLightClientHeader, err := BlockToLightClientHeader(ctx, attestedBlock.Version(), attestedBlock)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get attested light client header")
 	}
@@ -210,7 +208,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, currentSlot, finalizedBlock)
+			finalizedLightClientHeader, err := BlockToLightClientHeader(ctx, attestedBlock.Version(), finalizedBlock)
 			if err != nil {
 				return nil, errors.Wrap(err, "could not get finalized light client header")
 			}
@@ -247,9 +245,7 @@ func NewLightClientUpdateFromBeaconState(
 	return result, nil
 }
 
-func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState state.BeaconState) (interfaces.LightClientUpdate, error) {
-	currentEpoch := slots.ToEpoch(currentSlot)
-
+func CreateDefaultLightClientUpdate(attestedBlock interfaces.ReadOnlySignedBeaconBlock) (interfaces.LightClientUpdate, error) {
 	syncCommitteeSize := params.BeaconConfig().SyncCommitteeSize
 	pubKeys := make([][]byte, syncCommitteeSize)
 	for i := uint64(0); i < syncCommitteeSize; i++ {
@@ -261,7 +257,7 @@ func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState s
 	}
 
 	var nextSyncCommitteeBranch [][]byte
-	if attestedState.Version() >= version.Electra {
+	if attestedBlock.Version() >= version.Electra {
 		nextSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepthElectra)
 	} else {
 		nextSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepth)
@@ -276,7 +272,7 @@ func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState s
 	}
 
 	var finalityBranch [][]byte
-	if attestedState.Version() >= version.Electra {
+	if attestedBlock.Version() >= version.Electra {
 		finalityBranch = make([][]byte, fieldparams.FinalityBranchDepthElectra)
 	} else {
 		finalityBranch = make([][]byte, fieldparams.FinalityBranchDepth)
@@ -286,10 +282,12 @@ func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState s
 	}
 
 	var m proto.Message
-	if currentEpoch < params.BeaconConfig().CapellaForkEpoch {
+	switch attestedBlock.Version() {
+	case version.Altair, version.Bellatrix:
 		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),
@@ -310,10 +308,11 @@ func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState s
 				SyncCommitteeSignature: make([]byte, 96),
 			},
 		}
-	} else if currentEpoch < params.BeaconConfig().DenebForkEpoch {
+	case version.Capella:
 		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),
@@ -362,10 +361,11 @@ func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState s
 				SyncCommitteeSignature: make([]byte, 96),
 			},
 		}
-	} else if currentEpoch < params.BeaconConfig().ElectraForkEpoch {
+	case version.Deneb:
 		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,120 +418,65 @@ func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState s
 				SyncCommitteeSignature: make([]byte, 96),
 			},
 		}
-	} 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,
+	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),
 				},
-				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,
+				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,
 				},
-				SyncAggregate: &pb.SyncAggregate{
-					SyncCommitteeBits:      make([]byte, 64),
-					SyncCommitteeSignature: make([]byte, 96),
+				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),
 				},
-			}
-		} 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,
+				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,
-				},
-				SyncAggregate: &pb.SyncAggregate{
-					SyncCommitteeBits:      make([]byte, 64),
-					SyncCommitteeSignature: make([]byte, 96),
-				},
-			}
+				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)
@@ -575,189 +520,52 @@ func ComputeWithdrawalsRoot(payload interfaces.ExecutionData) ([]byte, error) {
 
 func BlockToLightClientHeader(
 	ctx context.Context,
-	currentSlot primitives.Slot,
-	block interfaces.ReadOnlySignedBeaconBlock,
+	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.
 ) (interfaces.LightClientHeader, error) {
-	var m proto.Message
-	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 block.Version() > attestedBlockVersion {
+		return nil, errors.Errorf("block version %s is greater than attested block version %s", version.String(block.Version()), version.String(attestedBlockVersion))
 	}
 
-	if currentEpoch < params.BeaconConfig().CapellaForkEpoch {
+	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:
 		m = &pb.LightClientHeaderAltair{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot:          block.Block().Slot(),
-				ProposerIndex: block.Block().ProposerIndex(),
-				ParentRoot:    parentRoot[:],
-				StateRoot:     stateRoot[:],
-				BodyRoot:      bodyRoot[:],
-			},
+			Beacon: beacon,
 		}
-	} 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")
-			}
+	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")
 		}
-
 		m = &pb.LightClientHeaderCapella{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot:          block.Block().Slot(),
-				ProposerIndex: block.Block().ProposerIndex(),
-				ParentRoot:    parentRoot[:],
-				StateRoot:     stateRoot[:],
-				BodyRoot:      bodyRoot[:],
-			},
+			Beacon:          beacon,
 			Execution:       payloadHeader,
 			ExecutionBranch: payloadProof,
 		}
-	} 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")
-			}
+	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")
 		}
-
 		m = &pb.LightClientHeaderDeneb{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot:          block.Block().Slot(),
-				ProposerIndex: block.Block().ProposerIndex(),
-				ParentRoot:    parentRoot[:],
-				StateRoot:     stateRoot[:],
-				BodyRoot:      bodyRoot[:],
-			},
+			Beacon:          beacon,
 			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()
@@ -909,7 +717,7 @@ func NewLightClientBootstrapFromBeaconState(
 		return nil, errors.Wrap(err, "could not create default light client bootstrap")
 	}
 
-	lightClientHeader, err := BlockToLightClientHeader(ctx, currentSlot, block)
+	lightClientHeader, err := BlockToLightClientHeader(ctx, state.Version(), block)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert block to light client header")
 	}
@@ -942,78 +750,6 @@ 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,7 +7,6 @@ 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"
@@ -547,7 +546,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 		header, err := lightClient.BlockToLightClientHeader(
 			l.Ctx,
-			primitives.Slot(params.BeaconConfig().AltairForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+			version.Altair,
 			l.Block,
 		)
 		require.NoError(t, err)
@@ -570,7 +569,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 		header, err := lightClient.BlockToLightClientHeader(
 			l.Ctx,
-			primitives.Slot(params.BeaconConfig().BellatrixForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+			version.Bellatrix,
 			l.Block,
 		)
 		require.NoError(t, err)
@@ -594,7 +593,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				primitives.Slot(params.BeaconConfig().CapellaForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+				version.Capella,
 				l.Block,
 			)
 			require.NoError(t, err)
@@ -655,7 +654,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				primitives.Slot(params.BeaconConfig().CapellaForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+				version.Capella,
 				l.Block,
 			)
 			require.NoError(t, err)
@@ -718,7 +717,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+				version.Deneb,
 				l.Block,
 			)
 			require.NoError(t, err)
@@ -787,7 +786,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+				version.Deneb,
 				l.Block,
 			)
 			require.NoError(t, err)
@@ -856,7 +855,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, l.State.Slot(), l.Block)
+			header, err := lightClient.BlockToLightClientHeader(l.Ctx, version.Electra, l.Block)
 			require.NoError(t, err)
 			require.NotNil(t, header, "header is nil")
 
@@ -921,7 +920,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, l.State.Slot(), l.Block)
+			header, err := lightClient.BlockToLightClientHeader(l.Ctx, version.Electra, l.Block)
 			require.NoError(t, err)
 			require.NotNil(t, header, "header is nil")
 
@@ -989,7 +988,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 		header, err := lightClient.BlockToLightClientHeader(
 			l.Ctx,
-			primitives.Slot(params.BeaconConfig().CapellaForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+			version.Capella,
 			l.Block)
 		require.NoError(t, err)
 		require.NotNil(t, header, "header is nil")
@@ -1011,7 +1010,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 		header, err := lightClient.BlockToLightClientHeader(
 			l.Ctx,
-			primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+			version.Deneb,
 			l.Block)
 		require.NoError(t, err)
 		require.NotNil(t, header, "header is nil")
@@ -1034,7 +1033,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+				version.Deneb,
 				l.Block)
 			require.NoError(t, err)
 			require.NotNil(t, header, "header is nil")
@@ -1094,7 +1093,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 
 			header, err := lightClient.BlockToLightClientHeader(
 				l.Ctx,
-				primitives.Slot(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SlotsPerEpoch,
+				version.Deneb,
 				l.Block)
 			require.NoError(t, err)
 			require.NotNil(t, header, "header is nil")
@@ -1180,14 +1179,13 @@ func createNonEmptyFinalityBranch() [][]byte {
 }
 
 func TestIsBetterUpdate(t *testing.T) {
-	config := params.BeaconConfig()
-	st, err := util.NewBeaconStateAltair()
+	blk, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockAltair())
 	require.NoError(t, err)
 
 	t.Run("new has supermajority but old doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1203,9 +1201,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("old has supermajority but new doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1221,9 +1219,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1239,9 +1237,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1257,9 +1255,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1296,9 +1294,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1335,9 +1333,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new has finality but old doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1378,9 +1376,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("old has finality but new doesn't", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1421,9 +1419,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1482,9 +1480,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1543,9 +1541,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new has more active participants than old", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1561,9 +1559,9 @@ func TestIsBetterUpdate(t *testing.T) {
 	})
 
 	t.Run("new has less active participants than old", func(t *testing.T) {
-		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1579,9 +1577,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1640,9 +1638,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1701,9 +1699,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{
@@ -1762,9 +1760,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(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(1), st)
+		oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
-		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(primitives.Slot(config.AltairForkEpoch*primitives.Epoch(config.SlotsPerEpoch)).Add(2), st)
+		newUpdate, err := lightClient.CreateDefaultLightClientUpdate(blk)
 		require.NoError(t, err)
 
 		oldUpdate.SetSyncAggregate(&pb.SyncAggregate{

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

@@ -1,18 +1,57 @@
 package light_client
 
 import (
+	"context"
 	"sync"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/pkg/errors"
 )
 
+var ErrLightClientBootstrapNotFound = errors.New("light client bootstrap not found")
+
 type Store struct {
 	mu sync.RWMutex
 
+	beaconDB             iface.HeadAccessDatabase
 	lastFinalityUpdate   interfaces.LightClientFinalityUpdate
 	lastOptimisticUpdate interfaces.LightClientOptimisticUpdate
 }
 
+func NewLightClientStore(db iface.HeadAccessDatabase) *Store {
+	return &Store{
+		beaconDB: db,
+	}
+}
+
+func (s *Store) LightClientBootstrap(ctx context.Context, blockRoot [32]byte) (interfaces.LightClientBootstrap, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	// Fetch the light client bootstrap from the database
+	bootstrap, err := s.beaconDB.LightClientBootstrap(ctx, blockRoot[:])
+	if err != nil {
+		return nil, err
+	}
+	if bootstrap == nil { // not found
+		return nil, ErrLightClientBootstrapNotFound
+	}
+
+	return bootstrap, nil
+}
+
+func (s *Store) SaveLightClientBootstrap(ctx context.Context, blockRoot [32]byte, bootstrap interfaces.LightClientBootstrap) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// Save the light client bootstrap to the database
+	if err := s.beaconDB.SaveLightClientBootstrap(ctx, blockRoot[:], bootstrap); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (s *Store) SetLastFinalityUpdate(update interfaces.LightClientFinalityUpdate) {
 	s.mu.Lock()
 	defer s.mu.Unlock()

beacon-chain/core/transition/stateutils/validator_index_map.go

@@ -8,6 +8,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	log "github.com/sirupsen/logrus"
 )
 
 // ValidatorIndexMap builds a lookup map for quickly determining the index of
@@ -21,8 +22,12 @@ func ValidatorIndexMap(validators []*ethpb.Validator) map[[fieldparams.BLSPubkey
 		if record == nil {
 			continue
 		}
+		if record.EffectiveBalance == 0 {
+			continue
+		}
 		key := bytesutil.ToBytes48(record.PublicKey)
 		m[key] = primitives.ValidatorIndex(idx)
 	}
+	log.Info("ValidatorIndexMap built with ", len(m), " entries")
 	return m
 }

beacon-chain/das/availability_blobs.go

@@ -12,7 +12,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/runtime/logging"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
-	errors "github.com/pkg/errors"
+	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -122,7 +122,7 @@ func (s *LazilyPersistentStoreBlob) IsDataAvailable(ctx context.Context, current
 				lf[fmt.Sprintf("fail_%d", i)] = fails[i].Error()
 			}
 			log.WithFields(lf).WithFields(logging.BlockFieldsFromBlob(sidecars[0])).
-				Debug("invalid BlobSidecars received")
+				Debug("Invalid BlobSidecars received")
 		}
 		return errors.Wrapf(err, "invalid BlobSidecars received for block %#x", root)
 	}

beacon-chain/db/filesystem/layout.go

@@ -255,7 +255,7 @@ func pruneBefore(before primitives.Epoch, l fsLayout) (map[primitives.Epoch]*pru
 				}
 				continue
 			}
-			log.WithError(err).Error("encountered unhandled error during pruning")
+			log.WithError(err).Error("Encountered unhandled error during pruning")
 			return nil, errors.Wrap(errPruneFailed, err.Error())
 		}
 		if ident.epoch >= before {

beacon-chain/db/kv/lightclient.go

@@ -153,6 +153,13 @@ func decodeLightClientBootstrap(enc []byte) (interfaces.LightClientBootstrap, []
 		}
 		m = bootstrap
 		syncCommitteeHash = enc[len(altairKey) : len(altairKey)+32]
+	case hasBellatrixKey(enc):
+		bootstrap := &ethpb.LightClientBootstrapAltair{}
+		if err := bootstrap.UnmarshalSSZ(enc[len(bellatrixKey)+32:]); err != nil {
+			return nil, nil, errors.Wrap(err, "could not unmarshal Bellatrix light client bootstrap")
+		}
+		m = bootstrap
+		syncCommitteeHash = enc[len(bellatrixKey) : len(bellatrixKey)+32]
 	case hasCapellaKey(enc):
 		bootstrap := &ethpb.LightClientBootstrapCapella{}
 		if err := bootstrap.UnmarshalSSZ(enc[len(capellaKey)+32:]); err != nil {
@@ -265,6 +272,12 @@ func decodeLightClientUpdate(enc []byte) (interfaces.LightClientUpdate, error) {
 			return nil, errors.Wrap(err, "could not unmarshal Altair light client update")
 		}
 		m = update
+	case hasBellatrixKey(enc):
+		update := &ethpb.LightClientUpdateAltair{}
+		if err := update.UnmarshalSSZ(enc[len(bellatrixKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Bellatrix light client update")
+		}
+		m = update
 	case hasCapellaKey(enc):
 		update := &ethpb.LightClientUpdateCapella{}
 		if err := update.UnmarshalSSZ(enc[len(capellaKey):]); err != nil {
@@ -297,6 +310,8 @@ func keyForLightClientUpdate(v int) ([]byte, error) {
 		return denebKey, nil
 	case version.Capella:
 		return capellaKey, nil
+	case version.Bellatrix:
+		return bellatrixKey, nil
 	case version.Altair:
 		return altairKey, nil
 	default:

beacon-chain/db/kv/lightclient_test.go

@@ -46,7 +46,21 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 		slot = primitives.Slot(config.AltairForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 		header, err = light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
 			Beacon: &pb.BeaconBlockHeader{
-				Slot:          1,
+				Slot:          slot,
+				ProposerIndex: primitives.ValidatorIndex(rand.Int()),
+				ParentRoot:    sampleRoot,
+				StateRoot:     sampleRoot,
+				BodyRoot:      sampleRoot,
+			},
+		})
+		require.NoError(t, err)
+		st, err = util.NewBeaconState()
+		require.NoError(t, err)
+	case version.Bellatrix:
+		slot = primitives.Slot(config.BellatrixForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
+		header, err = light_client.NewWrappedHeader(&pb.LightClientHeaderAltair{
+			Beacon: &pb.BeaconBlockHeader{
+				Slot:          slot,
 				ProposerIndex: primitives.ValidatorIndex(rand.Int()),
 				ParentRoot:    sampleRoot,
 				StateRoot:     sampleRoot,
@@ -60,7 +74,7 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 		slot = primitives.Slot(config.CapellaForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 		header, err = light_client.NewWrappedHeader(&pb.LightClientHeaderCapella{
 			Beacon: &pb.BeaconBlockHeader{
-				Slot:          1,
+				Slot:          slot,
 				ProposerIndex: primitives.ValidatorIndex(rand.Int()),
 				ParentRoot:    sampleRoot,
 				StateRoot:     sampleRoot,
@@ -88,7 +102,7 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 		slot = primitives.Slot(config.DenebForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 		header, err = light_client.NewWrappedHeader(&pb.LightClientHeaderDeneb{
 			Beacon: &pb.BeaconBlockHeader{
-				Slot:          1,
+				Slot:          slot,
 				ProposerIndex: primitives.ValidatorIndex(rand.Int()),
 				ParentRoot:    sampleRoot,
 				StateRoot:     sampleRoot,
@@ -116,7 +130,7 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 		slot = primitives.Slot(config.ElectraForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 		header, err = light_client.NewWrappedHeader(&pb.LightClientHeaderDeneb{
 			Beacon: &pb.BeaconBlockHeader{
-				Slot:          1,
+				Slot:          slot,
 				ProposerIndex: primitives.ValidatorIndex(rand.Int()),
 				ParentRoot:    sampleRoot,
 				StateRoot:     sampleRoot,
@@ -144,7 +158,7 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 		slot = primitives.Slot(config.FuluForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 		header, err = light_client.NewWrappedHeader(&pb.LightClientHeaderDeneb{
 			Beacon: &pb.BeaconBlockHeader{
-				Slot:          1,
+				Slot:          slot,
 				ProposerIndex: primitives.ValidatorIndex(rand.Int()),
 				ParentRoot:    sampleRoot,
 				StateRoot:     sampleRoot,
@@ -192,71 +206,30 @@ func TestStore_LightClientUpdate_CanSaveRetrieve(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	cfg := params.BeaconConfig()
 	cfg.AltairForkEpoch = 0
-	cfg.CapellaForkEpoch = 1
-	cfg.DenebForkEpoch = 2
-	cfg.ElectraForkEpoch = 3
-	cfg.FuluForkEpoch = 3
+	cfg.BellatrixForkEpoch = 1
+	cfg.CapellaForkEpoch = 2
+	cfg.DenebForkEpoch = 3
+	cfg.ElectraForkEpoch = 4
+	cfg.FuluForkEpoch = 5
 	params.OverrideBeaconConfig(cfg)
 
 	db := setupDB(t)
 	ctx := t.Context()
 
-	t.Run("Altair", func(t *testing.T) {
-		update, err := createUpdate(t, version.Altair)
-		require.NoError(t, err)
-		period := uint64(1)
+	for testVersion := version.Altair; testVersion <= version.Electra; testVersion++ {
+		t.Run(version.String(testVersion), func(t *testing.T) {
+			update, err := createUpdate(t, testVersion)
+			require.NoError(t, err)
+			period := uint64(1)
 
-		err = db.SaveLightClientUpdate(ctx, period, update)
-		require.NoError(t, err)
+			err = db.SaveLightClientUpdate(ctx, period, update)
+			require.NoError(t, err)
 
-		retrievedUpdate, err := db.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.DeepEqual(t, update, retrievedUpdate, "retrieved update does not match saved update")
-	})
-	t.Run("Capella", func(t *testing.T) {
-		update, err := createUpdate(t, version.Capella)
-		require.NoError(t, err)
-		period := uint64(1)
-		err = db.SaveLightClientUpdate(ctx, period, update)
-		require.NoError(t, err)
-
-		retrievedUpdate, err := db.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.DeepEqual(t, update, retrievedUpdate, "retrieved update does not match saved update")
-	})
-	t.Run("Deneb", func(t *testing.T) {
-		update, err := createUpdate(t, version.Deneb)
-		require.NoError(t, err)
-		period := uint64(1)
-		err = db.SaveLightClientUpdate(ctx, period, update)
-		require.NoError(t, err)
-
-		retrievedUpdate, err := db.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.DeepEqual(t, update, retrievedUpdate, "retrieved update does not match saved update")
-	})
-	t.Run("Electra", func(t *testing.T) {
-		update, err := createUpdate(t, version.Electra)
-		require.NoError(t, err)
-		period := uint64(1)
-		err = db.SaveLightClientUpdate(ctx, period, update)
-		require.NoError(t, err)
-
-		retrievedUpdate, err := db.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.DeepEqual(t, update, retrievedUpdate, "retrieved update does not match saved update")
-	})
-	t.Run("Fulu", func(t *testing.T) {
-		update, err := createUpdate(t, version.Fulu)
-		require.NoError(t, err)
-		period := uint64(1)
-		err = db.SaveLightClientUpdate(ctx, period, update)
-		require.NoError(t, err)
-
-		retrievedUpdate, err := db.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.DeepEqual(t, update, retrievedUpdate, "retrieved update does not match saved update")
-	})
+			retrievedUpdate, err := db.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.DeepEqual(t, update, retrievedUpdate, "retrieved update does not match saved update")
+		})
+	}
 }
 
 func TestStore_LightClientUpdates_canRetrieveRange(t *testing.T) {
@@ -584,9 +557,10 @@ func TestStore_LightClientBootstrap_CanSaveRetrieve(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	cfg := params.BeaconConfig()
 	cfg.AltairForkEpoch = 0
-	cfg.CapellaForkEpoch = 1
-	cfg.DenebForkEpoch = 2
-	cfg.ElectraForkEpoch = 3
+	cfg.BellatrixForkEpoch = 1
+	cfg.CapellaForkEpoch = 2
+	cfg.DenebForkEpoch = 3
+	cfg.ElectraForkEpoch = 4
 	cfg.EpochsPerSyncCommitteePeriod = 1
 	params.OverrideBeaconConfig(cfg)
 
@@ -599,89 +573,38 @@ func TestStore_LightClientBootstrap_CanSaveRetrieve(t *testing.T) {
 		require.IsNil(t, retrievedBootstrap)
 	})
 
-	t.Run("Altair", func(t *testing.T) {
-		bootstrap, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().AltairForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
-		require.NoError(t, err)
+	for testVersion := version.Altair; testVersion <= version.Electra; testVersion++ {
+		t.Run(version.String(testVersion), func(t *testing.T) {
+			bootstrap, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().VersionToForkEpochMap()[testVersion]) * uint64(params.BeaconConfig().SlotsPerEpoch)))
+			require.NoError(t, err)
 
-		err = bootstrap.SetCurrentSyncCommittee(createRandomSyncCommittee())
-		require.NoError(t, err)
+			err = bootstrap.SetCurrentSyncCommittee(createRandomSyncCommittee())
+			require.NoError(t, err)
 
-		err = db.SaveLightClientBootstrap(ctx, []byte("blockRootAltair"), bootstrap)
-		require.NoError(t, err)
+			blockRoot := []byte("blockRootAltair" + version.String(testVersion))
 
-		retrievedBootstrap, err := db.LightClientBootstrap(ctx, []byte("blockRootAltair"))
-		require.NoError(t, err)
-		require.DeepEqual(t, bootstrap.Header(), retrievedBootstrap.Header(), "retrieved bootstrap header does not match saved bootstrap header")
-		require.DeepEqual(t, bootstrap.CurrentSyncCommittee(), retrievedBootstrap.CurrentSyncCommittee(), "retrieved bootstrap sync committee does not match saved bootstrap sync committee")
-		savedBranch, err := bootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
-	})
+			err = db.SaveLightClientBootstrap(ctx, blockRoot, bootstrap)
+			require.NoError(t, err)
 
-	t.Run("Capella", func(t *testing.T) {
-		bootstrap, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().CapellaForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
-		require.NoError(t, err)
-
-		err = bootstrap.SetCurrentSyncCommittee(createRandomSyncCommittee())
-		require.NoError(t, err)
-
-		err = db.SaveLightClientBootstrap(ctx, []byte("blockRootCapella"), bootstrap)
-		require.NoError(t, err)
-
-		retrievedBootstrap, err := db.LightClientBootstrap(ctx, []byte("blockRootCapella"))
-		require.NoError(t, err)
-		require.DeepEqual(t, bootstrap.Header(), retrievedBootstrap.Header(), "retrieved bootstrap header does not match saved bootstrap header")
-		require.DeepEqual(t, bootstrap.CurrentSyncCommittee(), retrievedBootstrap.CurrentSyncCommittee(), "retrieved bootstrap sync committee does not match saved bootstrap sync committee")
-		savedBranch, err := bootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
-	})
-
-	t.Run("Deneb", func(t *testing.T) {
-		bootstrap, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().DenebForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
-		require.NoError(t, err)
-
-		err = bootstrap.SetCurrentSyncCommittee(createRandomSyncCommittee())
-		require.NoError(t, err)
-
-		err = db.SaveLightClientBootstrap(ctx, []byte("blockRootDeneb"), bootstrap)
-		require.NoError(t, err)
-
-		retrievedBootstrap, err := db.LightClientBootstrap(ctx, []byte("blockRootDeneb"))
-		require.NoError(t, err)
-		require.DeepEqual(t, bootstrap.Header(), retrievedBootstrap.Header(), "retrieved bootstrap header does not match saved bootstrap header")
-		require.DeepEqual(t, bootstrap.CurrentSyncCommittee(), retrievedBootstrap.CurrentSyncCommittee(), "retrieved bootstrap sync committee does not match saved bootstrap sync committee")
-		savedBranch, err := bootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
-	})
-
-	t.Run("Electra", func(t *testing.T) {
-		bootstrap, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().ElectraForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
-		require.NoError(t, err)
-
-		err = bootstrap.SetCurrentSyncCommittee(createRandomSyncCommittee())
-		require.NoError(t, err)
-
-		err = db.SaveLightClientBootstrap(ctx, []byte("blockRootElectra"), bootstrap)
-		require.NoError(t, err)
-
-		retrievedBootstrap, err := db.LightClientBootstrap(ctx, []byte("blockRootElectra"))
-		require.NoError(t, err)
-		require.DeepEqual(t, bootstrap.Header(), retrievedBootstrap.Header(), "retrieved bootstrap header does not match saved bootstrap header")
-		require.DeepEqual(t, bootstrap.CurrentSyncCommittee(), retrievedBootstrap.CurrentSyncCommittee(), "retrieved bootstrap sync committee does not match saved bootstrap sync committee")
-		savedBranch, err := bootstrap.CurrentSyncCommitteeBranchElectra()
-		require.NoError(t, err)
-		retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranchElectra()
-		require.NoError(t, err)
-		require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
-	})
+			retrievedBootstrap, err := db.LightClientBootstrap(ctx, blockRoot)
+			require.NoError(t, err)
+			require.DeepEqual(t, bootstrap.Header(), retrievedBootstrap.Header(), "retrieved bootstrap header does not match saved bootstrap header")
+			require.DeepEqual(t, bootstrap.CurrentSyncCommittee(), retrievedBootstrap.CurrentSyncCommittee(), "retrieved bootstrap sync committee does not match saved bootstrap sync committee")
+			if testVersion >= version.Electra {
+				savedBranch, err := bootstrap.CurrentSyncCommitteeBranchElectra()
+				require.NoError(t, err)
+				retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranchElectra()
+				require.NoError(t, err)
+				require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
+			} else {
+				savedBranch, err := bootstrap.CurrentSyncCommitteeBranch()
+				require.NoError(t, err)
+				retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranch()
+				require.NoError(t, err)
+				require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
+			}
+		})
+	}
 }
 
 func TestStore_LightClientBootstrap_MultipleBootstrapsWithSameSyncCommittee(t *testing.T) {
@@ -839,6 +762,7 @@ func createDefaultLightClientBootstrap(currentSlot primitives.Slot) (interfaces.
 		m = &pb.LightClientBootstrapAltair{
 			Header: &pb.LightClientHeaderAltair{
 				Beacon: &pb.BeaconBlockHeader{
+					Slot:       currentSlot,
 					ParentRoot: make([]byte, 32),
 					StateRoot:  make([]byte, 32),
 					BodyRoot:   make([]byte, 32),
@@ -851,6 +775,7 @@ func createDefaultLightClientBootstrap(currentSlot primitives.Slot) (interfaces.
 		m = &pb.LightClientBootstrapCapella{
 			Header: &pb.LightClientHeaderCapella{
 				Beacon: &pb.BeaconBlockHeader{
+					Slot:       currentSlot,
 					ParentRoot: make([]byte, 32),
 					StateRoot:  make([]byte, 32),
 					BodyRoot:   make([]byte, 32),
@@ -877,6 +802,7 @@ func createDefaultLightClientBootstrap(currentSlot primitives.Slot) (interfaces.
 		m = &pb.LightClientBootstrapDeneb{
 			Header: &pb.LightClientHeaderDeneb{
 				Beacon: &pb.BeaconBlockHeader{
+					Slot:       currentSlot,
 					ParentRoot: make([]byte, 32),
 					StateRoot:  make([]byte, 32),
 					BodyRoot:   make([]byte, 32),
@@ -905,6 +831,7 @@ func createDefaultLightClientBootstrap(currentSlot primitives.Slot) (interfaces.
 		m = &pb.LightClientBootstrapElectra{
 			Header: &pb.LightClientHeaderDeneb{
 				Beacon: &pb.BeaconBlockHeader{
+					Slot:       currentSlot,
 					ParentRoot: make([]byte, 32),
 					StateRoot:  make([]byte, 32),
 					BodyRoot:   make([]byte, 32),

beacon-chain/execution/BUILD.bazel

@@ -31,6 +31,7 @@ go_library(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/execution/types:go_default_library",
@@ -97,6 +98,7 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//async/event:go_default_library",
+        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",

beacon-chain/execution/engine_client.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
@@ -44,11 +45,18 @@ var (
 		GetPayloadMethodV3,
 		GetPayloadBodiesByHashV1,
 		GetPayloadBodiesByRangeV1,
+		GetBlobsV1,
 	}
+
 	electraEngineEndpoints = []string{
 		NewPayloadMethodV4,
 		GetPayloadMethodV4,
 	}
+
+	fuluEngineEndpoints = []string{
+		GetPayloadMethodV5,
+		GetBlobsV2,
+	}
 )
 
 const (
@@ -73,6 +81,8 @@ const (
 	GetPayloadMethodV3 = "engine_getPayloadV3"
 	// GetPayloadMethodV4 is the get payload method added for electra
 	GetPayloadMethodV4 = "engine_getPayloadV4"
+	// GetPayloadMethodV5 is the get payload method added for fulu
+	GetPayloadMethodV5 = "engine_getPayloadV5"
 	// BlockByHashMethod request string for JSON-RPC.
 	BlockByHashMethod = "eth_getBlockByHash"
 	// BlockByNumberMethod request string for JSON-RPC.
@@ -85,11 +95,16 @@ const (
 	ExchangeCapabilities = "engine_exchangeCapabilities"
 	// GetBlobsV1 request string for JSON-RPC.
 	GetBlobsV1 = "engine_getBlobsV1"
+	// GetBlobsV2 request string for JSON-RPC.
+	GetBlobsV2 = "engine_getBlobsV2"
 	// Defines the seconds before timing out engine endpoints with non-block execution semantics.
 	defaultEngineTimeout = time.Second
 )
 
-var errInvalidPayloadBodyResponse = errors.New("engine api payload body response is invalid")
+var (
+	errInvalidPayloadBodyResponse  = errors.New("engine api payload body response is invalid")
+	errMissingBlobsAndProofsFromEL = errors.New("engine api payload body response is missing blobs and proofs")
+)
 
 // ForkchoiceUpdatedResponse is the response kind received by the
 // engine_forkchoiceUpdatedV1 endpoint.
@@ -107,7 +122,8 @@ type Reconstructor interface {
 	ReconstructFullBellatrixBlockBatch(
 		ctx context.Context, blindedBlocks []interfaces.ReadOnlySignedBeaconBlock,
 	) ([]interfaces.SignedBeaconBlock, error)
-	ReconstructBlobSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, hi func(uint64) bool) ([]blocks.VerifiedROBlob, error)
+	ReconstructBlobSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte, hi func(uint64) bool) ([]blocks.VerifiedROBlob, error)
+	ReconstructDataColumnSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error)
 }
 
 // EngineCaller defines a client that can interact with an Ethereum
@@ -256,14 +272,17 @@ func (s *Service) ForkchoiceUpdated(
 }
 
 func getPayloadMethodAndMessage(slot primitives.Slot) (string, proto.Message) {
-	pe := slots.ToEpoch(slot)
-	if pe >= params.BeaconConfig().ElectraForkEpoch {
+	epoch := slots.ToEpoch(slot)
+	if epoch >= params.BeaconConfig().FuluForkEpoch {
+		return GetPayloadMethodV5, &pb.ExecutionBundleFulu{}
+	}
+	if epoch >= params.BeaconConfig().ElectraForkEpoch {
 		return GetPayloadMethodV4, &pb.ExecutionBundleElectra{}
 	}
-	if pe >= params.BeaconConfig().DenebForkEpoch {
+	if epoch >= params.BeaconConfig().DenebForkEpoch {
 		return GetPayloadMethodV3, &pb.ExecutionPayloadDenebWithValueAndBlobsBundle{}
 	}
-	if pe >= params.BeaconConfig().CapellaForkEpoch {
+	if epoch >= params.BeaconConfig().CapellaForkEpoch {
 		return GetPayloadMethodV2, &pb.ExecutionPayloadCapellaWithValue{}
 	}
 	return GetPayloadMethod, &pb.ExecutionPayload{}
@@ -289,7 +308,7 @@ func (s *Service) GetPayload(ctx context.Context, payloadId [8]byte, slot primit
 	}
 	res, err := blocks.NewGetPayloadResponse(result)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "new get payload response")
 	}
 	return res, nil
 }
@@ -298,33 +317,36 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.ExchangeCapabilities")
 	defer span.End()
 
-	// Only check for electra related engine methods if it has been activated.
 	if params.ElectraEnabled() {
 		supportedEngineEndpoints = append(supportedEngineEndpoints, electraEngineEndpoints...)
 	}
-	var result []string
-	err := s.rpcClient.CallContext(ctx, &result, ExchangeCapabilities, supportedEngineEndpoints)
-	if err != nil {
+
+	if params.FuluEnabled() {
+		supportedEngineEndpoints = append(supportedEngineEndpoints, fuluEngineEndpoints...)
+	}
+
+	elSupportedEndpointsSlice := make([]string, len(supportedEngineEndpoints))
+	if err := s.rpcClient.CallContext(ctx, &elSupportedEndpointsSlice, ExchangeCapabilities, supportedEngineEndpoints); err != nil {
 		return nil, handleRPCError(err)
 	}
 
-	var unsupported []string
-	for _, s1 := range supportedEngineEndpoints {
-		supported := false
-		for _, s2 := range result {
-			if s1 == s2 {
-				supported = true
-				break
-			}
-		}
-		if !supported {
-			unsupported = append(unsupported, s1)
+	elSupportedEndpoints := make(map[string]bool, len(elSupportedEndpointsSlice))
+	for _, method := range elSupportedEndpointsSlice {
+		elSupportedEndpoints[method] = true
+	}
+
+	unsupported := make([]string, 0)
+	for _, method := range supportedEngineEndpoints {
+		if !elSupportedEndpoints[method] {
+			unsupported = append(unsupported, method)
 		}
 	}
+
 	if len(unsupported) != 0 {
-		log.Warnf("Please update client, detected the following unsupported engine methods: %s", unsupported)
+		log.WithField("methods", unsupported).Warning("Connected execution client does not support some requested engine methods")
 	}
-	return result, handleRPCError(err)
+
+	return elSupportedEndpointsSlice, nil
 }
 
 // GetTerminalBlockHash returns the valid terminal block hash based on total difficulty.
@@ -495,9 +517,10 @@ func (s *Service) HeaderByNumber(ctx context.Context, number *big.Int) (*types.H
 func (s *Service) GetBlobs(ctx context.Context, versionedHashes []common.Hash) ([]*pb.BlobAndProof, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetBlobs")
 	defer span.End()
+
 	// If the execution engine does not support `GetBlobsV1`, return early to prevent encountering an error later.
 	if !s.capabilityCache.has(GetBlobsV1) {
-		return nil, nil
+		return nil, errors.New(fmt.Sprintf("%s is not supported", GetBlobsV1))
 	}
 
 	result := make([]*pb.BlobAndProof, len(versionedHashes))
@@ -505,6 +528,19 @@ func (s *Service) GetBlobs(ctx context.Context, versionedHashes []common.Hash) (
 	return result, handleRPCError(err)
 }
 
+func (s *Service) GetBlobsV2(ctx context.Context, versionedHashes []common.Hash) ([]*pb.BlobAndProofV2, error) {
+	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetBlobsV2")
+	defer span.End()
+
+	if !s.capabilityCache.has(GetBlobsV2) {
+		return nil, errors.New(fmt.Sprintf("%s is not supported", GetBlobsV2))
+	}
+
+	result := make([]*pb.BlobAndProofV2, len(versionedHashes))
+	err := s.rpcClient.CallContext(ctx, &result, GetBlobsV2, versionedHashes)
+	return result, handleRPCError(err)
+}
+
 // ReconstructFullBlock takes in a blinded beacon block and reconstructs
 // a beacon block with a full execution payload via the engine API.
 func (s *Service) ReconstructFullBlock(
@@ -584,7 +620,7 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 		blobIndex := kzgIndexes[i]
 		proof, err := blocks.MerkleProofKZGCommitment(blockBody, blobIndex)
 		if err != nil {
-			log.WithError(err).WithField("index", blobIndex).Error("failed to get Merkle proof for KZG commitment")
+			log.WithError(err).WithField("index", blobIndex).Error("Failed to get Merkle proof for KZG commitment")
 			continue
 		}
 		sidecar := &ethpb.BlobSidecar{
@@ -598,14 +634,14 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 
 		roBlob, err := blocks.NewROBlobWithRoot(sidecar, blockRoot)
 		if err != nil {
-			log.WithError(err).WithField("index", blobIndex).Error("failed to create RO blob with root")
+			log.WithError(err).WithField("index", blobIndex).Error("Failed to create RO blob with root")
 			continue
 		}
 
 		v := s.blobVerifier(roBlob, verification.ELMemPoolRequirements)
 		verifiedBlob, err := v.VerifiedROBlob()
 		if err != nil {
-			log.WithError(err).WithField("index", blobIndex).Error("failed to verify RO blob")
+			log.WithError(err).WithField("index", blobIndex).Error("Failed to verify RO blob")
 			continue
 		}
 
@@ -615,6 +651,75 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 	return verifiedBlobs, nil
 }
 
+// ReconstructDataColumnSidecars reconstructs the verified data column sidecars for a given beacon block.
+// It retrieves the KZG commitments from the block body, fetches the associated blobs and cell proofs from the EL,
+// and constructs the corresponding verified read-only data column sidecars.
+func (s *Service) ReconstructDataColumnSidecars(ctx context.Context, signedROBlock interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error) {
+	block := signedROBlock.Block()
+
+	log := log.WithFields(logrus.Fields{
+		"root": fmt.Sprintf("%#x", blockRoot),
+		"slot": block.Slot(),
+	})
+
+	kzgCommitments, err := block.Body().BlobKzgCommitments()
+	if err != nil {
+		return nil, wrapWithBlockRoot(err, blockRoot, "blob KZG commitments")
+	}
+
+	// Collect KZG hashes for all blobs.
+	versionedHashes := make([]common.Hash, 0, len(kzgCommitments))
+	for _, commitment := range kzgCommitments {
+		versionedHash := primitives.ConvertKzgCommitmentToVersionedHash(commitment)
+		versionedHashes = append(versionedHashes, versionedHash)
+	}
+
+	// Fetch all blobsAndCellsProofs from the execution client.
+	blobAndProofV2s, err := s.GetBlobsV2(ctx, versionedHashes)
+	if err != nil {
+		return nil, wrapWithBlockRoot(err, blockRoot, "get blobs V2")
+	}
+
+	// Return early if nothing is returned from the EL.
+	if len(blobAndProofV2s) == 0 {
+		log.Debug("No blobs returned from EL")
+		return nil, nil
+	}
+
+	// Extract the blobs and proofs from the blobAndProofV2s.
+	blobs, cellProofs := make([][]byte, 0, len(blobAndProofV2s)), make([][]byte, 0, len(blobAndProofV2s))
+	for _, blobsAndProofs := range blobAndProofV2s {
+		if blobsAndProofs == nil {
+			return nil, wrapWithBlockRoot(errMissingBlobsAndProofsFromEL, blockRoot, "")
+		}
+
+		blobs, cellProofs = append(blobs, blobsAndProofs.Blob), append(cellProofs, blobsAndProofs.KzgProofs...)
+	}
+
+	// Construct the data column sidcars from the blobs and cell proofs provided by the execution client.
+	dataColumnSidecars, err := peerdas.ConstructDataColumnSidecars(signedROBlock, blobs, cellProofs)
+	if err != nil {
+		return nil, wrapWithBlockRoot(err, blockRoot, "construct data column sidecars")
+	}
+
+	// Finally, construct verified RO data column sidecars.
+	// We trust the execution layer we are connected to, so we can upgrade the read only data column sidecar into a verified one.
+	verifiedRODataColumns := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecars))
+	for _, dataColumnSidecar := range dataColumnSidecars {
+		roDataColumn, err := blocks.NewRODataColumnWithRoot(dataColumnSidecar, blockRoot)
+		if err != nil {
+			return nil, wrapWithBlockRoot(err, blockRoot, "new read-only data column with root")
+		}
+
+		verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
+		verifiedRODataColumns = append(verifiedRODataColumns, verifiedRODataColumn)
+	}
+
+	log.Debug("Data columns successfully reconstructed from the execution client.")
+
+	return verifiedRODataColumns, nil
+}
+
 func fullPayloadFromPayloadBody(
 	header interfaces.ExecutionData, body *pb.ExecutionPayloadBody, bVersion int,
 ) (interfaces.ExecutionData, error) {
@@ -902,3 +1007,8 @@ func toBlockNumArg(number *big.Int) string {
 	}
 	return hexutil.EncodeBig(number)
 }
+
+// wrapWithBlockRoot returns a new error with the given block root.
+func wrapWithBlockRoot(err error, blockRoot [32]byte, message string) error {
+	return errors.Wrap(err, fmt.Sprintf("%s for block %#x", message, blockRoot))
+}

beacon-chain/execution/engine_client_test.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	mocks "github.com/OffchainLabs/prysm/v6/beacon-chain/execution/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
@@ -167,6 +168,7 @@ func TestClient_HTTP(t *testing.T) {
 	cfg.CapellaForkEpoch = 1
 	cfg.DenebForkEpoch = 2
 	cfg.ElectraForkEpoch = 3
+	cfg.FuluForkEpoch = 4
 	params.OverrideBeaconConfig(cfg)
 
 	t.Run(GetPayloadMethod, func(t *testing.T) {
@@ -317,11 +319,11 @@ func TestClient_HTTP(t *testing.T) {
 		require.DeepEqual(t, uint64(2), g)
 
 		commitments := [][]byte{bytesutil.PadTo([]byte("commitment1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("commitment2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, commitments, resp.BlobsBundle.KzgCommitments)
+		require.DeepEqual(t, commitments, resp.BlobsBundler.GetKzgCommitments())
 		proofs := [][]byte{bytesutil.PadTo([]byte("proof1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("proof2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, proofs, resp.BlobsBundle.Proofs)
+		require.DeepEqual(t, proofs, resp.BlobsBundler.GetProofs())
 		blobs := [][]byte{bytesutil.PadTo([]byte("a"), fieldparams.BlobLength), bytesutil.PadTo([]byte("b"), fieldparams.BlobLength)}
-		require.DeepEqual(t, blobs, resp.BlobsBundle.Blobs)
+		require.DeepEqual(t, blobs, resp.BlobsBundler.GetBlobs())
 	})
 	t.Run(GetPayloadMethodV4, func(t *testing.T) {
 		payloadId := [8]byte{1}
@@ -372,11 +374,11 @@ func TestClient_HTTP(t *testing.T) {
 		require.DeepEqual(t, uint64(2), g)
 
 		commitments := [][]byte{bytesutil.PadTo([]byte("commitment1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("commitment2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, commitments, resp.BlobsBundle.KzgCommitments)
+		require.DeepEqual(t, commitments, resp.BlobsBundler.GetKzgCommitments())
 		proofs := [][]byte{bytesutil.PadTo([]byte("proof1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("proof2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, proofs, resp.BlobsBundle.Proofs)
+		require.DeepEqual(t, proofs, resp.BlobsBundler.GetProofs())
 		blobs := [][]byte{bytesutil.PadTo([]byte("a"), fieldparams.BlobLength), bytesutil.PadTo([]byte("b"), fieldparams.BlobLength)}
-		require.DeepEqual(t, blobs, resp.BlobsBundle.Blobs)
+		require.DeepEqual(t, blobs, resp.BlobsBundler.GetBlobs())
 		requests := &pb.ExecutionRequests{
 			Deposits: []*pb.DepositRequest{
 				{
@@ -405,7 +407,52 @@ func TestClient_HTTP(t *testing.T) {
 
 		require.DeepEqual(t, requests, resp.ExecutionRequests)
 	})
+	t.Run(GetPayloadMethodV5, func(t *testing.T) {
+		payloadId := [8]byte{1}
+		want, ok := fix["ExecutionBundleFulu"].(*pb.GetPayloadV5ResponseJson)
+		require.Equal(t, true, ok)
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			enc, err := io.ReadAll(r.Body)
+			require.NoError(t, err)
+			jsonRequestString := string(enc)
 
+			reqArg, err := json.Marshal(pb.PayloadIDBytes(payloadId))
+			require.NoError(t, err)
+
+			// We expect the JSON string RPC request contains the right arguments.
+			require.Equal(t, true, strings.Contains(
+				jsonRequestString, string(reqArg),
+			))
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  want,
+			}
+			err = json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		defer srv.Close()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+		defer rpcClient.Close()
+
+		client := &Service{}
+		client.rpcClient = rpcClient
+
+		// We call the RPC method via HTTP and expect a proper result.
+		resp, err := client.GetPayload(ctx, payloadId, 4*params.BeaconConfig().SlotsPerEpoch)
+		require.NoError(t, err)
+		_, ok = resp.BlobsBundler.(*pb.BlobsBundleV2)
+		if !ok {
+			t.Logf("resp.BlobsBundler has unexpected type: %T", resp.BlobsBundler)
+		}
+		require.Equal(t, ok, true)
+	})
 	t.Run(ForkchoiceUpdatedMethod+" VALID status", func(t *testing.T) {
 		forkChoiceState := &pb.ForkchoiceState{
 			HeadBlockHash:      []byte("head"),
@@ -1539,6 +1586,7 @@ func fixtures() map[string]interface{} {
 		"ExecutionPayloadCapellaWithValue":  s.ExecutionPayloadWithValueCapella,
 		"ExecutionPayloadDenebWithValue":    s.ExecutionPayloadWithValueDeneb,
 		"ExecutionBundleElectra":            s.ExecutionBundleElectra,
+		"ExecutionBundleFulu":               s.ExecutionBundleFulu,
 		"ValidPayloadStatus":                s.ValidPayloadStatus,
 		"InvalidBlockHashStatus":            s.InvalidBlockHashStatus,
 		"AcceptedStatus":                    s.AcceptedStatus,
@@ -1774,6 +1822,36 @@ func fixturesStruct() *payloadFixtures {
 			append([]byte{pb.WithdrawalRequestType}, withdrawalRequestBytes...),
 			append([]byte{pb.ConsolidationRequestType}, consolidationRequestBytes...)},
 	}
+	executionBundleFixtureFulu := &pb.GetPayloadV5ResponseJson{
+		ShouldOverrideBuilder: true,
+		ExecutionPayload: &pb.ExecutionPayloadDenebJSON{
+			ParentHash:    &common.Hash{'a'},
+			FeeRecipient:  &common.Address{'b'},
+			StateRoot:     &common.Hash{'c'},
+			ReceiptsRoot:  &common.Hash{'d'},
+			LogsBloom:     &hexutil.Bytes{'e'},
+			PrevRandao:    &common.Hash{'f'},
+			BaseFeePerGas: "0x123",
+			BlockHash:     &common.Hash{'g'},
+			Transactions:  []hexutil.Bytes{{'h'}},
+			Withdrawals:   []*pb.Withdrawal{},
+			BlockNumber:   &hexUint,
+			GasLimit:      &hexUint,
+			GasUsed:       &hexUint,
+			Timestamp:     &hexUint,
+			BlobGasUsed:   &bgu,
+			ExcessBlobGas: &ebg,
+		},
+		BlockValue: "0x11fffffffff",
+		BlobsBundle: &pb.BlobBundleV2JSON{
+			Commitments: []hexutil.Bytes{[]byte("commitment1"), []byte("commitment2")},
+			Proofs:      []hexutil.Bytes{[]byte("proof1"), []byte("proof2")},
+			Blobs:       []hexutil.Bytes{{'a'}, {'b'}},
+		},
+		ExecutionRequests: []hexutil.Bytes{append([]byte{pb.DepositRequestType}, depositRequestBytes...),
+			append([]byte{pb.WithdrawalRequestType}, withdrawalRequestBytes...),
+			append([]byte{pb.ConsolidationRequestType}, consolidationRequestBytes...)},
+	}
 	parent := bytesutil.PadTo([]byte("parentHash"), fieldparams.RootLength)
 	sha3Uncles := bytesutil.PadTo([]byte("sha3Uncles"), fieldparams.RootLength)
 	miner := bytesutil.PadTo([]byte("miner"), fieldparams.FeeRecipientLength)
@@ -1868,6 +1946,7 @@ func fixturesStruct() *payloadFixtures {
 		ExecutionPayloadWithValueCapella:  executionPayloadWithValueFixtureCapella,
 		ExecutionPayloadWithValueDeneb:    executionPayloadWithValueFixtureDeneb,
 		ExecutionBundleElectra:            executionBundleFixtureElectra,
+		ExecutionBundleFulu:               executionBundleFixtureFulu,
 		ValidPayloadStatus:                validStatus,
 		InvalidBlockHashStatus:            inValidBlockHashStatus,
 		AcceptedStatus:                    acceptedStatus,
@@ -1892,6 +1971,7 @@ type payloadFixtures struct {
 	ExecutionPayloadWithValueCapella  *pb.GetPayloadV2ResponseJson
 	ExecutionPayloadWithValueDeneb    *pb.GetPayloadV3ResponseJson
 	ExecutionBundleElectra            *pb.GetPayloadV4ResponseJson
+	ExecutionBundleFulu               *pb.GetPayloadV5ResponseJson
 	ValidPayloadStatus                *pb.PayloadStatus
 	InvalidBlockHashStatus            *pb.PayloadStatus
 	AcceptedStatus                    *pb.PayloadStatus
@@ -2361,7 +2441,7 @@ func Test_ExchangeCapabilities(t *testing.T) {
 		for _, item := range results {
 			require.NotNil(t, item)
 		}
-		assert.LogsContain(t, logHook, "Please update client, detected the following unsupported engine methods:")
+		assert.LogsContain(t, logHook, "Connected execution client does not support some requested engine methods")
 	})
 	t.Run("list of items", func(t *testing.T) {
 		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -2424,7 +2504,7 @@ func TestReconstructBlobSidecars(t *testing.T) {
 	t.Run("get-blobs end point is not supported", func(t *testing.T) {
 		hi := mockSummary(t, []bool{true, true, true, true, true, false})
 		verifiedBlobs, err := client.ReconstructBlobSidecars(ctx, sb, r, hi)
-		require.NoError(t, err)
+		require.ErrorContains(t, "engine_getBlobsV1 is not supported", err)
 		require.Equal(t, 0, len(verifiedBlobs))
 	})
 
@@ -2476,6 +2556,76 @@ func TestReconstructBlobSidecars(t *testing.T) {
 	})
 }
 
+func TestReconstructDataColumnSidecars(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	// Setup right fork epoch
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.CapellaForkEpoch = 1
+	cfg.DenebForkEpoch = 2
+	cfg.ElectraForkEpoch = 3
+	cfg.FuluForkEpoch = 4
+	params.OverrideBeaconConfig(cfg)
+
+	client := &Service{capabilityCache: &capabilityCache{}}
+	b := util.NewBeaconBlockFulu()
+	b.Block.Slot = 4 * params.BeaconConfig().SlotsPerEpoch
+	kzgCommitments := createRandomKzgCommitments(t, 6)
+	b.Block.Body.BlobKzgCommitments = kzgCommitments
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	sb, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+
+	t.Run("GetBlobsV2 is not supported", func(t *testing.T) {
+		_, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
+		require.ErrorContains(t, "get blobs V2 for block", err)
+	})
+
+	t.Run("nothing received", func(t *testing.T) {
+		srv := createBlobServerV2(t, 0, []bool{})
+		defer srv.Close()
+
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(dataColumns))
+	})
+
+	t.Run("receiving all blobs", func(t *testing.T) {
+		blobMasks := []bool{true, true, true, true, true, true}
+		srv := createBlobServerV2(t, 6, blobMasks)
+		defer srv.Close()
+
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
+		require.NoError(t, err)
+		require.Equal(t, 128, len(dataColumns))
+	})
+
+	t.Run("missing some blobs", func(t *testing.T) {
+		blobMasks := []bool{false, true, true, true, true, true}
+		srv := createBlobServerV2(t, 6, blobMasks)
+		defer srv.Close()
+
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
+		require.ErrorContains(t, errMissingBlobsAndProofsFromEL.Error(), err)
+		require.Equal(t, 0, len(dataColumns))
+	})
+}
+
 func createRandomKzgCommitments(t *testing.T, num int) [][]byte {
 	kzgCommitments := make([][]byte, num)
 	for i := range kzgCommitments {
@@ -2511,6 +2661,42 @@ func createBlobServer(t *testing.T, numBlobs int, callbackFuncs ...func()) *http
 	}))
 }
 
+func createBlobServerV2(t *testing.T, numBlobs int, blobMasks []bool) *httptest.Server {
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		defer func() {
+			require.NoError(t, r.Body.Close())
+		}()
+
+		require.Equal(t, len(blobMasks), numBlobs)
+
+		blobAndCellProofs := make([]*pb.BlobAndProofV2Json, numBlobs)
+		for i := range blobAndCellProofs {
+			if !blobMasks[i] {
+				continue
+			}
+
+			blobAndCellProofs[i] = &pb.BlobAndProofV2Json{
+				Blob:      []byte("0xblob"),
+				KzgProofs: []hexutil.Bytes{},
+			}
+			for j := 0; j < int(params.BeaconConfig().NumberOfColumns); j++ {
+				cellProof := make([]byte, 48)
+				blobAndCellProofs[i].KzgProofs = append(blobAndCellProofs[i].KzgProofs, cellProof)
+			}
+		}
+
+		respJSON := map[string]interface{}{
+			"jsonrpc": "2.0",
+			"id":      1,
+			"result":  blobAndCellProofs,
+		}
+
+		err := json.NewEncoder(w).Encode(respJSON)
+		require.NoError(t, err)
+	}))
+}
+
 func setupRpcClient(t *testing.T, url string, client *Service) (*rpc.Client, *Service) {
 	rpcClient, err := rpc.DialHTTP(url)
 	require.NoError(t, err)
@@ -2522,6 +2708,12 @@ func setupRpcClient(t *testing.T, url string, client *Service) (*rpc.Client, *Se
 	return rpcClient, client
 }
 
+func setupRpcClientV2(t *testing.T, url string, client *Service) (*rpc.Client, *Service) {
+	rpcClient, client := setupRpcClient(t, url, client)
+	client.capabilityCache = &capabilityCache{capabilities: map[string]interface{}{GetBlobsV2: nil}}
+	return rpcClient, client
+}
+
 func testNewBlobVerifier() verification.NewBlobVerifier {
 	return func(b blocks.ROBlob, reqs []verification.Requirement) verification.BlobVerifier {
 		return &verification.MockBlobVerifier{

beacon-chain/execution/log_processing.go

@@ -248,14 +248,14 @@ func (s *Service) ProcessChainStart(genesisTime uint64, eth1BlockHash [32]byte,
 	for i := range s.chainStartData.ChainstartDeposits {
 		proof, err := s.depositTrie.MerkleProof(i)
 		if err != nil {
-			log.WithError(err).Error("unable to generate deposit proof")
+			log.WithError(err).Error("Unable to generate deposit proof")
 		}
 		s.chainStartData.ChainstartDeposits[i].Proof = proof
 	}
 
 	root, err := s.depositTrie.HashTreeRoot()
 	if err != nil { // This should never happen.
-		log.WithError(err).Error("unable to determine root of deposit trie, aborting chain start")
+		log.WithError(err).Error("Unable to determine root of deposit trie, aborting chain start")
 		return
 	}
 	s.chainStartData.Eth1Data = &ethpb.Eth1Data{

beacon-chain/execution/service.go

@@ -557,8 +557,8 @@ func (s *Service) initPOWService() {
 				}
 			}
 			// Handle edge case with embedded genesis state by fetching genesis header to determine
-			// its height.
-			if s.chainStartData.Chainstarted && s.chainStartData.GenesisBlock == 0 {
+			// its height only if the deposit requests have not started yet (Pre Pectra EIP-6110 behavior).
+			if s.chainStartData.Chainstarted && s.chainStartData.GenesisBlock == 0 && !s.depositRequestsStarted {
 				genHash := common.BytesToHash(s.chainStartData.Eth1Data.BlockHash)
 				genBlock := s.chainStartData.GenesisBlock
 				// In the event our provided chainstart data references a non-existent block hash,

beacon-chain/execution/testing/BUILD.bazel

@@ -17,6 +17,7 @@ go_library(
         "//beacon-chain/execution/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",

beacon-chain/execution/testing/mock_engine_client.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"math/big"
 
+	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"
@@ -38,6 +39,8 @@ type EngineClient struct {
 	ErrGetPayload               error
 	BlobSidecars                []blocks.VerifiedROBlob
 	ErrorBlobSidecars           error
+	DataColumnSidecars          []blocks.VerifiedRODataColumn
+	ErrorDataColumnSidecars     error
 }
 
 // NewPayload --
@@ -109,10 +112,14 @@ func (e *EngineClient) ReconstructFullBellatrixBlockBatch(
 }
 
 // ReconstructBlobSidecars is a mock implementation of the ReconstructBlobSidecars method.
-func (e *EngineClient) ReconstructBlobSidecars(context.Context, interfaces.ReadOnlySignedBeaconBlock, [32]byte, func(uint64) bool) ([]blocks.VerifiedROBlob, error) {
+func (e *EngineClient) ReconstructBlobSidecars(context.Context, interfaces.ReadOnlySignedBeaconBlock, [fieldparams.RootLength]byte, func(uint64) bool) ([]blocks.VerifiedROBlob, error) {
 	return e.BlobSidecars, e.ErrorBlobSidecars
 }
 
+func (e *EngineClient) ReconstructDataColumnSidecars(context.Context, interfaces.ReadOnlySignedBeaconBlock, [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error) {
+	return e.DataColumnSidecars, e.ErrorDataColumnSidecars
+}
+
 // GetTerminalBlockHash --
 func (e *EngineClient) GetTerminalBlockHash(ctx context.Context, transitionTime uint64) ([]byte, bool, error) {
 	ttd := new(big.Int)

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

@@ -127,7 +127,7 @@ func (f *ForkChoice) InsertNode(ctx context.Context, state state.BeaconState, ro
 	if err := f.updateCheckpoints(ctx, jc, fc); err != nil {
 		_, remErr := f.store.removeNode(ctx, node)
 		if remErr != nil {
-			log.WithError(remErr).Error("could not remove node")
+			log.WithError(remErr).Error("Could not remove node")
 		}
 		return errors.Wrap(err, "could not update checkpoints")
 	}

beacon-chain/node/node.go

@@ -167,7 +167,6 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		syncChecker:             &initialsync.SyncChecker{},
 		custodyInfo:             &peerdas.CustodyInfo{},
 		slasherEnabled:          cliCtx.Bool(flags.SlasherFlag.Name),
-		lcStore:                 &lightclient.Store{},
 	}
 
 	for _, opt := range opts {
@@ -235,6 +234,10 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 	// their initialization.
 	beacon.finalizedStateAtStartUp = nil
 
+	if features.Get().EnableLightClient {
+		beacon.lcStore = lightclient.NewLightClientStore(beacon.db)
+	}
+
 	return beacon, nil
 }
 
@@ -883,8 +886,10 @@ func (b *BeaconNode) registerSyncService(initialSyncComplete chan struct{}, bFil
 		regularsync.WithDataColumnStorage(b.DataColumnStorage),
 		regularsync.WithVerifierWaiter(b.verifyInitWaiter),
 		regularsync.WithAvailableBlocker(bFillStore),
+		regularsync.WithCustodyInfo(b.custodyInfo),
 		regularsync.WithSlasherEnabled(b.slasherEnabled),
 		regularsync.WithLightClientStore(b.lcStore),
+		regularsync.WithBatchVerifierLimit(b.cliCtx.Int(flags.BatchVerifierLimit.Name)),
 	)
 	return b.services.RegisterService(rs)
 }

beacon-chain/operations/attestations/kv/aggregated.go

@@ -78,16 +78,16 @@ func (c *AttCaches) aggregateParallel(atts map[attestation.Id][]ethpb.Att, leftO
 			for as := range ch {
 				aggregated, err := attaggregation.AggregateDisjointOneBitAtts(as)
 				if err != nil {
-					log.WithError(err).Error("could not aggregate unaggregated attestations")
+					log.WithError(err).Error("Could not aggregate unaggregated attestations")
 					continue
 				}
 				if aggregated == nil {
-					log.Error("nil aggregated attestation")
+					log.Error("Nil aggregated attestation")
 					continue
 				}
 				if aggregated.IsAggregated() {
 					if err := c.SaveAggregatedAttestations([]ethpb.Att{aggregated}); err != nil {
-						log.WithError(err).Error("could not save aggregated attestation")
+						log.WithError(err).Error("Could not save aggregated attestation")
 						continue
 					}
 				} else {

beacon-chain/p2p/gossip_scoring_params.go

@@ -214,13 +214,13 @@ func defaultAggregateTopicParams(activeValidators uint64) *pubsub.TopicScorePara
 	aggPerSlot := aggregatorsPerSlot(activeValidators)
 	firstMessageCap, err := decayLimit(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot*2/gossipSubD))
 	if err != nil {
-		log.WithError(err).Warn("skipping initializing topic scoring")
+		log.WithError(err).Warn("Skipping initializing topic scoring")
 		return nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	meshThreshold, err := decayThreshold(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot)/dampeningFactor)
 	if err != nil {
-		log.WithError(err).Warn("skipping initializing topic scoring")
+		log.WithError(err).Warn("Skipping initializing topic scoring")
 		return nil
 	}
 	meshWeight := -scoreByWeight(aggregateWeight, meshThreshold)
@@ -256,13 +256,13 @@ func defaultSyncContributionTopicParams() *pubsub.TopicScoreParams {
 	aggPerSlot := params.BeaconConfig().SyncCommitteeSubnetCount * params.BeaconConfig().TargetAggregatorsPerSyncSubcommittee
 	firstMessageCap, err := decayLimit(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot*2/gossipSubD))
 	if err != nil {
-		log.WithError(err).Warn("skipping initializing topic scoring")
+		log.WithError(err).Warn("Skipping initializing topic scoring")
 		return nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	meshThreshold, err := decayThreshold(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot)/dampeningFactor)
 	if err != nil {
-		log.WithError(err).Warn("skipping initializing topic scoring")
+		log.WithError(err).Warn("Skipping initializing topic scoring")
 		return nil
 	}
 	meshWeight := -scoreByWeight(syncContributionWeight, meshThreshold)
@@ -305,7 +305,7 @@ func defaultAggregateSubnetTopicParams(activeValidators uint64) *pubsub.TopicSco
 	// Determine the amount of validators expected in a subnet in a single slot.
 	numPerSlot := time.Duration(subnetWeight / uint64(params.BeaconConfig().SlotsPerEpoch))
 	if numPerSlot == 0 {
-		log.Warn("numPerSlot is 0, skipping initializing topic scoring")
+		log.Warn("Number per slot is 0, skipping initializing topic scoring")
 		return nil
 	}
 	comsPerSlot := committeeCountPerSlot(activeValidators)
@@ -318,20 +318,20 @@ func defaultAggregateSubnetTopicParams(activeValidators uint64) *pubsub.TopicSco
 	}
 	rate := numPerSlot * 2 / gossipSubD
 	if rate == 0 {
-		log.Warn("rate is 0, skipping initializing topic scoring")
+		log.Warn("Skipping initializing topic scoring because rate is 0")
 		return nil
 	}
 	// Determine expected first deliveries based on the message rate.
 	firstMessageCap, err := decayLimit(scoreDecay(firstDecay*oneEpochDuration()), float64(rate))
 	if err != nil {
-		log.WithError(err).Warn("skipping initializing topic scoring")
+		log.WithError(err).Warn("Skipping initializing topic scoring")
 		return nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	// Determine expected mesh deliveries based on message rate applied with a dampening factor.
 	meshThreshold, err := decayThreshold(scoreDecay(meshDecay*oneEpochDuration()), float64(numPerSlot)/dampeningFactor)
 	if err != nil {
-		log.WithError(err).Warn("skipping initializing topic scoring")
+		log.WithError(err).Warn("Skipping initializing topic scoring")
 		return nil
 	}
 	meshWeight := -scoreByWeight(topicWeight, meshThreshold)
@@ -381,7 +381,7 @@ func defaultSyncSubnetTopicParams(activeValidators uint64) *pubsub.TopicScorePar
 
 	rate := subnetWeight * 2 / gossipSubD
 	if rate == 0 {
-		log.Warn("rate is 0, skipping initializing topic scoring")
+		log.Warn("Skipping initializing topic scoring because rate is 0")
 		return nil
 	}
 	// Determine expected first deliveries based on the message rate.

beacon-chain/p2p/peers/status.go

@@ -705,31 +705,46 @@ func (p *Status) deprecatedPrune() {
 	p.tallyIPTracker()
 }
 
-// BestFinalized returns the highest finalized epoch equal to or higher than ours that is agreed
-// upon by the majority of peers. This method may not return the absolute highest finalized, but
-// the finalized epoch in which most peers can serve blocks (plurality voting).
-// Ideally, all peers would be reporting the same finalized epoch but some may be behind due to their
-// own latency, or because of their finalized epoch at the time we queried them.
-// Returns epoch number and list of peers that are at or beyond that epoch.
+// BestFinalized returns the highest finalized epoch equal to or higher than `ourFinalizedEpoch`
+// that is agreed upon by the majority of peers, and the peers agreeing on this finalized epoch.
+// This method may not return the absolute highest finalized epoch, but the finalized epoch in which
+// most peers can serve blocks (plurality voting). Ideally, all peers would be reporting the same
+// finalized epoch but some may be behind due to their own latency, or because of their finalized
+// epoch at the time we queried them.
 func (p *Status) BestFinalized(maxPeers int, ourFinalizedEpoch primitives.Epoch) (primitives.Epoch, []peer.ID) {
+	// Retrieve all connected peers.
 	connected := p.Connected()
+
+	// key: finalized epoch, value: number of peers that support this finalized epoch.
 	finalizedEpochVotes := make(map[primitives.Epoch]uint64)
+
+	// key: peer ID, value: finalized epoch of the peer.
 	pidEpoch := make(map[peer.ID]primitives.Epoch, len(connected))
+
+	// key: peer ID, value: head slot of the peer.
 	pidHead := make(map[peer.ID]primitives.Slot, len(connected))
+
 	potentialPIDs := make([]peer.ID, 0, len(connected))
 	for _, pid := range connected {
 		peerChainState, err := p.ChainState(pid)
-		if err == nil && peerChainState != nil && peerChainState.FinalizedEpoch >= ourFinalizedEpoch {
-			finalizedEpochVotes[peerChainState.FinalizedEpoch]++
-			pidEpoch[pid] = peerChainState.FinalizedEpoch
-			potentialPIDs = append(potentialPIDs, pid)
-			pidHead[pid] = peerChainState.HeadSlot
+
+		// Skip if the peer's finalized epoch is not defined, or if the peer's finalized epoch is
+		// lower than ours.
+		if err != nil || peerChainState == nil || peerChainState.FinalizedEpoch < ourFinalizedEpoch {
+			continue
 		}
+
+		finalizedEpochVotes[peerChainState.FinalizedEpoch]++
+
+		pidEpoch[pid] = peerChainState.FinalizedEpoch
+		pidHead[pid] = peerChainState.HeadSlot
+
+		potentialPIDs = append(potentialPIDs, pid)
 	}
 
 	// Select the target epoch, which is the epoch most peers agree upon.
-	var targetEpoch primitives.Epoch
-	var mostVotes uint64
+	// If there is a tie, select the highest epoch.
+	targetEpoch, mostVotes := primitives.Epoch(0), uint64(0)
 	for epoch, count := range finalizedEpochVotes {
 		if count > mostVotes || (count == mostVotes && epoch > targetEpoch) {
 			mostVotes = count
@@ -737,11 +752,12 @@ func (p *Status) BestFinalized(maxPeers int, ourFinalizedEpoch primitives.Epoch)
 		}
 	}
 
-	// Sort PIDs by finalized epoch, in decreasing order.
+	// Sort PIDs by finalized (epoch, head), in decreasing order.
 	sort.Slice(potentialPIDs, func(i, j int) bool {
 		if pidEpoch[potentialPIDs[i]] == pidEpoch[potentialPIDs[j]] {
 			return pidHead[potentialPIDs[i]] > pidHead[potentialPIDs[j]]
 		}
+
 		return pidEpoch[potentialPIDs[i]] > pidEpoch[potentialPIDs[j]]
 	})
 
@@ -765,25 +781,36 @@ func (p *Status) BestFinalized(maxPeers int, ourFinalizedEpoch primitives.Epoch)
 // and is shared by at least minPeers.
 func (p *Status) BestNonFinalized(minPeers int, ourHeadEpoch primitives.Epoch) (primitives.Epoch, []peer.ID) {
 	connected := p.Connected()
-	epochVotes := make(map[primitives.Epoch]uint64)
-	pidEpoch := make(map[peer.ID]primitives.Epoch, len(connected))
-	pidHead := make(map[peer.ID]primitives.Slot, len(connected))
-	potentialPIDs := make([]peer.ID, 0, len(connected))
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	ourHeadSlot := slotsPerEpoch.Mul(uint64(ourHeadEpoch))
 
-	ourHeadSlot := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(ourHeadEpoch))
+	// key: head epoch, value: number of peers that support this epoch.
+	epochVotes := make(map[primitives.Epoch]uint64)
+
+	// key: peer ID, value: head epoch of the peer.
+	pidEpoch := make(map[peer.ID]primitives.Epoch, len(connected))
+
+	// key: peer ID, value: head slot of the peer.
+	pidHead := make(map[peer.ID]primitives.Slot, len(connected))
+
+	potentialPIDs := make([]peer.ID, 0, len(connected))
 	for _, pid := range connected {
 		peerChainState, err := p.ChainState(pid)
-		if err == nil && peerChainState != nil && peerChainState.HeadSlot > ourHeadSlot {
-			epoch := slots.ToEpoch(peerChainState.HeadSlot)
-			epochVotes[epoch]++
-			pidEpoch[pid] = epoch
-			pidHead[pid] = peerChainState.HeadSlot
-			potentialPIDs = append(potentialPIDs, pid)
+		// Skip if the peer's head epoch is not defined, or if the peer's head slot is
+		// lower or equal than ours.
+		if err != nil || peerChainState == nil || peerChainState.HeadSlot <= ourHeadSlot {
+			continue
 		}
+
+		epoch := slots.ToEpoch(peerChainState.HeadSlot)
+		epochVotes[epoch]++
+		pidEpoch[pid] = epoch
+		pidHead[pid] = peerChainState.HeadSlot
+		potentialPIDs = append(potentialPIDs, pid)
 	}
 
 	// Select the target epoch, which has enough peers' votes (>= minPeers).
-	var targetEpoch primitives.Epoch
+	targetEpoch := primitives.Epoch(0)
 	for epoch, votes := range epochVotes {
 		if votes >= uint64(minPeers) && targetEpoch < epoch {
 			targetEpoch = epoch
@@ -1019,7 +1046,10 @@ func (p *Status) isfromBadIP(pid peer.ID) error {
 
 	if val, ok := p.ipTracker[ip.String()]; ok {
 		if val > CollocationLimit {
-			return errors.Errorf("collocation limit exceeded: got %d - limit %d", val, CollocationLimit)
+			return errors.Errorf(
+				"colocation limit exceeded: got %d - limit %d for peer %v with IP %v",
+				val, CollocationLimit, pid, ip.String(),
+			)
 		}
 	}
 

beacon-chain/p2p/service.go

@@ -222,7 +222,7 @@ func (s *Service) Start() {
 	if len(s.cfg.StaticPeers) > 0 {
 		addrs, err := PeersFromStringAddrs(s.cfg.StaticPeers)
 		if err != nil {
-			log.WithError(err).Error("could not convert ENR to multiaddr")
+			log.WithError(err).Error("Could not convert ENR to multiaddr")
 		}
 		// Set trusted peers for those that are provided as static addresses.
 		pids := peerIdsFromMultiAddrs(addrs)
@@ -429,7 +429,7 @@ func (s *Service) awaitStateInitialized() {
 	}
 	clock, err := s.cfg.ClockWaiter.WaitForClock(s.ctx)
 	if err != nil {
-		log.WithError(err).Fatal("failed to receive initial genesis data")
+		log.WithError(err).Fatal("Failed to receive initial genesis data")
 	}
 	s.genesisTime = clock.GenesisTime()
 	gvr := clock.GenesisValidatorsRoot()

beacon-chain/p2p/testing/mock_peersprovider.go

@@ -88,7 +88,7 @@ func createENR() *enr.Record {
 	}
 	db, err := enode.OpenDB("")
 	if err != nil {
-		log.Error("could not open node's peer database")
+		log.Error("Could not open node's peer database")
 	}
 	lNode := enode.NewLocalNode(db, key)
 	return lNode.Node().Record()

beacon-chain/rpc/endpoints.go

@@ -895,7 +895,7 @@ func (s *Service) beaconEndpoints(
 			template: "/eth/v1/beacon/states/{state_id}/pending_deposits",
 			name:     namespace + ".GetPendingDeposits",
 			middleware: []middleware.Middleware{
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetPendingDeposits,
 			methods: []string{http.MethodGet},
@@ -904,7 +904,7 @@ func (s *Service) beaconEndpoints(
 			template: "/eth/v1/beacon/states/{state_id}/pending_consolidations",
 			name:     namespace + ".GetPendingConsolidations",
 			middleware: []middleware.Middleware{
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetPendingConsolidations,
 			methods: []string{http.MethodGet},
@@ -913,7 +913,7 @@ func (s *Service) beaconEndpoints(
 			template: "/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals",
 			name:     namespace + ".GetPendingPartialWithdrawals",
 			middleware: []middleware.Middleware{
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
 			},
 			handler: server.GetPendingPartialWithdrawals,
 			methods: []string{http.MethodGet},

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

@@ -46,11 +46,11 @@ go_library(
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
+        "//container/multi-value-slice:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing/trace:go_default_library",

beacon-chain/rpc/eth/beacon/handlers_pool.go

@@ -22,8 +22,8 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	consensus_types "github.com/OffchainLabs/prysm/v6/consensus-types"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	mvslice "github.com/OffchainLabs/prysm/v6/container/multi-value-slice"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	"github.com/OffchainLabs/prysm/v6/network/httputil"
@@ -501,7 +501,7 @@ func (s *Server) SubmitVoluntaryExit(w http.ResponseWriter, r *http.Request) {
 	}
 	val, err := headState.ValidatorAtIndexReadOnly(exit.Exit.ValidatorIndex)
 	if err != nil {
-		if errors.Is(err, consensus_types.ErrOutOfBounds) {
+		if errors.Is(err, mvslice.ErrOutOfBounds) {
 			httputil.HandleError(w, "Could not get validator: "+err.Error(), http.StatusBadRequest)
 			return
 		}

beacon-chain/rpc/eth/events/events_test.go

@@ -529,6 +529,7 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 				st := tc.getState()
 				v := &eth.Validator{ExitEpoch: math.MaxUint64, EffectiveBalance: params.BeaconConfig().MinActivationBalance, WithdrawalCredentials: make([]byte, 32)}
 				require.NoError(t, st.SetValidators([]*eth.Validator{v}))
+				require.NoError(t, st.SetBalances([]uint64{0}))
 				currentSlot := primitives.Slot(0)
 				// to avoid slot processing
 				require.NoError(t, st.SetSlot(currentSlot+1))

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

@@ -25,6 +25,7 @@ go_library(
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
     ],
 )
@@ -42,9 +43,9 @@ go_test(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",

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

@@ -6,6 +6,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared"
 	"github.com/OffchainLabs/prysm/v6/config/params"
@@ -16,6 +17,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
 
@@ -33,13 +35,13 @@ func (s *Server) GetLightClientBootstrap(w http.ResponseWriter, req *http.Reques
 	}
 
 	blockRoot := bytesutil.ToBytes32(blockRootParam)
-	bootstrap, err := s.BeaconDB.LightClientBootstrap(ctx, blockRoot[:])
+	bootstrap, err := s.LCStore.LightClientBootstrap(ctx, blockRoot)
 	if err != nil {
-		httputil.HandleError(w, "Could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-	if bootstrap == nil {
-		httputil.HandleError(w, "Light client bootstrap not found", http.StatusNotFound)
+		if errors.Is(err, lightclient.ErrLightClientBootstrapNotFound) {
+			httputil.HandleError(w, "Light client bootstrap not found", http.StatusNotFound)
+		} else {
+			httputil.HandleError(w, "Could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
+		}
 		return
 	}
 

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

@@ -33,10 +33,10 @@ go_library(
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
+        "//container/multi-value-slice:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing/trace:go_default_library",

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

@@ -26,9 +26,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	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/primitives"
 	validator2 "github.com/OffchainLabs/prysm/v6/consensus-types/validator"
+	mvslice "github.com/OffchainLabs/prysm/v6/container/multi-value-slice"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	"github.com/OffchainLabs/prysm/v6/network/httputil"
@@ -570,7 +570,7 @@ func (s *Server) SubmitBeaconCommitteeSubscription(w http.ResponseWriter, r *htt
 		subscriptions[i] = consensusItem
 		val, err := st.ValidatorAtIndexReadOnly(consensusItem.ValidatorIndex)
 		if err != nil {
-			if errors.Is(err, consensus_types.ErrOutOfBounds) {
+			if errors.Is(err, mvslice.ErrOutOfBounds) {
 				httputil.HandleError(w, "Could not get validator: "+err.Error(), http.StatusBadRequest)
 				return
 			}
@@ -819,7 +819,7 @@ func (s *Server) PrepareBeaconProposer(w http.ResponseWriter, r *http.Request) {
 		if feeRecipient == primitives.ExecutionAddress([20]byte{}) {
 			feeRecipient = primitives.ExecutionAddress(params.BeaconConfig().DefaultFeeRecipient)
 			if feeRecipient == primitives.ExecutionAddress([20]byte{}) {
-				log.WithField("validatorIndex", validatorIndex).Warn("fee recipient is the burn address")
+				log.WithField("validatorIndex", validatorIndex).Warn("Fee recipient is the burn address")
 			}
 		}
 		val := cache.TrackedValidator{

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

@@ -8,13 +8,18 @@ import (
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/pkg/errors"
 	"google.golang.org/protobuf/proto"
 )
 
 // constructGenericBeaconBlock constructs a `GenericBeaconBlock` based on the block version and other parameters.
-func (vs *Server) constructGenericBeaconBlock(sBlk interfaces.SignedBeaconBlock, blobsBundle *enginev1.BlobsBundle, winningBid primitives.Wei) (*ethpb.GenericBeaconBlock, error) {
+func (vs *Server) constructGenericBeaconBlock(
+	sBlk interfaces.SignedBeaconBlock,
+	blobsBundler enginev1.BlobsBundler,
+	winningBid primitives.Wei,
+) (*ethpb.GenericBeaconBlock, error) {
 	if sBlk == nil || sBlk.Block() == nil {
-		return nil, fmt.Errorf("block cannot be nil")
+		return nil, errors.New("block cannot be nil")
 	}
 
 	blockProto, err := sBlk.Block().Proto()
@@ -35,11 +40,23 @@ func (vs *Server) constructGenericBeaconBlock(sBlk interfaces.SignedBeaconBlock,
 	case version.Capella:
 		return vs.constructCapellaBlock(blockProto, isBlinded, bidStr), nil
 	case version.Deneb:
-		return vs.constructDenebBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
+		bundle, ok := blobsBundler.(*enginev1.BlobsBundle)
+		if blobsBundler != nil && !ok {
+			return nil, fmt.Errorf("expected *BlobsBundler, got %T", blobsBundler)
+		}
+		return vs.constructDenebBlock(blockProto, isBlinded, bidStr, bundle), nil
 	case version.Electra:
-		return vs.constructElectraBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
+		bundle, ok := blobsBundler.(*enginev1.BlobsBundle)
+		if blobsBundler != nil && !ok {
+			return nil, fmt.Errorf("expected *BlobsBundler, got %T", blobsBundler)
+		}
+		return vs.constructElectraBlock(blockProto, isBlinded, bidStr, bundle), nil
 	case version.Fulu:
-		return vs.constructFuluBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
+		bundle, ok := blobsBundler.(*enginev1.BlobsBundleV2)
+		if blobsBundler != nil && !ok {
+			return nil, fmt.Errorf("expected *BlobsBundleV2, got %T", blobsBundler)
+		}
+		return vs.constructFuluBlock(blockProto, isBlinded, bidStr, bundle), nil
 	default:
 		return nil, fmt.Errorf("unknown block version: %d", sBlk.Version())
 	}
@@ -92,7 +109,7 @@ func (vs *Server) constructElectraBlock(blockProto proto.Message, isBlinded bool
 	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Electra{Electra: electraContents}, IsBlinded: false, PayloadValue: payloadValue}
 }
 
-func (vs *Server) constructFuluBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundle) *ethpb.GenericBeaconBlock {
+func (vs *Server) constructFuluBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundleV2) *ethpb.GenericBeaconBlock {
 	if isBlinded {
 		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedFulu{BlindedFulu: blockProto.(*ethpb.BlindedBeaconBlockFulu)}, IsBlinded: true, PayloadValue: payloadValue}
 	}

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

@@ -261,6 +261,10 @@ func (vs *Server) buildValidatorDuty(
 }
 
 func populateCommitteeFields(duty *ethpb.DutiesV2Response_Duty, la *helpers.LiteAssignment) {
+	if duty == nil || la == nil {
+		// should never be the case as previous functions should set
+		return
+	}
 	duty.CommitteeLength = la.CommitteeLength
 	duty.CommitteeIndex = la.CommitteeIndex
 	duty.ValidatorCommitteeIndex = la.ValidatorCommitteeIndex

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

@@ -136,7 +136,7 @@ func logFailedReorgAttempt(slot primitives.Slot, oldHeadRoot, headRoot [32]byte)
 		"slot":        slot,
 		"oldHeadRoot": fmt.Sprintf("%#x", oldHeadRoot),
 		"headRoot":    fmt.Sprintf("%#x", headRoot),
-	}).Warn("late block attempted reorg failed")
+	}).Warn("Late block attempted reorg failed")
 }
 
 func (vs *Server) getHeadNoReorg(ctx context.Context, slot primitives.Slot, parentRoot [32]byte) (state.BeaconState, error) {
@@ -232,7 +232,7 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 	}()
 
 	winningBid := primitives.ZeroWei()
-	var bundle *enginev1.BlobsBundle
+	var bundle enginev1.BlobsBundler
 	if sBlk.Version() >= version.Bellatrix {
 		local, err := vs.getLocalPayload(ctx, sBlk.Block(), head)
 		if err != nil {
@@ -430,7 +430,7 @@ func (vs *Server) PrepareBeaconProposer(
 		if feeRecipient == primitives.ExecutionAddress([20]byte{}) {
 			feeRecipient = primitives.ExecutionAddress(params.BeaconConfig().DefaultFeeRecipient)
 			if feeRecipient == primitives.ExecutionAddress([20]byte{}) {
-				log.WithField("validatorIndex", r.ValidatorIndex).Warn("fee recipient is the burn address")
+				log.WithField("validatorIndex", r.ValidatorIndex).Warn("Fee recipient is the burn address")
 			}
 		}
 		val := cache.TrackedValidator{

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

@@ -54,7 +54,7 @@ const blockBuilderTimeout = 1 * time.Second
 const gasLimitAdjustmentFactor = 1024
 
 // Sets the execution data for the block. Execution data can come from local EL client or remote builder depends on validator registration and circuit breaker conditions.
-func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, local *blocks.GetPayloadResponse, bid builder.Bid, builderBoostFactor primitives.Gwei) (primitives.Wei, *enginev1.BlobsBundle, error) {
+func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, local *blocks.GetPayloadResponse, bid builder.Bid, builderBoostFactor primitives.Gwei) (primitives.Wei, enginev1.BlobsBundler, error) {
 	_, span := trace.StartSpan(ctx, "ProposerServer.setExecutionData")
 	defer span.End()
 
@@ -69,13 +69,13 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 
 	// Use local payload if builder payload is nil.
 	if bid == nil {
-		return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+		return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 	}
 
 	builderPayload, err := bid.Header()
 	if err != nil {
 		log.WithError(err).Warn("Proposer: failed to retrieve header from BuilderBid")
-		return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+		return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 	}
 
 	switch {
@@ -84,7 +84,7 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 		if err != nil {
 			tracing.AnnotateError(span, err)
 			log.WithError(err).Warn("Proposer: failed to match withdrawals root")
-			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+			return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 		}
 
 		// Compare payload values between local and builder. Default to the local value if it is higher.
@@ -97,7 +97,7 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 				"minBuilderBid":    minBid,
 				"builderGweiValue": builderValueGwei,
 			}).Warn("Proposer: using local execution payload because min bid not attained")
-			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+			return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 		}
 
 		// Use local block if min difference is not attained
@@ -108,7 +108,7 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 				"minBidDiff":       minDiff,
 				"builderGweiValue": builderValueGwei,
 			}).Warn("Proposer: using local execution payload because min difference with local value was not attained")
-			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+			return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 		}
 
 		// Use builder payload if the following in true:
@@ -132,8 +132,8 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 			if bid.Version() >= version.Deneb {
 				bidDeneb, ok := bid.(builder.BidDeneb)
 				if !ok {
-					log.Warnf("bid type %T does not implement builder.BidDeneb", bid)
-					return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+					log.Warnf("Bid type %T does not implement builder.BidDeneb", bid)
+					return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 				} else {
 					builderKzgCommitments = bidDeneb.BlobKzgCommitments()
 				}
@@ -143,15 +143,15 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 			if bid.Version() >= version.Electra {
 				bidElectra, ok := bid.(builder.BidElectra)
 				if !ok {
-					log.Warnf("bid type %T does not implement builder.BidElectra", bid)
-					return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+					log.Warnf("Bid type %T does not implement builder.BidElectra", bid)
+					return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 				} else {
 					executionRequests = bidElectra.ExecutionRequests()
 				}
 			}
 			if err := setBuilderExecution(blk, builderPayload, builderKzgCommitments, executionRequests); err != nil {
 				log.WithError(err).Warn("Proposer: failed to set builder payload")
-				return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+				return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 			} else {
 				return bid.Value(), nil, nil
 			}
@@ -171,11 +171,11 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 			trace.Int64Attribute("builderGweiValue", int64(builderValueGwei)),     // lint:ignore uintcast -- This is OK for tracing.
 			trace.Int64Attribute("builderBoostFactor", int64(builderBoostFactor)), // lint:ignore uintcast -- This is OK for tracing.
 		)
-		return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+		return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 	default: // Bellatrix case.
 		if err := setBuilderExecution(blk, builderPayload, nil, nil); err != nil {
 			log.WithError(err).Warn("Proposer: failed to set builder payload")
-			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
+			return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
 		} else {
 			return bid.Value(), nil, nil
 		}
@@ -375,8 +375,8 @@ func matchingWithdrawalsRoot(local, builder interfaces.ExecutionData) (bool, err
 // It delegates to setExecution for the actual work.
 func setLocalExecution(blk interfaces.SignedBeaconBlock, local *blocks.GetPayloadResponse) error {
 	var kzgCommitments [][]byte
-	if local.BlobsBundle != nil {
-		kzgCommitments = local.BlobsBundle.KzgCommitments
+	if local.BlobsBundler != nil {
+		kzgCommitments = local.BlobsBundler.GetKzgCommitments()
 	}
 	if local.ExecutionRequests != nil {
 		if err := blk.SetExecutionRequests(local.ExecutionRequests); err != nil {

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

@@ -519,7 +519,7 @@ func TestServer_setExecutionData(t *testing.T) {
 			PayloadIDBytes: id,
 			GetPayloadResponse: &blocks.GetPayloadResponse{
 				ExecutionData: ed,
-				BlobsBundle:   blobsBundle,
+				BlobsBundler:  blobsBundle,
 				Bid:           primitives.ZeroWei(),
 			},
 		}
@@ -527,7 +527,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		res, err := vs.getLocalPayload(ctx, blk.Block(), capellaTransitionState)
 		require.NoError(t, err)
 		require.Equal(t, uint64(4), res.ExecutionData.BlockNumber())
-		require.DeepEqual(t, res.BlobsBundle, blobsBundle)
+		require.DeepEqual(t, res.BlobsBundler, blobsBundle)
 	})
 	t.Run("Can get builder payload and blobs in Deneb", func(t *testing.T) {
 		cfg := params.BeaconConfig().Copy()

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

@@ -28,8 +28,14 @@ func BuildBlobSidecars(blk interfaces.SignedBeaconBlock, blobs [][]byte, kzgProo
 		return nil, err
 	}
 	body := blk.Block().Body()
+	// Pre-compute subtrees once before the loop to avoid redundant calculations
+	proofComponents, err := blocks.PrecomputeMerkleProofComponents(body)
+	if err != nil {
+		return nil, err
+	}
+
 	for i := range blobSidecars {
-		proof, err := blocks.MerkleProofKZGCommitment(body, i)
+		proof, err := blocks.MerkleProofKZGCommitmentFromComponents(proofComponents, i)
 		if err != nil {
 			return nil, err
 		}

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

@@ -0,0 +1,224 @@
+package validator
+
+import (
+	"errors"
+	"testing"
+
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+// BuildBlobSidecarsOriginal is the original implementation for comparison
+func BuildBlobSidecarsOriginal(blk interfaces.SignedBeaconBlock, blobs [][]byte, kzgProofs [][]byte) ([]*ethpb.BlobSidecar, error) {
+	if blk.Version() < version.Deneb {
+		return nil, nil // No blobs before deneb.
+	}
+	commits, err := blk.Block().Body().BlobKzgCommitments()
+	if err != nil {
+		return nil, err
+	}
+	cLen := len(commits)
+	if cLen != len(blobs) || cLen != len(kzgProofs) {
+		return nil, errors.New("blob KZG commitments don't match number of blobs or KZG proofs")
+	}
+	blobSidecars := make([]*ethpb.BlobSidecar, cLen)
+	header, err := blk.Header()
+	if err != nil {
+		return nil, err
+	}
+	body := blk.Block().Body()
+	for i := range blobSidecars {
+		proof, err := blocks.MerkleProofKZGCommitment(body, i)
+		if err != nil {
+			return nil, err
+		}
+		blobSidecars[i] = &ethpb.BlobSidecar{
+			Index:                    uint64(i),
+			Blob:                     blobs[i],
+			KzgCommitment:            commits[i],
+			KzgProof:                 kzgProofs[i],
+			SignedBlockHeader:        header,
+			CommitmentInclusionProof: proof,
+		}
+	}
+	return blobSidecars, nil
+}
+
+func setupBenchmarkData(b *testing.B, numBlobs int) (interfaces.SignedBeaconBlock, [][]byte, [][]byte) {
+	b.Helper()
+
+	// Create KZG commitments
+	kzgCommitments := make([][]byte, numBlobs)
+	for i := 0; i < numBlobs; i++ {
+		kzgCommitments[i] = bytesutil.PadTo([]byte{byte(i)}, 48)
+	}
+
+	// Create block with KZG commitments
+	blk, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockDeneb())
+	if err != nil {
+		b.Fatal(err)
+	}
+	if err := blk.SetBlobKzgCommitments(kzgCommitments); err != nil {
+		b.Fatal(err)
+	}
+
+	// Create blobs
+	blobs := make([][]byte, numBlobs)
+	for i := 0; i < numBlobs; i++ {
+		blobs[i] = make([]byte, fieldparams.BlobLength)
+		// Add some variation to the blob data
+		blobs[i][0] = byte(i)
+	}
+
+	// Create KZG proofs
+	proof, err := hexutil.Decode("0xb4021b0de10f743893d4f71e1bf830c019e832958efd6795baf2f83b8699a9eccc5dc99015d8d4d8ec370d0cc333c06a")
+	if err != nil {
+		b.Fatal(err)
+	}
+	kzgProofs := make([][]byte, numBlobs)
+	for i := 0; i < numBlobs; i++ {
+		kzgProofs[i] = proof
+	}
+
+	return blk, blobs, kzgProofs
+}
+
+func BenchmarkBuildBlobSidecars_Original_1Blob(b *testing.B) {
+	blk, blobs, kzgProofs := setupBenchmarkData(b, 1)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := BuildBlobSidecarsOriginal(blk, blobs, kzgProofs)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkBuildBlobSidecars_Optimized_1Blob(b *testing.B) {
+	blk, blobs, kzgProofs := setupBenchmarkData(b, 1)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := BuildBlobSidecars(blk, blobs, kzgProofs)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkBuildBlobSidecars_Original_2Blobs(b *testing.B) {
+	blk, blobs, kzgProofs := setupBenchmarkData(b, 2)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := BuildBlobSidecarsOriginal(blk, blobs, kzgProofs)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkBuildBlobSidecars_Optimized_3Blobs(b *testing.B) {
+	blk, blobs, kzgProofs := setupBenchmarkData(b, 3)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := BuildBlobSidecars(blk, blobs, kzgProofs)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkBuildBlobSidecars_Original_3Blobs(b *testing.B) {
+	blk, blobs, kzgProofs := setupBenchmarkData(b, 3)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := BuildBlobSidecarsOriginal(blk, blobs, kzgProofs)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkBuildBlobSidecars_Optimized_4Blobs(b *testing.B) {
+	blk, blobs, kzgProofs := setupBenchmarkData(b, 4)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := BuildBlobSidecars(blk, blobs, kzgProofs)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkBuildBlobSidecars_Original_9Blobs(b *testing.B) {
+	blk, blobs, kzgProofs := setupBenchmarkData(b, 9)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := BuildBlobSidecarsOriginal(blk, blobs, kzgProofs)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkBuildBlobSidecars_Optimized_9Blobs(b *testing.B) {
+	blk, blobs, kzgProofs := setupBenchmarkData(b, 9)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := BuildBlobSidecars(blk, blobs, kzgProofs)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+// Benchmark the individual components to understand where the improvements come from
+func BenchmarkMerkleProofKZGCommitment_Original(b *testing.B) {
+	blk, _, _ := setupBenchmarkData(b, 4)
+	body := blk.Block().Body()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for j := 0; j < 4; j++ {
+			_, err := blocks.MerkleProofKZGCommitment(body, j)
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	}
+}
+
+func BenchmarkMerkleProofKZGCommitment_Optimized(b *testing.B) {
+	blk, _, _ := setupBenchmarkData(b, 4)
+	body := blk.Block().Body()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		// Pre-compute components once
+		components, err := blocks.PrecomputeMerkleProofComponents(body)
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		// Generate proofs for each index
+		for j := 0; j < 4; j++ {
+			_, err := blocks.MerkleProofKZGCommitmentFromComponents(components, j)
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	}
+}

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

@@ -89,7 +89,7 @@ func (vs *Server) deposits(
 	}
 
 	if !vs.Eth1InfoFetcher.ExecutionClientConnected() {
-		log.Warn("not connected to eth1 node, skip pending deposit insertion")
+		log.Warn("Not connected to eth1 node, skip pending deposit insertion")
 		return []*ethpb.Deposit{}, nil
 	}
 
@@ -113,7 +113,7 @@ func (vs *Server) deposits(
 	// If there are no pending deposits, exit early.
 	allPendingContainers := vs.PendingDepositsFetcher.PendingContainers(ctx, canonicalEth1DataHeight)
 	if len(allPendingContainers) == 0 {
-		log.Debug("no pending deposits for inclusion in block")
+		log.Debug("No pending deposits for inclusion in block")
 		return []*ethpb.Deposit{}, nil
 	}
 

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

@@ -80,7 +80,7 @@ func (vs *Server) getLocalPayloadFromEngine(
 
 	val, tracked := vs.TrackedValidatorsCache.Validator(proposerId)
 	if !tracked {
-		logrus.WithFields(logFields).Warn("could not find tracked proposer index")
+		logrus.WithFields(logFields).Warn("Could not find tracked proposer index")
 	}
 	setFeeRecipientIfBurnAddress(&val)
 

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

@@ -529,7 +529,7 @@ func TestServer_GetBeaconBlock_Deneb(t *testing.T) {
 		PayloadIDBytes: &enginev1.PayloadIDBytes{1},
 		GetPayloadResponse: &blocks.GetPayloadResponse{
 			ExecutionData: ed,
-			BlobsBundle:   bundle,
+			BlobsBundler:  bundle,
 		},
 	}
 
@@ -3271,7 +3271,7 @@ func TestProposer_GetParentHeadState(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, [32]byte(str), [32]byte(headStr))
 		require.NotEqual(t, [32]byte(str), [32]byte(genesisStr))
-		require.LogsContain(t, hook, "late block attempted reorg failed")
+		require.LogsContain(t, hook, "Late block attempted reorg failed")
 	})
 }
 

beacon-chain/slasher/helpers.go

@@ -247,7 +247,7 @@ func GetChunkFromDatabase(
 
 func closeDB(d *slasherkv.Store) {
 	if err := d.Close(); err != nil {
-		log.WithError(err).Error("could not close database")
+		log.WithError(err).Error("Could not close database")
 	}
 }
 

beacon-chain/state/fieldtrie/BUILD.bazel

@@ -31,7 +31,6 @@ go_test(
         "//beacon-chain/state/state-native/custom-types:go_default_library",
         "//beacon-chain/state/state-native/types:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
-        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",

beacon-chain/state/fieldtrie/field_trie_test.go

@@ -7,7 +7,6 @@ import (
 	customtypes "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/custom-types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stateutil"
-	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	mvslice "github.com/OffchainLabs/prysm/v6/container/multi-value-slice"
@@ -21,32 +20,19 @@ func TestFieldTrie_NewTrie(t *testing.T) {
 	t.Run("native state", func(t *testing.T) {
 		runNewTrie(t)
 	})
-	t.Run("native state with multivalue slice", func(t *testing.T) {
-		cfg := &features.Flags{}
-		cfg.EnableExperimentalState = true
-		reset := features.InitWithReset(cfg)
-		runNewTrie(t)
-
-		reset()
-	})
 }
 
 func runNewTrie(t *testing.T) {
 	newState, _ := util.DeterministicGenesisState(t, 40)
 	roots := newState.BlockRoots()
-	var elements interface{}
 	blockRoots := make([][32]byte, len(roots))
 	for i, r := range roots {
 		blockRoots[i] = [32]byte(r)
 	}
-	elements = customtypes.BlockRoots(blockRoots)
-
-	if features.Get().EnableExperimentalState {
-		mvRoots := buildTestCompositeSlice[[32]byte](blockRoots)
-		elements = mvslice.MultiValueSliceComposite[[32]byte]{
-			Identifiable:    mockIdentifier{},
-			MultiValueSlice: mvRoots,
-		}
+	mvRoots := buildTestCompositeSlice[[32]byte](blockRoots)
+	elements := mvslice.MultiValueSliceComposite[[32]byte]{
+		Identifiable:    mockIdentifier{},
+		MultiValueSlice: mvRoots,
 	}
 
 	trie, err := NewFieldTrie(types.BlockRoots, types.BasicArray, elements, uint64(params.BeaconConfig().SlotsPerHistoricalRoot))
@@ -69,27 +55,15 @@ func TestFieldTrie_RecomputeTrie(t *testing.T) {
 	t.Run("native state", func(t *testing.T) {
 		runRecomputeTrie(t)
 	})
-	t.Run("native state with multivalue slice", func(t *testing.T) {
-		cfg := &features.Flags{}
-		cfg.EnableExperimentalState = true
-		reset := features.InitWithReset(cfg)
-		runRecomputeTrie(t)
-
-		reset()
-	})
 }
 
 func runRecomputeTrie(t *testing.T) {
 	newState, _ := util.DeterministicGenesisState(t, 32)
 
-	var elements interface{}
-	elements = newState.Validators()
-	if features.Get().EnableExperimentalState {
-		mvRoots := buildTestCompositeSlice[*ethpb.Validator](newState.Validators())
-		elements = mvslice.MultiValueSliceComposite[*ethpb.Validator]{
-			Identifiable:    mockIdentifier{},
-			MultiValueSlice: mvRoots,
-		}
+	mvRoots := buildTestCompositeSlice[*ethpb.Validator](newState.Validators())
+	elements := mvslice.MultiValueSliceComposite[*ethpb.Validator]{
+		Identifiable:    mockIdentifier{},
+		MultiValueSlice: mvRoots,
 	}
 
 	trie, err := NewFieldTrie(types.Validators, types.CompositeArray, elements, params.BeaconConfig().ValidatorRegistryLimit)
@@ -125,26 +99,14 @@ func TestFieldTrie_RecomputeTrie_CompressedArray(t *testing.T) {
 	t.Run("native state", func(t *testing.T) {
 		runRecomputeTrie_CompressedArray(t)
 	})
-	t.Run("native state with multivalue slice", func(t *testing.T) {
-		cfg := &features.Flags{}
-		cfg.EnableExperimentalState = true
-		reset := features.InitWithReset(cfg)
-		runRecomputeTrie_CompressedArray(t)
-
-		reset()
-	})
 }
 
 func runRecomputeTrie_CompressedArray(t *testing.T) {
 	newState, _ := util.DeterministicGenesisState(t, 32)
-	var elements interface{}
-	elements = newState.Balances()
-	if features.Get().EnableExperimentalState {
-		mvBals := buildTestCompositeSlice(newState.Balances())
-		elements = mvslice.MultiValueSliceComposite[uint64]{
-			Identifiable:    mockIdentifier{},
-			MultiValueSlice: mvBals,
-		}
+	mvBals := buildTestCompositeSlice(newState.Balances())
+	elements := mvslice.MultiValueSliceComposite[uint64]{
+		Identifiable:    mockIdentifier{},
+		MultiValueSlice: mvBals,
 	}
 
 	trie, err := NewFieldTrie(types.Balances, types.CompressedArray, elements, stateutil.ValidatorLimitForBalancesChunks())

beacon-chain/state/state-native/BUILD.bazel

@@ -59,10 +59,8 @@ go_library(
         "//beacon-chain/state/state-native/custom-types:go_default_library",
         "//beacon-chain/state/state-native/types:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
-        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
@@ -135,7 +133,6 @@ go_test(
         "//beacon-chain/state/state-native/types:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/testing:go_default_library",
-        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

beacon-chain/state/state-native/README.md

@@ -13,9 +13,7 @@ Add the new getter and setter to `/beacon-chain/state/interfaces.go`.
 - Update `spec_parameters.go`.
 - Update `state_trie.go`:
   - Add a `[version]Fields` variable that contains all fields of the new state version.
-  - Add a `[version]SharedFieldRefCount` constant that represents the number of fields whose references are shared between states.
-  - Add an `experimentalState[Version]SharedFieldCountRef` constant that represents the number of **non multi-value slice** fields whose references are shared
-between states.
+  - Add a `[version]SharedFieldRefCount` constant that represents the number of fields whose references are shared between states. Multi-value slice references are not shared in this way so don't include them.
   - Add the following functions: `InitializeFromProto[Version]()`, `InitializeFromProtoUnsafe[Version]()`.
   - Update the following functions: `Copy()`, `initializeMerkleLayers()`, `RecordStateMetrics()` (applies only to multi-value slice fields), `rootSelector()`,
 `finalizerCleanup()` (applies only to multi-value slice fields).

beacon-chain/state/state-native/beacon_state.go

@@ -8,7 +8,6 @@ import (
 	customtypes "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/custom-types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stateutil"
-	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -24,19 +23,14 @@ type BeaconState struct {
 	slot                                primitives.Slot
 	fork                                *ethpb.Fork
 	latestBlockHeader                   *ethpb.BeaconBlockHeader
-	blockRoots                          customtypes.BlockRoots
 	blockRootsMultiValue                *MultiValueBlockRoots
-	stateRoots                          customtypes.StateRoots
 	stateRootsMultiValue                *MultiValueStateRoots
 	historicalRoots                     customtypes.HistoricalRoots
 	eth1Data                            *ethpb.Eth1Data
 	eth1DataVotes                       []*ethpb.Eth1Data
 	eth1DepositIndex                    uint64
-	validators                          []*ethpb.Validator
 	validatorsMultiValue                *MultiValueValidators
-	balances                            []uint64
 	balancesMultiValue                  *MultiValueBalances
-	randaoMixes                         customtypes.RandaoMixes
 	randaoMixesMultiValue               *MultiValueRandaoMixes
 	slashings                           []uint64
 	previousEpochAttestations           []*ethpb.PendingAttestation
@@ -47,7 +41,6 @@ type BeaconState struct {
 	previousJustifiedCheckpoint         *ethpb.Checkpoint
 	currentJustifiedCheckpoint          *ethpb.Checkpoint
 	finalizedCheckpoint                 *ethpb.Checkpoint
-	inactivityScores                    []uint64
 	inactivityScoresMultiValue          *MultiValueInactivityScores
 	currentSyncCommittee                *ethpb.SyncCommittee
 	nextSyncCommittee                   *ethpb.SyncCommittee
@@ -130,28 +123,12 @@ type beaconStateMarshalable struct {
 }
 
 func (b *BeaconState) MarshalJSON() ([]byte, error) {
-	var bRoots customtypes.BlockRoots
-	var sRoots customtypes.StateRoots
-	var mixes customtypes.RandaoMixes
-	var balances []uint64
-	var inactivityScores []uint64
-	var vals []*ethpb.Validator
-
-	if features.Get().EnableExperimentalState {
-		bRoots = b.blockRootsMultiValue.Value(b)
-		sRoots = b.stateRootsMultiValue.Value(b)
-		mixes = b.randaoMixesMultiValue.Value(b)
-		balances = b.balancesMultiValue.Value(b)
-		inactivityScores = b.inactivityScoresMultiValue.Value(b)
-		vals = b.validatorsMultiValue.Value(b)
-	} else {
-		bRoots = b.blockRoots
-		sRoots = b.stateRoots
-		mixes = b.randaoMixes
-		balances = b.balances
-		inactivityScores = b.inactivityScores
-		vals = b.validators
-	}
+	bRoots := b.blockRootsMultiValue.Value(b)
+	sRoots := b.stateRootsMultiValue.Value(b)
+	mixes := b.randaoMixesMultiValue.Value(b)
+	balances := b.balancesMultiValue.Value(b)
+	inactivityScores := b.inactivityScoresMultiValue.Value(b)
+	vals := b.validatorsMultiValue.Value(b)
 
 	marshalable := &beaconStateMarshalable{
 		Version:                             b.version,

beacon-chain/state/state-native/getters_block.go

@@ -2,10 +2,7 @@ package state_native
 
 import (
 	customtypes "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/custom-types"
-	"github.com/OffchainLabs/prysm/v6/config/features"
-	consensus_types "github.com/OffchainLabs/prysm/v6/consensus-types"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/pkg/errors"
 )
 
 // LatestBlockHeader stored within the beacon state.
@@ -58,13 +55,10 @@ func (b *BeaconState) BlockRoots() [][]byte {
 }
 
 func (b *BeaconState) blockRootsVal() customtypes.BlockRoots {
-	if features.Get().EnableExperimentalState {
-		if b.blockRootsMultiValue == nil {
-			return nil
-		}
-		return b.blockRootsMultiValue.Value(b)
+	if b.blockRootsMultiValue == nil {
+		return nil
 	}
-	return b.blockRoots
+	return b.blockRootsMultiValue.Value(b)
 }
 
 // BlockRootAtIndex retrieves a specific block root based on an
@@ -73,33 +67,12 @@ func (b *BeaconState) BlockRootAtIndex(idx uint64) ([]byte, error) {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	if features.Get().EnableExperimentalState {
-		if b.blockRootsMultiValue == nil {
-			return []byte{}, nil
-		}
-		r, err := b.blockRootsMultiValue.At(b, idx)
-		if err != nil {
-			return nil, err
-		}
-		return r[:], nil
-	}
-
-	if b.blockRoots == nil {
+	if b.blockRootsMultiValue == nil {
 		return []byte{}, nil
 	}
-	r, err := b.blockRootAtIndex(idx)
+	r, err := b.blockRootsMultiValue.At(b, idx)
 	if err != nil {
 		return nil, err
 	}
 	return r[:], nil
 }
-
-// blockRootAtIndex retrieves a specific block root based on an
-// input index value.
-// This assumes that a lock is already held on BeaconState.
-func (b *BeaconState) blockRootAtIndex(idx uint64) ([32]byte, error) {
-	if uint64(len(b.blockRoots)) <= idx {
-		return [32]byte{}, errors.Wrapf(consensus_types.ErrOutOfBounds, "block root index %d does not exist", idx)
-	}
-	return b.blockRoots[idx], nil
-}

beacon-chain/state/state-native/getters_participation.go

@@ -4,7 +4,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	customtypes "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/custom-types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stateutil"
-	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 )
 
@@ -82,11 +81,7 @@ func (b *BeaconState) UnrealizedCheckpointBalances() (uint64, uint64, uint64, er
 		return 0, 0, 0, ErrNilParticipation
 	}
 
-	if features.Get().EnableExperimentalState {
-		return stateutil.UnrealizedCheckpointBalances(cp, pp, stateutil.NewValMultiValueSliceReader(b.validatorsMultiValue, b), currentEpoch)
-	} else {
-		return stateutil.UnrealizedCheckpointBalances(cp, pp, stateutil.NewValSliceReader(b.validators), currentEpoch)
-	}
+	return stateutil.UnrealizedCheckpointBalances(cp, pp, stateutil.NewValMultiValueSliceReader(b.validatorsMultiValue, b), currentEpoch)
 }
 
 // currentEpochParticipationVal corresponding to participation bits on the beacon chain.

beacon-chain/state/state-native/getters_randao.go

@@ -2,9 +2,6 @@ package state_native
 
 import (
 	customtypes "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/custom-types"
-	"github.com/OffchainLabs/prysm/v6/config/features"
-	consensus_types "github.com/OffchainLabs/prysm/v6/consensus-types"
-	"github.com/pkg/errors"
 )
 
 // RandaoMixes of block proposers on the beacon chain.
@@ -20,13 +17,10 @@ func (b *BeaconState) RandaoMixes() [][]byte {
 }
 
 func (b *BeaconState) randaoMixesVal() customtypes.RandaoMixes {
-	if features.Get().EnableExperimentalState {
-		if b.randaoMixesMultiValue == nil {
-			return nil
-		}
-		return b.randaoMixesMultiValue.Value(b)
+	if b.randaoMixesMultiValue == nil {
+		return nil
 	}
-	return b.randaoMixes
+	return b.randaoMixesMultiValue.Value(b)
 }
 
 // RandaoMixAtIndex retrieves a specific block root based on an
@@ -35,36 +29,14 @@ func (b *BeaconState) RandaoMixAtIndex(idx uint64) ([]byte, error) {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	if features.Get().EnableExperimentalState {
-		if b.randaoMixesMultiValue == nil {
-			return nil, nil
-		}
-		r, err := b.randaoMixesMultiValue.At(b, idx)
-		if err != nil {
-			return nil, err
-		}
-		return r[:], nil
-	}
-
-	if b.randaoMixes == nil {
+	if b.randaoMixesMultiValue == nil {
 		return nil, nil
 	}
-	m, err := b.randaoMixAtIndex(idx)
+	r, err := b.randaoMixesMultiValue.At(b, idx)
 	if err != nil {
 		return nil, err
 	}
-	return m[:], nil
-}
-
-// randaoMixAtIndex retrieves a specific block root based on an
-// input index value.
-// This assumes that a lock is already held on BeaconState.
-func (b *BeaconState) randaoMixAtIndex(idx uint64) ([32]byte, error) {
-	if uint64(len(b.randaoMixes)) <= idx {
-		return [32]byte{}, errors.Wrapf(consensus_types.ErrOutOfBounds, "randao mix index %d does not exist", idx)
-	}
-
-	return b.randaoMixes[idx], nil
+	return r[:], nil
 }
 
 // RandaoMixesLength returns the length of the randao mixes slice.
@@ -72,14 +44,8 @@ func (b *BeaconState) RandaoMixesLength() int {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	if features.Get().EnableExperimentalState {
-		if b.randaoMixesMultiValue == nil {
-			return 0
-		}
-		return b.randaoMixesMultiValue.Len(b)
-	}
-	if b.randaoMixes == nil {
+	if b.randaoMixesMultiValue == nil {
 		return 0
 	}
-	return len(b.randaoMixes)
+	return b.randaoMixesMultiValue.Len(b)
 }

beacon-chain/state/state-native/getters_state.go

@@ -2,8 +2,6 @@ package state_native
 
 import (
 	customtypes "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/custom-types"
-	"github.com/OffchainLabs/prysm/v6/config/features"
-	consensus_types "github.com/OffchainLabs/prysm/v6/consensus-types"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/pkg/errors"
@@ -24,20 +22,14 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 	var bals []uint64
 	var inactivityScores []uint64
 
-	if features.Get().EnableExperimentalState {
-		if b.balancesMultiValue != nil {
-			bals = b.balancesMultiValue.Value(b)
-		}
-		if b.inactivityScoresMultiValue != nil {
-			inactivityScores = b.inactivityScoresMultiValue.Value(b)
-		}
-		if b.validatorsMultiValue != nil {
-			vals = b.validatorsMultiValue.Value(b)
-		}
-	} else {
-		bals = b.balances
-		inactivityScores = b.inactivityScores
-		vals = b.validators
+	if b.balancesMultiValue != nil {
+		bals = b.balancesMultiValue.Value(b)
+	}
+	if b.inactivityScoresMultiValue != nil {
+		inactivityScores = b.inactivityScoresMultiValue.Value(b)
+	}
+	if b.validatorsMultiValue != nil {
+		vals = b.validatorsMultiValue.Value(b)
 	}
 
 	switch b.version {
@@ -536,13 +528,10 @@ func (b *BeaconState) StateRoots() [][]byte {
 }
 
 func (b *BeaconState) stateRootsVal() customtypes.StateRoots {
-	if features.Get().EnableExperimentalState {
-		if b.stateRootsMultiValue == nil {
-			return nil
-		}
-		return b.stateRootsMultiValue.Value(b)
+	if b.stateRootsMultiValue == nil {
+		return nil
 	}
-	return b.stateRoots
+	return b.stateRootsMultiValue.Value(b)
 }
 
 // StateRootAtIndex retrieves a specific state root based on an
@@ -551,39 +540,16 @@ func (b *BeaconState) StateRootAtIndex(idx uint64) ([]byte, error) {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	if features.Get().EnableExperimentalState {
-		if b.stateRootsMultiValue == nil {
-			return nil, nil
-		}
-		r, err := b.stateRootsMultiValue.At(b, idx)
-		if err != nil {
-			return nil, err
-		}
-		return r[:], nil
-	}
-
-	if b.stateRoots == nil {
+	if b.stateRootsMultiValue == nil {
 		return nil, nil
 	}
-	r, err := b.stateRootAtIndex(idx)
+	r, err := b.stateRootsMultiValue.At(b, idx)
 	if err != nil {
 		return nil, err
 	}
 	return r[:], nil
 }
 
-// stateRootAtIndex retrieves a specific state root based on an
-// input index value.
-// This assumes that a lock is already held on BeaconState.
-//
-// WARNING: This function does not work with the multi-value slice feature.
-func (b *BeaconState) stateRootAtIndex(idx uint64) ([32]byte, error) {
-	if uint64(len(b.stateRoots)) <= idx {
-		return [32]byte{}, errors.Wrapf(consensus_types.ErrOutOfBounds, "state root index %d does not exist", idx)
-	}
-	return b.stateRoots[idx], nil
-}
-
 // ProtobufBeaconStatePhase0 transforms an input into beacon state in the form of protobuf.
 // Error is returned if the input is not type protobuf beacon state.
 func ProtobufBeaconStatePhase0(s interface{}) (*ethpb.BeaconState, error) {

beacon-chain/state/state-native/getters_validator.go

@@ -2,16 +2,12 @@ package state_native
 
 import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v6/config/features"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	consensus_types "github.com/OffchainLabs/prysm/v6/consensus-types"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/pkg/errors"
 )
 
 // Validators participating in consensus on the beacon chain.
@@ -32,17 +28,10 @@ func (b *BeaconState) ValidatorsReadOnly() []state.ReadOnlyValidator {
 
 func (b *BeaconState) validatorsVal() []*ethpb.Validator {
 	var v []*ethpb.Validator
-	if features.Get().EnableExperimentalState {
-		if b.validatorsMultiValue == nil {
-			return nil
-		}
-		v = b.validatorsMultiValue.Value(b)
-	} else {
-		if b.validators == nil {
-			return nil
-		}
-		v = b.validators
+	if b.validatorsMultiValue == nil {
+		return nil
 	}
+	v = b.validatorsMultiValue.Value(b)
 
 	res := make([]*ethpb.Validator, len(v))
 	for i := 0; i < len(res); i++ {
@@ -56,18 +45,10 @@ func (b *BeaconState) validatorsVal() []*ethpb.Validator {
 }
 
 func (b *BeaconState) validatorsReadOnlyVal() []state.ReadOnlyValidator {
-	var v []*ethpb.Validator
-	if features.Get().EnableExperimentalState {
-		if b.validatorsMultiValue == nil {
-			return nil
-		}
-		v = b.validatorsMultiValue.Value(b)
-	} else {
-		if b.validators == nil {
-			return nil
-		}
-		v = b.validators
+	if b.validatorsMultiValue == nil {
+		return nil
 	}
+	v := b.validatorsMultiValue.Value(b)
 
 	res := make([]state.ReadOnlyValidator, len(v))
 	var err error
@@ -84,34 +65,11 @@ func (b *BeaconState) validatorsReadOnlyVal() []state.ReadOnlyValidator {
 	return res
 }
 
-// references of validators participating in consensus on the beacon chain.
-// This assumes that a lock is already held on BeaconState. This does not
-// copy fully and instead just copies the reference.
-func (b *BeaconState) validatorsReferences() []*ethpb.Validator {
-	if b.validators == nil {
-		return nil
-	}
-
-	res := make([]*ethpb.Validator, len(b.validators), len(b.validators)+int(params.BeaconConfig().MaxDeposits))
-	for i := 0; i < len(res); i++ {
-		validator := b.validators[i]
-		if validator == nil {
-			continue
-		}
-		// copy validator reference instead.
-		res[i] = validator
-	}
-	return res
-}
-
 func (b *BeaconState) validatorsLen() int {
-	if features.Get().EnableExperimentalState {
-		if b.validatorsMultiValue == nil {
-			return 0
-		}
-		return b.validatorsMultiValue.Len(b)
+	if b.validatorsMultiValue == nil {
+		return 0
 	}
-	return len(b.validators)
+	return b.validatorsMultiValue.Len(b)
 }
 
 // ValidatorAtIndex is the validator at the provided index.
@@ -123,25 +81,14 @@ func (b *BeaconState) ValidatorAtIndex(idx primitives.ValidatorIndex) (*ethpb.Va
 }
 
 func (b *BeaconState) validatorAtIndex(idx primitives.ValidatorIndex) (*ethpb.Validator, error) {
-	if features.Get().EnableExperimentalState {
-		if b.validatorsMultiValue == nil {
-			return &ethpb.Validator{}, nil
-		}
-		v, err := b.validatorsMultiValue.At(b, uint64(idx))
-		if err != nil {
-			return nil, err
-		}
-		return ethpb.CopyValidator(v), nil
-	}
-
-	if b.validators == nil {
+	if b.validatorsMultiValue == nil {
 		return &ethpb.Validator{}, nil
 	}
-	if uint64(len(b.validators)) <= uint64(idx) {
-		return nil, errors.Wrapf(consensus_types.ErrOutOfBounds, "validator index %d does not exist", idx)
+	v, err := b.validatorsMultiValue.At(b, uint64(idx))
+	if err != nil {
+		return nil, err
 	}
-	val := b.validators[idx]
-	return ethpb.CopyValidator(val), nil
+	return ethpb.CopyValidator(v), nil
 }
 
 // ValidatorAtIndexReadOnly is the validator at the provided index. This method
@@ -154,25 +101,14 @@ func (b *BeaconState) ValidatorAtIndexReadOnly(idx primitives.ValidatorIndex) (s
 }
 
 func (b *BeaconState) validatorAtIndexReadOnly(idx primitives.ValidatorIndex) (state.ReadOnlyValidator, error) {
-	if features.Get().EnableExperimentalState {
-		if b.validatorsMultiValue == nil {
-			return nil, state.ErrNilValidatorsInState
-		}
-		v, err := b.validatorsMultiValue.At(b, uint64(idx))
-		if err != nil {
-			return nil, err
-		}
-		return NewValidator(v)
-	}
-
-	if b.validators == nil {
+	if b.validatorsMultiValue == nil {
 		return nil, state.ErrNilValidatorsInState
 	}
-	if uint64(len(b.validators)) <= uint64(idx) {
-		return nil, errors.Wrapf(consensus_types.ErrOutOfBounds, "validator index %d does not exist", idx)
+	v, err := b.validatorsMultiValue.At(b, uint64(idx))
+	if err != nil {
+		return nil, err
 	}
-	val := b.validators[idx]
-	return NewValidator(val)
+	return NewValidator(v)
 }
 
 // ValidatorIndexByPubkey returns a given validator by its 48-byte public key.
@@ -181,20 +117,40 @@ func (b *BeaconState) ValidatorIndexByPubkey(key [fieldparams.BLSPubkeyLength]by
 		return 0, false
 	}
 	b.lock.RLock()
-	defer b.lock.RUnlock()
 
-	var numOfVals int
-	if features.Get().EnableExperimentalState {
-		numOfVals = b.validatorsMultiValue.Len(b)
-	} else {
-		numOfVals = len(b.validators)
-	}
+	numOfVals := b.validatorsMultiValue.Len(b)
 
+	// Try fast lookup via validator map first
 	idx, ok := b.valMapHandler.Get(key)
-	if ok && primitives.ValidatorIndex(numOfVals) <= idx {
-		return primitives.ValidatorIndex(0), false
+	if ok && idx < primitives.ValidatorIndex(numOfVals) {
+		b.lock.RUnlock()
+		return idx, true
 	}
-	return idx, ok
+	if ok {
+		b.lock.RUnlock()
+		return 0, false // Found in map but out of bounds
+	}
+
+	// Release lock before calling ReadFromEveryValidator to avoid recursive lock
+	b.lock.RUnlock()
+
+	// Fallback: search through all validators using ReadFromEveryValidator
+	var foundIdx primitives.ValidatorIndex
+	var found bool
+
+	err := b.ReadFromEveryValidator(func(i int, val state.ReadOnlyValidator) error {
+		if val.PublicKey() == key {
+			foundIdx = primitives.ValidatorIndex(i)
+			found = true
+			return ErrNilParticipation // Return error to break early
+		}
+		return nil
+	})
+	if err != nil && err != ErrNilParticipation {
+		return 0, false
+	}
+
+	return foundIdx, found
 }
 
 // PubkeyAtIndex returns the pubkey at the given
@@ -203,18 +159,9 @@ func (b *BeaconState) PubkeyAtIndex(idx primitives.ValidatorIndex) [fieldparams.
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	var v *ethpb.Validator
-	if features.Get().EnableExperimentalState {
-		var err error
-		v, err = b.validatorsMultiValue.At(b, uint64(idx))
-		if err != nil {
-			return [fieldparams.BLSPubkeyLength]byte{}
-		}
-	} else {
-		if uint64(idx) >= uint64(len(b.validators)) {
-			return [fieldparams.BLSPubkeyLength]byte{}
-		}
-		v = b.validators[idx]
+	v, err := b.validatorsMultiValue.At(b, uint64(idx))
+	if err != nil {
+		return [fieldparams.BLSPubkeyLength]byte{}
 	}
 
 	if v == nil {
@@ -231,20 +178,10 @@ func (b *BeaconState) AggregateKeyFromIndices(idxs []uint64) (bls.PublicKey, err
 
 	pubKeys := make([][]byte, len(idxs))
 	for i, idx := range idxs {
-		var v *ethpb.Validator
-		if features.Get().EnableExperimentalState {
-			var err error
-			v, err = b.validatorsMultiValue.At(b, idx)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			if idx >= uint64(len(b.validators)) {
-				return nil, consensus_types.ErrOutOfBounds
-			}
-			v = b.validators[idx]
+		v, err := b.validatorsMultiValue.At(b, idx)
+		if err != nil {
+			return nil, err
 		}
-
 		if v == nil {
 			return nil, ErrNilWrappedValidator
 		}
@@ -261,15 +198,11 @@ func (b *BeaconState) PublicKeys() ([][fieldparams.BLSPubkeyLength]byte, error)
 	l := b.validatorsLen()
 	res := make([][fieldparams.BLSPubkeyLength]byte, l)
 	for i := 0; i < l; i++ {
-		if features.Get().EnableExperimentalState {
-			val, err := b.validatorsMultiValue.At(b, uint64(i))
-			if err != nil {
-				return nil, err
-			}
-			copy(res[i][:], val.PublicKey)
-		} else {
-			copy(res[i][:], b.validators[i].PublicKey)
+		val, err := b.validatorsMultiValue.At(b, uint64(i))
+		if err != nil {
+			return nil, err
 		}
+		copy(res[i][:], val.PublicKey)
 	}
 	return res, nil
 }
@@ -289,30 +222,6 @@ func (b *BeaconState) ReadFromEveryValidator(f func(idx int, val state.ReadOnlyV
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	if features.Get().EnableExperimentalState {
-		return b.readFromEveryValidatorMVSlice(f)
-	}
-
-	if b.validators == nil {
-		return state.ErrNilValidatorsInState
-	}
-
-	validators := b.validators
-
-	for i, v := range validators {
-		v, err := NewValidator(v)
-		if err != nil {
-			return err
-		}
-		if err = f(i, v); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// WARNING: This function works only for the multi-value slice feature.
-func (b *BeaconState) readFromEveryValidatorMVSlice(f func(idx int, val state.ReadOnlyValidator) error) error {
 	if b.validatorsMultiValue == nil {
 		return state.ErrNilValidatorsInState
 	}
@@ -342,18 +251,10 @@ func (b *BeaconState) Balances() []uint64 {
 }
 
 func (b *BeaconState) balancesVal() []uint64 {
-	if features.Get().EnableExperimentalState {
-		if b.balancesMultiValue == nil {
-			return nil
-		}
-		return b.balancesMultiValue.Value(b)
-	}
-	if b.balances == nil {
+	if b.balancesMultiValue == nil {
 		return nil
 	}
-	res := make([]uint64, len(b.balances))
-	copy(res, b.balances)
-	return res
+	return b.balancesMultiValue.Value(b)
 }
 
 // BalanceAtIndex of validator with the provided index.
@@ -365,19 +266,10 @@ func (b *BeaconState) BalanceAtIndex(idx primitives.ValidatorIndex) (uint64, err
 }
 
 func (b *BeaconState) balanceAtIndex(idx primitives.ValidatorIndex) (uint64, error) {
-	if features.Get().EnableExperimentalState {
-		if b.balancesMultiValue == nil {
-			return 0, nil
-		}
-		return b.balancesMultiValue.At(b, uint64(idx))
-	}
-	if b.balances == nil {
+	if b.balancesMultiValue == nil {
 		return 0, nil
 	}
-	if uint64(len(b.balances)) <= uint64(idx) {
-		return 0, errors.Wrapf(consensus_types.ErrOutOfBounds, "balance index %d does not exist", idx)
-	}
-	return b.balances[idx], nil
+	return b.balancesMultiValue.At(b, uint64(idx))
 }
 
 // BalancesLength returns the length of the balances slice.
@@ -385,13 +277,10 @@ func (b *BeaconState) BalancesLength() int {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	if features.Get().EnableExperimentalState {
-		if b.balancesMultiValue == nil {
-			return 0
-		}
-		return b.balancesMultiValue.Len(b)
+	if b.balancesMultiValue == nil {
+		return 0
 	}
-	return len(b.balances)
+	return b.balancesMultiValue.Len(b)
 }
 
 // Slashings of validators on the beacon chain.
@@ -431,18 +320,10 @@ func (b *BeaconState) InactivityScores() ([]uint64, error) {
 }
 
 func (b *BeaconState) inactivityScoresVal() []uint64 {
-	if features.Get().EnableExperimentalState {
-		if b.inactivityScoresMultiValue == nil {
-			return nil
-		}
-		return b.inactivityScoresMultiValue.Value(b)
-	}
-	if b.inactivityScores == nil {
+	if b.inactivityScoresMultiValue == nil {
 		return nil
 	}
-	res := make([]uint64, len(b.inactivityScores))
-	copy(res, b.inactivityScores)
-	return res
+	return b.inactivityScoresMultiValue.Value(b)
 }
 
 // PendingBalanceToWithdraw returns the sum of all pending withdrawals for the given validator.

beacon-chain/state/state-native/mvslice_fuzz_test.go

@@ -3,18 +3,12 @@ package state_native
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 )
 
 func FuzzMultiValueBalances(f *testing.F) {
-	resetFn := features.InitWithReset(&features.Flags{
-		EnableExperimentalState: true,
-	})
-	defer resetFn()
-
 	bals := make([]uint64, 65536)
 	firstState, err := InitializeFromProtoPhase0(&ethpb.BeaconState{Balances: bals})
 	require.NoError(f, err)

beacon-chain/state/state-native/references_test.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -17,663 +16,358 @@ import (
 )
 
 func TestStateReferenceSharing_Finalizer_Phase0(t *testing.T) {
-	// This test showcases the logic on the RandaoMixes field with the GC finalizer.
+	// This test showcases the logic on the Slashings field with the GC finalizer.
 
-	s, err := InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{RandaoMixes: [][]byte{[]byte("foo")}})
+	s, err := InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{Slashings: []uint64{10, 30, 40}})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected a single reference for RANDAO mixes")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected a single reference for RANDAO mixes")
 
 	func() {
 		// Create object in a different scope for GC
 		b := a.Copy()
-		assert.Equal(t, uint(2), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 references to RANDAO mixes")
+		assert.Equal(t, uint(2), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 references to RANDAO mixes")
 		_ = b
 	}()
 
 	runtime.GC() // Should run finalizer on object b
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 1 shared reference to RANDAO mixes!")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 1 shared reference to RANDAO mixes!")
 
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(2), b.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 shared references to RANDAO mixes")
-	require.NoError(t, b.UpdateRandaoMixesAtIndex(0, bytesutil.ToBytes32([]byte("bar"))))
-	if b.sharedFieldReferences[types.RandaoMixes].Refs() != 1 || a.sharedFieldReferences[types.RandaoMixes].Refs() != 1 {
-		t.Error("Expected 1 shared reference to RANDAO mix for both a and b")
+	assert.Equal(t, uint(2), b.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 shared references to RANDAO mixes")
+	require.NoError(t, b.UpdateSlashingsAtIndex(0, 100))
+	if b.sharedFieldReferences[types.Slashings].Refs() != 1 || a.sharedFieldReferences[types.Slashings].Refs() != 1 {
+		t.Error("Expected 1 shared reference to Slashings for both a and b")
 	}
 }
 
 func TestStateReferenceSharing_Finalizer_Altair(t *testing.T) {
-	// This test showcases the logic on the RandaoMixes field with the GC finalizer.
+	// This test showcases the logic on the Slashings field with the GC finalizer.
 
-	s, err := InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{RandaoMixes: [][]byte{[]byte("foo")}})
+	s, err := InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{Slashings: []uint64{10, 30, 40}})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected a single reference for RANDAO mixes")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected a single reference for RANDAO mixes")
 
 	func() {
 		// Create object in a different scope for GC
 		b := a.Copy()
-		assert.Equal(t, uint(2), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 references to RANDAO mixes")
+		assert.Equal(t, uint(2), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 references to RANDAO mixes")
 		_ = b
 	}()
 
 	runtime.GC() // Should run finalizer on object b
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 1 shared reference to RANDAO mixes!")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 1 shared reference to RANDAO mixes!")
 
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(2), b.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 shared references to RANDAO mixes")
-	require.NoError(t, b.UpdateRandaoMixesAtIndex(0, bytesutil.ToBytes32([]byte("bar"))))
-	if b.sharedFieldReferences[types.RandaoMixes].Refs() != 1 || a.sharedFieldReferences[types.RandaoMixes].Refs() != 1 {
-		t.Error("Expected 1 shared reference to RANDAO mix for both a and b")
+	assert.Equal(t, uint(2), b.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 shared references to RANDAO mixes")
+	require.NoError(t, b.UpdateSlashingsAtIndex(0, 100))
+	if b.sharedFieldReferences[types.Slashings].Refs() != 1 || a.sharedFieldReferences[types.Slashings].Refs() != 1 {
+		t.Error("Expected 1 shared reference to Slashings for both a and b")
 	}
 }
 
 func TestStateReferenceSharing_Finalizer_Bellatrix(t *testing.T) {
-	// This test showcases the logic on the RandaoMixes field with the GC finalizer.
+	// This test showcases the logic on the Slashings field with the GC finalizer.
 
-	s, err := InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{RandaoMixes: [][]byte{[]byte("foo")}})
+	s, err := InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{Slashings: []uint64{10, 30, 40}})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected a single reference for RANDAO mixes")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected a single reference for RANDAO mixes")
 
 	func() {
 		// Create object in a different scope for GC
 		b := a.Copy()
-		assert.Equal(t, uint(2), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 references to RANDAO mixes")
+		assert.Equal(t, uint(2), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 references to RANDAO mixes")
 		_ = b
 	}()
 
 	runtime.GC() // Should run finalizer on object b
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 1 shared reference to RANDAO mixes!")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 1 shared reference to RANDAO mixes!")
 
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(2), b.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 shared references to RANDAO mixes")
-	require.NoError(t, b.UpdateRandaoMixesAtIndex(0, bytesutil.ToBytes32([]byte("bar"))))
-	if b.sharedFieldReferences[types.RandaoMixes].Refs() != 1 || a.sharedFieldReferences[types.RandaoMixes].Refs() != 1 {
-		t.Error("Expected 1 shared reference to RANDAO mix for both a and b")
+	assert.Equal(t, uint(2), b.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 shared references to RANDAO mixes")
+	require.NoError(t, b.UpdateSlashingsAtIndex(0, 100))
+	if b.sharedFieldReferences[types.Slashings].Refs() != 1 || a.sharedFieldReferences[types.Slashings].Refs() != 1 {
+		t.Error("Expected 1 shared reference to Slashings for both a and b")
 	}
 }
 
 func TestStateReferenceSharing_Finalizer_Capella(t *testing.T) {
-	// This test showcases the logic on the RandaoMixes field with the GC finalizer.
+	// This test showcases the logic on the Slashings field with the GC finalizer.
 
-	s, err := InitializeFromProtoUnsafeCapella(&ethpb.BeaconStateCapella{RandaoMixes: [][]byte{[]byte("foo")}})
+	s, err := InitializeFromProtoUnsafeCapella(&ethpb.BeaconStateCapella{Slashings: []uint64{10, 30, 40}})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected a single reference for RANDAO mixes")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected a single reference for RANDAO mixes")
 
 	func() {
 		// Create object in a different scope for GC
 		b := a.Copy()
-		assert.Equal(t, uint(2), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 references to RANDAO mixes")
+		assert.Equal(t, uint(2), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 references to RANDAO mixes")
 		_ = b
 	}()
 
 	runtime.GC() // Should run finalizer on object b
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 1 shared reference to RANDAO mixes!")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 1 shared reference to RANDAO mixes!")
 
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(2), b.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 shared references to RANDAO mixes")
-	require.NoError(t, b.UpdateRandaoMixesAtIndex(0, bytesutil.ToBytes32([]byte("bar"))))
-	if b.sharedFieldReferences[types.RandaoMixes].Refs() != 1 || a.sharedFieldReferences[types.RandaoMixes].Refs() != 1 {
-		t.Error("Expected 1 shared reference to RANDAO mix for both a and b")
+	assert.Equal(t, uint(2), b.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 shared references to RANDAO mixes")
+	require.NoError(t, b.UpdateSlashingsAtIndex(0, 100))
+	if b.sharedFieldReferences[types.Slashings].Refs() != 1 || a.sharedFieldReferences[types.Slashings].Refs() != 1 {
+		t.Error("Expected 1 shared reference to Slashings for both a and b")
 	}
 }
 
 func TestStateReferenceSharing_Finalizer_Deneb(t *testing.T) {
-	// This test showcases the logic on the RandaoMixes field with the GC finalizer.
+	// This test showcases the logic on the Slashings field with the GC finalizer.
 
-	s, err := InitializeFromProtoUnsafeDeneb(&ethpb.BeaconStateDeneb{RandaoMixes: [][]byte{[]byte("foo")}})
+	s, err := InitializeFromProtoUnsafeDeneb(&ethpb.BeaconStateDeneb{Slashings: []uint64{10, 30, 40}})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected a single reference for RANDAO mixes")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected a single reference for RANDAO mixes")
 
 	func() {
 		// Create object in a different scope for GC
 		b := a.Copy()
-		assert.Equal(t, uint(2), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 references to RANDAO mixes")
+		assert.Equal(t, uint(2), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 references to RANDAO mixes")
 		_ = b
 	}()
 
 	runtime.GC() // Should run finalizer on object b
-	assert.Equal(t, uint(1), a.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 1 shared reference to RANDAO mixes!")
+	assert.Equal(t, uint(1), a.sharedFieldReferences[types.Slashings].Refs(), "Expected 1 shared reference to RANDAO mixes!")
 
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assert.Equal(t, uint(2), b.sharedFieldReferences[types.RandaoMixes].Refs(), "Expected 2 shared references to RANDAO mixes")
-	require.NoError(t, b.UpdateRandaoMixesAtIndex(0, bytesutil.ToBytes32([]byte("bar"))))
-	if b.sharedFieldReferences[types.RandaoMixes].Refs() != 1 || a.sharedFieldReferences[types.RandaoMixes].Refs() != 1 {
-		t.Error("Expected 1 shared reference to RANDAO mix for both a and b")
+	assert.Equal(t, uint(2), b.sharedFieldReferences[types.Slashings].Refs(), "Expected 2 shared references to RANDAO mixes")
+	require.NoError(t, b.UpdateSlashingsAtIndex(0, 100))
+	if b.sharedFieldReferences[types.Slashings].Refs() != 1 || a.sharedFieldReferences[types.Slashings].Refs() != 1 {
+		t.Error("Expected 1 shared reference to Slashings for both a and b")
 	}
 }
 
-func TestStateReferenceCopy_NoUnexpectedRootsMutation_Phase0(t *testing.T) {
-	root1, root2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
+func TestStateReferenceCopy_NoUnexpectedSlashingsMutation_Phase0(t *testing.T) {
+	val1, val2 := uint64(10), uint64(20)
 	s, err := InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{
-		BlockRoots: [][]byte{
-			root1[:],
-		},
-		StateRoots: [][]byte{
-			root1[:],
-		},
+		Slashings: []uint64{val1},
 	})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
 	require.NoError(t, err)
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
+	assertRefCount(t, a, types.Slashings, 1)
 
 	// Copy, increases reference count.
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.BlockRoots, 2)
-	assertRefCount(t, a, types.StateRoots, 2)
-	assertRefCount(t, b, types.BlockRoots, 2)
-	assertRefCount(t, b, types.StateRoots, 2)
+	assertRefCount(t, a, types.Slashings, 2)
+	assertRefCount(t, b, types.Slashings, 2)
 
 	// Assert shared state.
-	blockRootsA := a.BlockRoots()
-	stateRootsA := a.StateRoots()
-	blockRootsB := b.BlockRoots()
-	stateRootsB := b.StateRoots()
-	assertValFound(t, blockRootsA, root1[:])
-	assertValFound(t, blockRootsB, root1[:])
-	assertValFound(t, stateRootsA, root1[:])
-	assertValFound(t, stateRootsB, root1[:])
+	slashingsA := a.Slashings()
+	slashingsB := b.Slashings()
+	assertValFound(t, slashingsA, val1)
+	assertValFound(t, slashingsB, val1)
 
 	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateBlockRootAtIndex(0, root2))
-	require.NoError(t, a.UpdateStateRootAtIndex(0, root2))
+	require.NoError(t, a.UpdateSlashingsAtIndex(0, val2))
 
 	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValNotFound(t, a.BlockRoots(), root1[:])
-	assertValNotFound(t, a.StateRoots(), root1[:])
-	assertValFound(t, a.BlockRoots(), root2[:])
-	assertValFound(t, a.StateRoots(), root2[:])
-	assertValFound(t, b.BlockRoots(), root1[:])
-	assertValFound(t, b.StateRoots(), root1[:])
-	assert.DeepEqual(t, root2[:], a.BlockRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root2[:], a.StateRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root1[:], blockRootsB[0], "Unexpected mutation found")
-	assert.DeepEqual(t, root1[:], stateRootsB[0], "Unexpected mutation found")
+	assertValFound(t, a.Slashings(), val2)
+	assertValNotFound(t, a.Slashings(), val1)
+	assertValFound(t, b.Slashings(), val1)
+	assertValNotFound(t, b.Slashings(), val2)
+	assertValFound(t, slashingsB, val1)
+	assertValNotFound(t, slashingsB, val2)
+	assert.DeepEqual(t, val2, a.Slashings()[0], "Expected mutation not found")
+	assert.DeepEqual(t, val1, slashingsB[0], "Unexpected mutation found")
 
 	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
-	assertRefCount(t, b, types.BlockRoots, 1)
-	assertRefCount(t, b, types.StateRoots, 1)
+	assertRefCount(t, a, types.Slashings, 1)
+	assertRefCount(t, b, types.Slashings, 1)
 }
 
-func TestStateReferenceCopy_NoUnexpectedRootsMutation_Altair(t *testing.T) {
-	root1, root2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
+func TestStateReferenceCopy_NoUnexpectedSlashingMutation_Altair(t *testing.T) {
+	val1, val2 := uint64(10), uint64(20)
 	s, err := InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{
-		BlockRoots: [][]byte{
-			root1[:],
-		},
-		StateRoots: [][]byte{
-			root1[:],
-		},
+		Slashings: []uint64{val1},
 	})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
 	require.NoError(t, err)
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
+	assertRefCount(t, a, types.Slashings, 1)
 
 	// Copy, increases reference count.
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.BlockRoots, 2)
-	assertRefCount(t, a, types.StateRoots, 2)
-	assertRefCount(t, b, types.BlockRoots, 2)
-	assertRefCount(t, b, types.StateRoots, 2)
+	assertRefCount(t, a, types.Slashings, 2)
+	assertRefCount(t, b, types.Slashings, 2)
 
 	// Assert shared state.
-	blockRootsA := a.BlockRoots()
-	stateRootsA := a.StateRoots()
-	blockRootsB := b.BlockRoots()
-	stateRootsB := b.StateRoots()
-	assertValFound(t, blockRootsA, root1[:])
-	assertValFound(t, blockRootsB, root1[:])
-	assertValFound(t, stateRootsA, root1[:])
-	assertValFound(t, stateRootsB, root1[:])
+	slashingsA := a.Slashings()
+	slashingsB := b.Slashings()
+	assertValFound(t, slashingsA, val1)
+	assertValFound(t, slashingsB, val1)
 
 	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateBlockRootAtIndex(0, root2))
-	require.NoError(t, a.UpdateStateRootAtIndex(0, root2))
+	require.NoError(t, a.UpdateSlashingsAtIndex(0, val2))
 
 	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValNotFound(t, a.BlockRoots(), root1[:])
-	assertValNotFound(t, a.StateRoots(), root1[:])
-	assertValFound(t, a.BlockRoots(), root2[:])
-	assertValFound(t, a.StateRoots(), root2[:])
-	assertValFound(t, b.BlockRoots(), root1[:])
-	assertValFound(t, b.StateRoots(), root1[:])
-	assert.DeepEqual(t, root2[:], a.BlockRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root2[:], a.StateRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root1[:], blockRootsB[0], "Unexpected mutation found")
-	assert.DeepEqual(t, root1[:], stateRootsB[0], "Unexpected mutation found")
+	assertValFound(t, a.Slashings(), val2)
+	assertValNotFound(t, a.Slashings(), val1)
+	assertValFound(t, b.Slashings(), val1)
+	assertValNotFound(t, b.Slashings(), val2)
+	assertValFound(t, slashingsB, val1)
+	assertValNotFound(t, slashingsB, val2)
+	assert.DeepEqual(t, val2, a.Slashings()[0], "Expected mutation not found")
+	assert.DeepEqual(t, val1, slashingsB[0], "Unexpected mutation found")
 
 	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
-	assertRefCount(t, b, types.BlockRoots, 1)
-	assertRefCount(t, b, types.StateRoots, 1)
+	assertRefCount(t, a, types.Slashings, 1)
+	assertRefCount(t, b, types.Slashings, 1)
 }
 
-func TestStateReferenceCopy_NoUnexpectedRootsMutation_Bellatrix(t *testing.T) {
-	root1, root2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
+func TestStateReferenceCopy_NoUnexpectedSlashingMutation_Bellatrix(t *testing.T) {
+	val1, val2 := uint64(10), uint64(20)
 	s, err := InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{
-		BlockRoots: [][]byte{
-			root1[:],
-		},
-		StateRoots: [][]byte{
-			root1[:],
-		},
+		Slashings: []uint64{val1},
 	})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
 	require.NoError(t, err)
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
+	assertRefCount(t, a, types.Slashings, 1)
 
 	// Copy, increases reference count.
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.BlockRoots, 2)
-	assertRefCount(t, a, types.StateRoots, 2)
-	assertRefCount(t, b, types.BlockRoots, 2)
-	assertRefCount(t, b, types.StateRoots, 2)
+	assertRefCount(t, a, types.Slashings, 2)
+	assertRefCount(t, b, types.Slashings, 2)
 
 	// Assert shared state.
-	blockRootsA := a.BlockRoots()
-	stateRootsA := a.StateRoots()
-	blockRootsB := b.BlockRoots()
-	stateRootsB := b.StateRoots()
-	assertValFound(t, blockRootsA, root1[:])
-	assertValFound(t, blockRootsB, root1[:])
-	assertValFound(t, stateRootsA, root1[:])
-	assertValFound(t, stateRootsB, root1[:])
+	slashingsA := a.Slashings()
+	slashingsB := b.Slashings()
+	assertValFound(t, slashingsA, val1)
+	assertValFound(t, slashingsB, val1)
 
 	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateBlockRootAtIndex(0, root2))
-	require.NoError(t, a.UpdateStateRootAtIndex(0, root2))
+	require.NoError(t, a.UpdateSlashingsAtIndex(0, val2))
 
 	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValNotFound(t, a.BlockRoots(), root1[:])
-	assertValNotFound(t, a.StateRoots(), root1[:])
-	assertValFound(t, a.BlockRoots(), root2[:])
-	assertValFound(t, a.StateRoots(), root2[:])
-	assertValFound(t, b.BlockRoots(), root1[:])
-	assertValFound(t, b.StateRoots(), root1[:])
-	assert.DeepEqual(t, root2[:], a.BlockRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root2[:], a.StateRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root1[:], blockRootsB[0], "Unexpected mutation found")
-	assert.DeepEqual(t, root1[:], stateRootsB[0], "Unexpected mutation found")
+	assertValFound(t, a.Slashings(), val2)
+	assertValNotFound(t, a.Slashings(), val1)
+	assertValFound(t, b.Slashings(), val1)
+	assertValNotFound(t, b.Slashings(), val2)
+	assertValFound(t, slashingsB, val1)
+	assertValNotFound(t, slashingsB, val2)
+	assert.DeepEqual(t, val2, a.Slashings()[0], "Expected mutation not found")
+	assert.DeepEqual(t, val1, slashingsB[0], "Unexpected mutation found")
 
 	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
-	assertRefCount(t, b, types.BlockRoots, 1)
-	assertRefCount(t, b, types.StateRoots, 1)
+	assertRefCount(t, a, types.Slashings, 1)
+	assertRefCount(t, b, types.Slashings, 1)
 }
 
-func TestStateReferenceCopy_NoUnexpectedRootsMutation_Capella(t *testing.T) {
-	root1, root2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
+func TestStateReferenceCopy_NoUnexpectedSlashingMutation_Capella(t *testing.T) {
+	val1, val2 := uint64(10), uint64(20)
 	s, err := InitializeFromProtoUnsafeCapella(&ethpb.BeaconStateCapella{
-		BlockRoots: [][]byte{
-			root1[:],
-		},
-		StateRoots: [][]byte{
-			root1[:],
-		},
+		Slashings: []uint64{val1},
 	})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
 	require.NoError(t, err)
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
+	assertRefCount(t, a, types.Slashings, 1)
 
 	// Copy, increases reference count.
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.BlockRoots, 2)
-	assertRefCount(t, a, types.StateRoots, 2)
-	assertRefCount(t, b, types.BlockRoots, 2)
-	assertRefCount(t, b, types.StateRoots, 2)
+	assertRefCount(t, a, types.Slashings, 2)
+	assertRefCount(t, b, types.Slashings, 2)
 
 	// Assert shared state.
-	blockRootsA := a.BlockRoots()
-	stateRootsA := a.StateRoots()
-	blockRootsB := b.BlockRoots()
-	stateRootsB := b.StateRoots()
-	assertValFound(t, blockRootsA, root1[:])
-	assertValFound(t, blockRootsB, root1[:])
-	assertValFound(t, stateRootsA, root1[:])
-	assertValFound(t, stateRootsB, root1[:])
+	slashingsA := a.Slashings()
+	slashingsB := b.Slashings()
+	assertValFound(t, slashingsA, val1)
+	assertValFound(t, slashingsB, val1)
 
 	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateBlockRootAtIndex(0, root2))
-	require.NoError(t, a.UpdateStateRootAtIndex(0, root2))
+	require.NoError(t, a.UpdateSlashingsAtIndex(0, val2))
 
 	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValNotFound(t, a.BlockRoots(), root1[:])
-	assertValNotFound(t, a.StateRoots(), root1[:])
-	assertValFound(t, a.BlockRoots(), root2[:])
-	assertValFound(t, a.StateRoots(), root2[:])
-	assertValFound(t, b.BlockRoots(), root1[:])
-	assertValFound(t, b.StateRoots(), root1[:])
-	assert.DeepEqual(t, root2[:], a.BlockRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root2[:], a.StateRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root1[:], blockRootsB[0], "Unexpected mutation found")
-	assert.DeepEqual(t, root1[:], stateRootsB[0], "Unexpected mutation found")
+	assertValFound(t, a.Slashings(), val2)
+	assertValNotFound(t, a.Slashings(), val1)
+	assertValFound(t, b.Slashings(), val1)
+	assertValNotFound(t, b.Slashings(), val2)
+	assertValFound(t, slashingsB, val1)
+	assertValNotFound(t, slashingsB, val2)
+	assert.DeepEqual(t, val2, a.Slashings()[0], "Expected mutation not found")
+	assert.DeepEqual(t, val1, slashingsB[0], "Unexpected mutation found")
 
 	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
-	assertRefCount(t, b, types.BlockRoots, 1)
-	assertRefCount(t, b, types.StateRoots, 1)
+	assertRefCount(t, a, types.Slashings, 1)
+	assertRefCount(t, b, types.Slashings, 1)
 }
 
-func TestStateReferenceCopy_NoUnexpectedRootsMutation_Deneb(t *testing.T) {
-	root1, root2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
+func TestStateReferenceCopy_NoUnexpectedSlashingMutation_Deneb(t *testing.T) {
+	val1, val2 := uint64(10), uint64(20)
 	s, err := InitializeFromProtoUnsafeDeneb(&ethpb.BeaconStateDeneb{
-		BlockRoots: [][]byte{
-			root1[:],
-		},
-		StateRoots: [][]byte{
-			root1[:],
-		},
+		Slashings: []uint64{val1},
 	})
 	require.NoError(t, err)
 	a, ok := s.(*BeaconState)
 	require.Equal(t, true, ok)
 	require.NoError(t, err)
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
+	assertRefCount(t, a, types.Slashings, 1)
 
 	// Copy, increases reference count.
 	copied := a.Copy()
 	b, ok := copied.(*BeaconState)
 	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.BlockRoots, 2)
-	assertRefCount(t, a, types.StateRoots, 2)
-	assertRefCount(t, b, types.BlockRoots, 2)
-	assertRefCount(t, b, types.StateRoots, 2)
+	assertRefCount(t, a, types.Slashings, 2)
+	assertRefCount(t, b, types.Slashings, 2)
 
 	// Assert shared state.
-	blockRootsA := a.BlockRoots()
-	stateRootsA := a.StateRoots()
-	blockRootsB := b.BlockRoots()
-	stateRootsB := b.StateRoots()
-	assertValFound(t, blockRootsA, root1[:])
-	assertValFound(t, blockRootsB, root1[:])
-	assertValFound(t, stateRootsA, root1[:])
-	assertValFound(t, stateRootsB, root1[:])
+	slashingsA := a.Slashings()
+	slashingsB := b.Slashings()
+	assertValFound(t, slashingsA, val1)
+	assertValFound(t, slashingsB, val1)
 
 	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateBlockRootAtIndex(0, root2))
-	require.NoError(t, a.UpdateStateRootAtIndex(0, root2))
+	require.NoError(t, a.UpdateSlashingsAtIndex(0, val2))
 
 	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValNotFound(t, a.BlockRoots(), root1[:])
-	assertValNotFound(t, a.StateRoots(), root1[:])
-	assertValFound(t, a.BlockRoots(), root2[:])
-	assertValFound(t, a.StateRoots(), root2[:])
-	assertValFound(t, b.BlockRoots(), root1[:])
-	assertValFound(t, b.StateRoots(), root1[:])
-	assert.DeepEqual(t, root2[:], a.BlockRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root2[:], a.StateRoots()[0], "Expected mutation not found")
-	assert.DeepEqual(t, root1[:], blockRootsB[0], "Unexpected mutation found")
-	assert.DeepEqual(t, root1[:], stateRootsB[0], "Unexpected mutation found")
+	assertValFound(t, a.Slashings(), val2)
+	assertValNotFound(t, a.Slashings(), val1)
+	assertValFound(t, b.Slashings(), val1)
+	assertValNotFound(t, b.Slashings(), val2)
+	assertValFound(t, slashingsB, val1)
+	assertValNotFound(t, slashingsB, val2)
+	assert.DeepEqual(t, val2, a.Slashings()[0], "Expected mutation not found")
+	assert.DeepEqual(t, val1, slashingsB[0], "Unexpected mutation found")
 
 	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.BlockRoots, 1)
-	assertRefCount(t, a, types.StateRoots, 1)
-	assertRefCount(t, b, types.BlockRoots, 1)
-	assertRefCount(t, b, types.StateRoots, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRandaoMutation_Phase0(t *testing.T) {
-	val1, val2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{
-		RandaoMixes: [][]byte{
-			val1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, types.RandaoMixes, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.RandaoMixes, 2)
-	assertRefCount(t, b, types.RandaoMixes, 2)
-
-	// Assert shared state.
-	mixesA := a.RandaoMixes()
-	mixesB := b.RandaoMixes()
-	assertValFound(t, mixesA, val1[:])
-	assertValFound(t, mixesB, val1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateRandaoMixesAtIndex(0, val2))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValFound(t, a.RandaoMixes(), val2[:])
-	assertValNotFound(t, a.RandaoMixes(), val1[:])
-	assertValFound(t, b.RandaoMixes(), val1[:])
-	assertValNotFound(t, b.RandaoMixes(), val2[:])
-	assertValFound(t, mixesB, val1[:])
-	assertValNotFound(t, mixesB, val2[:])
-	assert.DeepEqual(t, val2[:], a.RandaoMixes()[0], "Expected mutation not found")
-	assert.DeepEqual(t, val1[:], mixesB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.RandaoMixes, 1)
-	assertRefCount(t, b, types.RandaoMixes, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRandaoMutation_Altair(t *testing.T) {
-	val1, val2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{
-		RandaoMixes: [][]byte{
-			val1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, types.RandaoMixes, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.RandaoMixes, 2)
-	assertRefCount(t, b, types.RandaoMixes, 2)
-
-	// Assert shared state.
-	mixesA := a.RandaoMixes()
-	mixesB := b.RandaoMixes()
-	assertValFound(t, mixesA, val1[:])
-	assertValFound(t, mixesB, val1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateRandaoMixesAtIndex(0, val2))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValFound(t, a.RandaoMixes(), val2[:])
-	assertValNotFound(t, a.RandaoMixes(), val1[:])
-	assertValFound(t, b.RandaoMixes(), val1[:])
-	assertValNotFound(t, b.RandaoMixes(), val2[:])
-	assertValFound(t, mixesB, val1[:])
-	assertValNotFound(t, mixesB, val2[:])
-	assert.DeepEqual(t, val2[:], a.RandaoMixes()[0], "Expected mutation not found")
-	assert.DeepEqual(t, val1[:], mixesB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.RandaoMixes, 1)
-	assertRefCount(t, b, types.RandaoMixes, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRandaoMutation_Bellatrix(t *testing.T) {
-	val1, val2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafeBellatrix(&ethpb.BeaconStateBellatrix{
-		RandaoMixes: [][]byte{
-			val1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, types.RandaoMixes, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.RandaoMixes, 2)
-	assertRefCount(t, b, types.RandaoMixes, 2)
-
-	// Assert shared state.
-	mixesA := a.RandaoMixes()
-	mixesB := b.RandaoMixes()
-	assertValFound(t, mixesA, val1[:])
-	assertValFound(t, mixesB, val1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateRandaoMixesAtIndex(0, val2))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValFound(t, a.RandaoMixes(), val2[:])
-	assertValNotFound(t, a.RandaoMixes(), val1[:])
-	assertValFound(t, b.RandaoMixes(), val1[:])
-	assertValNotFound(t, b.RandaoMixes(), val2[:])
-	assertValFound(t, mixesB, val1[:])
-	assertValNotFound(t, mixesB, val2[:])
-	assert.DeepEqual(t, val2[:], a.RandaoMixes()[0], "Expected mutation not found")
-	assert.DeepEqual(t, val1[:], mixesB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.RandaoMixes, 1)
-	assertRefCount(t, b, types.RandaoMixes, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRandaoMutation_Capella(t *testing.T) {
-	val1, val2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafeCapella(&ethpb.BeaconStateCapella{
-		RandaoMixes: [][]byte{
-			val1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, types.RandaoMixes, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.RandaoMixes, 2)
-	assertRefCount(t, b, types.RandaoMixes, 2)
-
-	// Assert shared state.
-	mixesA := a.RandaoMixes()
-	mixesB := b.RandaoMixes()
-	assertValFound(t, mixesA, val1[:])
-	assertValFound(t, mixesB, val1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateRandaoMixesAtIndex(0, val2))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValFound(t, a.RandaoMixes(), val2[:])
-	assertValNotFound(t, a.RandaoMixes(), val1[:])
-	assertValFound(t, b.RandaoMixes(), val1[:])
-	assertValNotFound(t, b.RandaoMixes(), val2[:])
-	assertValFound(t, mixesB, val1[:])
-	assertValNotFound(t, mixesB, val2[:])
-	assert.DeepEqual(t, val2[:], a.RandaoMixes()[0], "Expected mutation not found")
-	assert.DeepEqual(t, val1[:], mixesB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.RandaoMixes, 1)
-	assertRefCount(t, b, types.RandaoMixes, 1)
-}
-
-func TestStateReferenceCopy_NoUnexpectedRandaoMutation_Deneb(t *testing.T) {
-	val1, val2 := bytesutil.ToBytes32([]byte("foo")), bytesutil.ToBytes32([]byte("bar"))
-	s, err := InitializeFromProtoUnsafeDeneb(&ethpb.BeaconStateDeneb{
-		RandaoMixes: [][]byte{
-			val1[:],
-		},
-	})
-	require.NoError(t, err)
-	a, ok := s.(*BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, err)
-	assertRefCount(t, a, types.RandaoMixes, 1)
-
-	// Copy, increases reference count.
-	copied := a.Copy()
-	b, ok := copied.(*BeaconState)
-	require.Equal(t, true, ok)
-	assertRefCount(t, a, types.RandaoMixes, 2)
-	assertRefCount(t, b, types.RandaoMixes, 2)
-
-	// Assert shared state.
-	mixesA := a.RandaoMixes()
-	mixesB := b.RandaoMixes()
-	assertValFound(t, mixesA, val1[:])
-	assertValFound(t, mixesB, val1[:])
-
-	// Mutator should only affect calling state: a.
-	require.NoError(t, a.UpdateRandaoMixesAtIndex(0, val2))
-
-	// Assert no shared state mutation occurred only on state a (copy on write).
-	assertValFound(t, a.RandaoMixes(), val2[:])
-	assertValNotFound(t, a.RandaoMixes(), val1[:])
-	assertValFound(t, b.RandaoMixes(), val1[:])
-	assertValNotFound(t, b.RandaoMixes(), val2[:])
-	assertValFound(t, mixesB, val1[:])
-	assertValNotFound(t, mixesB, val2[:])
-	assert.DeepEqual(t, val2[:], a.RandaoMixes()[0], "Expected mutation not found")
-	assert.DeepEqual(t, val1[:], mixesB[0], "Unexpected mutation found")
-
-	// Copy on write happened, reference counters are reset.
-	assertRefCount(t, a, types.RandaoMixes, 1)
-	assertRefCount(t, b, types.RandaoMixes, 1)
+	assertRefCount(t, a, types.Slashings, 1)
+	assertRefCount(t, b, types.Slashings, 1)
 }
 
 func TestStateReferenceCopy_NoUnexpectedAttestationsMutation(t *testing.T) {
@@ -1017,10 +711,6 @@ func TestValidatorReferences_RemainsConsistent_Bellatrix(t *testing.T) {
 }
 
 func TestValidatorReferences_ApplyValidator_BalancesRead(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnableExperimentalState: true,
-	})
-	defer resetCfg()
 	s, err := InitializeFromProtoUnsafeAltair(&ethpb.BeaconStateAltair{
 		Validators: []*ethpb.Validator{
 			{PublicKey: []byte{'A'}},
@@ -1061,7 +751,7 @@ func assertRefCount(t *testing.T, b *BeaconState, idx types.FieldIndex, want uin
 }
 
 // assertValFound checks whether item with a given value exists in list.
-func assertValFound(t *testing.T, vals [][]byte, val []byte) {
+func assertValFound(t *testing.T, vals []uint64, val uint64) {
 	for i := range vals {
 		if reflect.DeepEqual(vals[i], val) {
 			return
@@ -1072,7 +762,7 @@ func assertValFound(t *testing.T, vals [][]byte, val []byte) {
 }
 
 // assertValNotFound checks whether item with a given value doesn't exist in list.
-func assertValNotFound(t *testing.T, vals [][]byte, val []byte) {
+func assertValNotFound(t *testing.T, vals []uint64, val uint64) {
 	for i := range vals {
 		if reflect.DeepEqual(vals[i], val) {
 			t.Log(string(debug.Stack()))

beacon-chain/state/state-native/setters_block.go

@@ -2,10 +2,6 @@ package state_native
 
 import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stateutil"
-	"github.com/OffchainLabs/prysm/v6/config/features"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	consensus_types "github.com/OffchainLabs/prysm/v6/consensus-types"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 )
@@ -26,21 +22,10 @@ func (b *BeaconState) SetBlockRoots(val [][]byte) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
-	if features.Get().EnableExperimentalState {
-		if b.blockRootsMultiValue != nil {
-			b.blockRootsMultiValue.Detach(b)
-		}
-		b.blockRootsMultiValue = NewMultiValueBlockRoots(val)
-	} else {
-		b.sharedFieldReferences[types.BlockRoots].MinusRef()
-		b.sharedFieldReferences[types.BlockRoots] = stateutil.NewRef(1)
-
-		rootsArr := make([][32]byte, fieldparams.BlockRootsLength)
-		for i := 0; i < len(rootsArr); i++ {
-			copy(rootsArr[i][:], val[i])
-		}
-		b.blockRoots = rootsArr
+	if b.blockRootsMultiValue != nil {
+		b.blockRootsMultiValue.Detach(b)
 	}
+	b.blockRootsMultiValue = NewMultiValueBlockRoots(val)
 
 	b.markFieldAsDirty(types.BlockRoots)
 	b.rebuildTrie[types.BlockRoots] = true
@@ -53,25 +38,8 @@ func (b *BeaconState) UpdateBlockRootAtIndex(idx uint64, blockRoot [32]byte) err
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
-	if features.Get().EnableExperimentalState {
-		if err := b.blockRootsMultiValue.UpdateAt(b, idx, blockRoot); err != nil {
-			return errors.Wrap(err, "could not update block roots")
-		}
-	} else {
-		if uint64(len(b.blockRoots)) <= idx {
-			return errors.Wrapf(consensus_types.ErrOutOfBounds, "block root index %d does not exist", idx)
-		}
-
-		r := b.blockRoots
-		if ref := b.sharedFieldReferences[types.BlockRoots]; ref.Refs() > 1 {
-			// Copy elements in underlying array by reference.
-			r = make([][32]byte, len(b.blockRoots))
-			copy(r, b.blockRoots)
-			ref.MinusRef()
-			b.sharedFieldReferences[types.BlockRoots] = stateutil.NewRef(1)
-		}
-		r[idx] = blockRoot
-		b.blockRoots = r
+	if err := b.blockRootsMultiValue.UpdateAt(b, idx, blockRoot); err != nil {
+		return errors.Wrap(err, "could not update block roots")
 	}
 
 	b.markFieldAsDirty(types.BlockRoots)

beacon-chain/state/state-native/setters_randao.go

@@ -2,10 +2,6 @@ package state_native
 
 import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stateutil"
-	"github.com/OffchainLabs/prysm/v6/config/features"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	consensus_types "github.com/OffchainLabs/prysm/v6/consensus-types"
 	"github.com/pkg/errors"
 )
 
@@ -15,21 +11,10 @@ func (b *BeaconState) SetRandaoMixes(val [][]byte) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
-	if features.Get().EnableExperimentalState {
-		if b.randaoMixesMultiValue != nil {
-			b.randaoMixesMultiValue.Detach(b)
-		}
-		b.randaoMixesMultiValue = NewMultiValueRandaoMixes(val)
-	} else {
-		b.sharedFieldReferences[types.RandaoMixes].MinusRef()
-		b.sharedFieldReferences[types.RandaoMixes] = stateutil.NewRef(1)
-
-		rootsArr := make([][32]byte, fieldparams.RandaoMixesLength)
-		for i := 0; i < len(rootsArr); i++ {
-			copy(rootsArr[i][:], val[i])
-		}
-		b.randaoMixes = rootsArr
+	if b.randaoMixesMultiValue != nil {
+		b.randaoMixesMultiValue.Detach(b)
 	}
+	b.randaoMixesMultiValue = NewMultiValueRandaoMixes(val)
 
 	b.markFieldAsDirty(types.RandaoMixes)
 	b.rebuildTrie[types.RandaoMixes] = true
@@ -39,29 +24,8 @@ func (b *BeaconState) SetRandaoMixes(val [][]byte) error {
 // UpdateRandaoMixesAtIndex for the beacon state. Updates the randao mixes
 // at a specific index to a new value.
 func (b *BeaconState) UpdateRandaoMixesAtIndex(idx uint64, val [32]byte) error {
-	if features.Get().EnableExperimentalState {
-		if err := b.randaoMixesMultiValue.UpdateAt(b, idx, val); err != nil {
-			return errors.Wrap(err, "could not update randao mixes")
-		}
-	} else {
-		if uint64(len(b.randaoMixes)) <= idx {
-			return errors.Wrapf(consensus_types.ErrOutOfBounds, "randao mix index %d does not exist", idx)
-		}
-
-		b.lock.Lock()
-
-		m := b.randaoMixes
-		if ref := b.sharedFieldReferences[types.RandaoMixes]; ref.Refs() > 1 {
-			// Copy elements in underlying array by reference.
-			m = make([][32]byte, len(b.randaoMixes))
-			copy(m, b.randaoMixes)
-			ref.MinusRef()
-			b.sharedFieldReferences[types.RandaoMixes] = stateutil.NewRef(1)
-		}
-		m[idx] = val
-		b.randaoMixes = m
-
-		b.lock.Unlock()
+	if err := b.randaoMixesMultiValue.UpdateAt(b, idx, val); err != nil {
+		return errors.Wrap(err, "could not update randao mixes")
 	}
 
 	b.lock.Lock()

beacon-chain/state/state-native/setters_state.go

@@ -2,10 +2,6 @@ package state_native
 
 import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stateutil"
-	"github.com/OffchainLabs/prysm/v6/config/features"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	consensus_types "github.com/OffchainLabs/prysm/v6/consensus-types"
 	"github.com/pkg/errors"
 )
 
@@ -15,21 +11,10 @@ func (b *BeaconState) SetStateRoots(val [][]byte) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
-	if features.Get().EnableExperimentalState {
-		if b.stateRootsMultiValue != nil {
-			b.stateRootsMultiValue.Detach(b)
-		}
-		b.stateRootsMultiValue = NewMultiValueStateRoots(val)
-	} else {
-		b.sharedFieldReferences[types.StateRoots].MinusRef()
-		b.sharedFieldReferences[types.StateRoots] = stateutil.NewRef(1)
-
-		rootsArr := make([][32]byte, fieldparams.StateRootsLength)
-		for i := 0; i < len(rootsArr); i++ {
-			copy(rootsArr[i][:], val[i])
-		}
-		b.stateRoots = rootsArr
+	if b.stateRootsMultiValue != nil {
+		b.stateRootsMultiValue.Detach(b)
 	}
+	b.stateRootsMultiValue = NewMultiValueStateRoots(val)
 
 	b.markFieldAsDirty(types.StateRoots)
 	b.rebuildTrie[types.StateRoots] = true
@@ -39,29 +24,8 @@ func (b *BeaconState) SetStateRoots(val [][]byte) error {
 // UpdateStateRootAtIndex for the beacon state. Updates the state root
 // at a specific index to a new value.
 func (b *BeaconState) UpdateStateRootAtIndex(idx uint64, stateRoot [32]byte) error {
-	if features.Get().EnableExperimentalState {
-		if err := b.stateRootsMultiValue.UpdateAt(b, idx, stateRoot); err != nil {
-			return errors.Wrap(err, "could not update state roots")
-		}
-	} else {
-		if uint64(len(b.stateRoots)) <= idx {
-			return errors.Wrapf(consensus_types.ErrOutOfBounds, "state root index %d does not exist", idx)
-		}
-
-		b.lock.Lock()
-
-		r := b.stateRoots
-		if ref := b.sharedFieldReferences[types.StateRoots]; ref.Refs() > 1 {
-			// Copy elements in underlying array by reference.
-			r = make([][32]byte, len(b.stateRoots))
-			copy(r, b.stateRoots)
-			ref.MinusRef()
-			b.sharedFieldReferences[types.StateRoots] = stateutil.NewRef(1)
-		}
-		r[idx] = stateRoot
-		b.stateRoots = r
-
-		b.lock.Unlock()
+	if err := b.stateRootsMultiValue.UpdateAt(b, idx, stateRoot); err != nil {
+		return errors.Wrap(err, "could not update state roots")
 	}
 
 	b.lock.Lock()