temp commit with some commentary. revert this commit later

async/multilock_test.go

@@ -110,8 +110,9 @@ func TestLockUnlock_CleansUnused(t *testing.T) {
 		lock := NewMultilock("dog", "cat", "owl")
 		lock.Lock()
 		assert.Equal(t, 3, len(locks.list))
-		lock.Unlock()
+		defer lock.Unlock()
 
+		<-time.After(100 * time.Millisecond)
 		wg.Done()
 	}()
 	wg.Wait()

beacon-chain/blockchain/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
         "error.go",
         "head.go",
         "head_sync_committee_info.go",
+        "info.go",
         "init_sync_process_block.go",
         "log.go",
         "metrics.go",
@@ -49,7 +50,6 @@ go_library(
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
-        "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
@@ -74,6 +74,7 @@ go_library(
         "//runtime/version:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_emicklei_dot//:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
@@ -103,6 +104,7 @@ go_test(
         "checktags_test.go",
         "head_sync_committee_info_test.go",
         "head_test.go",
+        "info_test.go",
         "init_test.go",
         "log_test.go",
         "metrics_test.go",

beacon-chain/blockchain/chain_info.go

@@ -6,7 +6,7 @@ import (
 
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -53,12 +53,12 @@ type HeadFetcher interface {
 	HeadETH1Data() *ethpb.Eth1Data
 	HeadPublicKeyToValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool)
 	HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([fieldparams.BLSPubkeyLength]byte, error)
+	ProtoArrayStore() *protoarray.Store
 	ChainHeads() ([][32]byte, []types.Slot)
 	IsOptimistic(ctx context.Context) (bool, error)
-	IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error)
+	IsOptimisticForRoot(ctx context.Context, root [32]byte, slot types.Slot) (bool, error)
 	HeadSyncCommitteeFetcher
 	HeadDomainFetcher
-	ForkChoicer() forkchoice.ForkChoicer
 }
 
 // ForkFetcher retrieves the current fork information of the Ethereum beacon chain.
@@ -238,6 +238,11 @@ func (s *Service) HeadETH1Data() *ethpb.Eth1Data {
 	return s.head.state.Eth1Data()
 }
 
+// ProtoArrayStore returns the proto array store object.
+func (s *Service) ProtoArrayStore() *protoarray.Store {
+	return s.cfg.ForkChoiceStore.Store()
+}
+
 // GenesisTime returns the genesis time of beacon chain.
 func (s *Service) GenesisTime() time.Time {
 	return s.genesisTime
@@ -283,7 +288,23 @@ func (s *Service) IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, er
 // ChainHeads returns all possible chain heads (leaves of fork choice tree).
 // Heads roots and heads slots are returned.
 func (s *Service) ChainHeads() ([][32]byte, []types.Slot) {
-	return s.cfg.ForkChoiceStore.Tips()
+	nodes := s.ProtoArrayStore().Nodes()
+
+	// Deliberate choice to not preallocate space for below.
+	// Heads cant be more than 2-3 in the worst case where pre-allocation will be 64 to begin with.
+	headsRoots := make([][32]byte, 0)
+	headsSlots := make([]types.Slot, 0)
+
+	nonExistentNode := ^uint64(0)
+	for _, node := range nodes {
+		// Possible heads have no children.
+		if node.BestDescendant() == nonExistentNode && node.BestChild() == nonExistentNode {
+			headsRoots = append(headsRoots, node.Root())
+			headsSlots = append(headsSlots, node.Slot())
+		}
+	}
+
+	return headsRoots, headsSlots
 }
 
 // HeadPublicKeyToValidatorIndex returns the validator index of the `pubkey` in current head state.
@@ -310,11 +331,6 @@ func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index types.V
 	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) {
 	s.headLock.RLock()
@@ -323,21 +339,16 @@ func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
 		return false, nil
 	}
 
-	return s.cfg.ForkChoiceStore.IsOptimistic(ctx, s.head.root)
+	return s.cfg.ForkChoiceStore.Optimistic(ctx, s.head.root, s.head.slot)
 }
 
 // IsOptimisticForRoot takes the root and slot as aguments instead of the current head
 // and returns true if it is optimistic.
-func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) {
-	return s.cfg.ForkChoiceStore.IsOptimistic(ctx, root)
+func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte, slot types.Slot) (bool, error) {
+	return s.cfg.ForkChoiceStore.Optimistic(ctx, root, slot)
 }
 
 // SetGenesisTime sets the genesis time of beacon chain.
 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_test.go

@@ -8,7 +8,6 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
@@ -41,12 +40,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(0, 0)}}
-	p := c.ForkChoiceStore()
-	require.Equal(t, 0, int(p.FinalizedEpoch()))
-}
-
 func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
@@ -284,40 +277,27 @@ func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
 	root = c.HeadGenesisValidatorsRoot()
 	require.DeepEqual(t, root[:], s.GenesisValidatorsRoot())
 }
-func TestService_ChainHeads_ProtoArray(t *testing.T) {
+
+func TestService_ProtoArrayStore(t *testing.T) {
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}}
+	p := c.ProtoArrayStore()
+	require.Equal(t, 0, int(p.FinalizedEpoch()))
+}
+
+func TestService_ChainHeads(t *testing.T) {
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0,
-		params.BeaconConfig().ZeroHash)}}
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0, false))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0, false))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 0, 0, false))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, 0, 0, false))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, 0, 0, false))
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}}
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, [32]byte{}, 0, 0))
 
 	roots, slots := c.ChainHeads()
 	require.DeepEqual(t, [][32]byte{{'c'}, {'d'}, {'e'}}, roots)
 	require.DeepEqual(t, []types.Slot{102, 103, 104}, slots)
 }
 
-func TestService_ChainHeads_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}}
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0, false))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0, false))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 0, 0, false))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, 0, 0, false))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, 0, 0, false))
-
-	roots, slots := c.ChainHeads()
-	require.Equal(t, 3, len(roots))
-	rootMap := map[[32]byte]types.Slot{[32]byte{'c'}: 102, [32]byte{'d'}: 103, [32]byte{'e'}: 104}
-	for i, root := range roots {
-		slot, ok := rootMap[root]
-		require.Equal(t, true, ok)
-		require.Equal(t, slot, slots[i])
-	}
-}
-
 func TestService_HeadPublicKeyToValidatorIndex(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 10)
 	c := &Service{}
@@ -376,7 +356,7 @@ func TestService_HeadValidatorIndexToPublicKeyNil(t *testing.T) {
 	require.Equal(t, [fieldparams.BLSPubkeyLength]byte{}, p)
 }
 
-func TestService_IsOptimistic_ProtoArray(t *testing.T) {
+func TestService_IsOptimistic(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	cfg := params.BeaconConfig()
 	cfg.BellatrixForkEpoch = 0
@@ -384,24 +364,8 @@ func TestService_IsOptimistic_ProtoArray(t *testing.T) {
 
 	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0, true))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0, true))
-
-	opt, err := c.IsOptimistic(ctx)
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimistic_DoublyLinkedTree(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.BellatrixForkEpoch = 0
-	params.OverrideBeaconConfig(cfg)
-
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0, true))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0, true))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0))
 
 	opt, err := c.IsOptimistic(ctx)
 	require.NoError(t, err)
@@ -416,24 +380,13 @@ func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
 	require.Equal(t, false, opt)
 }
 
-func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) {
+func TestService_IsOptimisticForRoot(t *testing.T) {
 	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0, true))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0, true))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0))
 
-	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-}
-
-func TestService_IsOptimisticForRoot_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0, true))
-	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0, true))
-
-	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
+	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'}, 100)
 	require.NoError(t, err)
 	require.Equal(t, true, opt)
 }

beacon-chain/blockchain/head.go

@@ -10,7 +10,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
@@ -78,13 +77,8 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
 		if err != nil {
 			return err
 		}
-		if features.Get().EnableForkChoiceDoublyLinkedTree {
-			s.cfg.ForkChoiceStore = doublylinkedtree.New(j.Epoch, f.Epoch)
-		} else {
-			s.cfg.ForkChoiceStore = protoarray.New(j.Epoch, f.Epoch, bytesutil.ToBytes32(f.Root))
-		}
-		// TODO(10261) send optimistic status
-		if err := s.insertBlockToForkChoiceStore(ctx, jb.Block(), headStartRoot, f, j, false /* optimistic status */); err != nil {
+		s.cfg.ForkChoiceStore = protoarray.New(j.Epoch, f.Epoch, bytesutil.ToBytes32(f.Root))
+		if err := s.insertBlockToForkChoiceStore(ctx, jb.Block(), headStartRoot, f, j); err != nil {
 			return err
 		}
 	}

beacon-chain/blockchain/info.go

@@ -0,0 +1,99 @@
+package blockchain
+
+import (
+	"encoding/hex"
+	"fmt"
+	"net/http"
+
+	"github.com/emicklei/dot"
+	"github.com/prysmaticlabs/prysm/config/params"
+)
+
+const template = `<html>
+<head>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/viz.js/2.1.2/viz.js"></script>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/viz.js/2.1.2/full.render.js"></script>
+<body>
+    <script type="application/javascript">
+        var graph = ` + "`%s`;" + `
+        var viz = new Viz();
+        viz.renderSVGElement(graph) // reading the graph.
+            .then(function(element) {
+                document.body.appendChild(element); // appends to document.
+            })
+            .catch(error => {
+                // Create a new Viz instance (@see Caveats page for more info)
+                viz = new Viz();
+                // Possibly display the error
+                console.error(error);
+            });
+    </script>
+</head>
+</body>
+</html>`
+
+// TreeHandler is a handler to serve /tree page in metrics.
+func (s *Service) TreeHandler(w http.ResponseWriter, r *http.Request) {
+	headState, err := s.HeadState(r.Context())
+	if err != nil {
+		log.WithError(err).Error("Could not get head state")
+		return
+	}
+	if headState == nil || headState.IsNil() {
+		if _, err := w.Write([]byte("Unavailable during initial syncing")); err != nil {
+			log.WithError(err).Error("Failed to render p2p info page")
+		}
+	}
+
+	nodes := s.cfg.ForkChoiceStore.Nodes()
+
+	graph := dot.NewGraph(dot.Directed)
+	graph.Attr("rankdir", "RL")
+	graph.Attr("labeljust", "l")
+
+	dotNodes := make([]*dot.Node, len(nodes))
+	avgBalance := uint64(averageBalance(headState.Balances()))
+
+	for i := len(nodes) - 1; i >= 0; i-- {
+		// Construct label for each node.
+		slot := fmt.Sprintf("%d", nodes[i].Slot())
+		weight := fmt.Sprintf("%d", nodes[i].Weight()/1e9) // Convert unit Gwei to unit ETH.
+		votes := fmt.Sprintf("%d", nodes[i].Weight()/1e9/avgBalance)
+		index := fmt.Sprintf("%d", i)
+		g := nodes[i].Graffiti()
+		graffiti := hex.EncodeToString(g[:8])
+		label := "slot: " + slot + "\n votes: " + votes + "\n weight: " + weight + "\n graffiti: " + graffiti
+		var dotN dot.Node
+		if nodes[i].Parent() != ^uint64(0) {
+			dotN = graph.Node(index).Box().Attr("label", label)
+		}
+
+		if nodes[i].Slot() == s.HeadSlot() &&
+			nodes[i].BestDescendant() == ^uint64(0) &&
+			nodes[i].Parent() != ^uint64(0) {
+			dotN = dotN.Attr("color", "green")
+		}
+
+		dotNodes[i] = &dotN
+	}
+
+	for i := len(nodes) - 1; i >= 0; i-- {
+		if nodes[i].Parent() != ^uint64(0) && nodes[i].Parent() < uint64(len(dotNodes)) {
+			graph.Edge(*dotNodes[i], *dotNodes[nodes[i].Parent()])
+		}
+	}
+
+	w.WriteHeader(http.StatusOK)
+	w.Header().Set("Content-Type", "text/html")
+	if _, err := fmt.Fprintf(w, template, graph.String()); err != nil {
+		log.WithError(err).Error("Failed to render p2p info page")
+	}
+}
+
+func averageBalance(balances []uint64) float64 {
+	total := uint64(0)
+	for i := 0; i < len(balances); i++ {
+		total += balances[i]
+	}
+	return float64(total) / float64(len(balances)) / float64(params.BeaconConfig().GweiPerEth)
+}

beacon-chain/blockchain/info_test.go

@@ -0,0 +1,50 @@
+package blockchain
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/testing/assert"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
+)
+
+func TestService_TreeHandler(t *testing.T) {
+	req, err := http.NewRequest("GET", "/tree", nil)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, headState.SetBalances([]uint64{params.BeaconConfig().GweiPerEth}))
+	fcs := protoarray.New(
+		0, // justifiedEpoch
+		0, // finalizedEpoch
+		[32]byte{'a'},
+	)
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+	}
+	s, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+	require.NoError(t, s.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, [32]byte{'a'}, [32]byte{'g'}, [32]byte{'c'}, 0, 0))
+	require.NoError(t, s.cfg.ForkChoiceStore.ProcessBlock(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'c'}, 0, 0))
+	s.setHead([32]byte{'a'}, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), headState)
+
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(s.TreeHandler)
+
+	handler.ServeHTTP(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+}

beacon-chain/blockchain/new_slot_test.go

@@ -25,11 +25,11 @@ func TestService_newSlot(t *testing.T) {
 	}
 	ctx := context.Background()
 
-	require.NoError(t, fcs.ProcessBlock(ctx, 0, [32]byte{}, [32]byte{}, 0, 0, false))        // genesis
-	require.NoError(t, fcs.ProcessBlock(ctx, 32, [32]byte{'a'}, [32]byte{}, 0, 0, false))    // finalized
-	require.NoError(t, fcs.ProcessBlock(ctx, 64, [32]byte{'b'}, [32]byte{'a'}, 0, 0, false)) // justified
-	require.NoError(t, fcs.ProcessBlock(ctx, 96, [32]byte{'c'}, [32]byte{'a'}, 0, 0, false)) // best justified
-	require.NoError(t, fcs.ProcessBlock(ctx, 97, [32]byte{'d'}, [32]byte{}, 0, 0, false))    // bad
+	require.NoError(t, fcs.ProcessBlock(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, 0, 0))        // genesis
+	require.NoError(t, fcs.ProcessBlock(ctx, 32, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0))    // finalized
+	require.NoError(t, fcs.ProcessBlock(ctx, 64, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0)) // justified
+	require.NoError(t, fcs.ProcessBlock(ctx, 96, [32]byte{'c'}, [32]byte{'a'}, [32]byte{}, 0, 0)) // best justified
+	require.NoError(t, fcs.ProcessBlock(ctx, 97, [32]byte{'d'}, [32]byte{}, [32]byte{}, 0, 0))    // bad
 
 	type args struct {
 		slot          types.Slot

beacon-chain/blockchain/optimistic_sync.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
@@ -12,7 +13,6 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/sirupsen/logrus"
@@ -80,8 +80,8 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, headBlk block.Beac
 }
 
 // notifyForkchoiceUpdate signals execution engine on a new payload
-func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int, header *ethpb.ExecutionPayloadHeader, postState state.BeaconState, blk block.SignedBeaconBlock) error {
-	if postState == nil {
+func (s *Service) notifyNewPayload(ctx context.Context, preState, postState state.BeaconState, blk block.SignedBeaconBlock) error {
+	if preState == nil || postState == nil {
 		return errors.New("pre and post states must not be nil")
 	}
 	// Execution payload is only supported in Bellatrix and beyond.
@@ -118,10 +118,10 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int, hea
 	}
 
 	// During the transition event, the transition block should be verified for sanity.
-	if isPreBellatrix(preStateVersion) {
+	if isPreBellatrix(preState.Version()) {
 		return nil
 	}
-	atTransition, err := blocks.IsMergeTransitionBlockUsingPayloadHeader(header, body)
+	atTransition, err := blocks.MergeTransitionBlock(preState, body)
 	if err != nil {
 		return errors.Wrap(err, "could not check if merge block is terminal")
 	}
@@ -158,3 +158,21 @@ func (s *Service) optimisticCandidateBlock(ctx context.Context, blk block.Beacon
 	}
 	return blocks.ExecutionBlock(jBlock.Block().Body())
 }
+
+// loadSyncedTips loads a previously saved synced Tips from DB
+// if no synced tips are saved, then it creates one from the given
+// root and slot number.
+func (s *Service) loadSyncedTips(root [32]byte, slot types.Slot) error {
+	// Initialize synced tips
+	tips, err := s.cfg.BeaconDB.ValidatedTips(s.ctx)
+	if err != nil || len(tips) == 0 {
+		tips[root] = slot
+		if err != nil {
+			log.WithError(err).Warn("Could not read synced tips from DB, using finalized checkpoint as synced tip")
+		}
+	}
+	if err := s.cfg.ForkChoiceStore.SetSyncedTips(tips); err != nil {
+		return errors.Wrap(err, "could not set synced tips")
+	}
+	return nil
+}

beacon-chain/blockchain/optimistic_sync_test.go

@@ -17,7 +17,6 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 	"github.com/prysmaticlabs/prysm/time/slots"
@@ -212,8 +211,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 			preState:  altairState,
 		},
 		{
-			name:      "nil post state",
-			preState:  phase0State,
+			name:      "nil states",
 			errString: "pre and post states must not be nil",
 		},
 		{
@@ -314,12 +312,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 			TotalDifficulty: "0x1",
 		}
 		service.cfg.ExecutionEngineCaller = engine
-		var payload *ethpb.ExecutionPayloadHeader
-		if tt.preState.Version() == version.Bellatrix {
-			payload, err = tt.preState.LatestExecutionPayloadHeader()
-			require.NoError(t, err)
-		}
-		err := service.notifyNewPayload(ctx, tt.preState.Version(), payload, tt.postState, tt.blk)
+		err := service.notifyNewPayload(ctx, tt.preState, tt.postState, tt.blk)
 		if tt.errString != "" {
 			require.ErrorContains(t, tt.errString, err)
 		} else {

beacon-chain/blockchain/options.go

@@ -11,7 +11,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
-	enginev1 "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -51,14 +50,6 @@ func WithChainStartFetcher(f powchain.ChainStartFetcher) Option {
 	}
 }
 
-// WithExecutionEngineCaller to call execution engine.
-func WithExecutionEngineCaller(c enginev1.Caller) Option {
-	return func(s *Service) error {
-		s.cfg.ExecutionEngineCaller = c
-		return nil
-	}
-}
-
 // WithDepositCache for deposit lifecycle after chain inclusion.
 func WithDepositCache(c *depositcache.DepositCache) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_attestation_test.go

@@ -8,7 +8,6 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
@@ -22,7 +21,7 @@ import (
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
-func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
+func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
@@ -128,113 +127,7 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 	}
 }
 
-func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithForkChoiceStore(doublylinkedtree.New(0, 0)),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	_, err = blockTree1(t, beaconDB, []byte{'g'})
-	require.NoError(t, err)
-
-	BlkWithOutState := util.NewBeaconBlock()
-	BlkWithOutState.Block.Slot = 0
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithOutState)))
-	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	BlkWithStateBadAtt := util.NewBeaconBlock()
-	BlkWithStateBadAtt.Block.Slot = 1
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithStateBadAtt)))
-	BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	s, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, s.SetSlot(100*params.BeaconConfig().SlotsPerEpoch))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, BlkWithStateBadAttRoot))
-
-	BlkWithValidState := util.NewBeaconBlock()
-	BlkWithValidState.Block.Slot = 2
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState)))
-
-	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
-	require.NoError(t, err)
-	s, err = util.NewBeaconState()
-	require.NoError(t, err)
-	err = s.SetFork(&ethpb.Fork{
-		Epoch:           0,
-		CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-	})
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, BlkWithValidStateRoot))
-
-	tests := []struct {
-		name      string
-		a         *ethpb.Attestation
-		wantedErr string
-	}{
-		{
-			name:      "attestation's data slot not aligned with target vote",
-			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}}),
-			wantedErr: "slot 32 does not match target epoch 0",
-		},
-		{
-			name:      "no pre state for attestations's target block",
-			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}}),
-			wantedErr: "could not get pre state for epoch 0",
-		},
-		{
-			name: "process attestation doesn't match current epoch",
-			a: util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
-				Root: BlkWithStateBadAttRoot[:]}}}),
-			wantedErr: "target epoch 100 does not match current epoch",
-		},
-		{
-			name:      "process nil attestation",
-			a:         nil,
-			wantedErr: "attestation can't be nil",
-		},
-		{
-			name:      "process nil field (a.Data) in attestation",
-			a:         &ethpb.Attestation{},
-			wantedErr: "attestation's data can't be nil",
-		},
-		{
-			name: "process nil field (a.Target) in attestation",
-			a: &ethpb.Attestation{
-				Data: &ethpb.AttestationData{
-					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
-					Target:          nil,
-					Source:          &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
-				},
-				AggregationBits: make([]byte, 1),
-				Signature:       make([]byte, 96),
-			},
-			wantedErr: "attestation's target can't be nil",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := service.OnAttestation(ctx, tt.a)
-			if tt.wantedErr != "" {
-				assert.ErrorContains(t, tt.wantedErr, err)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}
-
-func TestStore_OnAttestation_Ok_ProtoArray(t *testing.T) {
+func TestStore_OnAttestation_Ok(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
@@ -256,33 +149,7 @@ func TestStore_OnAttestation_Ok_ProtoArray(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, 1, 1, false))
-	require.NoError(t, service.OnAttestation(ctx, att[0]))
-}
-
-func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	fcs := doublylinkedtree.New(0, 0)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	genesisState, pks := util.DeterministicGenesisState(t, 64)
-	service.SetGenesisTime(time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0))
-	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
-	require.NoError(t, err)
-	tRoot := bytesutil.ToBytes32(att[0].Data.Target.Root)
-	copied := genesisState.Copy()
-	copied, err = transition.ProcessSlots(ctx, copied, 1)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, 1, 1, false))
+	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, tRoot, 1, 1))
 	require.NoError(t, service.OnAttestation(ctx, att[0]))
 }
 
@@ -463,7 +330,7 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
 	assert.NoError(t, service.verifyBeaconBlock(ctx, d), "Did not receive the wanted error")
 }
 
-func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
+func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
@@ -494,37 +361,6 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
 	require.ErrorContains(t, "Root and finalized store are not consistent", err)
 }
 
-func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	fcs := doublylinkedtree.New(0, 0)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	b32 := util.NewBeaconBlock()
-	b32.Block.Slot = 32
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
-	r32, err := b32.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 1})
-	b33 := util.NewBeaconBlock()
-	b33.Block.Slot = 33
-	b33.Block.ParentRoot = r32[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
-	r33, err := b33.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	err = service.VerifyFinalizedConsistency(context.Background(), r33[:])
-	require.ErrorContains(t, "Root and finalized store are not consistent", err)
-}
-
 func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	ctx := context.Background()
 
@@ -571,8 +407,8 @@ func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, b32.Block.Slot, r32, [32]byte{}, 0, 0, false))
-	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, b33.Block.Slot, r33, r32, 0, 0, false))
+	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, b32.Block.Slot, r32, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, b33.Block.Slot, r33, r32, [32]byte{}, 0, 0))
 
 	_, err = service.cfg.ForkChoiceStore.Head(ctx, 0, r32, []uint64{}, 0)
 	require.NoError(t, err)

beacon-chain/blockchain/process_block.go

@@ -21,7 +21,6 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
 )
@@ -99,17 +98,10 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		return err
 	}
 
-	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
-	if err != nil {
-		return err
-	}
 	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
 		return err
 	}
-	if err := s.notifyNewPayload(ctx, preStateVersion, preStateHeader, postState, signed); err != nil {
-		return errors.Wrap(err, "could not verify new payload")
-	}
 
 	// We add a proposer score boost to fork choice for the block root if applicable, right after
 	// running a successful state transition for the block.
@@ -119,8 +111,7 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		return err
 	}
 
-	// TODO(10261) Check optimistic status
-	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, false /* reg sync */, false /*optimistic sync*/); err != nil {
+	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, false /* reg sync */); err != nil {
 		return err
 	}
 
@@ -183,8 +174,9 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	if err := s.updateHead(ctx, balances); err != nil {
 		log.WithError(err).Warn("Could not update head")
 	}
-	if _, err := s.notifyForkchoiceUpdate(ctx, s.headBlock().Block(), bytesutil.ToBytes32(finalized.Root)); err != nil {
-		return err
+
+	if err := s.saveSyncedTipsDB(ctx); err != nil {
+		return errors.Wrap(err, "could not save synced tips")
 	}
 
 	if err := s.pruneCanonicalAttsFromPool(ctx, blockRoot, signed); err != nil {
@@ -258,21 +250,6 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	return s.handleEpochBoundary(ctx, postState)
 }
 
-func getStateVersionAndPayload(preState state.BeaconState) (int, *ethpb.ExecutionPayloadHeader, error) {
-	var preStateHeader *ethpb.ExecutionPayloadHeader
-	var err error
-	preStateVersion := preState.Version()
-	switch preStateVersion {
-	case version.Phase0, version.Altair:
-	default:
-		preStateHeader, err = preState.LatestExecutionPayloadHeader()
-		if err != nil {
-			return 0, nil, err
-		}
-	}
-	return preStateVersion, preStateHeader, nil
-}
-
 func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlock,
 	blockRoots [][32]byte) ([]*ethpb.Checkpoint, []*ethpb.Checkpoint, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
@@ -350,13 +327,16 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 // handles a block after the block's batch has been verified, where we can save blocks
 // their state summaries and split them off to relative hot/cold storage.
 func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.SignedBeaconBlock,
-	blockRoot [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint, optimistic bool) error {
+	blockRoot [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	b := signed.Block()
 
 	s.saveInitSyncBlock(blockRoot, signed)
-	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, fCheckpoint, jCheckpoint, optimistic); err != nil {
+	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
+	if err := s.saveSyncedTipsDB(ctx); err != nil {
+		return errors.Wrap(err, "could not save synced tips")
+	}
 
 	if err := s.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
 		Slot: signed.Block().Slot(),
@@ -442,13 +422,13 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 // This feeds in the block and block's attestations to fork choice store. It's allows fork choice store
 // to gain information on the most current chain.
 func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Context, blk block.BeaconBlock, root [32]byte,
-	st state.BeaconState, optimistic bool) error {
+	st state.BeaconState) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.insertBlockAndAttestationsToForkChoiceStore")
 	defer span.End()
 
 	fCheckpoint := st.FinalizedCheckpoint()
 	jCheckpoint := st.CurrentJustifiedCheckpoint()
-	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, fCheckpoint, jCheckpoint, optimistic); err != nil {
+	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
 	// Feed in block's attestations to fork choice store.
@@ -467,16 +447,15 @@ func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Contex
 }
 
 func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk block.BeaconBlock,
-	root [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint, optimistic bool) error {
-	//TODO(10261) check if the blocks are optimistic or not when filling fork choice
+	root [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	if err := s.fillInForkChoiceMissingBlocks(ctx, blk, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
 	// Feed in block to fork choice store.
 	if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
-		blk.Slot(), root, bytesutil.ToBytes32(blk.ParentRoot()),
+		blk.Slot(), root, bytesutil.ToBytes32(blk.ParentRoot()), bytesutil.ToBytes32(blk.Body().Graffiti()),
 		jCheckpoint.Epoch,
-		fCheckpoint.Epoch, optimistic); err != nil {
+		fCheckpoint.Epoch); err != nil {
 		return errors.Wrap(err, "could not process block for proto array fork choice")
 	}
 	return nil
@@ -484,7 +463,7 @@ func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk block.Be
 
 // This saves post state info to DB or cache. This also saves post state info to fork choice store.
 // Post state info consists of processed block and state. Do not call this method unless the block and state are verified.
-func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b block.SignedBeaconBlock, st state.BeaconState, initSync bool, optimistic bool) error {
+func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b block.SignedBeaconBlock, st state.BeaconState, initSync bool) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.savePostStateInfo")
 	defer span.End()
 	if initSync {
@@ -495,7 +474,7 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b block.Sig
 	if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
 		return errors.Wrap(err, "could not save state")
 	}
-	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, b.Block(), r, st, optimistic); err != nil {
+	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, b.Block(), r, st); err != nil {
 		return errors.Wrapf(err, "could not insert block %d to fork choice store", b.Block().Slot())
 	}
 	return nil
@@ -530,3 +509,12 @@ func (s *Service) pruneCanonicalAttsFromPool(ctx context.Context, r [32]byte, b
 	}
 	return nil
 }
+
+// Saves synced and validated tips to DB.
+func (s *Service) saveSyncedTipsDB(ctx context.Context) error {
+	tips := s.cfg.ForkChoiceStore.SyncedTips()
+	if len(tips) == 0 {
+		return nil
+	}
+	return s.cfg.BeaconDB.UpdateValidatedTips(ctx, tips)
+}

beacon-chain/blockchain/process_block_helpers.go

@@ -367,9 +367,9 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk block.B
 		b := pendingNodes[i]
 		r := pendingRoots[i]
 		if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
-			b.Slot(), r, bytesutil.ToBytes32(b.ParentRoot()),
+			b.Slot(), r, bytesutil.ToBytes32(b.ParentRoot()), bytesutil.ToBytes32(b.Body().Graffiti()),
 			jCheckpoint.Epoch,
-			fCheckpoint.Epoch, false /* optimistic status */); err != nil {
+			fCheckpoint.Epoch); err != nil {
 			return errors.Wrap(err, "could not process block for proto array fork choice")
 		}
 	}

beacon-chain/blockchain/process_block_test.go

@@ -16,7 +16,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
@@ -28,14 +27,13 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
 )
 
-func TestStore_OnBlock_ProtoArray(t *testing.T) {
+func TestStore_OnBlock(t *testing.T) {
 	ctx := context.Background()
 
 	beaconDB := testDB.SetupDB(t)
@@ -132,104 +130,7 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 	}
 }
 
-func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-
-	beaconDB := testDB.SetupDB(t)
-	fcs := doublylinkedtree.New(0, 0)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	genesisStateRoot := [32]byte{}
-	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
-	validGenesisRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err)
-	st, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
-	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
-	require.NoError(t, err)
-	random := util.NewBeaconBlock()
-	random.Block.Slot = 1
-	random.Block.ParentRoot = validGenesisRoot[:]
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(random)))
-	randomParentRoot, err := random.Block.HashTreeRoot()
-	assert.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), randomParentRoot))
-	randomParentRoot2 := roots[1]
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot2}))
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), bytesutil.ToBytes32(randomParentRoot2)))
-
-	tests := []struct {
-		name          string
-		blk           *ethpb.SignedBeaconBlock
-		s             state.BeaconState
-		time          uint64
-		wantErrString string
-	}{
-		{
-			name:          "parent block root does not have a state",
-			blk:           util.NewBeaconBlock(),
-			s:             st.Copy(),
-			wantErrString: "could not reconstruct parent state",
-		},
-		{
-			name: "block is from the future",
-			blk: func() *ethpb.SignedBeaconBlock {
-				b := util.NewBeaconBlock()
-				b.Block.ParentRoot = randomParentRoot2
-				b.Block.Slot = params.BeaconConfig().FarFutureSlot
-				return b
-			}(),
-			s:             st.Copy(),
-			wantErrString: "is in the far distant future",
-		},
-		{
-			name: "could not get finalized block",
-			blk: func() *ethpb.SignedBeaconBlock {
-				b := util.NewBeaconBlock()
-				b.Block.ParentRoot = randomParentRoot[:]
-				return b
-			}(),
-			s:             st.Copy(),
-			wantErrString: "is not a descendant of the current finalized block",
-		},
-		{
-			name: "same slot as finalized block",
-			blk: func() *ethpb.SignedBeaconBlock {
-				b := util.NewBeaconBlock()
-				b.Block.Slot = 0
-				b.Block.ParentRoot = randomParentRoot2
-				return b
-			}(),
-			s:             st.Copy(),
-			wantErrString: "block is equal or earlier than finalized block, slot 0 < slot 0",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
-			service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
-			service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: roots[0]})
-			service.store.SetPrevFinalizedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
-
-			root, err := tt.blk.Block.HashTreeRoot()
-			assert.NoError(t, err)
-			err = service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.blk), root)
-			assert.ErrorContains(t, tt.wantErrString, err)
-		})
-	}
-}
-
-func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
+func TestStore_OnBlockBatch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
@@ -281,58 +182,6 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 }
 
-func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	genesisStateRoot := [32]byte{}
-	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
-	gRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err)
-	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
-
-	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
-
-	st, keys := util.DeterministicGenesisState(t, 64)
-
-	bState := st.Copy()
-
-	var blks []block.SignedBeaconBlock
-	var blkRoots [][32]byte
-	var firstState state.BeaconState
-	for i := 1; i < 10; i++ {
-		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
-		require.NoError(t, err)
-		bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
-		require.NoError(t, err)
-		if i == 1 {
-			firstState = bState.Copy()
-		}
-		root, err := b.Block.HashTreeRoot()
-		require.NoError(t, err)
-		service.saveInitSyncBlock(root, wrapper.WrappedPhase0SignedBeaconBlock(b))
-		blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b))
-		blkRoots = append(blkRoots, root)
-	}
-
-	rBlock, err := blks[0].PbPhase0Block()
-	assert.NoError(t, err)
-	rBlock.Block.ParentRoot = gRoot[:]
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), blks[0]))
-	require.NoError(t, service.cfg.StateGen.SaveState(ctx, blkRoots[0], firstState))
-	_, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
-	require.NoError(t, err)
-}
-
 func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	ctx := context.Background()
 	params.SetupTestConfigCleanup(t)
@@ -366,7 +215,7 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	assert.Equal(t, true, update, "Should be able to update justified")
 }
 
-func TestShouldUpdateJustified_ReturnFalse_ProtoArray(t *testing.T) {
+func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 	ctx := context.Background()
 	params.SetupTestConfigCleanup(t)
 	params.OverrideBeaconConfig(params.MinimalSpecConfig())
@@ -395,36 +244,7 @@ func TestShouldUpdateJustified_ReturnFalse_ProtoArray(t *testing.T) {
 	assert.Equal(t, false, update, "Should not be able to update justified, received true")
 }
 
-func TestShouldUpdateJustified_ReturnFalse_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MinimalSpecConfig())
-
-	opts := testServiceOptsWithDB(t)
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	lastJustifiedBlk := util.NewBeaconBlock()
-	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
-	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	newJustifiedBlk := util.NewBeaconBlock()
-	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
-	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk)))
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk)))
-
-	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
-	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
-	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: lastJustifiedRoot[:]})
-
-	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
-	require.NoError(t, err)
-	assert.Equal(t, false, update, "Should not be able to update justified, received true")
-}
-
-func TestCachedPreState_CanGetFromStateSummary_ProtoArray(t *testing.T) {
+func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
@@ -455,37 +275,6 @@ func TestCachedPreState_CanGetFromStateSummary_ProtoArray(t *testing.T) {
 	require.NoError(t, service.verifyBlkPreState(ctx, wrapper.WrappedPhase0BeaconBlock(b.Block)))
 }
 
-func TestCachedPreState_CanGetFromStateSummary_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	s, err := v1.InitializeFromProto(&ethpb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
-	require.NoError(t, err)
-
-	genesisStateRoot := [32]byte{}
-	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
-	gRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err)
-	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
-	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
-
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 1
-	b.Block.ParentRoot = gRoot[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: gRoot[:]}))
-	require.NoError(t, service.cfg.StateGen.SaveState(ctx, gRoot, s))
-	require.NoError(t, service.verifyBlkPreState(ctx, wrapper.WrappedPhase0BeaconBlock(b.Block)))
-}
-
 func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
@@ -558,7 +347,7 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	assert.Equal(t, types.Epoch(2), service.store.BestJustifiedCheckpt().Epoch, "Incorrect justified epoch in service")
 }
 
