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
 }
 
@@ -460,9 +437,6 @@ func (s *Service) pruneAttsFromPool(ctx context.Context, headState state.BeaconS
 func (s *Service) pruneCoveredAttsFromPool(ctx context.Context, headState state.BeaconState, att ethpb.Att) error {
 	switch {
 	case !att.IsAggregated():
-		if features.Get().EnableExperimentalAttestationPool {
-			return errors.Wrap(s.cfg.AttestationCache.DeleteCovered(att), "could not delete covered attestation")
-		}
 		return s.cfg.AttPool.DeleteUnaggregatedAttestation(att)
 	case att.Version() == version.Phase0:
 		if features.Get().EnableExperimentalAttestationPool {
@@ -531,12 +505,12 @@ func (s *Service) pruneCoveredElectraAttsFromPool(ctx context.Context, headState
 			if err = s.cfg.AttestationCache.DeleteCovered(a); err != nil {
 				return errors.Wrap(err, "could not delete covered attestation")
 			}
-		} else if a.IsAggregated() {
-			if err = s.cfg.AttPool.DeleteAggregatedAttestation(a); err != nil {
-				return errors.Wrap(err, "could not delete aggregated attestation")
+		} else if !a.IsAggregated() {
+			if err = s.cfg.AttPool.DeleteUnaggregatedAttestation(a); err != nil {
+				return errors.Wrap(err, "could not delete unaggregated attestation")
 			}
-		} else if err = s.cfg.AttPool.DeleteUnaggregatedAttestation(a); err != nil {
-			return errors.Wrap(err, "could not delete unaggregated attestation")
+		} else if err = s.cfg.AttPool.DeleteAggregatedAttestation(a); err != nil {
+			return errors.Wrap(err, "could not delete aggregated attestation")
 		}
 
 		offset += uint64(len(c))

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/attestation.go

@@ -76,22 +76,13 @@ func (c *AttestationCache) Add(att ethpb.Att) error {
 	if group == nil {
 		group = &attGroup{
 			slot: att.GetData().Slot,
-			atts: []ethpb.Att{att.Clone()},
+			atts: []ethpb.Att{att},
 		}
 		c.atts[id] = group
 		return nil
 	}
 
 	if att.IsAggregated() {
-		// Ensure that this attestation is not already fully contained in an existing attestation.
-		for _, a := range group.atts {
-			if c, err := a.GetAggregationBits().Contains(att.GetAggregationBits()); err != nil {
-				return err
-			} else if c {
-				return nil
-			}
-		}
-
 		group.atts = append(group.atts, att.Clone())
 		return nil
 	}

beacon-chain/cache/attestation_test.go

@@ -151,32 +151,6 @@ func TestAdd(t *testing.T) {
 		require.Equal(t, 1, len(group.atts))
 		assert.DeepEqual(t, []int{0, 1}, group.atts[0].GetAggregationBits().BitIndices())
 	})
-	t.Run("added attestation is copied", func(t *testing.T) {
-		// We want to make sure that the running aggregate is based on a copy of the original attestation,
-		// to avoid mutating the original attestation.
-
-		c := NewAttestationCache()
-		ab := bitfield.NewBitlist(8)
-		ab.SetBitAt(0, true)
-		original := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: ab,
-			Signature:       sig.Marshal(),
-		}
-		require.NoError(t, c.Add(original))
-
-		ab = bitfield.NewBitlist(8)
-		ab.SetBitAt(1, true)
-		a := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: ab,
-			Signature:       sig.Marshal(),
-		}
-		require.NoError(t, c.Add(a))
-
-		// Assert that the bit of the second attestation was not added to the original attestation.
-		assert.Equal(t, uint64(1), original.AggregationBits.Count())
-	})
 }
 
 func TestGetAll(t *testing.T) {

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/core/peerdas/metrics.go

@@ -5,20 +5,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 )
 
-var (
-	dataColumnComputationTime = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "beacon_data_column_sidecar_computation_milliseconds",
-			Help:    "Captures the time taken to compute data column sidecars from blobs.",
-			Buckets: []float64{25, 50, 100, 250, 500, 750, 1000},
-		},
-	)
-
-	cellsAndProofsFromStructuredComputationTime = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "cells_and_proofs_from_structured_computation_milliseconds",
-			Help:    "Captures the time taken to compute cells and proofs from structured computation.",
-			Buckets: []float64{10, 20, 30, 40, 50, 100, 200},
-		},
-	)
+var dataColumnComputationTime = promauto.NewHistogram(
+	prometheus.HistogramOpts{
+		Name:    "beacon_data_column_sidecar_computation_milliseconds",
+		Help:    "Captures the time taken to compute data column sidecars from blobs.",
+		Buckets: []float64{25, 50, 100, 250, 500, 750, 1000},
+	},
 )

beacon-chain/core/peerdas/reconstruction.go

@@ -3,7 +3,6 @@ package peerdas
 import (
 	"sort"
 	"sync"
-	"time"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -297,42 +296,32 @@ func ComputeCellsAndProofsFromFlat(blobs [][]byte, cellProofs [][]byte) ([][]kzg
 		return nil, nil, ErrBlobsCellsProofsMismatch
 	}
 
-	var wg errgroup.Group
-
-	cellsPerBlob := make([][]kzg.Cell, blobCount)
-	proofsPerBlob := make([][]kzg.Proof, blobCount)
-
+	cellsPerBlob := make([][]kzg.Cell, 0, blobCount)
+	proofsPerBlob := make([][]kzg.Proof, 0, blobCount)
 	for i, blob := range blobs {
-		wg.Go(func() error {
-			var kzgBlob kzg.Blob
-			if copy(kzgBlob[:], blob) != len(kzgBlob) {
-				return errors.New("wrong blob size - should never happen")
+		var kzgBlob kzg.Blob
+		if copy(kzgBlob[:], blob) != len(kzgBlob) {
+			return nil, nil, errors.New("wrong blob size - should never happen")
+		}
+
+		// Compute the extended cells from the (non-extended) blob.
+		cells, err := kzg.ComputeCells(&kzgBlob)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "compute cells")
+		}
+
+		var proofs []kzg.Proof
+		for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
+			var kzgProof kzg.Proof
+			if copy(kzgProof[:], cellProofs[idx]) != len(kzgProof) {
+				return nil, nil, errors.New("wrong KZG proof size - should never happen")
 			}
 
-			// Compute the extended cells from the (non-extended) blob.
-			cells, err := kzg.ComputeCells(&kzgBlob)
-			if err != nil {
-				return errors.Wrap(err, "compute cells")
-			}
+			proofs = append(proofs, kzgProof)
+		}
 
-			proofs := make([]kzg.Proof, 0, numberOfColumns)
-			for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
-				var kzgProof kzg.Proof
-				if copy(kzgProof[:], cellProofs[idx]) != len(kzgProof) {
-					return errors.New("wrong KZG proof size - should never happen")
-				}
-
-				proofs = append(proofs, kzgProof)
-			}
-
-			cellsPerBlob[i] = cells
-			proofsPerBlob[i] = proofs
-			return nil
-		})
-	}
-
-	if err := wg.Wait(); err != nil {
-		return nil, nil, err
+		cellsPerBlob = append(cellsPerBlob, cells)
+		proofsPerBlob = append(proofsPerBlob, proofs)
 	}
 
 	return cellsPerBlob, proofsPerBlob, nil
