Fix Bad Merge in V4 (#12183)

* add tracer

* gaz

* preston's review

* preston's review

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/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/rpc/eth/debug/debug.go

@@ -166,7 +166,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/validator/server.go

@@ -16,7 +16,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

@@ -49,14 +49,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 {

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

@@ -117,8 +117,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
 		require.NoError(t, vs.setExecutionData(context.Background(), blk, capellaTransitionState))
@@ -171,7 +171,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
 		require.NoError(t, 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:
@@ -98,7 +96,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"
@@ -694,7 +693,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
@@ -735,7 +733,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")
 	}

proto/prysm/v1alpha1/BUILD.bazel

@@ -212,7 +212,6 @@ ssz_proto_files(
         "attestation.proto",
         "beacon_block.proto",
         "beacon_state.proto",
-        "blobs.proto",
         "sync_committee.proto",
         "withdrawals.proto",
     ],

proto/prysm/v1alpha1/beacon_block.proto

@@ -18,7 +18,6 @@ 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/engine/v1/execution_engine.proto";
 
 option csharp_namespace = "Ethereum.Eth.v1alpha1";
@@ -437,15 +436,6 @@ message BlindedBeaconBlockBodyBellatrix {
     ethereum.engine.v1.ExecutionPayloadHeader execution_payload_header = 10;
 }
 
-// This contains beacon block and the blob sidecar objects under single container.
-// It is to be gossip'ed over p2p to peers to validate and process.
-message SignedBeaconBlockAndBlobsSidecar {
-    // The block of the beacon chain.
-    SignedBeaconBlockCapella beacon_block = 1;
-    // The blob sidecar which corresponds to the block itself.
-    BlobsSidecar blobs_sidecar = 2;
-}
-
 message SignedBeaconBlockCapella {
     // The unsigned beacon block itself.
     BeaconBlockCapella block = 1;

proto/prysm/v1alpha1/blobs.pb.go

@@ -1,203 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.28.1
-// 	protoc        v3.15.8
-// source: proto/prysm/v1alpha1/blobs.proto
-
-package eth
-
-import (
-	reflect "reflect"
-	sync "sync"
-
-	github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
-	v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
-	_ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext"
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-type BlobsSidecar struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	BeaconBlockRoot []byte                                                            `protobuf:"bytes,1,opt,name=beacon_block_root,json=beaconBlockRoot,proto3" json:"beacon_block_root,omitempty" ssz-size:"32"`
-	BeaconBlockSlot github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot `protobuf:"varint,2,opt,name=beacon_block_slot,json=beaconBlockSlot,proto3" json:"beacon_block_slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"`
-	Blobs           []*v1.Blob                                                        `protobuf:"bytes,3,rep,name=blobs,proto3" json:"blobs,omitempty" ssz-max:"16"`
-	AggregatedProof []byte                                                            `protobuf:"bytes,4,opt,name=aggregated_proof,json=aggregatedProof,proto3" json:"aggregated_proof,omitempty" ssz-size:"48"`
-}
-
-func (x *BlobsSidecar) Reset() {
-	*x = BlobsSidecar{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_prysm_v1alpha1_blobs_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *BlobsSidecar) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*BlobsSidecar) ProtoMessage() {}
-
-func (x *BlobsSidecar) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_prysm_v1alpha1_blobs_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use BlobsSidecar.ProtoReflect.Descriptor instead.
-func (*BlobsSidecar) Descriptor() ([]byte, []int) {
-	return file_proto_prysm_v1alpha1_blobs_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *BlobsSidecar) GetBeaconBlockRoot() []byte {
-	if x != nil {
-		return x.BeaconBlockRoot
-	}
-	return nil
-}
-
-func (x *BlobsSidecar) GetBeaconBlockSlot() github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot {
-	if x != nil {
-		return x.BeaconBlockSlot
-	}
-	return github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot(0)
-}
-
-func (x *BlobsSidecar) GetBlobs() []*v1.Blob {
-	if x != nil {
-		return x.Blobs
-	}
-	return nil
-}
-
-func (x *BlobsSidecar) GetAggregatedProof() []byte {
-	if x != nil {
-		return x.AggregatedProof
-	}
-	return nil
-}
-
-var File_proto_prysm_v1alpha1_blobs_proto protoreflect.FileDescriptor
-
-var file_proto_prysm_v1alpha1_blobs_proto_rawDesc = []byte{
-	0x0a, 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, 0x12, 0x15, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68,
-	0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x1a, 0x1b, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2f, 0x65, 0x74, 0x68, 0x2f, 0x65, 0x78, 0x74, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 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, 0xa0,
-	0x02, 0x0a, 0x0c, 0x42, 0x6c, 0x6f, 0x62, 0x73, 0x53, 0x69, 0x64, 0x65, 0x63, 0x61, 0x72, 0x12,
-	0x32, 0x0a, 0x11, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
-	0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02,
-	0x33, 0x32, 0x52, 0x0f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52,
-	0x6f, 0x6f, 0x74, 0x12, 0x71, 0x0a, 0x11, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c,
-	0x6f, 0x63, 0x6b, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45,
-	0x82, 0xb5, 0x18, 0x41, 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, 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, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x0f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f,
-	0x63, 0x6b, 0x53, 0x6c, 0x6f, 0x74, 0x12, 0x36, 0x0a, 0x05, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x18,
-	0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
-	0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x62, 0x42,
-	0x06, 0x92, 0xb5, 0x18, 0x02, 0x31, 0x36, 0x52, 0x05, 0x62, 0x6c, 0x6f, 0x62, 0x73, 0x12, 0x31,
-	0x0a, 0x10, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x6f,
-	0x6f, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x34, 0x38,
-	0x52, 0x0f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f,
-	0x66, 0x42, 0x95, 0x01, 0x0a, 0x19, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65,
-	0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42,
-	0x0a, 0x42, 0x6c, 0x6f, 0x62, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 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, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x31, 0x61,
-	0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
-	0x31, 0xca, 0x02, 0x15, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68,
-	0x5c, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x33,
-}
-
-var (
-	file_proto_prysm_v1alpha1_blobs_proto_rawDescOnce sync.Once
-	file_proto_prysm_v1alpha1_blobs_proto_rawDescData = file_proto_prysm_v1alpha1_blobs_proto_rawDesc
-)
-
-func file_proto_prysm_v1alpha1_blobs_proto_rawDescGZIP() []byte {
-	file_proto_prysm_v1alpha1_blobs_proto_rawDescOnce.Do(func() {
-		file_proto_prysm_v1alpha1_blobs_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_prysm_v1alpha1_blobs_proto_rawDescData)
-	})
-	return file_proto_prysm_v1alpha1_blobs_proto_rawDescData
-}
-
-var file_proto_prysm_v1alpha1_blobs_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_proto_prysm_v1alpha1_blobs_proto_goTypes = []interface{}{
-	(*BlobsSidecar)(nil), // 0: ethereum.eth.v1alpha1.BlobsSidecar
-	(*v1.Blob)(nil),      // 1: ethereum.engine.v1.Blob
-}
-var file_proto_prysm_v1alpha1_blobs_proto_depIdxs = []int32{
-	1, // 0: ethereum.eth.v1alpha1.BlobsSidecar.blobs:type_name -> ethereum.engine.v1.Blob
-	1, // [1:1] is the sub-list for method output_type
-	1, // [1:1] is the sub-list for method input_type
-	1, // [1:1] is the sub-list for extension type_name
-	1, // [1:1] is the sub-list for extension extendee
-	0, // [0:1] is the sub-list for field type_name
-}
-
-func init() { file_proto_prysm_v1alpha1_blobs_proto_init() }
-func file_proto_prysm_v1alpha1_blobs_proto_init() {
-	if File_proto_prysm_v1alpha1_blobs_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_proto_prysm_v1alpha1_blobs_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*BlobsSidecar); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_proto_prysm_v1alpha1_blobs_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   1,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_proto_prysm_v1alpha1_blobs_proto_goTypes,
-		DependencyIndexes: file_proto_prysm_v1alpha1_blobs_proto_depIdxs,
-		MessageInfos:      file_proto_prysm_v1alpha1_blobs_proto_msgTypes,
-	}.Build()
-	File_proto_prysm_v1alpha1_blobs_proto = out.File
-	file_proto_prysm_v1alpha1_blobs_proto_rawDesc = nil
-	file_proto_prysm_v1alpha1_blobs_proto_goTypes = nil
-	file_proto_prysm_v1alpha1_blobs_proto_depIdxs = nil
-}