-func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
+func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
@@ -593,54 +382,13 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
-	assert.Equal(t, 5, service.cfg.ForkChoiceStore.NodeCount(), "Miss match nodes")
+	assert.Equal(t, 5, len(service.cfg.ForkChoiceStore.Nodes()), "Miss match nodes")
 	assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(bytesutil.ToBytes32(roots[4])), "Didn't save node")
 	assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(bytesutil.ToBytes32(roots[6])), "Didn't save node")
 	assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(bytesutil.ToBytes32(roots[8])), "Didn't save node")
 }
 
-func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: make([]byte, 32)})
-
-	genesisStateRoot := [32]byte{}
-	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
-	validGenesisRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err)
-	st, err := util.NewBeaconState()
-	require.NoError(t, err)
-
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
-	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
-	require.NoError(t, err)
-
-	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	block := util.NewBeaconBlock()
-	block.Block.Slot = 9
-	block.Block.ParentRoot = roots[8]
-
-	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
-	require.NoError(t, err)
-
-	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
-	assert.Equal(t, 5, service.cfg.ForkChoiceStore.NodeCount(), "Miss match nodes")
-	assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(bytesutil.ToBytes32(roots[4])), "Didn't save node")
-	assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(bytesutil.ToBytes32(roots[6])), "Didn't save node")
-	assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(bytesutil.ToBytes32(roots[8])), "Didn't save node")
-}
-
-func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
+func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
@@ -675,7 +423,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
-	assert.Equal(t, 5, service.cfg.ForkChoiceStore.NodeCount(), "Miss match nodes")
+	assert.Equal(t, 5, len(service.cfg.ForkChoiceStore.Nodes()), "Miss match nodes")
 	// Ensure all roots and their respective blocks exist.
 	wantedRoots := [][]byte{roots[0], roots[3], roots[4], roots[6], roots[8]}
 	for i, rt := range wantedRoots {
@@ -684,51 +432,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
 	}
 }
 
-func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: make([]byte, 32)})
-
-	genesisStateRoot := [32]byte{}
-	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
-	validGenesisRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err)
-	st, err := util.NewBeaconState()
-	require.NoError(t, err)
-
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
-	roots, err := blockTree1(t, beaconDB, validGenesisRoot[:])
-	require.NoError(t, err)
-
-	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	block := util.NewBeaconBlock()
-	block.Block.Slot = 9
-	block.Block.ParentRoot = roots[8]
-
-	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
-	require.NoError(t, err)
-
-	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
-	assert.Equal(t, 5, service.cfg.ForkChoiceStore.NodeCount(), "Miss match nodes")
-	// Ensure all roots and their respective blocks exist.
-	wantedRoots := [][]byte{roots[0], roots[3], roots[4], roots[6], roots[8]}
-	for i, rt := range wantedRoots {
-		assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(bytesutil.ToBytes32(rt)), fmt.Sprintf("Didn't save node: %d", i))
-		assert.Equal(t, true, service.cfg.BeaconDB.HasBlock(context.Background(), bytesutil.ToBytes32(rt)))
-	}
-}
-
-func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
+func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
@@ -775,60 +479,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 
 	// There should be 2 nodes, block 65 and block 64.
-	assert.Equal(t, 2, service.cfg.ForkChoiceStore.NodeCount(), "Miss match nodes")
-
-	// Block with slot 63 should be in fork choice because it's less than finalized epoch 1.
-	assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(r63), "Didn't save node")
-}
-
-func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	// Set finalized epoch to 1.
-	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 1})
-
-	genesisStateRoot := [32]byte{}
-	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
-	validGenesisRoot, err := genesis.Block.HashTreeRoot()
-	assert.NoError(t, err)
-	st, err := util.NewBeaconState()
-	require.NoError(t, err)
-
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
-
-	// Define a tree branch, slot 63 <- 64 <- 65
-	b63 := util.NewBeaconBlock()
-	b63.Block.Slot = 63
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b63)))
-	r63, err := b63.Block.HashTreeRoot()
-	require.NoError(t, err)
-	b64 := util.NewBeaconBlock()
-	b64.Block.Slot = 64
-	b64.Block.ParentRoot = r63[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b64)))
-	r64, err := b64.Block.HashTreeRoot()
-	require.NoError(t, err)
-	b65 := util.NewBeaconBlock()
-	b65.Block.Slot = 65
-	b65.Block.ParentRoot = r64[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b65)))
-
-	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b65).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
-	require.NoError(t, err)
-
-	// There should be 2 nodes, block 65 and block 64.
-	assert.Equal(t, 2, service.cfg.ForkChoiceStore.NodeCount(), "Miss match nodes")
+	assert.Equal(t, 2, len(service.cfg.ForkChoiceStore.Nodes()), "Miss match nodes")
 
 	// Block with slot 63 should be in fork choice because it's less than finalized epoch 1.
 	assert.Equal(t, true, service.cfg.ForkChoiceStore.HasNode(r63), "Didn't save node")
@@ -1017,7 +668,7 @@ func TestAncestor_CanUseForkchoice(t *testing.T) {
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), 0, 0, false)) // Saves blocks to fork choice store.
+		require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), [32]byte{}, 0, 0)) // Saves blocks to fork choice store.
 	}
 
 	r, err := service.ancestor(context.Background(), r200[:], 150)
@@ -1062,7 +713,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock))) // Saves blocks to DB.
 	}
 
-	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(context.Background(), 200, r200, r200, 0, 0, false))
+	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(context.Background(), 200, r200, r200, [32]byte{}, 0, 0))
 
 	r, err := service.ancestor(context.Background(), r200[:], 150)
 	require.NoError(t, err)
@@ -1262,48 +913,6 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 	require.Equal(t, f.Epoch, service.FinalizedCheckpt().Epoch)
 }
 
-func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	config := params.BeaconConfig()
-	config.AltairForkEpoch = 1
-	config.BellatrixForkEpoch = 2
-	params.OverrideBeaconConfig(config)
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	depositCache, err := depositcache.New()
-	require.NoError(t, err)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-		WithDepositCache(depositCache),
-		WithStateNotifier(&mock.MockStateNotifier{}),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	gs, keys := util.DeterministicGenesisState(t, 32)
-	require.NoError(t, service.saveGenesisData(ctx, gs))
-	gBlk, err := service.cfg.BeaconDB.GenesisBlock(ctx)
-	require.NoError(t, err)
-	gRoot, err := gBlk.Block().HashTreeRoot()
-	require.NoError(t, err)
-	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
-
-	testState := gs.Copy()
-	for i := types.Slot(1); i < params.BeaconConfig().SlotsPerEpoch; i++ {
-		blk, err := util.GenerateFullBlock(testState, keys, util.DefaultBlockGenConfig(), i)
-		require.NoError(t, err)
-		r, err := blk.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r))
-		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
-		require.NoError(t, err)
-	}
-}
-
 func TestInsertFinalizedDeposits(t *testing.T) {
 	ctx := context.Background()
 	opts := testServiceOptsWithDB(t)
@@ -1388,52 +997,48 @@ func TestRemoveBlockAttestationsInPool_NonCanonical(t *testing.T) {
 	require.Equal(t, 1, service.cfg.AttPool.AggregatedAttestationCount())
 }
 
-func Test_getStateVersionAndPayload(t *testing.T) {
-	tests := []struct {
-		name    string
-		st      state.BeaconState
-		version int
-		header  *ethpb.ExecutionPayloadHeader
-	}{
-		{
-			name: "phase 0 state",
-			st: func() state.BeaconState {
-				s, _ := util.DeterministicGenesisState(t, 1)
-				return s
-			}(),
-			version: version.Phase0,
-			header:  (*ethpb.ExecutionPayloadHeader)(nil),
-		},
-		{
-			name: "altair state",
-			st: func() state.BeaconState {
-				s, _ := util.DeterministicGenesisStateAltair(t, 1)
-				return s
-			}(),
-			version: version.Altair,
-			header:  (*ethpb.ExecutionPayloadHeader)(nil),
-		},
-		{
-			name: "bellatrix state",
-			st: func() state.BeaconState {
-				s, _ := util.DeterministicGenesisStateBellatrix(t, 1)
-				require.NoError(t, s.SetLatestExecutionPayloadHeader(&ethpb.ExecutionPayloadHeader{
-					BlockNumber: 1,
-				}))
-				return s
-			}(),
-			version: version.Bellatrix,
-			header: &ethpb.ExecutionPayloadHeader{
-				BlockNumber: 1,
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			version, header, err := getStateVersionAndPayload(tt.st)
-			require.NoError(t, err)
-			require.Equal(t, tt.version, version)
-			require.DeepEqual(t, tt.header, header)
-		})
+func TestService_saveSyncedTipsDB(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+
+	b1 := util.NewBeaconBlock()
+	b1.Block.Slot = 1
+	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
+	r1, err := b1.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b100 := util.NewBeaconBlock()
+	b100.Block.Slot = 100
+	b100.Block.ParentRoot = r1[:]
+	r100, err := b100.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b200 := util.NewBeaconBlock()
+	b200.Block.Slot = 200
+	b200.Block.ParentRoot = r1[:]
+	r200, err := b200.Block.HashTreeRoot()
+	require.NoError(t, err)
+	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
+		beaconBlock := util.NewBeaconBlock()
+		beaconBlock.Block.Slot = b.Block.Slot
+		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
+		r, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), [32]byte{}, 0, 0))
 	}
+
+	require.NoError(t, service.cfg.ForkChoiceStore.UpdateSyncedTipsWithValidRoot(ctx, r100))
+	require.NoError(t, service.saveSyncedTipsDB(ctx))
+	savedTips, err := service.cfg.BeaconDB.ValidatedTips(ctx)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(savedTips))
+	require.Equal(t, types.Slot(1), savedTips[r1])
+	require.Equal(t, types.Slot(100), savedTips[r100])
+
+	// Delete invalid root
+	require.NoError(t, service.cfg.ForkChoiceStore.UpdateSyncedTipsWithInvalidRoot(ctx, r200))
+	require.NoError(t, service.saveSyncedTipsDB(ctx))
+	savedTips, err = service.cfg.BeaconDB.ValidatedTips(ctx)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(savedTips))
+	require.Equal(t, types.Slot(100), savedTips[r100])
 }

beacon-chain/blockchain/receive_attestation_test.go

@@ -111,7 +111,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, 1, 1, false))
+	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, tRoot, 1, 1))
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
 	service.processAttestations(ctx)
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations()))

beacon-chain/blockchain/receive_block.go

@@ -86,8 +86,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBe
 
 	for i, b := range blocks {
 		blockCopy := b.Copy()
-		// TODO(10261) check optimistic status
-		if err = s.handleBlockAfterBatchVerify(ctx, blockCopy, blkRoots[i], fCheckpoints[i], jCheckpoints[i], false /*optimistic status*/); err != nil {
+		if err = s.handleBlockAfterBatchVerify(ctx, blockCopy, blkRoots[i], fCheckpoints[i], jCheckpoints[i]); err != nil {
 			tracing.AnnotateError(span, err)
 			return err
 		}

beacon-chain/blockchain/receive_block_test.go

@@ -192,7 +192,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 		t.Errorf("Received %d state notifications, expected at least 1", recvd)
 	}
 	// Verify fork choice has processed the block. (Genesis block and the new block)
-	assert.Equal(t, 2, s.cfg.ForkChoiceStore.NodeCount())
+	assert.Equal(t, 2, len(s.cfg.ForkChoiceStore.Nodes()))
 }
 
 func TestService_ReceiveBlockBatch(t *testing.T) {

beacon-chain/blockchain/service.go

@@ -21,7 +21,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	f "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
@@ -32,7 +31,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -85,7 +83,6 @@ type config struct {
 	StateGen                *stategen.State
 	SlasherAttestationsFeed *event.Feed
 	WeakSubjectivityCheckpt *ethpb.Checkpoint
-	BlockFetcher            powchain.POWBlockFetcher
 	FinalizedStateAtStartUp state.BeaconState
 	ExecutionEngineCaller   enginev1.Caller
 }
@@ -135,7 +132,6 @@ func (s *Service) Start() {
 			log.Fatal(err)
 		}
 	}
-	s.spawnProcessAttestationsRoutine(s.cfg.StateNotifier.StateFeed())
 }
 
 // Stop the blockchain service's main event loop and associated goroutines.
@@ -190,14 +186,13 @@ func (s *Service) startFromSavedState(saved state.BeaconState) error {
 	}
 	s.store = store.New(justified, finalized)
 
-	var store f.ForkChoicer
-	if features.Get().EnableForkChoiceDoublyLinkedTree {
-		store = doublylinkedtree.New(justified.Epoch, finalized.Epoch)
-	} else {
-		store = protoarray.New(justified.Epoch, finalized.Epoch, bytesutil.ToBytes32(finalized.Root))
-	}
+	store := protoarray.New(justified.Epoch, finalized.Epoch, bytesutil.ToBytes32(finalized.Root))
 	s.cfg.ForkChoiceStore = store
 
+	if err := s.loadSyncedTips(originRoot, saved.Slot()); err != nil {
+		return err
+	}
+
 	ss, err := slots.EpochStart(finalized.Epoch)
 	if err != nil {
 		return errors.Wrap(err, "could not get start slot of finalized epoch")
@@ -228,6 +223,8 @@ func (s *Service) startFromSavedState(saved state.BeaconState) error {
 		},
 	})
 
+	s.spawnProcessAttestationsRoutine(s.cfg.StateNotifier.StateFeed())
+
 	return nil
 }
 
@@ -336,6 +333,7 @@ func (s *Service) startFromPOWChain() error {
 		stateChannel := make(chan *feed.Event, 1)
 		stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
 		defer stateSub.Unsubscribe()
+		s.spawnProcessAttestationsRoutine(s.cfg.StateNotifier.StateFeed())
 		for {
 			select {
 			case event := <-stateChannel:
@@ -453,8 +451,9 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 		genesisBlk.Block().Slot(),
 		genesisBlkRoot,
 		params.BeaconConfig().ZeroHash,
+		[32]byte{},
 		genesisCheckpoint.Epoch,
-		genesisCheckpoint.Epoch, false /* optimistic status */); err != nil {
+		genesisCheckpoint.Epoch); err != nil {
 		log.Fatalf("Could not process genesis block for fork choice: %v", err)
 	}
 

beacon-chain/blockchain/service_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain/store"
 	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
@@ -19,7 +20,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
@@ -164,6 +164,74 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	require.LogsContain(t, hook, "data already exists")
 }
 
+func TestChainStart_SyncedTipsInDB(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	chainService := setupBeaconChain(t, beaconDB)
+
+	genesisBlk := util.NewBeaconBlock()
+	blkRoot, err := genesisBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
+	s, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, s.SetSlot(1))
+	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
+	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, blkRoot))
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
+	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+	chainService.cfg.FinalizedStateAtStartUp = s
+
+	tips := make(map[[32]byte]types.Slot)
+	tips[bytesutil.ToBytes32([]byte{'a'})] = 1
+	tips[bytesutil.ToBytes32([]byte{'b'})] = 2
+	require.NoError(t, beaconDB.UpdateValidatedTips(ctx, tips))
+
+	// Test the start function.
+	chainService.Start()
+
+	// Test synced Tips in DB
+	tips2 := chainService.cfg.ForkChoiceStore.SyncedTips()
+	require.Equal(t, len(tips2), len(tips))
+	for k, v := range tips {
+		v2, ok := tips2[k]
+		require.Equal(t, true, ok)
+		require.Equal(t, v, v2)
+	}
+}
+
+func TestChainStart_SyncedTipsNotInDB(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	chainService := setupBeaconChain(t, beaconDB)
+
+	genesisBlk := util.NewBeaconBlock()
+	blkRoot, err := genesisBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
+	s, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, s.SetSlot(1))
+	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
+	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, blkRoot))
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
+	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+	chainService.cfg.FinalizedStateAtStartUp = s
+	// Test the start function.
+	chainService.Start()
+
+	// Test synced Tips in DB
+	tips := chainService.cfg.ForkChoiceStore.SyncedTips()
+	require.Equal(t, 1, len(tips))
+	slot, ok := tips[blkRoot]
+	require.Equal(t, true, ok)
+	require.Equal(t, types.Slot(1), slot)
+}
+
 func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctx := context.Background()
@@ -447,7 +515,7 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	}
 }
 
-func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) {
+func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
@@ -460,26 +528,7 @@ func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState, false))
-
-	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
-	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
-}
-
-func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	s := &Service{
-		cfg:   &config{ForkChoiceStore: doublylinkedtree.New(0, 0), BeaconDB: beaconDB},
-		store: &store.Store{},
-	}
-	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
-	block := util.NewBeaconBlock()
-	r, err := block.Block.HashTreeRoot()
-	require.NoError(t, err)
-	beaconState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState, false))
+	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
 
 	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
 	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -533,7 +582,7 @@ func BenchmarkHasBlockDB(b *testing.B) {
 	}
 }
 
-func BenchmarkHasBlockForkChoiceStore_ProtoArray(b *testing.B) {
+func BenchmarkHasBlockForkChoiceStore(b *testing.B) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(b)
 	s := &Service{
@@ -547,28 +596,7 @@ func BenchmarkHasBlockForkChoiceStore_ProtoArray(b *testing.B) {
 	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	beaconState, err := v1.InitializeFromProto(bs)
 	require.NoError(b, err)
-	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState, false))
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		require.Equal(b, true, s.cfg.ForkChoiceStore.HasNode(r), "Block is not in fork choice store")
-	}
-}
-func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(b)
-	s := &Service{
-		cfg:   &config{ForkChoiceStore: doublylinkedtree.New(0, 0), BeaconDB: beaconDB},
-		store: &store.Store{},
-	}
-	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
-	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
-	r, err := block.Block.HashTreeRoot()
-	require.NoError(b, err)
-	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
-	beaconState, err := v1.InitializeFromProto(bs)
-	require.NoError(b, err)
-	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState, false))
+	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

beacon-chain/blockchain/testing/BUILD.bazel

@@ -18,7 +18,7 @@ go_library(
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/db:go_default_library",
-        "//beacon-chain/forkchoice:go_default_library",
+        "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

beacon-chain/blockchain/testing/mock.go

@@ -18,7 +18,7 @@ import (
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -41,6 +41,7 @@ type ChainService struct {
 	PreviousJustifiedCheckPoint *ethpb.Checkpoint
 	Slot                        *types.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
 	Balance                     *precompute.Balance
+	ForkChoiceStore             *protoarray.Store
 	CanonicalRoots              map[[32]byte]bool
 	Fork                        *ethpb.Fork
 	ETH1Data                    *ethpb.Eth1Data
@@ -60,12 +61,6 @@ type ChainService struct {
 	SyncContributionProofDomain []byte
 	SyncCommitteePubkeys        [][]byte
 	Genesis                     time.Time
-	ForkChoiceStore             forkchoice.ForkChoicer
-}
-
-// ForkChoicer mocks the same method in the chain service
-func (s *ChainService) ForkChoicer() forkchoice.ForkChoicer {
-	return s.ForkChoiceStore
 }
 
 // StateNotifier mocks the same method in the chain service.
@@ -325,6 +320,11 @@ func (s *ChainService) HeadETH1Data() *ethpb.Eth1Data {
 	return s.ETH1Data
 }
 
+// ProtoArrayStore mocks the same method in the chain service.
+func (s *ChainService) ProtoArrayStore() *protoarray.Store {
+	return s.ForkChoiceStore
+}
+
 // GenesisTime mocks the same method in the chain service.
 func (s *ChainService) GenesisTime() time.Time {
 	return s.Genesis
@@ -447,6 +447,6 @@ func (s *ChainService) IsOptimistic(_ context.Context) (bool, error) {
 }
 
 // IsOptimisticForRoot mocks the same method in the chain service.
-func (s *ChainService) IsOptimisticForRoot(_ context.Context, _ [32]byte) (bool, error) {
-	return s.Optimistic, nil
+func (s *ChainService) IsOptimisticForRoot(_ context.Context, _ [32]byte, _ types.Slot) (bool, error) {
+	return false, nil
 }

beacon-chain/core/blocks/payload.go

@@ -23,8 +23,6 @@ import (
 // Spec code:
 // def is_merge_transition_complete(state: BeaconState) -> bool:
 //    return state.latest_execution_payload_header != ExecutionPayloadHeader()
-//
-// Deprecated: Use `IsMergeTransitionBlockUsingPayloadHeader` instead.
 func MergeTransitionComplete(st state.BeaconState) (bool, error) {
 	h, err := st.LatestExecutionPayloadHeader()
 	if err != nil {
@@ -53,16 +51,6 @@ func MergeTransitionBlock(st state.BeaconState, body block.BeaconBlockBody) (boo
 	return ExecutionBlock(body)
 }
 
-// IsMergeTransitionBlockUsingPayloadHeader returns true if the input block is the terminal merge block.
-// Terminal merge block must be associated with an empty payload header.
-// This is an optimized version of MergeTransitionComplete where beacon state is not required as an argument.
-func IsMergeTransitionBlockUsingPayloadHeader(h *ethpb.ExecutionPayloadHeader, body block.BeaconBlockBody) (bool, error) {
-	if !isEmptyHeader(h) {
-		return false, nil
-	}
-	return ExecutionBlock(body)
-}
-
 // ExecutionBlock returns whether the block has a non-empty ExecutionPayload.
 //
 // Spec code:

beacon-chain/core/blocks/payload_test.go

@@ -350,185 +350,6 @@ func Test_MergeBlock(t *testing.T) {
 	}
 }
 
-func Test_IsMergeTransitionBlockUsingPayloadHeader(t *testing.T) {
-	tests := []struct {
-		name    string
-		payload *enginev1.ExecutionPayload
-		header  *ethpb.ExecutionPayloadHeader
-		want    bool
-	}{
-		{
-			name:    "empty header, empty payload",
-			payload: emptyPayload(),
-			header:  emptyPayloadHeader(),
-			want:    false,
-		},
-		{
-			name:    "non-empty header, empty payload",
-			payload: emptyPayload(),
-			header: func() *ethpb.ExecutionPayloadHeader {
-				h := emptyPayloadHeader()
-				h.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return h
-			}(),
-			want: false,
-		},
-		{
-			name: "empty header, payload has parent hash",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has fee recipient",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.FeeRecipient = bytesutil.PadTo([]byte{'a'}, fieldparams.FeeRecipientLength)
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has state root",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.StateRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has receipt root",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.ReceiptsRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has logs bloom",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.LogsBloom = bytesutil.PadTo([]byte{'a'}, fieldparams.LogsBloomLength)
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has random",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.PrevRandao = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has base fee",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.BaseFeePerGas = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has block hash",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.BlockHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has tx",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.Transactions = [][]byte{{'a'}}
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has extra data",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.ExtraData = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has block number",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.BlockNumber = 1
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has gas limit",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.GasLimit = 1
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has gas used",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.GasUsed = 1
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-		{
-			name: "empty header, payload has timestamp",
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.Timestamp = 1
-				return p
-			}(),
-			header: emptyPayloadHeader(),
-			want:   true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			blk := util.NewBeaconBlockBellatrix()
-			blk.Block.Body.ExecutionPayload = tt.payload
-			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
-			require.NoError(t, err)
-			got, err := blocks.IsMergeTransitionBlockUsingPayloadHeader(tt.header, body)
-			require.NoError(t, err)
-			if got != tt.want {
-				t.Errorf("MergeTransitionBlock() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
 func Test_IsExecutionBlock(t *testing.T) {
 	tests := []struct {
 		name    string

beacon-chain/core/helpers/block.go

@@ -11,22 +11,18 @@ import (
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
-var ErrNilSignedBeaconBlock = errors.New("signed beacon block can't be nil")
-var ErrNilBeaconBlock = errors.New("beacon block can't be nil")
-var ErrNilBeaconBlockBody = errors.New("beacon block body can't be nil")
-
 // BeaconBlockIsNil checks if any composite field of input signed beacon block is nil.
 // Access to these nil fields will result in run time panic,
 // it is recommended to run these checks as first line of defense.
 func BeaconBlockIsNil(b block.SignedBeaconBlock) error {
 	if b == nil || b.IsNil() {
-		return ErrNilSignedBeaconBlock
+		return errors.New("signed beacon block can't be nil")
 	}
 	if b.Block().IsNil() {
-		return ErrNilBeaconBlock
+		return errors.New("beacon block can't be nil")
 	}
 	if b.Block().Body().IsNil() {
-		return ErrNilBeaconBlockBody
+		return errors.New("beacon block body can't be nil")
 	}
 	return nil
 }

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -137,6 +137,16 @@ func CalculateStateRoot(
 	if err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not process block")
 	}
+	if signed.Version() == version.Altair || signed.Version() == version.Bellatrix {
+		sa, err := signed.Block().Body().SyncAggregate()
+		if err != nil {
+			return [32]byte{}, err
+		}
+		state, err = altair.ProcessSyncAggregate(ctx, state, sa)
+		if err != nil {
+			return [32]byte{}, err
+		}
+	}
 
 	return state.HashTreeRoot(ctx)
 }
@@ -173,6 +183,16 @@ func ProcessBlockNoVerifyAnySig(
 	if err != nil {
 		return nil, nil, err
 	}
+	if signed.Version() == version.Altair || signed.Version() == version.Bellatrix {
+		sa, err := signed.Block().Body().SyncAggregate()
+		if err != nil {
+			return nil, nil, err
+		}
+		state, err = altair.ProcessSyncAggregate(ctx, state, sa)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
 
 	bSet, err := b.BlockSignatureBatch(state, blk.ProposerIndex(), signed.Signature(), blk.HashTreeRoot)
 	if err != nil {
@@ -320,19 +340,6 @@ func ProcessBlockForStateRoot(
 		return nil, errors.Wrap(err, "could not process block operation")
 	}
 
-	if signed.Block().Version() == version.Phase0 {
-		return state, nil
-	}
-
-	sa, err := signed.Block().Body().SyncAggregate()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get sync aggregate from block")
-	}
-	state, err = altair.ProcessSyncAggregate(ctx, state, sa)
-	if err != nil {
-		return nil, errors.Wrap(err, "process_sync_aggregate failed")
-	}
-
 	return state, nil
 }
 

beacon-chain/db/errors.go

@@ -7,9 +7,3 @@ import "github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
 // i/o error. This variable copies the value in the kv package to the same scope as the Database interfaces,
 // so that it is available to code paths that do not interact directly with the kv package.
 var ErrNotFound = kv.ErrNotFound
-
-// ErrNotFoundState wraps ErrNotFound for an error specific to a state not being found in the database.
-var ErrNotFoundState = kv.ErrNotFoundState
-
-// ErrNotFoundOriginBlockRoot wraps ErrNotFound for an error specific to the origin block root.
-var ErrNotFoundOriginBlockRoot = kv.ErrNotFoundOriginBlockRoot

beacon-chain/db/iface/interface.go

@@ -30,9 +30,9 @@ type ReadOnlyDatabase interface {
 	IsFinalizedBlock(ctx context.Context, blockRoot [32]byte) bool
 	FinalizedChildBlock(ctx context.Context, blockRoot [32]byte) (block.SignedBeaconBlock, error)
 	HighestSlotBlocksBelow(ctx context.Context, slot types.Slot) ([]block.SignedBeaconBlock, error)
+	ValidatedTips(ctx context.Context) (map[[32]byte]types.Slot, error)
 	// State related methods.
 	State(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
-	StateOrError(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
 	GenesisState(ctx context.Context) (state.BeaconState, error)
 	HasState(ctx context.Context, blockRoot [32]byte) bool
 	StateSummary(ctx context.Context, blockRoot [32]byte) (*ethpb.StateSummary, error)
@@ -63,6 +63,7 @@ type NoHeadAccessDatabase interface {
 	SaveBlock(ctx context.Context, block block.SignedBeaconBlock) error
 	SaveBlocks(ctx context.Context, blocks []block.SignedBeaconBlock) error
 	SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) error
+	UpdateValidatedTips(ctx context.Context, newVals map[[32]byte]types.Slot) error
 	// State related methods.
 	SaveState(ctx context.Context, state state.ReadOnlyBeaconState, blockRoot [32]byte) error
 	SaveStates(ctx context.Context, states []state.ReadOnlyBeaconState, blockRoots [][32]byte) error

beacon-chain/db/kv/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
         "state_summary.go",
         "state_summary_cache.go",
         "utils.go",
+        "validated_tips.go",
         "wss.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/db/kv",
@@ -80,6 +81,7 @@ go_test(
         "checkpoint_test.go",
         "deposit_contract_test.go",
         "encoding_test.go",
+        "error_test.go",
         "finalized_block_roots_test.go",
         "genesis_test.go",
         "init_test.go",
@@ -91,6 +93,7 @@ go_test(
         "state_summary_test.go",
         "state_test.go",
         "utils_test.go",
+        "validated_tips_test.go",
     ],
     data = glob(["testdata/**"]),
     embed = [":go_default_library"],

beacon-chain/db/kv/error.go

@@ -1,6 +1,6 @@
 package kv
 
-import "github.com/pkg/errors"
+import "errors"
 
 // errDeleteFinalized is raised when we attempt to delete a finalized block/state
 var errDeleteFinalized = errors.New("cannot delete finalized block or state")
@@ -8,7 +8,42 @@ var errDeleteFinalized = errors.New("cannot delete finalized block or state")
 // ErrNotFound can be used directly, or as a wrapped DBError, whenever a db method needs to
 // indicate that a value couldn't be found.
 var ErrNotFound = errors.New("not found in db")
-var ErrNotFoundState = errors.Wrap(ErrNotFound, "state not found")
 
 // ErrNotFoundOriginBlockRoot is an error specifically for the origin block root getter
-var ErrNotFoundOriginBlockRoot = errors.Wrap(ErrNotFound, "OriginBlockRoot")
+var ErrNotFoundOriginBlockRoot = WrapDBError(ErrNotFound, "OriginBlockRoot")
+
+// WrapDBError wraps an error in a DBError. See commentary on DBError for more context.
+func WrapDBError(e error, outer string) error {
+	return DBError{
+		Wraps: e,
+		Outer: errors.New(outer),
+	}
+}
+
+// DBError implements the Error method so that it can be asserted as an error.
+// The Unwrap method supports error wrapping, enabling it to be used with errors.Is/As.
+// The primary use case is to make it simple for database methods to return errors
+// that wrap ErrNotFound, allowing calling code to check for "not found" errors
+// like: `error.Is(err, ErrNotFound)`. This is intended to improve error handling
+// in db lookup methods that need to differentiate between a missing value and some
+// other database error. for more background see:
+// https://go.dev/blog/go1.13-errors
+type DBError struct {
+	Wraps error
+	Outer error
+}
+
+// Error satisfies the error interface, so that DBErrors can be used anywhere that
+// expects an `error`.
+func (e DBError) Error() string {
+	es := e.Outer.Error()
+	if e.Wraps != nil {
+		es += ": " + e.Wraps.Error()
+	}
+	return es
+}
+
+// Unwrap is used by the errors package Is and As methods.
+func (e DBError) Unwrap() error {
+	return e.Wraps
+}

beacon-chain/db/kv/error_test.go

@@ -0,0 +1,24 @@
+package kv
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestWrappedSentinelError(t *testing.T) {
+	e := ErrNotFoundOriginBlockRoot
+	if !errors.Is(e, ErrNotFoundOriginBlockRoot) {
+		t.Error("expected that a copy of ErrNotFoundOriginBlockRoot would have an is-a relationship")
+	}
+
+	outer := errors.New("wrapped error")
+	e2 := DBError{Wraps: ErrNotFoundOriginBlockRoot, Outer: outer}
+	if !errors.Is(e2, ErrNotFoundOriginBlockRoot) {
+		t.Error("expected that errors.Is would know DBError wraps ErrNotFoundOriginBlockRoot")
+	}
+
+	// test that the innermost not found error is detected
+	if !errors.Is(e2, ErrNotFound) {
+		t.Error("expected that errors.Is would know ErrNotFoundOriginBlockRoot wraps ErrNotFound")
+	}
+}

beacon-chain/db/kv/state.go

@@ -3,7 +3,6 @@ package kv
 import (
 	"bytes"
 	"context"
-	"fmt"
 
 	"github.com/golang/snappy"
 	"github.com/pkg/errors"
@@ -47,19 +46,6 @@ func (s *Store) State(ctx context.Context, blockRoot [32]byte) (state.BeaconStat
 	return s.unmarshalState(ctx, enc, valEntries)
 }
 
-// StateOrError is just like State(), except it only returns a non-error response
-// if the requested state is found in the database.
-func (s *Store) StateOrError(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error) {
-	st, err := s.State(ctx, blockRoot)
-	if err != nil {
-		return nil, err
-	}
-	if st == nil || st.IsNil() {
-		return nil, errors.Wrap(ErrNotFoundState, fmt.Sprintf("no state with blockroot=%#x", blockRoot))
-	}
-	return st, nil
-}
-
 // GenesisState returns the genesis state in beacon chain.
 func (s *Store) GenesisState(ctx context.Context) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.GenesisState")

beacon-chain/db/kv/state_test.go

@@ -21,12 +21,6 @@ import (
 	bolt "go.etcd.io/bbolt"
 )
 
-func TestStateNil(t *testing.T) {
-	db := setupDB(t)
-	_, err := db.StateOrError(context.Background(), [32]byte{})
-	require.ErrorIs(t, err, ErrNotFoundState)
-}
-
 func TestState_CanSaveRetrieve(t *testing.T) {
 	db := setupDB(t)
 

beacon-chain/db/kv/validated_tips.go

@@ -0,0 +1,71 @@
+package kv
+
+import (
+	"context"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
+)
+
+// ValidatedTips returns all the validated_tips that are present in the DB.
+func (s *Store) ValidatedTips(ctx context.Context) (map[[32]byte]types.Slot, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.ValidatedTips")
+	defer span.End()
+
+	valTips := make(map[[32]byte]types.Slot, 1)
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(validatedTips)
+
+		c := bkt.Cursor()
+		for k, v := c.First(); k != nil; k, v = c.Next() {
+			if ctx.Err() != nil {
+				return ctx.Err()
+			}
+			valTips[bytesutil.ToBytes32(k)] = bytesutil.BytesToSlotBigEndian(v)
+		}
+		return nil
+	})
+	return valTips, err
+}
+
+// UpdateValidatedTips clears off all the old validated_tips from the DB and
+// adds the new tips that are provided.
+func (s *Store) UpdateValidatedTips(ctx context.Context, newVals map[[32]byte]types.Slot) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.UpdateValidatedTips")
+	defer span.End()
+
+	// Get the already existing tips.
+	oldVals, err := s.ValidatedTips(ctx)
+	if err != nil {
+		return err
+	}
+
+	updateErr := s.db.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(validatedTips)
+
+		// Delete keys that are present and not in the new set.
+		for k := range oldVals {
+			if _, ok := newVals[k]; !ok {
+				deleteErr := bkt.Delete(k[:])
+				if deleteErr != nil {
+					return deleteErr
+				}
+
+			}
+		}
+
+		// Add keys not present already.
+		for k, v := range newVals {
+			if _, ok := oldVals[k]; !ok {
+				putErr := bkt.Put(k[:], bytesutil.SlotToBytesBigEndian(v))
+				if putErr != nil {
+					return putErr
+				}
+			}
+		}
+		return nil
+	})
+	return updateErr
+}

beacon-chain/db/kv/validated_tips_test.go

@@ -0,0 +1,93 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/testing/require"
+)
+
+func TestTips_AddNewTips(t *testing.T) {
+	ctx := context.Background()
+	db := setupDB(t)
+
+	newTips := make(map[[32]byte]types.Slot)
+	newTips[[32]byte{'A'}] = types.Slot(1)
+	newTips[[32]byte{'B'}] = types.Slot(2)
+	newTips[[32]byte{'C'}] = types.Slot(3)
+
+	require.NoError(t, db.UpdateValidatedTips(ctx, newTips))
+
+	gotTips, err := db.ValidatedTips(ctx)
+	require.NoError(t, err)
+
+	require.Equal(t, true, areTipsSame(gotTips, newTips))
+}
+
+func TestTips_UpdateTipsWithoutOverlap(t *testing.T) {
+	ctx := context.Background()
+	db := setupDB(t)
+
+	oldTips := make(map[[32]byte]types.Slot)
+	oldTips[[32]byte{'A'}] = types.Slot(1)
+	oldTips[[32]byte{'B'}] = types.Slot(2)
+	oldTips[[32]byte{'C'}] = types.Slot(3)
+
+	require.NoError(t, db.UpdateValidatedTips(ctx, oldTips))
+
+	// create a new non-overlapping tips to add
+	newTips := make(map[[32]byte]types.Slot)
+	newTips[[32]byte{'D'}] = types.Slot(4)
+	newTips[[32]byte{'E'}] = types.Slot(5)
+	newTips[[32]byte{'F'}] = types.Slot(6)
+
+	require.NoError(t, db.UpdateValidatedTips(ctx, newTips))
+
+	gotTips, err := db.ValidatedTips(ctx)
+	require.NoError(t, err)
+
+	require.Equal(t, true, areTipsSame(gotTips, newTips))
+
+}
+
+func TestTips_UpdateTipsWithOverlap(t *testing.T) {
+	ctx := context.Background()
+	db := setupDB(t)
+
+	oldTips := make(map[[32]byte]types.Slot)
+	oldTips[[32]byte{'A'}] = types.Slot(1)
+	oldTips[[32]byte{'B'}] = types.Slot(2)
+	oldTips[[32]byte{'C'}] = types.Slot(3)
+	require.NoError(t, db.UpdateValidatedTips(ctx, oldTips))
+
+	// create a new overlapping tips to add
+	newTips := make(map[[32]byte]types.Slot)
+	newTips[[32]byte{'C'}] = types.Slot(3)
+	newTips[[32]byte{'D'}] = types.Slot(4)
+	newTips[[32]byte{'E'}] = types.Slot(5)
+	require.NoError(t, db.UpdateValidatedTips(ctx, newTips))
+
+	gotTips, err := db.ValidatedTips(ctx)
+	require.NoError(t, err)
+
+	require.Equal(t, true, areTipsSame(gotTips, newTips))
+
+}
+
+func areTipsSame(got map[[32]byte]types.Slot, required map[[32]byte]types.Slot) bool {
+	if len(got) != len(required) {
+		return false
+	}
+
+	for k, v := range got {
+		if val, ok := required[k]; ok {
+			if uint64(v) != uint64(val) {
+				return false
+			}
+		} else {
+			return false
+		}
+	}
+	return true
+}

beacon-chain/forkchoice/BUILD.bazel

@@ -12,8 +12,7 @@ go_library(
         "//testing/spectest:__subpackages__",
     ],
     deps = [
-        "//config/fieldparams:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
+        "//beacon-chain/forkchoice/protoarray:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
     ],
 )

beacon-chain/forkchoice/doubly-linked-tree/BUILD.bazel

@@ -1,55 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "doc.go",
-        "errors.go",
-        "forkchoice.go",
-        "metrics.go",
-        "node.go",
-        "optimistic_sync.go",
-        "proposer_boost.go",
-        "store.go",
-        "types.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree",
-    visibility = [
-        "//beacon-chain:__subpackages__",
-        "//testing/spectest:__subpackages__",
-    ],
-    deps = [
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prometheus_client_golang//prometheus:go_default_library",
-        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
-        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "ffg_update_test.go",
-        "forkchoice_test.go",
-        "no_vote_test.go",
-        "node_test.go",
-        "optimistic_sync_test.go",
-        "proposer_boost_test.go",
-        "store_test.go",
-        "vote_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//config/params:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-    ],
-)

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

@@ -1,4 +0,0 @@
-/*
-Package doublylinkedtree implements eth2 LMD GHOST fork choice using the doubly linked proto array node structure.
-*/
-package doublylinkedtree

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

@@ -1,10 +0,0 @@
-package doublylinkedtree
-
-import "errors"
-
-var errNilNode = errors.New("invalid nil or unknown node")
-var errInvalidBalance = errors.New("invalid node balance")
-var errInvalidProposerBoostRoot = errors.New("invalid proposer boost root")
-var errUnknownFinalizedRoot = errors.New("unknown finalized root")
-var errUnknownJustifiedRoot = errors.New("unknown justified root")
-var errInvalidOptimisticStatus = errors.New("invalid optimistic status")

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

@@ -1,193 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestFFGUpdates_OneBranch(t *testing.T) {
-	balances := []uint64{1, 1}
-	f := setup(0, 0)
-
-	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), 0, params.BeaconConfig().ZeroHash, balances, 0)
-	require.NoError(t, err)
-	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
-
-	// Define the following tree:
-	//            0 <- justified: 0, finalized: 0
-	//            |
-	//            1 <- justified: 0, finalized: 0
-	//            |
-	//            2 <- justified: 1, finalized: 0
-	//            |
-	//            3 <- justified: 2, finalized: 1
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(2), indexToHash(1), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(3), indexToHash(2), 2, 1, false))
-
-	// With starting justified epoch at 0, the head should be 3:
-	//            0 <- start
-	//            |
-	//            1
-	//            |
-	//            2
-	//            |
-	//            3 <- head
-	r, err = f.Head(context.Background(), 0, params.BeaconConfig().ZeroHash, balances, 0)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(3), r, "Incorrect head for with justified epoch at 0")
-
-	// With starting justified epoch at 1, the head should be 2:
-	//            0
-	//            |
-	//            1 <- start
-	//            |
-	//            2 <- head
-	//            |
-	//            3
-	r, err = f.Head(context.Background(), 1, indexToHash(2), balances, 0)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(2), r, "Incorrect head with justified epoch at 1")
-
-	// With starting justified epoch at 2, the head should be 3:
-	//            0
-	//            |
-	//            1
-	//            |
-	//            2 <- start
-	//            |
-	//            3 <- head
-	r, err = f.Head(context.Background(), 2, indexToHash(3), balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(3), r, "Incorrect head with justified epoch at 2")
-}
-
-func TestFFGUpdates_TwoBranches(t *testing.T) {
-	balances := []uint64{1, 1}
-	f := setup(0, 0)
-
-	r, err := f.Head(context.Background(), 0, params.BeaconConfig().ZeroHash, balances, 0)
-	require.NoError(t, err)
-	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
-
-	// Define the following tree:
-	//                                0
-	//                               / \
-	//  justified: 0, finalized: 0 -> 1   2 <- justified: 0, finalized: 0
-	//                              |   |
-	//  justified: 1, finalized: 0 -> 3   4 <- justified: 0, finalized: 0
-	//                              |   |
-	//  justified: 1, finalized: 0 -> 5   6 <- justified: 0, finalized: 0
-	//                              |   |
-	//  justified: 1, finalized: 0 -> 7   8 <- justified: 1, finalized: 0
-	//                              |   |
-	//  justified: 2, finalized: 0 -> 9  10 <- justified: 2, finalized: 0
-	// Left branch.
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(3), indexToHash(1), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(5), indexToHash(3), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(7), indexToHash(5), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(9), indexToHash(7), 2, 0, false))
-	// Right branch.
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(4), indexToHash(2), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(6), indexToHash(4), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(8), indexToHash(6), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(10), indexToHash(8), 2, 0, false))
-
-	// With start at 0, the head should be 10:
-	//           0  <-- start
-	//          / \
-	//         1   2
-	//         |   |
-	//         3   4
-	//         |   |
-	//         5   6
-	//         |   |
-	//         7   8
-	//         |   |
-	//         9  10 <-- head
-	r, err = f.Head(context.Background(), 0, params.BeaconConfig().ZeroHash, balances, 0)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(10), r, "Incorrect head with justified epoch at 0")
-
-	// Add a vote to 1:
-	//                 0
-	//                / \
-	//    +1 vote -> 1   2
-	//               |   |
-	//               3   4
-	//               |   |
-	//               5   6
-	//               |   |
-	//               7   8
-	//               |   |
-	//               9  10
-	f.ProcessAttestation(context.Background(), []uint64{0}, indexToHash(1), 0)
-
-	// With the additional vote to the left branch, the head should be 9:
-	//           0  <-- start
-	//          / \
-	//         1   2
-	//         |   |
-	//         3   4
-	//         |   |
-	//         5   6
-	//         |   |
-	//         7   8
-	//         |   |
-	// head -> 9  10
-	r, err = f.Head(context.Background(), 0, params.BeaconConfig().ZeroHash, balances, 0)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(9), r, "Incorrect head with justified epoch at 0")
-
-	// Add a vote to 2:
-	//                 0
-	//                / \
-	//               1   2 <- +1 vote
-	//               |   |
-	//               3   4
-	//               |   |
-	//               5   6
-	//               |   |
-	//               7   8
-	//               |   |
-	//               9  10
-	f.ProcessAttestation(context.Background(), []uint64{1}, indexToHash(2), 0)
-
-	// With the additional vote to the right branch, the head should be 10:
-	//           0  <-- start
-	//          / \
-	//         1   2
-	//         |   |
-	//         3   4
-	//         |   |
-	//         5   6
-	//         |   |
-	//         7   8
-	//         |   |
-	//         9  10 <-- head
-	r, err = f.Head(context.Background(), 0, params.BeaconConfig().ZeroHash, balances, 0)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(10), r, "Incorrect head with justified epoch at 0")
-
-	r, err = f.Head(context.Background(), 1, indexToHash(1), balances, 0)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(7), r, "Incorrect head with justified epoch at 0")
-}
-
-func setup(justifiedEpoch, finalizedEpoch types.Epoch) *ForkChoice {
-	ctx := context.Background()
-	f := New(justifiedEpoch, finalizedEpoch)
-	err := f.ProcessBlock(ctx, 0, params.BeaconConfig().ZeroHash, [32]byte{}, justifiedEpoch, finalizedEpoch, false)
-	if err != nil {
-		return nil
-	}
-	return f
-}

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