@@ -340,55 +329,40 @@ func ComputeCellsAndProofsFromFlat(blobs [][]byte, cellProofs [][]byte) ([][]kzg
 
 // ComputeCellsAndProofsFromStructured computes the cells and proofs from blobs and cell proofs.
 func ComputeCellsAndProofsFromStructured(blobsAndProofs []*pb.BlobAndProofV2) ([][]kzg.Cell, [][]kzg.Proof, error) {
-	start := time.Now()
-	defer func() {
-		cellsAndProofsFromStructuredComputationTime.Observe(float64(time.Since(start).Milliseconds()))
-	}()
-
-	var wg errgroup.Group
-
-	cellsPerBlob := make([][]kzg.Cell, len(blobsAndProofs))
-	proofsPerBlob := make([][]kzg.Proof, len(blobsAndProofs))
-
-	for i, blobAndProof := range blobsAndProofs {
+	cellsPerBlob := make([][]kzg.Cell, 0, len(blobsAndProofs))
+	proofsPerBlob := make([][]kzg.Proof, 0, len(blobsAndProofs))
+	for _, blobAndProof := range blobsAndProofs {
 		if blobAndProof == nil {
 			return nil, nil, ErrNilBlobAndProof
 		}
 
-		wg.Go(func() error {
-			var kzgBlob kzg.Blob
-			if copy(kzgBlob[:], blobAndProof.Blob) != len(kzgBlob) {
-				return errors.New("wrong blob size - should never happen")
+		var kzgBlob kzg.Blob
+		if copy(kzgBlob[:], blobAndProof.Blob) != len(kzgBlob) {
+			return nil, nil, errors.New("wrong blob size - should never happen")
+		}
+
+		// Compute the extended cells from the (non-extended) blob.
+		cells, err := kzg.ComputeCells(&kzgBlob)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "compute cells")
+		}
+
+		kzgProofs := make([]kzg.Proof, 0, fieldparams.NumberOfColumns)
+		for _, kzgProofBytes := range blobAndProof.KzgProofs {
+			if len(kzgProofBytes) != kzg.BytesPerProof {
+				return nil, nil, errors.New("wrong KZG proof size - should never happen")
 			}
 
-			// Compute the extended cells from the (non-extended) blob.
-			cells, err := kzg.ComputeCells(&kzgBlob)
-			if err != nil {
-				return errors.Wrap(err, "compute cells")
+			var kzgProof kzg.Proof
+			if copy(kzgProof[:], kzgProofBytes) != len(kzgProof) {
+				return nil, nil, errors.New("wrong copied KZG proof size - should never happen")
 			}
 
-			kzgProofs := make([]kzg.Proof, 0, fieldparams.NumberOfColumns)
-			for _, kzgProofBytes := range blobAndProof.KzgProofs {
-				if len(kzgProofBytes) != kzg.BytesPerProof {
-					return errors.New("wrong KZG proof size - should never happen")
-				}
+			kzgProofs = append(kzgProofs, kzgProof)
+		}
 
-				var kzgProof kzg.Proof
-				if copy(kzgProof[:], kzgProofBytes) != len(kzgProof) {
-					return errors.New("wrong copied KZG proof size - should never happen")
-				}
-
-				kzgProofs = append(kzgProofs, kzgProof)
-			}
-
-			cellsPerBlob[i] = cells
-			proofsPerBlob[i] = kzgProofs
-			return nil
-		})
-	}
-
-	if err := wg.Wait(); err != nil {
-		return nil, nil, err
+		cellsPerBlob = append(cellsPerBlob, cells)
+		proofsPerBlob = append(proofsPerBlob, kzgProofs)
 	}
 
 	return cellsPerBlob, proofsPerBlob, nil

beacon-chain/db/filesystem/data_column.go

@@ -515,11 +515,6 @@ func (dcs *DataColumnStorage) Clear() error {
 
 // prune clean the cache, the filesystem and mutexes.
 func (dcs *DataColumnStorage) prune() {
-	startTime := time.Now()
-	defer func() {
-		dataColumnPruneLatency.Observe(float64(time.Since(startTime).Milliseconds()))
-	}()
-
 	highestStoredEpoch := dcs.cache.HighestEpoch()
 
 	// Check if we need to prune.
@@ -627,9 +622,6 @@ func (dcs *DataColumnStorage) saveDataColumnSidecarsExistingFile(filePath string
 	// Create the SSZ encoded data column sidecars.
 	var sszEncodedDataColumnSidecars []byte
 
-	// Initialize the count of the saved SSZ encoded data column sidecar.
-	storedCount := uint8(0)
-
 	for {
 		dataColumnSidecars := pullChan(inputDataColumnSidecars)
 		if len(dataColumnSidecars) == 0 {
@@ -676,9 +668,6 @@ func (dcs *DataColumnStorage) saveDataColumnSidecarsExistingFile(filePath string
 				return errors.Wrap(err, "set index")
 			}
 
-			// Increment the count of the saved SSZ encoded data column sidecar.
-			storedCount++
-
 			// Append the SSZ encoded data column sidecar to the SSZ encoded data column sidecars.
 			sszEncodedDataColumnSidecars = append(sszEncodedDataColumnSidecars, sszEncodedDataColumnSidecar...)
 		}
@@ -703,12 +692,9 @@ func (dcs *DataColumnStorage) saveDataColumnSidecarsExistingFile(filePath string
 		return errWrongBytesWritten
 	}
 
-	syncStart := time.Now()
 	if err := file.Sync(); err != nil {
 		return errors.Wrap(err, "sync")
 	}
-	dataColumnFileSyncLatency.Observe(float64(time.Since(syncStart).Milliseconds()))
-	dataColumnBatchStoreCount.Observe(float64(storedCount))
 
 	return nil
 }
@@ -822,14 +808,10 @@ func (dcs *DataColumnStorage) saveDataColumnSidecarsNewFile(filePath string, inp
 		return errWrongBytesWritten
 	}
 
-	syncStart := time.Now()
 	if err := file.Sync(); err != nil {
 		return errors.Wrap(err, "sync")
 	}
 
-	dataColumnFileSyncLatency.Observe(float64(time.Since(syncStart).Milliseconds()))
-	dataColumnBatchStoreCount.Observe(float64(storedCount))
-
 	return nil
 }
 

beacon-chain/db/filesystem/metrics.go

@@ -36,15 +36,16 @@ var (
 	})
 
 	// Data columns
+	dataColumnBuckets     = []float64{3, 5, 7, 9, 11, 13}
 	dataColumnSaveLatency = promauto.NewHistogram(prometheus.HistogramOpts{
 		Name:    "data_column_storage_save_latency",
 		Help:    "Latency of DataColumnSidecar storage save operations in milliseconds",
-		Buckets: []float64{10, 20, 30, 50, 100, 200, 500},
+		Buckets: dataColumnBuckets,
 	})
 	dataColumnFetchLatency = promauto.NewHistogram(prometheus.HistogramOpts{
 		Name:    "data_column_storage_get_latency",
 		Help:    "Latency of DataColumnSidecar storage get operations in milliseconds",
-		Buckets: []float64{3, 5, 7, 9, 11, 13},
+		Buckets: dataColumnBuckets,
 	})
 	dataColumnPrunedCounter = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "data_column_pruned",
@@ -58,16 +59,4 @@ var (
 		Name: "data_column_disk_count",
 		Help: "Approximate number of data columns in storage",
 	})
-	dataColumnFileSyncLatency = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "data_column_file_sync_latency",
-		Help: "Latency of sync operations when saving data columns in milliseconds",
-	})
-	dataColumnBatchStoreCount = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "data_column_batch_store_count",
-		Help: "Number of data columns stored in a batch",
-	})
-	dataColumnPruneLatency = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "data_column_prune_latency",
-		Help: "Latency of data column prune operations in milliseconds",
-	})
 )

beacon-chain/execution/engine_client.go

@@ -532,19 +532,12 @@ func (s *Service) GetBlobsV2(ctx context.Context, versionedHashes []common.Hash)
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetBlobsV2")
 	defer span.End()
 
-	start := time.Now()
-
 	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)
-
-	if len(result) != 0 {
-		getBlobsV2Latency.Observe(float64(time.Since(start).Milliseconds()))
-	}
-
 	return result, handleRPCError(err)
 }
 

beacon-chain/execution/metrics.go

@@ -27,13 +27,6 @@ var (
 			Buckets: []float64{25, 50, 100, 200, 500, 1000, 2000, 4000},
 		},
 	)
-	getBlobsV2Latency = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "get_blobs_v2_latency_milliseconds",
-			Help:    "Captures RPC latency for getBlobsV2 in milliseconds",
-			Buckets: []float64{25, 50, 100, 200, 500, 1000, 2000, 4000},
-		},
-	)
 	errParseCount = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "execution_parse_error_count",
 		Help: "The number of errors that occurred while parsing execution payload",

beacon-chain/operations/attestations/prepare_forkchoice.go

@@ -120,9 +120,6 @@ func (s *Service) aggregateAndSaveForkChoiceAtts(atts []ethpb.Att) error {
 		return err
 	}
 
-	if features.Get().EnableExperimentalAttestationPool {
-		return s.cfg.Cache.SaveForkchoiceAttestations(aggregatedAtts)
-	}
 	return s.cfg.Pool.SaveForkchoiceAttestations(aggregatedAtts)
 }
 

beacon-chain/operations/attestations/prune_expired.go

@@ -20,7 +20,7 @@ func (s *Service) pruneExpired() {
 			s.pruneExpiredAtts()
 			s.updateMetrics()
 		case <-s.ctx.Done():
-			log.Debug("Context closed, exiting att pruning routine")
+			log.Debug("Context closed, exiting routine")
 			return
 		}
 	}