proto/prysm/v1alpha1/blobs.pb.gw.go

@@ -1,4 +0,0 @@
-//go:build ignore
-// +build ignore
-
-package ignore

proto/prysm/v1alpha1/blobs.proto

@@ -1,39 +0,0 @@
-// Copyright 2022 Prysmatic Labs.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-syntax = "proto3";
-
-package ethereum.eth.v1alpha1;
-
-import "proto/eth/ext/options.proto";
-import "proto/engine/v1/execution_engine.proto";
-
-option csharp_namespace = "Ethereum.Eth.v1alpha1";
-option go_package = "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1;eth";
-option java_multiple_files = true;
-option java_outer_classname = "BlobsProto";
-option java_package = "org.ethereum.eth.v1alpha1";
-option php_namespace = "Ethereum\\Eth\\v1alpha1";
-
-// The blobs sidecar which contains the beacon block root, slot, blobs and an aggregated proof
-// for fast validation.
-message BlobsSidecar {
-        // The beacon block root which corresponds to the beacon block.
-        bytes beacon_block_root = 1 [(ethereum.eth.ext.ssz_size) = "32"];
-        // The beacon block slot which corresponds ot the beacon block.
-        uint64 beacon_block_slot = 2 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"];
-        // The blobs itself which contains data to be committed.
-        repeated ethereum.engine.v1.Blob blobs = 3 [(ethereum.eth.ext.ssz_max)  = "16"];
-        // The aggregated proof for blobs and commitments for validation.
-        bytes aggregated_proof = 4 [(ethereum.eth.ext.ssz_size) = "48"];
-}

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)
 }