@@ -1,307 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/config/params"
-	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"go.opencensus.io/trace"
-)
-
-// New initializes a new fork choice store.
-func New(justifiedEpoch, finalizedEpoch types.Epoch) *ForkChoice {
-	s := &Store{
-		justifiedEpoch:    justifiedEpoch,
-		finalizedEpoch:    finalizedEpoch,
-		proposerBoostRoot: [32]byte{},
-		nodeByRoot:        make(map[[fieldparams.RootLength]byte]*Node),
-		pruneThreshold:    defaultPruneThreshold,
-	}
-
-	b := make([]uint64, 0)
-	v := make([]Vote, 0)
-	return &ForkChoice{store: s, balances: b, votes: v}
-}
-
-// NodeCount returns the current number of nodes in the Store.
-func (f *ForkChoice) NodeCount() int {
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-	return len(f.store.nodeByRoot)
-}
-
-// Head returns the head root from fork choice store.
-// It firsts computes validator's balance changes then recalculates block tree from leaves to root.
-func (f *ForkChoice) Head(
-	ctx context.Context,
-	justifiedEpoch types.Epoch,
-	justifiedRoot [32]byte,
-	justifiedStateBalances []uint64,
-	finalizedEpoch types.Epoch,
-) ([32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.Head")
-	defer span.End()
-	f.votesLock.Lock()
-	defer f.votesLock.Unlock()
-
-	calledHeadCount.Inc()
-
-	// Using the write lock here because `applyWeightChanges` that gets called subsequently requires a write operation.
-	f.store.nodesLock.Lock()
-	defer f.store.nodesLock.Unlock()
-
-	f.store.updateCheckpoints(justifiedEpoch, finalizedEpoch)
-
-	if err := f.updateBalances(justifiedStateBalances); err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not update balances")
-	}
-
-	if err := f.store.applyProposerBoostScore(justifiedStateBalances); err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not apply proposer boost score")
-	}
-
-	if err := f.store.treeRootNode.applyWeightChanges(ctx); err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not apply weight changes")
-	}
-
-	if err := f.store.treeRootNode.updateBestDescendant(ctx, justifiedEpoch, finalizedEpoch); err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not update best descendant")
-	}
-
-	return f.store.head(ctx, justifiedRoot)
-}
-
-// ProcessAttestation processes attestation for vote accounting, it iterates around validator indices
-// and update their votes accordingly.
-func (f *ForkChoice) ProcessAttestation(ctx context.Context, validatorIndices []uint64, blockRoot [32]byte, targetEpoch types.Epoch) {
-	_, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.ProcessAttestation")
-	defer span.End()
-	f.votesLock.Lock()
-	defer f.votesLock.Unlock()
-
-	for _, index := range validatorIndices {
-		// Validator indices will grow the vote cache.
-		for index >= uint64(len(f.votes)) {
-			f.votes = append(f.votes, Vote{currentRoot: params.BeaconConfig().ZeroHash, nextRoot: params.BeaconConfig().ZeroHash})
-		}
-
-		// Newly allocated vote if the root fields are untouched.
-		newVote := f.votes[index].nextRoot == params.BeaconConfig().ZeroHash &&
-			f.votes[index].currentRoot == params.BeaconConfig().ZeroHash
-
-		// Vote gets updated if it's newly allocated or high target epoch.
-		if newVote || targetEpoch > f.votes[index].nextEpoch {
-			f.votes[index].nextEpoch = targetEpoch
-			f.votes[index].nextRoot = blockRoot
-		}
-	}
-
-	processedAttestationCount.Inc()
-}
-
-// ProcessBlock processes a new block by inserting it to the fork choice store.
-func (f *ForkChoice) ProcessBlock(
-	ctx context.Context,
-	slot types.Slot,
-	blockRoot, parentRoot [fieldparams.RootLength]byte,
-	justifiedEpoch, finalizedEpoch types.Epoch, optimistic bool,
-) error {
-	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.ProcessBlock")
-	defer span.End()
-
-	return f.store.insert(ctx, slot, blockRoot, parentRoot, justifiedEpoch, finalizedEpoch, optimistic)
-}
-
-// Prune prunes the fork choice store with the new finalized root. The store is only pruned if the input
-// root is different than the current store finalized root, and the number of the store has met prune threshold.
-func (f *ForkChoice) Prune(ctx context.Context, finalizedRoot [32]byte) error {
-	return f.store.prune(ctx, finalizedRoot)
-}
-
-// HasNode returns true if the node exists in fork choice store,
-// false else wise.
-func (f *ForkChoice) HasNode(root [32]byte) bool {
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-
-	_, ok := f.store.nodeByRoot[root]
-	return ok
-}
-
-// HasParent returns true if the node parent exists in fork choice store,
-// false else wise.
-func (f *ForkChoice) HasParent(root [32]byte) bool {
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
-		return false
-	}
-
-	return node.parent != nil
-}
-
-// IsCanonical returns true if the given root is part of the canonical chain.
-func (f *ForkChoice) IsCanonical(root [32]byte) bool {
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
-		return false
-	}
-
-	if node.bestDescendant == nil {
-		if f.store.headNode.bestDescendant == nil {
-			return node == f.store.headNode
-		}
-		return node == f.store.headNode.bestDescendant
-	}
-	if f.store.headNode.bestDescendant == nil {
-		return node.bestDescendant == f.store.headNode
-	}
-	return node.bestDescendant == f.store.headNode.bestDescendant
-}
-
-// IsOptimistic returns true if the given root has been optimistically synced.
-func (f *ForkChoice) IsOptimistic(_ context.Context, root [32]byte) (bool, error) {
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
-		return false, errNilNode
-	}
-
-	return node.optimistic, nil
-}
-
-// AncestorRoot returns the ancestor root of input block root at a given slot.
-func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot types.Slot) ([]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "protoArray.AncestorRoot")
-	defer span.End()
-
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
-		return nil, errNilNode
-	}
-
-	n := node
-	for n != nil && n.slot > slot {
-		if ctx.Err() != nil {
-			return nil, ctx.Err()
-		}
-		n = n.parent
-	}
-
-	if n == nil {
-		return nil, errNilNode
-	}
-
-	return n.root[:], nil
-}
-
-// updateBalances updates the balances that directly voted for each block taking into account the
-// validators' latest votes.
-func (f *ForkChoice) updateBalances(newBalances []uint64) error {
-	for index, vote := range f.votes {
-		// Skip if validator has never voted for current root and next root (i.e. if the
-		// votes are zero hash aka genesis block), there's nothing to compute.
-		if vote.currentRoot == params.BeaconConfig().ZeroHash && vote.nextRoot == params.BeaconConfig().ZeroHash {
-			continue
-		}
-
-		oldBalance := uint64(0)
-		newBalance := uint64(0)
-		// If the validator index did not exist in `f.balances` or
-		// `newBalances` list above, the balance is just 0.
-		if index < len(f.balances) {
-			oldBalance = f.balances[index]
-		}
-		if index < len(newBalances) {
-			newBalance = newBalances[index]
-		}
-
-		// Update only if the validator's balance or vote has changed.
-		if vote.currentRoot != vote.nextRoot || oldBalance != newBalance {
-			// Ignore the vote if the root is not in fork choice
-			// store, that means we have not seen the block before.
-			nextNode, ok := f.store.nodeByRoot[vote.nextRoot]
-			if ok && vote.nextRoot != params.BeaconConfig().ZeroHash {
-				// Protection against nil node
-				if nextNode == nil {
-					return errNilNode
-				}
-				nextNode.balance += newBalance
-			}
-
-			currentNode, ok := f.store.nodeByRoot[vote.currentRoot]
-			if ok && vote.currentRoot != params.BeaconConfig().ZeroHash {
-				// Protection against nil node
-				if currentNode == nil {
-					return errNilNode
-				}
-				if currentNode.balance < oldBalance {
-					return errInvalidBalance
-				}
-				currentNode.balance -= oldBalance
-			}
-		}
-
-		// Rotate the validator vote.
-		f.votes[index].currentRoot = vote.nextRoot
-	}
-	f.balances = newBalances
-	return nil
-}
-
-// Tips returns a list of possible heads from fork choice store, it returns the
-// roots and the slots of the leaf nodes.
-func (f *ForkChoice) Tips() ([][32]byte, []types.Slot) {
-	return f.store.tips()
-}
-
-// ProposerBoost returns the proposerBoost of the store
-func (f *ForkChoice) ProposerBoost() [fieldparams.RootLength]byte {
-	return f.store.proposerBoost()
-}
-
-// SetOptimisticToValid sets the node with the given root as a fully validated node
-func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [fieldparams.RootLength]byte) error {
-	f.store.nodesLock.Lock()
-	defer f.store.nodesLock.Unlock()
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
-		return errNilNode
-	}
-	return node.setNodeAndParentValidated(ctx)
-}
-
-// JustifiedEpoch of fork choice store.
-func (f *ForkChoice) JustifiedEpoch() types.Epoch {
-	return f.store.justifiedEpoch
-}
-
-// FinalizedEpoch of fork choice store.
-func (f *ForkChoice) FinalizedEpoch() types.Epoch {
-	return f.store.finalizedEpoch
-}
-
-func (f *ForkChoice) ForkChoiceNodes() []*pbrpc.ForkChoiceNode {
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-	ret := make([]*pbrpc.ForkChoiceNode, len(f.store.nodeByRoot))
-	return f.store.treeRootNode.rpcNodes(ret)
-}
-
-// SetOptimisticToInvalid removes a block with an invalid execution payload from fork choice store
-func (f *ForkChoice) SetOptimisticToInvalid(ctx context.Context, root [fieldparams.RootLength]byte) error {
-	return f.store.removeNode(ctx, root)
-}

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

@@ -1,168 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"encoding/binary"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/hash"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) {
-	f := setup(0, 0)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), indexToHash(1), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, indexToHash(3), indexToHash(2), 0, 0, false))
-
-	f.votes = []Vote{
-		{indexToHash(1), indexToHash(1), 0},
-		{indexToHash(2), indexToHash(2), 0},
-		{indexToHash(3), indexToHash(3), 0},
-	}
-
-	// Each node gets one unique vote. The weight should look like 103 <- 102 <- 101 because
-	// they get propagated back.
-	require.NoError(t, f.updateBalances([]uint64{10, 20, 30}))
-	s := f.store
-	assert.Equal(t, uint64(10), s.nodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.nodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.nodeByRoot[indexToHash(3)].balance)
-}
-
-func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
-	f := setup(0, 0)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), indexToHash(1), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, indexToHash(3), indexToHash(2), 0, 0, false))
-	s := f.store
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
-
-	f.balances = []uint64{100, 100, 100}
-	f.votes = []Vote{
-		{indexToHash(1), indexToHash(1), 0},
-		{indexToHash(2), indexToHash(2), 0},
-		{indexToHash(3), indexToHash(3), 0},
-	}
-
-	require.NoError(t, f.updateBalances([]uint64{10, 20, 30}))
-	assert.Equal(t, uint64(10), s.nodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.nodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.nodeByRoot[indexToHash(3)].balance)
-}
-
-func TestForkChoice_IsCanonical(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, indexToHash(3), indexToHash(1), 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 4, indexToHash(4), indexToHash(2), 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 5, indexToHash(5), indexToHash(4), 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 6, indexToHash(6), indexToHash(5), 1, 1, false))
-
-	require.Equal(t, true, f.IsCanonical(params.BeaconConfig().ZeroHash))
-	require.Equal(t, false, f.IsCanonical(indexToHash(1)))
-	require.Equal(t, true, f.IsCanonical(indexToHash(2)))
-	require.Equal(t, false, f.IsCanonical(indexToHash(3)))
-	require.Equal(t, true, f.IsCanonical(indexToHash(4)))
-	require.Equal(t, true, f.IsCanonical(indexToHash(5)))
-	require.Equal(t, true, f.IsCanonical(indexToHash(6)))
-}
-
-func TestForkChoice_IsCanonicalReorg(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, [32]byte{'2'}, params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, [32]byte{'3'}, [32]byte{'1'}, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 4, [32]byte{'4'}, [32]byte{'2'}, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 5, [32]byte{'5'}, [32]byte{'4'}, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 6, [32]byte{'6'}, [32]byte{'5'}, 1, 1, false))
-
-	f.store.nodesLock.Lock()
-	f.store.nodeByRoot[[32]byte{'3'}].balance = 10
-	require.NoError(t, f.store.treeRootNode.applyWeightChanges(ctx))
-	require.Equal(t, uint64(10), f.store.nodeByRoot[[32]byte{'1'}].weight)
-	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'2'}].weight)
-
-	require.NoError(t, f.store.treeRootNode.updateBestDescendant(ctx, 1, 1))
-	require.DeepEqual(t, [32]byte{'3'}, f.store.treeRootNode.bestDescendant.root)
-	f.store.nodesLock.Unlock()
-
-	h, err := f.store.head(ctx, [32]byte{'1'})
-	require.NoError(t, err)
-	require.DeepEqual(t, [32]byte{'3'}, h)
-	require.DeepEqual(t, h, f.store.headNode.root)
-
-	require.Equal(t, true, f.IsCanonical(params.BeaconConfig().ZeroHash))
-	require.Equal(t, true, f.IsCanonical([32]byte{'1'}))
-	require.Equal(t, false, f.IsCanonical([32]byte{'2'}))
-	require.Equal(t, true, f.IsCanonical([32]byte{'3'}))
-	require.Equal(t, false, f.IsCanonical([32]byte{'4'}))
-	require.Equal(t, false, f.IsCanonical([32]byte{'5'}))
-	require.Equal(t, false, f.IsCanonical([32]byte{'6'}))
-}
-
-func TestForkChoice_AncestorRoot(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), indexToHash(1), 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 5, indexToHash(3), indexToHash(2), 1, 1, false))
-	f.store.treeRootNode = f.store.nodeByRoot[indexToHash(1)]
-	f.store.treeRootNode.parent = nil
-
-	r, err := f.AncestorRoot(ctx, indexToHash(3), 6)
-	assert.NoError(t, err)
-	assert.Equal(t, bytesutil.ToBytes32(r), indexToHash(3))
-
-	_, err = f.AncestorRoot(ctx, indexToHash(3), 0)
-	assert.ErrorContains(t, errNilNode.Error(), err)
-
-	root, err := f.AncestorRoot(ctx, indexToHash(3), 5)
-	require.NoError(t, err)
-	hash3 := indexToHash(3)
-	require.DeepEqual(t, hash3[:], root)
-	root, err = f.AncestorRoot(ctx, indexToHash(3), 1)
-	require.NoError(t, err)
-	hash1 := indexToHash(1)
-	require.DeepEqual(t, hash1[:], root)
-}
-
-func TestForkChoice_AncestorEqualSlot(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'3'}, [32]byte{'1'}, 1, 1, false))
-
-	r, err := f.AncestorRoot(ctx, [32]byte{'3'}, 100)
-	require.NoError(t, err)
-	root := bytesutil.ToBytes32(r)
-	require.Equal(t, root, [32]byte{'1'})
-}
-
-func TestForkChoice_AncestorLowerSlot(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 200, [32]byte{'3'}, [32]byte{'1'}, 1, 1, false))
-
-	r, err := f.AncestorRoot(ctx, [32]byte{'3'}, 150)
-	require.NoError(t, err)
-	root := bytesutil.ToBytes32(r)
-	require.Equal(t, root, [32]byte{'1'})
-}
-
-func indexToHash(i uint64) [32]byte {
-	var b [8]byte
-	binary.LittleEndian.PutUint64(b[:], i)
-	return hash.Hash(b[:])
-}

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

@@ -1,57 +0,0 @@
-package doublylinkedtree
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-var (
-	headSlotNumber = promauto.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "doublylinkedtree_head_slot",
-			Help: "The slot number of the current head.",
-		},
-	)
-	nodeCount = promauto.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "doublylinkedtree_node_count",
-			Help: "The number of nodes in the DAG array based store structure.",
-		},
-	)
-	headChangesCount = promauto.NewCounter(
-		prometheus.CounterOpts{
-			Name: "doublylinkedtree_head_changed_count",
-			Help: "The number of times head changes.",
-		},
-	)
-	calledHeadCount = promauto.NewCounter(
-		prometheus.CounterOpts{
-			Name: "doublylinkedtree_head_requested_count",
-			Help: "The number of times someone called head.",
-		},
-	)
-	processedBlockCount = promauto.NewCounter(
-		prometheus.CounterOpts{
-			Name: "doublylinkedtree_block_processed_count",
-			Help: "The number of times a block is processed for fork choice.",
-		},
-	)
-	processedAttestationCount = promauto.NewCounter(
-		prometheus.CounterOpts{
-			Name: "doublylinkedtree_attestation_processed_count",
-			Help: "The number of times an attestation is processed for fork choice.",
-		},
-	)
-	prunedCount = promauto.NewCounter(
-		prometheus.CounterOpts{
-			Name: "doublylinkedtree_pruned_count",
-			Help: "The number of times pruning happened.",
-		},
-	)
-	optimisticCount = promauto.NewCounter(
-		prometheus.CounterOpts{
-			Name: "doublylinkedtree_optimistic_count",
-			Help: "The number of blocks that have been optimistically synced.",
-		},
-	)
-)

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

@@ -1,114 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestNoVote_CanFindHead(t *testing.T) {
-	balances := make([]uint64, 16)
-	f := setup(1, 1)
-
-	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	if r != params.BeaconConfig().ZeroHash {
-		t.Errorf("Incorrect head with genesis")
-	}
-
-	// Insert block 2 into the tree and verify head is at 2:
-	//         0
-	//        /
-	//       2 <- head
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1, false))
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
-
-	// Insert block 1 into the tree and verify head is still at 2:
-	//            0
-	//           / \
-	//  head -> 2  1
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
-
-	// Insert block 3 into the tree and verify head is still at 2:
-	//            0
-	//           / \
-	//  head -> 2  1
-	//             |
-	//             3
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(3), indexToHash(1), 1, 1, false))
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
-
-	// Insert block 4 into the tree and verify head is at 4:
-	//            0
-	//           / \
-	//          2  1
-	//          |  |
-	//  head -> 4  3
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(4), indexToHash(2), 1, 1, false))
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
-
-	// Insert block 5 with justified epoch of 2, verify head is still at 4.
-	//            0
-	//           / \
-	//          2  1
-	//          |  |
-	//  head -> 4  3
-	//          |
-	//          5 <- justified epoch = 2
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(5), indexToHash(4), 2, 1, false))
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
-
-	// Verify there's an error when starting from a block with wrong justified epoch.
-	//            0
-	//           / \
-	//          2  1
-	//          |  |
-	//  head -> 4  3
-	//          |
-	//          5 <- starting from 5 with justified epoch 0 should error
-	_, err = f.Head(context.Background(), 1, indexToHash(5), balances, 1)
-	wanted := "head at slot 0 with weight 0 is not eligible, finalizedEpoch 1 != 1, justifiedEpoch 2 != 1"
-	require.ErrorContains(t, wanted, err)
-
-	// Set the justified epoch to 2 and start block to 5 to verify head is 5.
-	//            0
-	//           / \
-	//          2  1
-	//          |  |
-	//          4  3
-	//          |
-	//          5 <- head
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(5), r, "Incorrect head for with justified epoch at 2")
-
-	// Insert block 6 with justified epoch of 2, verify head is at 6.
-	//            0
-	//           / \
-	//          2  1
-	//          |  |
-	//          4  3
-	//          |
-	//          5
-	//          |
-	//          6 <- head
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(6), indexToHash(5), 2, 1, false))
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 2")
-}

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

@@ -1,152 +0,0 @@
-package doublylinkedtree
-
-import (
-	"bytes"
-	"context"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-// depth returns the length of the path to the root of Fork Choice
-func (n *Node) depth() uint64 {
-	ret := uint64(0)
-	for node := n.parent; node != nil; node = node.parent {
-		ret += 1
-	}
-	return ret
-}
-
-// applyWeightChanges recomputes the weight of the node passed as an argument and all of its descendants,
-// using the current balance stored in each node. This function requires a lock
-// in Store.nodesLock
-func (n *Node) applyWeightChanges(ctx context.Context) error {
-	// Recursively calling the children to sum their weights.
-	childrenWeight := uint64(0)
-	for _, child := range n.children {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		if err := child.applyWeightChanges(ctx); err != nil {
-			return err
-		}
-		childrenWeight += child.weight
-	}
-	if n.root == params.BeaconConfig().ZeroHash {
-		return nil
-	}
-	n.weight = n.balance + childrenWeight
-	return nil
-}
-
-// updateBestDescendant updates the best descendant of this node and its children.
-func (n *Node) updateBestDescendant(ctx context.Context, justifiedEpoch, finalizedEpoch types.Epoch) error {
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-	if len(n.children) == 0 {
-		n.bestDescendant = nil
-		return nil
-	}
-
-	var bestChild *Node
-	bestWeight := uint64(0)
-	hasViableDescendant := false
-	for _, child := range n.children {
-		if child == nil {
-			return errNilNode
-		}
-		if err := child.updateBestDescendant(ctx, justifiedEpoch, finalizedEpoch); err != nil {
-			return err
-		}
-		childLeadsToViableHead := child.leadsToViableHead(justifiedEpoch, finalizedEpoch)
-		if childLeadsToViableHead && !hasViableDescendant {
-			// The child leads to a viable head, but the current
-			// parent's best child doesn't.
-			bestWeight = child.weight
-			bestChild = child
-			hasViableDescendant = true
-		} else if childLeadsToViableHead {
-			// If both are viable, compare their weights.
-			if child.weight == bestWeight {
-				// Tie-breaker of equal weights by root.
-				if bytes.Compare(child.root[:], bestChild.root[:]) > 0 {
-					bestChild = child
-				}
-			} else if child.weight > bestWeight {
-				bestChild = child
-				bestWeight = child.weight
-			}
-		}
-	}
-	if hasViableDescendant {
-		if bestChild.bestDescendant == nil {
-			n.bestDescendant = bestChild
-		} else {
-			n.bestDescendant = bestChild.bestDescendant
-		}
-	} else {
-		n.bestDescendant = nil
-	}
-	return nil
-}
-
-// viableForHead returns true if the node is viable to head.
-// Any node with different finalized or justified epoch than
-// the ones in fork choice store should not be viable to head.
-func (n *Node) viableForHead(justifiedEpoch, finalizedEpoch types.Epoch) bool {
-	justified := justifiedEpoch == n.justifiedEpoch || justifiedEpoch == 0
-	finalized := finalizedEpoch == n.finalizedEpoch || finalizedEpoch == 0
-
-	return justified && finalized
-}
-
-func (n *Node) leadsToViableHead(justifiedEpoch, finalizedEpoch types.Epoch) bool {
-	if n.bestDescendant == nil {
-		return n.viableForHead(justifiedEpoch, finalizedEpoch)
-	}
-	return n.bestDescendant.viableForHead(justifiedEpoch, finalizedEpoch)
-}
-
-// setNodeAndParentValidated sets the current node and the parent as validated (i.e. non-optimistic).
-func (n *Node) setNodeAndParentValidated(ctx context.Context) error {
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-
-	if !n.optimistic || n.parent == nil {
-		return nil
-	}
-
-	n.optimistic = false
-	return n.parent.setNodeAndParentValidated(ctx)
-}
-
-// rpcNodes is used by the RPC Debug endpoint to return information
-// about all nodes in the fork choice store
-func (n *Node) rpcNodes(ret []*pbrpc.ForkChoiceNode) []*pbrpc.ForkChoiceNode {
-	for _, child := range n.children {
-		ret = child.rpcNodes(ret)
-	}
-	r := n.root
-	p := [32]byte{}
-	if n.parent != nil {
-		copy(p[:], n.parent.root[:])
-	}
-	b := [32]byte{}
-	if n.bestDescendant != nil {
-		copy(b[:], n.bestDescendant.root[:])
-	}
-	node := &pbrpc.ForkChoiceNode{
-		Slot:           n.slot,
-		Root:           r[:],
-		Parent:         p[:],
-		JustifiedEpoch: n.justifiedEpoch,
-		FinalizedEpoch: n.finalizedEpoch,
-		Weight:         n.weight,
-		BestDescendant: b[:],
-	}
-	ret = append(ret, node)
-	return ret
-}

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

@@ -1,204 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestNode_ApplyWeightChanges_PositiveChange(t *testing.T) {
-	f := setup(0, 0)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), indexToHash(1), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, indexToHash(3), indexToHash(2), 0, 0, false))
-
-	// The updated balances of each node is 100
-	s := f.store
-
-	s.nodesLock.Lock()
-	defer s.nodesLock.Unlock()
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
-
-	assert.NoError(t, s.treeRootNode.applyWeightChanges(ctx))
-
-	assert.Equal(t, uint64(300), s.nodeByRoot[indexToHash(1)].weight)
-	assert.Equal(t, uint64(200), s.nodeByRoot[indexToHash(2)].weight)
-	assert.Equal(t, uint64(100), s.nodeByRoot[indexToHash(3)].weight)
-}
-
-func TestNode_ApplyWeightChanges_NegativeChange(t *testing.T) {
-	f := setup(0, 0)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), indexToHash(1), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, indexToHash(3), indexToHash(2), 0, 0, false))
-
-	// The updated balances of each node is 100
-	s := f.store
-	s.nodesLock.Lock()
-	defer s.nodesLock.Unlock()
-	s.nodeByRoot[indexToHash(1)].weight = 400
-	s.nodeByRoot[indexToHash(2)].weight = 400
-	s.nodeByRoot[indexToHash(3)].weight = 400
-
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
-
-	assert.NoError(t, s.treeRootNode.applyWeightChanges(ctx))
-
-	assert.Equal(t, uint64(300), s.nodeByRoot[indexToHash(1)].weight)
-	assert.Equal(t, uint64(200), s.nodeByRoot[indexToHash(2)].weight)
-	assert.Equal(t, uint64(100), s.nodeByRoot[indexToHash(3)].weight)
-}
-
-func TestNode_UpdateBestDescendant_NonViableChild(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	// Input child is not viable.
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 2, 3, false))
-
-	// Verify parent's best child and best descendant are `none`.
-	s := f.store
-	assert.Equal(t, 1, len(s.treeRootNode.children))
-	nilBestDescendant := s.treeRootNode.bestDescendant == nil
-	assert.Equal(t, true, nilBestDescendant)
-}
-
-func TestNode_UpdateBestDescendant_ViableChild(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	// Input child is best descendant
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-
-	s := f.store
-	assert.Equal(t, 1, len(s.treeRootNode.children))
-	assert.Equal(t, s.treeRootNode.children[0], s.treeRootNode.bestDescendant)
-}
-
-func TestNode_UpdateBestDescendant_HigherWeightChild(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	// Input child is best descendant
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1, false))
-
-	s := f.store
-	s.nodeByRoot[indexToHash(1)].weight = 100
-	s.nodeByRoot[indexToHash(2)].weight = 200
-	assert.NoError(t, s.treeRootNode.updateBestDescendant(ctx, 1, 1))
-
-	assert.Equal(t, 2, len(s.treeRootNode.children))
-	assert.Equal(t, s.treeRootNode.children[1], s.treeRootNode.bestDescendant)
-}
-
-func TestNode_UpdateBestDescendant_LowerWeightChild(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	// Input child is best descendant
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1, false))
-
-	s := f.store
-	s.nodeByRoot[indexToHash(1)].weight = 200
-	s.nodeByRoot[indexToHash(2)].weight = 100
-	assert.NoError(t, s.treeRootNode.updateBestDescendant(ctx, 1, 1))
-
-	assert.Equal(t, 2, len(s.treeRootNode.children))
-	assert.Equal(t, s.treeRootNode.children[0], s.treeRootNode.bestDescendant)
-}
-
-func TestNode_TestDepth(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	// Input child is best descendant
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), indexToHash(1), 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, indexToHash(3), params.BeaconConfig().ZeroHash, 1, 1, false))
-
-	s := f.store
-	require.Equal(t, s.nodeByRoot[indexToHash(2)].depth(), uint64(2))
-	require.Equal(t, s.nodeByRoot[indexToHash(3)].depth(), uint64(1))
-}
-
-func TestNode_ViableForHead(t *testing.T) {
-	tests := []struct {
-		n              *Node
-		justifiedEpoch types.Epoch
-		finalizedEpoch types.Epoch
-		want           bool
-	}{
-		{&Node{}, 0, 0, true},
-		{&Node{}, 1, 0, false},
-		{&Node{}, 0, 1, false},
-		{&Node{finalizedEpoch: 1, justifiedEpoch: 1}, 1, 1, true},
-		{&Node{finalizedEpoch: 1, justifiedEpoch: 1}, 2, 2, false},
-		{&Node{finalizedEpoch: 3, justifiedEpoch: 4}, 4, 3, true},
-	}
-	for _, tc := range tests {
-		got := tc.n.viableForHead(tc.justifiedEpoch, tc.finalizedEpoch)
-		assert.Equal(t, tc.want, got)
-	}
-}
-
-func TestNode_LeadsToViableHead(t *testing.T) {
-	f := setup(4, 3)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, indexToHash(3), indexToHash(1), 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 4, indexToHash(4), indexToHash(2), 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 5, indexToHash(5), indexToHash(3), 4, 3, false))
-
-	require.Equal(t, true, f.store.treeRootNode.leadsToViableHead(4, 3))
-	require.Equal(t, true, f.store.nodeByRoot[indexToHash(5)].leadsToViableHead(4, 3))
-	require.Equal(t, false, f.store.nodeByRoot[indexToHash(2)].leadsToViableHead(4, 3))
-	require.Equal(t, false, f.store.nodeByRoot[indexToHash(4)].leadsToViableHead(4, 3))
-}
-
-func TestNode_SetFullyValidated(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	// insert blocks in the fork pattern (optimistic status in parenthesis)
-	//
-	// 0 (false) -- 1 (false) -- 2 (false) -- 3 (true) -- 4 (true)
-	//               \
-	//                 -- 5 (true)
-	//
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), indexToHash(1), 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, indexToHash(3), indexToHash(2), 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 4, indexToHash(4), indexToHash(3), 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 5, indexToHash(5), indexToHash(1), 1, 1, true))
-
-	opt, err := f.IsOptimistic(ctx, indexToHash(5))
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-
-	opt, err = f.IsOptimistic(ctx, indexToHash(4))
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-
-	require.NoError(t, f.store.nodeByRoot[indexToHash(4)].setNodeAndParentValidated(ctx))
-
-	// block 5 should still be optimistic
-	opt, err = f.IsOptimistic(ctx, indexToHash(5))
-	require.NoError(t, err)
-	require.Equal(t, true, opt)
-
-	// block 4 and 3 should now be valid
-	opt, err = f.IsOptimistic(ctx, indexToHash(4))
-	require.NoError(t, err)
-	require.Equal(t, false, opt)
-
-	opt, err = f.IsOptimistic(ctx, indexToHash(3))
-	require.NoError(t, err)
-	require.Equal(t, false, opt)
-}

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