@@ -28,13 +28,11 @@ func (s *Service) pruneExpired() {
 
 // pruneExpiredExperimental prunes attestations on every prune interval.
 func (s *Service) pruneExpiredExperimental() {
-	secondsPerSlot := params.BeaconConfig().SecondsPerSlot
-	offset := time.Duration(secondsPerSlot-1) * time.Second
-	slotTicker := slots.NewSlotTickerWithOffset(s.genesisTime, offset, secondsPerSlot)
-	defer slotTicker.Done()
+	ticker := time.NewTicker(s.cfg.pruneInterval)
+	defer ticker.Stop()
 	for {
 		select {
-		case <-slotTicker.C():
+		case <-ticker.C:
 			expirySlot, err := s.expirySlot()
 			if err != nil {
 				log.WithError(err).Error("Could not get expiry slot")
@@ -43,7 +41,7 @@ func (s *Service) pruneExpiredExperimental() {
 			numExpired := s.cfg.Cache.PruneBefore(expirySlot)
 			s.updateMetricsExperimental(numExpired)
 		case <-s.ctx.Done():
-			log.Debug("Context closed, exiting att pruning routine")
+			log.Debug("Context closed, exiting routine")
 			return
 		}
 	}

beacon-chain/operations/attestations/prune_expired_test.go

@@ -23,7 +23,8 @@ func TestPruneExpired_Ticker(t *testing.T) {
 	defer cancel()
 
 	s, err := NewService(ctx, &Config{
-		Pool: NewPool(),
+		Pool:          NewPool(),
+		pruneInterval: 250 * time.Millisecond,
 	})
 	require.NoError(t, err)
 

beacon-chain/operations/attestations/service.go

@@ -11,6 +11,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
 	lruwrpr "github.com/OffchainLabs/prysm/v7/cache/lru"
 	"github.com/OffchainLabs/prysm/v7/config/features"
+	"github.com/OffchainLabs/prysm/v7/config/params"
 	lru "github.com/hashicorp/golang-lru"
 )
 
@@ -30,6 +31,7 @@ type Service struct {
 type Config struct {
 	Cache               *cache.AttestationCache
 	Pool                Pool
+	pruneInterval       time.Duration
 	InitialSyncComplete chan struct{}
 }
 
@@ -38,6 +40,11 @@ type Config struct {
 func NewService(ctx context.Context, cfg *Config) (*Service, error) {
 	cache := lruwrpr.New(forkChoiceProcessedAttsSize)
 
+	if cfg.pruneInterval == 0 {
+		// Prune expired attestations from the pool every slot interval.
+		cfg.pruneInterval = time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second
+	}
+
 	ctx, cancel := context.WithCancel(ctx)
 	return &Service{
 		cfg:                     cfg,

beacon-chain/p2p/types/object_mapping.go

@@ -204,9 +204,6 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
 			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
-			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
-		},
 	}
 
 	// Reset our light client finality update map.
@@ -226,8 +223,5 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
 			return lightclientConsensusTypes.NewEmptyFinalityUpdateElectra(), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
-			return lightclientConsensusTypes.NewEmptyFinalityUpdateElectra(), nil
-		},
 	}
 }

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

@@ -130,10 +130,6 @@ func (s *Server) SubmitAttestationsV2(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.SubmitAttestationsV2")
 	defer span.End()
 
-	if shared.IsSyncing(ctx, w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
-		return
-	}
-
 	versionHeader := r.Header.Get(api.VersionHeader)
 	if versionHeader == "" {
 		httputil.HandleError(w, api.VersionHeader+" header is required", http.StatusBadRequest)
@@ -242,14 +238,22 @@ func (s *Server) handleAttestationsElectra(
 			},
 		})
 
-		// Broadcast first using CommitteeId directly (fast path)
-		// This matches gRPC behavior and avoids blocking on state fetching
-		wantedEpoch := slots.ToEpoch(singleAtt.Data.Slot)
+		targetState, err := s.AttestationStateFetcher.AttestationTargetState(ctx, singleAtt.Data.Target)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "could not get target state for attestation")
+		}
+		committee, err := corehelpers.BeaconCommitteeFromState(ctx, targetState, singleAtt.Data.Slot, singleAtt.CommitteeId)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "could not get committee for attestation")
+		}
+		att := singleAtt.ToAttestationElectra(committee)
+
+		wantedEpoch := slots.ToEpoch(att.Data.Slot)
 		vals, err := s.HeadFetcher.HeadValidatorsIndices(ctx, wantedEpoch)
 		if err != nil {
 			return nil, nil, errors.Wrap(err, "could not get head validator indices")
 		}
-		subnet := corehelpers.ComputeSubnetFromCommitteeAndSlot(uint64(len(vals)), singleAtt.CommitteeId, singleAtt.Data.Slot)
+		subnet := corehelpers.ComputeSubnetFromCommitteeAndSlot(uint64(len(vals)), att.GetCommitteeIndex(), att.Data.Slot)
 		if err = s.Broadcaster.BroadcastAttestation(ctx, subnet, singleAtt); err != nil {
 			failedBroadcasts = append(failedBroadcasts, &server.IndexedError{
 				Index:   i,
@@ -260,33 +264,17 @@ func (s *Server) handleAttestationsElectra(
 			}
 			continue
 		}
-	}
 
-	// Save to pool after broadcast (slow path - requires state fetching)
-	// Run in goroutine to avoid blocking the HTTP response
-	go func() {
-		for _, singleAtt := range validAttestations {
-			targetState, err := s.AttestationStateFetcher.AttestationTargetState(context.Background(), singleAtt.Data.Target)
-			if err != nil {
-				log.WithError(err).Error("Could not get target state for attestation")
-				continue
+		if features.Get().EnableExperimentalAttestationPool {
+			if err = s.AttestationCache.Add(att); err != nil {
+				log.WithError(err).Error("Could not save attestation")
 			}
-			committee, err := corehelpers.BeaconCommitteeFromState(context.Background(), targetState, singleAtt.Data.Slot, singleAtt.CommitteeId)
-			if err != nil {
-				log.WithError(err).Error("Could not get committee for attestation")
-				continue
-			}
-			att := singleAtt.ToAttestationElectra(committee)
-
-			if features.Get().EnableExperimentalAttestationPool {
-				if err = s.AttestationCache.Add(att); err != nil {
-					log.WithError(err).Error("Could not save attestation")
-				}
-			} else if err = s.AttestationsPool.SaveUnaggregatedAttestation(att); err != nil {
+		} else {
+			if err = s.AttestationsPool.SaveUnaggregatedAttestation(att); err != nil {
 				log.WithError(err).Error("Could not save attestation")
 			}
 		}
-	}()
+	}
 
 	if len(failedBroadcasts) > 0 {
 		log.WithFields(logrus.Fields{
@@ -382,8 +370,10 @@ func (s *Server) handleAttestations(
 			if err = s.AttestationsPool.SaveAggregatedAttestation(att); err != nil {
 				log.WithError(err).Error("Could not save aggregated attestation")
 			}
-		} else if err = s.AttestationsPool.SaveUnaggregatedAttestation(att); err != nil {
-			log.WithError(err).Error("Could not save unaggregated attestation")
+		} else {
+			if err = s.AttestationsPool.SaveUnaggregatedAttestation(att); err != nil {
+				log.WithError(err).Error("Could not save unaggregated attestation")
+			}
 		}
 	}
 
@@ -480,10 +470,6 @@ func (s *Server) SubmitSyncCommitteeSignatures(w http.ResponseWriter, r *http.Re
 	ctx, span := trace.StartSpan(r.Context(), "beacon.SubmitPoolSyncCommitteeSignatures")
 	defer span.End()
 
-	if shared.IsSyncing(ctx, w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
-		return
-	}
-
 	var req structs.SubmitSyncCommitteeSignaturesRequest
 	err := json.NewDecoder(r.Body).Decode(&req.Data)
 	switch {

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

@@ -26,7 +26,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/voluntaryexits/mock"
 	p2pMock "github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/core"
-	mockSync "github.com/OffchainLabs/prysm/v7/beacon-chain/sync/initial-sync/testing"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -623,8 +622,6 @@ func TestSubmitAttestationsV2(t *testing.T) {
 		HeadFetcher:             chainService,
 		ChainInfoFetcher:        chainService,
 		TimeFetcher:             chainService,
-		OptimisticModeFetcher:   chainService,
-		SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		OperationNotifier:       &blockchainmock.MockOperationNotifier{},
 		AttestationStateFetcher: chainService,
 	}
@@ -657,7 +654,6 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, primitives.Epoch(0), broadcaster.BroadcastAttestations[0].GetData().Source.Epoch)
 			assert.Equal(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", hexutil.Encode(broadcaster.BroadcastAttestations[0].GetData().Target.Root))
 			assert.Equal(t, primitives.Epoch(0), broadcaster.BroadcastAttestations[0].GetData().Target.Epoch)
-			time.Sleep(100 * time.Millisecond) // Wait for async pool save
 			assert.Equal(t, 1, s.AttestationsPool.UnaggregatedAttestationCount())
 		})
 		t.Run("multiple", func(t *testing.T) {
@@ -677,7 +673,6 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, http.StatusOK, writer.Code)
 			assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
 			assert.Equal(t, 2, broadcaster.NumAttestations())
-			time.Sleep(100 * time.Millisecond) // Wait for async pool save
 			assert.Equal(t, 2, s.AttestationsPool.UnaggregatedAttestationCount())
 		})
 		t.Run("phase0 att post electra", func(t *testing.T) {
@@ -798,7 +793,6 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, primitives.Epoch(0), broadcaster.BroadcastAttestations[0].GetData().Source.Epoch)
 			assert.Equal(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2", hexutil.Encode(broadcaster.BroadcastAttestations[0].GetData().Target.Root))
 			assert.Equal(t, primitives.Epoch(0), broadcaster.BroadcastAttestations[0].GetData().Target.Epoch)
-			time.Sleep(100 * time.Millisecond) // Wait for async pool save
 			assert.Equal(t, 1, s.AttestationsPool.UnaggregatedAttestationCount())
 		})
 		t.Run("multiple", func(t *testing.T) {
@@ -818,7 +812,6 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, http.StatusOK, writer.Code)
 			assert.Equal(t, true, broadcaster.BroadcastCalled.Load())
 			assert.Equal(t, 2, broadcaster.NumAttestations())
-			time.Sleep(100 * time.Millisecond) // Wait for async pool save
 			assert.Equal(t, 2, s.AttestationsPool.UnaggregatedAttestationCount())
 		})
 		t.Run("no body", func(t *testing.T) {
@@ -868,27 +861,6 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, true, strings.Contains(e.Failures[0].Message, "Incorrect attestation signature"))
 		})
 	})
