remove unused type def

* ser/des methods for BlobSidecarsByRootReq

* lint

---------

Co-authored-by: Kasey Kirkham <kasey@users.noreply.github.com>

README.md

@@ -2,8 +2,8 @@
 
 [![Build status](https://badge.buildkite.com/b555891daf3614bae4284dcf365b2340cefc0089839526f096.svg?branch=master)](https://buildkite.com/prysmatic-labs/prysm)
 [![Go Report Card](https://goreportcard.com/badge/github.com/prysmaticlabs/prysm)](https://goreportcard.com/report/github.com/prysmaticlabs/prysm)
-[![Consensus_Spec_Version 1.2.0](https://img.shields.io/badge/Consensus%20Spec%20Version-v1.2.0-blue.svg)](https://github.com/ethereum/consensus-specs/tree/v1.2.0)
-[![Execution_API_Version 1.0.0-beta.1](https://img.shields.io/badge/Execution%20API%20Version-v1.0.0.beta.1-blue.svg)](https://github.com/ethereum/execution-apis/tree/v1.0.0-beta.1/src/engine)
+[![Consensus_Spec_Version 1.3.0](https://img.shields.io/badge/Consensus%20Spec%20Version-v1.3.0-blue.svg)](https://github.com/ethereum/consensus-specs/tree/v1.3.0)
+[![Execution_API_Version 1.0.0-beta.2](https://img.shields.io/badge/Execution%20API%20Version-v1.0.0.beta.2-blue.svg)](https://github.com/ethereum/execution-apis/tree/v1.0.0-beta.2/src/engine)
 [![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)
 [![GitPOAP Badge](https://public-api.gitpoap.io/v1/repo/prysmaticlabs/prysm/badge)](https://www.gitpoap.io/gh/prysmaticlabs/prysm)
 

beacon-chain/blockchain/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "chain_info.go",
+        "chain_info_forkchoice.go",
         "error.go",
         "execution_engine.go",
         "forkchoice_update_execution.go",

beacon-chain/blockchain/chain_info.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
@@ -15,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
+	ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 	"go.opencensus.io/trace"
@@ -37,12 +37,16 @@ type ChainInfoFetcher interface {
 // of locking forkchoice
 type ForkchoiceFetcher interface {
 	Ancestor(context.Context, []byte, primitives.Slot) ([]byte, error)
-}
-
-// HeadUpdater defines a common interface for methods in blockchain service
-// which allow to update the head info
-type HeadUpdater interface {
+	CachedHeadRoot() [32]byte
+	GetProposerHead() [32]byte
+	SetForkChoiceGenesisTime(uint64)
 	UpdateHead(context.Context, primitives.Slot)
+	HighestReceivedBlockSlot() primitives.Slot
+	ReceivedBlocksLastEpoch() (uint64, error)
+	InsertNode(context.Context, state.BeaconState, [32]byte) error
+	ForkChoiceDump(context.Context) (*ethpbv1.ForkChoiceDump, error)
+	NewSlot(context.Context, primitives.Slot) error
+	ProposerBoost() [32]byte
 }
 
 // TimeFetcher retrieves the Ethereum consensus data that's related to time.
@@ -76,7 +80,6 @@ type HeadFetcher interface {
 
 // ForkFetcher retrieves the current fork information of the Ethereum beacon chain.
 type ForkFetcher interface {
-	ForkChoicer() forkchoice.ForkChoicer
 	CurrentFork() *ethpb.Fork
 	GenesisFetcher
 	TimeFetcher
@@ -105,25 +108,25 @@ type OptimisticModeFetcher interface {
 
 // FinalizedCheckpt returns the latest finalized checkpoint from chain store.
 func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
-	s.ForkChoicer().RLock()
-	defer s.ForkChoicer().RUnlock()
-	cp := s.ForkChoicer().FinalizedCheckpoint()
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	return &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
 }
 
 // PreviousJustifiedCheckpt returns the current justified checkpoint from chain store.
 func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
-	s.ForkChoicer().RLock()
-	defer s.ForkChoicer().RUnlock()
-	cp := s.ForkChoicer().PreviousJustifiedCheckpoint()
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	cp := s.cfg.ForkChoiceStore.PreviousJustifiedCheckpoint()
 	return &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
 }
 
 // CurrentJustifiedCheckpt returns the current justified checkpoint from chain store.
 func (s *Service) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
-	s.ForkChoicer().RLock()
-	defer s.ForkChoicer().RUnlock()
-	cp := s.ForkChoicer().JustifiedCheckpoint()
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	cp := s.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	return &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
 }
 
@@ -286,8 +289,8 @@ func (s *Service) CurrentFork() *ethpb.Fork {
 
 // IsCanonical returns true if the input block root is part of the canonical chain.
 func (s *Service) IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error) {
-	s.ForkChoicer().RLock()
-	defer s.ForkChoicer().RUnlock()
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
 	// If the block has not been finalized, check fork choice store to see if the block is canonical
 	if s.cfg.ForkChoiceStore.HasNode(blockRoot) {
 		return s.cfg.ForkChoiceStore.IsCanonical(blockRoot), nil
@@ -297,14 +300,6 @@ func (s *Service) IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, er
 	return s.cfg.BeaconDB.IsFinalizedBlock(ctx, blockRoot), nil
 }
 
-// ChainHeads returns all possible chain heads (leaves of fork choice tree).
-// Heads roots and heads slots are returned.
-func (s *Service) ChainHeads() ([][32]byte, []primitives.Slot) {
-	s.ForkChoicer().RLock()
-	defer s.ForkChoicer().RUnlock()
-	return s.cfg.ForkChoiceStore.Tips()
-}
-
 // HeadPublicKeyToValidatorIndex returns the validator index of the `pubkey` in current head state.
 func (s *Service) HeadPublicKeyToValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (primitives.ValidatorIndex, bool) {
 	s.headLock.RLock()
@@ -329,11 +324,6 @@ func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index primiti
 	return v.PublicKey(), nil
 }
 
-// ForkChoicer returns the forkchoice interface.
-func (s *Service) ForkChoicer() forkchoice.ForkChoicer {
-	return s.cfg.ForkChoiceStore
-}
-
 // IsOptimistic returns true if the current head is optimistic.
 func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
 	if slots.ToEpoch(s.CurrentSlot()) < params.BeaconConfig().BellatrixForkEpoch {
@@ -343,8 +333,8 @@ func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
 	headRoot := s.head.root
 	s.headLock.RUnlock()
 
-	s.ForkChoicer().RLock()
-	defer s.ForkChoicer().RUnlock()
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
 	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(headRoot)
 	if err == nil {
 		return optimistic, nil
@@ -360,14 +350,14 @@ func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
 // IsFinalized returns true if the input root is finalized.
 // It first checks latest finalized root then checks finalized root index in DB.
 func (s *Service) IsFinalized(ctx context.Context, root [32]byte) bool {
-	s.ForkChoicer().RLock()
-	defer s.ForkChoicer().RUnlock()
-	if s.ForkChoicer().FinalizedCheckpoint().Root == root {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	if s.cfg.ForkChoiceStore.FinalizedCheckpoint().Root == root {
 		return true
 	}
 	// If node exists in our store, then it is not
 	// finalized.
-	if s.ForkChoicer().HasNode(root) {
+	if s.cfg.ForkChoiceStore.HasNode(root) {
 		return false
 	}
 	return s.cfg.BeaconDB.IsFinalizedBlock(ctx, root)
@@ -377,17 +367,17 @@ func (s *Service) IsFinalized(ctx context.Context, root [32]byte) bool {
 // This in particular means that the blockroot is a descendant of the
 // finalized checkpoint
 func (s *Service) InForkchoice(root [32]byte) bool {
-	s.ForkChoicer().RLock()
-	defer s.ForkChoicer().RUnlock()
-	return s.ForkChoicer().HasNode(root)
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.HasNode(root)
 }
 
 // IsOptimisticForRoot takes the root as argument instead of the current head
 // and returns true if it is optimistic.
 func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) {
-	s.ForkChoicer().RLock()
+	s.cfg.ForkChoiceStore.RLock()
 	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(root)
-	s.ForkChoicer().RUnlock()
+	s.cfg.ForkChoiceStore.RUnlock()
 	if err == nil {
 		return optimistic, nil
 	}
@@ -465,9 +455,9 @@ func (s *Service) Ancestor(ctx context.Context, root []byte, slot primitives.Slo
 	r := bytesutil.ToBytes32(root)
 	// Get ancestor root from fork choice store instead of recursively looking up blocks in DB.
 	// This is most optimal outcome.
-	s.ForkChoicer().RLock()
+	s.cfg.ForkChoiceStore.RLock()
 	ar, err := s.cfg.ForkChoiceStore.AncestorRoot(ctx, r, slot)
-	s.ForkChoicer().RUnlock()
+	s.cfg.ForkChoiceStore.RUnlock()
 	if err != nil {
 		// Try getting ancestor root from DB when failed to retrieve from fork choice store.
 		// This is the second line of defense for retrieving ancestor root.
@@ -484,8 +474,3 @@ func (s *Service) Ancestor(ctx context.Context, root []byte, slot primitives.Slo
 func (s *Service) SetGenesisTime(t time.Time) {
 	s.genesisTime = t
 }
-
-// ForkChoiceStore returns the fork choice store in the service.
-func (s *Service) ForkChoiceStore() forkchoice.ForkChoicer {
-	return s.cfg.ForkChoiceStore
-}

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -0,0 +1,80 @@
+package blockchain
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
+	ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
+)
+
+// CachedHeadRoot returns the corresponding value from Forkchoice
+func (s *Service) CachedHeadRoot() [32]byte {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.CachedHeadRoot()
+}
+
+// GetProposerHead returns the corresponding value from forkchoice
+func (s *Service) GetProposerHead() [32]byte {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.GetProposerHead()
+}
+
+// SetForkChoiceGenesisTime sets the genesis time in Forkchoice
+func (s *Service) SetForkChoiceGenesisTime(timestamp uint64) {
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
+	s.cfg.ForkChoiceStore.SetGenesisTime(timestamp)
+}
+
+// HighestReceivedBlockSlot returns the corresponding value from forkchoice
+func (s *Service) HighestReceivedBlockSlot() primitives.Slot {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.HighestReceivedBlockSlot()
+}
+
+// ReceivedBlocksLastEpoch returns the corresponding value from forkchoice
+func (s *Service) ReceivedBlocksLastEpoch() (uint64, error) {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.ReceivedBlocksLastEpoch()
+}
+
+// InsertNode is a wrapper for node insertion which is self locked
+func (s *Service) InsertNode(ctx context.Context, st state.BeaconState, root [32]byte) error {
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
+	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, root)
+}
+
+// ForkChoiceDump returns the corresponding value from forkchoice
+func (s *Service) ForkChoiceDump(ctx context.Context) (*ethpbv1.ForkChoiceDump, error) {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.ForkChoiceDump(ctx)
+}
+
+// NewSlot returns the corresponding value from forkchoice
+func (s *Service) NewSlot(ctx context.Context, slot primitives.Slot) error {
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
+	return s.cfg.ForkChoiceStore.NewSlot(ctx, slot)
+}
+
+// ProposerBoost wraps the corresponding method from forkchoice
+func (s *Service) ProposerBoost() [32]byte {
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
+	return s.cfg.ForkChoiceStore.ProposerBoost()
+}
+
+// ChainHeads returns all possible chain heads (leaves of fork choice tree).
+// Heads roots and heads slots are returned.
+func (s *Service) ChainHeads() ([][32]byte, []primitives.Slot) {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.Tips()
+}

beacon-chain/blockchain/chain_info_test.go

@@ -71,12 +71,6 @@ func TestHeadRoot_Nil(t *testing.T) {
 	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], headRoot, "Incorrect pre chain start value")
 }
 
-func TestService_ForkChoiceStore(t *testing.T) {
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
-	p := c.ForkChoiceStore()
-	require.Equal(t, primitives.Epoch(0), p.FinalizedCheckpoint().Epoch)
-}
-
 func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
@@ -559,7 +553,7 @@ func TestService_IsFinalized(t *testing.T) {
 	ctx := context.Background()
 	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}}
 	r1 := [32]byte{'a'}
-	require.NoError(t, c.ForkChoiceStore().UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{
+	require.NoError(t, c.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{
 		Root: r1,
 	}))
 	b := util.NewBeaconBlock()

beacon-chain/blockchain/execution_engine.go

@@ -60,8 +60,8 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 		log.WithError(err).Error("Could not get execution payload for head block")
 		return nil, nil
 	}
-	finalizedHash := s.ForkChoicer().FinalizedPayloadBlockHash()
-	justifiedHash := s.ForkChoicer().JustifiedPayloadBlockHash()
+	finalizedHash := s.cfg.ForkChoiceStore.FinalizedPayloadBlockHash()
+	justifiedHash := s.cfg.ForkChoiceStore.JustifiedPayloadBlockHash()
 	fcs := &enginev1.ForkchoiceState{
 		HeadBlockHash:      headPayload.BlockHash(),
 		SafeBlockHash:      justifiedHash[:],
@@ -88,7 +88,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 			if len(lastValidHash) == 0 {
 				lastValidHash = defaultLatestValidHash
 			}
-			invalidRoots, err := s.ForkChoicer().SetOptimisticToInvalid(ctx, headRoot, headBlk.ParentRoot(), bytesutil.ToBytes32(lastValidHash))
+			invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, headRoot, headBlk.ParentRoot(), bytesutil.ToBytes32(lastValidHash))
 			if err != nil {
 				log.WithError(err).Error("Could not set head root to invalid")
 				return nil, nil
@@ -224,7 +224,7 @@ func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion int,
 		if err != nil {
 			return false, err
 		}
-		invalidRoots, err := s.ForkChoicer().SetOptimisticToInvalid(ctx, root, blk.Block().ParentRoot(), bytesutil.ToBytes32(lastValidHash))
+		invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, root, blk.Block().ParentRoot(), bytesutil.ToBytes32(lastValidHash))
 		if err != nil {
 			return false, err
 		}

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -89,13 +89,13 @@ func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, newHeadRoot
 // shouldOverrideFCU checks whether the incoming block is still subject to being
 // reorged or not by the next proposer.
 func (s *Service) shouldOverrideFCU(newHeadRoot [32]byte, proposingSlot primitives.Slot) bool {
-	headWeight, err := s.ForkChoicer().Weight(newHeadRoot)
+	headWeight, err := s.cfg.ForkChoiceStore.Weight(newHeadRoot)
 	if err != nil {
 		log.WithError(err).WithField("root", fmt.Sprintf("%#x", newHeadRoot)).Warn("could not determine node weight")
 	}
 	currentSlot := s.CurrentSlot()
 	if proposingSlot == currentSlot {
-		proposerHead := s.ForkChoicer().GetProposerHead()
+		proposerHead := s.cfg.ForkChoiceStore.GetProposerHead()
 		if proposerHead != newHeadRoot {
 			return true
 		}
@@ -106,7 +106,7 @@ func (s *Service) shouldOverrideFCU(newHeadRoot [32]byte, proposingSlot primitiv
 			params.BeaconConfig().SecondsPerSlot)
 		lateBlockFailedAttemptSecondThreshold.Inc()
 	} else {
-		if s.ForkChoicer().ShouldOverrideFCU() {
+		if s.cfg.ForkChoiceStore.ShouldOverrideFCU() {
 			return true
 		}
 		secs, err := slots.SecondsSinceSlotStart(currentSlot,

beacon-chain/blockchain/head.go

@@ -28,6 +28,8 @@ import (
 // UpdateAndSaveHeadWithBalances updates the beacon state head after getting justified balanced from cache.
 // This function is only used in spec-tests, it does save the head after updating it.
 func (s *Service) UpdateAndSaveHeadWithBalances(ctx context.Context) error {
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
 	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not update head")
@@ -94,18 +96,18 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 	}
 	oldHeadRoot := bytesutil.ToBytes32(r)
 	if headBlock.Block().ParentRoot() != oldHeadRoot {
-		commonRoot, forkSlot, err := s.ForkChoicer().CommonAncestor(ctx, oldHeadRoot, newHeadRoot)
+		commonRoot, forkSlot, err := s.cfg.ForkChoiceStore.CommonAncestor(ctx, oldHeadRoot, newHeadRoot)
 		if err != nil {
 			log.WithError(err).Error("Could not find common ancestor root")
 			commonRoot = params.BeaconConfig().ZeroHash
 		}
 		dis := headSlot + newHeadSlot - 2*forkSlot
 		dep := math.Max(uint64(headSlot-forkSlot), uint64(newHeadSlot-forkSlot))
-		oldWeight, err := s.ForkChoicer().Weight(oldHeadRoot)
+		oldWeight, err := s.cfg.ForkChoiceStore.Weight(oldHeadRoot)
 		if err != nil {
 			log.WithField("root", fmt.Sprintf("%#x", oldHeadRoot)).Warn("could not determine node weight")
 		}
-		newWeight, err := s.ForkChoicer().Weight(newHeadRoot)
+		newWeight, err := s.cfg.ForkChoiceStore.Weight(newHeadRoot)
 		if err != nil {
 			log.WithField("root", fmt.Sprintf("%#x", newHeadRoot)).Warn("could not determine node weight")
 		}
@@ -123,7 +125,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 		reorgDistance.Observe(float64(dis))
 		reorgDepth.Observe(float64(dep))
 
-		isOptimistic, err := s.ForkChoicer().IsOptimistic(newHeadRoot)
+		isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(newHeadRoot)
 		if err != nil {
 			return errors.Wrap(err, "could not check if node is optimistically synced")
 		}
@@ -363,7 +365,7 @@ func (s *Service) notifyNewHeadEvent(
 // This saves the Attestations and BLSToExecChanges between `orphanedRoot` and the common ancestor root that is derived using `newHeadRoot`.
 // It also filters out the attestations that is one epoch older as a defense so invalid attestations don't flow into the attestation pool.
 func (s *Service) saveOrphanedOperations(ctx context.Context, orphanedRoot [32]byte, newHeadRoot [32]byte) error {
-	commonAncestorRoot, _, err := s.ForkChoicer().CommonAncestor(ctx, newHeadRoot, orphanedRoot)
+	commonAncestorRoot, _, err := s.cfg.ForkChoiceStore.CommonAncestor(ctx, newHeadRoot, orphanedRoot)
 	switch {
 	// Exit early if there's no common ancestor and root doesn't exist, there would be nothing to save.
 	case errors.Is(err, forkchoice.ErrUnknownCommonAncestor):

beacon-chain/blockchain/head_test.go

@@ -308,7 +308,7 @@ func TestSaveOrphanedAtts(t *testing.T) {
 		require.NoError(t, err)
 		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
+		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
 	}
 
@@ -373,7 +373,7 @@ func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
 		require.NoError(t, err)
 		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
+		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
 	}
 
@@ -431,7 +431,7 @@ func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
 		require.NoError(t, err)
 		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
+		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
 	}
 
@@ -490,7 +490,7 @@ func TestSaveOrphanedAtts_CanFilter_DoublyLinkedTrie(t *testing.T) {
 		require.NoError(t, err)
 		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
-		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
+		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
 	}
 

beacon-chain/blockchain/process_block.go

@@ -108,13 +108,13 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 	}
 
 	// Verify that the parent block is in forkchoice
-	if !s.ForkChoicer().HasNode(b.ParentRoot()) {
+	if !s.cfg.ForkChoiceStore.HasNode(b.ParentRoot()) {
 		return ErrNotDescendantOfFinalized
 	}
 
 	// Save current justified and finalized epochs for future use.
-	currStoreJustifiedEpoch := s.ForkChoicer().JustifiedCheckpoint().Epoch
-	currStoreFinalizedEpoch := s.ForkChoicer().FinalizedCheckpoint().Epoch
+	currStoreJustifiedEpoch := s.cfg.ForkChoiceStore.JustifiedCheckpoint().Epoch
+	currStoreFinalizedEpoch := s.cfg.ForkChoiceStore.FinalizedCheckpoint().Epoch
 	preStateFinalizedEpoch := preState.FinalizedCheckpoint().Epoch
 	preStateJustifiedEpoch := preState.CurrentJustifiedCheckpoint().Epoch
 
@@ -187,18 +187,18 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 		}()
 	}
 
-	justified := s.ForkChoicer().JustifiedCheckpoint()
+	justified := s.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	start := time.Now()
 	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx)
 	if err != nil {
 		log.WithError(err).Warn("Could not update head")
 	}
 	if blockRoot != headRoot {
-		receivedWeight, err := s.ForkChoicer().Weight(blockRoot)
+		receivedWeight, err := s.cfg.ForkChoiceStore.Weight(blockRoot)
 		if err != nil {
 			log.WithField("root", fmt.Sprintf("%#x", blockRoot)).Warn("could not determine node weight")
 		}
-		headWeight, err := s.ForkChoicer().Weight(headRoot)
+		headWeight, err := s.cfg.ForkChoiceStore.Weight(headRoot)
 		if err != nil {
 			log.WithField("root", fmt.Sprintf("%#x", headRoot)).Warn("could not determine node weight")
 		}
@@ -252,7 +252,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 
 	// Save finalized check point to db and more.
 	postStateFinalizedEpoch := postState.FinalizedCheckpoint().Epoch
-	finalized := s.ForkChoicer().FinalizedCheckpoint()
+	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	if finalized.Epoch > currStoreFinalizedEpoch || (finalized.Epoch == postStateFinalizedEpoch && finalized.Epoch > preStateFinalizedEpoch) {
 		if err := s.updateFinalized(ctx, &ethpb.Checkpoint{Epoch: finalized.Epoch, Root: finalized.Root[:]}); err != nil {
 			return err
@@ -576,7 +576,7 @@ func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashing
 	for _, slashing := range slashings {
 		indices := blocks.SlashableAttesterIndices(slashing)
 		for _, index := range indices {
-			s.ForkChoicer().InsertSlashedIndex(ctx, primitives.ValidatorIndex(index))
+			s.cfg.ForkChoiceStore.InsertSlashedIndex(ctx, primitives.ValidatorIndex(index))
 		}
 	}
 }

beacon-chain/blockchain/process_block_helpers.go

@@ -85,7 +85,7 @@ func (s *Service) verifyBlkPreState(ctx context.Context, b interfaces.ReadOnlyBe
 // verifyBlkFinalizedSlot validates input block is not less than or equal
 // to current finalized slot.
 func (s *Service) verifyBlkFinalizedSlot(b interfaces.ReadOnlyBeaconBlock) error {
-	finalized := s.ForkChoicer().FinalizedCheckpoint()
+	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	finalizedSlot, err := slots.EpochStart(finalized.Epoch)
 	if err != nil {
 		return err
@@ -177,7 +177,7 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa
 	pendingNodes := make([]*forkchoicetypes.BlockAndCheckpoints, 0)
 
 	// Fork choice only matters from last finalized slot.
-	finalized := s.ForkChoicer().FinalizedCheckpoint()
+	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	fSlot, err := slots.EpochStart(finalized.Epoch)
 	if err != nil {
 		return err
@@ -203,7 +203,7 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa
 	if len(pendingNodes) == 1 {
 		return nil
 	}
-	if root != s.ensureRootNotZeros(finalized.Root) && !s.ForkChoicer().HasNode(root) {
+	if root != s.ensureRootNotZeros(finalized.Root) && !s.cfg.ForkChoiceStore.HasNode(root) {
 		return ErrNotDescendantOfFinalized
 	}
 	return s.cfg.ForkChoiceStore.InsertChain(ctx, pendingNodes)

beacon-chain/blockchain/process_block_test.go

@@ -139,7 +139,7 @@ func TestStore_OnBlock(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			fRoot := bytesutil.ToBytes32(roots[0])
-			require.NoError(t, service.ForkChoicer().UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: fRoot}))
+			require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: fRoot}))
 			root, err := tt.blk.Block.HashTreeRoot()
 			assert.NoError(t, err)
 			wsb, err := consensusblocks.NewSignedBeaconBlock(tt.blk)
@@ -288,9 +288,9 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	r0 := bytesutil.ToBytes32(roots[0])
 	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, fcp, fcp)
 	require.NoError(t, err)
-	require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	fcp2 := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r0}
-	require.NoError(t, service.ForkChoicer().UpdateFinalizedCheckpoint(fcp2))
+	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(fcp2))
 
 	err = service.fillInForkChoiceMissingBlocks(
 		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
@@ -339,9 +339,9 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	r0 := bytesutil.ToBytes32(roots[0])
 	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, fcp, fcp)
 	require.NoError(t, err)
-	require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	fcp2 := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r0}
-	require.NoError(t, service.ForkChoicer().UpdateFinalizedCheckpoint(fcp2))
+	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(fcp2))
 
 	err = service.fillInForkChoiceMissingBlocks(
 		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
@@ -406,7 +406,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
 
 	// Set finalized epoch to 2.
-	require.NoError(t, service.ForkChoicer().UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 2, Root: r64}))
+	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 2, Root: r64}))
 	err = service.fillInForkChoiceMissingBlocks(
 		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
@@ -1363,7 +1363,7 @@ func Test_verifyBlkFinalizedSlot_invalidBlock(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	require.NoError(t, service.ForkChoicer().UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 1}))
+	require.NoError(t, service.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 1}))
 	blk := util.HydrateBeaconBlock(&ethpb.BeaconBlock{Slot: 1})
 	wb, err := consensusblocks.NewBeaconBlock(blk)
 	require.NoError(t, err)
@@ -1459,7 +1459,7 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 		require.NoError(t, err)
 	}
 	// Check that we haven't justified the second epoch yet
-	jc := service.ForkChoicer().JustifiedCheckpoint()
+	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(0), jc.Epoch)
 
 	// import a block that justifies the second epoch
@@ -1474,14 +1474,14 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 	require.NoError(t, err)
 	err = service.onBlock(ctx, wsb, firstInvalidRoot)
 	require.NoError(t, err)
-	jc = service.ForkChoicer().JustifiedCheckpoint()
+	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
 
 	sjc := validHeadState.CurrentJustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(0), sjc.Epoch)
 	lvh := b.Block.Body.ExecutionPayload.ParentHash
 	// check our head
-	require.Equal(t, firstInvalidRoot, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, firstInvalidRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 
 	// import another block to find out that it was invalid
 	mockEngine = &mockExecution.EngineClient{ErrNewPayload: execution.ErrAcceptedSyncingPayloadStatus, ErrForkchoiceUpdated: execution.ErrInvalidPayloadStatus, ForkChoiceUpdatedResp: lvh}
@@ -1500,7 +1500,7 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 	// Check that forkchoice's head is the last invalid block imported. The
 	// store's headroot is the previous head (since the invalid block did
 	// not finish importing) one and that the node is optimistic
-	require.Equal(t, root, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	headRoot, err := service.HeadRoot(ctx)
 	require.NoError(t, err)
 	require.Equal(t, firstInvalidRoot, bytesutil.ToBytes32(headRoot))
@@ -1522,7 +1522,7 @@ func TestStore_NoViableHead_FCU(t *testing.T) {
 	require.NoError(t, err)
 	// Check the newly imported block is head, it justified the right
 	// checkpoint and the node is no longer optimistic
-	require.Equal(t, root, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	sjc = service.CurrentJustifiedCheckpt()
 	require.Equal(t, jc.Epoch, sjc.Epoch)
 	require.Equal(t, jc.Root, bytesutil.ToBytes32(sjc.Root))
@@ -1619,7 +1619,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, err)
 	}
 	// Check that we haven't justified the second epoch yet
-	jc := service.ForkChoicer().JustifiedCheckpoint()
+	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(0), jc.Epoch)
 
 	// import a block that justifies the second epoch
@@ -1634,14 +1634,14 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, err)
 	err = service.onBlock(ctx, wsb, firstInvalidRoot)
 	require.NoError(t, err)
-	jc = service.ForkChoicer().JustifiedCheckpoint()
+	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
 
 	sjc := validHeadState.CurrentJustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(0), sjc.Epoch)
 	lvh := b.Block.Body.ExecutionPayload.ParentHash
 	// check our head
-	require.Equal(t, firstInvalidRoot, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, firstInvalidRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 
 	// import another block to find out that it was invalid
 	mockEngine = &mockExecution.EngineClient{ErrNewPayload: execution.ErrInvalidPayloadStatus, NewPayloadResp: lvh}
@@ -1660,7 +1660,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	// Check that forkchoice's head and store's headroot are the previous head (since the invalid block did
 	// not finish importing and it was never imported to forkchoice). Check
 	// also that the node is optimistic
-	require.Equal(t, firstInvalidRoot, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, firstInvalidRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	headRoot, err := service.HeadRoot(ctx)
 	require.NoError(t, err)
 	require.Equal(t, firstInvalidRoot, bytesutil.ToBytes32(headRoot))
@@ -1682,7 +1682,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, err)
 	// Check the newly imported block is head, it justified the right
 	// checkpoint and the node is no longer optimistic
-	require.Equal(t, root, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	sjc = service.CurrentJustifiedCheckpt()
 	require.Equal(t, jc.Epoch, sjc.Epoch)
 	require.Equal(t, jc.Root, bytesutil.ToBytes32(sjc.Root))
@@ -1802,9 +1802,9 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, err)
 	}
 	// Check that we have justified the second epoch
-	jc := service.ForkChoicer().JustifiedCheckpoint()
+	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
-	invalidHeadRoot := service.ForkChoicer().CachedHeadRoot()
+	invalidHeadRoot := service.cfg.ForkChoiceStore.CachedHeadRoot()
 
 	// import block 19 to find out that the whole chain 13--18 was in fact
 	// invalid
@@ -1825,7 +1825,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	// Check that forkchoice's head and store's headroot are the previous head (since the invalid block did
 	// not finish importing and it was never imported to forkchoice). Check
 	// also that the node is optimistic
-	require.Equal(t, invalidHeadRoot, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, invalidHeadRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	headRoot, err := service.HeadRoot(ctx)
 	require.NoError(t, err)
 	require.Equal(t, invalidHeadRoot, bytesutil.ToBytes32(headRoot))
@@ -1855,7 +1855,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, service.onBlock(ctx, wsb, root))
 	// Check that the head is still INVALID and the node is still optimistic
-	require.Equal(t, invalidHeadRoot, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, invalidHeadRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	optimistic, err = service.IsOptimistic(ctx)
 	require.NoError(t, err)
 	require.Equal(t, true, optimistic)
@@ -1877,7 +1877,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, err)
 	}
 	// Head should still be INVALID and the node optimistic
-	require.Equal(t, invalidHeadRoot, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, invalidHeadRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	optimistic, err = service.IsOptimistic(ctx)
 	require.NoError(t, err)
 	require.Equal(t, true, optimistic)
@@ -1893,7 +1893,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, err)
 	err = service.onBlock(ctx, wsb, root)
 	require.NoError(t, err)
-	require.Equal(t, root, service.ForkChoicer().CachedHeadRoot())
+	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	sjc = service.CurrentJustifiedCheckpt()
 	require.Equal(t, primitives.Epoch(4), sjc.Epoch)
 	optimistic, err = service.IsOptimistic(ctx)
@@ -2011,7 +2011,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, service.onBlock(ctx, wsb, root))
 	}
 	// Check that we have justified the second epoch
-	jc := service.ForkChoicer().JustifiedCheckpoint()
+	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
 
 	// import block 19 to find out that the whole chain 13--18 was in fact
@@ -2045,7 +2045,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, service.StartFromSavedState(genesisState))
 
 	// Forkchoice has the genesisRoot loaded at startup
-	require.Equal(t, genesisRoot, service.ensureRootNotZeros(service.ForkChoicer().CachedHeadRoot()))
+	require.Equal(t, genesisRoot, service.ensureRootNotZeros(service.cfg.ForkChoiceStore.CachedHeadRoot()))
 	// Service's store has the finalized state as headRoot
 	headRoot, err := service.HeadRoot(ctx)
 	require.NoError(t, err)
@@ -2072,7 +2072,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	// We use onBlockBatch here because the valid chain is missing in forkchoice
 	require.NoError(t, service.onBlockBatch(ctx, []interfaces.ReadOnlySignedBeaconBlock{wsb}, [][32]byte{root}))
 	// Check that the head is now VALID and the node is not optimistic
-	require.Equal(t, genesisRoot, service.ensureRootNotZeros(service.ForkChoicer().CachedHeadRoot()))
+	require.Equal(t, genesisRoot, service.ensureRootNotZeros(service.cfg.ForkChoiceStore.CachedHeadRoot()))
 	headRoot, err = service.HeadRoot(ctx)
 	require.NoError(t, err)
 	require.Equal(t, root, bytesutil.ToBytes32(headRoot))

beacon-chain/blockchain/receive_attestation.go

@@ -100,17 +100,15 @@ func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
 			case <-s.ctx.Done():
 				return
 			case <-pat.C():
-				s.ForkChoicer().Lock()
 				s.UpdateHead(s.ctx, s.CurrentSlot()+1)
-				s.ForkChoicer().Unlock()
 			case <-st.C():
-				s.ForkChoicer().Lock()
-				if err := s.ForkChoicer().NewSlot(s.ctx, s.CurrentSlot()); err != nil {
+				s.cfg.ForkChoiceStore.Lock()
+				if err := s.cfg.ForkChoiceStore.NewSlot(s.ctx, s.CurrentSlot()); err != nil {
 					log.WithError(err).Error("could not process new slot")
 				}
+				s.cfg.ForkChoiceStore.Unlock()
 
 				s.UpdateHead(s.ctx, s.CurrentSlot())
-				s.ForkChoicer().Unlock()
 			}
 		}
 	}()
@@ -120,7 +118,8 @@ func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
 // The caller of this function MUST hold a lock in forkchoice
 func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot) {
 	start := time.Now()
-
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
 	// This function is only called at 10 seconds or 0 seconds into the slot
 	disparity := params.BeaconNetworkConfig().MaximumGossipClockDisparity
 	if !features.Get().DisableReorgLateBlocks {

beacon-chain/blockchain/receive_block.go

@@ -67,12 +67,12 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 
 	// Reports on block and fork choice metrics.
-	cp := s.ForkChoicer().FinalizedCheckpoint()
+	cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	finalized := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
 	reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
 
 	// Log block sync status.
-	cp = s.ForkChoicer().JustifiedCheckpoint()
+	cp = s.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	justified := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
 	if err := logBlockSyncStatus(blockCopy.Block(), blockRoot, justified, finalized, receivedTime, uint64(s.genesisTime.Unix())); err != nil {
 		log.WithError(err).Error("Unable to log block sync status")
@@ -123,7 +123,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Rea
 		})
 
 		// Reports on blockCopy and fork choice metrics.
-		cp := s.ForkChoicer().FinalizedCheckpoint()
+		cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 		finalized := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
 		reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
 	}
@@ -131,7 +131,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Rea
 	if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
 		return err
 	}
-	finalized := s.ForkChoicer().FinalizedCheckpoint()
+	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	if finalized == nil {
 		return errNilFinalizedInStore
 	}
@@ -152,8 +152,8 @@ func (s *Service) HasBlock(ctx context.Context, root [32]byte) bool {
 
 // ReceiveAttesterSlashing receives an attester slashing and inserts it to forkchoice
 func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing *ethpb.AttesterSlashing) {
-	s.ForkChoicer().Lock()
-	defer s.ForkChoicer().Unlock()
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
 	s.InsertSlashingsToForkChoiceStore(ctx, []*ethpb.AttesterSlashing{slashing})
 }
 
@@ -207,7 +207,7 @@ func (s *Service) checkSaveHotStateDB(ctx context.Context) error {
 	currentEpoch := slots.ToEpoch(s.CurrentSlot())
 	// Prevent `sinceFinality` going underflow.
 	var sinceFinality primitives.Epoch
-	finalized := s.ForkChoicer().FinalizedCheckpoint()
+	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	if finalized == nil {
 		return errNilFinalizedInStore
 	}

beacon-chain/blockchain/testing/BUILD.bazel

@@ -27,6 +27,7 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
+        "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

beacon-chain/blockchain/testing/mock.go

@@ -26,6 +26,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
+	ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/sirupsen/logrus"
 )
@@ -70,13 +71,8 @@ type ChainService struct {
 	OptimisticRoots             map[[32]byte]bool
 }
 
-// ForkChoicer mocks the same method in the chain service
-func (s *ChainService) ForkChoicer() forkchoice.ForkChoicer {
-	return s.ForkChoiceStore
-}
-
 func (s *ChainService) Ancestor(ctx context.Context, root []byte, slot primitives.Slot) ([]byte, error) {
-	r, err := s.ForkChoicer().AncestorRoot(ctx, bytesutil.ToBytes32(root), slot)
+	r, err := s.ForkChoiceStore.AncestorRoot(ctx, bytesutil.ToBytes32(root), slot)
 	return r[:], err
 }
 
@@ -473,7 +469,7 @@ func (s *ChainService) UpdateHead(ctx context.Context, slot primitives.Slot) {
 	if err != nil {
 		logrus.WithError(err).Error("could not update head")
 	}
-	err = s.ForkChoicer().InsertNode(ctx, st, root)
+	err = s.ForkChoiceStore.InsertNode(ctx, st, root)
 	if err != nil {
 		logrus.WithError(err).Error("could not insert node to forkchoice")
 	}
@@ -520,3 +516,74 @@ func prepareForkchoiceState(
 	st, err := state_native.InitializeFromProtoBellatrix(base)
 	return st, blockRoot, err
 }
+
+// CachedHeadRoot mocks the same method in the chain service
+func (s *ChainService) CachedHeadRoot() [32]byte {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.CachedHeadRoot()
+	}
+	return [32]byte{}
+}
+
+// GetProposerHead mocks the same method in the chain service
+func (s *ChainService) GetProposerHead() [32]byte {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.GetProposerHead()
+	}
+	return [32]byte{}
+}
+
+// SetForkchoiceGenesisTime mocks the same method in the chain service
+func (s *ChainService) SetForkChoiceGenesisTime(timestamp uint64) {
+	if s.ForkChoiceStore != nil {
+		s.ForkChoiceStore.SetGenesisTime(timestamp)
+	}
+}
+
+// ReceivedBlocksLastEpoch mocks the same method in the chain service
+func (s *ChainService) ReceivedBlocksLastEpoch() (uint64, error) {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.ReceivedBlocksLastEpoch()
+	}
+	return 0, nil
+}
+
+// HighestReceivedBlockSlot mocks the same method in the chain service
+func (s *ChainService) HighestReceivedBlockSlot() primitives.Slot {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.HighestReceivedBlockSlot()
+	}
+	return 0
+}
+
+// InsertNode mocks the same method in the chain service
+func (s *ChainService) InsertNode(ctx context.Context, st state.BeaconState, root [32]byte) error {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.InsertNode(ctx, st, root)
+	}
+	return nil
+}
+
+// ForkChoiceDump mocks the same method in the chain service
+func (s *ChainService) ForkChoiceDump(ctx context.Context) (*ethpbv1.ForkChoiceDump, error) {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.ForkChoiceDump(ctx)
+	}
+	return nil, nil
+}
+
+// NewSlot mocks the same method in the chain service
+func (s *ChainService) NewSlot(ctx context.Context, slot primitives.Slot) error {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.NewSlot(ctx, slot)
+	}
+	return nil
+}
+
+// ProposerBoost mocks the same method in the chain service
+func (s *ChainService) ProposerBoost() [32]byte {
+	if s.ForkChoiceStore != nil {
+		return s.ForkChoiceStore.ProposerBoost()
+	}
+	return [32]byte{}
+}

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -78,7 +78,7 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 				wsVerifier: wv,
 			}
 			require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: tt.finalizedEpoch}))