@@ -1,50 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-)
-
-// removeNode removes the node with the given root and all of its children
-// from the Fork Choice Store.
-func (s *Store) removeNode(ctx context.Context, root [32]byte) error {
-	s.nodesLock.Lock()
-	defer s.nodesLock.Unlock()
-
-	node, ok := s.nodeByRoot[root]
-	if !ok || node == nil {
-		return errNilNode
-	}
-	if !node.optimistic || node.parent == nil {
-		return errInvalidOptimisticStatus
-	}
-	children := node.parent.children
-	if len(children) == 1 {
-		node.parent.children = []*Node{}
-	} else {
-		for i, n := range children {
-			if n == node {
-				if i != len(children)-1 {
-					children[i] = children[len(children)-1]
-				}
-				node.parent.children = children[:len(children)-2]
-				break
-			}
-		}
-	}
-	return s.removeNodeAndChildren(ctx, node)
-}
-
-// removeNodeAndChildren removes `node` and all of its descendant from the Store
-func (s *Store) removeNodeAndChildren(ctx context.Context, node *Node) error {
-	for _, child := range node.children {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		if err := s.removeNodeAndChildren(ctx, child); err != nil {
-			return err
-		}
-	}
-
-	delete(s.nodeByRoot, node.root)
-	return nil
-}

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

@@ -1,70 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-// We test the algorithm to update a node from SYNCING to INVALID
-// We start with the same diagram as above:
-//
-//                E -- F
-//               /
-//         C -- D
-//        /      \
-//  A -- B        G -- H -- I
-//        \        \
-//         J        -- K -- L
-//
-// And every block in the Fork choice is optimistic.
-//
-func TestPruneInvalid(t *testing.T) {
-	tests := []struct {
-		root             [32]byte // the root of the new INVALID block
-		wantedNodeNumber int
-	}{
-		{
-			[32]byte{'j'},
-			12,
-		},
-		{
-			[32]byte{'c'},
-			4,
-		},
-		{
-			[32]byte{'i'},
-			12,
-		},
-		{
-			[32]byte{'h'},
-			11,
-		},
-		{
-			[32]byte{'g'},
-			8,
-		},
-	}
-	for _, tc := range tests {
-		ctx := context.Background()
-		f := setup(1, 1)
-
-		require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, 1, 1, true))
-
-		require.NoError(t, f.store.removeNode(context.Background(), tc.root))
-		require.Equal(t, tc.wantedNodeNumber, f.NodeCount())
-	}
-}

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

@@ -1,73 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"time"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-// BoostProposerRoot sets the block root which should be boosted during
-// the LMD fork choice algorithm calculations. This is meant to reward timely,
-// proposed blocks which occur before a cutoff interval set to
-// SECONDS_PER_SLOT // INTERVALS_PER_SLOT.
-//
-//  time_into_slot = (store.time - store.genesis_time) % SECONDS_PER_SLOT
-//  is_before_attesting_interval = time_into_slot < SECONDS_PER_SLOT // INTERVALS_PER_SLOT
-//  if get_current_slot(store) == block.slot and is_before_attesting_interval:
-//      store.proposer_boost_root = hash_tree_root(block)
-func (f *ForkChoice) BoostProposerRoot(_ context.Context, blockSlot types.Slot, blockRoot [32]byte, genesisTime time.Time) error {
-	secondsPerSlot := params.BeaconConfig().SecondsPerSlot
-	timeIntoSlot := uint64(time.Since(genesisTime).Seconds()) % secondsPerSlot
-	isBeforeAttestingInterval := timeIntoSlot < secondsPerSlot/params.BeaconConfig().IntervalsPerSlot
-	currentSlot := slots.SinceGenesis(genesisTime)
-
-	// Only update the boosted proposer root to the incoming block root
-	// if the block is for the current, clock-based slot and the block was timely.
-	if currentSlot == blockSlot && isBeforeAttestingInterval {
-		f.store.proposerBoostLock.Lock()
-		f.store.proposerBoostRoot = blockRoot
-		f.store.proposerBoostLock.Unlock()
-	}
-	return nil
-}
-
-// ResetBoostedProposerRoot sets the value of the proposer boosted root to zeros.
-func (f *ForkChoice) ResetBoostedProposerRoot(_ context.Context) error {
-	f.store.proposerBoostLock.Lock()
-	f.store.proposerBoostRoot = [32]byte{}
-	f.store.proposerBoostLock.Unlock()
-	return nil
-}
-
-// Given a list of validator balances, we compute the proposer boost score
-// that should be given to a proposer based on their committee weight, derived from
-// the total active balances, the size of a committee, and a boost score constant.
-// IMPORTANT: The caller MUST pass in a list of validator balances where balances > 0 refer to active
-// validators while balances == 0 are for inactive validators.
-func computeProposerBoostScore(validatorBalances []uint64) (score uint64, err error) {
-	totalActiveBalance := uint64(0)
-	numActive := uint64(0)
-	for _, balance := range validatorBalances {
-		// We only consider balances > 0. The input slice should be constructed
-		// as balance > 0 for all active validators and 0 for inactive ones.
-		if balance == 0 {
-			continue
-		}
-		totalActiveBalance += balance
-		numActive += 1
-	}
-	if numActive == 0 {
-		// Should never happen.
-		err = errors.New("no active validators")
-		return
-	}
-	avgBalance := totalActiveBalance / numActive
-	committeeSize := numActive / uint64(params.BeaconConfig().SlotsPerEpoch)
-	committeeWeight := committeeSize * avgBalance
-	score = (committeeWeight * params.BeaconConfig().ProposerScoreBoost) / 100
-	return
-}

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

@@ -1,491 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"fmt"
-	"testing"
-	"time"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-// Simple, ex-ante attack mitigation using proposer boost.
-// In a nutshell, an adversarial block proposer in slot n+1 keeps its proposal hidden.
-// The honest block proposer in slot n+2 will then propose an honest block. The
-// adversary can now use its committee members’ votes from both slots n+1 and n+2.
-// and release their withheld block of slot n+2 in an attempt to win fork choice.
-// If the honest proposal is boosted at slot n+2, it will win against this attacker.
-func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
-	ctx := context.Background()
-	zeroHash := params.BeaconConfig().ZeroHash
-	balances := make([]uint64, 64) // 64 active validators.
-	for i := 0; i < len(balances); i++ {
-		balances[i] = 10
-	}
-	jEpoch, fEpoch := types.Epoch(0), types.Epoch(0)
-	t.Run("back-propagates boost score to ancestors after proposer boosting", func(t *testing.T) {
-		f := setup(jEpoch, fEpoch)
-
-		// The head should always start at the finalized block.
-		headRoot, err := f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, zeroHash, headRoot, "Incorrect head with genesis")
-
-		// Insert block at slot 1 into the tree and verify head is at that block:
-		//         0
-		//         |
-		//         1 <- HEAD
-		slot := types.Slot(1)
-		newRoot := indexToHash(1)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				slot,
-				newRoot,
-				headRoot,
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-		f.ProcessAttestation(ctx, []uint64{0}, newRoot, fEpoch)
-		headRoot, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 1")
-
-		// Insert block at slot 2 into the tree and verify head is at that block:
-		//         0
-		//         |
-		//         1
-		//         |
-		//         2 <- HEAD
-		slot = types.Slot(2)
-		newRoot = indexToHash(2)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				slot,
-				newRoot,
-				headRoot,
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-		f.ProcessAttestation(ctx, []uint64{1}, newRoot, fEpoch)
-		headRoot, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 2")
-
-		// Insert block at slot 3 into the tree and verify head is at that block:
-		//         0
-		//         |
-		//         1
-		//         |
-		//         2
-		//         |
-		//         3 <- HEAD
-		slot = types.Slot(3)
-		newRoot = indexToHash(3)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				slot,
-				newRoot,
-				headRoot,
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-		f.ProcessAttestation(ctx, []uint64{2}, newRoot, fEpoch)
-		headRoot, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
-
-		// Insert a second block at slot 3 into the tree and boost its score.
-		//         0
-		//         |
-		//         1
-		//         |
-		//         2
-		//        / \
-		//       3   4 <- HEAD
-		slot = types.Slot(3)
-		newRoot = indexToHash(4)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				slot,
-				newRoot,
-				headRoot,
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-		f.ProcessAttestation(ctx, []uint64{3}, newRoot, fEpoch)
-		threeSlots := 3 * params.BeaconConfig().SecondsPerSlot
-		genesisTime := time.Now().Add(-time.Second * time.Duration(threeSlots))
-		require.NoError(t, f.BoostProposerRoot(ctx, slot, newRoot, genesisTime))
-		headRoot, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
-
-		// Check the ancestor scores from the store.
-		require.Equal(t, 5, len(f.store.nodeByRoot))
-
-		// Expect nodes to have a boosted, back-propagated score.
-		// Ancestors have the added weights of their children. Genesis is a special exception at 0 weight,
-		require.Equal(t, f.store.treeRootNode.weight, uint64(0))
-
-		// Otherwise, assuming a block, A, that is not-genesis:
-		//
-		// A -> B -> C
-		//
-		//Where each one has a weight of 10 individually, the final weights will look like
-		//
-		// (A: 30) -> (B: 20) -> (C: 10)
-		//
-		// The boost adds 14 to the weight, so if C is boosted, we would have
-		//
-		// (A: 44) -> (B: 34) -> (C: 24)
-		//
-		// In this case, we have a small fork:
-		//
-		// (A: 54) -> (B: 44) -> (C: 34)
-		//                   \_->(D: 24)
-		//
-		// So B has its own weight, 10, and the sum of both C and D. That's why we see weight 54 in the
-		// middle instead of the normal progression of (44 -> 34 -> 24).
-		node1 := f.store.nodeByRoot[indexToHash(1)]
-		require.Equal(t, node1.weight, uint64(54))
-		node2 := f.store.nodeByRoot[indexToHash(2)]
-		require.Equal(t, node2.weight, uint64(44))
-		node3 := f.store.nodeByRoot[indexToHash(4)]
-		require.Equal(t, node3.weight, uint64(24))
-	})
-	t.Run("vanilla ex ante attack", func(t *testing.T) {
-		f := setup(jEpoch, fEpoch)
-
-		// The head should always start at the finalized block.
-		r, err := f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, zeroHash, r, "Incorrect head with genesis")
-
-		// Proposer from slot 1 does not reveal their block, B, at slot 1.
-		// Proposer at slot 2 does reveal their block, C, and it becomes the head.
-		// C builds on A, as proposer at slot 1 did not reveal B.
-		//         A
-		//        / \
-		//      (B?) \
-		//            \
-		//             C <- Slot 2 HEAD
-		honestBlockSlot := types.Slot(2)
-		honestBlock := indexToHash(2)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				honestBlockSlot,
-				honestBlock,
-				zeroHash,
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
-
-		maliciouslyWithheldBlockSlot := types.Slot(1)
-		maliciouslyWithheldBlock := indexToHash(1)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				maliciouslyWithheldBlockSlot,
-				maliciouslyWithheldBlock,
-				zeroHash,
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-
-		// Ensure the head is C, the honest block.
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
-
-		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
-
-		// The maliciously withheld block has one vote.
-		votes := []uint64{1}
-		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
-
-		// Ensure the head is STILL C, the honest block, as the honest block had proposer boost.
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
-	})
-	t.Run("adversarial attestations > proposer boosting", func(t *testing.T) {
-		f := setup(jEpoch, fEpoch)
-
-		// The head should always start at the finalized block.
-		r, err := f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, zeroHash, r, "Incorrect head with genesis")
-
-		// Proposer from slot 1 does not reveal their block, B, at slot 1.
-		// Proposer at slot 2 does reveal their block, C, and it becomes the head.
-		// C builds on A, as proposer at slot 1 did not reveal B.
-		//         A
-		//        / \
-		//	    (B?) \
-		//            \
-		//             C <- Slot 2 HEAD
-		honestBlockSlot := types.Slot(2)
-		honestBlock := indexToHash(2)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				honestBlockSlot,
-				honestBlock,
-				zeroHash,
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-
-		// Ensure C is the head.
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
-
-		maliciouslyWithheldBlockSlot := types.Slot(1)
-		maliciouslyWithheldBlock := indexToHash(1)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				maliciouslyWithheldBlockSlot,
-				maliciouslyWithheldBlock,
-				zeroHash,
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-
-		// Ensure C is still the head after the malicious proposer reveals their block.
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
-
-		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
-
-		// An attestation is received for B that has more voting power than C with the proposer boost,
-		// allowing B to then become the head if their attestation has enough adversarial votes.
-		votes := []uint64{1, 2}
-		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
-
-		// Expect the head to have switched to B.
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, maliciouslyWithheldBlock, r, "Expected B to become the head")
-	})
-	t.Run("boosting necessary to sandwich attack", func(t *testing.T) {
-		// Boosting necessary to sandwich attack.
-		// Objects:
-		//	Block A - slot N
-		//	Block B (parent A) - slot N+1
-		//	Block C (parent A) - slot N+2
-		//	Block D (parent B) - slot N+3
-		//	Attestation_1 (Block C); size 1 - slot N+2 (honest)
-		// Steps:
-		//	Block A received at N — A is head
-		//	Block C received at N+2 — C is head
-		//	Block B received at N+2 — C is head
-		//	Attestation_1 received at N+3 — C is head
-		//	Block D received at N+3 — D is head
-		f := setup(jEpoch, fEpoch)
-		a := zeroHash
-
-		// The head should always start at the finalized block.
-		r, err := f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, zeroHash, r, "Incorrect head with genesis")
-
-		cSlot := types.Slot(2)
-		c := indexToHash(2)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				cSlot,
-				c,
-				a, // parent
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-
-		// Ensure C is the head.
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
-
-		// We boost C.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, cSlot /* slot */, c, genesis))
-
-		bSlot := types.Slot(1)
-		b := indexToHash(1)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				bSlot,
-				b,
-				a, // parent
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-
-		// Ensure C is still the head.
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
-
-		// An attestation for C is received at slot N+3.
-		votes := []uint64{1}
-		f.ProcessAttestation(ctx, votes, c, fEpoch)
-
-		// A block D, building on B, is received at slot N+3. It should not be able to win without boosting.
-		dSlot := types.Slot(3)
-		d := indexToHash(3)
-		require.NoError(t,
-			f.ProcessBlock(
-				ctx,
-				dSlot,
-				d,
-				b, // parent
-				jEpoch,
-				fEpoch,
-				true,
-			),
-		)
-
-		// D cannot win without a boost.
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, c, r, "Expected C to remain the head")
-
-		// Block D receives the boost.
-		genesis = time.Now().Add(-3 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, dSlot /* slot */, d, genesis))
-
-		// Ensure D becomes the head thanks to boosting.
-		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
-		require.NoError(t, err)
-		assert.Equal(t, d, r, "Expected D to become the head")
-	})
-}
-
-func TestForkChoice_BoostProposerRoot(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.SecondsPerSlot = 6
-	cfg.IntervalsPerSlot = 3
-	params.OverrideBeaconConfig(cfg)
-	ctx := context.Background()
-
-	t.Run("does not boost block from different slot", func(t *testing.T) {
-		f := &ForkChoice{
-			store: &Store{},
-		}
-		// Genesis set to 1 slot ago.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		blockRoot := [32]byte{'A'}
-
-		// Trying to boost a block from slot 0 should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(0), blockRoot, genesis)
-		require.NoError(t, err)
-		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
-	})
-	t.Run("does not boost untimely block from same slot", func(t *testing.T) {
-		f := &ForkChoice{
-			store: &Store{},
-		}
-		// Genesis set to 1 slot ago + X where X > attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		attestingInterval := time.Duration(cfg.SecondsPerSlot / cfg.IntervalsPerSlot)
-		greaterThanAttestingInterval := attestingInterval + 100*time.Millisecond
-		genesis = genesis.Add(-greaterThanAttestingInterval * time.Second)
-		blockRoot := [32]byte{'A'}
-
-		// Trying to boost a block from slot 1 that is untimely should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
-		require.NoError(t, err)
-		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
-	})
-	t.Run("boosts perfectly timely block from same slot", func(t *testing.T) {
-		f := &ForkChoice{
-			store: &Store{},
-		}
-		// Genesis set to 1 slot ago + 0 seconds into the attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		fmt.Println(genesis)
-		blockRoot := [32]byte{'A'}
-
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
-		require.NoError(t, err)
-		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
-	})
-	t.Run("boosts timely block from same slot", func(t *testing.T) {
-		f := &ForkChoice{
-			store: &Store{},
-		}
-		// Genesis set to 1 slot ago + (attesting interval / 2).
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		blockRoot := [32]byte{'A'}
-		halfAttestingInterval := time.Second
-		genesis = genesis.Add(-halfAttestingInterval)
-
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
-		require.NoError(t, err)
-		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
-	})
-}
-
-func TestForkChoice_computeProposerBoostScore(t *testing.T) {
-	t.Run("nil justified balances throws error", func(t *testing.T) {
-		_, err := computeProposerBoostScore(nil)
-		require.ErrorContains(t, "no active validators", err)
-	})
-	t.Run("normal active balances computes score", func(t *testing.T) {
-		validatorBalances := make([]uint64, 64) // Num validators
-		for i := 0; i < len(validatorBalances); i++ {
-			validatorBalances[i] = 10
-		}
-		// Avg balance is 10, and the number of validators is 64.
-		// With a committee size of num validators (64) / slots per epoch (32) == 2.
-		// we then have a committee weight of avg balance * committee size = 10 * 2 = 20.
-		// The score then becomes 10 * PROPOSER_SCORE_BOOST // 100, which is
-		// 20 * 70 / 100 = 14.
-		score, err := computeProposerBoostScore(validatorBalances)
-		require.NoError(t, err)
-		require.Equal(t, uint64(14), score)
-	})
-}

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

@@ -1,223 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"fmt"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"go.opencensus.io/trace"
-)
-
-// This defines the minimal number of block nodes that can be in the tree
-// before getting pruned upon new finalization.
-const defaultPruneThreshold = 256
-
-// applyProposerBoostScore applies the current proposer boost scores to the
-// relevant nodes
-func (s *Store) applyProposerBoostScore(newBalances []uint64) error {
-	s.proposerBoostLock.Lock()
-	defer s.proposerBoostLock.Unlock()
-
-	proposerScore := uint64(0)
-	var err error
-	if s.previousProposerBoostRoot != params.BeaconConfig().ZeroHash {
-		previousNode, ok := s.nodeByRoot[s.previousProposerBoostRoot]
-		if !ok || previousNode == nil {
-			return errInvalidProposerBoostRoot
-		}
-		previousNode.balance -= s.previousProposerBoostScore
-	}
-
-	if s.proposerBoostRoot != params.BeaconConfig().ZeroHash {
-		currentNode, ok := s.nodeByRoot[s.proposerBoostRoot]
-		if !ok || currentNode == nil {
-			return errInvalidProposerBoostRoot
-		}
-		proposerScore, err = computeProposerBoostScore(newBalances)
-		if err != nil {
-			return err
-		}
-		currentNode.balance += proposerScore
-	}
-	s.previousProposerBoostRoot = s.proposerBoostRoot
-	s.previousProposerBoostScore = proposerScore
-	return nil
-}
-
-// ProposerBoost of fork choice store.
-func (s *Store) proposerBoost() [fieldparams.RootLength]byte {
-	s.proposerBoostLock.RLock()
-	defer s.proposerBoostLock.RUnlock()
-	return s.proposerBoostRoot
-}
-
-// PruneThreshold of fork choice store.
-func (s *Store) PruneThreshold() uint64 {
-	return s.pruneThreshold
-}
-
-// head starts from justified root and then follows the best descendant links
-// to find the best block for head. This function assumes a lock on s.nodesLock
-func (s *Store) head(ctx context.Context, justifiedRoot [32]byte) ([32]byte, error) {
-	_, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.head")
-	defer span.End()
-
-	// JustifiedRoot has to be known
-	justifiedNode, ok := s.nodeByRoot[justifiedRoot]
-	if !ok || justifiedNode == nil {
-		return [32]byte{}, errUnknownJustifiedRoot
-	}
-
-	// If the justified node doesn't have a best descendant,
-	// the best node is itself.
-	bestDescendant := justifiedNode.bestDescendant
-	if bestDescendant == nil {
-		bestDescendant = justifiedNode
-	}
-
-	if !bestDescendant.viableForHead(s.justifiedEpoch, s.finalizedEpoch) {
-		return [32]byte{}, fmt.Errorf("head at slot %d with weight %d is not eligible, finalizedEpoch %d != %d, justifiedEpoch %d != %d",
-			bestDescendant.slot, bestDescendant.weight/10e9, bestDescendant.finalizedEpoch, s.finalizedEpoch, bestDescendant.justifiedEpoch, s.justifiedEpoch)
-	}
-
-	// Update metrics.
-	if bestDescendant != s.headNode {
-		headChangesCount.Inc()
-		headSlotNumber.Set(float64(bestDescendant.slot))
-		s.headNode = bestDescendant
-	}
-
-	return bestDescendant.root, nil
-}
-
-// insert registers a new block node to the fork choice store's node list.
-// It then updates the new node's parent with best child and descendant node.
-func (s *Store) insert(ctx context.Context,
-	slot types.Slot,
-	root, parentRoot [fieldparams.RootLength]byte,
-	justifiedEpoch, finalizedEpoch types.Epoch, optimistic bool) error {
-	_, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.insert")
-	defer span.End()
-
-	s.nodesLock.Lock()
-	defer s.nodesLock.Unlock()
-
-	// Return if the block has been inserted into Store before.
-	if _, ok := s.nodeByRoot[root]; ok {
-		return nil
-	}
-
-	parent := s.nodeByRoot[parentRoot]
-
-	n := &Node{
-		slot:           slot,
-		root:           root,
-		parent:         parent,
-		justifiedEpoch: justifiedEpoch,
-		finalizedEpoch: finalizedEpoch,
-		optimistic:     optimistic,
-	}
-
-	s.nodeByRoot[root] = n
-	if parent != nil {
-		parent.children = append(parent.children, n)
-		if err := s.treeRootNode.updateBestDescendant(ctx, s.justifiedEpoch, s.finalizedEpoch); err != nil {
-			return err
-		}
-	}
-
-	if !optimistic {
-		if err := n.setNodeAndParentValidated(ctx); err != nil {
-			return err
-		}
-	} else {
-		optimisticCount.Inc()
-	}
-
-	// Set the node as root if the store was empty
-	if s.treeRootNode == nil {
-		s.treeRootNode = n
-		s.headNode = n
-	}
-
-	// Update metrics.
-	processedBlockCount.Inc()
-	nodeCount.Set(float64(len(s.nodeByRoot)))
-
-	return nil
-}
-
-// updateCheckpoints Update the justified / finalized epochs in store if necessary.
-func (s *Store) updateCheckpoints(justifiedEpoch, finalizedEpoch types.Epoch) {
-	s.justifiedEpoch = justifiedEpoch
-	s.finalizedEpoch = finalizedEpoch
-}
-
-// pruneFinalizedNodeByRootMap prunes the `nodeByRoot` map
-// starting from `node` down to the finalized Node or to a leaf of the Fork
-// choice store. This method assumes a lock on nodesLock.
-func (s *Store) pruneFinalizedNodeByRootMap(ctx context.Context, node, finalizedNode *Node) error {
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-	if node == finalizedNode {
-		return nil
-	}
-	for _, child := range node.children {
-		if err := s.pruneFinalizedNodeByRootMap(ctx, child, finalizedNode); err != nil {
-			return err
-		}
-	}
-
-	delete(s.nodeByRoot, node.root)
-	return nil
-}
-
-// prune prunes the fork choice store with the new finalized root. The store is only pruned if the input
-// root is different than the current store finalized root, and the number of the store has met prune threshold.
-// This function does not prune for invalid optimistically synced nodes, it deals only with pruning upon finalization
-func (s *Store) prune(ctx context.Context, finalizedRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.Prune")
-	defer span.End()
-
-	s.nodesLock.Lock()
-	defer s.nodesLock.Unlock()
-
-	finalizedNode, ok := s.nodeByRoot[finalizedRoot]
-	if !ok || finalizedNode == nil {
-		return errUnknownFinalizedRoot
-	}
-
-	// The number of the nodes has not met the prune threshold.
-	// Pruning at small numbers incurs more cost than benefit.
-	if finalizedNode.depth() < s.pruneThreshold {
-		return nil
-	}
-
-	// Prune nodeByRoot starting from root
-	if err := s.pruneFinalizedNodeByRootMap(ctx, s.treeRootNode, finalizedNode); err != nil {
-		return err
-	}
-
-	finalizedNode.parent = nil
-	s.treeRootNode = finalizedNode
-
-	prunedCount.Inc()
-	return nil
-}
-
-// tips returns a list of possible heads from fork choice store, it returns the
-// roots and the slots of the leaf nodes.
-func (s *Store) tips() ([][32]byte, []types.Slot) {
-	var roots [][32]byte
-	var slots []types.Slot
-	for root, node := range s.nodeByRoot {
-		if len(node.children) == 0 {
-			roots = append(roots, root)
-			slots = append(slots, node.slot)
-		}
-	}
-	return roots, slots
-}

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

@@ -1,274 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"testing"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestStore_PruneThreshold(t *testing.T) {
-	s := &Store{
-		pruneThreshold: defaultPruneThreshold,
-	}
-	if got := s.PruneThreshold(); got != defaultPruneThreshold {
-		t.Errorf("PruneThreshold() = %v, want %v", got, defaultPruneThreshold)
-	}
-}
-
-func TestStore_JustifiedEpoch(t *testing.T) {
-	j := types.Epoch(100)
-	f := setup(j, j)
-	require.Equal(t, j, f.JustifiedEpoch())
-}
-
-func TestStore_FinalizedEpoch(t *testing.T) {
-	j := types.Epoch(50)
-	f := setup(j, j)
-	require.Equal(t, j, f.FinalizedEpoch())
-}
-
-func TestStore_NodeCount(t *testing.T) {
-	f := setup(0, 0)
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.Equal(t, 2, f.NodeCount())
-}
-
-func TestStore_NodeByRoot(t *testing.T) {
-	f := setup(0, 0)
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(2), indexToHash(1), 0, 0, false))
-	node0 := f.store.treeRootNode
-	node1 := node0.children[0]
-	node2 := node1.children[0]
-
-	expectedRoots := map[[32]byte]*Node{
-		params.BeaconConfig().ZeroHash: node0,
-		indexToHash(1):                 node1,
-		indexToHash(2):                 node2,
-	}
-
-	require.Equal(t, 3, f.NodeCount())
-	for root, node := range f.store.nodeByRoot {
-		v, ok := expectedRoots[root]
-		require.Equal(t, ok, true)
-		require.Equal(t, v, node)
-	}
-}
-
-func TestForkChoice_HasNode(t *testing.T) {
-	f := setup(0, 0)
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.Equal(t, true, f.HasNode(indexToHash(1)))
-}
-
-func TestStore_Head_UnknownJustifiedRoot(t *testing.T) {
-	f := setup(0, 0)
-
-	_, err := f.store.head(context.Background(), [32]byte{'a'})
-	assert.ErrorContains(t, errUnknownJustifiedRoot.Error(), err)
-}
-
-func TestStore_Head_Itself(t *testing.T) {
-	f := setup(0, 0)
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-
-	// Since the justified node does not have a best descendant so the best node
-	// is itself.
-	h, err := f.store.head(context.Background(), indexToHash(1))
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(1), h)
-}
-
-func TestStore_Head_BestDescendant(t *testing.T) {
-	f := setup(0, 0)
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(2), indexToHash(1), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(3), indexToHash(1), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(4), indexToHash(2), 0, 0, false))
-	h, err := f.store.head(context.Background(), indexToHash(1))
-	require.NoError(t, err)
-	require.Equal(t, h, indexToHash(4))
-}
-
-func TestStore_UpdateBestDescendant_ContextCancelled(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	f := setup(0, 0)
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	cancel()
-	err := f.ProcessBlock(ctx, 2, indexToHash(2), indexToHash(1), 0, 0, false)
-	require.ErrorContains(t, "context canceled", err)
-}
-
-func TestStore_Insert(t *testing.T) {
-	// The new node does not have a parent.
-	treeRootNode := &Node{slot: 0, root: indexToHash(0)}
-	nodeByRoot := map[[32]byte]*Node{indexToHash(0): treeRootNode}
-	s := &Store{nodeByRoot: nodeByRoot, treeRootNode: treeRootNode}
-	require.NoError(t, s.insert(context.Background(), 100, indexToHash(100), indexToHash(0), 1, 1, false))
-	assert.Equal(t, 2, len(s.nodeByRoot), "Did not insert block")
-	assert.Equal(t, (*Node)(nil), treeRootNode.parent, "Incorrect parent")
-	assert.Equal(t, 1, len(treeRootNode.children), "Incorrect children number")
-	child := treeRootNode.children[0]
-	assert.Equal(t, types.Epoch(1), child.justifiedEpoch, "Incorrect justification")
-	assert.Equal(t, types.Epoch(1), child.finalizedEpoch, "Incorrect finalization")
-	assert.Equal(t, indexToHash(100), child.root, "Incorrect root")
-}
-
-func TestStore_updateCheckpoints(t *testing.T) {
-	f := setup(0, 0)
-	s := f.store
-
-	s.updateCheckpoints(1, 1)
-	assert.Equal(t, types.Epoch(1), s.justifiedEpoch, "Did not update justified epoch")
-	assert.Equal(t, types.Epoch(1), s.finalizedEpoch, "Did not update finalized epoch")
-}
-
-func TestStore_Prune_LessThanThreshold(t *testing.T) {
-	// Define 100 nodes in store.
-	numOfNodes := uint64(100)
-	f := setup(0, 0)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	for i := uint64(2); i < numOfNodes; i++ {
-		require.NoError(t, f.ProcessBlock(ctx, types.Slot(i), indexToHash(i), indexToHash(i-1), 0, 0, false))
-	}
-
-	s := f.store
-	s.pruneThreshold = 100
-
-	// Finalized root has depth 99 so everything before it should be pruned,
-	// but PruneThreshold is at 100 so nothing will be pruned.
-	require.NoError(t, s.prune(context.Background(), indexToHash(99)))
-	assert.Equal(t, 100, len(s.nodeByRoot), "Incorrect nodes count")
-}
-
-func TestStore_Prune_MoreThanThreshold(t *testing.T) {
-	// Define 100 nodes in store.
-	numOfNodes := uint64(100)
-	f := setup(0, 0)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	for i := uint64(2); i < numOfNodes; i++ {
-		require.NoError(t, f.ProcessBlock(ctx, types.Slot(i), indexToHash(i), indexToHash(i-1), 0, 0, false))
-	}
-
-	s := f.store
-	s.pruneThreshold = 0
-
-	// Finalized root is at index 99 so everything before 99 should be pruned.
-	require.NoError(t, s.prune(context.Background(), indexToHash(99)))
-	assert.Equal(t, 1, len(s.nodeByRoot), "Incorrect nodes count")
-}
-
-func TestStore_Prune_MoreThanOnce(t *testing.T) {
-	// Define 100 nodes in store.
-	numOfNodes := uint64(100)
-	f := setup(0, 0)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	for i := uint64(2); i < numOfNodes; i++ {
-		require.NoError(t, f.ProcessBlock(ctx, types.Slot(i), indexToHash(i), indexToHash(i-1), 0, 0, false))
-	}
-
-	s := f.store
-	s.pruneThreshold = 0
-
-	// Finalized root is at index 11 so everything before 11 should be pruned.
-	require.NoError(t, s.prune(context.Background(), indexToHash(10)))
-	assert.Equal(t, 90, len(s.nodeByRoot), "Incorrect nodes count")
-
-	// One more time.
-	require.NoError(t, s.prune(context.Background(), indexToHash(20)))
-	assert.Equal(t, 80, len(s.nodeByRoot), "Incorrect nodes count")
-}
-
-// This unit tests starts with a simple branch like this
-//
-//       - 1
-//     /
-// -- 0 -- 2
-//
-// And we finalize 1. As a result only 1 should survive
-func TestStore_Prune_NoDanglingBranch(t *testing.T) {
-	f := setup(0, 0)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0, false))
-	f.store.pruneThreshold = 0
-
-	s := f.store
-	require.NoError(t, s.prune(context.Background(), indexToHash(1)))
-	require.Equal(t, len(s.nodeByRoot), 1)
-}
-
-// This test starts with the following branching diagram
-/// We start with the following diagram
-//
-//                E -- F
-//               /
-//         C -- D
-//        /      \
-//  A -- B        G -- H -- I
-//        \        \
-//         J        -- K -- L
-//
-//
-func TestStore_tips(t *testing.T) {
-	ctx := context.Background()
-	f := setup(1, 1)
-
-	require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, 1, 1, true))
-	expectedMap := map[[32]byte]types.Slot{
-		[32]byte{'f'}: 105,
-		[32]byte{'i'}: 106,
-		[32]byte{'l'}: 106,
-		[32]byte{'j'}: 102,
-	}
-	roots, slots := f.store.tips()
-	for i, r := range roots {
-		expectedSlot, ok := expectedMap[r]
-		require.Equal(t, true, ok)
-		require.Equal(t, slots[i], expectedSlot)
-	}
-}
-
-func TestStore_PruneMapsNodes(t *testing.T) {
-	f := setup(0, 0)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0, false))
-
-	s := f.store
-	s.pruneThreshold = 0
-	require.NoError(t, s.prune(context.Background(), indexToHash(uint64(1))))
-	require.Equal(t, len(s.nodeByRoot), 1)
-
-}
-
-func TestStore_HasParent(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	require.NoError(t, f.ProcessBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 2, indexToHash(2), indexToHash(1), 1, 1, false))
-	require.NoError(t, f.ProcessBlock(ctx, 3, indexToHash(3), indexToHash(2), 1, 1, false))
-	require.Equal(t, false, f.HasParent(params.BeaconConfig().ZeroHash))
-	require.Equal(t, true, f.HasParent(indexToHash(1)))
-	require.Equal(t, true, f.HasParent(indexToHash(2)))
-	require.Equal(t, true, f.HasParent(indexToHash(3)))
-	require.Equal(t, false, f.HasParent(indexToHash(4)))
-}

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

@@ -1,53 +0,0 @@
-package doublylinkedtree
-
-import (
-	"sync"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-)
-
-// ForkChoice defines the overall fork choice store which includes all block nodes, validator's latest votes and balances.
-type ForkChoice struct {
-	store     *Store
-	votes     []Vote // tracks individual validator's last vote.
-	votesLock sync.RWMutex
-	balances  []uint64 // tracks individual validator's last justified balances.
-}
-
-// Store defines the fork choice store which includes block nodes and the last view of checkpoint information.
-type Store struct {
-	justifiedEpoch             types.Epoch                            // latest justified epoch in store.
-	finalizedEpoch             types.Epoch                            // latest finalized epoch in store.
-	pruneThreshold             uint64                                 // do not prune tree unless threshold is reached.
-	proposerBoostRoot          [fieldparams.RootLength]byte           // latest block root that was boosted after being received in a timely manner.
-	previousProposerBoostRoot  [fieldparams.RootLength]byte           // previous block root that was boosted after being received in a timely manner.
-	previousProposerBoostScore uint64                                 // previous proposer boosted root score.
-	treeRootNode               *Node                                  // the root node of the store tree.
-	headNode                   *Node                                  // last head Node
-	nodeByRoot                 map[[fieldparams.RootLength]byte]*Node // nodes indexed by roots.
-	nodesLock                  sync.RWMutex
-	proposerBoostLock          sync.RWMutex
-}
-
-// Node defines the individual block which includes its block parent, ancestor and how much weight accounted for it.
-// This is used as an array based stateful DAG for efficient fork choice look up.
-type Node struct {
-	slot           types.Slot                   // slot of the block converted to the node.
-	root           [fieldparams.RootLength]byte // root of the block converted to the node.
-	parent         *Node                        // parent index of this node.
-	children       []*Node                      // the list of direct children of this Node
-	justifiedEpoch types.Epoch                  // justifiedEpoch of this node.
-	finalizedEpoch types.Epoch                  // finalizedEpoch of this node.
-	balance        uint64                       // the balance that voted for this node directly
-	weight         uint64                       // weight of this node: the total balance including children
-	bestDescendant *Node                        // bestDescendant node of this node.
-	optimistic     bool                         // whether the block has been fully validated or not
-}
-
-// Vote defines an individual validator's vote.
-type Vote struct {
-	currentRoot [fieldparams.RootLength]byte // current voting root.
-	nextRoot    [fieldparams.RootLength]byte // next voting root.
-	nextEpoch   types.Epoch                  // epoch of next voting period.
-}

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

@@ -1,297 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestVotes_CanFindHead(t *testing.T) {
-	balances := []uint64{1, 1}
-	f := setup(1, 1)
-
-	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
-
-	// Insert block 2 into the tree and verify head is at 2:
-	//         0
-	//        /
-	//       2 <- head
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1, true))
-
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
-
-	// Insert block 1 into the tree and verify head is still at 2:
-	//            0
-	//           / \
-	//  head -> 2  1
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, true))
-
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
-
-	// Add a vote to block 1 of the tree and verify head is switched to 1:
-	//            0
-	//           / \
-	//          2  1 <- +vote, new head
-	f.ProcessAttestation(context.Background(), []uint64{0}, indexToHash(1), 2)
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(1), r, "Incorrect head for with justified epoch at 1")
-
-	// Add a vote to block 2 of the tree and verify head is switched to 2:
-	//                     0
-	//                    / \
-	// vote, new head -> 2  1
-	f.ProcessAttestation(context.Background(), []uint64{1}, indexToHash(2), 2)
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
-
-	// Insert block 3 into the tree and verify head is still at 2:
-	//            0
-	//           / \
-	//  head -> 2  1
-	//             |
-	//             3
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(3), indexToHash(1), 1, 1, true))
-
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
-
-	// Move validator 0's vote from 1 to 3 and verify head is still at 2:
-	//            0
-	//           / \
-	//  head -> 2  1 <- old vote
-	//             |
-	//             3 <- new vote
-	f.ProcessAttestation(context.Background(), []uint64{0}, indexToHash(3), 3)
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
-
-	// Move validator 1's vote from 2 to 1 and verify head is switched to 3:
-	//               0
-	//              / \
-	// old vote -> 2  1 <- new vote
-	//                |
-	//                3 <- head
-	f.ProcessAttestation(context.Background(), []uint64{1}, indexToHash(1), 3)
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(3), r, "Incorrect head for with justified epoch at 1")
-
-	// Insert block 4 into the tree and verify head is at 4:
-	//            0
-	//           / \
-	//          2  1
-	//             |
-	//             3
-	//             |
-	//             4 <- head
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(4), indexToHash(3), 1, 1, true))
-
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
-
-	// Insert block 5 with justified epoch 2, it should be filtered out:
-	//            0
-	//           / \
-	//          2  1
-	//             |
-	//             3
-	//             |
-	//             4 <- head
-	//            /
-	//           5 <- justified epoch = 2
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(5), indexToHash(4), 2, 2, true))
-
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
-
-	// Insert block 6 with justified epoch 0:
-	//            0
-	//           / \
-	//          2  1
-	//             |
-	//             3
-	//             |
-	//             4 <- head
-	//            / \
-	//           5  6 <- justified epoch = 0
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(6), indexToHash(4), 1, 1, true))
-
-	// Moved 2 votes to block 5:
-	//            0
-	//           / \
-	//          2  1
-	//             |
-	//             3
-	//             |
-	//             4
-	//            / \
-	// 2 votes-> 5  6
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(6), indexToHash(4), 1, 1, true))
-
-	f.ProcessAttestation(context.Background(), []uint64{0, 1}, indexToHash(5), 4)
-
-	// Inset blocks 7, 8 and 9:
-	// 6 should still be the head, even though 5 has all the votes.
-	//            0
-	//           / \
-	//          2  1
-	//             |
-	//             3
-	//             |
-	//             4
-	//            / \
-	//           5  6 <- head
-	//           |
-	//           7
-	//           |
-	//           8
-	//           |
-	//           9
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(7), indexToHash(5), 2, 2, true))
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(8), indexToHash(7), 2, 2, true))
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(9), indexToHash(8), 2, 2, true))
-
-	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 1")
-
-	// Update fork choice justified epoch to 1 and start block to 5.
-	// Verify 9 is the head:
-	//            0
-	//           / \
-	//          2  1
-	//             |
-	//             3
-	//             |
-	//             4
-	//            / \
-	//           5  6
-	//           |
-	//           7
-	//           |
-	//           8
-	//           |
-	//           9 <- head
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
-
-	// Insert block 10 and 2 validators updated their vote to 9.
-	// Verify 9 is the head:
-	//             0
-	//            / \
-	//           2  1
-	//              |
-	//              3
-	//              |
-	//              4
-	//             / \
-	//            5  6
-	//            |
-	//            7
-	//            |
-	//            8
-	//           / \
-	// 2 votes->9  10
-	f.ProcessAttestation(context.Background(), []uint64{0, 1}, indexToHash(9), 5)
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(10), indexToHash(8), 2, 2, true))
-
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
-
-	// Add 3 more validators to the system.
-	balances = []uint64{1, 1, 1, 1, 1}
-	// The new validators voted for 10.
-	f.ProcessAttestation(context.Background(), []uint64{2, 3, 4}, indexToHash(10), 5)
-	// The new head should be 10.
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(10), r, "Incorrect head for with justified epoch at 2")
-
-	// Set the balances of the last 2 validators to 0.
-	balances = []uint64{1, 1, 1, 0, 0}
-	// The head should be back to 9.
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 1")
-
-	// Set the balances back to normal.
-	balances = []uint64{1, 1, 1, 1, 1}
-	// The head should be back to 10.
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(10), r, "Incorrect head for with justified epoch at 2")
-
-	// Remove the last 2 validators.
-	balances = []uint64{1, 1, 1}
-	// The head should be back to 9.
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 1")
-
-	// Verify pruning below the prune threshold does not affect head.
-	f.store.pruneThreshold = 1000
-	require.NoError(t, f.store.prune(context.Background(), indexToHash(5)))
-	assert.Equal(t, 11, len(f.store.nodeByRoot), "Incorrect nodes length after prune")
-
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
-
-	// Verify pruning above the prune threshold does prune:
-	//          0
-	//         / \
-	//        2   1
-	//            |
-	//            3
-	//            |
-	//            4
-	// -------pruned here ------
-	//          5   6
-	//          |
-	//          7
-	//          |
-	//          8
-	//         / \
-	//        9  10
-	f.store.pruneThreshold = 1
-	require.NoError(t, f.store.prune(context.Background(), indexToHash(5)))
-	assert.Equal(t, 5, len(f.store.nodeByRoot), "Incorrect nodes length after prune")
-
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
-
-	// Insert new block 11 and verify head is at 11.
-	//          5   6
-	//          |
-	//          7
-	//          |
-	//          8
-	//         / \
-	//        9  10
-	//        |
-	// head-> 11
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(11), indexToHash(9), 2, 2, true))
-
-	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
-	require.NoError(t, err)
-	assert.Equal(t, indexToHash(11), r, "Incorrect head for with justified epoch at 2")
-}

beacon-chain/forkchoice/interfaces.go

@@ -5,8 +5,7 @@ import (
 	"time"
 
 	types "github.com/prysmaticlabs/eth2-types"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 )
 
 // ForkChoicer represents the full fork choice interface composed of all the sub-interfaces.
@@ -16,26 +15,19 @@ type ForkChoicer interface {
 	AttestationProcessor // to track new attestation for fork choice.
 	Pruner               // to clean old data for fork choice.
 	Getter               // to retrieve fork choice information.
-	Setter               // to set fork choice information.
 	ProposerBooster      // ability to boost timely-proposed block roots.
+	SyncTipper           // to update and retrieve validated sync tips.
 }
 
 // HeadRetriever retrieves head root and optimistic info of the current chain.
 type HeadRetriever interface {
 	Head(context.Context, types.Epoch, [32]byte, []uint64, types.Epoch) ([32]byte, error)
-	Tips() ([][32]byte, []types.Slot)
-	IsOptimistic(ctx context.Context, root [32]byte) (bool, error)
+	Optimistic(ctx context.Context, root [32]byte, slot types.Slot) (bool, error)
 }
 
 // BlockProcessor processes the block that's used for accounting fork choice.
 type BlockProcessor interface {
-	ProcessBlock(ctx context.Context,
-		slot types.Slot,
-		root [32]byte,
-		parentRoot [32]byte,
-		justifiedEpoch types.Epoch,
-		finalizedEpoch types.Epoch,
-		optimisticStatus bool) error
+	ProcessBlock(context.Context, types.Slot, [32]byte, [32]byte, [32]byte, types.Epoch, types.Epoch) error
 }
 
 // AttestationProcessor processes the attestation that's used for accounting fork choice.
@@ -56,19 +48,19 @@ type ProposerBooster interface {
 
 // Getter returns fork choice related information.
 type Getter interface {
+	Nodes() []*protoarray.Node
+	Node([32]byte) *protoarray.Node
 	HasNode([32]byte) bool
-	ProposerBoost() [fieldparams.RootLength]byte
+	Store() *protoarray.Store
 	HasParent(root [32]byte) bool
 	AncestorRoot(ctx context.Context, root [32]byte, slot types.Slot) ([]byte, error)
 	IsCanonical(root [32]byte) bool
-	FinalizedEpoch() types.Epoch
-	JustifiedEpoch() types.Epoch
-	ForkChoiceNodes() []*pbrpc.ForkChoiceNode
-	NodeCount() int
 }
 
-// Setter allows to set forkchoice information
-type Setter interface {
-	SetOptimisticToValid(context.Context, [fieldparams.RootLength]byte) error
-	SetOptimisticToInvalid(context.Context, [fieldparams.RootLength]byte) error
+// SyncTipper returns sync tips related information.
+type SyncTipper interface {
+	SyncedTips() map[[32]byte]types.Slot
+	SetSyncedTips(tips map[[32]byte]types.Slot) error
+	UpdateSyncedTipsWithValidRoot(ctx context.Context, root [32]byte) error
+	UpdateSyncedTipsWithInvalidRoot(ctx context.Context, root [32]byte) error
 }

beacon-chain/forkchoice/protoarray/BUILD.bazel

@@ -21,7 +21,7 @@ go_library(
     deps = [
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",

beacon-chain/forkchoice/protoarray/errors.go

@@ -5,7 +5,6 @@ import "errors"
 var errUnknownFinalizedRoot = errors.New("unknown finalized root")
 var errUnknownJustifiedRoot = errors.New("unknown justified root")
 var errInvalidNodeIndex = errors.New("node index is invalid")
-var errUnknownNodeRoot = errors.New("unknown block root")
 var errInvalidJustifiedIndex = errors.New("justified index is invalid")
 var errInvalidBestChildIndex = errors.New("best child index is invalid")
 var errInvalidBestDescendantIndex = errors.New("best descendant index is invalid")

beacon-chain/forkchoice/protoarray/ffg_update_test.go

@@ -27,9 +27,9 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	//            2 <- justified: 1, finalized: 0
 	//            |
 	//            3 <- justified: 2, finalized: 1
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(2), indexToHash(1), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(3), indexToHash(2), 2, 1, false))
+	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, [32]byte{}, 0, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(2), indexToHash(1), [32]byte{}, 1, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(3), indexToHash(2), [32]byte{}, 2, 1))
 
 	// With starting justified epoch at 0, the head should be 3:
 	//            0 <- start
@@ -89,17 +89,17 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//                              |   |
 	//  justified: 2, finalized: 0 -> 9  10 <- justified: 2, finalized: 0
 	// Left branch.
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(3), indexToHash(1), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(5), indexToHash(3), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(7), indexToHash(5), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(9), indexToHash(7), 2, 0, false))
+	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, [32]byte{}, 0, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(3), indexToHash(1), [32]byte{}, 1, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(5), indexToHash(3), [32]byte{}, 1, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(7), indexToHash(5), [32]byte{}, 1, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(9), indexToHash(7), [32]byte{}, 2, 0))
 	// Right branch.
-	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(4), indexToHash(2), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(6), indexToHash(4), 0, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(8), indexToHash(6), 1, 0, false))
-	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(10), indexToHash(8), 2, 0, false))
+	require.NoError(t, f.ProcessBlock(context.Background(), 1, indexToHash(2), params.BeaconConfig().ZeroHash, [32]byte{}, 0, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 2, indexToHash(4), indexToHash(2), [32]byte{}, 0, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 3, indexToHash(6), indexToHash(4), [32]byte{}, 0, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(8), indexToHash(6), [32]byte{}, 1, 0))
+	require.NoError(t, f.ProcessBlock(context.Background(), 4, indexToHash(10), indexToHash(8), [32]byte{}, 2, 0))
 
 	// With start at 0, the head should be 10:
 	//           0  <-- start
@@ -183,7 +183,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 }
 
 func setup(justifiedEpoch, finalizedEpoch types.Epoch) *ForkChoice {
-	f := New(justifiedEpoch, finalizedEpoch, params.BeaconConfig().ZeroHash)
+	f := New(0, 0, params.BeaconConfig().ZeroHash)
 	f.store.nodesIndices[params.BeaconConfig().ZeroHash] = 0
 	f.store.nodes = append(f.store.nodes, &Node{
 		slot:           0,

beacon-chain/forkchoice/protoarray/helpers.go

@@ -15,7 +15,7 @@ func computeDeltas(
 	votes []Vote,
 	oldBalances, newBalances []uint64,
 ) ([]int, []Vote, error) {
-	_, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.computeDeltas")
+	_, span := trace.StartSpan(ctx, "protoArrayForkChoice.computeDeltas")
 	defer span.End()
 
 	deltas := make([]int, len(blockIndices))

beacon-chain/forkchoice/protoarray/no_vote_test.go

@@ -24,7 +24,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//         0
 	//        /
 	//       2 <- head
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1, false))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, [32]byte{}, 1, 1))
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
@@ -33,7 +33,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//            0
 	//           / \
 	//  head -> 2  1
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, false))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, [32]byte{}, 1, 1))
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
@@ -44,7 +44,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//  head -> 2  1
 	//             |
 	//             3
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(3), indexToHash(1), 1, 1, false))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(3), indexToHash(1), [32]byte{}, 1, 1))
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
@@ -55,7 +55,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//          2  1
 	//          |  |
 	//  head -> 4  3
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(4), indexToHash(2), 1, 1, false))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(4), indexToHash(2), [32]byte{}, 1, 1))
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
@@ -68,7 +68,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//  head -> 4  3
 	//          |
 	//          5 <- justified epoch = 2
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(5), indexToHash(4), 2, 1, false))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(5), indexToHash(4), [32]byte{}, 2, 1))
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
@@ -107,7 +107,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//          5
 	//          |
 	//          6 <- head
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(6), indexToHash(5), 2, 1, false))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(6), indexToHash(5), [32]byte{}, 2, 1))
 	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 1)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 2")

beacon-chain/forkchoice/protoarray/optimistic_sync.go

@@ -2,9 +2,11 @@ package protoarray
 
 import (
 	"context"
+	"fmt"
 
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 )
 
 // This returns the minimum and maximum slot of the synced_tips tree
@@ -25,29 +27,25 @@ func (f *ForkChoice) boundarySyncedTips() (types.Slot, types.Slot) {
 	return min, max
 }
 
-// IsOptimistic returns true if this node is optimistically synced
+// Optimistic returns true if this node is optimistically synced
 // A optimistically synced block is synced as usual, but its
 // execution payload is not validated, while the EL is still syncing.
-// This function returns an error if the block is not found in the fork choice
-// store
-func (f *ForkChoice) IsOptimistic(ctx context.Context, root [32]byte) (bool, error) {
+// WARNING: this function does not check if slot corresponds to the
+//          block with the given root. An incorrect response may be
+//          returned when requesting earlier than finalized epoch due
+//          to pruning of non-canonical branches. A requests for a
+//          combination root/slot of an available block is guaranteed
+//          to yield the correct result. The caller is responsible for
+//          checking the block's availability. A consensus bug could be
+//          a cause of getting this wrong, so think twice before passing
+//          a wrong pair.
+func (f *ForkChoice) Optimistic(ctx context.Context, root [32]byte, slot types.Slot) (bool, error) {
 	if ctx.Err() != nil {
 		return false, ctx.Err()
 	}
-	// If we reached this point then the block has to be in the Fork Choice
-	// Store!
-	f.store.nodesLock.RLock()
-	index, ok := f.store.nodesIndices[root]
-	if !ok {
-		f.store.nodesLock.RUnlock()
-		return false, errUnknownNodeRoot
-	}
-	node := f.store.nodes[index]
-	slot := node.slot
-
 	// If the node is a synced tip, then it's fully validated
 	f.syncedTips.RLock()
-	_, ok = f.syncedTips.validatedTips[root]
+	_, ok := f.syncedTips.validatedTips[root]
 	if ok {
 		f.syncedTips.RUnlock()
 		return false, nil
@@ -65,6 +63,18 @@ func (f *ForkChoice) IsOptimistic(ctx context.Context, root [32]byte) (bool, err
 		return false, nil
 	}
 
+	// If we reached this point then the block has to be in the Fork Choice
+	// Store!
+	f.store.nodesLock.RLock()
+	index, ok := f.store.nodesIndices[root]
+	if !ok {
+		// This should not happen
+		f.store.nodesLock.RUnlock()
+		return false, fmt.Errorf("invalid root, slot combination, got %#x, %d",
+			bytesutil.Trunc(root[:]), slot)
+	}
+	node := f.store.nodes[index]
+
 	// if the node is a leaf of the Fork Choice tree, then it's
 	// optimistic
 	childIndex := node.BestChild()
@@ -75,8 +85,9 @@ func (f *ForkChoice) IsOptimistic(ctx context.Context, root [32]byte) (bool, err
 	// recurse to the child
 	child := f.store.nodes[childIndex]
 	root = child.root
+	slot = child.slot
 	f.store.nodesLock.RUnlock()
-	return f.IsOptimistic(ctx, root)
+	return f.Optimistic(ctx, root, slot)
 }
 
 // This function returns the index of sync tip node that's ancestor to the input node.
@@ -97,10 +108,10 @@ func (s *Store) findSyncedTip(ctx context.Context, node *Node, syncedTips *optim
 	}
 }
 
-// SetOptimisticToValid is called with the root of a block that was returned as
+// UpdateSyncedTipsWithValidRoot is called with the root of a block that was returned as
 // VALID by the EL. This routine recomputes and updates the synced_tips map to
 // account for this new tip.
-func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [32]byte) error {
+func (f *ForkChoice) UpdateSyncedTipsWithValidRoot(ctx context.Context, root [32]byte) error {
 	f.store.nodesLock.RLock()
 	defer f.store.nodesLock.RUnlock()
 	// We can only update if given root is in Fork Choice
@@ -201,8 +212,8 @@ func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [32]byte) er
 	return nil
 }
 
-//  SetOptimisticToInvalid updates the synced_tips map when the block with the given root becomes INVALID.
-func (f *ForkChoice) SetOptimisticToInvalid(ctx context.Context, root [32]byte) error {
+// UpdateSyncedTipsWithInvalidRoot updates the synced_tips map when the block with the given root becomes INVALID.
+func (f *ForkChoice) UpdateSyncedTipsWithInvalidRoot(ctx context.Context, root [32]byte) error {
 	f.store.nodesLock.Lock()
 	defer f.store.nodesLock.Unlock()
 	idx, ok := f.store.nodesIndices[root]

beacon-chain/forkchoice/protoarray/optimistic_sync_test.go

@@ -28,7 +28,9 @@ import (
 
 func TestOptimistic(t *testing.T) {
 	root0 := bytesutil.ToBytes32([]byte("hello0"))
+	slot0 := types.Slot(98)
 	root1 := bytesutil.ToBytes32([]byte("hello1"))
+	slot1 := types.Slot(99)
 
 	nodeA := &Node{
 		slot:      types.Slot(100),
@@ -146,54 +148,56 @@ func TestOptimistic(t *testing.T) {
 	require.Equal(t, max, types.Slot(103), "maximum tip slot is different")
 
 	// We test first nodes outside the Fork Choice store
-	_, err := f.IsOptimistic(ctx, root0)
-	require.ErrorIs(t, errUnknownNodeRoot, err)
+	op, err := f.Optimistic(ctx, root0, slot0)
+	require.NoError(t, err)
+	require.Equal(t, op, false)
 
-	_, err = f.IsOptimistic(ctx, root1)
-	require.ErrorIs(t, errUnknownNodeRoot, err)
+	op, err = f.Optimistic(ctx, root1, slot1)
+	require.NoError(t, err)
+	require.Equal(t, op, false)
 
 	// We check all nodes in the Fork Choice store.
-	op, err := f.IsOptimistic(ctx, nodeA.root)
+	op, err = f.Optimistic(ctx, nodeA.root, nodeA.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, false)
 
-	op, err = f.IsOptimistic(ctx, nodeB.root)
+	op, err = f.Optimistic(ctx, nodeB.root, nodeB.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, false)
 
-	op, err = f.IsOptimistic(ctx, nodeC.root)
+	op, err = f.Optimistic(ctx, nodeC.root, nodeC.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, false)
 
-	op, err = f.IsOptimistic(ctx, nodeD.root)
+	op, err = f.Optimistic(ctx, nodeD.root, nodeD.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, false)
 
-	op, err = f.IsOptimistic(ctx, nodeE.root)
+	op, err = f.Optimistic(ctx, nodeE.root, nodeE.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, true)
 
-	op, err = f.IsOptimistic(ctx, nodeF.root)
+	op, err = f.Optimistic(ctx, nodeF.root, nodeF.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, true)
 
-	op, err = f.IsOptimistic(ctx, nodeG.root)
+	op, err = f.Optimistic(ctx, nodeG.root, nodeG.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, true)
 
-	op, err = f.IsOptimistic(ctx, nodeH.root)
+	op, err = f.Optimistic(ctx, nodeH.root, nodeH.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, true)
 
-	op, err = f.IsOptimistic(ctx, nodeI.root)
+	op, err = f.Optimistic(ctx, nodeI.root, nodeI.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, true)
 
-	op, err = f.IsOptimistic(ctx, nodeJ.root)
+	op, err = f.Optimistic(ctx, nodeJ.root, nodeJ.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, true)
 
-	op, err = f.IsOptimistic(ctx, nodeK.root)
+	op, err = f.Optimistic(ctx, nodeK.root, nodeK.slot)
 	require.NoError(t, err)
 	require.Equal(t, op, true)
 
@@ -216,22 +220,22 @@ func TestOptimistic(t *testing.T) {
 // And every block in the Fork choice is optimistic. Synced_Tips contains a
 // single block that is outside of Fork choice
 //
-func TestSetOptimisticToValid(t *testing.T) {
+func TestUpdateSyncTipsWithValidRoots(t *testing.T) {
 	ctx := context.Background()
 	f := setup(1, 1)
 
-	require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, 1, 1, true))
+	require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, [32]byte{}, 1, 1))
 	tests := []struct {
 		root      [32]byte                // the root of the new VALID block
 		tips      map[[32]byte]types.Slot // the old synced tips
@@ -321,7 +325,7 @@ func TestSetOptimisticToValid(t *testing.T) {
 		f.syncedTips.Lock()
 		f.syncedTips.validatedTips = tc.tips
 		f.syncedTips.Unlock()
-		err := f.SetOptimisticToValid(context.Background(), tc.root)
+		err := f.UpdateSyncedTipsWithValidRoot(context.Background(), tc.root)
 		if tc.wantedErr != nil {
 			require.ErrorIs(t, err, tc.wantedErr)
 		} else {
@@ -348,7 +352,7 @@ func TestSetOptimisticToValid(t *testing.T) {
 // single block that is outside of Fork choice. The numbers in parentheses are
 // the weights of the nodes before removal
 //
-func TestSetOptimisticToInvalid(t *testing.T) {
+func TestUpdateSyncTipsWithInvalidRoot(t *testing.T) {
 	tests := []struct {
 		root              [32]byte                // the root of the new INVALID block
 		tips              map[[32]byte]types.Slot // the old synced tips
@@ -409,18 +413,18 @@ func TestSetOptimisticToInvalid(t *testing.T) {
 		ctx := context.Background()
 		f := setup(1, 1)
 
-		require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, 1, 1, true))
-		require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, 1, 1, true))
+		require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, [32]byte{}, 1, 1))
+		require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, [32]byte{}, 1, 1))
 		weights := []uint64{10, 10, 9, 7, 1, 6, 2, 3, 1, 1, 1, 0, 0}
 		f.syncedTips.Lock()
 		f.syncedTips.validatedTips = tc.tips
@@ -439,7 +443,7 @@ func TestSetOptimisticToInvalid(t *testing.T) {
 		require.NotEqual(t, NonExistentNode, parentIndex)
 		parent := f.store.nodes[parentIndex]
 		f.store.nodesLock.Unlock()
-		err := f.SetOptimisticToInvalid(context.Background(), tc.root)
+		err := f.UpdateSyncedTipsWithInvalidRoot(context.Background(), tc.root)
 		require.NoError(t, err)
 		f.syncedTips.RLock()
 		_, parentSyncedTip := f.syncedTips.validatedTips[parent.root]
@@ -467,18 +471,18 @@ func TestFindSyncedTip(t *testing.T) {
 	ctx := context.Background()
 	f := setup(1, 1)
 
-	require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, 1, 1, true))
+	require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, [32]byte{}, 1, 1))
 	tests := []struct {
 		root   [32]byte                // the root of the block
 		tips   map[[32]byte]types.Slot // the synced tips

beacon-chain/forkchoice/protoarray/proposer_boost_test.go

@@ -21,6 +21,7 @@ import (
 func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 	ctx := context.Background()
 	zeroHash := params.BeaconConfig().ZeroHash
+	graffiti := [32]byte{}
 	balances := make([]uint64, 64) // 64 active validators.
 	for i := 0; i < len(balances); i++ {
 		balances[i] = 10
@@ -46,9 +47,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				slot,
 				newRoot,
 				headRoot,
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 		f.ProcessAttestation(ctx, []uint64{0}, newRoot, fEpoch)
@@ -70,9 +71,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				slot,
 				newRoot,
 				headRoot,
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 		f.ProcessAttestation(ctx, []uint64{1}, newRoot, fEpoch)
@@ -96,9 +97,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				slot,
 				newRoot,
 				headRoot,
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 		f.ProcessAttestation(ctx, []uint64{2}, newRoot, fEpoch)
@@ -122,9 +123,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				slot,
 				newRoot,
 				headRoot,
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 		f.ProcessAttestation(ctx, []uint64{3}, newRoot, fEpoch)
@@ -189,9 +190,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				honestBlockSlot,
 				honestBlock,
 				zeroHash,
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
@@ -206,9 +207,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				maliciouslyWithheldBlockSlot,
 				maliciouslyWithheldBlock,
 				zeroHash,
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 
@@ -255,9 +256,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				honestBlockSlot,
 				honestBlock,
 				zeroHash,
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 
@@ -274,9 +275,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				maliciouslyWithheldBlockSlot,
 				maliciouslyWithheldBlock,
 				zeroHash,
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 
@@ -330,9 +331,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				cSlot,
 				c,
 				a, // parent
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 
@@ -354,9 +355,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				bSlot,
 				b,
 				a, // parent
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 
@@ -378,9 +379,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				dSlot,
 				d,
 				b, // parent
+				graffiti,
 				jEpoch,
 				fEpoch,
-				false,
 			),
 		)
 

beacon-chain/forkchoice/protoarray/store.go

@@ -9,7 +9,6 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"go.opencensus.io/trace"
 )
 
@@ -131,35 +130,17 @@ func (f *ForkChoice) ProcessAttestation(ctx context.Context, validatorIndices []
 	processedAttestationCount.Inc()
 }
 
-// NodeCount returns the current number of nodes in the Store
-func (f *ForkChoice) NodeCount() int {
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-	return len(f.store.nodes)
-}
-
-// ProposerBoost returns the proposerBoost of the store
-func (f *ForkChoice) ProposerBoost() [fieldparams.RootLength]byte {
-	return f.store.proposerBoost()
-}
-
 // ProcessBlock processes a new block by inserting it to the fork choice store.
 func (f *ForkChoice) ProcessBlock(
 	ctx context.Context,
 	slot types.Slot,
-	blockRoot, parentRoot [32]byte,
-	justifiedEpoch, finalizedEpoch types.Epoch, optimistic bool) error {
+	blockRoot, parentRoot, graffiti [32]byte,
+	justifiedEpoch, finalizedEpoch types.Epoch,
+) error {
 	ctx, span := trace.StartSpan(ctx, "protoArrayForkChoice.ProcessBlock")
 	defer span.End()
 
-	if err := f.store.insert(ctx, slot, blockRoot, parentRoot, justifiedEpoch, finalizedEpoch); err != nil {
-		return err
-	}
-
-	if !optimistic {
-		return f.SetOptimisticToValid(ctx, blockRoot)
-	}
-	return nil
+	return f.store.insert(ctx, slot, blockRoot, parentRoot, graffiti, justifiedEpoch, finalizedEpoch)
 }
 
 // Prune prunes the fork choice store with the new finalized root. The store is only pruned if the input
@@ -168,6 +149,36 @@ func (f *ForkChoice) Prune(ctx context.Context, finalizedRoot [32]byte) error {
 	return f.store.prune(ctx, finalizedRoot, f.syncedTips)
 }
 
+// Nodes returns the copied list of block nodes in the fork choice store.
+func (f *ForkChoice) Nodes() []*Node {
+	f.store.nodesLock.RLock()
+	defer f.store.nodesLock.RUnlock()
+
+	cpy := make([]*Node, len(f.store.nodes))
+	copy(cpy, f.store.nodes)
+	return cpy
+}
+
+// Store returns the fork choice store object which contains all the information regarding proto array fork choice.
+func (f *ForkChoice) Store() *Store {
+	f.store.nodesLock.Lock()
+	defer f.store.nodesLock.Unlock()
+	return f.store
+}
+
+// Node returns the copied node in the fork choice store.
+func (f *ForkChoice) Node(root [32]byte) *Node {
+	f.store.nodesLock.RLock()
+	defer f.store.nodesLock.RUnlock()
+
+	index, ok := f.store.nodesIndices[root]
+	if !ok {
+		return nil
+	}
+
+	return copyNode(f.store.nodes[index])
+}
+
 // HasNode returns true if the node exists in fork choice store,
 // false else wise.
 func (f *ForkChoice) HasNode(root [32]byte) bool {
@@ -237,22 +248,36 @@ func (s *Store) PruneThreshold() uint64 {
 }
 
 // JustifiedEpoch of fork choice store.
-func (f *ForkChoice) JustifiedEpoch() types.Epoch {
-	return f.store.justifiedEpoch
+func (s *Store) JustifiedEpoch() types.Epoch {
+	return s.justifiedEpoch
 }
 
 // FinalizedEpoch of fork choice store.
-func (f *ForkChoice) FinalizedEpoch() types.Epoch {
-	return f.store.finalizedEpoch
+func (s *Store) FinalizedEpoch() types.Epoch {
+	return s.finalizedEpoch
 }
 
-// proposerBoost of fork choice store.
-func (s *Store) proposerBoost() [fieldparams.RootLength]byte {
+// ProposerBoost of fork choice store.
+func (s *Store) ProposerBoost() [fieldparams.RootLength]byte {
 	s.proposerBoostLock.RLock()
 	defer s.proposerBoostLock.RUnlock()
 	return s.proposerBoostRoot
 }
 
+// Nodes of fork choice store.
+func (s *Store) Nodes() []*Node {
+	s.nodesLock.RLock()
+	defer s.nodesLock.RUnlock()
+	return s.nodes
+}
+
+// NodesIndices of fork choice store.
+func (s *Store) NodesIndices() map[[32]byte]uint64 {
+	s.nodesLock.RLock()
+	defer s.nodesLock.RUnlock()
+	return s.nodesIndices
+}
+
 // head starts from justified root and then follows the best descendant links
 // to find the best block for head.
 func (s *Store) head(ctx context.Context, justifiedRoot [32]byte) ([32]byte, error) {
@@ -348,7 +373,7 @@ func (s *Store) updateCanonicalNodes(ctx context.Context, root [32]byte) error {
 // It then updates the new node's parent with best child and descendant node.
 func (s *Store) insert(ctx context.Context,
 	slot types.Slot,
-	root, parent [32]byte,
+	root, parent, graffiti [32]byte,
 	justifiedEpoch, finalizedEpoch types.Epoch) error {
 	_, span := trace.StartSpan(ctx, "protoArrayForkChoice.insert")
 	defer span.End()
@@ -371,6 +396,7 @@ func (s *Store) insert(ctx context.Context,
 	n := &Node{
 		slot:           slot,
 		root:           root,
+		graffiti:       graffiti,
 		parent:         parentIndex,
 		justifiedEpoch: justifiedEpoch,
 		finalizedEpoch: finalizedEpoch,
@@ -718,60 +744,3 @@ func (s *Store) leaves() ([]uint64, error) {
 	}
 	return leaves, nil
 }
-
-// Tips returns all possible chain heads (leaves of fork choice tree).
-// Heads roots and heads slots are returned.
-func (f *ForkChoice) Tips() ([][32]byte, []types.Slot) {
-
-	// Deliberate choice to not preallocate space for below.
-	// Heads cant be more than 2-3 in the worst case where pre-allocation will be 64 to begin with.
-	headsRoots := make([][32]byte, 0)
-	headsSlots := make([]types.Slot, 0)
-
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-	for _, node := range f.store.nodes {
-		// Possible heads have no children.
-		if node.BestDescendant() == NonExistentNode && node.BestChild() == NonExistentNode {
-			headsRoots = append(headsRoots, node.Root())
-			headsSlots = append(headsSlots, node.Slot())
-		}
-	}
-	return headsRoots, headsSlots
-}
-
-func (f *ForkChoice) ForkChoiceNodes() []*pbrpc.ForkChoiceNode {
-	f.store.nodesLock.RLock()
-	defer f.store.nodesLock.RUnlock()
-	ret := make([]*pbrpc.ForkChoiceNode, len(f.store.nodes))
-	var parentRoot [32]byte
-	for i, node := range f.store.nodes {
-		root := node.Root()
-		parentIdx := node.parent
-		if parentIdx == NonExistentNode {
-			parentRoot = params.BeaconConfig().ZeroHash
-		} else {
-			parent := f.store.nodes[parentIdx]
-			parentRoot = parent.Root()
-		}
-		bestDescendantIdx := node.BestDescendant()
-		var bestDescendantRoot [32]byte
-		if bestDescendantIdx == NonExistentNode {
-			bestDescendantRoot = params.BeaconConfig().ZeroHash
-		} else {
-			bestDescendantNode := f.store.nodes[bestDescendantIdx]
-			bestDescendantRoot = bestDescendantNode.Root()
-		}
-
-		ret[i] = &pbrpc.ForkChoiceNode{
-			Slot:           node.Slot(),
-			Root:           root[:],
-			Parent:         parentRoot[:],
-			JustifiedEpoch: node.JustifiedEpoch(),
-			FinalizedEpoch: node.FinalizedEpoch(),
-			Weight:         node.Weight(),
-			BestDescendant: bestDescendantRoot[:],
-		}
-	}
-	return ret
-}

beacon-chain/forkchoice/protoarray/store_test.go

@@ -22,14 +22,44 @@ func TestStore_PruneThreshold(t *testing.T) {
 
 func TestStore_JustifiedEpoch(t *testing.T) {
 	j := types.Epoch(100)
-	f := setup(j, j)
-	require.Equal(t, j, f.JustifiedEpoch())
+	s := &Store{
+		justifiedEpoch: j,
+	}
+	if got := s.JustifiedEpoch(); got != j {
+		t.Errorf("JustifiedEpoch() = %v, want %v", got, j)
+	}
 }
 
 func TestStore_FinalizedEpoch(t *testing.T) {
-	j := types.Epoch(50)
-	f := setup(j, j)
-	require.Equal(t, j, f.FinalizedEpoch())
+	f := types.Epoch(50)
+	s := &Store{
+		finalizedEpoch: f,
+	}
+	if got := s.FinalizedEpoch(); got != f {
+		t.Errorf("FinalizedEpoch() = %v, want %v", got, f)
+	}
+}
+
+func TestStore_Nodes(t *testing.T) {
+	nodes := []*Node{
+		{slot: 100},
+		{slot: 101},
+	}
+	s := &Store{
+		nodes: nodes,
+	}
+	require.DeepEqual(t, nodes, s.Nodes())
+}
+
+func TestStore_NodesIndices(t *testing.T) {
+	nodeIndices := map[[32]byte]uint64{
+		{'a'}: 1,
+		{'b'}: 2,
+	}
+	s := &Store{
+		nodesIndices: nodeIndices,
+	}
+	require.DeepEqual(t, nodeIndices, s.NodesIndices())
 }
 
 func TestForkChoice_HasNode(t *testing.T) {
@@ -44,6 +74,30 @@ func TestForkChoice_HasNode(t *testing.T) {
 	require.Equal(t, true, f.HasNode([32]byte{'a'}))
 }
 
+func TestForkChoice_Store(t *testing.T) {
+	nodeIndices := map[[32]byte]uint64{
+		{'a'}: 1,
+		{'b'}: 2,
+	}
+	s := &Store{
+		nodesIndices: nodeIndices,
+	}
+	f := &ForkChoice{store: s}
+	require.DeepEqual(t, s, f.Store())
+}
+
+func TestForkChoice_Nodes(t *testing.T) {
+	nodes := []*Node{
+		{slot: 100},
+		{slot: 101},
+	}
+	s := &Store{
+		nodes: nodes,
+	}
+	f := &ForkChoice{store: s}
+	require.DeepEqual(t, s.nodes, f.Nodes())
+}
+
 func TestStore_Head_UnknownJustifiedRoot(t *testing.T) {
 	s := &Store{nodesIndices: make(map[[32]byte]uint64)}
 
@@ -101,7 +155,7 @@ func TestStore_Head_ContextCancelled(t *testing.T) {
 func TestStore_Insert_UnknownParent(t *testing.T) {
 	// The new node does not have a parent.
 	s := &Store{nodesIndices: make(map[[32]byte]uint64)}
-	require.NoError(t, s.insert(context.Background(), 100, [32]byte{'A'}, [32]byte{'B'}, 1, 1))
+	require.NoError(t, s.insert(context.Background(), 100, [32]byte{'A'}, [32]byte{'B'}, [32]byte{}, 1, 1))
 	assert.Equal(t, 1, len(s.nodes), "Did not insert block")
 	assert.Equal(t, 1, len(s.nodesIndices), "Did not insert block")
 	assert.Equal(t, NonExistentNode, s.nodes[0].parent, "Incorrect parent")
@@ -117,7 +171,7 @@ func TestStore_Insert_KnownParent(t *testing.T) {
 	s.nodes = []*Node{{}}
 	p := [32]byte{'B'}
 	s.nodesIndices[p] = 0
-	require.NoError(t, s.insert(context.Background(), 100, [32]byte{'A'}, p, 1, 1))
+	require.NoError(t, s.insert(context.Background(), 100, [32]byte{'A'}, p, [32]byte{}, 1, 1))
 	assert.Equal(t, 2, len(s.nodes), "Did not insert block")
 	assert.Equal(t, 2, len(s.nodesIndices), "Did not insert block")
 	assert.Equal(t, uint64(0), s.nodes[1].parent, "Incorrect parent")
@@ -491,18 +545,18 @@ func TestStore_PruneSyncedTips(t *testing.T) {
 	ctx := context.Background()
 	f := setup(1, 1)
 
-	require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, 1, 1, true))
-	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, 1, 1, true))
+	require.NoError(t, f.ProcessBlock(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, [32]byte{}, 1, 1))
+	require.NoError(t, f.ProcessBlock(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, [32]byte{}, 1, 1))
 	syncedTips := &optimisticStore{
 		validatedTips: map[[32]byte]types.Slot{
 			[32]byte{'b'}: 101,
@@ -667,10 +721,8 @@ func TestStore_UpdateCanonicalNodes_WholeList(t *testing.T) {
 	require.Equal(t, true, f.IsCanonical([32]byte{'a'}))
 	require.Equal(t, true, f.IsCanonical([32]byte{'b'}))
 	require.Equal(t, true, f.IsCanonical([32]byte{'c'}))
-	idxc := f.store.nodesIndices[[32]byte{'c'}]
-	_, ok := f.store.nodesIndices[[32]byte{'d'}]
-	require.Equal(t, idxc, uint64(2))
-	require.Equal(t, false, ok)
+	require.DeepEqual(t, f.Node([32]byte{'c'}), f.store.nodes[2])
+	require.Equal(t, f.Node([32]byte{'d'}), (*Node)(nil))
 }
 
 func TestStore_UpdateCanonicalNodes_ParentAlreadyIn(t *testing.T) {

beacon-chain/forkchoice/protoarray/vote_test.go

@@ -23,7 +23,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//         0
 	//        /
 	//       2 <- head
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, [32]byte{}, 1, 1))
 
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
@@ -33,7 +33,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//            0
 	//           / \
 	//  head -> 2  1
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, [32]byte{}, 1, 1))
 
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
@@ -63,7 +63,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//  head -> 2  1
 	//             |
 	//             3
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(3), indexToHash(1), 1, 1, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(3), indexToHash(1), [32]byte{}, 1, 1))
 
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
@@ -99,7 +99,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//             3
 	//             |
 	//             4 <- head
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(4), indexToHash(3), 1, 1, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(4), indexToHash(3), [32]byte{}, 1, 1))
 
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
@@ -115,7 +115,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//             4 <- head
 	//            /
 	//           5 <- justified epoch = 2
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(5), indexToHash(4), 2, 2, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(5), indexToHash(4), [32]byte{}, 2, 2))
 
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
@@ -131,7 +131,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//             4 <- head
 	//            / \
 	//           5  6 <- justified epoch = 0
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(6), indexToHash(4), 1, 1, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(6), indexToHash(4), [32]byte{}, 1, 1))
 
 	// Moved 2 votes to block 5:
 	//            0
@@ -143,7 +143,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//             4
 	//            / \
 	// 2 votes-> 5  6
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(6), indexToHash(4), 1, 1, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(6), indexToHash(4), [32]byte{}, 1, 1))
 
 	f.ProcessAttestation(context.Background(), []uint64{0, 1}, indexToHash(5), 4)
 
@@ -164,9 +164,9 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//           8
 	//           |
 	//           9
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(7), indexToHash(5), 2, 2, true))
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(8), indexToHash(7), 2, 2, true))
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(9), indexToHash(8), 2, 2, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(7), indexToHash(5), [32]byte{}, 2, 2))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(8), indexToHash(7), [32]byte{}, 2, 2))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(9), indexToHash(8), [32]byte{}, 2, 2))
 
 	r, err = f.Head(context.Background(), 1, params.BeaconConfig().ZeroHash, balances, 1)
 	require.NoError(t, err)
@@ -211,7 +211,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//           / \
 	// 2 votes->9  10
 	f.ProcessAttestation(context.Background(), []uint64{0, 1}, indexToHash(9), 5)
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(10), indexToHash(8), 2, 2, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(10), indexToHash(8), [32]byte{}, 2, 2))
 
 	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
 	require.NoError(t, err)
@@ -290,7 +290,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//        9  10
 	//        |
 	// head-> 11
-	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(11), indexToHash(9), 2, 2, true))
+	require.NoError(t, f.ProcessBlock(context.Background(), 0, indexToHash(11), indexToHash(9), [32]byte{}, 2, 2))
 
 	r, err = f.Head(context.Background(), 2, indexToHash(5), balances, 2)
 	require.NoError(t, err)

beacon-chain/node/BUILD.bazel

@@ -24,7 +24,6 @@ go_library(
         "//beacon-chain/db/slasherkv:go_default_library",
         "//beacon-chain/deterministic-genesis:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
-        "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/gateway:go_default_library",
         "//beacon-chain/monitor:go_default_library",

beacon-chain/node/node.go

@@ -27,7 +27,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/slasherkv"
 	interopcoldstart "github.com/prysmaticlabs/prysm/beacon-chain/deterministic-genesis"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/gateway"
 	"github.com/prysmaticlabs/prysm/beacon-chain/monitor"
@@ -120,7 +119,6 @@ func New(cliCtx *cli.Context, opts ...Option) (*BeaconNode, error) {
 	configureEth1Config(cliCtx)
 	configureNetwork(cliCtx)
 	configureInteropConfig(cliCtx)
-	configureExecutionSetting(cliCtx)
 
 	// Initializes any forks here.
 	params.BeaconConfig().InitializeForkSchedule()
@@ -312,11 +310,8 @@ func (b *BeaconNode) Close() {
 }
 
 func (b *BeaconNode) startForkChoice() {
-	if features.Get().EnableForkChoiceDoublyLinkedTree {
-		b.forkChoiceStore = doublylinkedtree.New(0, 0)
-	} else {
-		b.forkChoiceStore = protoarray.New(0, 0, params.BeaconConfig().ZeroHash)
-	}
+	f := protoarray.New(0, 0, params.BeaconConfig().ZeroHash)
+	b.forkChoiceStore = f
 }
 
 func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
@@ -559,7 +554,6 @@ func (b *BeaconNode) registerBlockchainService() error {
 		blockchain.WithDatabase(b.db),
 		blockchain.WithDepositCache(b.depositCache),
 		blockchain.WithChainStartFetcher(web3Service),
-		blockchain.WithExecutionEngineCaller(web3Service.EngineAPIClient()),
 		blockchain.WithAttestationPool(b.attestationPool),
 		blockchain.WithExitPool(b.exitPool),
 		blockchain.WithSlashingPool(b.slashingsPool),
@@ -786,7 +780,6 @@ func (b *BeaconNode) registerRPCService() error {
 		StateGen:                b.stateGen,
 		EnableDebugRPCEndpoints: enableDebugRPCEndpoints,
 		MaxMsgSize:              maxMsgSize,
-		ExecutionEngineCaller:   web3Service.EngineAPIClient(),
 	})
 
 	return b.services.RegisterService(rpcService)
@@ -815,6 +808,8 @@ func (b *BeaconNode) registerPrometheusService(cliCtx *cli.Context) error {
 		)
 	}
 
+	additionalHandlers = append(additionalHandlers, prometheus.Handler{Path: "/tree", Handler: c.TreeHandler})
+
 	service := prometheus.NewService(
 		fmt.Sprintf("%s:%d", b.cliCtx.String(cmd.MonitoringHostFlag.Name), b.cliCtx.Int(flags.MonitoringPortFlag.Name)),
 		b.services,

beacon-chain/p2p/pubsub.go

@@ -89,7 +89,7 @@ func (s *Service) PublishToTopic(ctx context.Context, topic string, data []byte,
 		}
 		select {
 		case <-ctx.Done():
-			return errors.Wrapf(ctx.Err(), "unable to find requisite number of peers for topic %s, 0 peers found to publish to", topic)
+			return ctx.Err()
 		default:
 			time.Sleep(100 * time.Millisecond)
 		}

beacon-chain/p2p/subnets.go

@@ -62,8 +62,7 @@ func (s *Service) FindPeersWithSubnet(ctx context.Context, topic string,
 	wg := new(sync.WaitGroup)
 	for {
 		if err := ctx.Err(); err != nil {
-			return false, errors.Errorf("unable to find requisite number of peers for topic %s - "+
-				"only %d out of %d peers were able to be found", topic, currNum, threshold)
+			return false, err
 		}
 		if currNum >= threshold {
 			break

beacon-chain/powchain/engine-api-client/v1/mocks/BUILD.bazel

@@ -8,6 +8,5 @@ go_library(
     deps = [
         "//proto/engine/v1:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
     ],
 )

beacon-chain/powchain/engine-api-client/v1/mocks/client.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/pkg/errors"
 	pb "github.com/prysmaticlabs/prysm/proto/engine/v1"
 )
 
@@ -14,12 +13,8 @@ type EngineClient struct {
 	PayloadIDBytes        *pb.PayloadIDBytes
 	ForkChoiceUpdatedResp []byte
 	ExecutionPayload      *pb.ExecutionPayload
-	ExecutionBlock        *pb.ExecutionBlock
 	Err                   error
-	ErrLatestExecBlock    error
-	ErrExecBlockByHash    error
-	ErrForkchoiceUpdated  error
-	BlockByHashMap        map[[32]byte]*pb.ExecutionBlock
+	ExecutionBlock        *pb.ExecutionBlock
 }
 
 // NewPayload --
@@ -31,7 +26,7 @@ func (e *EngineClient) NewPayload(_ context.Context, _ *pb.ExecutionPayload) ([]
 func (e *EngineClient) ForkchoiceUpdated(
 	_ context.Context, _ *pb.ForkchoiceState, _ *pb.PayloadAttributes,
 ) (*pb.PayloadIDBytes, []byte, error) {
-	return e.PayloadIDBytes, e.ForkChoiceUpdatedResp, e.ErrForkchoiceUpdated
+	return e.PayloadIDBytes, e.ForkChoiceUpdatedResp, nil
 }
 
 // GetPayload --
@@ -46,14 +41,10 @@ func (e *EngineClient) ExchangeTransitionConfiguration(_ context.Context, _ *pb.
 
 // LatestExecutionBlock --
 func (e *EngineClient) LatestExecutionBlock(_ context.Context) (*pb.ExecutionBlock, error) {
-	return e.ExecutionBlock, e.ErrLatestExecBlock
+	return e.ExecutionBlock, nil
 }
 
 // ExecutionBlockByHash --
-func (e *EngineClient) ExecutionBlockByHash(_ context.Context, h common.Hash) (*pb.ExecutionBlock, error) {
-	b, ok := e.BlockByHashMap[h]
-	if !ok {
-		return nil, errors.New("block not found")
-	}
-	return b, e.ErrExecBlockByHash
+func (e *EngineClient) ExecutionBlockByHash(_ context.Context, _ common.Hash) (*pb.ExecutionBlock, error) {
+	return e.ExecutionBlock, nil
 }

beacon-chain/rpc/BUILD.bazel

@@ -22,7 +22,6 @@ go_library(
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
-        "//beacon-chain/powchain/engine-api-client/v1:go_default_library",
         "//beacon-chain/rpc/eth/beacon:go_default_library",
         "//beacon-chain/rpc/eth/debug:go_default_library",
         "//beacon-chain/rpc/eth/events:go_default_library",

beacon-chain/rpc/apimiddleware/custom_hooks.go

@@ -342,13 +342,8 @@ type phase0StateResponseJson struct {
 }
 
 type altairStateResponseJson struct {
-	Version string                 `json:"version"`
-	Data    *beaconStateAltairJson `json:"data"`
-}
-
-type bellatrixStateResponseJson struct {
-	Version string                    `json:"version"`
-	Data    *beaconStateBellatrixJson `json:"data"`
+	Version string             `json:"version"`
+	Data    *beaconStateV2Json `json:"data"`
 }
 
 func serializeV2State(response interface{}) (apimiddleware.RunDefault, []byte, apimiddleware.ErrorJson) {
@@ -358,23 +353,17 @@ func serializeV2State(response interface{}) (apimiddleware.RunDefault, []byte, a
 	}
 
 	var actualRespContainer interface{}
-	switch {
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_PHASE0.String())):
+	if strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_PHASE0.String())) {
 		actualRespContainer = &phase0StateResponseJson{
 			Version: respContainer.Version,
 			Data:    respContainer.Data.Phase0State,
 		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_ALTAIR.String())):
+	} else if strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_ALTAIR.String())) {
 		actualRespContainer = &altairStateResponseJson{
 			Version: respContainer.Version,
 			Data:    respContainer.Data.AltairState,
 		}
-	case strings.EqualFold(respContainer.Version, strings.ToLower(ethpbv2.Version_BELLATRIX.String())):
-		actualRespContainer = &bellatrixStateResponseJson{
-			Version: respContainer.Version,
-			Data:    respContainer.Data.BellatrixState,
-		}
-	default:
+	} else {
 		return false, nil, apimiddleware.InternalServerError(fmt.Errorf("unsupported state version '%s'", respContainer.Version))
 	}
 

beacon-chain/rpc/apimiddleware/custom_hooks_test.go

@@ -564,7 +564,7 @@ func TestSerializeV2State(t *testing.T) {
 			Version: ethpbv2.Version_ALTAIR.String(),
 			Data: &beaconStateContainerV2Json{
 				Phase0State: nil,
-				AltairState: &beaconStateAltairJson{},
+				AltairState: &beaconStateV2Json{},
 			},
 		}
 		runDefault, j, errJson := serializeV2State(response)
@@ -574,21 +574,6 @@ func TestSerializeV2State(t *testing.T) {
 		require.NoError(t, json.Unmarshal(j, &altairStateResponseJson{}))
 	})
 
-	t.Run("Bellatrix", func(t *testing.T) {
-		response := &beaconStateV2ResponseJson{
-			Version: ethpbv2.Version_BELLATRIX.String(),
-			Data: &beaconStateContainerV2Json{
-				Phase0State:    nil,
-				BellatrixState: &beaconStateBellatrixJson{},
-			},
-		}
-		runDefault, j, errJson := serializeV2State(response)
-		require.Equal(t, nil, errJson)
-		require.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		require.NotNil(t, j)
-		require.NoError(t, json.Unmarshal(j, &bellatrixStateResponseJson{}))
-	})
-
 	t.Run("incorrect response type", func(t *testing.T) {
 		runDefault, j, errJson := serializeV2State(&types.Empty{})
 		require.Equal(t, apimiddleware.RunDefault(false), runDefault)

beacon-chain/rpc/apimiddleware/structs.go

@@ -403,23 +403,6 @@ type executionPayloadJson struct {
 	Transactions  []string `json:"transactions" hex:"true"`
 }
 
-type executionPayloadHeaderJson struct {
-	ParentHash       string `json:"parent_hash" hex:"true"`
-	CoinBase         string `json:"coinbase" hex:"true"`
-	StateRoot        string `json:"state_root" hex:"true"`
-	ReceiptRoot      string `json:"receipt_root" hex:"true"`
-	LogsBloom        string `json:"logs_bloom" hex:"true"`
-	Random           string `json:"random" hex:"true"`
-	BlockNumber      string `json:"block_number"`
-	GasLimit         string `json:"gas_limit"`
-	GasUsed          string `json:"gas_used"`
-	TimeStamp        string `json:"timestamp"`
-	ExtraData        string `json:"extra_data" hex:"true"`
-	BaseFeePerGas    string `json:"base_fee_per_gas" hex:"true"`
-	BlockHash        string `json:"block_hash" hex:"true"`
-	TransactionsRoot string `json:"transactions_root" hex:"true"`
-}
-
 type syncAggregateJson struct {
 	SyncCommitteeBits      string `json:"sync_committee_bits" hex:"true"`
 	SyncCommitteeSignature string `json:"sync_committee_signature" hex:"true"`
@@ -563,7 +546,7 @@ type beaconStateJson struct {
 	FinalizedCheckpoint         *checkpointJson           `json:"finalized_checkpoint"`
 }
 
-type beaconStateAltairJson struct {
+type beaconStateV2Json struct {
 	GenesisTime                 string                 `json:"genesis_time"`
 	GenesisValidatorsRoot       string                 `json:"genesis_validators_root" hex:"true"`
 	Slot                        string                 `json:"slot"`
@@ -590,38 +573,9 @@ type beaconStateAltairJson struct {
 	NextSyncCommittee           *syncCommitteeJson     `json:"next_sync_committee"`
 }
 
-type beaconStateBellatrixJson struct {
-	GenesisTime                  string                      `json:"genesis_time"`
-	GenesisValidatorsRoot        string                      `json:"genesis_validators_root" hex:"true"`
-	Slot                         string                      `json:"slot"`
-	Fork                         *forkJson                   `json:"fork"`
-	LatestBlockHeader            *beaconBlockHeaderJson      `json:"latest_block_header"`
-	BlockRoots                   []string                    `json:"block_roots" hex:"true"`
-	StateRoots                   []string                    `json:"state_roots" hex:"true"`
-	HistoricalRoots              []string                    `json:"historical_roots" hex:"true"`
-	Eth1Data                     *eth1DataJson               `json:"eth1_data"`
-	Eth1DataVotes                []*eth1DataJson             `json:"eth1_data_votes"`
-	Eth1DepositIndex             string                      `json:"eth1_deposit_index"`
-	Validators                   []*validatorJson            `json:"validators"`
-	Balances                     []string                    `json:"balances"`
-	RandaoMixes                  []string                    `json:"randao_mixes" hex:"true"`
-	Slashings                    []string                    `json:"slashings"`
-	PreviousEpochParticipation   EpochParticipation          `json:"previous_epoch_participation"`
-	CurrentEpochParticipation    EpochParticipation          `json:"current_epoch_participation"`
-	JustificationBits            string                      `json:"justification_bits" hex:"true"`
-	PreviousJustifiedCheckpoint  *checkpointJson             `json:"previous_justified_checkpoint"`
-	CurrentJustifiedCheckpoint   *checkpointJson             `json:"current_justified_checkpoint"`
-	FinalizedCheckpoint          *checkpointJson             `json:"finalized_checkpoint"`
-	InactivityScores             []string                    `json:"inactivity_scores"`
-	CurrentSyncCommittee         *syncCommitteeJson          `json:"current_sync_committee"`
-	NextSyncCommittee            *syncCommitteeJson          `json:"next_sync_committee"`
-	LatestExecutionPayloadHeader *executionPayloadHeaderJson `json:"latest_execution_payload_header"`
-}
-
 type beaconStateContainerV2Json struct {
-	Phase0State    *beaconStateJson          `json:"phase0_state"`
-	AltairState    *beaconStateAltairJson    `json:"altair_state"`
-	BellatrixState *beaconStateBellatrixJson `json:"bellatrix_state"`
+	Phase0State *beaconStateJson   `json:"phase0_state"`
+	AltairState *beaconStateV2Json `json:"altair_state"`
 }
 
 type forkJson struct {

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

@@ -15,6 +15,7 @@ import (
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/proto/migration"
+	ethpbalpha "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"go.opencensus.io/trace"
@@ -180,10 +181,11 @@ func (bs *Server) SubmitBlock(ctx context.Context, req *ethpbv2.SignedBeaconBloc
 		if err := bs.BlockReceiver.ReceiveBlock(ctx, wrappedPhase0Blk, root); err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not process beacon block: %v", err)
 		}
-	}
-
-	altairBlkContainer, ok := req.Message.(*ethpbv2.SignedBeaconBlockContainerV2_AltairBlock)
-	if ok {
+	} else {
+		altairBlkContainer, ok := req.Message.(*ethpbv2.SignedBeaconBlockContainerV2_AltairBlock)
+		if !ok {
+			return nil, status.Errorf(codes.InvalidArgument, "Could not get Altair block from request")
+		}
 		altairBlk := altairBlkContainer.AltairBlock
 		v1alpha1Blk, err := migration.AltairToV1Alpha1SignedBlock(&ethpbv2.SignedBeaconBlockAltair{Message: altairBlk, Signature: req.Signature})
 		if err != nil {
@@ -219,43 +221,6 @@ func (bs *Server) SubmitBlock(ctx context.Context, req *ethpbv2.SignedBeaconBloc
 		}
 	}
 
-	bellatrixBlkContainer, ok := req.Message.(*ethpbv2.SignedBeaconBlockContainerV2_BellatrixBlock)
-	if ok {
-		bellatrixBlk := bellatrixBlkContainer.BellatrixBlock
-		v1alpha1Blk, err := migration.BellatrixToV1Alpha1SignedBlock(&ethpbv2.SignedBeaconBlockBellatrix{Message: bellatrixBlk, Signature: req.Signature})
-		if err != nil {
-			return nil, status.Errorf(codes.InvalidArgument, "Could not convert block to v1 block")
-		}
-		wrappedBellatrixBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(v1alpha1Blk)
-		if err != nil {
-			return nil, status.Errorf(codes.InvalidArgument, "Could not prepare bellatrix block")
-		}
-
-		root, err := bellatrixBlk.HashTreeRoot()
-		if err != nil {
-			return nil, status.Errorf(codes.InvalidArgument, "Could not tree hash block: %v", err)
-		}
-
-		// Do not block proposal critical path with debug logging or block feed updates.
-		defer func() {
-			log.WithField("blockRoot", fmt.Sprintf("%#x", bytesutil.Trunc(root[:]))).Debugf(
-				"Block proposal received via RPC")
-			bs.BlockNotifier.BlockFeed().Send(&feed.Event{
-				Type: blockfeed.ReceivedBlock,
-				Data: &blockfeed.ReceivedBlockData{SignedBlock: wrappedBellatrixBlk},
-			})
-		}()
-
-		// Broadcast the new block to the network.
-		if err := bs.Broadcaster.Broadcast(ctx, wrappedBellatrixBlk.Proto()); err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not broadcast block: %v", err)
-		}
-
-		if err := bs.BlockReceiver.ReceiveBlock(ctx, wrappedBellatrixBlk, root); err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not process beacon block: %v", err)
-		}
-	}
-
 	return &emptypb.Empty{}, nil
 }
 
@@ -309,14 +274,12 @@ func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (
 	ctx, span := trace.StartSpan(ctx, "beacon.GetBlockV2")
 	defer span.End()
 
-	blk, err := bs.blockFromBlockID(ctx, req.BlockId)
+	blk, phase0Blk, err := bs.blocksFromId(ctx, req.BlockId)
 	err = handleGetBlockError(blk, err)
 	if err != nil {
 		return nil, err
 	}
-
-	_, err = blk.PbPhase0Block()
-	if err == nil {
+	if phase0Blk != nil {
 		v1Blk, err := migration.SignedBeaconBlock(blk)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
@@ -329,38 +292,29 @@ func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (
 			},
 		}, nil
 	}
-	// ErrUnsupportedPhase0Block means that we have another block type
-	if !errors.Is(err, wrapper.ErrUnsupportedPhase0Block) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-
-	altairBlk, err := blk.PbAltairBlock()
-	if err == nil {
-		if altairBlk == nil {
-			return nil, status.Errorf(codes.Internal, "Nil block")
-		}
-		v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-		}
-		return &ethpbv2.BlockResponseV2{
-			Version: ethpbv2.Version_ALTAIR,
-			Data: &ethpbv2.SignedBeaconBlockContainerV2{
-				Message:   &ethpbv2.SignedBeaconBlockContainerV2_AltairBlock{AltairBlock: v2Blk},
-				Signature: blk.Signature(),
-			},
-		}, nil
-	}
-	// ErrUnsupportedAltairBlock means that we have another block type
-	if !errors.Is(err, wrapper.ErrUnsupportedAltairBlock) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
 
 	bellatrixBlk, err := blk.PbBellatrixBlock()
-	if err == nil {
-		if bellatrixBlk == nil {
-			return nil, status.Errorf(codes.Internal, "Nil block")
+	if err != nil {
+		altairBlk, err := blk.PbAltairBlock()
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not check for block")
 		}
+		if altairBlk != nil {
+			v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block)
+			if err != nil {
+				return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
+			}
+			return &ethpbv2.BlockResponseV2{
+				Version: ethpbv2.Version_ALTAIR,
+				Data: &ethpbv2.SignedBeaconBlockContainerV2{
+					Message:   &ethpbv2.SignedBeaconBlockContainerV2_AltairBlock{AltairBlock: v2Blk},
+					Signature: blk.Signature(),
+				},
+			}, nil
+		}
+		return nil, status.Errorf(codes.Internal, "Could not check for block")
+	}
+	if bellatrixBlk != nil {
 		v2Blk, err := migration.V1Alpha1BeaconBlockBellatrixToV2(bellatrixBlk.Block)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
@@ -373,12 +327,8 @@ func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (
 			},
 		}, nil
 	}
-	// ErrUnsupportedBellatrixBlock means that we have another block type
-	if !errors.Is(err, wrapper.ErrUnsupportedBellatrixBlock) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
 
-	return nil, status.Errorf(codes.Internal, "Unknown block type %T", blk)
+	return nil, nil
 }
 
 // GetBlockSSZV2 returns the SSZ-serialized version of the beacon block for given block ID.
@@ -386,14 +336,12 @@ func (bs *Server) GetBlockSSZV2(ctx context.Context, req *ethpbv2.BlockRequestV2
 	ctx, span := trace.StartSpan(ctx, "beacon.GetBlockSSZV2")
 	defer span.End()
 
-	blk, err := bs.blockFromBlockID(ctx, req.BlockId)
+	blk, phase0Blk, err := bs.blocksFromId(ctx, req.BlockId)
 	err = handleGetBlockError(blk, err)
 	if err != nil {
 		return nil, err
 	}
-
-	_, err = blk.PbPhase0Block()
-	if err == nil {
+	if phase0Blk != nil {
 		signedBeaconBlock, err := migration.SignedBeaconBlock(blk)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
@@ -404,60 +352,23 @@ func (bs *Server) GetBlockSSZV2(ctx context.Context, req *ethpbv2.BlockRequestV2
 		}
 		return &ethpbv2.BlockSSZResponseV2{Version: ethpbv2.Version_PHASE0, Data: sszBlock}, nil
 	}
-	// ErrUnsupportedPhase0Block means that we have another block type
-	if !errors.Is(err, wrapper.ErrUnsupportedPhase0Block) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-
 	altairBlk, err := blk.PbAltairBlock()
-	if err == nil {
-		if altairBlk == nil {
-			return nil, status.Errorf(codes.Internal, "Nil block")
-		}
-		v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-		}
-		data := &ethpbv2.SignedBeaconBlockAltair{
-			Message:   v2Blk,
-			Signature: blk.Signature(),
-		}
-		sszData, err := data.MarshalSSZ()
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not marshal block into SSZ: %v", err)
-		}
-		return &ethpbv2.BlockSSZResponseV2{Version: ethpbv2.Version_ALTAIR, Data: sszData}, nil
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check for Altair block")
 	}
-	// ErrUnsupportedAltairBlock means that we have another block type
-	if !errors.Is(err, wrapper.ErrUnsupportedAltairBlock) {
+	v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block)
+	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
 	}
-
-	bellatrixBlk, err := blk.PbBellatrixBlock()
-	if err == nil {
-		if bellatrixBlk == nil {
-			return nil, status.Errorf(codes.Internal, "Nil block")
-		}
-		v2Blk, err := migration.V1Alpha1BeaconBlockBellatrixToV2(bellatrixBlk.Block)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-		}
-		data := &ethpbv2.SignedBeaconBlockBellatrix{
-			Message:   v2Blk,
-			Signature: blk.Signature(),
-		}
-		sszData, err := data.MarshalSSZ()
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not marshal block into SSZ: %v", err)
-		}
-		return &ethpbv2.BlockSSZResponseV2{Version: ethpbv2.Version_BELLATRIX, Data: sszData}, nil
+	data := &ethpbv2.SignedBeaconBlockAltair{
+		Message:   v2Blk,
+		Signature: blk.Signature(),
 	}
-	// ErrUnsupportedBellatrixBlock means that we have another block type
-	if !errors.Is(err, wrapper.ErrUnsupportedBellatrixBlock) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
+	sszData, err := data.MarshalSSZ()
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not marshal block into SSZ: %v", err)
 	}
-
-	return nil, status.Errorf(codes.Internal, "Unknown block type %T", blk)
+	return &ethpbv2.BlockSSZResponseV2{Version: ethpbv2.Version_ALTAIR, Data: sszData}, nil
 }
 
 // GetBlockRoot retrieves hashTreeRoot of BeaconBlock/BeaconBlockHeader.