-	t.Run("syncing", func(t *testing.T) {
-		chainService := &blockchainmock.ChainService{}
-		s := &Server{
-			HeadFetcher:           chainService,
-			TimeFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			SyncChecker:           &mockSync.Sync{IsSyncing: true},
-		}
-
-		var body bytes.Buffer
-		_, err := body.WriteString(singleAtt)
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
-		request.Header.Set(api.VersionHeader, version.String(version.Phase0))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.SubmitAttestationsV2(writer, request)
-		assert.Equal(t, http.StatusServiceUnavailable, writer.Code)
-		assert.Equal(t, true, strings.Contains(writer.Body.String(), "Beacon node is currently syncing"))
-	})
 }
 
 func TestListVoluntaryExits(t *testing.T) {
@@ -1085,19 +1057,14 @@ func TestSubmitSyncCommitteeSignatures(t *testing.T) {
 
 	t.Run("single", func(t *testing.T) {
 		broadcaster := &p2pMock.MockBroadcaster{}
-		chainService := &blockchainmock.ChainService{
-			State:                st,
-			SyncCommitteeIndices: []primitives.CommitteeIndex{0},
-		}
 		s := &Server{
-			HeadFetcher:           chainService,
-			TimeFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
 			CoreService: &core.Service{
 				SyncCommitteePool: synccommittee.NewStore(),
 				P2P:               broadcaster,
-				HeadFetcher:       chainService,
+				HeadFetcher: &blockchainmock.ChainService{
+					State:                st,
+					SyncCommitteeIndices: []primitives.CommitteeIndex{0},
+				},
 			},
 		}
 
@@ -1122,19 +1089,14 @@ func TestSubmitSyncCommitteeSignatures(t *testing.T) {
 	})
 	t.Run("multiple", func(t *testing.T) {
 		broadcaster := &p2pMock.MockBroadcaster{}
-		chainService := &blockchainmock.ChainService{
-			State:                st,
-			SyncCommitteeIndices: []primitives.CommitteeIndex{0},
-		}
 		s := &Server{
-			HeadFetcher:           chainService,
-			TimeFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
 			CoreService: &core.Service{
 				SyncCommitteePool: synccommittee.NewStore(),
 				P2P:               broadcaster,
-				HeadFetcher:       chainService,
+				HeadFetcher: &blockchainmock.ChainService{
+					State:                st,
+					SyncCommitteeIndices: []primitives.CommitteeIndex{0},
+				},
 			},
 		}
 
@@ -1158,18 +1120,13 @@ func TestSubmitSyncCommitteeSignatures(t *testing.T) {
 	})
 	t.Run("invalid", func(t *testing.T) {
 		broadcaster := &p2pMock.MockBroadcaster{}
-		chainService := &blockchainmock.ChainService{
-			State: st,
-		}
 		s := &Server{
-			HeadFetcher:           chainService,
-			TimeFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
 			CoreService: &core.Service{
 				SyncCommitteePool: synccommittee.NewStore(),
 				P2P:               broadcaster,
-				HeadFetcher:       chainService,
+				HeadFetcher: &blockchainmock.ChainService{
+					State: st,
+				},
 			},
 		}
 
@@ -1192,13 +1149,7 @@ func TestSubmitSyncCommitteeSignatures(t *testing.T) {
 		assert.Equal(t, false, broadcaster.BroadcastCalled.Load())
 	})
 	t.Run("empty", func(t *testing.T) {
-		chainService := &blockchainmock.ChainService{State: st}
-		s := &Server{
-			HeadFetcher:           chainService,
-			TimeFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
-		}
+		s := &Server{}
 
 		var body bytes.Buffer
 		_, err := body.WriteString("[]")
@@ -1215,13 +1166,7 @@ func TestSubmitSyncCommitteeSignatures(t *testing.T) {
 		assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
 	})
 	t.Run("no body", func(t *testing.T) {
-		chainService := &blockchainmock.ChainService{State: st}
-		s := &Server{
-			HeadFetcher:           chainService,
-			TimeFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
-		}
+		s := &Server{}
 
 		request := httptest.NewRequest(http.MethodPost, "http://example.com", nil)
 		writer := httptest.NewRecorder()
@@ -1234,26 +1179,6 @@ func TestSubmitSyncCommitteeSignatures(t *testing.T) {
 		assert.Equal(t, http.StatusBadRequest, e.Code)
 		assert.Equal(t, true, strings.Contains(e.Message, "No data submitted"))
 	})
-	t.Run("syncing", func(t *testing.T) {
-		chainService := &blockchainmock.ChainService{State: st}
-		s := &Server{
-			HeadFetcher:           chainService,
-			TimeFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			SyncChecker:           &mockSync.Sync{IsSyncing: true},
-		}
-
-		var body bytes.Buffer
-		_, err := body.WriteString(singleSyncCommitteeMsg)
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://example.com", &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.SubmitSyncCommitteeSignatures(writer, request)
-		assert.Equal(t, http.StatusServiceUnavailable, writer.Code)
-		assert.Equal(t, true, strings.Contains(writer.Body.String(), "Beacon node is currently syncing"))
-	})
 }
 
 func TestListBLSToExecutionChanges(t *testing.T) {

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

@@ -52,27 +52,24 @@ func (vs *Server) ProposeAttestation(ctx context.Context, att *ethpb.Attestation
 	ctx, span := trace.StartSpan(ctx, "AttesterServer.ProposeAttestation")
 	defer span.End()
 
-	if vs.SyncChecker.Syncing() {
-		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
-	}
-
 	resp, err := vs.proposeAtt(ctx, att, att.GetData().CommitteeIndex)
 	if err != nil {
 		return nil, err
 	}
 
-	go func() {
-		if features.Get().EnableExperimentalAttestationPool {
-			if err := vs.AttestationCache.Add(att); err != nil {
-				log.WithError(err).Error("Could not save attestation")
-			}
-		} else {
+	if features.Get().EnableExperimentalAttestationPool {
+		if err = vs.AttestationCache.Add(att); err != nil {
+			log.WithError(err).Error("Could not save attestation")
+		}
+	} else {
+		go func() {
 			attCopy := att.Copy()
 			if err := vs.AttPool.SaveUnaggregatedAttestation(attCopy); err != nil {
 				log.WithError(err).Error("Could not save unaggregated attestation")
+				return
 			}
-		}
-	}()
+		}()
+	}
 
 	return resp, nil
 }
@@ -85,10 +82,6 @@ func (vs *Server) ProposeAttestationElectra(ctx context.Context, singleAtt *ethp
 	ctx, span := trace.StartSpan(ctx, "AttesterServer.ProposeAttestationElectra")
 	defer span.End()
 
-	if vs.SyncChecker.Syncing() {
-		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
-	}
-
 	resp, err := vs.proposeAtt(ctx, singleAtt, singleAtt.GetCommitteeIndex())
 	if err != nil {
 		return nil, err
@@ -105,17 +98,18 @@ func (vs *Server) ProposeAttestationElectra(ctx context.Context, singleAtt *ethp
 
 	singleAttCopy := singleAtt.Copy()
 	att := singleAttCopy.ToAttestationElectra(committee)
-	go func() {
-		if features.Get().EnableExperimentalAttestationPool {
-			if err := vs.AttestationCache.Add(att); err != nil {
-				log.WithError(err).Error("Could not save attestation")
-			}
-		} else {
+	if features.Get().EnableExperimentalAttestationPool {
+		if err = vs.AttestationCache.Add(att); err != nil {
+			log.WithError(err).Error("Could not save attestation")
+		}
+	} else {
+		go func() {
 			if err := vs.AttPool.SaveUnaggregatedAttestation(att); err != nil {
 				log.WithError(err).Error("Could not save unaggregated attestation")
+				return
 			}
-		}
-	}()
+		}()
+	}
 
 	return resp, nil
 }

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

@@ -38,7 +38,6 @@ func TestProposeAttestation(t *testing.T) {
 		OperationNotifier:       (&mock.ChainService{}).OperationNotifier(),
 		TimeFetcher:             chainService,
 		AttestationStateFetcher: chainService,
-		SyncChecker:             &mockSync.Sync{IsSyncing: false},
 	}
 	head := util.NewBeaconBlock()
 	head.Block.Slot = 999
@@ -142,7 +141,6 @@ func TestProposeAttestation_IncorrectSignature(t *testing.T) {
 		P2P:               &mockp2p.MockBroadcaster{},
 		AttPool:           attestations.NewPool(),
 		OperationNotifier: (&mock.ChainService{}).OperationNotifier(),
-		SyncChecker:       &mockSync.Sync{IsSyncing: false},
 	}
 
 	req := util.HydrateAttestation(&ethpb.Attestation{})
@@ -151,37 +149,6 @@ func TestProposeAttestation_IncorrectSignature(t *testing.T) {
 	assert.ErrorContains(t, wanted, err)
 }
 
-func TestProposeAttestation_Syncing(t *testing.T) {
-	attesterServer := &Server{
-		SyncChecker: &mockSync.Sync{IsSyncing: true},
-	}
-
-	req := util.HydrateAttestation(&ethpb.Attestation{})
-	_, err := attesterServer.ProposeAttestation(t.Context(), req)
-	assert.ErrorContains(t, "Syncing to latest head", err)
-	s, ok := status.FromError(err)
-	require.Equal(t, true, ok)
-	assert.Equal(t, codes.Unavailable, s.Code())
-}
-
-func TestProposeAttestationElectra_Syncing(t *testing.T) {
-	attesterServer := &Server{
-		SyncChecker: &mockSync.Sync{IsSyncing: true},
-	}
-
-	req := &ethpb.SingleAttestation{
-		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
-			Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
-		},
-	}
-	_, err := attesterServer.ProposeAttestationElectra(t.Context(), req)
-	assert.ErrorContains(t, "Syncing to latest head", err)
-	s, ok := status.FromError(err)
-	require.Equal(t, true, ok)
-	assert.Equal(t, codes.Unavailable, s.Code())
-}
-
 func TestGetAttestationData_OK(t *testing.T) {
 	block := util.NewBeaconBlock()
 	block.Block.Slot = 3*params.BeaconConfig().SlotsPerEpoch + 1

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

@@ -439,12 +439,16 @@ func (vs *Server) deleteAttsInPool(ctx context.Context, atts []ethpb.Att) error
 			if err := vs.AttestationCache.DeleteCovered(att); err != nil {
 				return errors.Wrap(err, "could not delete attestation")
 			}
-		} else if att.IsAggregated() {
-			if err := vs.AttPool.DeleteAggregatedAttestation(att); err != nil {
-				return err
+		} else {
+			if att.IsAggregated() {
+				if err := vs.AttPool.DeleteAggregatedAttestation(att); err != nil {
+					return err
+				}
+			} else {
+				if err := vs.AttPool.DeleteUnaggregatedAttestation(att); err != nil {
+					return err
+				}
 			}
-		} else if err := vs.AttPool.DeleteUnaggregatedAttestation(att); err != nil {
-			return err
 		}
 	}
 	return nil

beacon-chain/sync/batch_verifier.go

@@ -163,15 +163,11 @@ func (s *Service) validateWithKzgBatchVerifier(ctx context.Context, dataColumns
 
 	resChan := make(chan error, 1)
 	verificationSet := &kzgVerifier{dataColumns: dataColumns, resChan: resChan}
+	s.kzgChan <- verificationSet
+
 	ctx, cancel := context.WithTimeout(ctx, timeout)
 	defer cancel()
 
-	select {
-	case s.kzgChan <- verificationSet:
-	case <-ctx.Done():
-		return pubsub.ValidationIgnore, ctx.Err()
-	}
-
 	select {
 	case <-ctx.Done():
 		return pubsub.ValidationIgnore, ctx.Err() // parent context canceled, give up

beacon-chain/sync/data_column_sidecars.go

@@ -3,7 +3,6 @@ package sync
 import (
 	"bytes"
 	"context"
-	"fmt"
 	"maps"
 	"slices"
 	"sync"
@@ -244,10 +243,8 @@ func requestDirectSidecarsFromPeers(
 	}
 
 	// Compute missing indices by root, excluding those already in storage.
-	var lastRoot [fieldparams.RootLength]byte
 	missingIndicesByRoot := make(map[[fieldparams.RootLength]byte]map[uint64]bool, len(incompleteRoots))
 	for root := range incompleteRoots {
-		lastRoot = root
 		storedIndices := storedIndicesByRoot[root]
 
 		missingIndices := make(map[uint64]bool, len(requestedIndices))
@@ -262,7 +259,6 @@ func requestDirectSidecarsFromPeers(
 		}
 	}
 
-	initialMissingRootCount := len(missingIndicesByRoot)
 	initialMissingCount := computeTotalCount(missingIndicesByRoot)
 
 	indicesByRootByPeer, err := computeIndicesByRootByPeer(params.P2P, slotByRoot, missingIndicesByRoot, connectedPeers)
@@ -305,19 +301,11 @@ func requestDirectSidecarsFromPeers(
 		}
 	}
 
-	log := log.WithFields(logrus.Fields{
-		"duration":                time.Since(start),
-		"initialMissingRootCount": initialMissingRootCount,
-		"initialMissingCount":     initialMissingCount,
-		"finalMissingRootCount":   len(missingIndicesByRoot),
-		"finalMissingCount":       computeTotalCount(missingIndicesByRoot),
-	})
-
-	if initialMissingRootCount == 1 {
-		log = log.WithField("root", fmt.Sprintf("%#x", lastRoot))
-	}
-
-	log.Debug("Requested direct data column sidecars from peers")
+	log.WithFields(logrus.Fields{
+		"duration":            time.Since(start),
+		"initialMissingCount": initialMissingCount,
+		"finalMissingCount":   computeTotalCount(missingIndicesByRoot),
+	}).Debug("Requested direct data column sidecars from peers")
 
 	return verifiedColumnsByRoot, nil
 }

beacon-chain/sync/kzg_batch_verifier_test.go

@@ -304,36 +304,6 @@ func TestValidateWithKzgBatchVerifier_DeadlockOnTimeout(t *testing.T) {
 	}
 }
 
-func TestValidateWithKzgBatchVerifier_ContextCanceledBeforeSend(t *testing.T) {
-	cancelledCtx, cancel := context.WithCancel(t.Context())
-	cancel()
-
-	service := &Service{
-		ctx:     context.Background(),
-		kzgChan: make(chan *kzgVerifier),
-	}
-
-	done := make(chan struct{})
-	go func() {
-		result, err := service.validateWithKzgBatchVerifier(cancelledCtx, nil)
-		require.Equal(t, pubsub.ValidationIgnore, result)
-		require.ErrorIs(t, err, context.Canceled)
-		close(done)
-	}()
-
-	select {
-	case <-done:
-	case <-time.After(500 * time.Millisecond):
-		t.Fatal("validateWithKzgBatchVerifier did not return after context cancellation")
-	}
-
-	select {
-	case <-service.kzgChan:
-		t.Fatal("verificationSet was sent to kzgChan despite canceled context")
-	default:
-	}
-}
-
 func createValidTestDataColumns(t *testing.T, count int) []blocks.RODataColumn {
 	_, roSidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, count)
 	if len(roSidecars) >= count {

beacon-chain/sync/metrics.go

@@ -204,13 +204,6 @@ var (
 		},
 	)
 
-	dataColumnsRecoveredFromELAttempts = promauto.NewCounter(
-		prometheus.CounterOpts{
-			Name: "data_columns_recovered_from_el_attempts",
-			Help: "Count the number of data columns recovery attempts from the execution layer.",
-		},
-	)
-
 	dataColumnsRecoveredFromELTotal = promauto.NewCounter(
 		prometheus.CounterOpts{
 			Name: "data_columns_recovered_from_el_total",
@@ -249,13 +242,6 @@ var (
 			Buckets: []float64{100, 250, 500, 750, 1000, 1500, 2000, 4000, 8000, 12000, 16000},
 		},
 	)
-
-	dataColumnSidecarsObtainedViaELCount = promauto.NewSummary(
-		prometheus.SummaryOpts{
-			Name: "data_column_obtained_via_el_count",
-			Help: "Count the number of data column sidecars obtained via the execution layer.",
-		},
-	)
 )
 
 func (s *Service) updateMetrics() {

beacon-chain/sync/pending_attestations_queue.go

@@ -3,9 +3,9 @@ package sync
 import (
 	"bytes"
 	"context"
+	"encoding/hex"
 	"fmt"
 	"slices"
-	"time"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
@@ -21,23 +21,13 @@ import (
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/OffchainLabs/prysm/v7/time"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
-const pendingAttsLimit = 32768
-
-// aggregatorIndexFilter defines how aggregator index should be handled in equality checks.
-type aggregatorIndexFilter int
-
-const (
-	// ignoreAggregatorIndex means aggregates differing only by aggregator index are considered equal.
-	ignoreAggregatorIndex aggregatorIndexFilter = iota
-	// includeAggregatorIndex means aggregator index must also match for aggregates to be considered equal.
-	includeAggregatorIndex
-)
+var pendingAttsLimit = 32768
 
 // This method processes pending attestations as a "known" block as arrived. With validations,
 // the valid attestations get saved into the operation mem pool, and the invalid attestations gets deleted
@@ -60,7 +50,16 @@ func (s *Service) processPendingAttsForBlock(ctx context.Context, bRoot [32]byte
 	attestations := s.blkRootToPendingAtts[bRoot]
 	s.pendingAttsLock.RUnlock()
 
-	s.processAttestations(ctx, attestations)
+	if len(attestations) > 0 {
+		start := time.Now()
+		s.processAttestations(ctx, attestations)
+		duration := time.Since(start)
+		log.WithFields(logrus.Fields{
+			"blockRoot":        hex.EncodeToString(bytesutil.Trunc(bRoot[:])),
+			"pendingAttsCount": len(attestations),
+			"duration":         duration,
+		}).Debug("Verified and saved pending attestations to pool")
+	}
 
 	randGen := rand.NewGenerator()
 	// Delete the missing block root key from pending attestation queue so a node will not request for the block again.
@@ -80,71 +79,26 @@ func (s *Service) processPendingAttsForBlock(ctx context.Context, bRoot [32]byte
 	return s.sendBatchRootRequest(ctx, pendingRoots, randGen)
 }
 
-// processAttestations processes a list of attestations.
-// It assumes (for logging purposes only) that all attestations pertain to the same block.
 func (s *Service) processAttestations(ctx context.Context, attestations []any) {
 	if len(attestations) == 0 {
 		return
 	}
 
-	firstAttestation := attestations[0]
-	var blockRoot []byte
-	switch v := firstAttestation.(type) {
-	case ethpb.Att:
-		blockRoot = v.GetData().BeaconBlockRoot
-	case ethpb.SignedAggregateAttAndProof:
-		blockRoot = v.AggregateAttestationAndProof().AggregateVal().GetData().BeaconBlockRoot
-	default:
-		log.Warnf("Unexpected attestation type %T, skipping processing", v)
-		return
-	}
-
-	validAggregates := make([]ethpb.SignedAggregateAttAndProof, 0, len(attestations))
-	startAggregate := time.Now()
 	atts := make([]ethpb.Att, 0, len(attestations))
-	aggregateAttAndProofCount := 0
 	for _, att := range attestations {
 		switch v := att.(type) {
 		case ethpb.Att:
 			atts = append(atts, v)
 		case ethpb.SignedAggregateAttAndProof:
-			aggregateAttAndProofCount++
-			// Avoid processing multiple aggregates only differing by aggregator index.
-			if slices.ContainsFunc(validAggregates, func(other ethpb.SignedAggregateAttAndProof) bool {
-				return pendingAggregatesAreEqual(v, other, ignoreAggregatorIndex)
-			}) {
-				continue
-			}
-
-			if err := s.processAggregate(ctx, v); err != nil {
-				log.WithError(err).Debug("Pending aggregate attestation could not be processed")
-				continue
-			}
-
-			validAggregates = append(validAggregates, v)
+			s.processAggregate(ctx, v)
 		default:
 			log.Warnf("Unexpected attestation type %T, skipping", v)
 		}
 	}
-	durationAggregateAttAndProof := time.Since(startAggregate)
 
-	startAtts := time.Now()
 	for _, bucket := range bucketAttestationsByData(atts) {
 		s.processAttestationBucket(ctx, bucket)
 	}
-
-	durationAtts := time.Since(startAtts)
-
-	log.WithFields(logrus.Fields{
-		"blockRoot":                       fmt.Sprintf("%#x", blockRoot),
-		"totalCount":                      len(attestations),
-		"aggregateAttAndProofCount":       aggregateAttAndProofCount,
-		"uniqueAggregateAttAndProofCount": len(validAggregates),
-		"attCount":                        len(atts),
-		"durationTotal":                   durationAggregateAttAndProof + durationAtts,
-		"durationAggregateAttAndProof":    durationAggregateAttAndProof,
-		"durationAtts":                    durationAtts,
-	}).Debug("Verified and saved pending attestations to pool")
 }
 
 // attestationBucket groups attestations with the same AttestationData for batch processing.
@@ -349,20 +303,21 @@ func (s *Service) processVerifiedAttestation(
 	})
 }
 
-func (s *Service) processAggregate(ctx context.Context, aggregate ethpb.SignedAggregateAttAndProof) error {
+func (s *Service) processAggregate(ctx context.Context, aggregate ethpb.SignedAggregateAttAndProof) {
 	res, err := s.validateAggregatedAtt(ctx, aggregate)
 	if err != nil {
 		log.WithError(err).Debug("Pending aggregated attestation failed validation")
-		return errors.Wrap(err, "validate aggregated att")
+		return
 	}
-
 	if res != pubsub.ValidationAccept || !s.validateBlockInAttestation(ctx, aggregate) {
-		return errors.New("Pending aggregated attestation failed validation")
+		log.Debug("Pending aggregated attestation failed validation")
+		return
 	}
 
 	att := aggregate.AggregateAttestationAndProof().AggregateVal()
 	if err := s.saveAttestation(att); err != nil {
-		return errors.Wrap(err, "save attestation")
+		log.WithError(err).Debug("Could not save aggregated attestation")
+		return
 	}
 
 	_ = s.setAggregatorIndexEpochSeen(att.GetData().Target.Epoch, aggregate.AggregateAttestationAndProof().GetAggregatorIndex())
@@ -370,8 +325,6 @@ func (s *Service) processAggregate(ctx context.Context, aggregate ethpb.SignedAg
 	if err := s.cfg.p2p.Broadcast(ctx, aggregate); err != nil {
 		log.WithError(err).Debug("Could not broadcast aggregated attestation")
 	}
-
-	return nil
 }
 
 // This defines how pending aggregates are saved in the map. The key is the
@@ -383,7 +336,7 @@ func (s *Service) savePendingAggregate(agg ethpb.SignedAggregateAttAndProof) {
 
 	s.savePending(root, agg, func(other any) bool {
 		a, ok := other.(ethpb.SignedAggregateAttAndProof)
-		return ok && pendingAggregatesAreEqual(agg, a, includeAggregatorIndex)
+		return ok && pendingAggregatesAreEqual(agg, a)
 	})
 }
 
@@ -438,19 +391,13 @@ func (s *Service) savePending(root [32]byte, pending any, isEqual func(other any
 	s.blkRootToPendingAtts[root] = append(s.blkRootToPendingAtts[root], pending)
 }
 
-// pendingAggregatesAreEqual checks if two pending aggregate attestations are equal.
-// The filter parameter controls whether aggregator index is considered in the equality check.
-func pendingAggregatesAreEqual(a, b ethpb.SignedAggregateAttAndProof, filter aggregatorIndexFilter) bool {
+func pendingAggregatesAreEqual(a, b ethpb.SignedAggregateAttAndProof) bool {
 	if a.Version() != b.Version() {
 		return false
 	}
-
-	if filter == includeAggregatorIndex {
-		if a.AggregateAttestationAndProof().GetAggregatorIndex() != b.AggregateAttestationAndProof().GetAggregatorIndex() {
-			return false
-		}
+	if a.AggregateAttestationAndProof().GetAggregatorIndex() != b.AggregateAttestationAndProof().GetAggregatorIndex() {
+		return false
 	}
-
 	aAtt := a.AggregateAttestationAndProof().AggregateVal()
 	bAtt := b.AggregateAttestationAndProof().AggregateVal()
 	if aAtt.GetData().Slot != bAtt.GetData().Slot {

beacon-chain/sync/pending_attestations_queue_test.go

@@ -94,7 +94,7 @@ func TestProcessPendingAtts_NoBlockRequestBlock(t *testing.T) {
 	// Process block A (which exists and has no pending attestations)
 	// This should skip processing attestations for A and request blocks B and C
 	require.NoError(t, r.processPendingAttsForBlock(t.Context(), rootA))
-	require.LogsContain(t, hook, "Requesting blocks by root")
+	require.LogsContain(t, hook, "Requesting block by root")
 }
 
 func TestProcessPendingAtts_HasBlockSaveUnaggregatedAtt(t *testing.T) {
@@ -911,17 +911,17 @@ func Test_pendingAggregatesAreEqual(t *testing.T) {
 					},
 					AggregationBits: bitfield.Bitlist{0b1111},
 				}}}
-		assert.Equal(t, true, pendingAggregatesAreEqual(a, b, includeAggregatorIndex))
+		assert.Equal(t, true, pendingAggregatesAreEqual(a, b))
 	})
 	t.Run("different version", func(t *testing.T) {
 		a := &ethpb.SignedAggregateAttestationAndProof{Message: &ethpb.AggregateAttestationAndProof{AggregatorIndex: 1}}
 		b := &ethpb.SignedAggregateAttestationAndProofElectra{Message: &ethpb.AggregateAttestationAndProofElectra{AggregatorIndex: 1}}
-		assert.Equal(t, false, pendingAggregatesAreEqual(a, b, includeAggregatorIndex))
+		assert.Equal(t, false, pendingAggregatesAreEqual(a, b))
 	})
 	t.Run("different aggregator index", func(t *testing.T) {
 		a := &ethpb.SignedAggregateAttestationAndProof{Message: &ethpb.AggregateAttestationAndProof{AggregatorIndex: 1}}
 		b := &ethpb.SignedAggregateAttestationAndProof{Message: &ethpb.AggregateAttestationAndProof{AggregatorIndex: 2}}
-		assert.Equal(t, false, pendingAggregatesAreEqual(a, b, includeAggregatorIndex))
+		assert.Equal(t, false, pendingAggregatesAreEqual(a, b))
 	})
 	t.Run("different slot", func(t *testing.T) {
 		a := &ethpb.SignedAggregateAttestationAndProof{
@@ -942,7 +942,7 @@ func Test_pendingAggregatesAreEqual(t *testing.T) {
 					},
 					AggregationBits: bitfield.Bitlist{0b1111},
 				}}}
-		assert.Equal(t, false, pendingAggregatesAreEqual(a, b, includeAggregatorIndex))
+		assert.Equal(t, false, pendingAggregatesAreEqual(a, b))
 	})
 	t.Run("different committee index", func(t *testing.T) {
 		a := &ethpb.SignedAggregateAttestationAndProof{
@@ -963,7 +963,7 @@ func Test_pendingAggregatesAreEqual(t *testing.T) {
 					},
 					AggregationBits: bitfield.Bitlist{0b1111},
 				}}}
-		assert.Equal(t, false, pendingAggregatesAreEqual(a, b, includeAggregatorIndex))
+		assert.Equal(t, false, pendingAggregatesAreEqual(a, b))
 	})
 	t.Run("different aggregation bits", func(t *testing.T) {
 		a := &ethpb.SignedAggregateAttestationAndProof{
@@ -984,30 +984,7 @@ func Test_pendingAggregatesAreEqual(t *testing.T) {
 					},
 					AggregationBits: bitfield.Bitlist{0b1000},
 				}}}
-		assert.Equal(t, false, pendingAggregatesAreEqual(a, b, includeAggregatorIndex))
-	})
-	t.Run("different aggregator index should be equal while ignoring aggregator index", func(t *testing.T) {
-		a := &ethpb.SignedAggregateAttestationAndProof{
-			Message: &ethpb.AggregateAttestationAndProof{
-				AggregatorIndex: 1,
-				Aggregate: &ethpb.Attestation{
-					Data: &ethpb.AttestationData{
-						Slot:           1,
-						CommitteeIndex: 1,
-					},
-					AggregationBits: bitfield.Bitlist{0b1111},
-				}}}
-		b := &ethpb.SignedAggregateAttestationAndProof{
-			Message: &ethpb.AggregateAttestationAndProof{
-				AggregatorIndex: 2,
-				Aggregate: &ethpb.Attestation{
-					Data: &ethpb.AttestationData{
-						Slot:           1,
-						CommitteeIndex: 1,
-					},
-					AggregationBits: bitfield.Bitlist{0b1111},
-				}}}
-		assert.Equal(t, true, pendingAggregatesAreEqual(a, b, ignoreAggregatorIndex))
+		assert.Equal(t, false, pendingAggregatesAreEqual(a, b))
 	})
 }
 

beacon-chain/sync/pending_blocks_queue.go

@@ -2,6 +2,7 @@ package sync
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"slices"
 	"sync"
@@ -43,13 +44,11 @@ func (s *Service) processPendingBlocksQueue() {
 		if !s.chainIsStarted() {
 			return
 		}
-
 		locker.Lock()
-		defer locker.Unlock()
-
 		if err := s.processPendingBlocks(s.ctx); err != nil {
 			log.WithError(err).Debug("Could not process pending blocks")
 		}
+		locker.Unlock()
 	})
 }
 
@@ -74,10 +73,8 @@ func (s *Service) processPendingBlocks(ctx context.Context) error {
 	randGen := rand.NewGenerator()
 	var parentRoots [][32]byte
 
-	blkRoots := make([][32]byte, 0, len(sortedSlots)*maxBlocksPerSlot)
-
 	// Iterate through sorted slots.
-	for i, slot := range sortedSlots {
+	for _, slot := range sortedSlots {
 		// Skip processing if slot is in the future.
 		if slot > s.cfg.clock.CurrentSlot() {
 			continue
@@ -94,9 +91,6 @@ func (s *Service) processPendingBlocks(ctx context.Context) error {
 
 		// Process each block in the queue.
 		for _, b := range blocksInCache {
-			start := time.Now()
-			totalDuration := time.Duration(0)
-
 			if err := blocks.BeaconBlockIsNil(b); err != nil {
 				continue
 			}
@@ -153,34 +147,19 @@ func (s *Service) processPendingBlocks(ctx context.Context) error {
 			}
 			cancelFunction()
 
-			blkRoots = append(blkRoots, blkRoot)
+			// Process pending attestations for this block.
+			if err := s.processPendingAttsForBlock(ctx, blkRoot); err != nil {
+				log.WithError(err).Debug("Failed to process pending attestations for block")
+			}
 
 			// Remove the processed block from the queue.
 			if err := s.removeBlockFromQueue(b, blkRoot); err != nil {
 				return err
 			}
-
-			duration := time.Since(start)
-			totalDuration += duration
-			log.WithFields(logrus.Fields{
-				"slotIndex":     fmt.Sprintf("%d/%d", i+1, len(sortedSlots)),
-				"slot":          slot,
-				"root":          fmt.Sprintf("%#x", blkRoot),
-				"duration":      duration,
-				"totalDuration": totalDuration,
-			}).Debug("Processed pending block and cleared it in cache")
+			log.WithFields(logrus.Fields{"slot": slot, "blockRoot": hex.EncodeToString(bytesutil.Trunc(blkRoot[:]))}).Debug("Processed pending block and cleared it in cache")
 		}
-
 		span.End()
 	}
-
-	for _, blkRoot := range blkRoots {
-		// Process pending attestations for this block.
-		if err := s.processPendingAttsForBlock(ctx, blkRoot); err != nil {
-			log.WithError(err).Debug("Failed to process pending attestations for block")
-		}
-	}
-
 	return s.sendBatchRootRequest(ctx, parentRoots, randGen)
 }
 
@@ -400,19 +379,6 @@ func (s *Service) sendBatchRootRequest(ctx context.Context, roots [][32]byte, ra
 			req = roots[:maxReqBlock]
 		}
 
-		if logrus.GetLevel() >= logrus.DebugLevel {
-			rootsStr := make([]string, 0, len(roots))
-			for _, req := range roots {
-				rootsStr = append(rootsStr, fmt.Sprintf("%#x", req))
-			}
-
-			log.WithFields(logrus.Fields{
-				"peer":  pid,
-				"count": len(req),
-				"roots": rootsStr,
-			}).Debug("Requesting blocks by root")
-		}
-
 		// Send the request to the peer.
 		if err := s.sendBeaconBlocksRequest(ctx, &req, pid); err != nil {
 			tracing.AnnotateError(span, err)
@@ -472,6 +438,8 @@ func (s *Service) filterOutPendingAndSynced(roots [][fieldparams.RootLength]byte
 			roots = append(roots[:i], roots[i+1:]...)
 			continue
 		}
+
+		log.WithField("blockRoot", fmt.Sprintf("%#x", r)).Debug("Requesting block by root")
 	}
 	return roots
 }

beacon-chain/sync/subscriber_beacon_aggregate_proof.go

@@ -26,10 +26,11 @@ func (s *Service) beaconAggregateProofSubscriber(_ context.Context, msg proto.Me
 
 	if features.Get().EnableExperimentalAttestationPool {
 		return s.cfg.attestationCache.Add(aggregate)
-	}
-	if aggregate.IsAggregated() {
+	} else {
+		// An unaggregated attestation can make it here. It’s valid, the aggregator it just itself, although it means poor performance for the subnet.
+		if !aggregate.IsAggregated() {
+			return s.cfg.attPool.SaveUnaggregatedAttestation(aggregate)
+		}
 		return s.cfg.attPool.SaveAggregatedAttestation(aggregate)
 	}
-	// An unaggregated attestation can make it here. It’s valid, the aggregator it just itself, although it means poor performance for the subnet.
-	return s.cfg.attPool.SaveUnaggregatedAttestation(aggregate)
 }

beacon-chain/sync/subscriber_beacon_attestation.go

@@ -23,16 +23,16 @@ func (s *Service) committeeIndexBeaconAttestationSubscriber(_ context.Context, m
 
 	if features.Get().EnableExperimentalAttestationPool {
 		return s.cfg.attestationCache.Add(a)
+	} else {
+		exists, err := s.cfg.attPool.HasAggregatedAttestation(a)
+		if err != nil {
+			return errors.Wrap(err, "could not determine if attestation pool has this attestation")
+		}
+		if exists {
+			return nil
+		}
+		return s.cfg.attPool.SaveUnaggregatedAttestation(a)
 	}
-	exists, err := s.cfg.attPool.HasAggregatedAttestation(a)
-	if err != nil {
-		return errors.Wrap(err, "could not determine if attestation pool has this attestation")
-	}
-	if exists {
-		return nil
-	}
-	return s.cfg.attPool.SaveUnaggregatedAttestation(a)
-
 }
 
 func persistentSubnetIndices() []uint64 {

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -189,30 +189,12 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 		ctx, cancel := context.WithTimeout(ctx, secondsPerHalfSlot)
 		defer cancel()
 
-		log := log.WithFields(logrus.Fields{
-			"root":          fmt.Sprintf("%#x", source.Root()),
-			"slot":          source.Slot(),
-			"proposerIndex": source.ProposerIndex(),
-			"type":          source.Type(),
-		})
-
-		var constructedSidecarCount uint64
 		for iteration := uint64(0); ; /*no stop condition*/ iteration++ {
-			log = log.WithField("iteration", iteration)
-
 			// Exit early if all sidecars to sample have been seen.
 			if s.haveAllSidecarsBeenSeen(source.Slot(), source.ProposerIndex(), columnIndicesToSample) {
-				if iteration > 0 && constructedSidecarCount == 0 {
-					log.Debug("No data column sidecars constructed from the execution client")
-				}
-
 				return nil, nil
 			}
 
-			if iteration == 0 {
-				dataColumnsRecoveredFromELAttempts.Inc()
-			}
-
 			// Try to reconstruct data column constructedSidecars from the execution client.
 			constructedSidecars, err := s.cfg.executionReconstructor.ConstructDataColumnSidecars(ctx, source)
 			if err != nil {
@@ -220,8 +202,8 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 			}
 
 			// No sidecars are retrieved from the EL, retry later
-			constructedSidecarCount = uint64(len(constructedSidecars))
-			if constructedSidecarCount == 0 {
+			sidecarCount := uint64(len(constructedSidecars))
+			if sidecarCount == 0 {
 				if ctx.Err() != nil {
 					return nil, ctx.Err()
 				}
@@ -230,11 +212,9 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 				continue
 			}
 
-			dataColumnsRecoveredFromELTotal.Inc()
-
 			// Boundary check.
-			if constructedSidecarCount != fieldparams.NumberOfColumns {
-				return nil, errors.Errorf("reconstruct data column sidecars returned %d sidecars, expected %d - should never happen", constructedSidecarCount, fieldparams.NumberOfColumns)
+			if sidecarCount != fieldparams.NumberOfColumns {
+				return nil, errors.Errorf("reconstruct data column sidecars returned %d sidecars, expected %d - should never happen", sidecarCount, fieldparams.NumberOfColumns)
 			}
 
 			unseenIndices, err := s.broadcastAndReceiveUnseenDataColumnSidecars(ctx, source.Slot(), source.ProposerIndex(), columnIndicesToSample, constructedSidecars)
@@ -242,12 +222,19 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 				return nil, errors.Wrap(err, "broadcast and receive unseen data column sidecars")
 			}
 
-			log.WithFields(logrus.Fields{
-				"count":   len(unseenIndices),
-				"indices": helpers.SortedPrettySliceFromMap(unseenIndices),
-			}).Debug("Constructed data column sidecars from the execution client")
+			if len(unseenIndices) > 0 {
+				dataColumnsRecoveredFromELTotal.Inc()
 
-			dataColumnSidecarsObtainedViaELCount.Observe(float64(len(unseenIndices)))
+				log.WithFields(logrus.Fields{
+					"root":          fmt.Sprintf("%#x", source.Root()),
+					"slot":          source.Slot(),
+					"proposerIndex": source.ProposerIndex(),
+					"iteration":     iteration,
+					"type":          source.Type(),
+					"count":         len(unseenIndices),
+					"indices":       helpers.SortedPrettySliceFromMap(unseenIndices),
+				}).Debug("Constructed data column sidecars from the execution client")
+			}
 
 			return nil, nil
 		}

beacon-chain/sync/validate_data_column.go

@@ -51,12 +51,14 @@ func (s *Service) validateDataColumn(ctx context.Context, pid peer.ID, msg *pubs
 	// Decode the message, reject if it fails.
 	m, err := s.decodePubsubMessage(msg)
 	if err != nil {
+		log.WithError(err).Error("Failed to decode message")
 		return pubsub.ValidationReject, err
 	}
 
 	// Reject messages that are not of the expected type.
 	dcsc, ok := m.(*eth.DataColumnSidecar)
 	if !ok {
+		log.WithField("message", m).Error("Message is not of type *eth.DataColumnSidecar")
 		return pubsub.ValidationReject, errWrongMessage
 	}
 

beacon-chain/sync/validate_light_client_test.go

@@ -54,13 +54,11 @@ func TestValidateLightClientOptimisticUpdate(t *testing.T) {
 	cfg.CapellaForkEpoch = 3
 	cfg.DenebForkEpoch = 4
 	cfg.ElectraForkEpoch = 5
-	cfg.FuluForkEpoch = 6
 	cfg.ForkVersionSchedule[[4]byte{1, 0, 0, 0}] = 1
 	cfg.ForkVersionSchedule[[4]byte{2, 0, 0, 0}] = 2
 	cfg.ForkVersionSchedule[[4]byte{3, 0, 0, 0}] = 3
 	cfg.ForkVersionSchedule[[4]byte{4, 0, 0, 0}] = 4
 	cfg.ForkVersionSchedule[[4]byte{5, 0, 0, 0}] = 5
-	cfg.ForkVersionSchedule[[4]byte{6, 0, 0, 0}] = 6
 	params.OverrideBeaconConfig(cfg)
 
 	secondsPerSlot := int(params.BeaconConfig().SecondsPerSlot)
@@ -103,10 +101,7 @@ func TestValidateLightClientOptimisticUpdate(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		for v := range version.All() {
-			if v == version.Phase0 {
-				continue
-			}
+		for v := 1; v < 6; v++ {
 			t.Run(test.name+"_"+version.String(v), func(t *testing.T) {
 				ctx := t.Context()
 				p := p2ptest.NewTestP2P(t)
@@ -185,13 +180,11 @@ func TestValidateLightClientFinalityUpdate(t *testing.T) {
 	cfg.CapellaForkEpoch = 3
 	cfg.DenebForkEpoch = 4
 	cfg.ElectraForkEpoch = 5
-	cfg.FuluForkEpoch = 6
 	cfg.ForkVersionSchedule[[4]byte{1, 0, 0, 0}] = 1
 	cfg.ForkVersionSchedule[[4]byte{2, 0, 0, 0}] = 2
 	cfg.ForkVersionSchedule[[4]byte{3, 0, 0, 0}] = 3
 	cfg.ForkVersionSchedule[[4]byte{4, 0, 0, 0}] = 4
 	cfg.ForkVersionSchedule[[4]byte{5, 0, 0, 0}] = 5
-	cfg.ForkVersionSchedule[[4]byte{6, 0, 0, 0}] = 6
 	params.OverrideBeaconConfig(cfg)
 
 	secondsPerSlot := int(params.BeaconConfig().SecondsPerSlot)
@@ -234,10 +227,7 @@ func TestValidateLightClientFinalityUpdate(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		for v := range version.All() {
-			if v == version.Phase0 {
-				continue
-			}
+		for v := 1; v < 6; v++ {
 			t.Run(test.name+"_"+version.String(v), func(t *testing.T) {
 				ctx := t.Context()
 				p := p2ptest.NewTestP2P(t)

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"
@@ -361,7 +360,7 @@ func (dv *RODataColumnsVerifier) SidecarParentSeen(parentSeen func([fieldparams.
 		}
 
 		if !dv.fc.HasNode(parentRoot) {
-			return columnErrBuilder(errors.Wrapf(errSidecarParentNotSeen, "parent root: %#x", parentRoot))
+			return columnErrBuilder(errSidecarParentNotSeen)
 		}
 	}
 
@@ -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/avoid_kzg_send_after_context_cancel.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Prevent blocked sends to the KZG batch verifier when the caller context is already canceled, avoiding useless queueing and potential hangs.

changelog/bastin_fix-lcp2p-bug.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Fix the missing fork version object mapping for Fulu in light client p2p.

changelog/james-prysm_align-atter-pool-apis.md

@@ -1,3 +0,0 @@
-### Changed
-
-- the /eth/v2/beacon/pool/attestations and /eth/v1/beacon/pool/sync_committees now returns a 503 error if the node is still syncing, the rest api is also working in a similar process to gRPC broadcasting immediately now.

changelog/james-prysm_skip-e2e-slot1-check.md

@@ -1,3 +0,0 @@
-### Changed
-
-- e2e sync committee evaluator now skips the first slot after startup, we already skip the fork epoch for checks here, this skip only applies on startup, due to altair always from 0 and validators need to warm up.

changelog/manu-agg.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Pending aggregates: When multiple aggregated attestations only differing by the aggregator index are in the pending queue, only process one of them.

changelog/manu-remove-error-logs.md

@@ -1,2 +0,0 @@
-### Changed
-- `validateDataColumn`: Remove error logs.

changelog/manu_reconstruct-metrics.md

@@ -1,7 +0,0 @@
-### Added
-- prometheus histogram `cells_and_proofs_from_structured_computation_milliseconds` to track computation time for cells and proofs from structured blobs.
-- prometheus histogram `get_blobs_v2_latency_milliseconds` to track RPC latency for `getBlobsV2` calls to the execution layer.
-
-### Changed
-- Run `ComputeCellsAndProofsFromFlat` in parallel to improve performance when computing cells and proofs.
-- Run `ComputeCellsAndProofsFromStructured` in parallel to improve performance when computing cells and proofs.

changelog/potuz_remove_proposer_cache.md

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

changelog/radek_improve-att-cache.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Make experimental att cache fully functional.

testing/endtoend/evaluators/validator.go

@@ -262,11 +262,6 @@ func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.Clie
 			// Skip fork slot.
 			continue
 		}
-		// Skip slot 1 at genesis - validators need time to ramp up after chain start.
-		// This is a startup timing issue, not a fork transition issue.
-		if b.Block().Slot() == 1 {
-			continue
-		}
 		expectedParticipation := expectedSyncParticipation
 		switch slots.ToEpoch(b.Block().Slot()) {
 		case params.BeaconConfig().AltairForkEpoch: