Fix verification tests

Co-Authored-By: Claude <noreply@anthropic.com>

beacon-chain/blockchain/process_block.go

@@ -335,9 +335,6 @@ func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.Beacon
 	if err := helpers.UpdateCommitteeCache(ctx, st, e); err != nil {
 		return errors.Wrap(err, "could not update committee cache")
 	}
-	if err := helpers.UpdateProposerIndicesInCache(ctx, st, e); err != nil {
-		return errors.Wrap(err, "could not update proposer index cache")
-	}
 	go func(ep primitives.Epoch) {
 		// Use a custom deadline here, since this method runs asynchronously.
 		// We ignore the parent method's context and instead create a new one
@@ -348,26 +345,6 @@ func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.Beacon
 			log.WithError(err).Warn("Could not update committee cache")
 		}
 	}(e)
-	// 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")
-		return nil
-	}
-	// The proposer indices cache takes the target root for the previous
-	// epoch as key
-	if e > 0 {
-		e = e - 1
-	}
-	target, err := s.cfg.ForkChoiceStore.TargetRootForEpoch(r, e)
-	if err != nil {
-		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")
-	}
 	return nil
 }
 

beacon-chain/blockchain/service.go

@@ -15,7 +15,6 @@ import (
 	statefeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
-	coreTime "github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/filesystem"
@@ -397,10 +396,6 @@ func (s *Service) initializeBeaconChain(
 	if err := helpers.UpdateCommitteeCache(ctx, genesisState, 0); err != nil {
 		return nil, err
 	}
-	if err := helpers.UpdateProposerIndicesInCache(ctx, genesisState, coreTime.CurrentEpoch(genesisState)); err != nil {
-		return nil, err
-	}
-
 	s.cfg.AttService.SetGenesisTime(genesisState.GenesisTime())
 
 	return genesisState, nil

beacon-chain/cache/BUILD.bazel

@@ -17,9 +17,6 @@ go_library(
         "error.go",
         "interfaces.go",
         "payload_id.go",
-        "proposer_indices.go",
-        "proposer_indices_disabled.go",  # keep
-        "proposer_indices_type.go",
         "registration.go",
         "skip_slot_cache.go",
         "subnet_ids.go",
@@ -40,7 +37,6 @@ go_library(
         "//beacon-chain/operations/attestations/attmap:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//cache/lru:go_default_library",
-        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
@@ -77,7 +73,6 @@ go_test(
         "committee_test.go",
         "payload_id_test.go",
         "private_access_test.go",
-        "proposer_indices_test.go",
         "registration_test.go",
         "skip_slot_cache_test.go",
         "subnet_ids_test.go",

beacon-chain/cache/proposer_indices.go

@@ -1,122 +0,0 @@
-//go:build !fuzz
-
-package cache
-
-import (
-	"sync"
-
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-var (
-	// ProposerIndicesCacheMiss tracks the number of proposerIndices requests that aren't present in the cache.
-	ProposerIndicesCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "proposer_indices_cache_miss",
-		Help: "The number of proposer indices requests that aren't present in the cache.",
-	})
-	// ProposerIndicesCacheHit tracks the number of proposerIndices requests that are in the cache.
-	ProposerIndicesCacheHit = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "proposer_indices_cache_hit",
-		Help: "The number of proposer indices requests that are present in the cache.",
-	})
-)
-
-// ProposerIndicesCache keeps track of the proposer indices in the next two
-// epochs. It is keyed by the state root of the last epoch before. That is, for
-// blocks during epoch 2, for example slot 65, it will be keyed by the state
-// root of slot 63 (last slot in epoch 1).
-// The cache keeps two sets of indices computed, the "safe" set is computed
-// right before the epoch transition into the current epoch. For example for
-// epoch 2 we will compute this list after importing block 63. The "unsafe"
-// version is computed an epoch in advance, for example for epoch 3, it will be
-// computed after importing block 63.
-//
-// The cache also keeps a map from checkpoints to state roots so that one is
-// able to access the proposer indices list from a checkpoint instead. The
-// checkpoint is the checkpoint for the epoch previous to the requested
-// proposer indices. That is, for a slot in epoch 2 (eg. 65), the checkpoint
-// root would be for slot 32 if present.
-type ProposerIndicesCache struct {
-	sync.Mutex
-	indices map[primitives.Epoch]map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex
-	rootMap map[forkchoicetypes.Checkpoint][32]byte // A map from checkpoint root to state root
-}
-
-// NewProposerIndicesCache returns a newly created cache
-func NewProposerIndicesCache() *ProposerIndicesCache {
-	return &ProposerIndicesCache{
-		indices: make(map[primitives.Epoch]map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex),
-		rootMap: make(map[forkchoicetypes.Checkpoint][32]byte),
-	}
-}
-
-// ProposerIndices returns the proposer indices (safe) for the given root
-func (p *ProposerIndicesCache) ProposerIndices(epoch primitives.Epoch, root [32]byte) ([fieldparams.SlotsPerEpoch]primitives.ValidatorIndex, bool) {
-	p.Lock()
-	defer p.Unlock()
-	inner, ok := p.indices[epoch]
-	if !ok {
-		ProposerIndicesCacheMiss.Inc()
-		return [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{}, false
-	}
-	indices, exists := inner[root]
-	if exists {
-		ProposerIndicesCacheHit.Inc()
-	} else {
-		ProposerIndicesCacheMiss.Inc()
-	}
-	return indices, exists
-}
-
-// Prune resets the ProposerIndicesCache to its initial state
-func (p *ProposerIndicesCache) Prune(epoch primitives.Epoch) {
-	p.Lock()
-	defer p.Unlock()
-	for key := range p.indices {
-		if key < epoch {
-			delete(p.indices, key)
-		}
-	}
-	for key := range p.rootMap {
-		if key.Epoch+1 < epoch {
-			delete(p.rootMap, key)
-		}
-	}
-}
-
-// Set sets the proposer indices for the given root as key
-func (p *ProposerIndicesCache) Set(epoch primitives.Epoch, root [32]byte, indices [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex) {
-	p.Lock()
-	defer p.Unlock()
-
-	inner, ok := p.indices[epoch]
-	if !ok {
-		inner = make(map[[32]byte][fieldparams.SlotsPerEpoch]primitives.ValidatorIndex)
-		p.indices[epoch] = inner
-	}
-	inner[root] = indices
-}
-
-// SetCheckpoint updates the map from checkpoints to state roots
-func (p *ProposerIndicesCache) SetCheckpoint(c forkchoicetypes.Checkpoint, root [32]byte) {
-	p.Lock()
-	defer p.Unlock()
-	p.rootMap[c] = root
-}
-
-// IndicesFromCheckpoint returns the proposer indices from a checkpoint rather than the state root
-func (p *ProposerIndicesCache) IndicesFromCheckpoint(c forkchoicetypes.Checkpoint) ([fieldparams.SlotsPerEpoch]primitives.ValidatorIndex, bool) {
-	p.Lock()
-	emptyIndices := [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{}
-	root, ok := p.rootMap[c]
-	p.Unlock()
-	if !ok {
-		ProposerIndicesCacheMiss.Inc()
-		return emptyIndices, ok
-	}
-	return p.ProposerIndices(c.Epoch+1, root)
-}

beacon-chain/cache/proposer_indices_disabled.go

@@ -1,63 +0,0 @@
-//go:build fuzz
-
-// This file is used in fuzzer builds to bypass proposer indices caches.
-package cache
-
-import (
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-var (
-	// ProposerIndicesCacheMiss tracks the number of proposerIndices requests that aren't present in the cache.
-	ProposerIndicesCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "proposer_indices_cache_miss",
-		Help: "The number of proposer indices requests that aren't present in the cache.",
-	})
-	// ProposerIndicesCacheHit tracks the number of proposerIndices requests that are in the cache.
-	ProposerIndicesCacheHit = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "proposer_indices_cache_hit",
-		Help: "The number of proposer indices requests that are present in the cache.",
-	})
-)
-
-// FakeProposerIndicesCache is a struct with 1 queue for looking up proposer indices by root.
-type FakeProposerIndicesCache struct {
-}
-
-// NewProposerIndicesCache creates a new proposer indices cache for storing/accessing proposer index assignments of an epoch.
-func NewProposerIndicesCache() *FakeProposerIndicesCache {
-	return &FakeProposerIndicesCache{}
-}
-
-// ProposerIndices is a stub.
-func (c *FakeProposerIndicesCache) ProposerIndices(_ primitives.Epoch, _ [32]byte) ([fieldparams.SlotsPerEpoch]primitives.ValidatorIndex, bool) {
-	return [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{}, false
-}
-
-// UnsafeProposerIndices is a stub.
-func (c *FakeProposerIndicesCache) UnsafeProposerIndices(_ primitives.Epoch, _ [32]byte) ([fieldparams.SlotsPerEpoch]primitives.ValidatorIndex, bool) {
-	return [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{}, false
-}
-
-// Prune is a stub.
-func (p *FakeProposerIndicesCache) Prune(epoch primitives.Epoch) {}
-
-// Set is a stub.
-func (p *FakeProposerIndicesCache) Set(epoch primitives.Epoch, root [32]byte, indices [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex) {
-}
-
-// SetUnsafe is a stub.
-func (p *FakeProposerIndicesCache) SetUnsafe(epoch primitives.Epoch, root [32]byte, indices [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex) {
-}
-
-// SetCheckpoint is a stub.
-func (p *FakeProposerIndicesCache) SetCheckpoint(c forkchoicetypes.Checkpoint, root [32]byte) {}
-
-// IndicesFromCheckpoint is a stub.
-func (p *FakeProposerIndicesCache) IndicesFromCheckpoint(_ forkchoicetypes.Checkpoint) ([fieldparams.SlotsPerEpoch]primitives.ValidatorIndex, bool) {
-	return [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{}, false
-}

beacon-chain/cache/proposer_indices_test.go

@@ -1,105 +0,0 @@
-//go:build !fuzz
-
-package cache
-
-import (
-	"testing"
-
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestProposerCache_Set(t *testing.T) {
-	cache := NewProposerIndicesCache()
-	bRoot := [32]byte{'A'}
-	indices, ok := cache.ProposerIndices(0, bRoot)
-	require.Equal(t, false, ok)
-	emptyIndices := [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{}
-	require.Equal(t, indices, emptyIndices, "Expected committee count not to exist in empty cache")
-	emptyIndices[0] = 1
-	cache.Set(0, bRoot, emptyIndices)
-
-	received, ok := cache.ProposerIndices(0, bRoot)
-	require.Equal(t, true, ok)
-	require.Equal(t, received, emptyIndices)
-
-	newRoot := [32]byte{'B'}
-	copy(emptyIndices[3:], []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6})
-	cache.Set(0, newRoot, emptyIndices)
-
-	received, ok = cache.ProposerIndices(0, newRoot)
-	require.Equal(t, true, ok)
-	require.Equal(t, emptyIndices, received)
-}
-
-func TestProposerCache_CheckpointAndPrune(t *testing.T) {
-	cache := NewProposerIndicesCache()
-	indices := [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{}
-	copy(indices[3:], []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6})
-	for i := 1; i < 10; i++ {
-		root := [32]byte{byte(i)}
-		cache.Set(primitives.Epoch(i), root, indices)
-		cpRoot := [32]byte{byte(i - 1)}
-		cache.SetCheckpoint(forkchoicetypes.Checkpoint{Epoch: primitives.Epoch(i - 1), Root: cpRoot}, root)
-	}
-	received, ok := cache.ProposerIndices(1, [32]byte{1})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-
-	received, ok = cache.ProposerIndices(4, [32]byte{4})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-
-	received, ok = cache.ProposerIndices(9, [32]byte{9})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-
-	received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-
-	received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{3}})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-
-	received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{Epoch: 4, Root: [32]byte{4}})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-
-	received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{Epoch: 8, Root: [32]byte{8}})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-
-	cache.Prune(5)
-
-	emptyIndices := [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex{}
-	received, ok = cache.ProposerIndices(1, [32]byte{1})
-	require.Equal(t, false, ok)
-	require.Equal(t, emptyIndices, received)
-
-	received, ok = cache.ProposerIndices(4, [32]byte{4})
-	require.Equal(t, false, ok)
-	require.Equal(t, emptyIndices, received)
-
-	received, ok = cache.ProposerIndices(9, [32]byte{9})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-
-	received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{Epoch: 0, Root: [32]byte{0}})
-	require.Equal(t, false, ok)
-	require.Equal(t, emptyIndices, received)
-
-	received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{3}})
-	require.Equal(t, false, ok)
-	require.Equal(t, emptyIndices, received)
-
-	received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{Epoch: 4, Root: [32]byte{4}})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-
-	received, ok = cache.IndicesFromCheckpoint(forkchoicetypes.Checkpoint{Epoch: 8, Root: [32]byte{8}})
-	require.Equal(t, true, ok)
-	require.Equal(t, indices, received)
-}

beacon-chain/cache/proposer_indices_type.go

@@ -1,11 +0,0 @@
-package cache
-
-import (
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-)
-
-// ProposerIndices defines the cached struct for proposer indices.
-type ProposerIndices struct {
-	BlockRoot       [32]byte
-	ProposerIndices []primitives.ValidatorIndex
-}

beacon-chain/core/helpers/BUILD.bazel

@@ -23,7 +23,6 @@ go_library(
     deps = [
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -72,7 +71,6 @@ go_test(
     deps = [
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/fieldparams:go_default_library",

beacon-chain/core/helpers/beacon_committee.go

@@ -10,9 +10,7 @@ import (
 	"github.com/OffchainLabs/go-bitfield"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/container/slice"
@@ -27,8 +25,7 @@ import (
 )
 
 var (
-	committeeCache       = cache.NewCommitteesCache()
-	proposerIndicesCache = cache.NewProposerIndicesCache()
+	committeeCache = cache.NewCommitteesCache()
 )
 
 type beaconCommitteeFunc = func(
@@ -528,75 +525,6 @@ func UpdateCommitteeCache(ctx context.Context, state state.ReadOnlyBeaconState,
 	return nil
 }
 
-// UpdateProposerIndicesInCache updates proposer indices entry of the committee cache.
-// Input state is used to retrieve active validator indices.
-// Input root is to use as key in the cache.
-// Input epoch is the epoch to retrieve proposer indices for.
-func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaconState, epoch primitives.Epoch) error {
-	// The cache uses the state root at the end of (current epoch - 1) as key.
-	// (e.g. for epoch 2, the key is root at slot 63)
-	if epoch <= params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
-		return nil
-	}
-	slot, err := slots.EpochEnd(epoch - 1)
-	if err != nil {
-		return err
-	}
-	root, err := StateRootAtSlot(state, slot)
-	if err != nil {
-		return err
-	}
-	var proposerIndices []primitives.ValidatorIndex
-	// use the state if post fulu (EIP-7917)
-	if state.Version() >= version.Fulu {
-		lookAhead, err := state.ProposerLookahead()
-		if err != nil {
-			return errors.Wrap(err, "could not get proposer lookahead")
-		}
-		proposerIndices = lookAhead[:params.BeaconConfig().SlotsPerEpoch]
-	} else {
-		// Skip cache update if the key already exists
-		_, ok := proposerIndicesCache.ProposerIndices(epoch, [32]byte(root))
-		if ok {
-			return nil
-		}
-		indices, err := ActiveValidatorIndices(ctx, state, epoch)
-		if err != nil {
-			return err
-		}
-		proposerIndices, err = PrecomputeProposerIndices(state, indices, epoch)
-		if err != nil {
-			return err
-		}
-		if len(proposerIndices) != int(params.BeaconConfig().SlotsPerEpoch) {
-			return errors.New("invalid proposer length returned from state")
-		}
-	}
-	// This is here to deal with tests only
-	var indicesArray [fieldparams.SlotsPerEpoch]primitives.ValidatorIndex
-	copy(indicesArray[:], proposerIndices)
-	proposerIndicesCache.Prune(epoch - 2)
-	proposerIndicesCache.Set(epoch, [32]byte(root), indicesArray)
-	return nil
-}
-
-// UpdateCachedCheckpointToStateRoot updates the map from checkpoints to state root in the proposer indices cache
-func UpdateCachedCheckpointToStateRoot(state state.ReadOnlyBeaconState, cp *forkchoicetypes.Checkpoint) error {
-	if cp.Epoch <= params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
-		return nil
-	}
-	slot, err := slots.EpochEnd(cp.Epoch)
-	if err != nil {
-		return err
-	}
-	root, err := state.StateRootAtIndex(uint64(slot % params.BeaconConfig().SlotsPerHistoricalRoot))
-	if err != nil {
-		return err
-	}
-	proposerIndicesCache.SetCheckpoint(*cp, [32]byte(root))
-	return nil
-}
-
 // ExpandCommitteeCache resizes the cache to a higher limit.
 func ExpandCommitteeCache() {
 	committeeCache.ExpandCommitteeCache()
@@ -610,7 +538,6 @@ func CompressCommitteeCache() {
 // ClearCache clears the beacon committee cache and sync committee cache.
 func ClearCache() {
 	committeeCache.Clear()
-	proposerIndicesCache.Prune(0)
 	syncCommitteeCache.Clear()
 	balanceCache.Clear()
 }

beacon-chain/core/helpers/private_access_fuzz_noop_test.go

@@ -11,7 +11,3 @@ func CommitteeCache() *cache.FakeCommitteeCache {
 func SyncCommitteeCache() *cache.FakeSyncCommitteeCache {
 	return syncCommitteeCache
 }
-
-func ProposerIndicesCache() *cache.FakeProposerIndicesCache {
-	return proposerIndicesCache
-}

beacon-chain/core/helpers/private_access_test.go

@@ -11,7 +11,3 @@ func CommitteeCache() *cache.CommitteeCache {
 func SyncCommitteeCache() *cache.SyncCommitteeCache {
 	return syncCommitteeCache
 }
-
-func ProposerIndicesCache() *cache.ProposerIndicesCache {
-	return proposerIndicesCache
-}

beacon-chain/core/helpers/validators.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -273,32 +272,6 @@ func BeaconProposerIndex(ctx context.Context, state state.ReadOnlyBeaconState) (
 	return BeaconProposerIndexAtSlot(ctx, state, state.Slot())
 }
 
-// cachedProposerIndexAtSlot returns the proposer index at the given slot from
-// the cache at the given root key.
-func cachedProposerIndexAtSlot(slot primitives.Slot, root [32]byte) (primitives.ValidatorIndex, error) {
-	proposerIndices, has := proposerIndicesCache.ProposerIndices(slots.ToEpoch(slot), root)
-	if !has {
-		return 0, errProposerIndexMiss
-	}
-	if len(proposerIndices) != int(params.BeaconConfig().SlotsPerEpoch) {
-		return 0, errProposerIndexMiss
-	}
-	return proposerIndices[slot%params.BeaconConfig().SlotsPerEpoch], nil
-}
-
-// ProposerIndexAtSlotFromCheckpoint returns the proposer index at the given
-// slot from the cache at the given checkpoint
-func ProposerIndexAtSlotFromCheckpoint(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, error) {
-	proposerIndices, has := proposerIndicesCache.IndicesFromCheckpoint(*c)
-	if !has {
-		return 0, errProposerIndexMiss
-	}
-	if len(proposerIndices) != int(params.BeaconConfig().SlotsPerEpoch) {
-		return 0, errProposerIndexMiss
-	}
-	return proposerIndices[slot%params.BeaconConfig().SlotsPerEpoch], nil
-}
-
 func beaconProposerIndexAtSlotFulu(state state.ReadOnlyBeaconState, slot primitives.Slot) (primitives.ValidatorIndex, error) {
 	e := slots.ToEpoch(slot)
 	stateEpoch := slots.ToEpoch(state.Slot())
@@ -329,32 +302,6 @@ func BeaconProposerIndexAtSlot(ctx context.Context, state state.ReadOnlyBeaconSt
 			return beaconProposerIndexAtSlotFulu(state, slot)
 		}
 	}
-	// The cache uses the state root of the previous epoch - minimum_seed_lookahead last slot as key. (e.g. Starting epoch 1, slot 32, the key would be block root at slot 31)
-	// For simplicity, the node will skip caching of genesis epoch. If the passed state has not yet reached this slot then we do not check the cache.
-	if e <= stateEpoch && e > params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
-		s, err := slots.EpochEnd(e - 1)
-		if err != nil {
-			return 0, err
-		}
-		r, err := StateRootAtSlot(state, s)
-		if err != nil {
-			return 0, err
-		}
-		if r != nil && !bytes.Equal(r, params.BeaconConfig().ZeroHash[:]) {
-			pid, err := cachedProposerIndexAtSlot(slot, [32]byte(r))
-			if err == nil {
-				return pid, nil
-			}
-			if err := UpdateProposerIndicesInCache(ctx, state, e); err != nil {
-				return 0, errors.Wrap(err, "could not update proposer index cache")
-			}
-			pid, err = cachedProposerIndexAtSlot(slot, [32]byte(r))
-			if err == nil {
-				return pid, nil
-			}
-		}
-	}
-
 	seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconProposer)
 	if err != nil {
 		return 0, errors.Wrap(err, "could not generate seed")

beacon-chain/core/helpers/validators_test.go

@@ -7,7 +7,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -878,23 +877,6 @@ func TestLastActivatedValidatorIndex_OK(t *testing.T) {
 	require.Equal(t, index, primitives.ValidatorIndex(3))
 }
 
-func TestProposerIndexFromCheckpoint(t *testing.T) {
-	helpers.ClearCache()
-
-	e := primitives.Epoch(2)
-	r := [32]byte{'a'}
-	root := [32]byte{'b'}
-	ids := [32]primitives.ValidatorIndex{}
-	slot := primitives.Slot(69) // slot 5 in the Epoch
-	ids[5] = primitives.ValidatorIndex(19)
-	helpers.ProposerIndicesCache().Set(e, r, ids)
-	c := &forkchoicetypes.Checkpoint{Root: root, Epoch: e - 1}
-	helpers.ProposerIndicesCache().SetCheckpoint(*c, r)
-	id, err := helpers.ProposerIndexAtSlotFromCheckpoint(c, slot)
-	require.NoError(t, err)
-	require.Equal(t, ids[5], id)
-}
-
 func TestHasETH1WithdrawalCredentials(t *testing.T) {
 	creds := []byte{0xFA, 0xCC}
 	v := &ethpb.Validator{WithdrawalCredentials: creds}

beacon-chain/verification/blob.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
@@ -289,27 +288,15 @@ func (bv *ROBlobVerifier) SidecarKzgProofVerified() (err error) {
 // for later processing while proposers for the block's branch are calculated -- in such a case do not REJECT, instead IGNORE this message.
 func (bv *ROBlobVerifier) SidecarProposerExpected(ctx context.Context) (err error) {
 	defer bv.recordResult(RequireSidecarProposerExpected, &err)
-	e := slots.ToEpoch(bv.blob.Slot())
-	if e > 0 {
-		e = e - 1
-	}
-	r, err := bv.fc.TargetRootForEpoch(bv.blob.ParentRoot(), e)
+	pst, err := bv.parentState(ctx)
 	if err != nil {
+		log.WithError(err).WithFields(logging.BlobFields(bv.blob)).Debug("State replay to parent_root failed")
 		return errSidecarUnexpectedProposer
 	}
-	c := &forkchoicetypes.Checkpoint{Root: r, Epoch: e}
-	idx, cached := bv.pc.Proposer(c, bv.blob.Slot())
-	if !cached {
-		pst, err := bv.parentState(ctx)
-		if err != nil {
-			log.WithError(err).WithFields(logging.BlobFields(bv.blob)).Debug("State replay to parent_root failed")
-			return errSidecarUnexpectedProposer
-		}
-		idx, err = bv.pc.ComputeProposer(ctx, bv.blob.ParentRoot(), bv.blob.Slot(), pst)
-		if err != nil {
-			log.WithError(err).WithFields(logging.BlobFields(bv.blob)).Debug("Error computing proposer index from parent state")
-			return errSidecarUnexpectedProposer
-		}
+	idx, err := bv.pc.ComputeProposer(ctx, bv.blob.Slot(), pst)
+	if err != nil {
+		log.WithError(err).WithFields(logging.BlobFields(bv.blob)).Debug("Error computing proposer index from parent state")
+		return errSidecarUnexpectedProposer
 	}
 	if idx != bv.blob.ProposerIndex() {
 		log.WithError(errSidecarUnexpectedProposer).

beacon-chain/verification/blob_test.go

@@ -452,33 +452,17 @@ func TestSidecarProposerExpected(t *testing.T) {
 	ctx := t.Context()
 	_, blobs := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, 1)
 	b := blobs[0]
-	t.Run("cached, matches", func(t *testing.T) {
-		ini := Initializer{shared: &sharedResources{pc: &mockProposerCache{ProposerCB: pcReturnsIdx(b.ProposerIndex())}, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
-		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
-		require.NoError(t, v.SidecarProposerExpected(ctx))
-		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
-		require.NoError(t, v.results.result(RequireSidecarProposerExpected))
-	})
-	t.Run("cached, does not match", func(t *testing.T) {
-		ini := Initializer{shared: &sharedResources{pc: &mockProposerCache{ProposerCB: pcReturnsIdx(b.ProposerIndex() + 1)}, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
-		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
-		require.ErrorIs(t, v.SidecarProposerExpected(ctx), errSidecarUnexpectedProposer)
-		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
-		require.NotNil(t, v.results.result(RequireSidecarProposerExpected))
-	})
-	t.Run("not cached, state lookup failure", func(t *testing.T) {
-		ini := Initializer{shared: &sharedResources{sr: sbrNotFound(t, b.ParentRoot()), pc: &mockProposerCache{ProposerCB: pcReturnsNotFound()}, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
+	t.Run("state lookup failure", func(t *testing.T) {
+		ini := Initializer{shared: &sharedResources{sr: sbrNotFound(t, b.ParentRoot()), pc: &mockProposerCache{}, fc: &mockForkchoicer{TargetRootForEpochCB: fcReturnsTargetRoot([32]byte{})}}}
 		v := ini.NewBlobVerifier(b, GossipBlobSidecarRequirements)
 		require.ErrorIs(t, v.SidecarProposerExpected(ctx), errSidecarUnexpectedProposer)
 		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
 		require.NotNil(t, v.results.result(RequireSidecarProposerExpected))
 	})
 
-	t.Run("not cached, proposer matches", func(t *testing.T) {
+	t.Run("proposer matches", func(t *testing.T) {
 		pc := &mockProposerCache{
-			ProposerCB: pcReturnsNotFound(),
-			ComputeProposerCB: func(_ context.Context, root [32]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
-				require.Equal(t, b.ParentRoot(), root)
+			ComputeProposerCB: func(_ context.Context, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
 				require.Equal(t, b.Slot(), slot)
 				return b.ProposerIndex(), nil
 			},
@@ -489,11 +473,9 @@ func TestSidecarProposerExpected(t *testing.T) {
 		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
 		require.NoError(t, v.results.result(RequireSidecarProposerExpected))
 	})
-	t.Run("not cached, proposer does not match", func(t *testing.T) {
+	t.Run("proposer does not match", func(t *testing.T) {
 		pc := &mockProposerCache{
-			ProposerCB: pcReturnsNotFound(),
-			ComputeProposerCB: func(_ context.Context, root [32]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
-				require.Equal(t, b.ParentRoot(), root)
+			ComputeProposerCB: func(_ context.Context, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
 				require.Equal(t, b.Slot(), slot)
 				return b.ProposerIndex() + 1, nil
 			},
@@ -504,11 +486,9 @@ func TestSidecarProposerExpected(t *testing.T) {
 		require.Equal(t, true, v.results.executed(RequireSidecarProposerExpected))
 		require.NotNil(t, v.results.result(RequireSidecarProposerExpected))
 	})
-	t.Run("not cached, ComputeProposer fails", func(t *testing.T) {
+	t.Run("ComputeProposer fails", func(t *testing.T) {
 		pc := &mockProposerCache{
-			ProposerCB: pcReturnsNotFound(),
-			ComputeProposerCB: func(_ context.Context, root [32]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
-				require.Equal(t, b.ParentRoot(), root)
+			ComputeProposerCB: func(_ context.Context, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
 				require.Equal(t, b.Slot(), slot)
 				return 0, errors.New("ComputeProposer failed")
 			},
@@ -845,28 +825,11 @@ func (v *validxStateOverride) ReadFromEveryValidator(f func(idx int, val state.R
 }
 
 type mockProposerCache struct {
-	ComputeProposerCB func(ctx context.Context, root [32]byte, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error)
-	ProposerCB        func(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, bool)
+	ComputeProposerCB func(ctx context.Context, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error)
 }
 
-func (p *mockProposerCache) ComputeProposer(ctx context.Context, root [32]byte, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error) {
-	return p.ComputeProposerCB(ctx, root, slot, pst)
-}
-
-func (p *mockProposerCache) Proposer(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, bool) {
-	return p.ProposerCB(c, slot)
+func (p *mockProposerCache) ComputeProposer(ctx context.Context, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error) {
+	return p.ComputeProposerCB(ctx, slot, pst)
 }
 
 var _ proposerCache = &mockProposerCache{}
-
-func pcReturnsIdx(idx primitives.ValidatorIndex) func(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, bool) {
-	return func(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, bool) {
-		return idx, true
-	}
-}
-
-func pcReturnsNotFound() func(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, bool) {
-	return func(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, bool) {
-		return 0, false
-	}
-}

beacon-chain/verification/cache.go

@@ -7,7 +7,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	lruwrpr "github.com/OffchainLabs/prysm/v7/cache/lru"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -16,6 +15,7 @@ import (
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	lru "github.com/hashicorp/golang-lru"
+	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
@@ -152,8 +152,7 @@ func (c *sigCache) SignatureVerified(sig signatureData) (bool, error) {
 // and cache the result so that it can be reused when the same verification needs to be performed
 // across multiple values.
 type proposerCache interface {
-	ComputeProposer(ctx context.Context, root [32]byte, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error)
-	Proposer(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, bool)
+	ComputeProposer(ctx context.Context, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error)
 }
 
 func newPropCache() *propCache {
@@ -163,26 +162,20 @@ func newPropCache() *propCache {
 type propCache struct {
 }
 
-// ComputeProposer takes the state for the given parent root and slot and computes the proposer index, updating the
-// proposer index cache when successful.
-func (*propCache) ComputeProposer(ctx context.Context, parent [32]byte, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error) {
-	pst, err := transition.ProcessSlotsUsingNextSlotCache(ctx, pst, parent[:], slot)
-	if err != nil {
-		return 0, err
+// ComputeProposer takes the state and computes the proposer index at the given slot
+func (*propCache) ComputeProposer(ctx context.Context, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error) {
+	// After Fulu, the lookahead only contains proposers for the current and next epoch.
+	stateEpoch := slots.ToEpoch(pst.Slot())
+	slotEpoch := slots.ToEpoch(slot)
+	if slotEpoch > stateEpoch+1 {
+		start, err := slots.EpochStart(slotEpoch - 1)
+		if err != nil {
+			return 0, err
+		}
+		pst, err = transition.ProcessSlots(ctx, pst, start)
+		if err != nil {
+			return 0, errors.Wrap(err, "failed to advance state to compute proposer")
+		}
 	}
-	idx, err := helpers.BeaconProposerIndex(ctx, pst)
-	if err != nil {
-		return 0, err
-	}
-	return idx, nil
-}
-
-// Proposer returns the validator index if it is found in the cache, along with a boolean indicating
-// whether the value was present, similar to accessing an lru or go map.
-func (*propCache) Proposer(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, bool) {
-	id, err := helpers.ProposerIndexAtSlotFromCheckpoint(c, slot)
-	if err != nil {
-		return 0, false
-	}
-	return id, true
+	return helpers.BeaconProposerIndexAtSlot(ctx, pst, slot)
 }

beacon-chain/verification/cache_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/crypto/bls"
@@ -107,25 +106,3 @@ func (m *mockValidatorAtIndexer) ValidatorAtIndex(idx primitives.ValidatorIndex)
 }
 
 var _ validatorAtIndexer = &mockValidatorAtIndexer{}
-
-func TestProposerCache(t *testing.T) {
-	ctx := t.Context()
-	// 3 validators because that was the first number that produced a non-zero proposer index by default
-	st, _ := util.DeterministicGenesisStateDeneb(t, 3)
-
-	pc := newPropCache()
-	_, cached := pc.Proposer(&forkchoicetypes.Checkpoint{}, 1)
-	// should not be cached yet
-	require.Equal(t, false, cached)
-
-	// If this test breaks due to changes in the deterministic state gen, just replace '2' with whatever the right index is.
-	expectedIdx := 2
-	idx, err := pc.ComputeProposer(ctx, [32]byte{}, 1, st)
-	require.NoError(t, err)
-	require.Equal(t, primitives.ValidatorIndex(expectedIdx), idx)
-
-	idx, cached = pc.Proposer(&forkchoicetypes.Checkpoint{}, 1)
-	// TODO: update this test when we integrate a proposer id cache
-	require.Equal(t, false, cached)
-	require.Equal(t, primitives.ValidatorIndex(0), idx)
-}

beacon-chain/verification/data_column.go

@@ -11,7 +11,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
-	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -484,38 +483,6 @@ func (dv *RODataColumnsVerifier) SidecarProposerExpected(ctx context.Context) (e
 
 	defer dv.recordResult(RequireSidecarProposerExpected, &err)
 
-	type slotParentRoot struct {
-		slot       primitives.Slot
-		parentRoot [fieldparams.RootLength]byte
-	}
-
-	targetRootBySlotParentRoot := make(map[slotParentRoot][fieldparams.RootLength]byte)
-
-	var targetRootFromCache = func(slot primitives.Slot, parentRoot [fieldparams.RootLength]byte) ([fieldparams.RootLength]byte, error) {
-		// Use cached values if available.
-		slotParentRoot := slotParentRoot{slot: slot, parentRoot: parentRoot}
-		if root, ok := targetRootBySlotParentRoot[slotParentRoot]; ok {
-			return root, nil
-		}
-
-		// Compute the epoch of the data column slot.
-		dataColumnEpoch := slots.ToEpoch(slot)
-		if dataColumnEpoch > 0 {
-			dataColumnEpoch = dataColumnEpoch - 1
-		}
-
-		// Compute the target root for the epoch.
-		targetRoot, err := dv.fc.TargetRootForEpoch(parentRoot, dataColumnEpoch)
-		if err != nil {
-			return [fieldparams.RootLength]byte{}, columnErrBuilder(errors.Wrap(err, "target root from epoch"))
-		}
-
-		// Store the target root in the cache.
-		targetRootBySlotParentRoot[slotParentRoot] = targetRoot
-
-		return targetRoot, nil
-	}
-
 	for _, dataColumn := range dv.dataColumns {
 		// Extract the slot of the data column.
 		dataColumnSlot := dataColumn.Slot()
@@ -523,56 +490,33 @@ func (dv *RODataColumnsVerifier) SidecarProposerExpected(ctx context.Context) (e
 		// Extract the root of the parent block corresponding to the data column.
 		parentRoot := dataColumn.ParentRoot()
 
-		// Compute the target root for the data column.
-		targetRoot, err := targetRootFromCache(dataColumnSlot, parentRoot)
-		if err != nil {
-			return columnErrBuilder(errors.Wrap(err, "target root"))
-		}
-
-		// Compute the epoch of the data column slot.
-		dataColumnEpoch := slots.ToEpoch(dataColumnSlot)
-		if dataColumnEpoch > 0 {
-			dataColumnEpoch = dataColumnEpoch - 1
-		}
-
-		// Create a checkpoint for the target root.
-		checkpoint := &forkchoicetypes.Checkpoint{Root: targetRoot, Epoch: dataColumnEpoch}
-
-		// Try to extract the proposer index from the data column in the cache.
-		idx, cached := dv.pc.Proposer(checkpoint, dataColumnSlot)
-
-		if !cached {
-			parentRoot := dataColumn.ParentRoot()
-			// Ensure the expensive index computation is only performed once for
-			// concurrent requests for the same signature data.
-			idxAny, err, _ := dv.sg.Do(concatRootSlot(parentRoot, dataColumnSlot), func() (any, error) {
-				verifyingState, err := dv.getVerifyingState(ctx, dataColumn)
-				if err != nil {
-					return nil, columnErrBuilder(errors.Wrap(err, "verifying state"))
-				}
-
-				idx, err = helpers.BeaconProposerIndexAtSlot(ctx, verifyingState, dataColumnSlot)
-				if err != nil {
-					return nil, columnErrBuilder(errors.Wrap(err, "compute proposer"))
-				}
-
-				return idx, nil
-			})
+		// Ensure the expensive index computation is only performed once for
+		// concurrent requests for the same signature data.
+		idxAny, err, _ := dv.sg.Do(concatRootSlot(parentRoot, dataColumnSlot), func() (any, error) {
+			verifyingState, err := dv.getVerifyingState(ctx, dataColumn)
 			if err != nil {
-				return err
+				return nil, columnErrBuilder(errors.Wrap(err, "verifying state"))
 			}
 
-			var ok bool
-			if idx, ok = idxAny.(primitives.ValidatorIndex); !ok {
-				return columnErrBuilder(errors.New("type assertion to ValidatorIndex failed"))
+			idx, err := helpers.BeaconProposerIndexAtSlot(ctx, verifyingState, dataColumnSlot)
+			if err != nil {
+				return nil, columnErrBuilder(errors.Wrap(err, "compute proposer"))
 			}
+
+			return idx, nil
+		})
+		if err != nil {
+			return err
 		}
 
+		idx, ok := idxAny.(primitives.ValidatorIndex)
+		if !ok {
+			return columnErrBuilder(errors.New("type assertion to ValidatorIndex failed"))
+		}
 		if idx != dataColumn.ProposerIndex() {
 			return columnErrBuilder(errSidecarUnexpectedProposer)
 		}
 	}
-
 	return nil
 }
 

beacon-chain/verification/data_column_test.go

@@ -799,35 +799,20 @@ func TestDataColumnsSidecarProposerExpected(t *testing.T) {
 	columns := GenerateTestDataColumns(t, parentRoot, columnSlot, blobCount)
 	firstColumn := columns[0]
 	ctx := t.Context()
+
 	testCases := []struct {
-		name          string
-		stateByRooter StateByRooter
-		proposerCache proposerCache
-		columns       []blocks.RODataColumn
-		error         string
+		name              string
+		stateByRooter     StateByRooter
+		headStateProvider *mockHeadStateProvider
+		columns           []blocks.RODataColumn
+		error             string
 	}{
 		{
-			name:          "Cached, matches",
-			stateByRooter: nil,
-			proposerCache: &mockProposerCache{
-				ProposerCB: pcReturnsIdx(firstColumn.ProposerIndex()),
-			},
-			columns: columns,
-		},
-		{
-			name:          "Cached, does not match",
-			stateByRooter: nil,
-			proposerCache: &mockProposerCache{
-				ProposerCB: pcReturnsIdx(firstColumn.ProposerIndex() + 1),
-			},
-			columns: columns,
-			error:   errSidecarUnexpectedProposer.Error(),
-		},
-		{
-			name:          "Not cached, state lookup failure",
+			name:          "state lookup failure",
 			stateByRooter: sbrNotFound(t, firstColumn.ParentRoot()),
-			proposerCache: &mockProposerCache{
-				ProposerCB: pcReturnsNotFound(),
+			headStateProvider: &mockHeadStateProvider{
+				headRoot: []byte{0xff}, // Different from parentRoot so it won't use head
+				headSlot: 1000,
 			},
 			columns: columns,
 			error:   "verifying state",
@@ -839,8 +824,7 @@ func TestDataColumnsSidecarProposerExpected(t *testing.T) {
 			initializer := Initializer{
 				shared: &sharedResources{
 					sr:  tc.stateByRooter,
-					pc:  tc.proposerCache,
-					hsp: &mockHeadStateProvider{},
+					hsp: tc.headStateProvider,
 					fc: &mockForkchoicer{
 						TargetRootForEpochCB: fcReturnsTargetRoot([fieldparams.RootLength]byte{}),
 					},

changelog/potuz_remove_proposer_cache.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Removed proposer id cache.