-			cp := s.ForkChoicer().FinalizedCheckpoint()
+			cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 			err = s.wsVerifier.VerifyWeakSubjectivity(context.Background(), cp.Epoch)
 			if tt.wantErr == nil {
 				require.NoError(t, err)

beacon-chain/db/iface/interface.go

@@ -56,8 +56,8 @@ type ReadOnlyDatabase interface {
 	RegistrationByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
 
 	// Blob operations.
-	BlobSidecarsByRoot(ctx context.Context, beaconBlockRoot [32]byte) (*ethpb.BlobSidecars, error)
-	BlobSidecarsBySlot(ctx context.Context, slot primitives.Slot) (*ethpb.BlobSidecars, error)
+	BlobSidecarsByRoot(ctx context.Context, beaconBlockRoot [32]byte, indices ...uint64) ([]*ethpb.BlobSidecar, error)
+	BlobSidecarsBySlot(ctx context.Context, slot primitives.Slot, indices ...uint64) ([]*ethpb.BlobSidecar, error)
 
 	// origin checkpoint sync support
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
@@ -95,7 +95,7 @@ type NoHeadAccessDatabase interface {
 	SaveRegistrationsByValidatorIDs(ctx context.Context, ids []primitives.ValidatorIndex, regs []*ethpb.ValidatorRegistrationV1) error
 
 	// Blob operations.
-	SaveBlobSidecar(ctx context.Context, blobSidecars *ethpb.BlobSidecars) error
+	SaveBlobSidecar(ctx context.Context, sidecars []*ethpb.BlobSidecar) error
 	DeleteBlobSidecar(ctx context.Context, beaconBlockRoot [32]byte) error
 
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint primitives.Slot) error

beacon-chain/db/kv/BUILD.bazel

@@ -113,6 +113,7 @@ go_test(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/testing:go_default_library",
         "//testing/assert:go_default_library",
+        "//testing/assertions:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",

beacon-chain/db/kv/blob.go

@@ -22,22 +22,23 @@ import (
 //
 //  3. Begin the save algorithm:  If the incoming blob has a slot bigger than the saved slot at the spot
 //     in the rotating keys buffer, we overwrite all elements for that slot.
-func (s *Store) SaveBlobSidecar(ctx context.Context, blobSidecars *ethpb.BlobSidecars) error {
+func (s *Store) SaveBlobSidecar(ctx context.Context, scs []*ethpb.BlobSidecar) error {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveBlobSidecar")
 	defer span.End()
 
-	if blobSidecars == nil || len(blobSidecars.Sidecars) == 0 {
+	if len(scs) == 0 {
 		return errors.New("nil or empty blob sidecars")
 	}
+	slot := scs[0].Slot
 
 	return s.db.Update(func(tx *bolt.Tx) error {
-		encodedBlobSidecar, err := encode(ctx, blobSidecars)
+		encodedBlobSidecar, err := encode(ctx, &ethpb.BlobSidecars{Sidecars: scs})
 		if err != nil {
 			return err
 		}
 		bkt := tx.Bucket(blobsBucket)
 		c := bkt.Cursor()
-		newKey := blobSidecarKey(blobSidecars.Sidecars[0])
+		newKey := blobSidecarKey(scs[0])
 		rotatingBufferPrefix := newKey[0:8]
 		var replacingKey []byte
 		for k, _ := c.Seek(rotatingBufferPrefix); bytes.HasPrefix(k, rotatingBufferPrefix); k, _ = c.Next() {
@@ -45,8 +46,8 @@ func (s *Store) SaveBlobSidecar(ctx context.Context, blobSidecars *ethpb.BlobSid
 				replacingKey = k
 				oldSlotBytes := replacingKey[8:16]
 				oldSlot := bytesutil.BytesToSlotBigEndian(oldSlotBytes)
-				if oldSlot >= blobSidecars.Sidecars[0].Slot {
-					return fmt.Errorf("attempted to save blob with slot %d but already have older blob with slot %d", blobSidecars.Sidecars[0].Slot, oldSlot)
+				if oldSlot >= slot {
+					return fmt.Errorf("attempted to save blob with slot %d but already have older blob with slot %d", slot, oldSlot)
 				}
 				break
 			}
@@ -64,8 +65,11 @@ func (s *Store) SaveBlobSidecar(ctx context.Context, blobSidecars *ethpb.BlobSid
 	})
 }
 
-// BlobSidecarsByRoot retrieves the blobs given a beacon block root.
-func (s *Store) BlobSidecarsByRoot(ctx context.Context, beaconBlockRoot [32]byte) (*ethpb.BlobSidecars, error) {
+// BlobSidecarsByRoot retrieves the blobs for the given beacon block root.
+// If the `indices` argument is omitted, all blobs for the root will be returned.
+// Otherwise, the result will be filtered to only include the specified indices.
+// An error will result if an invalid index is specified.
+func (s *Store) BlobSidecarsByRoot(ctx context.Context, root [32]byte, indices ...uint64) ([]*ethpb.BlobSidecar, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.BlobSidecarsByRoot")
 	defer span.End()
 
@@ -74,7 +78,7 @@ func (s *Store) BlobSidecarsByRoot(ctx context.Context, beaconBlockRoot [32]byte
 		c := tx.Bucket(blobsBucket).Cursor()
 		// Bucket size is bounded and bolt cursors are fast. Moreover, a thin caching layer can be added.
 		for k, v := c.First(); k != nil; k, v = c.Next() {
-			if bytes.HasSuffix(k, beaconBlockRoot[:]) {
+			if bytes.HasSuffix(k, root[:]) {
 				enc = v
 				break
 			}
@@ -86,15 +90,37 @@ func (s *Store) BlobSidecarsByRoot(ctx context.Context, beaconBlockRoot [32]byte
 	if enc == nil {
 		return nil, ErrNotFound
 	}
-	sidecars := &ethpb.BlobSidecars{}
-	if err := decode(ctx, enc, sidecars); err != nil {
+	sc := &ethpb.BlobSidecars{}
+	if err := decode(ctx, enc, sc); err != nil {
 		return nil, err
 	}
+
+	return filterForIndices(sc, indices...)
+}
+
+func filterForIndices(sc *ethpb.BlobSidecars, indices ...uint64) ([]*ethpb.BlobSidecar, error) {
+	if len(indices) == 0 {
+		return sc.Sidecars, nil
+	}
+	// NB: This loop assumes that the BlobSidecars value stores the complete set of blobs for a block
+	// in ascending order from eg 0..3, without gaps. This allows us to assume the indices argument
+	// maps 1:1 with indices in the BlobSidecars storage object.
+	maxIdx := uint64(len(sc.Sidecars)) - 1
+	sidecars := make([]*ethpb.BlobSidecar, len(indices))
+	for i, idx := range indices {
+		if idx > maxIdx {
+			return nil, errors.Wrapf(ErrNotFound, "BlobSidecars missing index: index %d", idx)
+		}
+		sidecars[i] = sc.Sidecars[idx]
+	}
 	return sidecars, nil
 }
 
-// BlobSidecarsBySlot retrieves sidecars from a slot.
-func (s *Store) BlobSidecarsBySlot(ctx context.Context, slot types.Slot) (*ethpb.BlobSidecars, error) {
+// BlobSidecarsBySlot retrieves BlobSidecars for the given slot.
+// If the `indices` argument is omitted, all blobs for the root will be returned.
+// Otherwise, the result will be filtered to only include the specified indices.
+// An error will result if an invalid index is specified.
+func (s *Store) BlobSidecarsBySlot(ctx context.Context, slot types.Slot, indices ...uint64) ([]*ethpb.BlobSidecar, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.BlobSidecarsBySlot")
 	defer span.End()
 
@@ -116,11 +142,12 @@ func (s *Store) BlobSidecarsBySlot(ctx context.Context, slot types.Slot) (*ethpb
 	if enc == nil {
 		return nil, ErrNotFound
 	}
-	sidecars := &ethpb.BlobSidecars{}
-	if err := decode(ctx, enc, sidecars); err != nil {
+	sc := &ethpb.BlobSidecars{}
+	if err := decode(ctx, enc, sc); err != nil {
 		return nil, err
 	}
-	return sidecars, nil
+
+	return filterForIndices(sc, indices...)
 }
 
 // DeleteBlobSidecar returns true if the blobs are in the db.

beacon-chain/db/kv/blob_test.go

@@ -4,16 +4,35 @@ import (
 	"context"
 	"crypto/rand"
 	"encoding/binary"
+	"fmt"
 	"testing"
 
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v4/testing/assertions"
 	"github.com/prysmaticlabs/prysm/v4/testing/require"
 )
 
+func equalBlobSlices(expect []*ethpb.BlobSidecar, got []*ethpb.BlobSidecar) error {
+	if len(expect) != len(got) {
+		return fmt.Errorf("mismatched lengths, expect=%d, got=%d", len(expect), len(got))
+	}
+	for i := 0; i < len(expect); i++ {
+		es := expect[i]
+		gs := got[i]
+		var e string
+		assertions.DeepEqual(assertions.SprintfAssertionLoggerFn(&e), es, gs)
+		if e != "" {
+			return errors.New(e)
+		}
+	}
+	return nil
+}
+
 func TestStore_BlobSidecars(t *testing.T) {
 	ctx := context.Background()
 
@@ -25,122 +44,165 @@ func TestStore_BlobSidecars(t *testing.T) {
 	t.Run("empty by root", func(t *testing.T) {
 		db := setupDB(t)
 		got, err := db.BlobSidecarsByRoot(ctx, [32]byte{})
-		require.NoError(t, err)
-		require.DeepEqual(t, (*ethpb.BlobSidecars)(nil), got)
+		require.ErrorIs(t, ErrNotFound, err)
+		require.Equal(t, 0, len(got))
 	})
 	t.Run("empty by slot", func(t *testing.T) {
 		db := setupDB(t)
 		got, err := db.BlobSidecarsBySlot(ctx, 1)
-		require.NoError(t, err)
-		require.DeepEqual(t, (*ethpb.BlobSidecars)(nil), got)
+		require.ErrorIs(t, ErrNotFound, err)
+		require.Equal(t, 0, len(got))
 	})
 	t.Run("save and retrieve by root (one)", func(t *testing.T) {
 		db := setupDB(t)
 		scs := generateBlobSidecars(t, 1)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, 1, len(scs.Sidecars))
-		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs.Sidecars[0].BlockRoot))
+		require.Equal(t, 1, len(scs))
+		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot))
 		require.NoError(t, err)
-		require.Equal(t, 1, len(got.Sidecars))
-		require.DeepEqual(t, scs, got)
+		require.NoError(t, equalBlobSlices(scs, got))
 	})
 	t.Run("save and retrieve by root (max)", func(t *testing.T) {
 		db := setupDB(t)
 		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs.Sidecars))
-		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs.Sidecars[0].BlockRoot))
+		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot))
 		require.NoError(t, err)
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(got.Sidecars))
-		require.DeepEqual(t, scs, got)
+		require.NoError(t, equalBlobSlices(scs, got))
+	})
+	t.Run("save and retrieve valid subset by root", func(t *testing.T) {
+		db := setupDB(t)
+		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
+		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+
+		// we'll request indices 0 and 3, so make a slice with those indices for comparison
+		expect := make([]*ethpb.BlobSidecar, 2)
+		expect[0] = scs[0]
+		expect[1] = scs[3]
+
+		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot), 0, 3)
+		require.NoError(t, err)
+		require.NoError(t, equalBlobSlices(expect, got))
+		require.Equal(t, uint64(0), got[0].Index)
+		require.Equal(t, uint64(3), got[1].Index)
+	})
+	t.Run("error for invalid index when retrieving by root", func(t *testing.T) {
+		db := setupDB(t)
+		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
+		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+
+		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot), uint64(len(scs)))
+		require.ErrorIs(t, err, ErrNotFound)
+		require.Equal(t, 0, len(got))
 	})
 	t.Run("save and retrieve by slot (one)", func(t *testing.T) {
 		db := setupDB(t)
 		scs := generateBlobSidecars(t, 1)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, 1, len(scs.Sidecars))
-		got, err := db.BlobSidecarsBySlot(ctx, scs.Sidecars[0].Slot)
+		require.Equal(t, 1, len(scs))
+		got, err := db.BlobSidecarsBySlot(ctx, scs[0].Slot)
 		require.NoError(t, err)
-		require.Equal(t, 1, len(got.Sidecars))
-		require.DeepEqual(t, scs, got)
+		require.NoError(t, equalBlobSlices(scs, got))
 	})
 	t.Run("save and retrieve by slot (max)", func(t *testing.T) {
 		db := setupDB(t)
 		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs.Sidecars))
-		got, err := db.BlobSidecarsBySlot(ctx, scs.Sidecars[0].Slot)
+		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		got, err := db.BlobSidecarsBySlot(ctx, scs[0].Slot)
 		require.NoError(t, err)
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(got.Sidecars))
-		require.DeepEqual(t, scs, got)
+		require.NoError(t, equalBlobSlices(scs, got))
+	})
+	t.Run("save and retrieve valid subset by slot", func(t *testing.T) {
+		db := setupDB(t)
+		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
+		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+
+		// we'll request indices 0 and 3, so make a slice with those indices for comparison
+		expect := make([]*ethpb.BlobSidecar, 2)
+		expect[0] = scs[0]
+		expect[1] = scs[3]
+
+		got, err := db.BlobSidecarsBySlot(ctx, scs[0].Slot, 0, 3)
+		require.NoError(t, err)
+		require.NoError(t, equalBlobSlices(expect, got))
+
+		require.Equal(t, uint64(0), got[0].Index)
+		require.Equal(t, uint64(3), got[1].Index)
+	})
+	t.Run("error for invalid index when retrieving by slot", func(t *testing.T) {
+		db := setupDB(t)
+		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
+		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+
+		got, err := db.BlobSidecarsBySlot(ctx, scs[0].Slot, uint64(len(scs)))
+		require.ErrorIs(t, err, ErrNotFound)
+		require.Equal(t, 0, len(got))
 	})
 	t.Run("delete works", func(t *testing.T) {
 		db := setupDB(t)
 		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs.Sidecars))
-		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs.Sidecars[0].BlockRoot))
+		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot))
 		require.NoError(t, err)
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(got.Sidecars))
-		require.DeepEqual(t, scs, got)
-		require.NoError(t, db.DeleteBlobSidecar(ctx, bytesutil.ToBytes32(scs.Sidecars[0].BlockRoot)))
-		got, err = db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs.Sidecars[0].BlockRoot))
-		require.NoError(t, err)
-		require.DeepEqual(t, (*ethpb.BlobSidecars)(nil), got)
+		require.NoError(t, equalBlobSlices(scs, got))
+		require.NoError(t, db.DeleteBlobSidecar(ctx, bytesutil.ToBytes32(scs[0].BlockRoot)))
+		got, err = db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot))
+		require.ErrorIs(t, ErrNotFound, err)
+		require.Equal(t, 0, len(got))
 	})
 	t.Run("saving a blob with older slot", func(t *testing.T) {
 		db := setupDB(t)
 		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs.Sidecars))
-		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs.Sidecars[0].BlockRoot))
+		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot))
 		require.NoError(t, err)
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(got.Sidecars))
-		require.DeepEqual(t, scs, got)
+		require.NoError(t, equalBlobSlices(scs, got))
 		require.ErrorContains(t, "but already have older blob with slot", db.SaveBlobSidecar(ctx, scs))
 	})
 	t.Run("saving a new blob for rotation", func(t *testing.T) {
 		db := setupDB(t)
 		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs.Sidecars))
-		oldBlockRoot := scs.Sidecars[0].BlockRoot
-		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs.Sidecars[0].BlockRoot))
+		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		oldBlockRoot := scs[0].BlockRoot
+		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(oldBlockRoot))
 		require.NoError(t, err)
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(got.Sidecars))
-		require.DeepEqual(t, scs, got)
+		require.NoError(t, equalBlobSlices(scs, got))
 
 		newScs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
 		newRetentionSlot := primitives.Slot(params.BeaconNetworkConfig().MinEpochsForBlobsSidecarsRequest.Mul(uint64(params.BeaconConfig().SlotsPerEpoch)))
-		newScs.Sidecars[0].Slot = scs.Sidecars[0].Slot + newRetentionSlot
+		newScs[0].Slot = scs[0].Slot + newRetentionSlot
 		require.NoError(t, db.SaveBlobSidecar(ctx, newScs))
 
-		got, err = db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(oldBlockRoot))
-		require.NoError(t, err)
-		require.DeepEqual(t, (*ethpb.BlobSidecars)(nil), got)
+		_, err = db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(oldBlockRoot))
+		require.ErrorIs(t, ErrNotFound, err)
 
-		got, err = db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(newScs.Sidecars[0].BlockRoot))
+		got, err = db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(newScs[0].BlockRoot))
 		require.NoError(t, err)
-		require.DeepEqual(t, newScs, got)
+		require.NoError(t, equalBlobSlices(newScs, got))
 	})
 }
 
-func generateBlobSidecars(t *testing.T, n uint64) *ethpb.BlobSidecars {
+func generateBlobSidecars(t *testing.T, n uint64) []*ethpb.BlobSidecar {
 	blobSidecars := make([]*ethpb.BlobSidecar, n)
 	for i := uint64(0); i < n; i++ {
-		blobSidecars[i] = generateBlobSidecar(t)
-	}
-	return &ethpb.BlobSidecars{
-		Sidecars: blobSidecars,
+		blobSidecars[i] = generateBlobSidecar(t, i)
 	}
+	return blobSidecars
 }
 
-func generateBlobSidecar(t *testing.T) *ethpb.BlobSidecar {
+func generateBlobSidecar(t *testing.T, index uint64) *ethpb.BlobSidecar {
 	blockRoot := make([]byte, 32)
 	_, err := rand.Read(blockRoot)
 	require.NoError(t, err)
-	index := make([]byte, 8)
-	_, err = rand.Read(index)
 	require.NoError(t, err)
 	slot := make([]byte, 8)
 	_, err = rand.Read(slot)
@@ -166,7 +228,7 @@ func generateBlobSidecar(t *testing.T) *ethpb.BlobSidecar {
 
 	return &ethpb.BlobSidecar{
 		BlockRoot:       blockRoot,
-		Index:           binary.LittleEndian.Uint64(index),
+		Index:           index,
 		Slot:            primitives.Slot(binary.LittleEndian.Uint64(slot)),
 		BlockParentRoot: blockParentRoot,
 		ProposerIndex:   primitives.ValidatorIndex(binary.LittleEndian.Uint64(proposerIndex)),

beacon-chain/execution/log_processing_test.go

@@ -405,8 +405,8 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	web3Service.httpLogger = testAcc.Backend
 	web3Service.latestEth1Data.LastRequestedBlock = 0
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().NumberU64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 	bConfig := params.MinimalSpecConfig().Copy()
 	bConfig.MinGenesisTime = 0
 	bConfig.SecondsPerETH1Block = 10
@@ -444,8 +444,8 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
 		testAcc.Backend.Commit()
 	}
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().NumberU64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	// Set up our subscriber now to listen for the chain started event.
 	stateChannel := make(chan *feed.Event, 1)
@@ -502,8 +502,8 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	web3Service.httpLogger = testAcc.Backend
 	web3Service.latestEth1Data.LastRequestedBlock = 0
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().NumberU64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 	bConfig := params.MinimalSpecConfig().Copy()
 	bConfig.SecondsPerETH1Block = 10
 	params.OverrideBeaconConfig(bConfig)
@@ -540,14 +540,14 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	for i := uint64(0); i < 1500; i++ {
 		testAcc.Backend.Commit()
 	}
-	wantedGenesisTime := testAcc.Backend.Blockchain().CurrentBlock().Time()
+	wantedGenesisTime := testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	// Forward the chain to account for the follow distance
 	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
 		testAcc.Backend.Commit()
 	}
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().NumberU64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	// Set the genesis time 500 blocks ahead of the last
 	// deposit log.

beacon-chain/execution/service_test.go

@@ -210,14 +210,14 @@ func TestFollowBlock_OK(t *testing.T) {
 
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	baseHeight := testAcc.Backend.Blockchain().CurrentBlock().NumberU64()
+	baseHeight := testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
 	// process follow_distance blocks
 	for i := 0; i < int(params.BeaconConfig().Eth1FollowDistance); i++ {
 		testAcc.Backend.Commit()
 	}
 	// set current height
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().NumberU64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	h, err := web3Service.followedBlockHeight(context.Background())
 	require.NoError(t, err)
@@ -229,8 +229,8 @@ func TestFollowBlock_OK(t *testing.T) {
 		testAcc.Backend.Commit()
 	}
 	// set current height
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().NumberU64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	h, err = web3Service.followedBlockHeight(context.Background())
 	require.NoError(t, err)

beacon-chain/node/BUILD.bazel

@@ -63,6 +63,7 @@ go_library(
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
+        "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
     ],

beacon-chain/node/config.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
+	fastssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v4/cmd"
 	"github.com/prysmaticlabs/prysm/v4/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
@@ -189,3 +190,7 @@ func configureExecutionSetting(cliCtx *cli.Context) error {
 		" Default fee recipient will be used as a fall back", checksumAddress.Hex())
 	return params.SetActive(c)
 }
+
+func configureFastSSZHashingAlgorithm() {
+	fastssz.EnableVectorizedHTR = true
+}

beacon-chain/node/node.go

@@ -148,6 +148,7 @@ func New(cliCtx *cli.Context, opts ...Option) (*BeaconNode, error) {
 	if err := configureExecutionSetting(cliCtx); err != nil {
 		return nil, err
 	}
+	configureFastSSZHashingAlgorithm()
 
 	// Initializes any forks here.
 	params.BeaconConfig().InitializeForkSchedule()
@@ -798,10 +799,10 @@ func (b *BeaconNode) registerRPCService() error {
 		PeerManager:                   p2pService,
 		MetadataProvider:              p2pService,
 		ChainInfoFetcher:              chainService,
-		HeadUpdater:                   chainService,
 		HeadFetcher:                   chainService,
 		CanonicalFetcher:              chainService,
 		ForkFetcher:                   chainService,
+		ForkchoiceFetcher:             chainService,
 		FinalizationFetcher:           chainService,
 		BlockReceiver:                 chainService,
 		AttestationReceiver:           chainService,

beacon-chain/p2p/BUILD.bazel

@@ -24,6 +24,7 @@ go_library(
         "options.go",
         "pubsub.go",
         "pubsub_filter.go",
+        "pubsub_tracer.go",
         "rpc_topic_mappings.go",
         "sender.go",
         "service.go",
@@ -84,6 +85,7 @@ go_library(
         "@com_github_libp2p_go_libp2p//core/host:go_default_library",
         "@com_github_libp2p_go_libp2p//core/network:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
+        "@com_github_libp2p_go_libp2p//core/peerstore:go_default_library",
         "@com_github_libp2p_go_libp2p//core/protocol:go_default_library",
         "@com_github_libp2p_go_libp2p//p2p/muxer/mplex:go_default_library",
         "@com_github_libp2p_go_libp2p//p2p/security/noise:go_default_library",

beacon-chain/p2p/monitoring.go

@@ -4,6 +4,7 @@ import (
 	"strings"
 
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p/core/peerstore"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 )
@@ -63,6 +64,80 @@ var (
 		Name: "p2p_sync_committee_subnet_attempted_broadcasts",
 		Help: "The number of sync committee that were attempted to be broadcast.",
 	})
+
+	// Gossip Tracer Metrics
+	pubsubTopicsActive = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "p2p_pubsub_topic_active",
+		Help: "The topics that the peer is participating in gossipsub.",
+	},
+		[]string{"topic"})
+	pubsubTopicsGraft = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_graft_total",
+		Help: "The number of graft messages sent for a particular topic",
+	},
+		[]string{"topic"})
+	pubsubTopicsPrune = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_prune_total",
+		Help: "The number of prune messages sent for a particular topic",
+	},
+		[]string{"topic"})
+	pubsubMessageDeliver = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_deliver_total",
+		Help: "The number of messages received for delivery of a particular topic",
+	},
+		[]string{"topic"})
+	pubsubMessageUndeliverable = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_undeliverable_total",
+		Help: "The number of messages received which weren't able to be delivered of a particular topic",
+	},
+		[]string{"topic"})
+	pubsubMessageValidate = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_validate_total",
+		Help: "The number of messages received for validation of a particular topic",
+	},
+		[]string{"topic"})
+	pubsubMessageDuplicate = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_duplicate_total",
+		Help: "The number of duplicate messages sent for a particular topic",
+	},
+		[]string{"topic"})
+	pubsubMessageReject = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_reject_total",
+		Help: "The number of messages rejected of a particular topic",
+	},
+		[]string{"topic"})
+	pubsubPeerThrottle = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_throttle_total",
+		Help: "The number of times a peer has been throttled for a particular topic",
+	},
+		[]string{"topic"})
+	pubsubRPCRecv = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_rpc_recv_total",
+		Help: "The number of messages received via rpc for a particular topic",
+	},
+		[]string{"control_message"})
+	pubsubRPCSubRecv = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "p2p_pubsub_rpc_recv_sub_total",
+		Help: "The number of subscription messages received via rpc",
+	})
+	pubsubRPCDrop = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_rpc_drop_total",
+		Help: "The number of messages dropped via rpc for a particular topic",
+	},
+		[]string{"control_message"})
+	pubsubRPCSubDrop = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "p2p_pubsub_rpc_drop_sub_total",
+		Help: "The number of subscription messages dropped via rpc",
+	})
+	pubsubRPCSent = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_rpc_sent_total",
+		Help: "The number of messages sent via rpc for a particular topic",
+	},
+		[]string{"control_message"})
+	pubsubRPCSubSent = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "p2p_pubsub_rpc_sent_sub_total",
+		Help: "The number of subscription messages sent via rpc",
+	})
 )
 
 func (s *Service) updateMetrics() {
@@ -84,20 +159,7 @@ func (s *Service) updateMetrics() {
 			continue
 		}
 
-		// Get the agent data.
-		rawAgent, err := store.Get(pid, "AgentVersion")
-		agent, ok := rawAgent.(string)
-		if err != nil || !ok {
-			agent = "unknown"
-		}
-		foundName := "unknown"
-		for _, knownAgent := range knownAgentVersions {
-			// If the agent string matches one of our known agents, we set
-			// the value to our own, sanitized string.
-			if strings.Contains(strings.ToLower(agent), knownAgent) {
-				foundName = knownAgent
-			}
-		}
+		foundName := agentFromPid(pid, store)
 		numConnectedPeersByClient[foundName] += 1
 
 		// Get peer scoring data.
@@ -123,3 +185,21 @@ func average(xs []float64) float64 {
 	}
 	return total / float64(len(xs))
 }
+
+func agentFromPid(pid peer.ID, store peerstore.Peerstore) string {
+	// Get the agent data.
+	rawAgent, err := store.Get(pid, "AgentVersion")
+	agent, ok := rawAgent.(string)
+	if err != nil || !ok {
+		return "unknown"
+	}
+	foundName := "unknown"
+	for _, knownAgent := range knownAgentVersions {
+		// If the agent string matches one of our known agents, we set
+		// the value to our own, sanitized string.
+		if strings.Contains(strings.ToLower(agent), knownAgent) {
+			foundName = knownAgent
+		}
+	}
+	return foundName
+}

beacon-chain/p2p/pubsub.go

@@ -145,6 +145,7 @@ func (s *Service) pubsubOptions() []pubsub.Option {
 		pubsub.WithPeerScore(peerScoringParams()),
 		pubsub.WithPeerScoreInspect(s.peerInspector, time.Minute),
 		pubsub.WithGossipSubParams(pubsubGossipParam()),
+		pubsub.WithRawTracer(gossipTracer{host: s.host}),
 	}
 	return psOpts
 }

beacon-chain/p2p/pubsub_tracer.go

@@ -0,0 +1,103 @@
+package p2p
+
+import (
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/libp2p/go-libp2p/core/host"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p/core/protocol"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+var _ = pubsub.RawTracer(gossipTracer{})
+
+// This tracer is used to implement metrics collection for messages received
+// and broadcasted through gossipsub.
+type gossipTracer struct {
+	host host.Host
+}
+
+// AddPeer .
+func (g gossipTracer) AddPeer(p peer.ID, proto protocol.ID) {
+	// no-op
+}
+
+// RemovePeer .
+func (g gossipTracer) RemovePeer(p peer.ID) {
+	// no-op
+}
+
+// Join .
+func (g gossipTracer) Join(topic string) {
+	pubsubTopicsActive.WithLabelValues(topic).Set(1)
+}
+
+// Leave .
+func (g gossipTracer) Leave(topic string) {
+	pubsubTopicsActive.WithLabelValues(topic).Set(0)
+}
+
+// Graft .
+func (g gossipTracer) Graft(p peer.ID, topic string) {
+	pubsubTopicsGraft.WithLabelValues(topic).Inc()
+}
+
+// Prune .
+func (g gossipTracer) Prune(p peer.ID, topic string) {
+	pubsubTopicsPrune.WithLabelValues(topic).Inc()
+}
+
+// ValidateMessage .
+func (g gossipTracer) ValidateMessage(msg *pubsub.Message) {
+	pubsubMessageValidate.WithLabelValues(*msg.Topic).Inc()
+}
+
+// DeliverMessage .
+func (g gossipTracer) DeliverMessage(msg *pubsub.Message) {
+	pubsubMessageDeliver.WithLabelValues(*msg.Topic).Inc()
+}
+
+// RejectMessage .
+func (g gossipTracer) RejectMessage(msg *pubsub.Message, reason string) {
+	pubsubMessageReject.WithLabelValues(*msg.Topic).Inc()
+}
+
+// DuplicateMessage .
+func (g gossipTracer) DuplicateMessage(msg *pubsub.Message) {
+	pubsubMessageDuplicate.WithLabelValues(*msg.Topic).Inc()
+}
+
+// UndeliverableMessage .
+func (g gossipTracer) UndeliverableMessage(msg *pubsub.Message) {
+	pubsubMessageUndeliverable.WithLabelValues(*msg.Topic).Inc()
+}
+
+// ThrottlePeer .
+func (g gossipTracer) ThrottlePeer(p peer.ID) {
+	agent := agentFromPid(p, g.host.Peerstore())
+	pubsubPeerThrottle.WithLabelValues(agent).Inc()
+}
+
+// RecvRPC .
+func (g gossipTracer) RecvRPC(rpc *pubsub.RPC) {
+	setMetricFromRPC(pubsubRPCSubRecv, pubsubRPCRecv, rpc)
+}
+
+// SendRPC .
+func (g gossipTracer) SendRPC(rpc *pubsub.RPC, p peer.ID) {
+	setMetricFromRPC(pubsubRPCSubSent, pubsubRPCSent, rpc)
+}
+
+// DropRPC .
+func (g gossipTracer) DropRPC(rpc *pubsub.RPC, p peer.ID) {
+	setMetricFromRPC(pubsubRPCSubDrop, pubsubRPCDrop, rpc)
+}
+
+func setMetricFromRPC(ctr prometheus.Counter, gauge *prometheus.CounterVec, rpc *pubsub.RPC) {
+	ctr.Add(float64(len(rpc.Subscriptions)))
+	if rpc.Control != nil {
+		gauge.WithLabelValues("graft").Add(float64(len(rpc.Control.Graft)))
+		gauge.WithLabelValues("prune").Add(float64(len(rpc.Control.Prune)))
+		gauge.WithLabelValues("ihave").Add(float64(len(rpc.Control.Ihave)))
+		gauge.WithLabelValues("iwant").Add(float64(len(rpc.Control.Iwant)))
+	}
+}

beacon-chain/p2p/types/BUILD.bazel

@@ -41,7 +41,9 @@ go_test(
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
+        "@com_github_prysmaticlabs_fastssz//:go_default_library",
     ],
 )

beacon-chain/p2p/types/types.go

@@ -32,7 +32,6 @@ func (b *SSZBytes) HashTreeRootWith(hh *ssz.Hasher) error {
 
 // BeaconBlockByRootsReq specifies the block by roots request type.
 type BeaconBlockByRootsReq [][rootLength]byte
-type BlobSidecarsByRootReq []*eth.BlobIdentifier
 
 // MarshalSSZTo marshals the block by roots request with the provided byte slice.
 func (r *BeaconBlockByRootsReq) MarshalSSZTo(dst []byte) ([]byte, error) {
@@ -122,3 +121,66 @@ func (m *ErrorMessage) UnmarshalSSZ(buf []byte) error {
 	*m = errMsg
 	return nil
 }
+
+// BlobSidecarsByRootReq is used to specify a list of blob targets (root+index) in a BlobSidecarsByRoot RPC request.
+type BlobSidecarsByRootReq []*eth.BlobIdentifier
+
+// BlobIdentifier is a fixed size value, so we can compute its fixed size at start time (see init below)
+var blobIdSize int
+
+// SizeSSZ returns the size of the serialized representation.
+func (b *BlobSidecarsByRootReq) SizeSSZ() int {
+	return len(*b) * blobIdSize
+}
+
+// MarshalSSZTo marshals the block by roots request with the provided byte slice.
+func (b *BlobSidecarsByRootReq) MarshalSSZTo(dst []byte) ([]byte, error) {
+	// A List without an enclosing container is marshaled exactly like a vector, no length offset required.
+	marshalledObj, err := b.MarshalSSZ()
+	if err != nil {
+		return nil, err
+	}
+	return append(dst, marshalledObj...), nil
+}
+
+// MarshalSSZ Marshals the block by roots request type into the serialized object.
+func (b *BlobSidecarsByRootReq) MarshalSSZ() ([]byte, error) {
+	buf := make([]byte, len(*b)*blobIdSize)
+	for i, id := range *b {
+		by, err := id.MarshalSSZ()
+		if err != nil {
+			return nil, err
+		}
+		copy(buf[i*blobIdSize:(i+1)*blobIdSize], by)
+	}
+	return buf, nil
+}
+
+// UnmarshalSSZ unmarshals the provided bytes buffer into the
+// block by roots request object.
+func (b *BlobSidecarsByRootReq) UnmarshalSSZ(buf []byte) error {
+	bufLen := len(buf)
+	maxLength := int(params.BeaconNetworkConfig().MaxRequestBlobsSidecars) * blobIdSize
+	if bufLen > maxLength {
+		return errors.Errorf("expected buffer with length of upto %d but received length %d", maxLength, bufLen)
+	}
+	if bufLen%blobIdSize != 0 {
+		return errors.Wrapf(ssz.ErrIncorrectByteSize, "size=%d", bufLen)
+	}
+	count := bufLen / blobIdSize
+	*b = make([]*eth.BlobIdentifier, count)
+	for i := 0; i < count; i++ {
+		id := &eth.BlobIdentifier{}
+		err := id.UnmarshalSSZ(buf[i*blobIdSize : (i+1)*blobIdSize])
+		if err != nil {
+			return err
+		}
+		(*b)[i] = id
+	}
+	return nil
+}
+
+func init() {
+	sizer := &eth.BlobIdentifier{}
+	blobIdSize = sizer.SizeSSZ()
+}

beacon-chain/p2p/types/types_test.go

@@ -4,12 +4,82 @@ import (
 	"encoding/hex"
 	"testing"
 
+	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
+	eth "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/testing/assert"
 	"github.com/prysmaticlabs/prysm/v4/testing/require"
 )
 
+func generateBlobIdentifiers(n int) []*eth.BlobIdentifier {
+	r := make([]*eth.BlobIdentifier, n)
+	for i := 0; i < n; i++ {
+		r[i] = &eth.BlobIdentifier{
+			BlockRoot: bytesutil.PadTo([]byte{byte(i)}, 32),
+			Index:     0,
+		}
+	}
+	return r
+}
+
+func TestBlobSidecarsByRootReq_MarshalSSZ(t *testing.T) {
+	cases := []struct {
+		name         string
+		ids          []*eth.BlobIdentifier
+		marshalErr   error
+		unmarshalErr error
+		unmarshalMod func([]byte) []byte
+	}{
+		{
+			name: "empty list",
+		},
+		{
+			name: "single item list",
+			ids:  generateBlobIdentifiers(1),
+		},
+		{
+			name: "10 item list",
+			ids:  generateBlobIdentifiers(10),
+		},
+		{
+			name: "wonky unmarshal size",
+			ids:  generateBlobIdentifiers(10),
+			unmarshalMod: func(in []byte) []byte {
+				in = append(in, byte(0))
+				return in
+			},
+			unmarshalErr: ssz.ErrIncorrectByteSize,
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			r := BlobSidecarsByRootReq(c.ids)
+			by, err := r.MarshalSSZ()
+			if c.marshalErr != nil {
+				require.ErrorIs(t, err, c.marshalErr)
+				return
+			}
+			require.NoError(t, err)
+			if c.unmarshalMod != nil {
+				by = c.unmarshalMod(by)
+			}
+			got := &BlobSidecarsByRootReq{}
+			err = got.UnmarshalSSZ(by)
+			if c.unmarshalErr != nil {
+				require.ErrorIs(t, err, c.unmarshalErr)
+				return
+			}
+			require.NoError(t, err)
+			for i, gid := range *got {
+				require.DeepEqual(t, c.ids[i], gid)
+			}
+		})
+	}
+}
+
 func TestBeaconBlockByRootsReq_Limit(t *testing.T) {
 	fixedRoots := make([][32]byte, 0)
 	for i := uint64(0); i < params.BeaconNetworkConfig().MaxRequestBlocks+100; i++ {

beacon-chain/rpc/apimiddleware/structs.go

@@ -1314,7 +1314,7 @@ type EventPayloadAttributeV2Json struct {
 	ParentBlockNumber string                   `json:"parent_block_number"`
 	ParentBlockRoot   string                   `json:"parent_block_root" hex:"true"`
 	ParentBlockHash   string                   `json:"parent_block_hash" hex:"true"`
-	PayloadAttributes *PayloadAttributesV2Json `json:"payload_attributes_v2"`
+	PayloadAttributes *PayloadAttributesV2Json `json:"payload_attributes"`
 }
 
 type PayloadAttributesV1Json struct {

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

@@ -181,7 +181,5 @@ func (ds *Server) ListForkChoiceHeadsV2(ctx context.Context, _ *emptypb.Empty) (
 
 // GetForkChoice returns a dump fork choice store.
 func (ds *Server) GetForkChoice(ctx context.Context, _ *emptypb.Empty) (*ethpbv1.ForkChoiceDump, error) {
-	ds.ForkFetcher.ForkChoicer().RLock()
-	defer ds.ForkFetcher.ForkChoicer().RUnlock()
-	return ds.ForkFetcher.ForkChoicer().ForkChoiceDump(ctx)
+	return ds.ForkchoiceFetcher.ForkChoiceDump(ctx)
 }

beacon-chain/rpc/eth/debug/debug_test.go

@@ -326,7 +326,7 @@ func TestServer_GetForkChoice(t *testing.T) {
 	fRoot := [32]byte{'a'}
 	fc := &forkchoicetypes.Checkpoint{Epoch: 2, Root: fRoot}
 	require.NoError(t, store.UpdateFinalizedCheckpoint(fc))
-	bs := &Server{ForkFetcher: &blockchainmock.ChainService{ForkChoiceStore: store}}
+	bs := &Server{ForkchoiceFetcher: &blockchainmock.ChainService{ForkChoiceStore: store}}
 	res, err := bs.GetForkChoice(context.Background(), &empty.Empty{})
 	require.NoError(t, err)
 	require.Equal(t, primitives.Epoch(2), res.FinalizedCheckpoint.Epoch, "Did not get wanted finalized epoch")

beacon-chain/rpc/eth/debug/server.go

@@ -17,6 +17,7 @@ type Server struct {
 	StateFetcher          statefetcher.Fetcher
 	OptimisticModeFetcher blockchain.OptimisticModeFetcher
 	ForkFetcher           blockchain.ForkFetcher
+	ForkchoiceFetcher     blockchain.ForkchoiceFetcher
 	FinalizationFetcher   blockchain.FinalizationFetcher
 	ChainInfoFetcher      blockchain.ChainInfoFetcher
 }

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

@@ -331,7 +331,7 @@ func (s *Server) streamPayloadAttributes(stream ethpbservice.Events_StreamEvents
 				ParentBlockNumber: headPayload.BlockNumber(),
 				ParentBlockRoot:   headRoot,
 				ParentBlockHash:   headPayload.BlockHash(),
-				PayloadAttributesV2: &enginev1.PayloadAttributesV2{
+				PayloadAttributes: &enginev1.PayloadAttributesV2{
 					Timestamp:             uint64(t.Unix()),
 					PrevRandao:            prevRando,
 					SuggestedFeeRecipient: headPayload.FeeRecipient(),

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

@@ -494,7 +494,7 @@ func TestStreamEvents_StateEvents(t *testing.T) {
 				ParentBlockNumber: 1,
 				ParentBlockRoot:   make([]byte, 32),
 				ParentBlockHash:   make([]byte, 32),
-				PayloadAttributesV2: &enginev1.PayloadAttributesV2{
+				PayloadAttributes: &enginev1.PayloadAttributesV2{
 					Timestamp:             24,
 					PrevRandao:            prevRando,
 					SuggestedFeeRecipient: make([]byte, 20),

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

@@ -17,7 +17,6 @@ import (
 // providing RPC endpoints intended for validator clients.
 type Server struct {
 	HeadFetcher            blockchain.HeadFetcher
-	HeadUpdater            blockchain.HeadUpdater
 	TimeFetcher            blockchain.TimeFetcher
 	SyncChecker            sync.Checker
 	AttestationsPool       attestations.Pool

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

@@ -723,8 +723,8 @@ func TestProduceBlockV2(t *testing.T) {
 			HeadFetcher:           mockChainService,
 			SyncChecker:           &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:         mockChainService,
-			HeadUpdater:           mockChainService,
 			ForkFetcher:           mockChainService,
+			ForkchoiceFetcher:     mockChainService,
 			ChainStartFetcher:     mockExecutionChain,
 			Eth1InfoFetcher:       mockExecutionChain,
 			Eth1BlockFetcher:      mockExecutionChain,
@@ -835,8 +835,8 @@ func TestProduceBlockV2(t *testing.T) {
 			HeadFetcher:           mockChainService,
 			SyncChecker:           &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:         mockChainService,
-			HeadUpdater:           mockChainService,
 			ForkFetcher:           mockChainService,
+			ForkchoiceFetcher:     mockChainService,
 			ChainStartFetcher:     mockExecutionChain,
 			Eth1InfoFetcher:       mockExecutionChain,
 			Eth1BlockFetcher:      mockExecutionChain,
@@ -1035,8 +1035,8 @@ func TestProduceBlockV2(t *testing.T) {
 			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
-			HeadUpdater:            mockChainService,
 			ForkFetcher:            mockChainService,
+			ForkchoiceFetcher:      mockChainService,
 			ChainStartFetcher:      mockExecutionChain,
 			Eth1InfoFetcher:        mockExecutionChain,
 			Eth1BlockFetcher:       mockExecutionChain,
@@ -1278,8 +1278,8 @@ func TestProduceBlockV2(t *testing.T) {
 			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
-			HeadUpdater:            mockChainService,
 			ForkFetcher:            mockChainService,
+			ForkchoiceFetcher:      mockChainService,
 			ChainStartFetcher:      mockExecutionChain,
 			Eth1InfoFetcher:        mockExecutionChain,
 			Eth1BlockFetcher:       mockExecutionChain,
@@ -1416,8 +1416,9 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     mockChainService,
-			HeadUpdater:       mockChainService,
+			TimeFetcher:       mockChainService,
 			ForkFetcher:       mockChainService,
+			ForkchoiceFetcher: mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -1579,8 +1580,9 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     mockChainService,
-			HeadUpdater:       mockChainService,
+			TimeFetcher:       mockChainService,
 			ForkFetcher:       mockChainService,
+			ForkchoiceFetcher: mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -1785,8 +1787,8 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
-			HeadUpdater:            mockChainService,
 			ForkFetcher:            mockChainService,
+			ForkchoiceFetcher:      mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
@@ -2029,8 +2031,8 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
-			HeadUpdater:            mockChainService,
 			ForkFetcher:            mockChainService,
+			ForkchoiceFetcher:      mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
@@ -2260,8 +2262,9 @@ func TestProduceBlindedBlock(t *testing.T) {
 			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     mockChainService,
-			HeadUpdater:       mockChainService,
 			ForkFetcher:       mockChainService,
+			TimeFetcher:       mockChainService,
+			ForkchoiceFetcher: mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -2366,8 +2369,9 @@ func TestProduceBlindedBlock(t *testing.T) {
 			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     mockChainService,
-			HeadUpdater:       mockChainService,
 			ForkFetcher:       mockChainService,
+			TimeFetcher:       mockChainService,
+			ForkchoiceFetcher: mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -2557,12 +2561,12 @@ func TestProduceBlindedBlock(t *testing.T) {
 		v1Alpha1Server := &v1alpha1validator.Server{
 			BeaconDB:               db,
 			ForkFetcher:            mockChainService,
+			ForkchoiceFetcher:      mockChainService,
 			TimeFetcher:            mockChainService,
 			HeadFetcher:            mockChainService,
 			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
-			HeadUpdater:            mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{GenesisState: beaconState},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
@@ -2780,12 +2784,12 @@ func TestProduceBlindedBlock(t *testing.T) {
 			ExecutionEngineCaller:  &mockExecution.EngineClient{PayloadIDBytes: id, ExecutionPayloadCapella: &enginev1.ExecutionPayloadCapella{BlockNumber: 1, Withdrawals: wds}, BlockValue: big.NewInt(0)},
 			BeaconDB:               db,
 			ForkFetcher:            mockChainService,
+			ForkchoiceFetcher:      mockChainService,
 			TimeFetcher:            mockChainService,
 			HeadFetcher:            mockChainService,
 			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
-			HeadUpdater:            mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
@@ -2930,8 +2934,9 @@ func TestProduceBlindedBlockSSZ(t *testing.T) {
 			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     mockChainService,
-			HeadUpdater:       mockChainService,
+			TimeFetcher:       mockChainService,
 			ForkFetcher:       mockChainService,
+			ForkchoiceFetcher: mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -3093,8 +3098,9 @@ func TestProduceBlindedBlockSSZ(t *testing.T) {
 			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       mockChainService,
+			TimeFetcher:       mockChainService,
 			ForkFetcher:       mockChainService,
+			ForkchoiceFetcher: mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -3299,8 +3305,8 @@ func TestProduceBlindedBlockSSZ(t *testing.T) {
 			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
-			HeadUpdater:            mockChainService,
 			ForkFetcher:            mockChainService,
+			ForkchoiceFetcher:      mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
@@ -3537,8 +3543,8 @@ func TestProduceBlindedBlockSSZ(t *testing.T) {
 			OptimisticModeFetcher:  &mockChain.ChainService{},
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
-			HeadUpdater:            mockChainService,
 			ForkFetcher:            mockChainService,
+			ForkchoiceFetcher:      mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},

beacon-chain/rpc/prysm/v1alpha1/beacon/server.go

@@ -46,6 +46,5 @@ type Server struct {
 	StateGen                    stategen.StateManager
 	SyncChecker                 sync.Checker
 	ReplayerBuilder             stategen.ReplayerBuilder
-	HeadUpdater                 blockchain.HeadUpdater
 	OptimisticModeFetcher       blockchain.OptimisticModeFetcher
 }

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

@@ -52,14 +52,12 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	}
 
 	// process attestations and update head in forkchoice
-	vs.ForkFetcher.ForkChoicer().Lock()
-	vs.HeadUpdater.UpdateHead(ctx, vs.ForkFetcher.CurrentSlot())
-	headRoot := vs.ForkFetcher.ForkChoicer().CachedHeadRoot()
-	parentRoot := vs.ForkFetcher.ForkChoicer().GetProposerHead()
+	vs.ForkchoiceFetcher.UpdateHead(ctx, vs.TimeFetcher.CurrentSlot())
+	headRoot := vs.ForkchoiceFetcher.CachedHeadRoot()
+	parentRoot := vs.ForkchoiceFetcher.GetProposerHead()
 	if parentRoot != headRoot {
 		blockchain.LateBlockAttemptedReorgCount.Inc()
 	}
-	vs.ForkFetcher.ForkChoicer().Unlock()
 
 	// An optimistic validator MUST NOT produce a block (i.e., sign across the DOMAIN_BEACON_PROPOSER domain).
 	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch {
@@ -337,11 +335,22 @@ func (vs *Server) proposeGenericBeaconBlock(ctx context.Context, req *ethpb.Gene
 		if !ok {
 			return nil, status.Error(codes.Internal, "Could not cast block to Deneb")
 		}
-		for _, sidecar := range b.Deneb.Blobs {
+		scs := make([]*ethpb.BlobSidecar, len(b.Deneb.Blobs))
+		for i, sidecar := range b.Deneb.Blobs {
+			scs[i] = sidecar.Message
+			// Hehehe skip index 1 and let peers handle it.
+			if sidecar.Message.Index == 1 {
+				continue
+			}
 			if err := vs.P2P.BroadcastBlob(ctx, sidecar.Message.Index, sidecar); err != nil {
 				return nil, errors.Wrap(err, "could not broadcast blob sidecar")
 			}
 		}
+		if len(scs) > 0 {
+			if err := vs.BeaconDB.SaveBlobSidecar(ctx, scs); err != nil {
+				return nil, errors.Wrap(err, "could not save blob sidecar")
+			}
+		}
 	}
 
 	// Do not block proposal critical path with debug logging or block feed updates.

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

@@ -118,8 +118,8 @@ func TestServer_setExecutionData(t *testing.T) {
 		wb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockBellatrix())
 		require.NoError(t, err)
 		chain := &blockchainTest.ChainService{ForkChoiceStore: doublylinkedtree.New(), Genesis: time.Now(), Block: wb}
-		vs.ForkFetcher = chain
-		vs.ForkFetcher.ForkChoicer().SetGenesisTime(uint64(time.Now().Unix()))
+		vs.ForkchoiceFetcher = chain
+		vs.ForkchoiceFetcher.SetForkChoiceGenesisTime(uint64(time.Now().Unix()))
 		vs.TimeFetcher = chain
 		vs.HeadFetcher = chain
 		_, err = vs.setExecutionData(context.Background(), blk, capellaTransitionState)
@@ -173,7 +173,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		require.NoError(t, err)
 		chain := &blockchainTest.ChainService{ForkChoiceStore: doublylinkedtree.New(), Genesis: time.Now(), Block: wb}
 		vs.ForkFetcher = chain
-		vs.ForkFetcher.ForkChoicer().SetGenesisTime(uint64(time.Now().Unix()))
+		vs.ForkchoiceFetcher.SetForkChoiceGenesisTime(uint64(time.Now().Unix()))
 		vs.TimeFetcher = chain
 		vs.HeadFetcher = chain
 		_, err = vs.setExecutionData(context.Background(), blk, capellaTransitionState)

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

@@ -41,15 +41,12 @@ func (vs *Server) validatorRegistered(ctx context.Context, id primitives.Validat
 
 // circuitBreakBuilder returns true if the builder is not allowed to be used due to circuit breaker conditions.
 func (vs *Server) circuitBreakBuilder(s primitives.Slot) (bool, error) {
-	if vs.ForkFetcher == nil || vs.ForkFetcher.ForkChoicer() == nil {
+	if vs.ForkchoiceFetcher == nil {
 		return true, errors.New("no fork choicer configured")
 	}
 
-	vs.ForkFetcher.ForkChoicer().RLock()
-	defer vs.ForkFetcher.ForkChoicer().RUnlock()
-
 	// Circuit breaker is active if the missing consecutive slots greater than `MaxBuilderConsecutiveMissedSlots`.
-	highestReceivedSlot := vs.ForkFetcher.ForkChoicer().HighestReceivedBlockSlot()
+	highestReceivedSlot := vs.ForkchoiceFetcher.HighestReceivedBlockSlot()
 	maxConsecutiveSkipSlotsAllowed := params.BeaconConfig().MaxBuilderConsecutiveMissedSlots
 	diff, err := s.SafeSubSlot(highestReceivedSlot)
 	if err != nil {
@@ -71,7 +68,7 @@ func (vs *Server) circuitBreakBuilder(s primitives.Slot) (bool, error) {
 	}
 
 	// Circuit breaker is active if the missing slots per epoch (rolling window) greater than `MaxBuilderEpochMissedSlots`.
-	receivedCount, err := vs.ForkFetcher.ForkChoicer().ReceivedBlocksLastEpoch()
+	receivedCount, err := vs.ForkchoiceFetcher.ReceivedBlocksLastEpoch()
 	if err != nil {
 		return true, err
 	}

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

@@ -26,8 +26,8 @@ func TestServer_circuitBreakBuilder(t *testing.T) {
 	_, err := s.circuitBreakBuilder(0)
 	require.ErrorContains(t, "no fork choicer configured", err)
 
-	s.ForkFetcher = &blockchainTest.ChainService{ForkChoiceStore: doublylinkedtree.New()}
-	s.ForkFetcher.ForkChoicer().SetGenesisTime(uint64(time.Now().Unix()))
+	s.ForkchoiceFetcher = &blockchainTest.ChainService{ForkChoiceStore: doublylinkedtree.New()}
+	s.ForkchoiceFetcher.SetForkChoiceGenesisTime(uint64(time.Now().Unix()))
 	b, err := s.circuitBreakBuilder(params.BeaconConfig().MaxBuilderConsecutiveMissedSlots + 1)
 	require.NoError(
 		t,
@@ -41,7 +41,7 @@ func TestServer_circuitBreakBuilder(t *testing.T) {
 	ctx := context.Background()
 	st, blkRoot, err := createState(1, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, s.ForkFetcher.ForkChoicer().InsertNode(ctx, st, blkRoot))
+	require.NoError(t, s.ForkchoiceFetcher.InsertNode(ctx, st, blkRoot))
 	b, err = s.circuitBreakBuilder(params.BeaconConfig().MaxBuilderConsecutiveMissedSlots)
 	require.NoError(t, err)
 	require.Equal(t, false, b)
@@ -52,7 +52,7 @@ func TestServer_circuitBreakBuilder(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 	st, blkRoot, err = createState(params.BeaconConfig().SlotsPerEpoch, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, s.ForkFetcher.ForkChoicer().InsertNode(ctx, st, blkRoot))
+	require.NoError(t, s.ForkchoiceFetcher.InsertNode(ctx, st, blkRoot))
 	b, err = s.circuitBreakBuilder(params.BeaconConfig().SlotsPerEpoch + 1)
 	require.NoError(t, err)
 	require.Equal(t, true, b)
@@ -62,7 +62,7 @@ func TestServer_circuitBreakBuilder(t *testing.T) {
 	for i := primitives.Slot(2); i <= want+2; i++ {
 		st, blkRoot, err = createState(i, [32]byte{byte(i)}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 		require.NoError(t, err)
-		require.NoError(t, s.ForkFetcher.ForkChoicer().InsertNode(ctx, st, blkRoot))
+		require.NoError(t, s.ForkchoiceFetcher.InsertNode(ctx, st, blkRoot))
 	}
 	b, err = s.circuitBreakBuilder(params.BeaconConfig().SlotsPerEpoch + 1)
 	require.NoError(t, err)
@@ -99,8 +99,8 @@ func TestServer_canUseBuilder(t *testing.T) {
 	proposerServer := &Server{}
 	ctx := context.Background()
 
-	proposerServer.ForkFetcher = &blockchainTest.ChainService{ForkChoiceStore: doublylinkedtree.New()}
-	proposerServer.ForkFetcher.ForkChoicer().SetGenesisTime(uint64(time.Now().Unix()))
+	proposerServer.ForkchoiceFetcher = &blockchainTest.ChainService{ForkChoiceStore: doublylinkedtree.New()}
+	proposerServer.ForkchoiceFetcher.SetForkChoiceGenesisTime(uint64(time.Now().Unix()))
 	reg, err := proposerServer.canUseBuilder(ctx, params.BeaconConfig().MaxBuilderConsecutiveMissedSlots+1, 0)
 	require.NoError(t, err)
 	require.Equal(t, false, reg)

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

@@ -443,8 +443,8 @@ func TestServer_GetBeaconBlock_Optimistic(t *testing.T) {
 	proposerServer := &Server{
 		OptimisticModeFetcher: &mock.ChainService{Optimistic: true},
 		SyncChecker:           &mockSync.Sync{},
-		HeadUpdater:           mockChainService,
 		ForkFetcher:           mockChainService,
+		ForkchoiceFetcher:     mockChainService,
 		TimeFetcher:           &mock.ChainService{}}
 	req := &ethpb.BlockRequest{
 		Slot: bellatrixSlot + 1,
@@ -462,11 +462,11 @@ func getProposerServer(db db.HeadAccessDatabase, headState state.BeaconState, he
 		HeadFetcher:           mockChainService,
 		SyncChecker:           &mockSync.Sync{IsSyncing: false},
 		BlockReceiver:         mockChainService,
-		HeadUpdater:           mockChainService,
 		ChainStartFetcher:     &mockExecution.Chain{},
 		Eth1InfoFetcher:       &mockExecution.Chain{},
 		Eth1BlockFetcher:      &mockExecution.Chain{},
 		ForkFetcher:           mockChainService,
+		ForkchoiceFetcher:     mockChainService,
 		MockEth1Votes:         true,
 		AttPool:               attestations.NewPool(),
 		SlashingsPool:         slashings.NewPool(),

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

@@ -45,8 +45,8 @@ type Server struct {
 	AttestationCache       *cache.AttestationCache
 	ProposerSlotIndexCache *cache.ProposerPayloadIDsCache
 	HeadFetcher            blockchain.HeadFetcher
-	HeadUpdater            blockchain.HeadUpdater
 	ForkFetcher            blockchain.ForkFetcher
+	ForkchoiceFetcher      blockchain.ForkchoiceFetcher
 	GenesisFetcher         blockchain.GenesisFetcher
 	FinalizationFetcher    blockchain.FinalizationFetcher
 	TimeFetcher            blockchain.TimeFetcher

beacon-chain/rpc/service.go

@@ -81,10 +81,10 @@ type Config struct {
 	BeaconMonitoringPort          int
 	BeaconDB                      db.HeadAccessDatabase
 	ChainInfoFetcher              blockchain.ChainInfoFetcher
-	HeadUpdater                   blockchain.HeadUpdater
 	HeadFetcher                   blockchain.HeadFetcher
 	CanonicalFetcher              blockchain.CanonicalFetcher
 	ForkFetcher                   blockchain.ForkFetcher
+	ForkchoiceFetcher             blockchain.ForkchoiceFetcher
 	FinalizationFetcher           blockchain.FinalizationFetcher
 	AttestationReceiver           blockchain.AttestationReceiver
 	BlockReceiver                 blockchain.BlockReceiver
@@ -196,8 +196,8 @@ func (s *Service) Start() {
 		AttPool:                s.cfg.AttestationsPool,
 		ExitPool:               s.cfg.ExitPool,
 		HeadFetcher:            s.cfg.HeadFetcher,
-		HeadUpdater:            s.cfg.HeadUpdater,
 		ForkFetcher:            s.cfg.ForkFetcher,
+		ForkchoiceFetcher:      s.cfg.ForkchoiceFetcher,
 		GenesisFetcher:         s.cfg.GenesisFetcher,
 		FinalizationFetcher:    s.cfg.FinalizationFetcher,
 		TimeFetcher:            s.cfg.GenesisTimeFetcher,
@@ -227,7 +227,6 @@ func (s *Service) Start() {
 	}
 	validatorServerV1 := &validator.Server{
 		HeadFetcher:           s.cfg.HeadFetcher,
-		HeadUpdater:           s.cfg.HeadUpdater,
 		TimeFetcher:           s.cfg.GenesisTimeFetcher,
 		SyncChecker:           s.cfg.SyncService,
 		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
@@ -280,7 +279,6 @@ func (s *Service) Start() {
 		BeaconDB:                    s.cfg.BeaconDB,
 		AttestationsPool:            s.cfg.AttestationsPool,
 		SlashingsPool:               s.cfg.SlashingsPool,
-		HeadUpdater:                 s.cfg.HeadUpdater,
 		OptimisticModeFetcher:       s.cfg.OptimisticModeFetcher,
 		HeadFetcher:                 s.cfg.HeadFetcher,
 		FinalizationFetcher:         s.cfg.FinalizationFetcher,
@@ -363,6 +361,7 @@ func (s *Service) Start() {
 			},
 			OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
 			ForkFetcher:           s.cfg.ForkFetcher,
+			ForkchoiceFetcher:     s.cfg.ForkchoiceFetcher,
 			FinalizationFetcher:   s.cfg.FinalizationFetcher,
 			ChainInfoFetcher:      s.cfg.ChainInfoFetcher,
 		}

beacon-chain/state/fieldtrie/BUILD.bazel

@@ -12,7 +12,6 @@ go_library(
         "//beacon-chain/state/state-native/custom-types:go_default_library",
         "//beacon-chain/state/state-native/types:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
-        "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/state/fieldtrie/field_trie_helpers.go

@@ -9,7 +9,6 @@ import (
 	customtypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/state/state-native/custom-types"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state/state-native/types"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state/stateutil"
-	"github.com/prysmaticlabs/prysm/v4/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	pmath "github.com/prysmaticlabs/prysm/v4/math"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
@@ -250,9 +249,8 @@ func handleEth1DataSlice(val []*ethpb.Eth1Data, indices []uint64, convertAll boo
 		length = len(val)
 	}
 	roots := make([][32]byte, 0, length)
-	hasher := hash.CustomSHA256Hasher()
 	rootCreator := func(input *ethpb.Eth1Data) error {
-		newRoot, err := stateutil.Eth1DataRootWithHasher(hasher, input)
+		newRoot, err := stateutil.Eth1DataRootWithHasher(input)
 		if err != nil {
 			return err
 		}

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

@@ -9,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state/stateutil"
 	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
-	"github.com/prysmaticlabs/prysm/v4/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/encoding/ssz"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
@@ -24,7 +23,6 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 	if state == nil {
 		return nil, errors.New("nil state")
 	}
-	hasher := hash.CustomSHA256Hasher()
 	var fieldRoots [][]byte
 	switch state.version {
 	case version.Phase0:
@@ -100,7 +98,7 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 	fieldRoots[types.HistoricalRoots.RealPosition()] = historicalRootsRt[:]
 
 	// Eth1Data data structure root.
-	eth1HashTreeRoot, err := stateutil.Eth1Root(hasher, state.eth1Data)
+	eth1HashTreeRoot, err := stateutil.Eth1Root(state.eth1Data)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not compute eth1data merkleization")
 	}

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

@@ -14,7 +14,6 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/container/slice"
-	"github.com/prysmaticlabs/prysm/v4/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/encoding/ssz"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
@@ -811,7 +810,6 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 	defer span.End()
 	span.AddAttributes(trace.StringAttribute("field", field.String(b.version)))
 
-	hasher := hash.CustomSHA256Hasher()
 	switch field {
 	case types.GenesisTime:
 		return ssz.Uint64Root(b.genesisTime), nil
@@ -852,7 +850,7 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 		}
 		return ssz.ByteArrayRootWithLimit(hRoots, fieldparams.HistoricalRootsLength)
 	case types.Eth1Data:
-		return stateutil.Eth1Root(hasher, b.eth1Data)
+		return stateutil.Eth1Root(b.eth1Data)
 	case types.Eth1DataVotes:
 		if b.rebuildTrie[field] {
 			err := b.resetFieldTrie(

beacon-chain/state/stateutil/eth1_root.go

@@ -6,14 +6,13 @@ import (
 
 	"github.com/pkg/errors"
 	params "github.com/prysmaticlabs/prysm/v4/config/params"
-	"github.com/prysmaticlabs/prysm/v4/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/encoding/ssz"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 )
 
 // Eth1DataRootWithHasher returns the hash tree root of input `eth1Data`.
-func Eth1DataRootWithHasher(hasher ssz.HashFn, eth1Data *ethpb.Eth1Data) ([32]byte, error) {
+func Eth1DataRootWithHasher(eth1Data *ethpb.Eth1Data) ([32]byte, error) {
 	if eth1Data == nil {
 		return [32]byte{}, errors.New("nil eth1 data")
 	}
@@ -42,21 +41,16 @@ func Eth1DataRootWithHasher(hasher ssz.HashFn, eth1Data *ethpb.Eth1Data) ([32]by
 
 // Eth1DatasRoot returns the hash tree root of input `eth1Datas`.
 func Eth1DatasRoot(eth1Datas []*ethpb.Eth1Data) ([32]byte, error) {
-	hasher := hash.CustomSHA256Hasher()
 	eth1VotesRoots := make([][32]byte, 0, len(eth1Datas))
 	for i := 0; i < len(eth1Datas); i++ {
-		eth1, err := Eth1DataRootWithHasher(hasher, eth1Datas[i])
+		eth1, err := Eth1DataRootWithHasher(eth1Datas[i])
 		if err != nil {
 			return [32]byte{}, errors.Wrap(err, "could not compute eth1data merkleization")
 		}
 		eth1VotesRoots = append(eth1VotesRoots, eth1)
 	}
 
-	eth1VotesRootsRoot, err := ssz.BitwiseMerkleize(
-		eth1VotesRoots,
-		uint64(len(eth1VotesRoots)),
-		params.BeaconConfig().Eth1DataVotesLength(),
-	)
+	eth1VotesRootsRoot, err := ssz.BitwiseMerkleize(eth1VotesRoots, uint64(len(eth1VotesRoots)), params.BeaconConfig().Eth1DataVotesLength())
 	if err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not compute eth1data votes merkleization")
 	}

beacon-chain/state/stateutil/field_root_attestation.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/pkg/errors"
 	params "github.com/prysmaticlabs/prysm/v4/config/params"
-	"github.com/prysmaticlabs/prysm/v4/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v4/encoding/ssz"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 )
@@ -24,21 +23,16 @@ func EpochAttestationsRoot(atts []*ethpb.PendingAttestation) ([32]byte, error) {
 		return [32]byte{}, fmt.Errorf("epoch attestation exceeds max length %d", max)
 	}
 
-	hasher := hash.CustomSHA256Hasher()
 	roots := make([][32]byte, len(atts))
 	for i := 0; i < len(atts); i++ {
-		pendingRoot, err := pendingAttestationRoot(hasher, atts[i])
+		pendingRoot, err := pendingAttestationRoot(atts[i])
 		if err != nil {
 			return [32]byte{}, errors.Wrap(err, "could not attestation merkleization")
 		}
 		roots[i] = pendingRoot
 	}
 
-	attsRootsRoot, err := ssz.BitwiseMerkleize(
-		roots,
-		uint64(len(roots)),
-		params.BeaconConfig().CurrentEpochAttestationsLength(),
-	)
+	attsRootsRoot, err := ssz.BitwiseMerkleize(roots, uint64(len(roots)), params.BeaconConfig().CurrentEpochAttestationsLength())
 	if err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not compute epoch attestations merkleization")
 	}
@@ -53,7 +47,7 @@ func EpochAttestationsRoot(atts []*ethpb.PendingAttestation) ([32]byte, error) {
 	return res, nil
 }
 
-func pendingAttestationRoot(hasher ssz.HashFn, att *ethpb.PendingAttestation) ([32]byte, error) {
+func pendingAttestationRoot(att *ethpb.PendingAttestation) ([32]byte, error) {
 	if att == nil {
 		return [32]byte{}, errors.New("nil pending attestation")
 	}

beacon-chain/state/stateutil/field_root_eth1.go

@@ -2,18 +2,17 @@ package stateutil
 
 import (
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v4/encoding/ssz"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 )
 
 // Eth1Root computes the HashTreeRoot Merkleization of
 // a BeaconBlockHeader struct according to the eth2
 // Simple Serialize specification.
-func Eth1Root(hasher ssz.HashFn, eth1Data *ethpb.Eth1Data) ([32]byte, error) {
+func Eth1Root(eth1Data *ethpb.Eth1Data) ([32]byte, error) {
 	if eth1Data == nil {
 		return [32]byte{}, errors.New("nil eth1 data")
 	}
-	return Eth1DataRootWithHasher(hasher, eth1Data)
+	return Eth1DataRootWithHasher(eth1Data)
 }
 
 // Eth1DataVotesRoot computes the HashTreeRoot Merkleization of

beacon-chain/state/stateutil/historical_summaries_root.go

@@ -26,11 +26,7 @@ func HistoricalSummariesRoot(summaries []*ethpb.HistoricalSummary) ([32]byte, er
 		roots[i] = r
 	}
 
-	summariesRoot, err := ssz.BitwiseMerkleize(
-		roots,
-		uint64(len(roots)),
-		fieldparams.HistoricalRootsLength,
-	)
+	summariesRoot, err := ssz.BitwiseMerkleize(roots, uint64(len(roots)), fieldparams.HistoricalRootsLength)
 	if err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not compute historical summaries merkleization")
 	}

beacon-chain/sync/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "batch_verifier.go",
         "block_and_blob_queue.go",
+        "block_batcher.go",
         "broadcast_bls_changes.go",
         "context.go",
         "deadlines.go",
@@ -140,6 +141,7 @@ go_test(
         "batch_verifier_test.go",
         "blobs_test.go",
         "block_and_blob_queue_test.go",
+        "block_batcher_test.go",
         "broadcast_bls_changes_test.go",
         "context_test.go",
         "decode_pubsub_test.go",
@@ -154,6 +156,7 @@ go_test(
         "rpc_blob_sidecars_by_root_test.go",
         "rpc_chunked_response_test.go",
         "rpc_goodbye_test.go",
+        "rpc_handler_test.go",
         "rpc_metadata_test.go",
         "rpc_ping_test.go",
         "rpc_send_request_test.go",
@@ -245,7 +248,6 @@ go_test(
         "@com_github_libp2p_go_libp2p_pubsub//pb:go_default_library",
         "@com_github_patrickmn_go_cache//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",

beacon-chain/sync/blobs_test.go

@@ -15,7 +15,6 @@ import (
 	mock "github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/testing"
 	db "github.com/prysmaticlabs/prysm/v4/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p/encoder"
 	p2ptest "github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p/testing"
 	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
@@ -43,12 +42,14 @@ type blobsTestCase struct {
 	requestFromSidecars requestFromSidecars
 	topic               protocol.ID
 	oldestSlot          oldestSlotCallback
+	streamReader        expectedRequirer
 }
 
 type testHandler func(s *Service) rpcHandler
 type expectedDefiner func(t *testing.T, scs []*ethpb.BlobSidecar, req interface{}) []*expectedBlobChunk
 type requestFromSidecars func([]*ethpb.BlobSidecar) interface{}
 type oldestSlotCallback func(t *testing.T) types.Slot
+type expectedRequirer func(*testing.T, *Service, []*expectedBlobChunk) func(network.Stream)
 
 func generateTestBlockWithSidecars(t *testing.T, parent [32]byte, slot types.Slot, nblobs int) (*ethpb.SignedBeaconBlockDeneb, []*ethpb.BlobSidecar) {
 	// Start service with 160 as allowed blocks capacity (and almost zero capacity recovery).
@@ -131,9 +132,9 @@ type expectedBlobChunk struct {
 }
 
 func (r *expectedBlobChunk) requireExpected(t *testing.T, s *Service, stream network.Stream) {
-	d := s.cfg.p2p.Encoding().DecodeWithMaxLength
+	encoding := s.cfg.p2p.Encoding()
 
-	code, _, err := ReadStatusCode(stream, &encoder.SszNetworkEncoder{})
+	code, _, err := ReadStatusCode(stream, encoding)
 	require.NoError(t, err)
 	require.Equal(t, r.code, code, "unexpected response code")
 	//require.Equal(t, r.message, msg, "unexpected error message")
@@ -150,7 +151,7 @@ func (r *expectedBlobChunk) requireExpected(t *testing.T, s *Service, stream net
 	require.Equal(t, ctxBytes, bytesutil.ToBytes4(c))
 
 	sc := &ethpb.BlobSidecar{}
-	require.NoError(t, d(stream, sc))
+	require.NoError(t, encoding.DecodeWithMaxLength(stream, sc))
 	require.Equal(t, bytesutil.ToBytes32(sc.BlockRoot), bytesutil.ToBytes32(r.sidecar.BlockRoot))
 	require.Equal(t, sc.Index, r.sidecar.Index)
 }
@@ -196,7 +197,6 @@ func (c *blobsTestCase) setup(t *testing.T) (*Service, []*ethpb.BlobSidecar, fun
 	client := p2ptest.NewTestP2P(t)
 	s := &Service{
 		cfg:         &config{p2p: client, chain: c.chain, beaconDB: d},
-		blobs:       &MockBlobDB{},
 		rateLimiter: newRateLimiter(client),
 	}
 
@@ -208,22 +208,29 @@ func (c *blobsTestCase) setup(t *testing.T) (*Service, []*ethpb.BlobSidecar, fun
 	return s, sidecars, cleanup
 }
 
+func defaultExpectedRequirer(t *testing.T, s *Service, expect []*expectedBlobChunk) func(network.Stream) {
+	return func(stream network.Stream) {
+		for _, ex := range expect {
+			ex.requireExpected(t, s, stream)
+		}
+	}
+}
+
 func (c *blobsTestCase) run(t *testing.T) {
 	s, sidecars, cleanup := c.setup(t)
 	defer cleanup()
 	req := c.requestFromSidecars(sidecars)
 	expect := c.defineExpected(t, sidecars, req)
+	m := map[types.Slot][]*ethpb.BlobSidecar{}
 	for _, sc := range expect {
-		require.NoError(t, s.blobs.WriteBlobSidecar(sc.sidecar))
+		m[sc.sidecar.Slot] = append(m[sc.sidecar.Slot], sc.sidecar)
+	}
+	for _, blobSidecars := range m {
+		require.NoError(t, s.cfg.beaconDB.SaveBlobSidecar(context.Background(), blobSidecars))
 	}
 	if c.total != nil {
 		require.Equal(t, *c.total, len(expect))
 	}
-	nh := func(stream network.Stream) {
-		for _, ex := range expect {
-			ex.requireExpected(t, s, stream)
-		}
-	}
 	rht := &rpcHandlerTest{
 		t:       t,
 		topic:   c.topic,
@@ -231,7 +238,7 @@ func (c *blobsTestCase) run(t *testing.T) {
 		err:     c.err,
 		s:       s,
 	}
-	rht.testHandler(nh, c.serverHandle(s), req)
+	rht.testHandler(c.streamReader(t, s, expect), c.serverHandle(s), req)
 }
 
 // we use max uints for future forks, but this causes overflows when computing slots

beacon-chain/sync/block_and_blob_queue.go

@@ -1,6 +1,7 @@
 package sync
 
 import (
+	"context"
 	"sync"
 
 	"github.com/ethereum/go-ethereum/params"
@@ -134,3 +135,28 @@ func (q *blockAndBlocksQueue) canImport(r [32]byte) (bool, error) {
 
 	return len(commitments) == len(bnb.blobs), nil
 }
+
+func (q *blockAndBlocksQueue) missingRootAndIndex(ctx context.Context) (map[[32]byte][]uint64, error) {
+	q.lock.RLock()
+	defer q.lock.RUnlock()
+
+	m := make(map[[32]byte][]uint64)
+
+	for r, b := range q.queue {
+		kzgs, err := b.blk.Block().Body().BlobKzgCommitments()
+		if err != nil {
+			return nil, err
+		}
+		has := make(map[uint64]bool)
+		for _, blob := range b.blobs {
+			has[blob.Index] = true
+		}
+		for i := range kzgs {
+			if has[uint64(i)] {
+				continue
+			}
+			m[r] = append(m[r], uint64(i))
+		}
+	}
+	return m, nil
+}

beacon-chain/sync/block_and_blob_queue_test.go

@@ -1,6 +1,7 @@
 package sync
 
 import (
+	"context"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
@@ -106,3 +107,16 @@ func Test_blockAndBlocksQueue(t *testing.T) {
 		require.Equal(t, false, canImport)
 	})
 }
+
+func Test_blockAndBlocksQueue_missingRootAndIndex(t *testing.T) {
+	q := newBlockAndBlobs()
+	sb, err := blocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlockDeneb(&eth.SignedBeaconBlockDeneb{Block: &eth.BeaconBlockDeneb{}}))
+	require.NoError(t, err)
+	b := bytesutil.PadTo([]byte("kzg"), 48)
+	require.NoError(t, sb.SetBlobKzgCommitments([][]byte{b, b, b}))
+	require.NoError(t, err)
+	require.NoError(t, q.addBlock(sb))
+	m, err := q.missingRootAndIndex(context.Background())
+	require.NoError(t, err)
+	t.Log(m)
+}

beacon-chain/sync/block_batcher.go

@@ -0,0 +1,184 @@
+package sync
+
+import (
+	"context"
+	"sort"
+	"time"
+
+	libp2pcore "github.com/libp2p/go-libp2p/core"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db/filters"
+	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
+)
+
+type canonicalChecker func(context.Context, [32]byte) (bool, error)
+
+// filters all the provided blocks to ensure they are canonical
+// and are strictly linear.
+func filterCanonical(ctx context.Context, blks []blocks.ROBlock, prevRoot *[32]byte, canonical canonicalChecker) ([]blocks.ROBlock, []blocks.ROBlock, error) {
+	seq := make([]blocks.ROBlock, 0, len(blks))
+	nseq := make([]blocks.ROBlock, 0)
+	for i, b := range blks {
+		cb, err := canonical(ctx, b.Root())
+		if err != nil {
+			return nil, nil, err
+		}
+		if !cb {
+			continue
+		}
+		// filterCanonical is called in batches, so prevRoot can be the last root from the previous batch.
+		// prevRoot will be the zero value until we find the first canonical block in a given request.
+		first := *prevRoot == [32]byte{}
+		// We assume blocks are processed in order, so the previous canonical root should be the parent of the next.
+		// If the current block isn't descended from the last, something is wrong. Append everything remaining
+		// to the list of non-sequential blocks and stop building the canonical list.
+		if !first && *prevRoot != b.Block().ParentRoot() {
+			nseq = append(nseq, blks[i:]...)
+			break
+		}
+		seq = append(seq, blks[i])
+		// Set the previous root as the
+		// newly added block's root
+		currRoot := b.Root()
+		*prevRoot = currRoot
+	}
+	return seq, nseq, nil
+}
+
+// returns a copy of the []ROBlock list in sorted order with duplicates removed
+func sortedUniqueBlocks(blks []blocks.ROBlock) []blocks.ROBlock {
+	// Remove duplicate blocks received
+	sort.Sort(blocks.ROBlockSlice(blks))
+	u := 0
+	for i := 1; i < len(blks); i++ {
+		if blks[i].Root() != blks[u].Root() {
+			u += 1
+			if u != i {
+				blks[u] = blks[i]
+			}
+		}
+	}
+	return blks[:u+1]
+}
+
+type blockBatch struct {
+	start  primitives.Slot
+	end    primitives.Slot
+	seq    []blocks.ROBlock
+	nonseq []blocks.ROBlock
+	err    error
+}
+
+func (bb blockBatch) RateLimitCost() int {
+	return int(bb.end - bb.start)
+}
+
+func (bb blockBatch) Sequence() []blocks.ROBlock {
+	return bb.seq
+}
+
+func (bb blockBatch) SequenceBroken() bool {
+	return len(bb.nonseq) > 0
+}
+
+func (bb blockBatch) Err() error {
+	return bb.err
+}
+
+type blockRangeBatcher struct {
+	start       primitives.Slot
+	end         primitives.Slot
+	size        uint64
+	db          db.NoHeadAccessDatabase
+	limiter     *limiter
+	isCanonical canonicalChecker
+	ticker      *time.Ticker
+
+	lastSeq [32]byte
+	current *blockBatch
+}
+
+func (bb *blockRangeBatcher) genesisBlock(ctx context.Context) (blocks.ROBlock, error) {
+	b, err := bb.db.GenesisBlock(ctx)
+	if err != nil {
+		return blocks.ROBlock{}, err
+	}
+	htr, err := b.Block().HashTreeRoot()
+	if err != nil {
+		return blocks.ROBlock{}, err
+	}
+	return blocks.NewROBlock(b, htr), nil
+}
+
+func newBlockBatch(start, reqEnd primitives.Slot, size uint64) (blockBatch, bool) {
+	if start > reqEnd {
+		return blockBatch{}, false
+	}
+	nb := blockBatch{start: start, end: start.Add(size - 1)}
+	if nb.end > reqEnd {
+		nb.end = reqEnd
+	}
+	return nb, true
+}
+
+func (bat blockBatch) Next(reqEnd primitives.Slot, size uint64) (blockBatch, bool) {
+	if bat.SequenceBroken() {
+		return blockBatch{}, false
+	}
+	return newBlockBatch(bat.end.Add(1), reqEnd, size)
+}
+
+func (bb *blockRangeBatcher) Next(ctx context.Context, stream libp2pcore.Stream) (blockBatch, bool) {
+	var nb blockBatch
+	var ok bool
+	if bb.current != nil {
+		current := *bb.current
+		nb, ok = current.Next(bb.end, bb.size)
+	} else {
+		nb, ok = newBlockBatch(bb.start, bb.end, bb.size)
+	}
+	if !ok {
+		return blockBatch{}, false
+	}
+	if err := bb.limiter.validateRequest(stream, bb.size); err != nil {
+		return blockBatch{err: errors.Wrap(err, "throttled by rate limiter")}, false
+	}
+
+	// block if there is work to do, unless this is the first batch
+	if bb.ticker != nil && bb.current != nil {
+		<-bb.ticker.C
+	}
+	filter := filters.NewFilter().SetStartSlot(nb.start).SetEndSlot(nb.end)
+	blks, roots, err := bb.db.Blocks(ctx, filter)
+	if err != nil {
+		return blockBatch{err: errors.Wrap(err, "Could not retrieve blocks")}, false
+	}
+
+	// make slice with extra +1 capacity in case we want to grow it to also hold the genesis block
+	rob := make([]blocks.ROBlock, len(blks), len(blks)+1)
+	goff := 0 // offset for genesis value
+	if nb.start == 0 {
+		gb, err := bb.genesisBlock(ctx)
+		if err != nil {
+			return blockBatch{err: errors.Wrap(err, "could not retrieve genesis block")}, false
+		}
+		rob = append(rob, blocks.ROBlock{}) // grow the slice to its capacity to hold the genesis block
+		rob[0] = gb
+		goff = 1
+	}
+	for i := 0; i < len(blks); i++ {
+		rob[goff+i] = blocks.NewROBlock(blks[i], roots[i])
+	}
+	// Filter and sort our retrieved blocks, so that
+	// we only return valid sets of blocks.
+	rob = sortedUniqueBlocks(rob)
+
+	nb.seq, nb.nonseq, nb.err = filterCanonical(ctx, rob, &bb.lastSeq, bb.isCanonical)
+
+	// Decrease allowed blocks capacity by the number of streamed blocks.
+	bb.limiter.add(stream, int64(1+nb.end.SubSlot(nb.start)))
+	bb.current = &nb
+	return *bb.current, true
+}

beacon-chain/sync/block_batcher_test.go

@@ -0,0 +1,68 @@
+package sync
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v4/testing/require"
+)
+
+func TestSortedObj_SortBlocksRoots(t *testing.T) {
+	source := rand.NewSource(33)
+	randGen := rand.New(source)
+	randFunc := func() int64 {
+		return randGen.Int63n(50)
+	}
+
+	var blks []blocks.ROBlock
+	for i := 0; i < 10; i++ {
+		slot := primitives.Slot(randFunc())
+		newBlk, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot, Body: &ethpb.BeaconBlockBody{}}})
+		require.NoError(t, err)
+		root := bytesutil.ToBytes32(bytesutil.Bytes32(uint64(slot)))
+		blks = append(blks, blocks.NewROBlock(newBlk, root))
+	}
+
+	newBlks := sortedUniqueBlocks(blks)
+	previousSlot := primitives.Slot(0)
+	for _, b := range newBlks {
+		if b.Block().Slot() < previousSlot {
+			t.Errorf("Block list is not sorted as %d is smaller than previousSlot %d", b.Block().Slot(), previousSlot)
+		}
+		previousSlot = b.Block().Slot()
+	}
+}
+
+func TestSortedObj_NoDuplicates(t *testing.T) {
+	source := rand.NewSource(33)
+	randGen := rand.New(source)
+	var blks []blocks.ROBlock
+	randFunc := func() int64 {
+		return randGen.Int63n(50)
+	}
+
+	for i := 0; i < 10; i++ {
+		slot := primitives.Slot(randFunc())
+		newBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot, Body: &ethpb.BeaconBlockBody{}}}
+		// append twice
+		wsb, err := blocks.NewSignedBeaconBlock(newBlk)
+		require.NoError(t, err)
+		wsbCopy, err := wsb.Copy()
+		require.NoError(t, err)
+		root := bytesutil.ToBytes32(bytesutil.Bytes32(uint64(slot)))
+		blks = append(blks, blocks.NewROBlock(wsb, root), blocks.NewROBlock(wsbCopy, root))
+	}
+
+	dedup := sortedUniqueBlocks(blks)
+	roots := make(map[[32]byte]int)
+	for i, b := range dedup {
+		if di, dup := roots[b.Root()]; dup {
+			t.Errorf("Duplicated root %#x at index %d and %d", b.Root(), di, i)
+		}
+		roots[b.Root()] = i
+	}
+}

beacon-chain/sync/rpc_beacon_blocks_by_range.go

@@ -2,13 +2,10 @@ package sync
 
 import (
 	"context"
-	"sort"
 	"time"
 
 	libp2pcore "github.com/libp2p/go-libp2p/core"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db/filters"
 	p2ptypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p/types"
 	"github.com/prysmaticlabs/prysm/v4/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
@@ -126,25 +123,13 @@ func (s *Service) writeBlockBatchToStream(ctx context.Context, batch blockBatch,
 	ctx, span := trace.StartSpan(ctx, "sync.WriteBlockRangeToStream")
 	defer span.End()
 
-	blks := batch.Sequence()
-	// If the blocks are blinded, we reconstruct the full block via the execution client.
-	blindedExists := false
-	blindedIndex := 0
-	for i, b := range blks {
-		// Since the blocks are sorted in ascending order, we assume that the following
-		// blocks from the first blinded block are also ascending.
-		if b.IsBlinded() {
-			blindedExists = true
-			blindedIndex = i
-			break
-		}
-	}
-
-	for _, b := range blks {
+	blinded := make([]interfaces.ReadOnlySignedBeaconBlock, 0)
+	for _, b := range batch.Sequence() {
 		if err := blocks.BeaconBlockIsNil(b); err != nil {
 			continue
 		}
 		if b.IsBlinded() {
+			blinded = append(blinded, b.ReadOnlySignedBeaconBlock)
 			continue
 		}
 		if chunkErr := s.chunkBlockWriter(stream, b); chunkErr != nil {
@@ -152,22 +137,16 @@ func (s *Service) writeBlockBatchToStream(ctx context.Context, batch blockBatch,
 			return chunkErr
 		}
 	}
-
-	var err error
-	var reconstructedBlock []interfaces.SignedBeaconBlock
-	if blindedExists {
-		blinded := blks[blindedIndex:]
-		unwrapped := make([]interfaces.ReadOnlySignedBeaconBlock, len(blinded))
-		for i := range blinded {
-			unwrapped[i] = blks[i].ReadOnlySignedBeaconBlock
-		}
-		reconstructedBlock, err = s.cfg.executionPayloadReconstructor.ReconstructFullBellatrixBlockBatch(ctx, unwrapped)
-		if err != nil {
-			log.WithError(err).Error("Could not reconstruct full bellatrix block batch from blinded bodies")
-			return err
-		}
+	if len(blinded) == 0 {
+		return nil
 	}
-	for _, b := range reconstructedBlock {
+
+	reconstructed, err := s.cfg.executionPayloadReconstructor.ReconstructFullBellatrixBlockBatch(ctx, blinded)
+	if err != nil {
+		log.WithError(err).Error("Could not reconstruct full bellatrix block batch from blinded bodies")
+		return err
+	}
+	for _, b := range reconstructed {
 		if err := blocks.BeaconBlockIsNil(b); err != nil {
 			continue
 		}
@@ -182,173 +161,3 @@ func (s *Service) writeBlockBatchToStream(ctx context.Context, batch blockBatch,
 
 	return nil
 }
-
-type canonicalChecker func(context.Context, [32]byte) (bool, error)
-
-// filters all the provided blocks to ensure they are canonical
-// and are strictly linear.
-func filterCanonical(ctx context.Context, blks []blocks.ROBlock, prevRoot *[32]byte, canonical canonicalChecker) ([]blocks.ROBlock, []blocks.ROBlock, error) {
-	seq := make([]blocks.ROBlock, 0, len(blks))
-	nseq := make([]blocks.ROBlock, 0)
-	for i, b := range blks {
-		cb, err := canonical(ctx, b.Root())
-		if err != nil {
-			return nil, nil, err
-		}
-		if !cb {
-			continue
-		}
-		// filterCanonical is called in batches, so prevRoot can be the last root from the previous batch.
-		// prevRoot will be the zero value until we find the first canonical block in a given request.
-		first := *prevRoot == [32]byte{}
-		// We assume blocks are processed in order, so the previous canonical root should be the parent of the next.
-		// If the current block isn't descended from the last, something is wrong. Append everything remaining
-		// to the list of non-sequential blocks and stop building the canonical list.
-		if !first && *prevRoot != b.Block().ParentRoot() {
-			nseq = append(nseq, blks[i:]...)
-			break
-		}
-		seq = append(seq, blks[i])
-		// Set the previous root as the
-		// newly added block's root
-		currRoot := b.Root()
-		*prevRoot = currRoot
-	}
-	return seq, nseq, nil
-}
-
-// returns a copy of the []ROBlock list in sorted order with duplicates removed
-func sortedUniqueBlocks(blks []blocks.ROBlock) []blocks.ROBlock {
-	// Remove duplicate blocks received
-	sort.Sort(blocks.ROBlockSlice(blks))
-	u := 0
-	for i := 1; i < len(blks); i++ {
-		if blks[i].Root() != blks[u].Root() {
-			u += 1
-			if u != i {
-				blks[u] = blks[i]
-			}
-		}
-	}
-	return blks[:u+1]
-}
-
-type blockBatch struct {
-	start  primitives.Slot
-	end    primitives.Slot
-	seq    []blocks.ROBlock
-	nonseq []blocks.ROBlock
-	err    error
-}
-
-func (bb blockBatch) RateLimitCost() int {
-	return int(bb.end - bb.start)
-}
-
-func (bb blockBatch) Sequence() []blocks.ROBlock {
-	return bb.seq
-}
-
-func (bb blockBatch) SequenceBroken() bool {
-	return len(bb.nonseq) > 0
-}
-
-func (bb blockBatch) Err() error {
-	return bb.err
-}
-
-type blockRangeBatcher struct {
-	start       primitives.Slot
-	end         primitives.Slot
-	size        uint64
-	db          db.NoHeadAccessDatabase
-	limiter     *limiter
-	isCanonical canonicalChecker
-	ticker      *time.Ticker
-
-	lastSeq [32]byte
-	current *blockBatch
-}
-
-func (bb *blockRangeBatcher) genesisBlock(ctx context.Context) (blocks.ROBlock, error) {
-	b, err := bb.db.GenesisBlock(ctx)
-	if err != nil {
-		return blocks.ROBlock{}, err
-	}
-	htr, err := b.Block().HashTreeRoot()
-	if err != nil {
-		return blocks.ROBlock{}, err
-	}
-	return blocks.NewROBlock(b, htr), nil
-}
-
-func newBlockBatch(start, reqEnd primitives.Slot, size uint64) (blockBatch, bool) {
-	if start > reqEnd {
-		return blockBatch{}, false
-	}
-	nb := blockBatch{start: start, end: start.Add(size - 1)}
-	if nb.end > reqEnd {
-		nb.end = reqEnd
-	}
-	return nb, true
-}
-
-func (bat blockBatch) Next(reqEnd primitives.Slot, size uint64) (blockBatch, bool) {
-	if bat.SequenceBroken() {
-		return blockBatch{}, false
-	}
-	return newBlockBatch(bat.end.Add(1), reqEnd, size)
-}
-
-func (bb *blockRangeBatcher) Next(ctx context.Context, stream libp2pcore.Stream) (blockBatch, bool) {
-	var nb blockBatch
-	var ok bool
-	if bb.current != nil {
-		current := *bb.current
-		nb, ok = current.Next(bb.end, bb.size)
-	} else {
-		nb, ok = newBlockBatch(bb.start, bb.end, bb.size)
-	}
-	if !ok {
-		return blockBatch{}, false
-	}
-	if err := bb.limiter.validateRequest(stream, bb.size); err != nil {
-		return blockBatch{err: errors.Wrap(err, "throttled by rate limiter")}, false
-	}
-
-	// block if there is work to do, unless this is the first batch
-	if bb.ticker != nil && bb.current != nil {
-		<-bb.ticker.C
-	}
-	filter := filters.NewFilter().SetStartSlot(nb.start).SetEndSlot(nb.end)
-	blks, roots, err := bb.db.Blocks(ctx, filter)
-	if err != nil {
-		return blockBatch{err: errors.Wrap(err, "Could not retrieve blocks")}, false
-	}
-
-	// make slice with extra +1 capacity in case we want to grow it to also hold the genesis block
-	rob := make([]blocks.ROBlock, len(blks), len(blks)+1)
-	goff := 0 // offset for genesis value
-	if nb.start == 0 {
-		gb, err := bb.genesisBlock(ctx)
-		if err != nil {
-			return blockBatch{err: errors.Wrap(err, "could not retrieve genesis block")}, false
-		}
-		rob = append(rob, blocks.ROBlock{}) // grow the slice to its capacity to hold the genesis block
-		rob[0] = gb
-		goff = 1
-	}
-	for i := 0; i < len(blks); i++ {
-		rob[goff+i] = blocks.NewROBlock(blks[i], roots[i])
-	}
-	// Filter and sort our retrieved blocks, so that
-	// we only return valid sets of blocks.
-	rob = sortedUniqueBlocks(rob)
-
-	nb.seq, nb.nonseq, nb.err = filterCanonical(ctx, rob, &bb.lastSeq, bb.isCanonical)
-
-	// Decrease allowed blocks capacity by the number of streamed blocks.
-	bb.limiter.add(stream, int64(1+nb.end.SubSlot(nb.start)))
-	bb.current = &nb
-	return *bb.current, true
-}

beacon-chain/sync/rpc_beacon_blocks_by_range_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"io"
 	"math/big"
-	"math/rand"
 	"sync"
 	"testing"
 	"time"
@@ -1102,59 +1101,3 @@ func TestRPCBeaconBlocksByRange_FilterBlocks_PreviousRoot(t *testing.T) {
 	// pointer should reference a new root.
 	require.NotEqual(t, *ptrRt, [32]byte{})
 }
-
-func TestSortedObj_SortBlocksRoots(t *testing.T) {
-	source := rand.NewSource(33)
-	randGen := rand.New(source)
-	randFunc := func() int64 {
-		return randGen.Int63n(50)
-	}
-
-	var blks []blocks.ROBlock
-	for i := 0; i < 10; i++ {
-		slot := primitives.Slot(randFunc())
-		newBlk, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot, Body: &ethpb.BeaconBlockBody{}}})
-		require.NoError(t, err)
-		root := bytesutil.ToBytes32(bytesutil.Bytes32(uint64(slot)))
-		blks = append(blks, blocks.NewROBlock(newBlk, root))
-	}
-
-	newBlks := sortedUniqueBlocks(blks)
-	previousSlot := primitives.Slot(0)
-	for _, b := range newBlks {
-		if b.Block().Slot() < previousSlot {
-			t.Errorf("Block list is not sorted as %d is smaller than previousSlot %d", b.Block().Slot(), previousSlot)
-		}
-		previousSlot = b.Block().Slot()
-	}
-}
-
-func TestSortedObj_NoDuplicates(t *testing.T) {
-	source := rand.NewSource(33)
-	randGen := rand.New(source)
-	var blks []blocks.ROBlock
-	randFunc := func() int64 {
-		return randGen.Int63n(50)
-	}
-
-	for i := 0; i < 10; i++ {
-		slot := primitives.Slot(randFunc())
-		newBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot, Body: &ethpb.BeaconBlockBody{}}}
-		// append twice
-		wsb, err := blocks.NewSignedBeaconBlock(newBlk)
-		require.NoError(t, err)
-		wsbCopy, err := wsb.Copy()
-		require.NoError(t, err)
-		root := bytesutil.ToBytes32(bytesutil.Bytes32(uint64(slot)))
-		blks = append(blks, blocks.NewROBlock(wsb, root), blocks.NewROBlock(wsbCopy, root))
-	}
-
-	dedup := sortedUniqueBlocks(blks)
-	roots := make(map[[32]byte]int)
-	for i, b := range dedup {
-		if di, dup := roots[b.Root()]; dup {
-			t.Errorf("Duplicated root %#x at index %d and %d", b.Root(), di, i)
-		}
-		roots[b.Root()] = i
-	}
-}

beacon-chain/sync/rpc_beacon_blocks_by_root.go

@@ -58,7 +58,8 @@ func (s *Service) sendRecentBeaconBlocksAndBlobsRequest(ctx context.Context, blo
 		return nil
 	}
 
-	blobs, err := SendBlobSidecarByRoot(ctx, s.cfg.chain, s.cfg.p2p, id, reqs)
+	req := types.BlobSidecarsByRootReq(reqs)
+	blobs, err := SendBlobSidecarByRoot(ctx, s.cfg.chain, s.cfg.p2p, id, &req)
 	if err != nil {
 		return err
 	}

beacon-chain/sync/rpc_blob_sidecars_by_range.go

@@ -34,7 +34,7 @@ func (s *Service) streamBlobBatch(ctx context.Context, batch blockBatch, stream
 			s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
 			return writes, errors.Wrapf(err, "could not retrieve sidecars for block root %#x", root)
 		}
-		for _, sc := range scs.Sidecars {
+		for _, sc := range scs {
 			SetStreamWriteDeadline(stream, defaultWriteDuration)
 			if chunkErr := WriteBlobSidecarChunk(stream, s.cfg.chain, s.cfg.p2p.Encoding(), sc); chunkErr != nil {
 				log.WithError(chunkErr).Debug("Could not send a chunked response")

beacon-chain/sync/rpc_blob_sidecars_by_range_test.go

@@ -82,6 +82,9 @@ func (c *blobsTestCase) runTestBlobSidecarsByRange(t *testing.T) {
 	if c.oldestSlot == nil {
 		c.oldestSlot = c.defaultOldestSlotByRange
 	}
+	if c.streamReader == nil {
+		c.streamReader = defaultExpectedRequirer
+	}
 	c.run(t)
 }
 

beacon-chain/sync/rpc_blob_sidecars_by_root.go

@@ -35,6 +35,7 @@ func blobMinReqEpoch(finalized, current primitives.Epoch) primitives.Epoch {
 // blobSidecarByRootRPCHandler handles the /eth2/beacon_chain/req/blob_sidecars_by_root/1/ RPC request.
 // spec: https://github.com/ethereum/consensus-specs/blob/a7e45db9ac2b60a33e144444969ad3ac0aae3d4c/specs/deneb/p2p-interface.md#blobsidecarsbyroot-v1
 func (s *Service) blobSidecarByRootRPCHandler(ctx context.Context, msg interface{}, stream libp2pcore.Stream) error {
+	log.Warn("Received blob sidecar by root request")
 	ctx, span := trace.StartSpan(ctx, "sync.blobSidecarByRootRPCHandler")
 	defer span.End()
 	ctx, cancel := context.WithTimeout(ctx, ttfbTimeout)
@@ -48,22 +49,22 @@ func (s *Service) blobSidecarByRootRPCHandler(ctx context.Context, msg interface
 	minReqEpoch := blobMinReqEpoch(s.cfg.chain.FinalizedCheckpt().Epoch, slots.ToEpoch(s.cfg.chain.CurrentSlot()))
 	blobIdents := *ref
 	for i := range blobIdents {
+		log.Warnf("Received blob sidecar request for block %#x, index %d", blobIdents[i].BlockRoot, blobIdents[i].Index)
 		root, idx := bytesutil.ToBytes32(blobIdents[i].BlockRoot), blobIdents[i].Index
 		scs, err := s.cfg.beaconDB.BlobSidecarsByRoot(ctx, root)
 		if err != nil {
 			if errors.Is(err, db.ErrNotFound) {
+				log.WithError(err).Errorf("error retrieving BlobSidecar, root=%x, index=%d", root, idx)
 				continue
 			}
 			log.WithError(err).Debugf("error retrieving BlobSidecar, root=%x, index=%d", root, idx)
 			s.writeErrorResponseToStream(responseCodeServerError, types.ErrGeneric.Error(), stream)
 			return err
 		}
-		if idx >= uint64(len(scs.Sidecars)) {
-			log.WithError(err).Debugf("error retrieving BlobSidecar, root=%x, index=%d", root, idx)
-			s.writeErrorResponseToStream(responseCodeServerError, types.ErrGeneric.Error(), stream)
-			return err
+		if idx >= uint64(len(scs)) {
+			continue
 		}
-		sc := scs.Sidecars[idx]
+		sc := scs[idx]
 
 		// If any root in the request content references a block earlier than minimum_request_epoch,
 		// peers MAY respond with error code 3: ResourceUnavailable or not include the blob in the response.
@@ -82,5 +83,6 @@ func (s *Service) blobSidecarByRootRPCHandler(ctx context.Context, msg interface
 		}
 		s.rateLimiter.add(stream, 1)
 	}
+	closeStream(stream, log)
 	return nil
 }

beacon-chain/sync/rpc_blob_sidecars_by_root_test.go

@@ -3,6 +3,7 @@ package sync
 import (
 	"testing"
 
+	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p"
 	p2pTypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p/types"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
@@ -82,9 +83,45 @@ func (c *blobsTestCase) runTestBlobSidecarsByRoot(t *testing.T) {
 	if c.oldestSlot == nil {
 		c.oldestSlot = c.defaultOldestSlotByRoot
 	}
+	if c.streamReader == nil {
+		c.streamReader = defaultExpectedRequirer
+	}
 	c.run(t)
 }
 
+func TestReadChunkEncodedBlobs(t *testing.T) {
+	dmc := defaultMockChain(t)
+	cases := []*blobsTestCase{
+		{
+			name:         "test successful read via requester",
+			nblocks:      1,
+			chain:        dmc,
+			streamReader: readChunkEncodedBlobsAsStreamReader,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			c.runTestBlobSidecarsByRoot(t)
+		})
+	}
+}
+
+func readChunkEncodedBlobsAsStreamReader(t *testing.T, s *Service, expect []*expectedBlobChunk) func(network.Stream) {
+	ff := s.cfg.chain
+	encoding := s.cfg.p2p.Encoding()
+	return func(stream network.Stream) {
+		scs, err := readChunkEncodedBlobs(stream, ff, encoding)
+		require.NoError(t, err)
+		require.Equal(t, len(expect), len(scs))
+		for i, sc := range scs {
+			esc := expect[i].sidecar
+			require.Equal(t, esc.Slot, sc.Slot)
+			require.Equal(t, esc.Index, sc.Index)
+			require.Equal(t, bytesutil.ToBytes32(esc.BlockRoot), bytesutil.ToBytes32(sc.BlockRoot))
+		}
+	}
+}
+
 func TestBlobsByRootValidation(t *testing.T) {
 	cfg := params.BeaconConfig()
 	repositionFutureEpochs(cfg)

beacon-chain/sync/rpc_chunked_response.go

@@ -92,15 +92,15 @@ func ReadChunkedBlock(stream libp2pcore.Stream, chain blockchain.ForkFetcher, p2
 // WriteBlobSidecarChunk writes blob chunk object to stream.
 // response_chunk  ::= <result> | <context-bytes> | <encoding-dependent-header> | <encoded-payload>
 func WriteBlobSidecarChunk(stream libp2pcore.Stream, chain blockchain.ChainInfoFetcher, encoding encoder.NetworkEncoding, sidecar *ethpb.BlobSidecar) error {
-	if _, err := stream.Write([]byte{responseCodeSuccess}); err != nil {
-		return err
-	}
 	valRoot := chain.GenesisValidatorsRoot()
 	ctxBytes, err := forks.ForkDigestFromEpoch(slots.ToEpoch(sidecar.GetSlot()), valRoot[:])
 	if err != nil {
 		return err
 	}
 
+	if _, err := stream.Write([]byte{responseCodeSuccess}); err != nil {
+		return err
+	}
 	if err := writeContextToStream(ctxBytes[:], stream, chain); err != nil {
 		return err
 	}

beacon-chain/sync/rpc_send_request.go

@@ -7,7 +7,6 @@ import (
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/pkg/errors"
-	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p/encoder"
@@ -135,43 +134,41 @@ func SendBeaconBlocksByRootRequest(
 
 func SendBlobSidecarByRoot(
 	ctx context.Context, ci blockchain.ChainInfoFetcher, p2pApi p2p.P2P, pid peer.ID,
-	req p2ptypes.BlobSidecarsByRootReq,
+	req *p2ptypes.BlobSidecarsByRootReq,
 ) ([]*pb.BlobSidecar, error) {
 	topic, err := p2p.TopicFromMessage(p2p.BlobSidecarsByRootName, slots.ToEpoch(ci.CurrentSlot()))
 	if err != nil {
 		return nil, err
 	}
+	log.WithField("topic", topic).Debug("Sending blob sidecar request")
 	stream, err := p2pApi.Send(ctx, req, topic, pid)
 	if err != nil {
 		return nil, err
 	}
 	defer closeStream(stream, log)
 
-	max := int(params.BeaconNetworkConfig().MaxRequestBlobsSidecars * params.BeaconConfig().MaxBlobsPerBlock)
-	return readChunkEncodedBlobs(stream, max, ci, p2pApi.Encoding().DecodeWithMaxLength)
+	return readChunkEncodedBlobs(stream, ci, p2pApi.Encoding())
 }
 
 var ErrBlobChunkedReadFailure = errors.New("failed to read stream of chunk-encoded blobs")
 
-type readerSSZDecoder func(io.Reader, ssz.Unmarshaler) error
-
-func readChunkEncodedBlobs(stream network.Stream, max int, ff blockchain.ForkFetcher, decode readerSSZDecoder) ([]*pb.BlobSidecar, error) {
-	defer closeStream(stream, log)
-	//d := s.cfg.p2p.Encoding().DecodeWithMaxLength
-	sidecars := make([]*pb.BlobSidecar, 0)
+func readChunkEncodedBlobs(stream network.Stream, ff blockchain.ForkFetcher, encoding encoder.NetworkEncoding) ([]*pb.BlobSidecar, error) {
+	decode := encoding.DecodeWithMaxLength
+	max := int(params.BeaconNetworkConfig().MaxRequestBlobsSidecars)
 	var (
 		code uint8
 		msg  string
 		err  error
-		br   int
 	)
-	for code, msg, err = ReadStatusCode(stream, &encoder.SszNetworkEncoder{}); err != nil; br++ {
+	sidecars := make([]*pb.BlobSidecar, 0)
+	for i := 0; i < max; i++ {
+		code, msg, err = ReadStatusCode(stream, encoding)
+		if err != nil {
+			break
+		}
 		if code != 0 {
 			return nil, errors.Wrap(ErrBlobChunkedReadFailure, msg)
 		}
-		if br > max {
-			break
-		}
 		// TODO: we should add some code to switch on the fork version to determine deserialization type
 		// punting to rush this out to unblock testing.
 		_, err = readContextFromStream(stream, ff)
@@ -181,11 +178,11 @@ func readChunkEncodedBlobs(stream network.Stream, max int, ff blockchain.ForkFet
 
 		sc := &pb.BlobSidecar{}
 		if err := decode(stream, sc); err != nil {
-			return nil, errors.Wrap(err, "failed to decode the protobuf-enoded BlobSidecar message from RPC chunk stream")
+			return nil, errors.Wrap(err, "failed to decode the protobuf-encoded BlobSidecar message from RPC chunk stream")
 		}
 		sidecars = append(sidecars, sc)
 	}
-	if err != nil && !errors.Is(err, io.EOF) {
+	if !errors.Is(err, io.EOF) {
 		return nil, err
 	}
 	return sidecars, nil

beacon-chain/sync/service.go

@@ -186,6 +186,7 @@ func (s *Service) Start() {
 	s.processPendingAttsQueue()
 	s.maintainPeerStatuses()
 	s.resyncIfBehind()
+	s.requestMissingBlobsRoutine(s.ctx)
 
 	// Update sync metrics.
 	async.RunEvery(s.ctx, syncMetricsInterval, s.updateMetrics)

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -3,12 +3,17 @@ package sync
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain"
+	"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p/types"
+	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	eth "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
+	"github.com/prysmaticlabs/prysm/v4/time/slots"
 	"github.com/sirupsen/logrus"
 	"google.golang.org/protobuf/proto"
 )
@@ -81,9 +86,7 @@ func (s *Service) receiveBlockAndBlobs(ctx context.Context, root [32]byte) error
 			"root":      fmt.Sprintf("%#x", scs[0].BlockRoot),
 			"blobCount": len(scs),
 		}).Info("Saving blobs")
-		if err := s.cfg.beaconDB.SaveBlobSidecar(ctx, &eth.BlobSidecars{
-			Sidecars: scs,
-		}); err != nil {
+		if err := s.cfg.beaconDB.SaveBlobSidecar(ctx, scs); err != nil {
 			return err
 		}
 	}
@@ -111,3 +114,62 @@ func (s *Service) receiveBlock(ctx context.Context, signed interfaces.ReadOnlySi
 	}
 	return nil
 }
+
+func (s *Service) requestMissingBlobsRoutine(ctx context.Context) {
+
+	time.Sleep(5 * time.Second)
+
+	ticker := slots.NewSlotTickerWithOffset(s.cfg.chain.GenesisTime(), time.Second, params.BeaconConfig().SecondsPerSlot)
+
+	go func() {
+		for {
+			select {
+			case <-ticker.C():
+				cp := s.cfg.chain.FinalizedCheckpt()
+				_, bestPeers := s.cfg.p2p.Peers().BestFinalized(maxPeerRequest, cp.Epoch)
+				if len(bestPeers) == 0 {
+					log.Warn("No peers to request missing blobs")
+					continue
+				}
+				var reqs []*eth.BlobIdentifier
+
+				m, err := s.blockAndBlobs.missingRootAndIndex(ctx)
+				if err != nil {
+					log.WithError(err).Error("Failed to get missing root and index")
+					continue
+				}
+				if len(m) == 0 {
+					continue
+				}
+				for r, indices := range m {
+					for _, i := range indices {
+						reqs = append(reqs, &eth.BlobIdentifier{
+							BlockRoot: r[:],
+							Index:     i,
+						})
+					}
+				}
+				req := types.BlobSidecarsByRootReq(reqs)
+				scs, err := SendBlobSidecarByRoot(ctx, s.cfg.chain, s.cfg.p2p, bestPeers[0], &req)
+				if err != nil {
+					log.WithError(err).Error("Failed to send blob sidecar by root")
+					continue
+				}
+				for _, sc := range scs {
+					if err := s.blockAndBlobs.addBlob(sc); err != nil {
+						log.WithError(err).Error("Failed to add blob")
+						continue
+					}
+					if err := s.importBlockAndBlobs(ctx, bytesutil.ToBytes32(sc.BlockRoot)); err != nil {
+						log.WithError(err).Error("Failed to import block and blobs")
+						continue
+					}
+				}
+
+			case <-ctx.Done():
+				log.Debug("Context closed, exiting routine")
+				return
+			}
+		}
+	}()
+}

deps.bzl

@@ -737,7 +737,18 @@ def prysm_deps():
         sum = "h1:cenwrSVm+Z7QLSV/BsnenAOcDXdX4cMv4wP0B/5QbPg=",
         version = "v0.0.0-20160310174837-449fdfce4d96",
     )
-
+    go_repository(
+        name = "com_github_naoina_toml",
+        importpath = "github.com/naoina/toml",
+        sum = "h1:shk/vn9oCoOTmwcouEdwIeOtOGA/ELRUw/GwvxwfT+0=",
+        version = "v0.1.2-0.20170918210437-9fafd6967416",
+    )
+    go_repository(
+        name = "com_github_naoina_go_stringutil",
+        importpath = "github.com/naoina/go-stringutil",
+        sum = "h1:rCUeRUHjBjGTSHl0VC00jUPLz8/F9dDzYI70Hzifhks=",
+        version = "v0.1.0",
+    )
     go_repository(
         name = "com_github_dop251_goja",
         importpath = "github.com/dop251/goja",
@@ -988,7 +999,24 @@ def prysm_deps():
         sum = "h1:f6D9Hr8xV8uYKlyuj8XIruxlh9WjVjdh1gIicAS7ays=",
         version = "v0.0.0-20191108122812-4678299bea08",
     )
-
+    go_repository(
+        name = "com_github_gballet_go_verkle",
+        importpath = "github.com/gballet/go-verkle",
+        sum = "h1:AB7YjNrzlVHsYz06zCULVV2zYCEft82P86dSmtwxKL0=",
+        version = "v0.0.0-20220902153445-097bd83b7732",
+    )
+    go_repository(
+        name = "com_github_crate_crypto_go_ipa",
+        importpath = "github.com/crate-crypto/go-ipa",
+        sum = "h1:6IrxszG5G+O7zhtkWxq6+unVvnrm1fqV2Pe+T95DUzw=",
+        version = "v0.0.0-20220523130400-f11357ae11c7",
+    )
+    go_repository(
+        name = "com_github_jedisct1_go_minisign",
+        importpath = "github.com/jedisct1/go-minisign",
+        sum = "h1:UvSe12bq+Uj2hWd8aOlwPmoZ+CITRFrdit+sDGfAg8U=",
+        version = "v0.0.0-20190909160543-45766022959e",
+    )
     go_repository(
         name = "com_github_gdamore_encoding",
         importpath = "github.com/gdamore/encoding",

proto/eth/v1/events.pb.go

@@ -606,12 +606,12 @@ type EventPayloadAttributeV2_BasePayloadAttribute struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ProposalSlot        github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot           `protobuf:"varint,3,opt,name=proposal_slot,json=proposalSlot,proto3" json:"proposal_slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"`
-	ParentBlockNumber   uint64                                                                      `protobuf:"varint,4,opt,name=parent_block_number,json=parentBlockNumber,proto3" json:"parent_block_number,omitempty"`
-	ParentBlockRoot     []byte                                                                      `protobuf:"bytes,5,opt,name=parent_block_root,json=parentBlockRoot,proto3" json:"parent_block_root,omitempty" ssz-size:"32"`
-	ParentBlockHash     []byte                                                                      `protobuf:"bytes,6,opt,name=parent_block_hash,json=parentBlockHash,proto3" json:"parent_block_hash,omitempty" ssz-size:"32"`
-	ProposerIndex       github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.ValidatorIndex `protobuf:"varint,7,opt,name=proposer_index,json=proposerIndex,proto3" json:"proposer_index,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.ValidatorIndex"`
-	PayloadAttributesV2 *v1.PayloadAttributesV2                                                     `protobuf:"bytes,8,opt,name=payload_attributes_v2,json=payloadAttributesV2,proto3" json:"payload_attributes_v2,omitempty"`
+	ProposalSlot      github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot           `protobuf:"varint,3,opt,name=proposal_slot,json=proposalSlot,proto3" json:"proposal_slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"`
+	ParentBlockNumber uint64                                                                      `protobuf:"varint,4,opt,name=parent_block_number,json=parentBlockNumber,proto3" json:"parent_block_number,omitempty"`
+	ParentBlockRoot   []byte                                                                      `protobuf:"bytes,5,opt,name=parent_block_root,json=parentBlockRoot,proto3" json:"parent_block_root,omitempty" ssz-size:"32"`
+	ParentBlockHash   []byte                                                                      `protobuf:"bytes,6,opt,name=parent_block_hash,json=parentBlockHash,proto3" json:"parent_block_hash,omitempty" ssz-size:"32"`
+	ProposerIndex     github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.ValidatorIndex `protobuf:"varint,7,opt,name=proposer_index,json=proposerIndex,proto3" json:"proposer_index,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.ValidatorIndex"`
+	PayloadAttributes *v1.PayloadAttributesV2                                                     `protobuf:"bytes,8,opt,name=payload_attributes,json=payloadAttributes,proto3" json:"payload_attributes,omitempty"`
 }
 
 func (x *EventPayloadAttributeV2_BasePayloadAttribute) Reset() {
@@ -681,9 +681,9 @@ func (x *EventPayloadAttributeV2_BasePayloadAttribute) GetProposerIndex() github
 	return github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.ValidatorIndex(0)
 }
 
-func (x *EventPayloadAttributeV2_BasePayloadAttribute) GetPayloadAttributesV2() *v1.PayloadAttributesV2 {
+func (x *EventPayloadAttributeV2_BasePayloadAttribute) GetPayloadAttributes() *v1.PayloadAttributesV2 {
 	if x != nil {
-		return x.PayloadAttributesV2
+		return x.PayloadAttributes
 	}
 	return nil
 }
@@ -822,7 +822,7 @@ var file_proto_eth_v1_events_proto_rawDesc = []byte{
 	0x28, 0x0b, 0x32, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e,
 	0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x41,
 	0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x52, 0x11, 0x70, 0x61, 0x79, 0x6c, 0x6f,
-	0x61, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0xf8, 0x04, 0x0a,
+	0x61, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x22, 0xf3, 0x04, 0x0a,
 	0x17, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x41, 0x74, 0x74,
 	0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73,
 	0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69,
@@ -831,7 +831,7 @@ var file_proto_eth_v1_events_proto_rawDesc = []byte{
 	0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x41,
 	0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x56, 0x32, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x50,
 	0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52,
-	0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0xef, 0x03, 0x0a, 0x14, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61,
+	0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0xea, 0x03, 0x0a, 0x14, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61,
 	0x79, 0x6c, 0x6f, 0x61, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x12, 0x6a,
 	0x0a, 0x0d, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18,
 	0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75,
@@ -856,21 +856,21 @@ var file_proto_eth_v1_events_proto_rawDesc = []byte{
 	0x34, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65,
 	0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x56, 0x61, 0x6c,
 	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x0d, 0x70, 0x72, 0x6f,
-	0x70, 0x6f, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x5b, 0x0a, 0x15, 0x70, 0x61,
+	0x70, 0x6f, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x56, 0x0a, 0x12, 0x70, 0x61,
 	0x79, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73,
-	0x5f, 0x76, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x65, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50,
-	0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73,
-	0x56, 0x32, 0x52, 0x13, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69,
-	0x62, 0x75, 0x74, 0x65, 0x73, 0x56, 0x32, 0x42, 0x7e, 0x0a, 0x13, 0x6f, 0x72, 0x67, 0x2e, 0x65,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x42, 0x11,
-	0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x50, 0x72, 0x6f, 0x74,
-	0x6f, 0x50, 0x01, 0x5a, 0x2e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
-	0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72,
-	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x34, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68,
-	0x2f, 0x76, 0x31, 0xaa, 0x02, 0x0f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45,
-	0x74, 0x68, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x0f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
-	0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75,
+	0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x79, 0x6c,
+	0x6f, 0x61, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x56, 0x32, 0x52,
+	0x11, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74,
+	0x65, 0x73, 0x42, 0x7e, 0x0a, 0x13, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65,
+	0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x42, 0x11, 0x42, 0x65, 0x61, 0x63, 0x6f,
+	0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2e,
+	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d,
+	0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76,
+	0x34, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0xaa, 0x02,
+	0x0f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x56, 0x31,
+	0xca, 0x02, 0x0f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c,
+	0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -903,7 +903,7 @@ var file_proto_eth_v1_events_proto_depIdxs = []int32{
 	7,  // 0: ethereum.eth.v1.EventPayloadAttributeV1.data:type_name -> ethereum.eth.v1.EventPayloadAttributeV1.BasePayloadAttribute
 	8,  // 1: ethereum.eth.v1.EventPayloadAttributeV2.data:type_name -> ethereum.eth.v1.EventPayloadAttributeV2.BasePayloadAttribute
 	9,  // 2: ethereum.eth.v1.EventPayloadAttributeV1.BasePayloadAttribute.payload_attributes:type_name -> ethereum.engine.v1.PayloadAttributes
-	10, // 3: ethereum.eth.v1.EventPayloadAttributeV2.BasePayloadAttribute.payload_attributes_v2:type_name -> ethereum.engine.v1.PayloadAttributesV2
+	10, // 3: ethereum.eth.v1.EventPayloadAttributeV2.BasePayloadAttribute.payload_attributes:type_name -> ethereum.engine.v1.PayloadAttributesV2
 	4,  // [4:4] is the sub-list for method output_type
 	4,  // [4:4] is the sub-list for method input_type
 	4,  // [4:4] is the sub-list for extension type_name

proto/eth/v1/events.proto

@@ -159,6 +159,6 @@ message EventPayloadAttributeV2 {
         // The version N must match the payload attributes for the hard fork matching version.
         // The beacon API encoded object must have equivalent fields to its counterpart in execution-apis with two differences:
         // 1) snake_case identifiers must be used rather than camelCase; 2) integers must be encoded as quoted decimals rather than big-endian hex.
-        engine.v1.PayloadAttributesV2 payload_attributes_v2 = 8;
+        engine.v1.PayloadAttributesV2 payload_attributes = 8;
   }
 }

proto/prysm/v1alpha1/beacon_block.pb.go

@@ -3704,11 +3704,11 @@ var file_proto_prysm_v1alpha1_beacon_block_proto_rawDesc = []byte{
 	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x70,
 	0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70,
 	0x68, 0x61, 0x31, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79,
-	0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x77, 0x69, 0x74, 0x68,
-	0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70,
-	0x68, 0x61, 0x31, 0x2f, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x72, 0x79,
+	0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x62, 0x6c, 0x6f, 0x62,
+	0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70,
+	0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x77, 0x69,
+	0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
 	0x26, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x76, 0x31,
 	0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x67, 0x69, 0x6e,
 	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc9, 0x05, 0x0a, 0x18, 0x47, 0x65, 0x6e, 0x65,
@@ -4905,8 +4905,8 @@ func file_proto_prysm_v1alpha1_beacon_block_proto_init() {
 		return
 	}
 	file_proto_prysm_v1alpha1_attestation_proto_init()
-	file_proto_prysm_v1alpha1_withdrawals_proto_init()
 	file_proto_prysm_v1alpha1_blobs_proto_init()
+	file_proto_prysm_v1alpha1_withdrawals_proto_init()
 	if !protoimpl.UnsafeEnabled {
 		file_proto_prysm_v1alpha1_beacon_block_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*GenericSignedBeaconBlock); i {

proto/prysm/v1alpha1/beacon_block.proto

@@ -17,8 +17,8 @@ package ethereum.eth.v1alpha1;
 
 import "proto/eth/ext/options.proto";
 import "proto/prysm/v1alpha1/attestation.proto";
-import "proto/prysm/v1alpha1/withdrawals.proto";
 import "proto/prysm/v1alpha1/blobs.proto";
+import "proto/prysm/v1alpha1/withdrawals.proto";
 import "proto/engine/v1/execution_engine.proto";
 
 option csharp_namespace = "Ethereum.Eth.v1alpha1";

proto/prysm/v1alpha1/beacon_chain.proto

@@ -670,9 +670,7 @@ message ValidatorPerformanceRequest {
     repeated uint64 indices = 2 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.ValidatorIndex"];
 }
 
-// DEPRECATED: Prysm Web UI and associated endpoints will be fully removed in a future hard fork.
 message ValidatorPerformanceResponse {
-    option deprecated = true;
     // A list of validator effective balances mapped 1-to-1 with the request's
     // public keys.
     repeated uint64 current_effective_balances = 1;

testing/assertions/assertions.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"reflect"
 	"runtime"
+	"sort"
 	"strings"
 
 	"github.com/d4l3k/messagediff"
@@ -22,6 +23,12 @@ type AssertionTestingTB interface {
 
 type assertionLoggerFn func(string, ...interface{})
 
+func SprintfAssertionLoggerFn(s *string) assertionLoggerFn {
+	return func(ef string, eargs ...interface{}) {
+		*s = fmt.Sprintf(ef, eargs...)
+	}
+}
+
 // Equal compares values using comparison operator.
 func Equal(loggerFn assertionLoggerFn, expected, actual interface{}, msg ...interface{}) {
 	if expected != actual {
@@ -45,11 +52,44 @@ func DeepEqual(loggerFn assertionLoggerFn, expected, actual interface{}, msg ...
 	if !isDeepEqual(expected, actual) {
 		errMsg := parseMsg("Values are not equal", msg...)
 		_, file, line, _ := runtime.Caller(2)
-		diff, _ := messagediff.PrettyDiff(expected, actual)
+		diff := ""
+		if _, isProto := expected.(proto.Message); isProto {
+			diff = ProtobufPrettyDiff(expected, actual)
+		} else {
+			diff, _ = messagediff.PrettyDiff(expected, actual)
+		}
 		loggerFn("%s:%d %s, want: %#v, got: %#v, diff: %s", filepath.Base(file), line, errMsg, expected, actual, diff)
 	}
 }
 
+var protobufPrivateFields = map[string]bool{
+	"sizeCache": true,
+	"state":     true,
+}
+
+func ProtobufPrettyDiff(a, b interface{}) string {
+	d, _ := messagediff.DeepDiff(a, b)
+	var dstr []string
+	appendNotProto := func(path, str string) {
+		parts := strings.Split(path, ".")
+		if len(parts) > 1 && protobufPrivateFields[parts[1]] {
+			return
+		}
+		dstr = append(dstr, str)
+	}
+	for path, added := range d.Added {
+		appendNotProto(path.String(), fmt.Sprintf("added: %s = %#v\n", path.String(), added))
+	}
+	for path, removed := range d.Removed {
+		appendNotProto(path.String(), fmt.Sprintf("removed: %s = %#v\n", path.String(), removed))
+	}
+	for path, modified := range d.Modified {
+		appendNotProto(path.String(), fmt.Sprintf("modified: %s = %#v\n", path.String(), modified))
+	}
+	sort.Strings(dstr)
+	return strings.Join(dstr, "")
+}
+
 // DeepNotEqual compares values using DeepEqual.
 func DeepNotEqual(loggerFn assertionLoggerFn, expected, actual interface{}, msg ...interface{}) {
 	if isDeepEqual(expected, actual) {

testing/spectest/shared/common/forkchoice/builder.go

@@ -43,11 +43,11 @@ func (bb *Builder) Tick(t testing.TB, tick int64) {
 	currentSlot := uint64(tick) / params.BeaconConfig().SecondsPerSlot
 	for lastSlot < currentSlot {
 		lastSlot++
-		bb.service.ForkChoicer().SetGenesisTime(uint64(time.Now().Unix() - int64(params.BeaconConfig().SecondsPerSlot*lastSlot)))
-		require.NoError(t, bb.service.ForkChoicer().NewSlot(context.TODO(), primitives.Slot(lastSlot)))
+		bb.service.SetForkChoiceGenesisTime(uint64(time.Now().Unix() - int64(params.BeaconConfig().SecondsPerSlot*lastSlot)))
+		require.NoError(t, bb.service.NewSlot(context.TODO(), primitives.Slot(lastSlot)))
 	}
 	if tick > int64(params.BeaconConfig().SecondsPerSlot*lastSlot) {
-		bb.service.ForkChoicer().SetGenesisTime(uint64(time.Now().Unix() - tick))
+		bb.service.SetForkChoiceGenesisTime(uint64(time.Now().Unix() - tick))
 	}
 	bb.lastTick = tick
 }
@@ -144,9 +144,7 @@ func (bb *Builder) Check(t testing.TB, c *Check) {
 	}
 	if c.ProposerBoostRoot != nil {
 		want := fmt.Sprintf("%#x", common.FromHex(*c.ProposerBoostRoot))
-		bb.service.ForkChoiceStore().RLock()
-		got := fmt.Sprintf("%#x", bb.service.ForkChoiceStore().ProposerBoost())
-		bb.service.ForkChoiceStore().RUnlock()
+		got := fmt.Sprintf("%#x", bb.service.ProposerBoost())
 		require.DeepEqual(t, want, got)
 	}
 

testing/validator-mock/beacon_chain_client_mock.go

@@ -36,36 +36,6 @@ func (m *MockBeaconChainClient) EXPECT() *MockBeaconChainClientMockRecorder {
 	return m.recorder
 }
 
-// AttestationPool mocks base method.
-func (m *MockBeaconChainClient) AttestationPool(arg0 context.Context, arg1 *eth.AttestationPoolRequest) (*eth.AttestationPoolResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AttestationPool", arg0, arg1)
-	ret0, _ := ret[0].(*eth.AttestationPoolResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AttestationPool indicates an expected call of AttestationPool.
-func (mr *MockBeaconChainClientMockRecorder) AttestationPool(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttestationPool", reflect.TypeOf((*MockBeaconChainClient)(nil).AttestationPool), arg0, arg1)
-}
-
-// GetBeaconConfig mocks base method.
-func (m *MockBeaconChainClient) GetBeaconConfig(arg0 context.Context, arg1 *emptypb.Empty) (*eth.BeaconConfig, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetBeaconConfig", arg0, arg1)
-	ret0, _ := ret[0].(*eth.BeaconConfig)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetBeaconConfig indicates an expected call of GetBeaconConfig.
-func (mr *MockBeaconChainClientMockRecorder) GetBeaconConfig(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBeaconConfig", reflect.TypeOf((*MockBeaconChainClient)(nil).GetBeaconConfig), arg0, arg1)
-}
-
 // GetChainHead mocks base method.
 func (m *MockBeaconChainClient) GetChainHead(arg0 context.Context, arg1 *emptypb.Empty) (*eth.ChainHead, error) {
 	m.ctrl.T.Helper()
@@ -81,51 +51,6 @@ func (mr *MockBeaconChainClientMockRecorder) GetChainHead(arg0, arg1 interface{}
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChainHead", reflect.TypeOf((*MockBeaconChainClient)(nil).GetChainHead), arg0, arg1)
 }
 
-// GetIndividualVotes mocks base method.
-func (m *MockBeaconChainClient) GetIndividualVotes(arg0 context.Context, arg1 *eth.IndividualVotesRequest) (*eth.IndividualVotesRespond, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetIndividualVotes", arg0, arg1)
-	ret0, _ := ret[0].(*eth.IndividualVotesRespond)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetIndividualVotes indicates an expected call of GetIndividualVotes.
-func (mr *MockBeaconChainClientMockRecorder) GetIndividualVotes(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndividualVotes", reflect.TypeOf((*MockBeaconChainClient)(nil).GetIndividualVotes), arg0, arg1)
-}
-
-// GetValidator mocks base method.
-func (m *MockBeaconChainClient) GetValidator(arg0 context.Context, arg1 *eth.GetValidatorRequest) (*eth.Validator, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetValidator", arg0, arg1)
-	ret0, _ := ret[0].(*eth.Validator)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetValidator indicates an expected call of GetValidator.
-func (mr *MockBeaconChainClientMockRecorder) GetValidator(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidator", reflect.TypeOf((*MockBeaconChainClient)(nil).GetValidator), arg0, arg1)
-}
-
-// GetValidatorActiveSetChanges mocks base method.
-func (m *MockBeaconChainClient) GetValidatorActiveSetChanges(arg0 context.Context, arg1 *eth.GetValidatorActiveSetChangesRequest) (*eth.ActiveSetChanges, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetValidatorActiveSetChanges", arg0, arg1)
-	ret0, _ := ret[0].(*eth.ActiveSetChanges)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetValidatorActiveSetChanges indicates an expected call of GetValidatorActiveSetChanges.
-func (mr *MockBeaconChainClientMockRecorder) GetValidatorActiveSetChanges(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorActiveSetChanges", reflect.TypeOf((*MockBeaconChainClient)(nil).GetValidatorActiveSetChanges), arg0, arg1)
-}
-
 // GetValidatorParticipation mocks base method.
 func (m *MockBeaconChainClient) GetValidatorParticipation(arg0 context.Context, arg1 *eth.GetValidatorParticipationRequest) (*eth.ValidatorParticipationResponse, error) {
 	m.ctrl.T.Helper()
@@ -171,81 +96,6 @@ func (mr *MockBeaconChainClientMockRecorder) GetValidatorQueue(arg0, arg1 interf
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorQueue", reflect.TypeOf((*MockBeaconChainClient)(nil).GetValidatorQueue), arg0, arg1)
 }
 
-// ListAttestations mocks base method.
-func (m *MockBeaconChainClient) ListAttestations(arg0 context.Context, arg1 *eth.ListAttestationsRequest) (*eth.ListAttestationsResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListAttestations", arg0, arg1)
-	ret0, _ := ret[0].(*eth.ListAttestationsResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListAttestations indicates an expected call of ListAttestations.
-func (mr *MockBeaconChainClientMockRecorder) ListAttestations(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttestations", reflect.TypeOf((*MockBeaconChainClient)(nil).ListAttestations), arg0, arg1)
-}
-
-// ListBeaconBlocks mocks base method.
-func (m *MockBeaconChainClient) ListBeaconBlocks(arg0 context.Context, arg1 *eth.ListBlocksRequest) (*eth.ListBeaconBlocksResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListBeaconBlocks", arg0, arg1)
-	ret0, _ := ret[0].(*eth.ListBeaconBlocksResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListBeaconBlocks indicates an expected call of ListBeaconBlocks.
-func (mr *MockBeaconChainClientMockRecorder) ListBeaconBlocks(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBeaconBlocks", reflect.TypeOf((*MockBeaconChainClient)(nil).ListBeaconBlocks), arg0, arg1)
-}
-
-// ListBeaconCommittees mocks base method.
-func (m *MockBeaconChainClient) ListBeaconCommittees(arg0 context.Context, arg1 *eth.ListCommitteesRequest) (*eth.BeaconCommittees, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListBeaconCommittees", arg0, arg1)
-	ret0, _ := ret[0].(*eth.BeaconCommittees)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListBeaconCommittees indicates an expected call of ListBeaconCommittees.
-func (mr *MockBeaconChainClientMockRecorder) ListBeaconCommittees(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBeaconCommittees", reflect.TypeOf((*MockBeaconChainClient)(nil).ListBeaconCommittees), arg0, arg1)
-}
-
-// ListIndexedAttestations mocks base method.
-func (m *MockBeaconChainClient) ListIndexedAttestations(arg0 context.Context, arg1 *eth.ListIndexedAttestationsRequest) (*eth.ListIndexedAttestationsResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListIndexedAttestations", arg0, arg1)
-	ret0, _ := ret[0].(*eth.ListIndexedAttestationsResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListIndexedAttestations indicates an expected call of ListIndexedAttestations.
-func (mr *MockBeaconChainClientMockRecorder) ListIndexedAttestations(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIndexedAttestations", reflect.TypeOf((*MockBeaconChainClient)(nil).ListIndexedAttestations), arg0, arg1)
-}
-
-// ListValidatorAssignments mocks base method.
-func (m *MockBeaconChainClient) ListValidatorAssignments(arg0 context.Context, arg1 *eth.ListValidatorAssignmentsRequest) (*eth.ValidatorAssignments, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListValidatorAssignments", arg0, arg1)
-	ret0, _ := ret[0].(*eth.ValidatorAssignments)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListValidatorAssignments indicates an expected call of ListValidatorAssignments.
-func (mr *MockBeaconChainClientMockRecorder) ListValidatorAssignments(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListValidatorAssignments", reflect.TypeOf((*MockBeaconChainClient)(nil).ListValidatorAssignments), arg0, arg1)
-}
-
 // ListValidatorBalances mocks base method.
 func (m *MockBeaconChainClient) ListValidatorBalances(arg0 context.Context, arg1 *eth.ListValidatorBalancesRequest) (*eth.ValidatorBalances, error) {
 	m.ctrl.T.Helper()
@@ -275,108 +125,3 @@ func (mr *MockBeaconChainClientMockRecorder) ListValidators(arg0, arg1 interface
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListValidators", reflect.TypeOf((*MockBeaconChainClient)(nil).ListValidators), arg0, arg1)
 }
-
-// StreamAttestations mocks base method.
-func (m *MockBeaconChainClient) StreamAttestations(arg0 context.Context, arg1 *emptypb.Empty) (eth.BeaconChain_StreamAttestationsClient, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StreamAttestations", arg0, arg1)
-	ret0, _ := ret[0].(eth.BeaconChain_StreamAttestationsClient)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StreamAttestations indicates an expected call of StreamAttestations.
-func (mr *MockBeaconChainClientMockRecorder) StreamAttestations(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamAttestations", reflect.TypeOf((*MockBeaconChainClient)(nil).StreamAttestations), arg0, arg1)
-}
-
-// StreamBlocks mocks base method.
-func (m *MockBeaconChainClient) StreamBlocks(arg0 context.Context, arg1 *eth.StreamBlocksRequest) (eth.BeaconChain_StreamBlocksClient, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StreamBlocks", arg0, arg1)
-	ret0, _ := ret[0].(eth.BeaconChain_StreamBlocksClient)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StreamBlocks indicates an expected call of StreamBlocks.
-func (mr *MockBeaconChainClientMockRecorder) StreamBlocks(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamBlocks", reflect.TypeOf((*MockBeaconChainClient)(nil).StreamBlocks), arg0, arg1)
-}
-
-// StreamChainHead mocks base method.
-func (m *MockBeaconChainClient) StreamChainHead(arg0 context.Context, arg1 *emptypb.Empty) (eth.BeaconChain_StreamChainHeadClient, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StreamChainHead", arg0, arg1)
-	ret0, _ := ret[0].(eth.BeaconChain_StreamChainHeadClient)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StreamChainHead indicates an expected call of StreamChainHead.
-func (mr *MockBeaconChainClientMockRecorder) StreamChainHead(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamChainHead", reflect.TypeOf((*MockBeaconChainClient)(nil).StreamChainHead), arg0, arg1)
-}
-
-// StreamIndexedAttestations mocks base method.
-func (m *MockBeaconChainClient) StreamIndexedAttestations(arg0 context.Context, arg1 *emptypb.Empty) (eth.BeaconChain_StreamIndexedAttestationsClient, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StreamIndexedAttestations", arg0, arg1)
-	ret0, _ := ret[0].(eth.BeaconChain_StreamIndexedAttestationsClient)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StreamIndexedAttestations indicates an expected call of StreamIndexedAttestations.
-func (mr *MockBeaconChainClientMockRecorder) StreamIndexedAttestations(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamIndexedAttestations", reflect.TypeOf((*MockBeaconChainClient)(nil).StreamIndexedAttestations), arg0, arg1)
-}
-
-// StreamValidatorsInfo mocks base method.
-func (m *MockBeaconChainClient) StreamValidatorsInfo(arg0 context.Context) (eth.BeaconChain_StreamValidatorsInfoClient, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StreamValidatorsInfo", arg0)
-	ret0, _ := ret[0].(eth.BeaconChain_StreamValidatorsInfoClient)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StreamValidatorsInfo indicates an expected call of StreamValidatorsInfo.
-func (mr *MockBeaconChainClientMockRecorder) StreamValidatorsInfo(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamValidatorsInfo", reflect.TypeOf((*MockBeaconChainClient)(nil).StreamValidatorsInfo), arg0)
-}
-
-// SubmitAttesterSlashing mocks base method.
-func (m *MockBeaconChainClient) SubmitAttesterSlashing(arg0 context.Context, arg1 *eth.AttesterSlashing) (*eth.SubmitSlashingResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubmitAttesterSlashing", arg0, arg1)
-	ret0, _ := ret[0].(*eth.SubmitSlashingResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SubmitAttesterSlashing indicates an expected call of SubmitAttesterSlashing.
-func (mr *MockBeaconChainClientMockRecorder) SubmitAttesterSlashing(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitAttesterSlashing", reflect.TypeOf((*MockBeaconChainClient)(nil).SubmitAttesterSlashing), arg0, arg1)
-}
-
-// SubmitProposerSlashing mocks base method.
-func (m *MockBeaconChainClient) SubmitProposerSlashing(arg0 context.Context, arg1 *eth.ProposerSlashing) (*eth.SubmitSlashingResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubmitProposerSlashing", arg0, arg1)
-	ret0, _ := ret[0].(*eth.SubmitSlashingResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SubmitProposerSlashing indicates an expected call of SubmitProposerSlashing.
-func (mr *MockBeaconChainClientMockRecorder) SubmitProposerSlashing(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitProposerSlashing", reflect.TypeOf((*MockBeaconChainClient)(nil).SubmitProposerSlashing), arg0, arg1)
-}

testing/validator-mock/node_client_mock.go

@@ -36,21 +36,6 @@ func (m *MockNodeClient) EXPECT() *MockNodeClientMockRecorder {
 	return m.recorder
 }
 
-// GetETH1ConnectionStatus mocks base method.
-func (m *MockNodeClient) GetETH1ConnectionStatus(arg0 context.Context, arg1 *emptypb.Empty) (*eth.ETH1ConnectionStatus, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetETH1ConnectionStatus", arg0, arg1)
-	ret0, _ := ret[0].(*eth.ETH1ConnectionStatus)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetETH1ConnectionStatus indicates an expected call of GetETH1ConnectionStatus.
-func (mr *MockNodeClientMockRecorder) GetETH1ConnectionStatus(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetETH1ConnectionStatus", reflect.TypeOf((*MockNodeClient)(nil).GetETH1ConnectionStatus), arg0, arg1)
-}
-
 // GetGenesis mocks base method.
 func (m *MockNodeClient) GetGenesis(arg0 context.Context, arg1 *emptypb.Empty) (*eth.Genesis, error) {
 	m.ctrl.T.Helper()
@@ -66,36 +51,6 @@ func (mr *MockNodeClientMockRecorder) GetGenesis(arg0, arg1 interface{}) *gomock
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGenesis", reflect.TypeOf((*MockNodeClient)(nil).GetGenesis), arg0, arg1)
 }
 
-// GetHost mocks base method.
-func (m *MockNodeClient) GetHost(arg0 context.Context, arg1 *emptypb.Empty) (*eth.HostData, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetHost", arg0, arg1)
-	ret0, _ := ret[0].(*eth.HostData)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetHost indicates an expected call of GetHost.
-func (mr *MockNodeClientMockRecorder) GetHost(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHost", reflect.TypeOf((*MockNodeClient)(nil).GetHost), arg0, arg1)
-}
-
-// GetPeer mocks base method.
-func (m *MockNodeClient) GetPeer(arg0 context.Context, arg1 *eth.PeerRequest) (*eth.Peer, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPeer", arg0, arg1)
-	ret0, _ := ret[0].(*eth.Peer)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetPeer indicates an expected call of GetPeer.
-func (mr *MockNodeClientMockRecorder) GetPeer(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeer", reflect.TypeOf((*MockNodeClient)(nil).GetPeer), arg0, arg1)
-}
-
 // GetSyncStatus mocks base method.
 func (m *MockNodeClient) GetSyncStatus(arg0 context.Context, arg1 *emptypb.Empty) (*eth.SyncStatus, error) {
 	m.ctrl.T.Helper()
@@ -126,21 +81,6 @@ func (mr *MockNodeClientMockRecorder) GetVersion(arg0, arg1 interface{}) *gomock
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*MockNodeClient)(nil).GetVersion), arg0, arg1)
 }
 
-// ListImplementedServices mocks base method.
-func (m *MockNodeClient) ListImplementedServices(arg0 context.Context, arg1 *emptypb.Empty) (*eth.ImplementedServices, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListImplementedServices", arg0, arg1)
-	ret0, _ := ret[0].(*eth.ImplementedServices)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListImplementedServices indicates an expected call of ListImplementedServices.
-func (mr *MockNodeClientMockRecorder) ListImplementedServices(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImplementedServices", reflect.TypeOf((*MockNodeClient)(nil).ListImplementedServices), arg0, arg1)
-}
-
 // ListPeers mocks base method.
 func (m *MockNodeClient) ListPeers(arg0 context.Context, arg1 *emptypb.Empty) (*eth.Peers, error) {
 	m.ctrl.T.Helper()

testing/validator-mock/slasher_client_mock.go

@@ -35,21 +35,6 @@ func (m *MockSlasherClient) EXPECT() *MockSlasherClientMockRecorder {
 	return m.recorder
 }
 
-// HighestAttestations mocks base method.
-func (m *MockSlasherClient) HighestAttestations(arg0 context.Context, arg1 *eth.HighestAttestationRequest) (*eth.HighestAttestationResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HighestAttestations", arg0, arg1)
-	ret0, _ := ret[0].(*eth.HighestAttestationResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// HighestAttestations indicates an expected call of HighestAttestations.
-func (mr *MockSlasherClientMockRecorder) HighestAttestations(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HighestAttestations", reflect.TypeOf((*MockSlasherClient)(nil).HighestAttestations), arg0, arg1)
-}
-
 // IsSlashableAttestation mocks base method.
 func (m *MockSlasherClient) IsSlashableAttestation(arg0 context.Context, arg1 *eth.IndexedAttestation) (*eth.AttesterSlashingResponse, error) {
 	m.ctrl.T.Helper()

validator/client/beacon-api/beacon_api_beacon_chain_client.go

@@ -15,82 +15,6 @@ type beaconApiBeaconChainClient struct {
 	jsonRestHandler jsonRestHandler
 }
 
-func (c beaconApiBeaconChainClient) ListAttestations(ctx context.Context, in *ethpb.ListAttestationsRequest) (*ethpb.ListAttestationsResponse, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.ListAttestations(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.ListAttestations is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-func (c beaconApiBeaconChainClient) ListIndexedAttestations(ctx context.Context, in *ethpb.ListIndexedAttestationsRequest) (*ethpb.ListIndexedAttestationsResponse, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.ListIndexedAttestations(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.ListIndexedAttestations is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-// Deprecated: Do not use.
-func (c beaconApiBeaconChainClient) StreamAttestations(ctx context.Context, in *empty.Empty) (ethpb.BeaconChain_StreamAttestationsClient, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.StreamAttestations(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.StreamAttestations is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-// Deprecated: Do not use.
-func (c beaconApiBeaconChainClient) StreamIndexedAttestations(ctx context.Context, in *empty.Empty) (ethpb.BeaconChain_StreamIndexedAttestationsClient, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.StreamIndexedAttestations(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.StreamIndexedAttestations is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-func (c beaconApiBeaconChainClient) AttestationPool(ctx context.Context, in *ethpb.AttestationPoolRequest) (*ethpb.AttestationPoolResponse, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.AttestationPool(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.AttestationPool is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-func (c beaconApiBeaconChainClient) ListBeaconBlocks(ctx context.Context, in *ethpb.ListBlocksRequest) (*ethpb.ListBeaconBlocksResponse, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.ListBeaconBlocks(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.ListBeaconBlocks is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-// Deprecated: Do not use.
-func (c beaconApiBeaconChainClient) StreamBlocks(ctx context.Context, in *ethpb.StreamBlocksRequest) (ethpb.BeaconChain_StreamBlocksClient, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.StreamBlocks(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.StreamBlocks is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-// Deprecated: Do not use.
-func (c beaconApiBeaconChainClient) StreamChainHead(ctx context.Context, in *empty.Empty) (ethpb.BeaconChain_StreamChainHeadClient, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.StreamChainHead(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.StreamChainHead is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
 func (c beaconApiBeaconChainClient) GetChainHead(ctx context.Context, in *empty.Empty) (*ethpb.ChainHead, error) {
 	if c.fallbackClient != nil {
 		return c.fallbackClient.GetChainHead(ctx, in)
@@ -100,15 +24,6 @@ func (c beaconApiBeaconChainClient) GetChainHead(ctx context.Context, in *empty.
 	panic("beaconApiBeaconChainClient.GetChainHead is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
 }
 
-func (c beaconApiBeaconChainClient) ListBeaconCommittees(ctx context.Context, in *ethpb.ListCommitteesRequest) (*ethpb.BeaconCommittees, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.ListBeaconCommittees(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.ListBeaconCommittees is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
 func (c beaconApiBeaconChainClient) ListValidatorBalances(ctx context.Context, in *ethpb.ListValidatorBalancesRequest) (*ethpb.ValidatorBalances, error) {
 	if c.fallbackClient != nil {
 		return c.fallbackClient.ListValidatorBalances(ctx, in)
@@ -127,24 +42,6 @@ func (c beaconApiBeaconChainClient) ListValidators(ctx context.Context, in *ethp
 	panic("beaconApiBeaconChainClient.ListValidators is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
 }
 
-func (c beaconApiBeaconChainClient) GetValidator(ctx context.Context, in *ethpb.GetValidatorRequest) (*ethpb.Validator, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.GetValidator(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.GetValidator is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-func (c beaconApiBeaconChainClient) GetValidatorActiveSetChanges(ctx context.Context, in *ethpb.GetValidatorActiveSetChangesRequest) (*ethpb.ActiveSetChanges, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.GetValidatorActiveSetChanges(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.GetValidatorActiveSetChanges is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
 func (c beaconApiBeaconChainClient) GetValidatorQueue(ctx context.Context, in *empty.Empty) (*ethpb.ValidatorQueue, error) {
 	if c.fallbackClient != nil {
 		return c.fallbackClient.GetValidatorQueue(ctx, in)
@@ -163,15 +60,6 @@ func (c beaconApiBeaconChainClient) GetValidatorPerformance(ctx context.Context,
 	panic("beaconApiBeaconChainClient.GetValidatorPerformance is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
 }
 
-func (c beaconApiBeaconChainClient) ListValidatorAssignments(ctx context.Context, in *ethpb.ListValidatorAssignmentsRequest) (*ethpb.ValidatorAssignments, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.ListValidatorAssignments(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.ListValidatorAssignments is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
 func (c beaconApiBeaconChainClient) GetValidatorParticipation(ctx context.Context, in *ethpb.GetValidatorParticipationRequest) (*ethpb.ValidatorParticipationResponse, error) {
 	if c.fallbackClient != nil {
 		return c.fallbackClient.GetValidatorParticipation(ctx, in)
@@ -181,52 +69,6 @@ func (c beaconApiBeaconChainClient) GetValidatorParticipation(ctx context.Contex
 	panic("beaconApiBeaconChainClient.GetValidatorParticipation is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
 }
 
-func (c beaconApiBeaconChainClient) GetBeaconConfig(ctx context.Context, in *empty.Empty) (*ethpb.BeaconConfig, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.GetBeaconConfig(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.GetBeaconConfig is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-// Deprecated: Do not use.
-func (c beaconApiBeaconChainClient) StreamValidatorsInfo(ctx context.Context) (ethpb.BeaconChain_StreamValidatorsInfoClient, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.StreamValidatorsInfo(ctx)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.StreamValidatorsInfo is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-func (c beaconApiBeaconChainClient) SubmitAttesterSlashing(ctx context.Context, in *ethpb.AttesterSlashing) (*ethpb.SubmitSlashingResponse, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.SubmitAttesterSlashing(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.SubmitAttesterSlashing is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-func (c beaconApiBeaconChainClient) SubmitProposerSlashing(ctx context.Context, in *ethpb.ProposerSlashing) (*ethpb.SubmitSlashingResponse, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.SubmitProposerSlashing(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.SubmitProposerSlashing is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
-func (c beaconApiBeaconChainClient) GetIndividualVotes(ctx context.Context, in *ethpb.IndividualVotesRequest) (*ethpb.IndividualVotesRespond, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.GetIndividualVotes(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiBeaconChainClient.GetIndividualVotes is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
-}
-
 func NewBeaconApiBeaconChainClientWithFallback(host string, timeout time.Duration, fallbackClient iface.BeaconChainClient) iface.BeaconChainClient {
 	jsonRestHandler := beaconApiJsonRestHandler{
 		httpClient: http.Client{Timeout: timeout},

validator/client/beacon-api/beacon_api_node_client.go

@@ -42,33 +42,6 @@ func (c *beaconApiNodeClient) GetVersion(ctx context.Context, in *empty.Empty) (
 	panic("beaconApiNodeClient.GetVersion is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiNodeClientWithFallback.")
 }
 
-func (c *beaconApiNodeClient) ListImplementedServices(ctx context.Context, in *empty.Empty) (*ethpb.ImplementedServices, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.ListImplementedServices(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiNodeClient.ListImplementedServices is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiNodeClientWithFallback.")
-}
-
-func (c *beaconApiNodeClient) GetHost(ctx context.Context, in *empty.Empty) (*ethpb.HostData, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.GetHost(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiNodeClient.GetHost is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiNodeClientWithFallback.")
-}
-
-func (c *beaconApiNodeClient) GetPeer(ctx context.Context, in *ethpb.PeerRequest) (*ethpb.Peer, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.GetPeer(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiNodeClient.GetPeer is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiNodeClientWithFallback.")
-}
-
 func (c *beaconApiNodeClient) ListPeers(ctx context.Context, in *empty.Empty) (*ethpb.Peers, error) {
 	if c.fallbackClient != nil {
 		return c.fallbackClient.ListPeers(ctx, in)
@@ -78,15 +51,6 @@ func (c *beaconApiNodeClient) ListPeers(ctx context.Context, in *empty.Empty) (*
 	panic("beaconApiNodeClient.ListPeers is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiNodeClientWithFallback.")
 }
 
-func (c *beaconApiNodeClient) GetETH1ConnectionStatus(ctx context.Context, in *empty.Empty) (*ethpb.ETH1ConnectionStatus, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.GetETH1ConnectionStatus(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiNodeClient.GetETH1ConnectionStatus is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiNodeClientWithFallback.")
-}
-
 func NewNodeClientWithFallback(host string, timeout time.Duration, fallbackClient iface.NodeClient) iface.NodeClient {
 	jsonRestHandler := beaconApiJsonRestHandler{
 		httpClient: http.Client{Timeout: timeout},

validator/client/beacon-api/beacon_api_slasher_client.go

@@ -32,16 +32,6 @@ func (c beaconApiSlasherClient) IsSlashableBlock(ctx context.Context, in *ethpb.
 	panic("beaconApiSlasherClient.IsSlashableBlock is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiSlasherClientWithFallback.")
 }
 
-// Deprecated: Do not use.
-func (c beaconApiSlasherClient) HighestAttestations(ctx context.Context, in *ethpb.HighestAttestationRequest) (*ethpb.HighestAttestationResponse, error) {
-	if c.fallbackClient != nil {
-		return c.fallbackClient.HighestAttestations(ctx, in)
-	}
-
-	// TODO: Implement me
-	panic("beaconApiSlasherClient.HighestAttestations is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiSlasherClientWithFallback.")
-}
-
 func NewSlasherClientWithFallback(host string, timeout time.Duration, fallbackClient iface.SlasherClient) iface.SlasherClient {
 	jsonRestHandler := beaconApiJsonRestHandler{
 		httpClient: http.Client{Timeout: timeout},

validator/client/grpc-api/grpc_beacon_chain_client.go

@@ -13,50 +13,10 @@ type grpcBeaconChainClient struct {
 	beaconChainClient ethpb.BeaconChainClient
 }
 
-func (c *grpcBeaconChainClient) ListAttestations(ctx context.Context, in *ethpb.ListAttestationsRequest) (*ethpb.ListAttestationsResponse, error) {
-	return c.beaconChainClient.ListAttestations(ctx, in)
-}
-
-func (c *grpcBeaconChainClient) ListIndexedAttestations(ctx context.Context, in *ethpb.ListIndexedAttestationsRequest) (*ethpb.ListIndexedAttestationsResponse, error) {
-	return c.beaconChainClient.ListIndexedAttestations(ctx, in)
-}
-
-// Deprecated: Do not use.
-func (c *grpcBeaconChainClient) StreamAttestations(ctx context.Context, in *empty.Empty) (ethpb.BeaconChain_StreamAttestationsClient, error) {
-	return c.beaconChainClient.StreamAttestations(ctx, in)
-}
-
-// Deprecated: Do not use.
-func (c *grpcBeaconChainClient) StreamIndexedAttestations(ctx context.Context, in *empty.Empty) (ethpb.BeaconChain_StreamIndexedAttestationsClient, error) {
-	return c.beaconChainClient.StreamIndexedAttestations(ctx, in)
-}
-
-func (c *grpcBeaconChainClient) AttestationPool(ctx context.Context, in *ethpb.AttestationPoolRequest) (*ethpb.AttestationPoolResponse, error) {
-	return c.beaconChainClient.AttestationPool(ctx, in)
-}
-
-func (c *grpcBeaconChainClient) ListBeaconBlocks(ctx context.Context, in *ethpb.ListBlocksRequest) (*ethpb.ListBeaconBlocksResponse, error) {
-	return c.beaconChainClient.ListBeaconBlocks(ctx, in)
-}
-
-// Deprecated: Do not use.
-func (c *grpcBeaconChainClient) StreamBlocks(ctx context.Context, in *ethpb.StreamBlocksRequest) (ethpb.BeaconChain_StreamBlocksClient, error) {
-	return c.beaconChainClient.StreamBlocks(ctx, in)
-}
-
-// Deprecated: Do not use.
-func (c *grpcBeaconChainClient) StreamChainHead(ctx context.Context, in *empty.Empty) (ethpb.BeaconChain_StreamChainHeadClient, error) {
-	return c.beaconChainClient.StreamChainHead(ctx, in)
-}
-
 func (c *grpcBeaconChainClient) GetChainHead(ctx context.Context, in *empty.Empty) (*ethpb.ChainHead, error) {
 	return c.beaconChainClient.GetChainHead(ctx, in)
 }
 
-func (c *grpcBeaconChainClient) ListBeaconCommittees(ctx context.Context, in *ethpb.ListCommitteesRequest) (*ethpb.BeaconCommittees, error) {
-	return c.beaconChainClient.ListBeaconCommittees(ctx, in)
-}
-
 func (c *grpcBeaconChainClient) ListValidatorBalances(ctx context.Context, in *ethpb.ListValidatorBalancesRequest) (*ethpb.ValidatorBalances, error) {
 	return c.beaconChainClient.ListValidatorBalances(ctx, in)
 }
@@ -65,14 +25,6 @@ func (c *grpcBeaconChainClient) ListValidators(ctx context.Context, in *ethpb.Li
 	return c.beaconChainClient.ListValidators(ctx, in)
 }
 
-func (c *grpcBeaconChainClient) GetValidator(ctx context.Context, in *ethpb.GetValidatorRequest) (*ethpb.Validator, error) {
-	return c.beaconChainClient.GetValidator(ctx, in)
-}
-
-func (c *grpcBeaconChainClient) GetValidatorActiveSetChanges(ctx context.Context, in *ethpb.GetValidatorActiveSetChangesRequest) (*ethpb.ActiveSetChanges, error) {
-	return c.beaconChainClient.GetValidatorActiveSetChanges(ctx, in)
-}
-
 func (c *grpcBeaconChainClient) GetValidatorQueue(ctx context.Context, in *empty.Empty) (*ethpb.ValidatorQueue, error) {
 	return c.beaconChainClient.GetValidatorQueue(ctx, in)
 }
@@ -81,35 +33,10 @@ func (c *grpcBeaconChainClient) GetValidatorPerformance(ctx context.Context, in
 	return c.beaconChainClient.GetValidatorPerformance(ctx, in)
 }
 
-func (c *grpcBeaconChainClient) ListValidatorAssignments(ctx context.Context, in *ethpb.ListValidatorAssignmentsRequest) (*ethpb.ValidatorAssignments, error) {
-	return c.beaconChainClient.ListValidatorAssignments(ctx, in)
-}
-
 func (c *grpcBeaconChainClient) GetValidatorParticipation(ctx context.Context, in *ethpb.GetValidatorParticipationRequest) (*ethpb.ValidatorParticipationResponse, error) {
 	return c.beaconChainClient.GetValidatorParticipation(ctx, in)
 }
 
-func (c *grpcBeaconChainClient) GetBeaconConfig(ctx context.Context, in *empty.Empty) (*ethpb.BeaconConfig, error) {
-	return c.beaconChainClient.GetBeaconConfig(ctx, in)
-}
-
-// Deprecated: Do not use.
-func (c *grpcBeaconChainClient) StreamValidatorsInfo(ctx context.Context) (ethpb.BeaconChain_StreamValidatorsInfoClient, error) {
-	return c.beaconChainClient.StreamValidatorsInfo(ctx)
-}
-
-func (c *grpcBeaconChainClient) SubmitAttesterSlashing(ctx context.Context, in *ethpb.AttesterSlashing) (*ethpb.SubmitSlashingResponse, error) {
-	return c.beaconChainClient.SubmitAttesterSlashing(ctx, in)
-}
-
-func (c *grpcBeaconChainClient) SubmitProposerSlashing(ctx context.Context, in *ethpb.ProposerSlashing) (*ethpb.SubmitSlashingResponse, error) {
-	return c.beaconChainClient.SubmitProposerSlashing(ctx, in)
-}
-
-func (c *grpcBeaconChainClient) GetIndividualVotes(ctx context.Context, in *ethpb.IndividualVotesRequest) (*ethpb.IndividualVotesRespond, error) {
-	return c.beaconChainClient.GetIndividualVotes(ctx, in)
-}
-
 func NewGrpcBeaconChainClient(cc grpc.ClientConnInterface) iface.BeaconChainClient {
 	return &grpcBeaconChainClient{ethpb.NewBeaconChainClient(cc)}
 }

validator/client/grpc-api/grpc_node_client.go

@@ -25,26 +25,10 @@ func (c *grpcNodeClient) GetVersion(ctx context.Context, in *empty.Empty) (*ethp
 	return c.nodeClient.GetVersion(ctx, in)
 }
 
-func (c *grpcNodeClient) ListImplementedServices(ctx context.Context, in *empty.Empty) (*ethpb.ImplementedServices, error) {
-	return c.nodeClient.ListImplementedServices(ctx, in)
-}
-
-func (c *grpcNodeClient) GetHost(ctx context.Context, in *empty.Empty) (*ethpb.HostData, error) {
-	return c.nodeClient.GetHost(ctx, in)
-}
-
-func (c *grpcNodeClient) GetPeer(ctx context.Context, in *ethpb.PeerRequest) (*ethpb.Peer, error) {
-	return c.nodeClient.GetPeer(ctx, in)
-}
-
 func (c *grpcNodeClient) ListPeers(ctx context.Context, in *empty.Empty) (*ethpb.Peers, error) {
 	return c.nodeClient.ListPeers(ctx, in)
 }
 
-func (c *grpcNodeClient) GetETH1ConnectionStatus(ctx context.Context, in *empty.Empty) (*ethpb.ETH1ConnectionStatus, error) {
-	return c.nodeClient.GetETH1ConnectionStatus(ctx, in)
-}
-
 func NewNodeClient(cc grpc.ClientConnInterface) iface.NodeClient {
 	return &grpcNodeClient{ethpb.NewNodeClient(cc)}
 }

validator/client/grpc-api/grpc_slasher_client.go

@@ -20,10 +20,6 @@ func (c *grpcSlasherClient) IsSlashableBlock(ctx context.Context, in *ethpb.Sign
 	return c.slasherClient.IsSlashableBlock(ctx, in)
 }
 
-func (c *grpcSlasherClient) HighestAttestations(ctx context.Context, in *ethpb.HighestAttestationRequest) (*ethpb.HighestAttestationResponse, error) {
-	return c.slasherClient.HighestAttestations(ctx, in)
-}
-
 func NewSlasherClient(cc grpc.ClientConnInterface) iface.SlasherClient {
 	return &grpcSlasherClient{ethpb.NewSlasherClient(cc)}
 }

validator/client/iface/beacon_chain_client.go

@@ -8,32 +8,10 @@ import (
 )
 
 type BeaconChainClient interface {
-	ListAttestations(ctx context.Context, in *ethpb.ListAttestationsRequest) (*ethpb.ListAttestationsResponse, error)
-	ListIndexedAttestations(ctx context.Context, in *ethpb.ListIndexedAttestationsRequest) (*ethpb.ListIndexedAttestationsResponse, error)
-	// Deprecated: Do not use.
-	StreamAttestations(ctx context.Context, in *empty.Empty) (ethpb.BeaconChain_StreamAttestationsClient, error)
-	// Deprecated: Do not use.
-	StreamIndexedAttestations(ctx context.Context, in *empty.Empty) (ethpb.BeaconChain_StreamIndexedAttestationsClient, error)
-	AttestationPool(ctx context.Context, in *ethpb.AttestationPoolRequest) (*ethpb.AttestationPoolResponse, error)
-	ListBeaconBlocks(ctx context.Context, in *ethpb.ListBlocksRequest) (*ethpb.ListBeaconBlocksResponse, error)
-	// Deprecated: Do not use.
-	StreamBlocks(ctx context.Context, in *ethpb.StreamBlocksRequest) (ethpb.BeaconChain_StreamBlocksClient, error)
-	// Deprecated: Do not use.
-	StreamChainHead(ctx context.Context, in *empty.Empty) (ethpb.BeaconChain_StreamChainHeadClient, error)
 	GetChainHead(ctx context.Context, in *empty.Empty) (*ethpb.ChainHead, error)
-	ListBeaconCommittees(ctx context.Context, in *ethpb.ListCommitteesRequest) (*ethpb.BeaconCommittees, error)
 	ListValidatorBalances(ctx context.Context, in *ethpb.ListValidatorBalancesRequest) (*ethpb.ValidatorBalances, error)
 	ListValidators(ctx context.Context, in *ethpb.ListValidatorsRequest) (*ethpb.Validators, error)
-	GetValidator(ctx context.Context, in *ethpb.GetValidatorRequest) (*ethpb.Validator, error)
-	GetValidatorActiveSetChanges(ctx context.Context, in *ethpb.GetValidatorActiveSetChangesRequest) (*ethpb.ActiveSetChanges, error)
 	GetValidatorQueue(ctx context.Context, in *empty.Empty) (*ethpb.ValidatorQueue, error)
 	GetValidatorPerformance(ctx context.Context, in *ethpb.ValidatorPerformanceRequest) (*ethpb.ValidatorPerformanceResponse, error)
-	ListValidatorAssignments(ctx context.Context, in *ethpb.ListValidatorAssignmentsRequest) (*ethpb.ValidatorAssignments, error)
 	GetValidatorParticipation(ctx context.Context, in *ethpb.GetValidatorParticipationRequest) (*ethpb.ValidatorParticipationResponse, error)
-	GetBeaconConfig(ctx context.Context, in *empty.Empty) (*ethpb.BeaconConfig, error)
-	// Deprecated: Do not use.
-	StreamValidatorsInfo(ctx context.Context) (ethpb.BeaconChain_StreamValidatorsInfoClient, error)
-	SubmitAttesterSlashing(ctx context.Context, in *ethpb.AttesterSlashing) (*ethpb.SubmitSlashingResponse, error)
-	SubmitProposerSlashing(ctx context.Context, in *ethpb.ProposerSlashing) (*ethpb.SubmitSlashingResponse, error)
-	GetIndividualVotes(ctx context.Context, in *ethpb.IndividualVotesRequest) (*ethpb.IndividualVotesRespond, error)
 }

validator/client/iface/node_client.go

@@ -11,9 +11,5 @@ type NodeClient interface {
 	GetSyncStatus(ctx context.Context, in *empty.Empty) (*ethpb.SyncStatus, error)
 	GetGenesis(ctx context.Context, in *empty.Empty) (*ethpb.Genesis, error)
 	GetVersion(ctx context.Context, in *empty.Empty) (*ethpb.Version, error)
-	ListImplementedServices(ctx context.Context, in *empty.Empty) (*ethpb.ImplementedServices, error)
-	GetHost(ctx context.Context, in *empty.Empty) (*ethpb.HostData, error)
-	GetPeer(ctx context.Context, in *ethpb.PeerRequest) (*ethpb.Peer, error)
 	ListPeers(ctx context.Context, in *empty.Empty) (*ethpb.Peers, error)
-	GetETH1ConnectionStatus(ctx context.Context, in *empty.Empty) (*ethpb.ETH1ConnectionStatus, error)
 }

validator/client/iface/slasher_client.go

@@ -9,5 +9,4 @@ import (
 type SlasherClient interface {
 	IsSlashableAttestation(ctx context.Context, in *ethpb.IndexedAttestation) (*ethpb.AttesterSlashingResponse, error)
 	IsSlashableBlock(ctx context.Context, in *ethpb.SignedBeaconBlockHeader) (*ethpb.ProposerSlashingResponse, error)
-	HighestAttestations(ctx context.Context, in *ethpb.HighestAttestationRequest) (*ethpb.HighestAttestationResponse, error)
 }