@@ -544,17 +455,11 @@ func (bs *Server) ListBlockAttestations(ctx context.Context, req *ethpbv1.BlockR
 	ctx, span := trace.StartSpan(ctx, "beacon.ListBlockAttestations")
 	defer span.End()
 
-	blk, err := bs.blockFromBlockID(ctx, req.BlockId)
-	err = handleGetBlockError(blk, err)
+	blk, phase0Blk, err := bs.blocksFromId(ctx, req.BlockId)
 	if err != nil {
-		return nil, err
+		return nil, status.Errorf(codes.Internal, "Could not get block: %v", err)
 	}
-
-	_, err = blk.PbPhase0Block()
-	if err != nil && !errors.Is(err, wrapper.ErrUnsupportedPhase0Block) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-	}
-	if err == nil {
+	if phase0Blk != nil {
 		v1Blk, err := migration.SignedBeaconBlock(blk)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
@@ -563,42 +468,36 @@ func (bs *Server) ListBlockAttestations(ctx context.Context, req *ethpbv1.BlockR
 			Data: v1Blk.Block.Body.Attestations,
 		}, nil
 	}
-
 	altairBlk, err := blk.PbAltairBlock()
-	if err != nil && !errors.Is(err, wrapper.ErrUnsupportedAltairBlock) {
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check for Altair block")
+	}
+	v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block)
+	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
 	}
-	if err == nil {
-		if altairBlk == nil {
-			return nil, status.Errorf(codes.Internal, "Nil block")
-		}
-		v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-		}
-		return &ethpbv1.BlockAttestationsResponse{
-			Data: v2Blk.Body.Attestations,
-		}, nil
-	}
+	return &ethpbv1.BlockAttestationsResponse{
+		Data: v2Blk.Body.Attestations,
+	}, nil
+}
 
-	bellatrixBlock, err := blk.PbBellatrixBlock()
-	if err != nil && !errors.Is(err, wrapper.ErrUnsupportedBellatrixBlock) {
-		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
+func (bs *Server) blocksFromId(ctx context.Context, blockId []byte) (
+	signedBlock block.SignedBeaconBlock,
+	phase0Block *ethpbalpha.SignedBeaconBlock,
+	err error,
+) {
+	blk, err := bs.blockFromBlockID(ctx, blockId)
+	err = handleGetBlockError(blk, err)
+	if err != nil {
+		return nil, nil, err
 	}
-	if err == nil {
-		if bellatrixBlock == nil {
-			return nil, status.Errorf(codes.Internal, "Nil block")
-		}
-		v2Blk, err := migration.V1Alpha1BeaconBlockBellatrixToV2(bellatrixBlock.Block)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
-		}
-		return &ethpbv1.BlockAttestationsResponse{
-			Data: v2Blk.Body.Attestations,
-		}, nil
+	phase0Blk, err := blk.PbPhase0Block()
+	// Assume we have an Altair block when Phase 0 block is unsupported.
+	// In such case we continue with the rest of the function.
+	if err != nil && !errors.Is(err, wrapper.ErrUnsupportedPhase0Block) {
+		return nil, nil, errors.New("Could not check for phase 0 block")
 	}
-
-	return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
+	return blk, phase0Blk, nil
 }
 
 func (bs *Server) blockFromBlockID(ctx context.Context, blockId []byte) (block.SignedBeaconBlock, error) {

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

@@ -410,47 +410,6 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
 		_, err = beaconChainServer.SubmitBlock(context.Background(), blockReq)
 		assert.NoError(t, err, "Could not propose block correctly")
 	})
-
-	t.Run("Bellatrix", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		genesis := util.NewBeaconBlockBellatrix()
-		wrapped, err := wrapper.WrappedBellatrixSignedBeaconBlock(genesis)
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapped), "Could not save genesis block")
-
-		numDeposits := uint64(64)
-		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
-		bsRoot, err := beaconState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		genesisRoot, err := genesis.Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
-
-		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
-		beaconChainServer := &Server{
-			BeaconDB:         beaconDB,
-			BlockReceiver:    c,
-			ChainInfoFetcher: c,
-			BlockNotifier:    c.BlockNotifier(),
-			Broadcaster:      mockp2p.NewTestP2P(t),
-		}
-		req := util.NewBeaconBlockBellatrix()
-		req.Block.Slot = 5
-		req.Block.ParentRoot = bsRoot[:]
-		v2Block, err := migration.V1Alpha1BeaconBlockBellatrixToV2(req.Block)
-		require.NoError(t, err)
-		wrapped, err = wrapper.WrappedBellatrixSignedBeaconBlock(req)
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveBlock(ctx, wrapped))
-		blockReq := &ethpbv2.SignedBeaconBlockContainerV2{
-			Message:   &ethpbv2.SignedBeaconBlockContainerV2_BellatrixBlock{BellatrixBlock: v2Block},
-			Signature: req.Signature,
-		}
-		_, err = beaconChainServer.SubmitBlock(context.Background(), blockReq)
-		assert.NoError(t, err, "Could not propose block correctly")
-	})
 }
 
 func TestServer_GetBlock(t *testing.T) {
@@ -1016,45 +975,6 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
 		assert.DeepEqual(t, sszBlock, resp.Data)
 		assert.Equal(t, ethpbv2.Version_ALTAIR, resp.Version)
 	})
-
-	t.Run("Bellatrix", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		_, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
-		headBlock := blkContainers[len(blkContainers)-1]
-
-		b2 := util.NewBeaconBlockBellatrix()
-		b2.Block.Slot = 30
-		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-		signedBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(b2)
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
-
-		chainBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.GetBellatrixBlock())
-		require.NoError(t, err)
-		bs := &Server{
-			BeaconDB: beaconDB,
-			ChainInfoFetcher: &mock.ChainService{
-				DB:                  beaconDB,
-				Block:               chainBlk,
-				Root:                headBlock.BlockRoot,
-				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-			},
-		}
-
-		ok, blocks, err := beaconDB.BlocksBySlot(ctx, 30)
-		require.Equal(t, true, ok)
-		require.NoError(t, err)
-		sszBlock, err := blocks[0].MarshalSSZ()
-		require.NoError(t, err)
-
-		resp, err := bs.GetBlockSSZV2(ctx, &ethpbv2.BlockRequestV2{BlockId: []byte("30")})
-		require.NoError(t, err)
-		assert.NotNil(t, resp)
-		assert.DeepEqual(t, sszBlock, resp.Data)
-		assert.Equal(t, ethpbv2.Version_BELLATRIX, resp.Version)
-	})
 }
 
 func TestServer_GetBlockRoot(t *testing.T) {
@@ -1355,104 +1275,4 @@ func TestServer_ListBlockAttestations(t *testing.T) {
 			})
 		}
 	})
-
-	t.Run("Bellatrix", func(t *testing.T) {
-		beaconDB := dbTest.SetupDB(t)
-		ctx := context.Background()
-
-		_, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
-		headBlock := blkContainers[len(blkContainers)-1]
-		blk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock)
-		require.NoError(t, err)
-		bs := &Server{
-			BeaconDB: beaconDB,
-			ChainInfoFetcher: &mock.ChainService{
-				DB:                  beaconDB,
-				Block:               blk,
-				Root:                headBlock.BlockRoot,
-				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-			},
-		}
-
-		genBlk, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
-		root, err := genBlk.Block.HashTreeRoot()
-		require.NoError(t, err)
-
-		tests := []struct {
-			name    string
-			blockID []byte
-			want    *ethpbalpha.SignedBeaconBlockBellatrix
-			wantErr bool
-		}{
-			{
-				name:    "slot",
-				blockID: []byte("30"),
-				want:    blkContainers[30].Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock,
-			},
-			{
-				name:    "bad formatting",
-				blockID: []byte("3bad0"),
-				wantErr: true,
-			},
-			{
-				name:    "head",
-				blockID: []byte("head"),
-				want:    headBlock.Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock,
-			},
-			{
-				name:    "finalized",
-				blockID: []byte("finalized"),
-				want:    blkContainers[64].Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock,
-			},
-			{
-				name:    "genesis",
-				blockID: []byte("genesis"),
-				want:    genBlk,
-			},
-			{
-				name:    "genesis root",
-				blockID: root[:],
-				want:    genBlk,
-			},
-			{
-				name:    "root",
-				blockID: blkContainers[20].BlockRoot,
-				want:    blkContainers[20].Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock,
-			},
-			{
-				name:    "non-existent root",
-				blockID: bytesutil.PadTo([]byte("hi there"), 32),
-				wantErr: true,
-			},
-			{
-				name:    "slot",
-				blockID: []byte("40"),
-				want:    blkContainers[40].Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock,
-			},
-			{
-				name:    "no block",
-				blockID: []byte("105"),
-				wantErr: true,
-			},
-		}
-		for _, tt := range tests {
-			t.Run(tt.name, func(t *testing.T) {
-				blk, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{
-					BlockId: tt.blockID,
-				})
-				if tt.wantErr {
-					require.NotEqual(t, err, nil)
-					return
-				}
-				require.NoError(t, err)
-
-				v1Block, err := migration.V1Alpha1BeaconBlockBellatrixToV2(tt.want.Block)
-				require.NoError(t, err)
-
-				if !reflect.DeepEqual(blk.Data, v1Block.Body.Attestations) {
-					t.Error("Expected attestations to equal")
-				}
-			})
-		}
-	})
 }

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

@@ -212,10 +212,6 @@ func (m *futureSyncMockFetcher) StateRoot(context.Context, []byte) ([]byte, erro
 	return m.BeaconStateRoot, nil
 }
 
-func (m *futureSyncMockFetcher) StateBySlot(context.Context, types.Slot) (state.BeaconState, error) {
-	return m.BeaconState, nil
-}
-
 func TestListSyncCommitteesFuture(t *testing.T) {
 	ctx := context.Background()
 	st, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().SyncCommitteeSize)

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

@@ -28,7 +28,7 @@ func (ds *Server) GetBeaconState(ctx context.Context, req *ethpbv1.StateRequest)
 	if beaconSt.Version() != version.Phase0 {
 		return nil, status.Error(codes.Internal, "State has incorrect type")
 	}
-	protoSt, err := migration.BeaconStateToProto(beaconSt)
+	protoSt, err := migration.BeaconStateToV1(beaconSt)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not convert state to proto: %v", err)
 	}
@@ -67,7 +67,7 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 	}
 	switch beaconSt.Version() {
 	case version.Phase0:
-		protoSt, err := migration.BeaconStateToProto(beaconSt)
+		protoSt, err := migration.BeaconStateToV1(beaconSt)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not convert state to proto: %v", err)
 		}
@@ -82,7 +82,7 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 		if !ok {
 			return nil, status.Error(codes.Internal, "Altair state type assertion failed")
 		}
-		protoState, err := migration.BeaconStateAltairToProto(altairState)
+		protoState, err := migration.BeaconStateAltairToV2(altairState)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not convert state to proto: %v", err)
 		}
@@ -92,21 +92,6 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 				State: &ethpbv2.BeaconStateContainer_AltairState{AltairState: protoState},
 			},
 		}, nil
-	case version.Bellatrix:
-		bellatrixState, ok := beaconSt.(state.BeaconStateBellatrix)
-		if !ok {
-			return nil, status.Error(codes.Internal, "Bellatrix state type assertion failed")
-		}
-		protoState, err := migration.BeaconStateBellatrixToProto(bellatrixState)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not convert state to proto: %v", err)
-		}
-		return &ethpbv2.BeaconStateResponseV2{
-			Version: ethpbv2.Version_BELLATRIX,
-			Data: &ethpbv2.BeaconStateContainer{
-				State: &ethpbv2.BeaconStateContainer_BellatrixState{BellatrixState: protoState},
-			},
-		}, nil
 	default:
 		return nil, status.Error(codes.Internal, "Unsupported state version")
 	}

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

@@ -303,13 +303,6 @@ func (vs *Server) ProduceBlockV2(ctx context.Context, req *ethpbv1.ProduceBlockR
 	}, nil
 }
 
-// PrepareBeaconProposer --
-func (vs *Server) PrepareBeaconProposer(
-	_ context.Context, _ *ethpbv1.PrepareBeaconProposerRequest,
-) (*emptypb.Empty, error) {
-	return &emptypb.Empty{}, status.Error(codes.Unimplemented, "Unimplemented")
-}
-
 // ProduceAttestationData requests that the beacon node produces attestation data for
 // the requested committee index and slot based on the nodes current head.
 func (vs *Server) ProduceAttestationData(ctx context.Context, req *ethpbv1.ProduceAttestationDataRequest) (*ethpbv1.ProduceAttestationDataResponse, error) {

beacon-chain/rpc/prysm/v1alpha1/beacon/BUILD.bazel

@@ -83,7 +83,6 @@ go_test(
     shard_count = 4,
     deps = [
         "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/block:go_default_library",
@@ -92,7 +91,6 @@ go_test(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",

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

@@ -2,7 +2,6 @@ package beacon
 
 import (
 	"context"
-	"fmt"
 	"strconv"
 
 	types "github.com/prysmaticlabs/eth2-types"
@@ -59,11 +58,9 @@ func (bs *Server) ListValidatorAssignments(
 	if err != nil {
 		return nil, err
 	}
-	requestedState, err := bs.ReplayerBuilder.ForSlot(startSlot).ReplayBlocks(ctx)
+	requestedState, err := bs.StateGen.StateBySlot(ctx, startSlot)
 	if err != nil {
-		msg := fmt.Sprintf("could not replay all blocks from the closest stored state (at slot %d) "+
-			"to the requested epoch (%d) - %v", startSlot, requestedEpoch, err)
-		return nil, status.Error(codes.Internal, msg)
+		return nil, status.Errorf(codes.Internal, "Could not retrieve archived state for epoch %d: %v", requestedEpoch, err)
 	}
 
 	// Filter out assignments by public keys.

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

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	mockstategen "github.com/prysmaticlabs/prysm/beacon-chain/state/stategen/mock"
 	"github.com/prysmaticlabs/prysm/cmd"
 	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -25,13 +24,13 @@ import (
 )
 
 func TestServer_ListAssignments_CannotRequestFutureEpoch(t *testing.T) {
+
 	db := dbTest.SetupDB(t)
 	ctx := context.Background()
 	bs := &Server{
 		BeaconDB:           db,
 		GenesisTimeFetcher: &mock.ChainService{},
 	}
-	addDefaultReplayerBuilder(bs, db)
 
 	wanted := errNoEpochInfoError
 	_, err := bs.ListValidatorAssignments(
@@ -46,6 +45,7 @@ func TestServer_ListAssignments_CannotRequestFutureEpoch(t *testing.T) {
 }
 
 func TestServer_ListAssignments_NoResults(t *testing.T) {
+
 	db := dbTest.SetupDB(t)
 	ctx := context.Background()
 	st, err := util.NewBeaconState()
@@ -62,7 +62,6 @@ func TestServer_ListAssignments_NoResults(t *testing.T) {
 		BeaconDB:           db,
 		GenesisTimeFetcher: &mock.ChainService{},
 		StateGen:           stategen.New(db),
-		ReplayerBuilder:    mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(st)),
 	}
 	wanted := &ethpb.ValidatorAssignments{
 		Assignments:   make([]*ethpb.ValidatorAssignments_CommitteeAssignment, 0),
@@ -102,8 +101,8 @@ func TestServer_ListAssignments_Pagination_InputOutOfRange(t *testing.T) {
 		})
 	}
 
-	blk := util.NewBeaconBlock()
-	blockRoot, err := blk.Block.HashTreeRoot()
+	blk := util.NewBeaconBlock().Block
+	blockRoot, err := blk.HashTreeRoot()
 	require.NoError(t, err)
 
 	s, err := util.NewBeaconState()
@@ -124,7 +123,6 @@ func TestServer_ListAssignments_Pagination_InputOutOfRange(t *testing.T) {
 		},
 		GenesisTimeFetcher: &mock.ChainService{},
 		StateGen:           stategen.New(db),
-		ReplayerBuilder:    mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(s)),
 	}
 
 	wanted := fmt.Sprintf("page start %d >= list %d", 500, count)
@@ -178,8 +176,8 @@ func TestServer_ListAssignments_Pagination_DefaultPageSize_NoArchive(t *testing.
 		}
 	}
 
-	b := util.NewBeaconBlock()
-	blockRoot, err := b.Block.HashTreeRoot()
+	blk := util.NewBeaconBlock().Block
+	blockRoot, err := blk.HashTreeRoot()
 	require.NoError(t, err)
 
 	s, err := util.NewBeaconState()
@@ -200,7 +198,6 @@ func TestServer_ListAssignments_Pagination_DefaultPageSize_NoArchive(t *testing.
 		},
 		GenesisTimeFetcher: &mock.ChainService{},
 		StateGen:           stategen.New(db),
-		ReplayerBuilder:    mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(s)),
 	}
 
 	res, err := bs.ListValidatorAssignments(context.Background(), &ethpb.ListValidatorAssignmentsRequest{
@@ -249,8 +246,8 @@ func TestServer_ListAssignments_FilterPubkeysIndices_NoPagination(t *testing.T)
 		validators = append(validators, val)
 	}
 
-	b := util.NewBeaconBlock()
-	blockRoot, err := b.Block.HashTreeRoot()
+	blk := util.NewBeaconBlock().Block
+	blockRoot, err := blk.HashTreeRoot()
 	require.NoError(t, err)
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -267,7 +264,6 @@ func TestServer_ListAssignments_FilterPubkeysIndices_NoPagination(t *testing.T)
 		},
 		GenesisTimeFetcher: &mock.ChainService{},
 		StateGen:           stategen.New(db),
-		ReplayerBuilder:    mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(s)),
 	}
 
 	pubKey1 := make([]byte, params.BeaconConfig().BLSPubkeyLength)
@@ -319,16 +315,13 @@ func TestServer_ListAssignments_CanFilterPubkeysIndices_WithPagination(t *testin
 		validators = append(validators, val)
 	}
 
-	b := util.NewBeaconBlock()
-	blockRoot, err := b.Block.HashTreeRoot()
+	blk := util.NewBeaconBlock().Block
+	blockRoot, err := blk.HashTreeRoot()
 	require.NoError(t, err)
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
-	w, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
 	require.NoError(t, s.SetValidators(validators))
 	require.NoError(t, db.SaveState(ctx, s, blockRoot))
-	require.NoError(t, db.SaveBlock(ctx, w))
 	require.NoError(t, db.SaveGenesisBlockRoot(ctx, blockRoot))
 
 	bs := &Server{
@@ -342,8 +335,6 @@ func TestServer_ListAssignments_CanFilterPubkeysIndices_WithPagination(t *testin
 		StateGen:           stategen.New(db),
 	}
 
-	addDefaultReplayerBuilder(bs, db)
-
 	req := &ethpb.ListValidatorAssignmentsRequest{Indices: []types.ValidatorIndex{1, 2, 3, 4, 5, 6}, PageSize: 2, PageToken: "1"}
 	res, err := bs.ListValidatorAssignments(context.Background(), req)
 	require.NoError(t, err)

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

@@ -2,7 +2,6 @@ package beacon
 
 import (
 	"context"
-	"fmt"
 	"strconv"
 
 	"github.com/pkg/errors"
@@ -479,12 +478,10 @@ func (bs *Server) GetWeakSubjectivityCheckpoint(ctx context.Context, _ *emptypb.
 		return nil, status.Error(codes.Internal, "Could not get weak subjectivity slot")
 	}
 
-	wsState, err := bs.ReplayerBuilder.ForSlot(wsSlot).ReplayBlocks(ctx)
+	wsState, err := bs.StateGen.StateBySlot(ctx, wsSlot)
 	if err != nil {
-		msg := fmt.Sprintf("error replaying blocks for state at slot %d: %v", wsSlot, err)
-		return nil, status.Error(codes.Internal, msg)
+		return nil, status.Error(codes.Internal, "Could not get weak subjectivity state")
 	}
-
 	stateRoot, err := wsState.HashTreeRoot(ctx)
 	if err != nil {
 		return nil, status.Error(codes.Internal, "Could not get weak subjectivity state root")

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

@@ -12,7 +12,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	blockfeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/block"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/cmd"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
@@ -726,6 +728,77 @@ func TestServer_StreamBlocksVerified_OnHeadUpdated(t *testing.T) {
 	<-exitRoutine
 }
 
+func TestServer_GetWeakSubjectivityCheckpoint(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	params.OverrideBeaconConfig(params.MainnetConfig())
+
+	db := dbTest.SetupDB(t)
+	ctx := context.Background()
+
+	// Beacon state.
+	beaconState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, beaconState.SetSlot(10))
+
+	// Active validator set is used for computing the weak subjectivity period.
+	numVals := 256 // Works with params.BeaconConfig().MinGenesisActiveValidatorCount as well, but takes longer.
+	validators := make([]*ethpb.Validator, numVals)
+	balances := make([]uint64, len(validators))
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, params.BeaconConfig().BLSPubkeyLength),
+			WithdrawalCredentials: make([]byte, 32),
+			EffectiveBalance:      28 * 1e9,
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+		balances[i] = validators[i].EffectiveBalance
+	}
+	require.NoError(t, beaconState.SetValidators(validators))
+	require.NoError(t, beaconState.SetBalances(balances))
+
+	// Genesis block.
+	genesisBlock := util.NewBeaconBlock()
+	genesisBlockRoot, err := genesisBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock)))
+	require.NoError(t, db.SaveState(ctx, beaconState, genesisBlockRoot))
+	require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisBlockRoot))
+
+	// Finalized checkpoint.
+	finalizedEpoch := types.Epoch(1020)
+	require.NoError(t, beaconState.SetSlot(types.Slot(finalizedEpoch.Mul(uint64(params.BeaconConfig().SlotsPerEpoch)))))
+	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{
+		Epoch: finalizedEpoch - 1,
+		Root:  bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength),
+	}))
+	require.NoError(t, beaconState.SetFinalizedCheckpoint(&ethpb.Checkpoint{
+		Epoch: finalizedEpoch,
+		Root:  bytesutil.PadTo([]byte{'B'}, fieldparams.RootLength),
+	}))
+
+	chainService := &chainMock.ChainService{State: beaconState}
+	server := &Server{
+		Ctx:           ctx,
+		BlockNotifier: chainService.BlockNotifier(),
+		HeadFetcher:   chainService,
+		BeaconDB:      db,
+		StateGen:      stategen.New(db),
+	}
+
+	wsEpoch, err := helpers.ComputeWeakSubjectivityPeriod(context.Background(), beaconState)
+	require.NoError(t, err)
+
+	c, err := server.GetWeakSubjectivityCheckpoint(ctx, &emptypb.Empty{})
+	require.NoError(t, err)
+	e := finalizedEpoch - (finalizedEpoch % wsEpoch)
+	require.Equal(t, e, c.Epoch)
+	wsState, err := server.StateGen.StateBySlot(ctx, params.BeaconConfig().SlotsPerEpoch.Mul(uint64(e)))
+	require.NoError(t, err)
+	sRoot, err := wsState.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	require.DeepEqual(t, sRoot[:], c.StateRoot)
+}
+
 func TestServer_ListBeaconBlocks_NoResults(t *testing.T) {
 	db := dbTest.SetupDB(t)
 	ctx := context.Background()

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

@@ -74,9 +74,9 @@ func (bs *Server) retrieveCommitteesForEpoch(
 	if err != nil {
 		return nil, nil, err
 	}
-	requestedState, err := bs.ReplayerBuilder.ForSlot(startSlot).ReplayBlocks(ctx)
+	requestedState, err := bs.StateGen.StateBySlot(ctx, startSlot)
 	if err != nil {
-		return nil, nil, status.Errorf(codes.Internal, "error replaying blocks for state at slot %d: %v", startSlot, err)
+		return nil, nil, status.Errorf(codes.Internal, "Could not get state: %v", err)
 	}
 	seed, err := helpers.Seed(requestedState, epoch, params.BeaconConfig().DomainBeaconAttester)
 	if err != nil {

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

@@ -3,7 +3,6 @@ package beacon
 import (
 	"context"
 	"encoding/binary"
-	"math"
 	"testing"
 	"time"
 
@@ -12,7 +11,6 @@ import (
 	dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	mockstategen "github.com/prysmaticlabs/prysm/beacon-chain/state/stategen/mock"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -50,8 +48,6 @@ func TestServer_ListBeaconCommittees_CurrentEpoch(t *testing.T) {
 	require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
 	require.NoError(t, db.SaveState(ctx, headState, gRoot))
 
-	bs.ReplayerBuilder = mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState))
-
 	activeIndices, err := helpers.ActiveValidatorIndices(ctx, headState, 0)
 	require.NoError(t, err)
 	attesterSeed, err := helpers.Seed(headState, 0, params.BeaconConfig().DomainBeaconAttester)
@@ -73,13 +69,6 @@ func TestServer_ListBeaconCommittees_CurrentEpoch(t *testing.T) {
 	}
 }
 
-func addDefaultReplayerBuilder(s *Server, h stategen.HistoryAccessor) {
-	cc := &mockstategen.MockCanonicalChecker{Is: true, Err: nil}
-	cs := &mockstategen.MockCurrentSlotter{Slot: math.MaxUint64 - 1}
-	s.ReplayerBuilder = stategen.NewCanonicalBuilder(h, cc, cs)
-}
-
-// TODO: test failure
 func TestServer_ListBeaconCommittees_PreviousEpoch(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	params.OverrideBeaconConfig(params.MainnetConfig())
@@ -98,13 +87,12 @@ func TestServer_ListBeaconCommittees_PreviousEpoch(t *testing.T) {
 	require.NoError(t, headState.SetRandaoMixes(mixes))
 	require.NoError(t, headState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
 
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, wrapper.SetBlockSlot(b, headState.Slot()))
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, b))
-	gRoot, err := b.Block().HashTreeRoot()
+	b := util.NewBeaconBlock()
+	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	gRoot, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, db.SaveState(ctx, headState, gRoot))
+	require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
 
 	offset := int64(headState.Slot().Mul(params.BeaconConfig().SecondsPerSlot))
 	m := &mock.ChainService{
@@ -116,7 +104,6 @@ func TestServer_ListBeaconCommittees_PreviousEpoch(t *testing.T) {
 		GenesisTimeFetcher: m,
 		StateGen:           stategen.New(db),
 	}
-	addDefaultReplayerBuilder(bs, db)
 
 	activeIndices, err := helpers.ActiveValidatorIndices(ctx, headState, 1)
 	require.NoError(t, err)

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

@@ -45,5 +45,4 @@ type Server struct {
 	CollectedAttestationsBuffer chan []*ethpb.Attestation
 	StateGen                    stategen.StateManager
 	SyncChecker                 sync.Checker
-	ReplayerBuilder             stategen.ReplayerBuilder
 }

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

@@ -2,7 +2,6 @@ package beacon
 
 import (
 	"context"
-	"fmt"
 	"sort"
 	"strconv"
 
@@ -65,9 +64,9 @@ func (bs *Server) ListValidatorBalances(
 	if err != nil {
 		return nil, err
 	}
-	requestedState, err := bs.ReplayerBuilder.ForSlot(startSlot).ReplayBlocks(ctx)
+	requestedState, err := bs.StateGen.StateBySlot(ctx, startSlot)
 	if err != nil {
-		return nil, status.Error(codes.Internal, fmt.Sprintf("error replaying blocks for state at slot %d: %v", startSlot, err))
+		return nil, status.Errorf(codes.Internal, "Could not get state: %v", err)
 	}
 
 	vals := requestedState.Validators()
@@ -220,10 +219,7 @@ func (bs *Server) ListValidators(
 		if err != nil {
 			return nil, err
 		}
-		reqState, err = bs.ReplayerBuilder.ForSlot(s).ReplayBlocks(ctx)
-		if err != nil {
-			return nil, status.Error(codes.Internal, fmt.Sprintf("error replaying blocks for state at slot %d: %v", s, err))
-		}
+		reqState, err = bs.StateGen.StateBySlot(ctx, s)
 	} else {
 		reqState, err = bs.HeadFetcher.HeadState(ctx)
 	}
@@ -415,9 +411,9 @@ func (bs *Server) GetValidatorActiveSetChanges(
 	if err != nil {
 		return nil, err
 	}
-	requestedState, err := bs.ReplayerBuilder.ForSlot(s).ReplayBlocks(ctx)
+	requestedState, err := bs.StateGen.StateBySlot(ctx, s)
 	if err != nil {
-		return nil, status.Error(codes.Internal, fmt.Sprintf("error replaying blocks for state at slot %d: %v", s, err))
+		return nil, status.Errorf(codes.Internal, "Could not get state: %v", err)
 	}
 
 	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, requestedState, coreTime.CurrentEpoch(requestedState))
@@ -497,24 +493,31 @@ func (bs *Server) GetValidatorParticipation(
 			requestedEpoch,
 		)
 	}
-	// Use the last slot of requested epoch to obtain current and previous epoch attestations.
-	// This ensures that we don't miss previous attestations when input requested epochs.
-	startSlot, err := slots.EpochEnd(requestedEpoch)
+
+	// Get current slot state for current epoch attestations.
+	startSlot, err := slots.EpochStart(requestedEpoch)
 	if err != nil {
 		return nil, err
 	}
-	// Get as close as we can to the end of the current epoch without going past the curent slot.
-	// The above check ensures a future *epoch* isn't requested, but the end slot of the requested epoch could still
-	// be past the current slot. In that case, use the current slot as the best approximation of the requested epoch.
-	// Replayer will make sure the slot ultimately used is canonical.
-	if startSlot > currentSlot {
-		startSlot = currentSlot
-	}
-
-	// ReplayerBuilder ensures that a canonical chain is followed to the slot
-	beaconState, err := bs.ReplayerBuilder.ForSlot(startSlot).ReplayBlocks(ctx)
+	// Use the last slot of requested epoch to obtain current and previous epoch attestations.
+	// This ensures that we don't miss previous attestations when input requested epochs.
+	startSlot += params.BeaconConfig().SlotsPerEpoch - 1
+	// The start slot should be a canonical slot.
+	canonical, err := bs.isSlotCanonical(ctx, startSlot)
 	if err != nil {
-		return nil, status.Error(codes.Internal, fmt.Sprintf("error replaying blocks for state at slot %d: %v", startSlot, err))
+		return nil, err
+	}
+	// Keep looking back until there's a canonical slot.
+	for i := int(startSlot - 1); !canonical && i >= 0; i-- {
+		canonical, err = bs.isSlotCanonical(ctx, types.Slot(i))
+		if err != nil {
+			return nil, err
+		}
+		startSlot = types.Slot(i)
+	}
+	beaconState, err := bs.StateGen.StateBySlot(ctx, startSlot)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not get state: %v", err)
 	}
 	var v []*precompute.Validator
 	var b *precompute.Balance
@@ -831,9 +834,9 @@ func (bs *Server) GetIndividualVotes(
 	if err != nil {
 		return nil, err
 	}
-	st, err := bs.ReplayerBuilder.ForSlot(s).ReplayBlocks(ctx)
+	requestedState, err := bs.StateGen.StateBySlot(ctx, s)
 	if err != nil {
-		return nil, status.Errorf(codes.Internal, "failed to replay blocks for state at epoch %d: %v", req.Epoch, err)
+		return nil, status.Errorf(codes.Internal, "Could not retrieve archived state for epoch %d: %v", req.Epoch, err)
 	}
 	// Track filtered validators to prevent duplication in the response.
 	filtered := map[types.ValidatorIndex]bool{}
@@ -841,7 +844,7 @@ func (bs *Server) GetIndividualVotes(
 	votes := make([]*ethpb.IndividualVotesRespond_IndividualVote, 0, len(req.Indices)+len(req.PublicKeys))
 	// Filter out assignments by public keys.
 	for _, pubKey := range req.PublicKeys {
-		index, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
+		index, ok := requestedState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
 		if !ok {
 			votes = append(votes, &ethpb.IndividualVotesRespond_IndividualVote{PublicKey: pubKey, ValidatorIndex: types.ValidatorIndex(^uint64(0))})
 			continue
@@ -861,27 +864,27 @@ func (bs *Server) GetIndividualVotes(
 
 	var v []*precompute.Validator
 	var bal *precompute.Balance
-	switch st.Version() {
+	switch requestedState.Version() {
 	case version.Phase0:
-		v, bal, err = precompute.New(ctx, st)
+		v, bal, err = precompute.New(ctx, requestedState)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not set up pre compute instance: %v", err)
 		}
-		v, _, err = precompute.ProcessAttestations(ctx, st, v, bal)
+		v, _, err = precompute.ProcessAttestations(ctx, requestedState, v, bal)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not pre compute attestations: %v", err)
 		}
 	case version.Altair:
-		v, bal, err = altair.InitializePrecomputeValidators(ctx, st)
+		v, bal, err = altair.InitializePrecomputeValidators(ctx, requestedState)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not set up altair pre compute instance: %v", err)
 		}
-		v, _, err = altair.ProcessEpochParticipation(ctx, st, bal, v)
+		v, _, err = altair.ProcessEpochParticipation(ctx, requestedState, bal, v)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not pre compute attestations: %v", err)
 		}
 	default:
-		return nil, status.Errorf(codes.Internal, "Invalid state type retrieved with a version of %d", st.Version())
+		return nil, status.Errorf(codes.Internal, "Invalid state type retrieved with a version of %d", requestedState.Version())
 	}
 
 	for _, index := range filteredIndices {
@@ -889,7 +892,7 @@ func (bs *Server) GetIndividualVotes(
 			votes = append(votes, &ethpb.IndividualVotesRespond_IndividualVote{ValidatorIndex: index})
 			continue
 		}
-		val, err := st.ValidatorAtIndexReadOnly(index)
+		val, err := requestedState.ValidatorAtIndexReadOnly(index)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not retrieve validator: %v", err)
 
@@ -920,6 +923,37 @@ func (bs *Server) GetIndividualVotes(
 	}, nil
 }
 
+// isSlotCanonical returns true if the input slot has a canonical block in the chain,
+// if the input slot has a skip block, false is returned,
+// if the input slot has more than one block, an error is returned.
+func (bs *Server) isSlotCanonical(ctx context.Context, slot types.Slot) (bool, error) {
+	if slot == 0 {
+		return true, nil
+	}
+
+	hasBlockRoots, roots, err := bs.BeaconDB.BlockRootsBySlot(ctx, slot)
+	if err != nil {
+		return false, err
+	}
+	if !hasBlockRoots {
+		return false, nil
+	}
+
+	// Loop through all roots in slot, and
+	// check which one is canonical.
+	for _, rt := range roots {
+		canonical, err := bs.CanonicalFetcher.IsCanonical(ctx, rt)
+		if err != nil {
+			return false, err
+		}
+		if canonical {
+			return true, nil
+		}
+
+	}
+	return false, nil
+}
+
 // Determines whether a validator has already exited.
 func validatorHasExited(validator *ethpb.Validator, currentEpoch types.Epoch) bool {
 	farFutureEpoch := params.BeaconConfig().FarFutureEpoch

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

@@ -12,11 +12,9 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/go-bitfield"
 	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	coreTime "github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -117,8 +115,6 @@ func TestServer_ListValidatorBalances_NoResults(t *testing.T) {
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, gRoot))
 
-	bs.ReplayerBuilder = mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState))
-
 	wanted := &ethpb.ValidatorBalances{
 		Balances:      make([]*ethpb.ValidatorBalances_Balance, 0),
 		TotalSize:     int32(0),
@@ -176,7 +172,6 @@ func TestServer_ListValidatorBalances_DefaultResponse_NoArchive(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: st,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(st)),
 	}
 	res, err := bs.ListValidatorBalances(
 		ctx,
@@ -205,7 +200,6 @@ func TestServer_ListValidatorBalances_PaginationOutOfRange(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	wanted := fmt.Sprintf("page start %d >= list %d", 200, len(headState.Balances()))
@@ -254,7 +248,6 @@ func TestServer_ListValidatorBalances_Pagination_Default(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	tests := []struct {
@@ -338,7 +331,6 @@ func TestServer_ListValidatorBalances_Pagination_CustomPageSizes(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	tests := []struct {
@@ -406,7 +398,6 @@ func TestServer_ListValidatorBalances_OutOfRange(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	req := &ethpb.ListValidatorBalancesRequest{Indices: []types.ValidatorIndex{types.ValidatorIndex(1)}, QueryFilter: &ethpb.ListValidatorBalancesRequest_Epoch{Epoch: 0}}
@@ -669,7 +660,6 @@ func TestServer_ListValidatorBalances_UnknownValidatorInResponse(t *testing.T) {
 		HeadFetcher: &mock.ChainService{
 			State: headState,
 		},
-		ReplayerBuilder: mockstategen.NewMockReplayerBuilder(mockstategen.WithMockState(headState)),
 	}
 
 	nonExistentPubKey := [32]byte{8}
@@ -1019,41 +1009,47 @@ func TestServer_ListValidators_DefaultPageSize(t *testing.T) {
 }
 
 func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
-	params.OverrideBeaconConfig(params.MainnetConfig())
-	transition.SkipSlotCache.Disable()
-
-	ctx := context.Background()
-	slot := types.Slot(0)
-	epochs := 10
-	numVals := uint64(10)
-
-	b := util.NewBeaconBlock()
-	b.Block.Slot = slot
-	sb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	st, _ := util.DeterministicGenesisState(t, numVals)
-	require.NoError(t, st.SetSlot(slot))
-	require.Equal(t, int(numVals), len(st.Validators()))
-
 	beaconDB := dbTest.SetupDB(t)
-	require.NoError(t, beaconDB.SaveBlock(ctx, sb))
-	require.NoError(t, beaconDB.SaveState(ctx, st, r))
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, r))
+	ctx := context.Background()
 
+	numEpochs := types.Epoch(30)
+	validators := make([]*ethpb.Validator, numEpochs)
+	for i := types.Epoch(0); i < numEpochs; i++ {
+		validators[i] = &ethpb.Validator{
+			ActivationEpoch:       i,
+			PublicKey:             make([]byte, 48),
+			WithdrawalCredentials: make([]byte, 32),
+		}
+	}
+	want := make([]*ethpb.Validators_ValidatorContainer, len(validators))
+	for i := 0; i < len(validators); i++ {
+		want[i] = &ethpb.Validators_ValidatorContainer{
+			Index:     types.ValidatorIndex(i),
+			Validator: validators[i],
+		}
+	}
+
+	st, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, st.SetSlot(20*params.BeaconConfig().SlotsPerEpoch))
+	require.NoError(t, st.SetValidators(validators))
+	b := util.NewBeaconBlock()
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	gRoot, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveState(ctx, st, gRoot))
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
 	secondsPerEpoch := params.BeaconConfig().SecondsPerSlot * uint64(params.BeaconConfig().SlotsPerEpoch)
 	bs := &Server{
 		HeadFetcher: &mock.ChainService{
 			State: st,
 		},
 		GenesisTimeFetcher: &mock.ChainService{
-			Genesis: time.Now().Add(time.Duration(-1*int64(uint64(epochs)*secondsPerEpoch)) * time.Second),
+			// We are in epoch 30
+			Genesis: time.Now().Add(time.Duration(-1*int64(30*secondsPerEpoch)) * time.Second),
 		},
+		StateGen: stategen.New(beaconDB),
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 
 	req := &ethpb.ListValidatorsRequest{
 		QueryFilter: &ethpb.ListValidatorsRequest_Genesis{
@@ -1062,26 +1058,16 @@ func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
 	}
 	res, err := bs.ListValidators(context.Background(), req)
 	require.NoError(t, err)
-	assert.Equal(t, epochs, len(res.ValidatorList))
+	assert.Equal(t, 30, len(res.ValidatorList))
 
-	vals := st.Validators()
-	want := make([]*ethpb.Validators_ValidatorContainer, 0)
-	for i, v := range vals {
-		want = append(want, &ethpb.Validators_ValidatorContainer{
-			Index:     types.ValidatorIndex(i),
-			Validator: v,
-		})
-	}
 	req = &ethpb.ListValidatorsRequest{
 		QueryFilter: &ethpb.ListValidatorsRequest_Epoch{
-			Epoch: 10,
+			Epoch: 20,
 		},
 	}
 	res, err = bs.ListValidators(context.Background(), req)
 	require.NoError(t, err)
-
-	require.Equal(t, len(want), len(res.ValidatorList), "incorrect number of validators")
-	assert.DeepSSZEqual(t, want, res.ValidatorList, "mismatch in validator values")
+	assert.DeepSSZEqual(t, want, res.ValidatorList, "Incorrect number of validators")
 }
 
 func TestServer_ListValidators_ProcessHeadStateSlots(t *testing.T) {
@@ -1284,8 +1270,8 @@ func TestServer_GetValidatorActiveSetChanges(t *testing.T) {
 			FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, fieldparams.RootLength)},
 		},
 		GenesisTimeFetcher: &mock.ChainService{},
+		StateGen:           stategen.New(beaconDB),
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 	res, err := bs.GetValidatorActiveSetChanges(ctx, &ethpb.GetValidatorActiveSetChangesRequest{
 		QueryFilter: &ethpb.GetValidatorActiveSetChangesRequest_Genesis{Genesis: true},
 	})
@@ -1503,6 +1489,43 @@ func TestServer_GetValidatorParticipation_CannotRequestFutureEpoch(t *testing.T)
 	assert.ErrorContains(t, wanted, err)
 }
 
+func TestServer_GetValidatorParticipation_UnknownState(t *testing.T) {
+	beaconDB := dbTest.SetupDB(t)
+
+	ctx := context.Background()
+	headState, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, headState.SetSlot(0))
+	epoch := types.Epoch(50)
+	slots := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epoch))
+	mockStateGen := &mockstategen.MockStateManager{
+		StatesBySlot: map[types.Slot]state.BeaconState{
+			0: (*v1.BeaconState)(nil),
+		},
+	}
+	bs := &Server{
+		BeaconDB: beaconDB,
+		HeadFetcher: &mock.ChainService{
+			State: headState,
+		},
+		GenesisTimeFetcher: &mock.ChainService{
+			Genesis: time.Now().Add(time.Duration(-1*int64(slots)) * time.Second),
+		},
+		StateGen: mockStateGen,
+	}
+
+	wanted := "Could not set up pre compute instance: failed to initialize precompute: nil inner state"
+	_, err = bs.GetValidatorParticipation(
+		ctx,
+		&ethpb.GetValidatorParticipationRequest{
+			QueryFilter: &ethpb.GetValidatorParticipationRequest_Epoch{
+				Epoch: 1,
+			},
+		},
+	)
+	assert.ErrorContains(t, wanted, err)
+}
+
 func TestServer_GetValidatorParticipation_CurrentAndPrevEpoch(t *testing.T) {
 	helpers.ClearCache()
 	beaconDB := dbTest.SetupDB(t)
@@ -1529,7 +1552,7 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpoch(t *testing.T) {
 	}}
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, headState.SetSlot(16))
+	require.NoError(t, headState.SetSlot(2*params.BeaconConfig().SlotsPerEpoch-1))
 	require.NoError(t, headState.SetValidators(validators))
 	require.NoError(t, headState.SetBalances(balances))
 	require.NoError(t, headState.AppendCurrentEpochAttestations(atts[0]))
@@ -1544,7 +1567,6 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpoch(t *testing.T) {
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, bRoot))
-	require.NoError(t, beaconDB.SaveState(ctx, headState, params.BeaconConfig().ZeroHash))
 
 	m := &mock.ChainService{State: headState}
 	offset := int64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
@@ -1562,7 +1584,6 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpoch(t *testing.T) {
 		},
 		FinalizationFetcher: &mock.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 100}},
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 
 	res, err := bs.GetValidatorParticipation(ctx, &ethpb.GetValidatorParticipationRequest{QueryFilter: &ethpb.GetValidatorParticipationRequest_Epoch{Epoch: 1}})
 	require.NoError(t, err)
@@ -1611,7 +1632,7 @@ func TestServer_GetValidatorParticipation_OrphanedUntilGenesis(t *testing.T) {
 	}}
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, headState.SetSlot(0))
+	require.NoError(t, headState.SetSlot(2*params.BeaconConfig().SlotsPerEpoch-1))
 	require.NoError(t, headState.SetValidators(validators))
 	require.NoError(t, headState.SetBalances(balances))
 	require.NoError(t, headState.AppendCurrentEpochAttestations(atts[0]))
@@ -1620,10 +1641,11 @@ func TestServer_GetValidatorParticipation_OrphanedUntilGenesis(t *testing.T) {
 	b := util.NewBeaconBlock()
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	bRoot, err := b.Block.HashTreeRoot()
+	require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bRoot[:]}))
+	require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:]}))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, bRoot))
-	require.NoError(t, beaconDB.SaveState(ctx, headState, params.BeaconConfig().ZeroHash))
 
 	m := &mock.ChainService{State: headState}
 	offset := int64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
@@ -1641,7 +1663,6 @@ func TestServer_GetValidatorParticipation_OrphanedUntilGenesis(t *testing.T) {
 		},
 		FinalizationFetcher: &mock.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 100}},
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 
 	res, err := bs.GetValidatorParticipation(ctx, &ethpb.GetValidatorParticipationRequest{QueryFilter: &ethpb.GetValidatorParticipationRequest_Epoch{Epoch: 1}})
 	require.NoError(t, err)
@@ -1667,36 +1688,32 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpochAltair(t *testing.T
 	beaconDB := dbTest.SetupDB(t)
 	params.SetupTestConfigCleanup(t)
 	params.OverrideBeaconConfig(params.MainnetConfig())
-	transition.SkipSlotCache.Disable()
 
 	ctx := context.Background()
 	validatorCount := uint64(32)
 
-	genState, _ := util.DeterministicGenesisStateAltair(t, validatorCount)
-	c, err := altair.NextSyncCommittee(ctx, genState)
-	require.NoError(t, err)
-	require.NoError(t, genState.SetCurrentSyncCommittee(c))
-
 	bits := make([]byte, validatorCount)
 	for i := range bits {
 		bits[i] = 0xff
 	}
-	require.NoError(t, genState.SetCurrentParticipationBits(bits))
-	require.NoError(t, genState.SetPreviousParticipationBits(bits))
+	headState, _ := util.DeterministicGenesisStateAltair(t, validatorCount)
+	require.NoError(t, headState.SetSlot(2*params.BeaconConfig().SlotsPerEpoch-1))
+	require.NoError(t, headState.SetCurrentParticipationBits(bits))
+	require.NoError(t, headState.SetPreviousParticipationBits(bits))
 
-	gsr, err := genState.HashTreeRoot(ctx)
+	b := util.NewBeaconBlockAltair()
+	b.Block.Slot = 16
+	ab, err := wrapper.WrappedAltairSignedBeaconBlock(b)
 	require.NoError(t, err)
-	gb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlockAltair())
-	require.NoError(t, wrapper.SetBlockStateRoot(gb, gsr))
-	require.NoError(t, err)
-	gRoot, err := gb.Block().HashTreeRoot()
+	require.NoError(t, beaconDB.SaveBlock(ctx, ab))
+	bRoot, err := b.Block.HashTreeRoot()
+	require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bRoot[:]}))
+	require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:]}))
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
 	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveState(ctx, headState, bRoot))
 
-	require.NoError(t, beaconDB.SaveState(ctx, genState, gRoot))
-	require.NoError(t, beaconDB.SaveBlock(ctx, gb))
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
-
-	m := &mock.ChainService{State: genState}
+	m := &mock.ChainService{State: headState}
 	offset := int64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
 	bs := &Server{
 		BeaconDB:    beaconDB,
@@ -1705,11 +1722,15 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpochAltair(t *testing.T
 		GenesisTimeFetcher: &mock.ChainService{
 			Genesis: prysmTime.Now().Add(time.Duration(-1*offset) * time.Second),
 		},
+		CanonicalFetcher: &mock.ChainService{
+			CanonicalRoots: map[[32]byte]bool{
+				bRoot: true,
+			},
+		},
 		FinalizationFetcher: &mock.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 100}},
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 
-	res, err := bs.GetValidatorParticipation(ctx, &ethpb.GetValidatorParticipationRequest{QueryFilter: &ethpb.GetValidatorParticipationRequest_Epoch{Epoch: 0}})
+	res, err := bs.GetValidatorParticipation(ctx, &ethpb.GetValidatorParticipationRequest{QueryFilter: &ethpb.GetValidatorParticipationRequest_Epoch{Epoch: 1}})
 	require.NoError(t, err)
 
 	wanted := &ethpb.ValidatorParticipation{
@@ -1726,24 +1747,6 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpochAltair(t *testing.T
 	}
 	assert.DeepEqual(t, true, res.Finalized, "Incorrect validator participation respond")
 	assert.DeepEqual(t, wanted, res.Participation, "Incorrect validator participation respond")
-
-	res, err = bs.GetValidatorParticipation(ctx, &ethpb.GetValidatorParticipationRequest{QueryFilter: &ethpb.GetValidatorParticipationRequest_Epoch{Epoch: 1}})
-	require.NoError(t, err)
-
-	wanted = &ethpb.ValidatorParticipation{
-		GlobalParticipationRate:          1,
-		VotedEther:                       validatorCount * params.BeaconConfig().MaxEffectiveBalance,
-		EligibleEther:                    validatorCount * params.BeaconConfig().MaxEffectiveBalance,
-		CurrentEpochActiveGwei:           validatorCount * params.BeaconConfig().MaxEffectiveBalance,
-		CurrentEpochAttestingGwei:        params.BeaconConfig().EffectiveBalanceIncrement, // Empty because after one epoch, current participation rotates to previous
-		CurrentEpochTargetAttestingGwei:  params.BeaconConfig().EffectiveBalanceIncrement,
-		PreviousEpochActiveGwei:          validatorCount * params.BeaconConfig().MaxEffectiveBalance,
-		PreviousEpochAttestingGwei:       validatorCount * params.BeaconConfig().MaxEffectiveBalance,
-		PreviousEpochTargetAttestingGwei: validatorCount * params.BeaconConfig().MaxEffectiveBalance,
-		PreviousEpochHeadAttestingGwei:   validatorCount * params.BeaconConfig().MaxEffectiveBalance,
-	}
-	assert.DeepEqual(t, true, res.Finalized, "Incorrect validator participation respond")
-	assert.DeepEqual(t, wanted, res.Participation, "Incorrect validator participation respond")
 }
 
 func TestGetValidatorPerformance_Syncing(t *testing.T) {
@@ -2067,7 +2070,6 @@ func BenchmarkListValidatorBalances(b *testing.B) {
 			State: headState,
 		},
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 
 	req := &ethpb.ListValidatorBalancesRequest{PageSize: 100}
 	b.StartTimer()
@@ -2112,16 +2114,15 @@ func TestServer_GetIndividualVotes_ValidatorsDontExist(t *testing.T) {
 	beaconDB := dbTest.SetupDB(t)
 	ctx := context.Background()
 
-	var slot types.Slot = 0
 	validators := uint64(64)
 	stateWithValidators, _ := util.DeterministicGenesisState(t, validators)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetValidators(stateWithValidators.Validators()))
-	require.NoError(t, beaconState.SetSlot(slot))
+	require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
 
 	b := util.NewBeaconBlock()
-	b.Block.Slot = slot
+	b.Block.Slot = params.BeaconConfig().SlotsPerEpoch
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	gRoot, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -2133,7 +2134,6 @@ func TestServer_GetIndividualVotes_ValidatorsDontExist(t *testing.T) {
 		StateGen:           gen,
 		GenesisTimeFetcher: &mock.ChainService{},
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 
 	// Test non exist public key.
 	res, err := bs.GetIndividualVotes(ctx, &ethpb.IndividualVotesRequest{
@@ -2192,6 +2192,7 @@ func TestServer_GetIndividualVotes_Working(t *testing.T) {
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, beaconState.SetValidators(stateWithValidators.Validators()))
+	require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
 
 	bf := bitfield.NewBitlist(validators / uint64(params.BeaconConfig().SlotsPerEpoch))
 	att1 := util.NewAttestation()
@@ -2217,7 +2218,7 @@ func TestServer_GetIndividualVotes_Working(t *testing.T) {
 	require.NoError(t, err)
 
 	b := util.NewBeaconBlock()
-	b.Block.Slot = 0
+	b.Block.Slot = params.BeaconConfig().SlotsPerEpoch
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	gRoot, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -2229,7 +2230,6 @@ func TestServer_GetIndividualVotes_Working(t *testing.T) {
 		StateGen:           gen,
 		GenesisTimeFetcher: &mock.ChainService{},
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 
 	res, err := bs.GetIndividualVotes(ctx, &ethpb.IndividualVotesRequest{
 		Indices: []types.ValidatorIndex{0, 1},
@@ -2268,10 +2268,9 @@ func TestServer_GetIndividualVotes_WorkingAltair(t *testing.T) {
 	beaconDB := dbTest.SetupDB(t)
 	ctx := context.Background()
 
-	var slot types.Slot = 0
 	validators := uint64(32)
 	beaconState, _ := util.DeterministicGenesisStateAltair(t, validators)
-	require.NoError(t, beaconState.SetSlot(slot))
+	require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
 
 	pb, err := beaconState.CurrentEpochParticipation()
 	require.NoError(t, err)
@@ -2282,7 +2281,7 @@ func TestServer_GetIndividualVotes_WorkingAltair(t *testing.T) {
 	require.NoError(t, beaconState.SetPreviousParticipationBits(pb))
 
 	b := util.NewBeaconBlock()
-	b.Block.Slot = slot
+	b.Block.Slot = params.BeaconConfig().SlotsPerEpoch
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	gRoot, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -2294,7 +2293,6 @@ func TestServer_GetIndividualVotes_WorkingAltair(t *testing.T) {
 		StateGen:           gen,
 		GenesisTimeFetcher: &mock.ChainService{},
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 
 	res, err := bs.GetIndividualVotes(ctx, &ethpb.IndividualVotesRequest{
 		Indices: []types.ValidatorIndex{0, 1},
@@ -2380,7 +2378,6 @@ func TestServer_GetIndividualVotes_AltairEndOfEpoch(t *testing.T) {
 		StateGen:           gen,
 		GenesisTimeFetcher: &mock.ChainService{},
 	}
-	addDefaultReplayerBuilder(bs, beaconDB)
 
 	res, err := bs.GetIndividualVotes(ctx, &ethpb.IndividualVotesRequest{
 		Indices: []types.ValidatorIndex{0, 1},
@@ -2502,3 +2499,88 @@ func Test_validatorStatus(t *testing.T) {
 		})
 	}
 }
+
+func TestServer_isSlotCanonical(t *testing.T) {
+	beaconDB := dbTest.SetupDB(t)
+	ctx := context.Background()
+	var roots [][32]byte
+	cRoots := map[[32]byte]bool{}
+	for i := 1; i < 100; i++ {
+		b := util.NewBeaconBlock()
+		b.Block.Slot = types.Slot(i)
+		require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+		br, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		if i%2 == 0 {
+			cRoots[br] = true
+		}
+		roots = append(roots, br)
+	}
+
+	bs := &Server{
+		BeaconDB: beaconDB,
+		CanonicalFetcher: &mock.ChainService{
+			CanonicalRoots: cRoots,
+		},
+	}
+
+	for i := range roots {
+		slot := types.Slot(i + 1)
+		c, err := bs.isSlotCanonical(ctx, slot)
+		require.NoError(t, err)
+		if slot%2 == 0 {
+			require.Equal(t, true, c)
+		} else {
+			require.Equal(t, false, c)
+		}
+	}
+}
+
+func TestServer_isSlotCanonical_MultipleBlocks(t *testing.T) {
+	beaconDB := dbTest.SetupDB(t)
+	ctx := context.Background()
+	var roots [][32]byte
+	cRoots := map[[32]byte]bool{}
+	for i := 1; i < 100; i++ {
+		b := util.NewBeaconBlock()
+		b.Block.Slot = types.Slot(i)
+		require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+		br, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		if i%2 == 0 {
+			cRoots[br] = true
+			// Save a block in the same slot
+			b = util.NewBeaconBlock()
+			b.Block.Slot = types.Slot(i)
+			b.Block.ProposerIndex = 100
+			require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+		}
+		roots = append(roots, br)
+	}
+
+	bs := &Server{
+		BeaconDB: beaconDB,
+		CanonicalFetcher: &mock.ChainService{
+			CanonicalRoots: cRoots,
+		},
+	}
+
+	for i := range roots {
+		slot := types.Slot(i + 1)
+		c, err := bs.isSlotCanonical(ctx, slot)
+		require.NoError(t, err)
+		if slot%2 == 0 {
+			require.Equal(t, true, c)
+		} else {
+			require.Equal(t, false, c)
+		}
+	}
+}
+
+func TestServer_isSlotCanonicalForSlot0(t *testing.T) {
+	ctx := context.Background()
+	bs := &Server{}
+	c, err := bs.isSlotCanonical(ctx, 0)
+	require.NoError(t, err)
+	require.Equal(t, true, c)
+}

beacon-chain/rpc/prysm/v1alpha1/debug/BUILD.bazel

@@ -50,9 +50,7 @@ go_test(
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/p2p/testing:go_default_library",
-        "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
-        "//beacon-chain/state/stategen/mock:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/rpc/prysm/v1alpha1/debug/forkchoice.go

@@ -2,18 +2,43 @@ package debug
 
 import (
 	"context"
+	"encoding/hex"
 
 	"github.com/golang/protobuf/ptypes/empty"
 	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
 
-// GetForkChoice returns a fork choice store.
-func (ds *Server) GetForkChoice(_ context.Context, _ *empty.Empty) (*pbrpc.ForkChoiceResponse, error) {
-	store := ds.HeadFetcher.ForkChoicer()
+// GetProtoArrayForkChoice returns proto array fork choice store.
+func (ds *Server) GetProtoArrayForkChoice(_ context.Context, _ *empty.Empty) (*pbrpc.ProtoArrayForkChoiceResponse, error) {
+	store := ds.HeadFetcher.ProtoArrayStore()
 
-	return &pbrpc.ForkChoiceResponse{
+	nodes := store.Nodes()
+	returnedNodes := make([]*pbrpc.ProtoArrayNode, len(nodes))
+
+	for i := 0; i < len(returnedNodes); i++ {
+		r := nodes[i].Root()
+		returnedNodes[i] = &pbrpc.ProtoArrayNode{
+			Slot:           nodes[i].Slot(),
+			Root:           r[:],
+			Parent:         nodes[i].Parent(),
+			JustifiedEpoch: nodes[i].JustifiedEpoch(),
+			FinalizedEpoch: nodes[i].FinalizedEpoch(),
+			Weight:         nodes[i].Weight(),
+			BestChild:      nodes[i].BestChild(),
+			BestDescendant: nodes[i].BestDescendant(),
+		}
+	}
+
+	indices := make(map[string]uint64, len(store.NodesIndices()))
+	for k, v := range store.NodesIndices() {
+		indices[hex.EncodeToString(k[:])] = v
+	}
+
+	return &pbrpc.ProtoArrayForkChoiceResponse{
+		PruneThreshold:  store.PruneThreshold(),
 		JustifiedEpoch:  store.JustifiedEpoch(),
 		FinalizedEpoch:  store.FinalizedEpoch(),
-		ForkchoiceNodes: store.ForkChoiceNodes(),
+		ProtoArrayNodes: returnedNodes,
+		Indices:         indices,
 	}, nil
 }

beacon-chain/rpc/prysm/v1alpha1/debug/forkchoice_test.go

@@ -11,11 +11,12 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
-func TestServer_GetForkChoice_ProtoArray(t *testing.T) {
-	store := protoarray.New(0, 0, [32]byte{'a'})
+func TestServer_GetForkChoice(t *testing.T) {
+	store := &protoarray.Store{}
 	bs := &Server{HeadFetcher: &mock.ChainService{ForkChoiceStore: store}}
-	res, err := bs.GetForkChoice(context.Background(), &empty.Empty{})
+	res, err := bs.GetProtoArrayForkChoice(context.Background(), &empty.Empty{})
 	require.NoError(t, err)
+	assert.Equal(t, store.PruneThreshold(), res.PruneThreshold, "Did not get wanted prune threshold")
 	assert.Equal(t, store.JustifiedEpoch(), res.JustifiedEpoch, "Did not get wanted justified epoch")
 	assert.Equal(t, store.FinalizedEpoch(), res.FinalizedEpoch, "Did not get wanted finalized epoch")
 }

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

@@ -30,7 +30,6 @@ type Server struct {
 	HeadFetcher        blockchain.HeadFetcher
 	PeerManager        p2p.PeerManager
 	PeersFetcher       p2p.PeersProvider
-	ReplayerBuilder    stategen.ReplayerBuilder
 }
 
 // SetLoggingLevel of a beacon node according to a request type,

beacon-chain/rpc/prysm/v1alpha1/debug/state.go

@@ -2,7 +2,6 @@ package debug
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -29,11 +28,10 @@ func (ds *Server) GetBeaconState(
 			)
 		}
 
-		st, err := ds.ReplayerBuilder.ForSlot(q.Slot).ReplayBlocks(ctx)
+		st, err := ds.StateGen.StateBySlot(ctx, q.Slot)
 		if err != nil {
-			return nil, status.Error(codes.Internal, fmt.Sprintf("error replaying blocks for state at slot %d: %v", q.Slot, err))
+			return nil, status.Errorf(codes.Internal, "Could not compute state by slot: %v", err)
 		}
-
 		encoded, err := st.MarshalSSZ()
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not ssz encode beacon state: %v", err)

beacon-chain/rpc/prysm/v1alpha1/debug/state_test.go

@@ -2,15 +2,12 @@ package debug
 
 import (
 	"context"
-	"math"
 	"testing"
 
 	types "github.com/prysmaticlabs/eth2-types"
 	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
 	dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	mockstategen "github.com/prysmaticlabs/prysm/beacon-chain/state/stategen/mock"
 	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -18,16 +15,6 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
-func addReplayerBuilder(s *Server, h stategen.HistoryAccessor, is bool, canonErr error, currSlot types.Slot) {
-	cc := &mockstategen.MockCanonicalChecker{Is: is, Err: canonErr}
-	cs := &mockstategen.MockCurrentSlotter{Slot: currSlot}
-	s.ReplayerBuilder = stategen.NewCanonicalBuilder(h, cc, cs)
-}
-
-func addDefaultReplayerBuilder(s *Server, h stategen.HistoryAccessor) {
-	addReplayerBuilder(s, h, true, nil, math.MaxUint64-1)
-}
-
 func TestServer_GetBeaconState(t *testing.T) {
 	db := dbTest.SetupDB(t)
 	ctx := context.Background()
@@ -47,7 +34,6 @@ func TestServer_GetBeaconState(t *testing.T) {
 		StateGen:           gen,
 		GenesisTimeFetcher: &mock.ChainService{},
 	}
-	addDefaultReplayerBuilder(bs, db)
 	_, err = bs.GetBeaconState(ctx, &pbrpc.BeaconStateRequest{})
 	assert.ErrorContains(t, "Need to specify either a block root or slot to request state", err)
 	req := &pbrpc.BeaconStateRequest{
@@ -60,44 +46,16 @@ func TestServer_GetBeaconState(t *testing.T) {
 	wanted, err := st.MarshalSSZ()
 	require.NoError(t, err)
 	assert.DeepEqual(t, wanted, res.Encoded)
-
-	req = &pbrpc.BeaconStateRequest{
-		QueryFilter: &pbrpc.BeaconStateRequest_Slot{
-			Slot: st.Slot(),
-		},
-	}
-	wanted, err = st.MarshalSSZ()
-	require.NoError(t, err)
-	res, err = bs.GetBeaconState(ctx, req)
-	require.NoError(t, err)
-	resState := &pbrpc.BeaconState{}
-	err = resState.UnmarshalSSZ(res.Encoded)
-	require.NoError(t, err)
-	assert.Equal(t, resState.Slot, st.Slot())
-	assert.DeepEqual(t, wanted, res.Encoded)
-
-	// request a slot after the state
-	// note that if the current slot were <= slot+1, this would fail
-	// but the mock stategen.CurrentSlotter gives a current slot far in the future
-	// so this acts like requesting a state at a skipped slot
 	req = &pbrpc.BeaconStateRequest{
 		QueryFilter: &pbrpc.BeaconStateRequest_Slot{
 			Slot: slot + 1,
 		},
 	}
-	state := state.BeaconState(st)
-	// since we are requesting a state at a skipped slot, use the same method as stategen
-	// to advance to the pre-state for the subsequent slot
-	state, err = stategen.ReplayProcessSlots(ctx, state, slot+1)
-	require.NoError(t, err)
-	wanted, err = state.MarshalSSZ()
+	require.NoError(t, st.SetSlot(slot+1))
+	wanted, err = st.MarshalSSZ()
 	require.NoError(t, err)
 	res, err = bs.GetBeaconState(ctx, req)
 	require.NoError(t, err)
-	resState = &pbrpc.BeaconState{}
-	err = resState.UnmarshalSSZ(res.Encoded)
-	require.NoError(t, err)
-	assert.Equal(t, resState.Slot, state.Slot())
 	assert.DeepEqual(t, wanted, res.Encoded)
 }
 

beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel

@@ -15,7 +15,6 @@ go_library(
         "proposer_bellatrix.go",
         "proposer_deposits.go",
         "proposer_eth1data.go",
-        "proposer_execution_payload.go",
         "proposer_phase0.go",
         "proposer_sync_aggregate.go",
         "server.go",
@@ -41,14 +40,12 @@ go_library(
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/core/transition/interop:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
-        "//beacon-chain/db:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
-        "//beacon-chain/powchain/engine-api-client/v1:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/sync:go_default_library",
@@ -74,14 +71,11 @@ go_library(
         "//runtime/version:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ferranbt_fastssz//:go_default_library",
-        "@com_github_holiman_uint256//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
-        "@io_bazel_rules_go//proto/wkt:empty_go_proto",
         "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
         "@org_golang_google_grpc//status:go_default_library",
@@ -101,7 +95,6 @@ go_test(
         "blocks_test.go",
         "exit_test.go",
         "proposer_attestations_test.go",
-        "proposer_execution_payload_test.go",
         "proposer_sync_aggregate_test.go",
         "proposer_test.go",
         "server_test.go",
@@ -131,7 +124,6 @@ go_test(
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p/testing:go_default_library",
-        "//beacon-chain/powchain/engine-api-client/v1/mocks:go_default_library",
         "//beacon-chain/powchain/testing:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
@@ -157,15 +149,11 @@ go_test(
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_d4l3k_messagediff//:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_golang_mock//gomock:go_default_library",
-        "@com_github_holiman_uint256//:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@org_golang_google_grpc//codes:go_default_library",
-        "@org_golang_google_grpc//status:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
     ],

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

@@ -28,11 +28,6 @@ func (vs *Server) SubmitAggregateSelectionProof(ctx context.Context, req *ethpb.
 		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
 	}
 
-	// An optimistic validator MUST NOT participate in attestation. (i.e., sign across the DOMAIN_BEACON_ATTESTER, DOMAIN_SELECTION_PROOF or DOMAIN_AGGREGATE_AND_PROOF domains).
-	if err := vs.optimisticStatus(ctx); err != nil {
-		return nil, err
-	}
-
 	st, err := vs.HeadFetcher.HeadState(ctx)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not determine head state: %v", err)

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

@@ -55,7 +55,6 @@ func TestSubmitAggregateAndProof_CantFindValidatorIndex(t *testing.T) {
 	server := &Server{
 		HeadFetcher: &mock.ChainService{State: s},
 		SyncChecker: &mockSync.Sync{IsSyncing: false},
-		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
 	}
 
 	priv, err := bls.RandKey()
@@ -83,7 +82,6 @@ func TestSubmitAggregateAndProof_IsAggregatorAndNoAtts(t *testing.T) {
 		HeadFetcher: &mock.ChainService{State: s},
 		SyncChecker: &mockSync.Sync{IsSyncing: false},
 		AttPool:     attestations.NewPool(),
-		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
 	}
 
 	priv, err := bls.RandKey()
@@ -117,7 +115,6 @@ func TestSubmitAggregateAndProof_UnaggregateOk(t *testing.T) {
 		SyncChecker: &mockSync.Sync{IsSyncing: false},
 		AttPool:     attestations.NewPool(),
 		P2P:         &mockp2p.MockBroadcaster{},
-		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
 	}
 
 	priv, err := bls.RandKey()
@@ -155,7 +152,6 @@ func TestSubmitAggregateAndProof_AggregateOk(t *testing.T) {
 		SyncChecker: &mockSync.Sync{IsSyncing: false},
 		AttPool:     attestations.NewPool(),
 		P2P:         &mockp2p.MockBroadcaster{},
-		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
 	}
 
 	priv, err := bls.RandKey()
@@ -195,7 +191,6 @@ func TestSubmitAggregateAndProof_AggregateNotOk(t *testing.T) {
 		SyncChecker: &mockSync.Sync{IsSyncing: false},
 		AttPool:     attestations.NewPool(),
 		P2P:         &mockp2p.MockBroadcaster{},
-		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
 	}
 
 	priv, err := bls.RandKey()
@@ -324,7 +319,6 @@ func TestSubmitAggregateAndProof_PreferOwnAttestation(t *testing.T) {
 		SyncChecker: &mockSync.Sync{IsSyncing: false},
 		AttPool:     attestations.NewPool(),
 		P2P:         &mockp2p.MockBroadcaster{},
-		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
 	}
 
 	priv, err := bls.RandKey()
@@ -375,7 +369,6 @@ func TestSubmitAggregateAndProof_SelectsMostBitsWhenOwnAttestationNotPresent(t *
 		SyncChecker: &mockSync.Sync{IsSyncing: false},
 		AttPool:     attestations.NewPool(),
 		P2P:         &mockp2p.MockBroadcaster{},
-		TimeFetcher: &mock.ChainService{Genesis: time.Now()},
 	}
 
 	priv, err := bls.RandKey()