test changes

api/client/beacon/checkpoint.go

@@ -12,7 +12,6 @@ import (
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/ssz/detect"
 	"github.com/prysmaticlabs/prysm/io/file"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	log "github.com/sirupsen/logrus"
 	"golang.org/x/mod/semver"
@@ -56,7 +55,7 @@ func (o *OriginData) BlockBytes() []byte {
 }
 
 func fname(prefix string, vu *detect.VersionedUnmarshaler, slot types.Slot, root [32]byte) string {
-	return fmt.Sprintf("%s_%s_%s_%d-%#x.ssz", prefix, vu.Config.ConfigName, version.String(vu.Fork), slot, root)
+	return fmt.Sprintf("%s_%s_%s_%d-%#x.ssz", prefix, vu.Config.ConfigName, vu.Fork.String(), slot, root)
 }
 
 // DownloadFinalizedData downloads the most recently finalized state, and the block most recently applied to that state.
@@ -70,7 +69,7 @@ func DownloadFinalizedData(ctx context.Context, client *Client) (*OriginData, er
 	if err != nil {
 		return nil, errors.Wrap(err, "error detecting chain config for finalized state")
 	}
-	log.Printf("detected supported config in remote finalized state, name=%s, fork=%s", vu.Config.ConfigName, version.String(vu.Fork))
+	log.Printf("detected supported config in remote finalized state, name=%s, fork=%s", vu.Config.ConfigName, vu.Fork.String())
 	s, err := vu.UnmarshalBeaconState(sb)
 	if err != nil {
 		return nil, errors.Wrap(err, "error unmarshaling finalized state to correct version")
@@ -194,7 +193,7 @@ func computeBackwardsCompatible(ctx context.Context, client *Client) (*WeakSubje
 	if err != nil {
 		return nil, errors.Wrap(err, "error detecting chain config for beacon state")
 	}
-	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", vu.Config.ConfigName, version.String(vu.Fork))
+	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", vu.Config.ConfigName, vu.Fork.String())
 
 	s, err := vu.UnmarshalBeaconState(sb)
 	if err != nil {
@@ -245,7 +244,7 @@ func getWeakSubjectivityEpochFromHead(ctx context.Context, client *Client) (type
 	if err != nil {
 		return 0, errors.Wrap(err, "error detecting chain config for beacon state")
 	}
-	log.Printf("detected supported config in remote head state, name=%s, fork=%s", vu.Config.ConfigName, version.String(vu.Fork))
+	log.Printf("detected supported config in remote head state, name=%s, fork=%s", vu.Config.ConfigName, vu.Fork.String())
 	headState, err := vu.UnmarshalBeaconState(headBytes)
 	if err != nil {
 		return 0, errors.Wrap(err, "error unmarshaling state to correct version")

beacon-chain/blockchain/chain_info_test.go

@@ -80,9 +80,9 @@ func TestHeadRoot_Nil(t *testing.T) {
 }
 
 func TestService_ForkChoiceStore(t *testing.T) {
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
+	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}}
 	p := c.ForkChoiceStore()
-	require.Equal(t, types.Epoch(0), p.FinalizedCheckpoint().Epoch)
+	require.Equal(t, 0, int(p.FinalizedEpoch()))
 }
 
 func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
@@ -327,7 +327,7 @@ func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
 }
 func TestService_ChainHeads_ProtoArray(t *testing.T) {
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}}
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0)}}
 	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
@@ -357,7 +357,7 @@ func TestService_ChainHeads_ProtoArray(t *testing.T) {
 
 func TestService_ChainHeads_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
+	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}}
 	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
@@ -452,7 +452,7 @@ func TestService_IsOptimistic_ProtoArray(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
@@ -472,7 +472,7 @@ func TestService_IsOptimistic_DoublyLinkedTree(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
@@ -495,7 +495,7 @@ func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
 
 func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) {
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
@@ -510,7 +510,7 @@ func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) {
 
 func TestService_IsOptimisticForRoot_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
@@ -526,7 +526,7 @@ func TestService_IsOptimisticForRoot_DoublyLinkedTree(t *testing.T) {
 func TestService_IsOptimisticForRoot_DB_ProtoArray(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
@@ -591,7 +591,7 @@ func TestService_IsOptimisticForRoot_DB_ProtoArray(t *testing.T) {
 func TestService_IsOptimisticForRoot_DB_DoublyLinkedTree(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
@@ -655,7 +655,7 @@ func TestService_IsOptimisticForRoot_DB_DoublyLinkedTree(t *testing.T) {
 func TestService_IsOptimisticForRoot_DB_non_canonical(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10

beacon-chain/blockchain/execution_engine.go

@@ -19,6 +19,7 @@ import (
 	"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/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -141,7 +142,7 @@ func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, er
 	if err != nil {
 		return [32]byte{}, err
 	}
-	if blocks.IsPreBellatrixVersion(blk.Block().Version()) {
+	if blk.Block().Version().IsPreBellatrix() {
 		return params.BeaconConfig().ZeroHash, nil
 	}
 	payload, err := blk.Block().Body().ExecutionPayload()
@@ -153,14 +154,14 @@ func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, er
 
 // notifyForkchoiceUpdate signals execution engine on a new payload.
 // It returns true if the EL has returned VALID for the block
-func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion int,
+func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion version.ForkVersion,
 	postStateHeader *ethpb.ExecutionPayloadHeader, blk interfaces.SignedBeaconBlock) (bool, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.notifyNewPayload")
 	defer span.End()
 
 	// Execution payload is only supported in Bellatrix and beyond. Pre
 	// merge blocks are never optimistic
-	if blocks.IsPreBellatrixVersion(postStateVersion) {
+	if postStateVersion.IsPreBellatrix() {
 		return true, nil
 	}
 	if err := wrapper.BeaconBlockIsNil(blk); err != nil {

beacon-chain/blockchain/execution_engine_test.go

@@ -11,7 +11,6 @@ import (
 	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"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	bstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -44,7 +43,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, altairBlk))
 	require.NoError(t, beaconDB.SaveBlock(ctx, bellatrixBlk))
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -185,7 +184,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 			st, _ := util.DeterministicGenesisState(t, 1)
 			require.NoError(t, beaconDB.SaveState(ctx, st, tt.finalizedRoot))
 			require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, tt.finalizedRoot))
-			fc := &ethpb.Checkpoint{Epoch: 0, Root: tt.finalizedRoot[:]}
+			fc := &ethpb.Checkpoint{Epoch: 1, Root: tt.finalizedRoot[:]}
 			service.store.SetFinalizedCheckptAndPayloadHash(fc, [32]byte{'a'})
 			service.store.SetJustifiedCheckptAndPayloadHash(fc, [32]byte{'b'})
 			arg := &notifyForkchoiceUpdateArg{
@@ -290,7 +289,7 @@ func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, wbg))
 
 	// Insert blocks into forkchoice
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -327,9 +326,7 @@ func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
 	fcs.ProcessAttestation(ctx, []uint64{0}, brd, 1)
 	fcs.ProcessAttestation(ctx, []uint64{1}, brf, 1)
 	fcs.ProcessAttestation(ctx, []uint64{2}, brg, 1)
-	jc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: bra}
-	require.NoError(t, fcs.UpdateJustifiedCheckpoint(jc))
-	headRoot, err := fcs.Head(ctx, []uint64{50, 100, 200})
+	headRoot, err := fcs.Head(ctx, bra, []uint64{50, 100, 200})
 	require.NoError(t, err)
 	require.Equal(t, brg, headRoot)
 
@@ -350,7 +347,7 @@ func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
 	_, err = service.notifyForkchoiceUpdate(ctx, a)
 	require.ErrorIs(t, ErrInvalidPayload, err)
 	// Ensure Head is D
-	headRoot, err = fcs.Head(ctx, service.justifiedBalances.balances)
+	headRoot, err = fcs.Head(ctx, bra, service.justifiedBalances.balances)
 	require.NoError(t, err)
 	require.Equal(t, brd, headRoot)
 
@@ -367,7 +364,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -585,7 +582,7 @@ func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -628,7 +625,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -830,7 +827,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	stateGen := stategen.New(beaconDB)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stateGen),
@@ -930,7 +927,7 @@ func TestService_removeInvalidBlockAndState(t *testing.T) {
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -986,7 +983,7 @@ func TestService_getPayloadHash(t *testing.T) {
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)

beacon-chain/blockchain/head.go

@@ -12,7 +12,6 @@ import (
 	"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"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
@@ -96,23 +95,16 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) ([32]byte,
 			return [32]byte{}, err
 		}
 		if features.Get().EnableForkChoiceDoublyLinkedTree {
-			s.cfg.ForkChoiceStore = doublylinkedtree.New()
+			s.cfg.ForkChoiceStore = doublylinkedtree.New(j.Epoch, f.Epoch)
 		} else {
-			s.cfg.ForkChoiceStore = protoarray.New()
+			s.cfg.ForkChoiceStore = protoarray.New(j.Epoch, f.Epoch)
 		}
 		if err := s.insertBlockToForkChoiceStore(ctx, jb.Block(), headStartRoot, st, f, j); err != nil {
 			return [32]byte{}, err
 		}
 	}
-	jc := &forkchoicetypes.Checkpoint{Epoch: j.Epoch, Root: headStartRoot}
-	fc := &forkchoicetypes.Checkpoint{Epoch: f.Epoch, Root: s.ensureRootNotZeros(bytesutil.ToBytes32(f.Root))}
-	if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(jc); err != nil {
-		return [32]byte{}, err
-	}
-	if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(fc); err != nil {
-		return [32]byte{}, err
-	}
-	return s.cfg.ForkChoiceStore.Head(ctx, balances)
+
+	return s.cfg.ForkChoiceStore.Head(ctx, headStartRoot, balances)
 }
 
 // This saves head info to the local service cache, it also saves the

beacon-chain/blockchain/head_test.go

@@ -174,8 +174,10 @@ func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
 	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: r[:]}, [32]byte{'a'})
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{}, [32]byte{'b'})
 	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{})
-	_, err = service.updateHead(context.Background(), []uint64{})
+	headRoot, err := service.updateHead(context.Background(), []uint64{})
 	require.NoError(t, err)
+	st, _ := util.DeterministicGenesisState(t, 1)
+	require.NoError(t, service.saveHead(context.Background(), headRoot, wsb, st))
 }
 
 func Test_notifyNewHeadEvent(t *testing.T) {
@@ -611,7 +613,7 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 	ctx := context.Background()
 
 	beaconDB := testDB.SetupDB(t)
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -628,7 +630,7 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, bellatrixBlk))
 	fcp := &ethpb.Checkpoint{
 		Root:  bellatrixBlkRoot[:],
-		Epoch: 0,
+		Epoch: 1,
 	}
 	service.store.SetFinalizedCheckptAndPayloadHash(fcp, [32]byte{'a'})
 	service.store.SetJustifiedCheckptAndPayloadHash(fcp, [32]byte{'b'})

beacon-chain/blockchain/log.go

@@ -67,7 +67,7 @@ func logBlockSyncStatus(block interfaces.BeaconBlock, blockRoot [32]byte, justif
 		log = log.WithField("justifiedEpoch", justified.Epoch)
 		log = log.WithField("justifiedRoot", fmt.Sprintf("0x%s...", hex.EncodeToString(justified.Root)[:8]))
 		log = log.WithField("parentRoot", fmt.Sprintf("0x%s...", hex.EncodeToString(block.ParentRoot())[:8]))
-		log = log.WithField("version", version.String(block.Version()))
+		log = log.WithField("version", block.Version().String())
 		log = log.WithField("sinceSlotStartTime", prysmTime.Now().Sub(startTime))
 		log = log.WithField("chainServiceProcessedTime", prysmTime.Now().Sub(receivedTime))
 	}

beacon-chain/blockchain/metrics.go

@@ -14,7 +14,6 @@ import (
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 var (
@@ -266,8 +265,8 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 	var b *precompute.Balance
 	var v []*precompute.Validator
 	var err error
-	switch headState.Version() {
-	case version.Phase0:
+	switch {
+	case headState.Version().IsPhase0Compatible():
 		// Validator participation should be viewed on the canonical chain.
 		v, b, err = precompute.New(ctx, headState)
 		if err != nil {
@@ -277,7 +276,7 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 		if err != nil {
 			return err
 		}
-	case version.Altair, version.Bellatrix:
+	case headState.Version().IsParticipationBitsCompatible():
 		v, b, err = altair.InitializePrecomputeValidators(ctx, headState)
 		if err != nil {
 			return err

beacon-chain/blockchain/mock_test.go

@@ -13,7 +13,7 @@ import (
 
 func testServiceOptsWithDB(t *testing.T) []Option {
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	return []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),

beacon-chain/blockchain/new_slot.go

@@ -5,9 +5,7 @@ import (
 	"context"
 
 	"github.com/pkg/errors"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
@@ -70,8 +68,7 @@ func (s *Service) NewSlot(ctx context.Context, slot types.Slot) error {
 				return err
 			}
 			s.store.SetJustifiedCheckptAndPayloadHash(bj, h)
-			if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{
-				Epoch: bj.Epoch, Root: bytesutil.ToBytes32(bj.Root)}); err != nil {
+			if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(bj); err != nil {
 				return err
 			}
 		}

beacon-chain/blockchain/new_slot_test.go

@@ -20,7 +20,7 @@ import (
 
 func TestService_newSlot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),

beacon-chain/blockchain/pow_block_test.go

@@ -109,7 +109,7 @@ func Test_validateMergeBlock(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -152,7 +152,7 @@ func Test_validateMergeBlock(t *testing.T) {
 func Test_getBlkParentHashAndTD(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),

beacon-chain/blockchain/process_attestation_test.go

@@ -9,7 +9,6 @@ import (
 	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"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -29,7 +28,7 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 
 	opts := []Option{
 		WithDatabase(beaconDB),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 		WithStateGen(stategen.New(beaconDB)),
 	}
 	service, err := NewService(ctx, opts...)
@@ -141,7 +140,7 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
 
 	opts := []Option{
 		WithDatabase(beaconDB),
-		WithForkChoiceStore(doublylinkedtree.New()),
+		WithForkChoiceStore(doublylinkedtree.New(0, 0)),
 		WithStateGen(stategen.New(beaconDB)),
 	}
 	service, err := NewService(ctx, opts...)
@@ -251,7 +250,7 @@ func TestStore_OnAttestation_Ok_ProtoArray(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -279,7 +278,7 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -488,7 +487,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -523,7 +522,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -611,9 +610,7 @@ func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
-	jc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r32}
-	require.NoError(t, service.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(jc))
-	_, err = service.cfg.ForkChoiceStore.Head(ctx, []uint64{})
+	_, err = service.cfg.ForkChoiceStore.Head(ctx, r32, []uint64{})
 	require.NoError(t, err)
 	err = service.VerifyFinalizedConsistency(context.Background(), r33[:])
 	require.NoError(t, err)

beacon-chain/blockchain/process_block.go

@@ -222,12 +222,10 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 		}
 		s.store.SetJustifiedCheckptAndPayloadHash(postState.CurrentJustifiedCheckpoint(), h)
 		// Update Forkchoice checkpoints
-		if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{
-			Epoch: psj.Epoch, Root: bytesutil.ToBytes32(psj.Root)}); err != nil {
+		if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(psj); err != nil {
 			return err
 		}
-		if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{
-			Epoch: psf.Epoch, Root: bytesutil.ToBytes32(psf.Root)}); err != nil {
+		if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(psf); err != nil {
 			return err
 		}
 	}
@@ -319,15 +317,15 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	return s.handleEpochBoundary(ctx, postState)
 }
 
-func getStateVersionAndPayload(st state.BeaconState) (int, *ethpb.ExecutionPayloadHeader, error) {
+func getStateVersionAndPayload(st state.BeaconState) (version.ForkVersion, *ethpb.ExecutionPayloadHeader, error) {
 	if st == nil {
 		return 0, nil, errors.New("nil state")
 	}
 	var preStateHeader *ethpb.ExecutionPayloadHeader
 	var err error
 	preStateVersion := st.Version()
-	switch preStateVersion {
-	case version.Phase0, version.Altair:
+	switch {
+	case preStateVersion.IsPreBellatrix():
 	default:
 		preStateHeader, err = st.LatestExecutionPayloadHeader()
 		if err != nil {
@@ -380,7 +378,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 		Messages:   [][32]byte{},
 	}
 	type versionAndHeader struct {
-		version int
+		version version.ForkVersion
 		header  *ethpb.ExecutionPayloadHeader
 	}
 	preVersionAndHeaders := make([]*versionAndHeader, len(blks))
@@ -443,8 +441,8 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 			}
 		}
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
-			JustifiedCheckpoint: jCheckpoints[i],
-			FinalizedCheckpoint: fCheckpoints[i]}
+			JustifiedEpoch: jCheckpoints[i].Epoch,
+			FinalizedEpoch: fCheckpoints[i].Epoch}
 		pendingNodes[len(blks)-i-1] = args
 		s.saveInitSyncBlock(blockRoots[i], b)
 		if err = s.handleBlockAfterBatchVerify(ctx, b, blockRoots[i], fCheckpoints[i], jCheckpoints[i]); err != nil {
@@ -463,7 +461,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 	}
 	// Prune forkchoice store only if the new finalized checkpoint is higher
 	// than the finalized checkpoint in forkchoice store.
-	if fCheckpoints[len(blks)-1].Epoch > s.cfg.ForkChoiceStore.FinalizedCheckpoint().Epoch {
+	if fCheckpoints[len(blks)-1].Epoch > s.cfg.ForkChoiceStore.FinalizedEpoch() {
 		if err := s.cfg.ForkChoiceStore.Prune(ctx, s.ensureRootNotZeros(bytesutil.ToBytes32(fCheckpoints[len(blks)-1].Root))); err != nil {
 			return errors.Wrap(err, "could not prune fork choice nodes")
 		}
@@ -545,8 +543,7 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed interf
 			return err
 		}
 		s.store.SetFinalizedCheckptAndPayloadHash(fCheckpoint, h)
-		if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{
-			Epoch: fCheckpoint.Epoch, Root: bytesutil.ToBytes32(fCheckpoint.Root)}); err != nil {
+		if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(fCheckpoint); err != nil {
 			return err
 		}
 	}
@@ -687,9 +684,9 @@ func (s *Service) pruneCanonicalAttsFromPool(ctx context.Context, r [32]byte, b
 }
 
 // validateMergeTransitionBlock validates the merge transition block.
-func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion int, stateHeader *ethpb.ExecutionPayloadHeader, blk interfaces.SignedBeaconBlock) error {
+func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion version.ForkVersion, stateHeader *ethpb.ExecutionPayloadHeader, blk interfaces.SignedBeaconBlock) error {
 	// Skip validation if block is older than Bellatrix.
-	if blocks.IsPreBellatrixVersion(blk.Block().Version()) {
+	if blk.Block().Version().IsPreBellatrix() {
 		return nil
 	}
 
@@ -704,7 +701,7 @@ func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion
 
 	// Handle case where pre-state is Altair but block contains payload.
 	// To reach here, the block must have contained a valid payload.
-	if blocks.IsPreBellatrixVersion(stateVersion) {
+	if stateVersion.IsPreBellatrix() {
 		return s.validateMergeBlock(ctx, blk)
 	}
 

beacon-chain/blockchain/process_block_helpers.go

@@ -218,8 +218,7 @@ func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaco
 		}
 		s.store.SetJustifiedCheckptAndPayloadHash(cpt, h)
 		// Update forkchoice's justified checkpoint
-		if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{
-			Epoch: cpt.Epoch, Root: bytesutil.ToBytes32(cpt.Root)}); err != nil {
+		if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(cpt); err != nil {
 			return err
 		}
 	}
@@ -245,8 +244,7 @@ func (s *Service) updateJustifiedInitSync(ctx context.Context, cp *ethpb.Checkpo
 		return err
 	}
 	s.store.SetJustifiedCheckptAndPayloadHash(cp, h)
-	return s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{
-		Epoch: cp.Epoch, Root: bytesutil.ToBytes32(cp.Root)})
+	return s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(cp)
 }
 
 func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) error {
@@ -362,7 +360,7 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa
 		return err
 	}
 	pendingNodes = append(pendingNodes, &forkchoicetypes.BlockAndCheckpoints{Block: blk,
-		JustifiedCheckpoint: jCheckpoint, FinalizedCheckpoint: fCheckpoint})
+		JustifiedEpoch: jCheckpoint.Epoch, FinalizedEpoch: fCheckpoint.Epoch})
 	// As long as parent node is not in fork choice store, and parent node is in DB.
 	root := bytesutil.ToBytes32(blk.ParentRoot())
 	for !s.cfg.ForkChoiceStore.HasNode(root) && s.cfg.BeaconDB.HasBlock(ctx, root) {
@@ -375,8 +373,8 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa
 		}
 		root = bytesutil.ToBytes32(b.Block().ParentRoot())
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
-			JustifiedCheckpoint: jCheckpoint,
-			FinalizedCheckpoint: fCheckpoint}
+			JustifiedEpoch: jCheckpoint.Epoch,
+			FinalizedEpoch: fCheckpoint.Epoch}
 		pendingNodes = append(pendingNodes, args)
 	}
 	if len(pendingNodes) == 1 {

beacon-chain/blockchain/process_block_test.go

@@ -47,7 +47,7 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 	ctx := context.Background()
 
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -150,7 +150,7 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
 
 	beaconDB := testDB.SetupDB(t)
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -253,7 +253,7 @@ func TestStore_OnBlock_ProposerBoostEarly(t *testing.T) {
 	ctx := context.Background()
 
 	beaconDB := testDB.SetupDB(t)
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithStateGen(stategen.New(beaconDB)),
 		WithForkChoiceStore(fcs),
@@ -268,7 +268,7 @@ func TestStore_OnBlock_ProposerBoostEarly(t *testing.T) {
 		SecondsIntoSlot: 0,
 	}
 	require.NoError(t, service.cfg.ForkChoiceStore.BoostProposerRoot(ctx, args))
-	_, err = service.cfg.ForkChoiceStore.Head(ctx, []uint64{})
+	_, err = service.cfg.ForkChoiceStore.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{})
 	require.ErrorContains(t, "could not apply proposer boost score: invalid proposer boost root", err)
 }
 
@@ -293,7 +293,7 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
 	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'b'})
 
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -340,7 +340,7 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	jroot := bytesutil.ToBytes32(jcp.Root)
 	require.Equal(t, blkRoots[63], jroot)
-	require.Equal(t, types.Epoch(2), service.cfg.ForkChoiceStore.JustifiedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(2), service.cfg.ForkChoiceStore.JustifiedEpoch())
 }
 
 func TestStore_OnBlockBatch_PruneOK(t *testing.T) {
@@ -362,7 +362,7 @@ func TestStore_OnBlockBatch_PruneOK(t *testing.T) {
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -427,7 +427,7 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
 	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'b'})
 
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -474,7 +474,7 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	jroot := bytesutil.ToBytes32(jcp.Root)
 	require.Equal(t, blkRoots[63], jroot)
-	require.Equal(t, types.Epoch(2), service.cfg.ForkChoiceStore.JustifiedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(2), service.cfg.ForkChoiceStore.JustifiedEpoch())
 }
 
 func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
@@ -496,7 +496,7 @@ func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
 	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'b'})
 
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	service.saveInitSyncBlock(gRoot, wsb)
 	st, keys := util.DeterministicGenesisState(t, 64)
 	bState := st.Copy()
@@ -577,7 +577,7 @@ func TestShouldUpdateJustified_ReturnFalse_ProtoArray(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	lastJustifiedBlk := util.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
 	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
@@ -610,7 +610,7 @@ func TestShouldUpdateJustified_ReturnFalse_DoublyLinkedTree(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	lastJustifiedBlk := util.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
 	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
@@ -657,7 +657,7 @@ func TestCachedPreState_CanGetFromStateSummary_ProtoArray(t *testing.T) {
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -694,7 +694,7 @@ func TestCachedPreState_CanGetFromStateSummary_DoublyLinkedTree(t *testing.T) {
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -728,7 +728,7 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -759,7 +759,7 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -805,7 +805,7 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -851,7 +851,7 @@ func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -898,7 +898,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -947,7 +947,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -996,7 +996,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -1063,7 +1063,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -1131,7 +1131,7 @@ func TestFillForkChoiceMissingBlocks_FinalizedSibling_DoublyLinkedTree(t *testin
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -1272,7 +1272,7 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -1363,7 +1363,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -1425,7 +1425,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -1570,7 +1570,7 @@ func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
 func TestOnBlock_CanFinalize(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -1626,7 +1626,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 func TestOnBlock_NilBlock(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -1645,7 +1645,7 @@ func TestOnBlock_NilBlock(t *testing.T) {
 func TestOnBlock_InvalidSignature(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -1686,7 +1686,7 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -1924,7 +1924,7 @@ func Test_validateMergeTransitionBlock(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -2052,7 +2052,7 @@ func Test_validateMergeTransitionBlock(t *testing.T) {
 func TestService_insertSlashingsToForkChoiceStore(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -2103,7 +2103,7 @@ func TestService_insertSlashingsToForkChoiceStore(t *testing.T) {
 func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -2175,7 +2175,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r2))
 		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r3))
 		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r4))
-		service.cfg.ForkChoiceStore = protoarray.New()
+		service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	}
 }
 
@@ -2183,7 +2183,7 @@ func Test_verifyBlkFinalizedSlot_invalidBlock(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),

beacon-chain/blockchain/receive_block_test.go

@@ -127,7 +127,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 
 			opts := []Option{
 				WithDatabase(beaconDB),
-				WithForkChoiceStore(protoarray.New()),
+				WithForkChoiceStore(protoarray.New(0, 0)),
 				WithAttestationPool(attestations.NewPool()),
 				WithExitPool(voluntaryexits.NewPool()),
 				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
@@ -168,7 +168,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
 	opts := []Option{
 		WithDatabase(beaconDB),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 		WithAttestationPool(attestations.NewPool()),
 		WithExitPool(voluntaryexits.NewPool()),
 		WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
@@ -248,7 +248,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			beaconDB := testDB.SetupDB(t)
 			opts := []Option{
 				WithDatabase(beaconDB),
-				WithForkChoiceStore(protoarray.New()),
+				WithForkChoiceStore(protoarray.New(0, 0)),
 				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
 				WithStateGen(stategen.New(beaconDB)),
 			}

beacon-chain/blockchain/service.go

@@ -23,7 +23,6 @@ import (
 	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"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
@@ -209,20 +208,11 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	var forkChoicer f.ForkChoicer
 	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
 	if features.Get().EnableForkChoiceDoublyLinkedTree {
-		forkChoicer = doublylinkedtree.New()
+		forkChoicer = doublylinkedtree.New(justified.Epoch, finalized.Epoch)
 	} else {
-		forkChoicer = protoarray.New()
+		forkChoicer = protoarray.New(justified.Epoch, finalized.Epoch)
 	}
 	s.cfg.ForkChoiceStore = forkChoicer
-	if err := forkChoicer.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: justified.Epoch,
-		Root: bytesutil.ToBytes32(justified.Root)}); err != nil {
-		return errors.Wrap(err, "could not update forkchoice's justified checkpoint")
-	}
-	if err := forkChoicer.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,
-		Root: bytesutil.ToBytes32(finalized.Root)}); err != nil {
-		return errors.Wrap(err, "could not update forkchoice's finalized checkpoint")
-	}
-
 	st, err := s.cfg.StateGen.StateByRoot(s.ctx, fRoot)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint state")

beacon-chain/blockchain/service_test.go

@@ -130,7 +130,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		WithAttestationPool(attestations.NewPool()),
 		WithP2PBroadcaster(&mockBroadcaster{}),
 		WithStateNotifier(&mockBeaconNode{}),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 		WithAttestationService(attService),
 		WithStateGen(stateGen),
 	}
@@ -505,7 +505,7 @@ func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg:   &config{ForkChoiceStore: protoarray.New(), BeaconDB: beaconDB},
+		cfg:   &config{ForkChoiceStore: protoarray.New(0, 0), BeaconDB: beaconDB},
 		store: &store.Store{},
 	}
 	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}, [32]byte{})
@@ -526,7 +526,7 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg:   &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
+		cfg:   &config{ForkChoiceStore: doublylinkedtree.New(0, 0), BeaconDB: beaconDB},
 		store: &store.Store{},
 	}
 	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}, [32]byte{})
@@ -599,7 +599,7 @@ func BenchmarkHasBlockForkChoiceStore_ProtoArray(b *testing.B) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(b)
 	s := &Service{
-		cfg:   &config{ForkChoiceStore: protoarray.New(), BeaconDB: beaconDB},
+		cfg:   &config{ForkChoiceStore: protoarray.New(0, 0), BeaconDB: beaconDB},
 		store: &store.Store{},
 	}
 	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}, [32]byte{})
@@ -622,7 +622,7 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(b)
 	s := &Service{
-		cfg:   &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
+		cfg:   &config{ForkChoiceStore: doublylinkedtree.New(0, 0), BeaconDB: beaconDB},
 		store: &store.Store{},
 	}
 	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}, [32]byte{})

beacon-chain/blockchain/testing/mock.go

@@ -62,7 +62,6 @@ type ChainService struct {
 	Genesis                     time.Time
 	ForkChoiceStore             forkchoice.ForkChoicer
 	ReceiveBlockMockErr         error
-	OptimisticCheckRootReceived [32]byte
 }
 
 // ForkChoicer mocks the same method in the chain service
@@ -448,8 +447,7 @@ func (s *ChainService) IsOptimistic(_ context.Context) (bool, error) {
 }
 
 // IsOptimisticForRoot mocks the same method in the chain service.
-func (s *ChainService) IsOptimisticForRoot(_ context.Context, root [32]byte) (bool, error) {
-	s.OptimisticCheckRootReceived = root
+func (s *ChainService) IsOptimisticForRoot(_ context.Context, _ [32]byte) (bool, error) {
 	return s.Optimistic, nil
 }
 

beacon-chain/cache/sync_committee_head_state.go

@@ -32,7 +32,7 @@ func (c *SyncCommitteeHeadStateCache) Put(slot types.Slot, st state.BeaconState)
 		return ErrNilValueProvided
 	}
 
-	if st.Version() == version.Phase0 {
+	if st.Version().IsPhase0Compatible() {
 		return ErrIncorrectType
 	}
 

beacon-chain/core/blocks/attester_slashing.go

@@ -13,7 +13,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/slashings"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
@@ -79,11 +78,11 @@ func ProcessAttesterSlashing(
 			cfg := params.BeaconConfig()
 			var slashingQuotient uint64
 			switch {
-			case beaconState.Version() == version.Phase0:
+			case beaconState.Version().IsPhase0Compatible():
 				slashingQuotient = cfg.MinSlashingPenaltyQuotient
-			case beaconState.Version() == version.Altair:
+			case beaconState.Version().IsAltairCompatible():
 				slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
-			case beaconState.Version() == version.Bellatrix:
+			case beaconState.Version().IsBellatrixCompatible():
 				slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
 			default:
 				return nil, errors.New("unknown state version")

beacon-chain/core/blocks/payload.go

@@ -13,7 +13,6 @@ import (
 	"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/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
@@ -33,7 +32,7 @@ func IsMergeTransitionComplete(st state.BeaconState) (bool, error) {
 	if st == nil {
 		return false, errors.New("nil state")
 	}
-	if IsPreBellatrixVersion(st.Version()) {
+	if st.Version().IsPreBellatrix() {
 		return false, nil
 	}
 	h, err := st.LatestExecutionPayloadHeader()
@@ -86,7 +85,7 @@ func IsExecutionEnabled(st state.BeaconState, body interfaces.BeaconBlockBody) (
 	if st == nil || body == nil {
 		return false, errors.New("nil state or block body")
 	}
-	if IsPreBellatrixVersion(st.Version()) {
+	if st.Version().IsPreBellatrix() {
 		return false, nil
 	}
 	header, err := st.LatestExecutionPayloadHeader()
@@ -105,11 +104,6 @@ func IsExecutionEnabledUsingHeader(header *ethpb.ExecutionPayloadHeader, body in
 	return IsExecutionBlock(body)
 }
 
-// IsPreBellatrixVersion returns true if input version is before bellatrix fork.
-func IsPreBellatrixVersion(v int) bool {
-	return v < version.Bellatrix
-}
-
 // ValidatePayloadWhenMergeCompletes validates if payload is valid versus input beacon state.
 // These validation steps ONLY apply to post merge.
 //
@@ -276,7 +270,7 @@ func ProcessPayloadHeader(st state.BeaconState, header *ethpb.ExecutionPayloadHe
 // GetBlockPayloadHash returns the hash of the execution payload of the block
 func GetBlockPayloadHash(blk interfaces.BeaconBlock) ([32]byte, error) {
 	payloadHash := [32]byte{}
-	if IsPreBellatrixVersion(blk.Version()) {
+	if blk.Version().IsPreBellatrix() {
 		return payloadHash, nil
 	}
 	payload, err := blk.Body().ExecutionPayload()

beacon-chain/core/blocks/proposer_slashing.go

@@ -74,10 +74,16 @@ func ProcessProposerSlashing(
 		return nil, errors.Wrap(err, "could not verify proposer slashing")
 	}
 	cfg := params.BeaconConfig()
-
-	slashingQuotient, err := beaconState.MinSlashingPenaltyQuotient()
-	if err != nil {
-		return nil, err
+	var slashingQuotient uint64
+	switch {
+	case beaconState.Version().IsPhase0Compatible():
+		slashingQuotient = cfg.MinSlashingPenaltyQuotient
+	case beaconState.Version().IsAltairCompatible():
+		slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
+	case beaconState.Version().IsBellatrixCompatible():
+		slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
+	default:
+		return nil, errors.New("unknown state version")
 	}
 	beaconState, err = slashFunc(ctx, beaconState, slashing.Header_1.Header.ProposerIndex, slashingQuotient, cfg.ProposerRewardQuotient)
 	if err != nil {

beacon-chain/core/epoch/precompute/attestation.go

@@ -171,7 +171,7 @@ func UpdateValidator(vp []*Validator, record *Validator, indices []uint64, a *et
 }
 
 // UpdateBalance updates pre computed balance store.
-func UpdateBalance(vp []*Validator, bBal *Balance, stateVersion int) *Balance {
+func UpdateBalance(vp []*Validator, bBal *Balance, stateVersion version.ForkVersion) *Balance {
 	for _, v := range vp {
 		if !v.IsSlashed {
 			if v.IsCurrentEpochAttester {
@@ -180,10 +180,10 @@ func UpdateBalance(vp []*Validator, bBal *Balance, stateVersion int) *Balance {
 			if v.IsCurrentEpochTargetAttester {
 				bBal.CurrentEpochTargetAttested += v.CurrentEpochEffectiveBalance
 			}
-			if stateVersion == version.Phase0 && v.IsPrevEpochAttester {
+			if stateVersion.IsPhase0Compatible() && v.IsPrevEpochAttester {
 				bBal.PrevEpochAttested += v.CurrentEpochEffectiveBalance
 			}
-			if (stateVersion == version.Altair || stateVersion == version.Bellatrix) && v.IsPrevEpochSourceAttester {
+			if stateVersion.IsHigherOrEqualToAltair() && v.IsPrevEpochSourceAttester {
 				bBal.PrevEpochAttested += v.CurrentEpochEffectiveBalance
 			}
 			if v.IsPrevEpochTargetAttester {

beacon-chain/core/time/BUILD.bazel

@@ -9,7 +9,6 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
     ],
 )

beacon-chain/core/time/slot_epoch.go

@@ -4,7 +4,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
@@ -48,7 +47,7 @@ func NextEpoch(state state.ReadOnlyBeaconState) types.Epoch {
 
 // HigherEqualThanAltairVersionAndEpoch returns if the input state `s` has a higher version number than Altair state and input epoch `e` is higher equal than fork epoch.
 func HigherEqualThanAltairVersionAndEpoch(s state.BeaconState, e types.Epoch) bool {
-	return s.Version() >= version.Altair && e >= params.BeaconConfig().AltairForkEpoch
+	return s.Version().IsHigherOrEqualToAltair() && e >= params.BeaconConfig().AltairForkEpoch
 }
 
 // CanUpgradeToAltair returns true if the input `slot` can upgrade to Altair.

beacon-chain/core/transition/transition.go

@@ -22,7 +22,6 @@ import (
 	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/math"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"go.opencensus.io/trace"
 )
 
@@ -248,14 +247,14 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot types.Slot)
 			return nil, errors.Wrap(err, "could not process slot")
 		}
 		if time.CanProcessEpoch(state) {
-			switch state.Version() {
-			case version.Phase0:
+			switch {
+			case state.Version().IsPhase0Compatible():
 				state, err = ProcessEpochPrecompute(ctx, state)
 				if err != nil {
 					tracing.AnnotateError(span, err)
 					return nil, errors.Wrap(err, "could not process epoch with optimizations")
 				}
-			case version.Altair, version.Bellatrix:
+			case state.Version().IsHigherOrEqualToAltair():
 				state, err = altair.ProcessEpoch(ctx, state)
 				if err != nil {
 					tracing.AnnotateError(span, err)

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -15,7 +15,6 @@ import (
 	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"go.opencensus.io/trace"
 )
 
@@ -232,13 +231,13 @@ func ProcessOperationsNoVerifyAttsSigs(
 	}
 
 	var err error
-	switch signedBeaconBlock.Version() {
-	case version.Phase0:
+	switch {
+	case signedBeaconBlock.Version().IsPhase0Compatible():
 		state, err = phase0Operations(ctx, state, signedBeaconBlock)
 		if err != nil {
 			return nil, err
 		}
-	case version.Altair, version.Bellatrix:
+	case signedBeaconBlock.Version().IsHigherOrEqualToAltair():
 		state, err = altairOperations(ctx, state, signedBeaconBlock)
 		if err != nil {
 			return nil, err
@@ -329,7 +328,7 @@ func ProcessBlockForStateRoot(
 		return nil, errors.Wrap(err, "could not process block operation")
 	}
 
-	if signed.Block().Version() == version.Phase0 {
+	if signed.Block().Version().IsPhase0Compatible() {
 		return state, nil
 	}
 

beacon-chain/db/kv/blocks.go

@@ -17,7 +17,6 @@ import (
 	"github.com/prysmaticlabs/prysm/container/slice"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	bolt "go.etcd.io/bbolt"
 	"go.opencensus.io/trace"
@@ -794,14 +793,14 @@ func marshalBlock(_ context.Context, blk interfaces.SignedBeaconBlock) ([]byte,
 	if err != nil {
 		return nil, err
 	}
-	switch blk.Version() {
-	case version.BellatrixBlind:
+	switch {
+	case blk.Version().IsBlindedBlockCompatible():
 		return snappy.Encode(nil, append(bellatrixBlindKey, obj...)), nil
-	case version.Bellatrix:
+	case blk.Version().IsBellatrixCompatible():
 		return snappy.Encode(nil, append(bellatrixKey, obj...)), nil
-	case version.Altair:
+	case blk.Version().IsAltairCompatible():
 		return snappy.Encode(nil, append(altairKey, obj...)), nil
-	case version.Phase0:
+	case blk.Version().IsPhase0Compatible():
 		return snappy.Encode(nil, obj), nil
 	default:
 		return nil, errors.New("Unknown block version")

beacon-chain/db/kv/wss.go

@@ -9,7 +9,6 @@ import (
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/ssz/detect"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // SaveOrigin loads an ssz serialized Block & BeaconState from an io.Reader
@@ -38,7 +37,7 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 		return fmt.Errorf("config mismatch, beacon node configured to connect to %s, detected state is for %s", params.BeaconConfig().ConfigName, cf.Config.ConfigName)
 	}
 
-	log.Infof("detected supported config for state & block version, config name=%s, fork name=%s", cf.Config.ConfigName, version.String(cf.Fork))
+	log.Infof("detected supported config for state & block version, config name=%s, fork name=%s", cf.Config.ConfigName, cf.Fork.String())
 	state, err := cf.UnmarshalBeaconState(serState)
 	if err != nil {
 		return errors.Wrap(err, "failed to initialize origin state w/ bytes + config+fork")

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

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -17,7 +16,7 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	ctx := context.Background()
 
 	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), balances)
+	r, err := f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
 
@@ -47,7 +46,7 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	//            2
 	//            |
 	//            3 <- head
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(3), r, "Incorrect head for with justified epoch at 0")
 
@@ -59,8 +58,8 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	//            2 <- head
 	//            |
 	//            3
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Root: indexToHash(2), Epoch: 1}
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 1
+	r, err = f.Head(context.Background(), indexToHash(2), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head with justified epoch at 1")
 
@@ -72,8 +71,8 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	//            2 <- start
 	//            |
 	//            3 <- head
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Root: indexToHash(3), Epoch: 2}
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 2
+	r, err = f.Head(context.Background(), indexToHash(3), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(3), r, "Incorrect head with justified epoch at 2")
 }
@@ -83,7 +82,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
 
-	r, err := f.Head(context.Background(), balances)
+	r, err := f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
 
@@ -144,7 +143,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//         7   8
 	//         |   |
 	//         9  10 <-- head
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(10), r, "Incorrect head with justified epoch at 0")
 
@@ -174,7 +173,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//         7   8
 	//         |   |
 	// head -> 9  10
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head with justified epoch at 0")
 
@@ -204,21 +203,19 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//         7   8
 	//         |   |
 	//         9  10 <-- head
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(10), r, "Incorrect head with justified epoch at 0")
 
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 1, Root: indexToHash(1)}
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 1
+	r, err = f.Head(context.Background(), indexToHash(1), balances)
 	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()
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: justifiedEpoch, Root: params.BeaconConfig().ZeroHash}
-	f.store.finalizedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: finalizedEpoch, Root: params.BeaconConfig().ZeroHash}
+	f := New(justifiedEpoch, finalizedEpoch)
 	state, blkRoot, err := prepareForkchoiceState(ctx, 0, params.BeaconConfig().ZeroHash, [32]byte{}, params.BeaconConfig().ZeroHash, justifiedEpoch, finalizedEpoch)
 	if err != nil {
 		return nil

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

@@ -13,22 +13,22 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
 // New initializes a new fork choice store.
-func New() *ForkChoice {
+func New(justifiedEpoch, finalizedEpoch types.Epoch) *ForkChoice {
 	s := &Store{
-		justifiedCheckpoint: &forkchoicetypes.Checkpoint{},
-		finalizedCheckpoint: &forkchoicetypes.Checkpoint{},
-		proposerBoostRoot:   [32]byte{},
-		nodeByRoot:          make(map[[fieldparams.RootLength]byte]*Node),
-		nodeByPayload:       make(map[[fieldparams.RootLength]byte]*Node),
-		slashedIndices:      make(map[types.ValidatorIndex]bool),
-		pruneThreshold:      defaultPruneThreshold,
+		justifiedEpoch:    justifiedEpoch,
+		finalizedEpoch:    finalizedEpoch,
+		proposerBoostRoot: [32]byte{},
+		nodeByRoot:        make(map[[fieldparams.RootLength]byte]*Node),
+		nodeByPayload:     make(map[[fieldparams.RootLength]byte]*Node),
+		slashedIndices:    make(map[types.ValidatorIndex]bool),
+		pruneThreshold:    defaultPruneThreshold,
 	}
 
 	b := make([]uint64, 0)
@@ -47,6 +47,7 @@ func (f *ForkChoice) NodeCount() int {
 // It firsts computes validator's balance changes then recalculates block tree from leaves to root.
 func (f *ForkChoice) Head(
 	ctx context.Context,
+	justifiedRoot [32]byte,
 	justifiedStateBalances []uint64,
 ) ([32]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.Head")
@@ -72,12 +73,10 @@ func (f *ForkChoice) Head(
 		return [32]byte{}, errors.Wrap(err, "could not apply weight changes")
 	}
 
-	jc := f.JustifiedCheckpoint()
-	fc := f.FinalizedCheckpoint()
-	if err := f.store.treeRootNode.updateBestDescendant(ctx, jc.Epoch, fc.Epoch); err != nil {
+	if err := f.store.treeRootNode.updateBestDescendant(ctx, f.store.justifiedEpoch, f.store.finalizedEpoch); err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not update best descendant")
 	}
-	return f.store.head(ctx)
+	return f.store.head(ctx, justifiedRoot)
 }
 
 // ProcessAttestation processes attestation for vote accounting, it iterates around validator indices
@@ -327,24 +326,20 @@ func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [fieldparams
 	return node.setNodeAndParentValidated(ctx)
 }
 
-// JustifiedCheckpoint of fork choice store.
-func (f *ForkChoice) JustifiedCheckpoint() *forkchoicetypes.Checkpoint {
-	f.store.checkpointsLock.RLock()
-	defer f.store.checkpointsLock.RUnlock()
-	return f.store.justifiedCheckpoint
+// JustifiedEpoch of fork choice store.
+func (f *ForkChoice) JustifiedEpoch() types.Epoch {
+	return f.store.justifiedEpoch
 }
 
-// FinalizedCheckpoint of fork choice store.
-func (f *ForkChoice) FinalizedCheckpoint() *forkchoicetypes.Checkpoint {
-	f.store.checkpointsLock.RLock()
-	defer f.store.checkpointsLock.RUnlock()
-	return f.store.finalizedCheckpoint
+// FinalizedEpoch of fork choice store.
+func (f *ForkChoice) FinalizedEpoch() types.Epoch {
+	return f.store.finalizedEpoch
 }
 
-func (f *ForkChoice) ForkChoiceNodes() []*ethpb.ForkChoiceNode {
+func (f *ForkChoice) ForkChoiceNodes() []*pbrpc.ForkChoiceNode {
 	f.store.nodesLock.RLock()
 	defer f.store.nodesLock.RUnlock()
-	ret := make([]*ethpb.ForkChoiceNode, len(f.store.nodeByRoot))
+	ret := make([]*pbrpc.ForkChoiceNode, len(f.store.nodeByRoot))
 	return f.store.treeRootNode.rpcNodes(ret)
 }
 
@@ -389,25 +384,25 @@ func (f *ForkChoice) InsertSlashedIndex(_ context.Context, index types.Validator
 	}
 }
 
-// UpdateJustifiedCheckpoint sets the justified checkpoint to the given one
-func (f *ForkChoice) UpdateJustifiedCheckpoint(jc *forkchoicetypes.Checkpoint) error {
+// UpdateJustifiedCheckpoint sets the justified epoch to the given one
+func (f *ForkChoice) UpdateJustifiedCheckpoint(jc *pbrpc.Checkpoint) error {
 	if jc == nil {
 		return errInvalidNilCheckpoint
 	}
-	f.store.checkpointsLock.Lock()
-	defer f.store.checkpointsLock.Unlock()
-	f.store.justifiedCheckpoint = jc
+	f.store.nodesLock.Lock()
+	defer f.store.nodesLock.Unlock()
+	f.store.justifiedEpoch = jc.Epoch
 	return nil
 }
 
-// UpdateFinalizedCheckpoint sets the finalized checkpoint to the given one
-func (f *ForkChoice) UpdateFinalizedCheckpoint(fc *forkchoicetypes.Checkpoint) error {
+// UpdateFinalizedCheckpoint sets the finalized epoch to the given one
+func (f *ForkChoice) UpdateFinalizedCheckpoint(fc *pbrpc.Checkpoint) error {
 	if fc == nil {
 		return errInvalidNilCheckpoint
 	}
-	f.store.checkpointsLock.Lock()
-	defer f.store.checkpointsLock.Unlock()
-	f.store.finalizedCheckpoint = fc
+	f.store.nodesLock.Lock()
+	defer f.store.nodesLock.Unlock()
+	f.store.finalizedEpoch = fc.Epoch
 	return nil
 }
 
@@ -478,7 +473,7 @@ func (f *ForkChoice) InsertOptimisticChain(ctx context.Context, chain []*forkcho
 		}
 		if err := f.store.insert(ctx,
 			b.Slot(), r, parentRoot, payloadHash,
-			chain[i].JustifiedCheckpoint.Epoch, chain[i].FinalizedCheckpoint.Epoch); err != nil {
+			chain[i].JustifiedEpoch, chain[i].FinalizedEpoch); err != nil {
 			return err
 		}
 	}

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

@@ -211,9 +211,7 @@ func TestForkChoice_IsCanonicalReorg(t *testing.T) {
 	require.DeepEqual(t, [32]byte{'3'}, f.store.treeRootNode.bestDescendant.root)
 	f.store.nodesLock.Unlock()
 
-	r1 := [32]byte{'1'}
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 1, Root: r1}
-	h, err := f.store.head(ctx)
+	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)
@@ -298,7 +296,7 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 	state, blkRoot, err := prepareForkchoiceState(ctx, 1, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	head, err := f.Head(ctx, []uint64{})
+	head, err := f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'a'}, head)
 
@@ -309,21 +307,21 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	head, err = f.Head(ctx, []uint64{})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
 	// Insert two attestations for block b, one for c it becomes head
 	f.ProcessAttestation(ctx, []uint64{1, 2}, [32]byte{'b'}, 1)
 	f.ProcessAttestation(ctx, []uint64{3}, [32]byte{'c'}, 1)
-	head, err = f.Head(ctx, []uint64{100, 200, 200, 300})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{100, 200, 200, 300})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'b'}, head)
 
 	// Process b's slashing, c is now head
 	f.InsertSlashedIndex(ctx, 1)
 	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
-	head, err = f.Head(ctx, []uint64{100, 200, 200, 300})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{100, 200, 200, 300})
 	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
 	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
@@ -332,7 +330,7 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 	// Process b's slashing again, should be a noop
 	f.InsertSlashedIndex(ctx, 1)
 	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
-	head, err = f.Head(ctx, []uint64{100, 200, 200, 300})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{100, 200, 200, 300})
 	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
 	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
@@ -354,14 +352,12 @@ func TestStore_UpdateCheckpoints(t *testing.T) {
 	f := setup(1, 1)
 	jr := [32]byte{'j'}
 	fr := [32]byte{'f'}
-	jc := &forkchoicetypes.Checkpoint{Root: jr, Epoch: 3}
-	fc := &forkchoicetypes.Checkpoint{Root: fr, Epoch: 2}
+	jc := &ethpb.Checkpoint{Root: jr[:], Epoch: 3}
+	fc := &ethpb.Checkpoint{Root: fr[:], Epoch: 2}
 	require.NoError(t, f.UpdateJustifiedCheckpoint(jc))
 	require.NoError(t, f.UpdateFinalizedCheckpoint(fc))
-	require.Equal(t, f.store.justifiedCheckpoint.Epoch, jc.Epoch)
-	require.Equal(t, f.store.justifiedCheckpoint.Root, jc.Root)
-	require.Equal(t, f.store.finalizedCheckpoint.Epoch, fc.Epoch)
-	require.Equal(t, f.store.finalizedCheckpoint.Root, fc.Root)
+	require.Equal(t, f.store.justifiedEpoch, jc.Epoch)
+	require.Equal(t, f.store.finalizedEpoch, fc.Epoch)
 }
 
 func TestStore_CommonAncestor(t *testing.T) {
@@ -566,10 +562,8 @@ func TestStore_InsertOptimisticChain(t *testing.T) {
 	require.NoError(t, err)
 	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
-	blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(),
-		JustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-	})
+	blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(), JustifiedEpoch: 1,
+		FinalizedEpoch: 1})
 	for i := uint64(2); i < 11; i++ {
 		blk := util.NewBeaconBlock()
 		blk.Block.Slot = types.Slot(i)
@@ -577,10 +571,8 @@ func TestStore_InsertOptimisticChain(t *testing.T) {
 		blk.Block.ParentRoot = copiedRoot[:]
 		wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
 		require.NoError(t, err)
-		blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(),
-			JustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-			FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-		})
+		blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(), JustifiedEpoch: 1,
+			FinalizedEpoch: 1})
 		root, err = blk.Block.HashTreeRoot()
 		require.NoError(t, err)
 	}

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

@@ -15,7 +15,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	ctx := context.Background()
 
 	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), balances)
+	r, err := f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	if r != params.BeaconConfig().ZeroHash {
 		t.Errorf("Incorrect head with genesis")
@@ -28,7 +28,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err := prepareForkchoiceState(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -39,7 +39,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -52,7 +52,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -65,7 +65,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
 
@@ -80,7 +80,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
 
@@ -92,8 +92,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//  head -> 4  3
 	//          |
 	//          5 <- starting from 5 with justified epoch 0 should error
-	f.store.justifiedCheckpoint.Root = indexToHash(5)
-	_, err = f.Head(context.Background(), balances)
+	_, err = f.Head(context.Background(), indexToHash(5), balances)
 	wanted := "head at slot 0 with weight 0 is not eligible, finalizedEpoch 1 != 1, justifiedEpoch 2 != 1"
 	require.ErrorContains(t, wanted, err)
 
@@ -105,8 +104,8 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//          4  3
 	//          |
 	//          5 <- head
-	f.store.justifiedCheckpoint.Epoch = 2
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 2
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(5), r, "Incorrect head for with justified epoch at 2")
 
@@ -123,7 +122,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(6), indexToHash(5), params.BeaconConfig().ZeroHash, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 2")
 }

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

@@ -35,7 +35,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
 		// The head should always start at the finalized block.
-		headRoot, err := f.Head(ctx, balances)
+		headRoot, err := f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, zeroHash, headRoot, "Incorrect head with genesis")
 
@@ -58,7 +58,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		f.ProcessAttestation(ctx, []uint64{0}, newRoot, fEpoch)
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 1")
 
@@ -82,7 +82,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		f.ProcessAttestation(ctx, []uint64{1}, newRoot, fEpoch)
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 2")
 
@@ -108,7 +108,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		f.ProcessAttestation(ctx, []uint64{2}, newRoot, fEpoch)
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
 
@@ -144,7 +144,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		}
 
 		require.NoError(t, f.BoostProposerRoot(ctx, args))
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
 
@@ -186,7 +186,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// Regression: process attestations for C, check that it
 		// becomes head, we need two attestations to have C.weight = 30 > 24 = D.weight
 		f.ProcessAttestation(ctx, []uint64{4, 5}, indexToHash(3), fEpoch)
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, indexToHash(3), headRoot, "Incorrect head for justified epoch at slot 4")
 
@@ -195,7 +195,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
 		// The head should always start at the finalized block.
-		r, err := f.Head(ctx, balances)
+		r, err := f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, zeroHash, r, "Incorrect head with genesis")
 
@@ -220,7 +220,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
@@ -239,7 +239,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure the head is C, the honest block.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
@@ -260,7 +260,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.ProcessAttestation(ctx, votes, honestBlock, fEpoch)
 
 		// Ensure the head is STILL C, the honest block, as the honest block had proposer boost.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 	})
@@ -268,7 +268,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
 		// The head should always start at the finalized block.
-		r, err := f.Head(ctx, balances)
+		r, err := f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, zeroHash, r, "Incorrect head with genesis")
 
@@ -295,7 +295,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure C is the head.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
@@ -314,7 +314,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure C is still the head after the malicious proposer reveals their block.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
@@ -333,7 +333,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
 
 		// Expect the head to have switched to B.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, maliciouslyWithheldBlock, r, "Expected B to become the head")
 	})
@@ -355,7 +355,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		a := zeroHash
 
 		// The head should always start at the finalized block.
-		r, err := f.Head(ctx, balances)
+		r, err := f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, zeroHash, r, "Incorrect head with genesis")
 
@@ -374,7 +374,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure C is the head.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
 
@@ -402,7 +402,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure C is still the head.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
 
@@ -426,7 +426,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// D cannot win without a boost.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, c, r, "Expected C to remain the head")
 
@@ -442,7 +442,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// Ensure D becomes the head thanks to boosting.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, d, r, "Expected D to become the head")
 	})

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

@@ -60,12 +60,12 @@ func (s *Store) PruneThreshold() uint64 {
 
 // 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) ([32]byte, error) {
+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[s.justifiedCheckpoint.Root]
+	justifiedNode, ok := s.nodeByRoot[justifiedRoot]
 	if !ok || justifiedNode == nil {
 		return [32]byte{}, errUnknownJustifiedRoot
 	}
@@ -77,9 +77,9 @@ func (s *Store) head(ctx context.Context) ([32]byte, error) {
 		bestDescendant = justifiedNode
 	}
 
-	if !bestDescendant.viableForHead(s.justifiedCheckpoint.Epoch, s.finalizedCheckpoint.Epoch) {
+	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.finalizedCheckpoint.Epoch, bestDescendant.justifiedEpoch, s.justifiedCheckpoint.Epoch)
+			bestDescendant.slot, bestDescendant.weight/10e9, bestDescendant.finalizedEpoch, s.finalizedEpoch, bestDescendant.justifiedEpoch, s.justifiedEpoch)
 	}
 
 	// Update metrics.
@@ -134,8 +134,7 @@ func (s *Store) insert(ctx context.Context,
 		}
 	} else {
 		parent.children = append(parent.children, n)
-		if err := s.treeRootNode.updateBestDescendant(ctx,
-			s.justifiedCheckpoint.Epoch, s.finalizedCheckpoint.Epoch); err != nil {
+		if err := s.treeRootNode.updateBestDescendant(ctx, s.justifiedEpoch, s.finalizedEpoch); err != nil {
 			return err
 		}
 	}

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

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -23,13 +22,13 @@ 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.JustifiedCheckpoint().Epoch)
+	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.FinalizedCheckpoint().Epoch)
+	require.Equal(t, j, f.FinalizedEpoch())
 }
 
 func TestStore_NodeCount(t *testing.T) {
@@ -79,8 +78,7 @@ func TestForkChoice_HasNode(t *testing.T) {
 func TestStore_Head_UnknownJustifiedRoot(t *testing.T) {
 	f := setup(0, 0)
 
-	f.store.justifiedCheckpoint.Root = [32]byte{'a'}
-	_, err := f.store.head(context.Background())
+	_, err := f.store.head(context.Background(), [32]byte{'a'})
 	assert.ErrorContains(t, errUnknownJustifiedRoot.Error(), err)
 }
 
@@ -92,8 +90,7 @@ func TestStore_Head_Itself(t *testing.T) {
 
 	// Since the justified node does not have a best descendant so the best node
 	// is itself.
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: indexToHash(1)}
-	h, err := f.store.head(context.Background())
+	h, err := f.store.head(context.Background(), indexToHash(1))
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(1), h)
 }
@@ -113,8 +110,7 @@ func TestStore_Head_BestDescendant(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: indexToHash(1)}
-	h, err := f.store.head(context.Background())
+	h, err := f.store.head(context.Background(), indexToHash(1))
 	require.NoError(t, err)
 	require.Equal(t, h, indexToHash(4))
 }
@@ -137,9 +133,7 @@ func TestStore_Insert(t *testing.T) {
 	treeRootNode := &Node{slot: 0, root: indexToHash(0)}
 	nodeByRoot := map[[32]byte]*Node{indexToHash(0): treeRootNode}
 	nodeByPayload := map[[32]byte]*Node{indexToHash(0): treeRootNode}
-	jc := &forkchoicetypes.Checkpoint{Epoch: 0}
-	fc := &forkchoicetypes.Checkpoint{Epoch: 0}
-	s := &Store{nodeByRoot: nodeByRoot, treeRootNode: treeRootNode, nodeByPayload: nodeByPayload, justifiedCheckpoint: jc, finalizedCheckpoint: fc}
+	s := &Store{nodeByRoot: nodeByRoot, treeRootNode: treeRootNode, nodeByPayload: nodeByPayload}
 	payloadHash := [32]byte{'a'}
 	require.NoError(t, s.insert(context.Background(), 100, indexToHash(100), indexToHash(0), payloadHash, 1, 1))
 	assert.Equal(t, 2, len(s.nodeByRoot), "Did not insert block")

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

@@ -3,7 +3,6 @@ package doublylinkedtree
 import (
 	"sync"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 )
@@ -18,8 +17,8 @@ type ForkChoice struct {
 
 // Store defines the fork choice store which includes block nodes and the last view of checkpoint information.
 type Store struct {
-	justifiedCheckpoint        *forkchoicetypes.Checkpoint            // latest justified epoch in store.
-	finalizedCheckpoint        *forkchoicetypes.Checkpoint            // latest finalized epoch in store.
+	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.
@@ -31,7 +30,6 @@ type Store struct {
 	slashedIndices             map[types.ValidatorIndex]bool          // the list of equivocating validator indices
 	nodesLock                  sync.RWMutex
 	proposerBoostLock          sync.RWMutex
-	checkpointsLock            sync.RWMutex
 }
 
 // Node defines the individual block which includes its block parent, ancestor and how much weight accounted for it.

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

@@ -44,11 +44,11 @@ func (f *ForkChoice) UpdateUnrealizedCheckpoints() {
 	for _, node := range f.store.nodeByRoot {
 		node.justifiedEpoch = node.unrealizedJustifiedEpoch
 		node.finalizedEpoch = node.unrealizedFinalizedEpoch
-		if node.justifiedEpoch > f.store.justifiedCheckpoint.Epoch {
-			f.store.justifiedCheckpoint.Epoch = node.justifiedEpoch
+		if node.justifiedEpoch > f.store.justifiedEpoch {
+			f.store.justifiedEpoch = node.justifiedEpoch
 		}
-		if node.finalizedEpoch > f.store.finalizedCheckpoint.Epoch {
-			f.store.finalizedCheckpoint.Epoch = node.finalizedEpoch
+		if node.finalizedEpoch > f.store.finalizedEpoch {
+			f.store.finalizedEpoch = node.finalizedEpoch
 		}
 	}
 }

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

@@ -4,9 +4,9 @@ import (
 	"context"
 	"testing"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
@@ -80,17 +80,17 @@ func TestStore_LongFork(t *testing.T) {
 
 	// Add an attestation to c, it is head
 	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'c'}, 1)
-	headRoot, err := f.Head(ctx, []uint64{100})
+	headRoot, err := f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, headRoot)
 
 	// D is head even though its weight is lower.
-	ha := [32]byte{'a'}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'b'}, [32]byte{'D'}, 2, 1)
+	hr := [32]byte{'d'}
+	state, blkRoot, err = prepareForkchoiceState(ctx, 103, hr, [32]byte{'b'}, [32]byte{'D'}, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	require.NoError(t, f.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 2, Root: ha}))
-	headRoot, err = f.Head(ctx, []uint64{100})
+	require.NoError(t, f.UpdateJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 2, Root: hr[:]}))
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'d'}, headRoot)
 	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'d'}].weight)
@@ -98,7 +98,7 @@ func TestStore_LongFork(t *testing.T) {
 
 	// Update unrealized justification, c becomes head
 	f.UpdateUnrealizedCheckpoints()
-	headRoot, err = f.Head(ctx, []uint64{100})
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, headRoot)
 }
@@ -157,31 +157,30 @@ func TestStore_NoDeadLock(t *testing.T) {
 
 	// Epoch 3
 	// Current Head is H
-	headRoot, err := f.Head(ctx, []uint64{100})
+	headRoot, err := f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'h'}, headRoot)
-	require.Equal(t, types.Epoch(0), f.JustifiedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(0), f.JustifiedEpoch())
 
 	// Insert Block I, it becomes Head
 	hr := [32]byte{'i'}
 	state, blkRoot, err = prepareForkchoiceState(ctx, 108, hr, [32]byte{'f'}, [32]byte{'I'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	ha := [32]byte{'a'}
-	require.NoError(t, f.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 1, Root: ha}))
-	headRoot, err = f.Head(ctx, []uint64{100})
+	require.NoError(t, f.UpdateJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 1, Root: hr[:]}))
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'i'}, headRoot)
-	require.Equal(t, types.Epoch(1), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, types.Epoch(0), f.FinalizedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(1), f.JustifiedEpoch())
+	require.Equal(t, types.Epoch(0), f.FinalizedEpoch())
 
 	// Realized Justified checkpoints, H becomes head
 	f.UpdateUnrealizedCheckpoints()
-	headRoot, err = f.Head(ctx, []uint64{100})
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'h'}, headRoot)
-	require.Equal(t, types.Epoch(2), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, types.Epoch(1), f.FinalizedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(2), f.JustifiedEpoch())
+	require.Equal(t, types.Epoch(1), f.FinalizedEpoch())
 }
 
 //    Epoch  1       |         Epoch 2
@@ -226,10 +225,10 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 
 	// Insert an attestation to H, H is head
 	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'h'}, 1)
-	headRoot, err := f.Head(ctx, []uint64{100})
+	headRoot, err := f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'h'}, headRoot)
-	require.Equal(t, types.Epoch(0), f.JustifiedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(0), f.JustifiedEpoch())
 
 	// D arrives late, D is head
 	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 0, 0)
@@ -237,10 +236,10 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'d'}, 1))
 	f.UpdateUnrealizedCheckpoints()
-	headRoot, err = f.Head(ctx, []uint64{100})
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'d'}, headRoot)
-	require.Equal(t, types.Epoch(1), f.JustifiedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(1), f.JustifiedEpoch())
 	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'d'}].weight)
 	require.Equal(t, uint64(100), f.store.nodeByRoot[[32]byte{'h'}].weight)
 }

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

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -16,7 +15,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	ctx := context.Background()
 
 	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), balances)
+	r, err := f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
 
@@ -28,7 +27,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -40,7 +39,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -49,7 +48,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//           / \
 	//          2  1 <- +vote, new head
 	f.ProcessAttestation(context.Background(), []uint64{0}, indexToHash(1), 2)
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(1), r, "Incorrect head for with justified epoch at 1")
 
@@ -58,7 +57,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//                    / \
 	// vote, new head -> 2  1
 	f.ProcessAttestation(context.Background(), []uint64{1}, indexToHash(2), 2)
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -72,7 +71,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -83,7 +82,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//             |
 	//             3 <- new vote
 	f.ProcessAttestation(context.Background(), []uint64{0}, indexToHash(3), 3)
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -94,7 +93,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//                |
 	//                3 <- head
 	f.ProcessAttestation(context.Background(), []uint64{1}, indexToHash(1), 3)
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(3), r, "Incorrect head for with justified epoch at 1")
 
@@ -110,7 +109,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
 
@@ -128,7 +127,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
 
@@ -189,7 +188,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 1")
 
@@ -210,9 +209,9 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//           8
 	//           |
 	//           9 <- head
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Root: indexToHash(5), Epoch: 2}
-	f.store.finalizedCheckpoint = &forkchoicetypes.Checkpoint{Root: indexToHash(5), Epoch: 2}
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 2
+	f.store.finalizedEpoch = 2
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
 
@@ -238,7 +237,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
 
@@ -247,28 +246,28 @@ func TestVotes_CanFindHead(t *testing.T) {
 	// 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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 1")
 
@@ -277,7 +276,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
 
@@ -301,7 +300,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
 
@@ -319,7 +318,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(11), r, "Incorrect head for with justified epoch at 2")
 }

beacon-chain/forkchoice/interfaces.go

@@ -23,7 +23,7 @@ type ForkChoicer interface {
 
 // HeadRetriever retrieves head root and optimistic info of the current chain.
 type HeadRetriever interface {
-	Head(context.Context, []uint64) ([32]byte, error)
+	Head(context.Context, [32]byte, []uint64) ([32]byte, error)
 	Tips() ([][32]byte, []types.Slot)
 	IsOptimistic(root [32]byte) (bool, error)
 }
@@ -59,8 +59,8 @@ type Getter interface {
 	AncestorRoot(ctx context.Context, root [32]byte, slot types.Slot) ([]byte, error)
 	CommonAncestorRoot(ctx context.Context, root1 [32]byte, root2 [32]byte) ([32]byte, error)
 	IsCanonical(root [32]byte) bool
-	FinalizedCheckpoint() *forkchoicetypes.Checkpoint
-	JustifiedCheckpoint() *forkchoicetypes.Checkpoint
+	FinalizedEpoch() types.Epoch
+	JustifiedEpoch() types.Epoch
 	ForkChoiceNodes() []*ethpb.ForkChoiceNode
 	NodeCount() int
 }
@@ -69,6 +69,6 @@ type Getter interface {
 type Setter interface {
 	SetOptimisticToValid(context.Context, [fieldparams.RootLength]byte) error
 	SetOptimisticToInvalid(context.Context, [fieldparams.RootLength]byte, [fieldparams.RootLength]byte, [fieldparams.RootLength]byte) ([][32]byte, error)
-	UpdateJustifiedCheckpoint(*forkchoicetypes.Checkpoint) error
-	UpdateFinalizedCheckpoint(*forkchoicetypes.Checkpoint) error
+	UpdateJustifiedCheckpoint(*ethpb.Checkpoint) error
+	UpdateFinalizedCheckpoint(*ethpb.Checkpoint) error
 }

beacon-chain/forkchoice/protoarray/ffg_update_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -62,7 +61,7 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	ctx := context.Background()
 
 	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), balances)
+	r, err := f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
 
@@ -92,7 +91,7 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	//            2
 	//            |
 	//            3 <- head
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(3), r, "Incorrect head for with justified epoch at 0")
 
@@ -104,9 +103,8 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	//            2 <- head
 	//            |
 	//            3
-	jc := &forkchoicetypes.Checkpoint{Epoch: 1, Root: indexToHash(2)}
-	f.store.justifiedCheckpoint = jc
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 1
+	r, err = f.Head(context.Background(), indexToHash(2), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head with justified epoch at 1")
 
@@ -118,9 +116,8 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	//            2 <- start
 	//            |
 	//            3 <- head
-	jc = &forkchoicetypes.Checkpoint{Epoch: 2, Root: indexToHash(3)}
-	f.store.justifiedCheckpoint = jc
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 2
+	r, err = f.Head(context.Background(), indexToHash(3), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(3), r, "Incorrect head with justified epoch at 2")
 }
@@ -130,7 +127,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
 
-	r, err := f.Head(context.Background(), balances)
+	r, err := f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
 
@@ -191,7 +188,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//         7   8
 	//         |   |
 	//         9  10 <-- head
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(10), r, "Incorrect head with justified epoch at 0")
 
@@ -221,7 +218,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//         7   8
 	//         |   |
 	// head -> 9  10
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head with justified epoch at 0")
 
@@ -251,22 +248,19 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//         7   8
 	//         |   |
 	//         9  10 <-- head
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(10), r, "Incorrect head with justified epoch at 0")
 
-	jc := &forkchoicetypes.Checkpoint{Epoch: 1, Root: indexToHash(1)}
-	f.store.justifiedCheckpoint = jc
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 1
+	r, err = f.Head(context.Background(), indexToHash(1), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(7), r, "Incorrect head with justified epoch at 0")
 }
 
 func setup(justifiedEpoch, finalizedEpoch types.Epoch) *ForkChoice {
-	f := New()
+	f := New(justifiedEpoch, finalizedEpoch)
 	f.store.nodesIndices[params.BeaconConfig().ZeroHash] = 0
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: justifiedEpoch, Root: params.BeaconConfig().ZeroHash}
-	f.store.finalizedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: finalizedEpoch, Root: params.BeaconConfig().ZeroHash}
 	f.store.nodes = append(f.store.nodes, &Node{
 		slot:           0,
 		root:           params.BeaconConfig().ZeroHash,
@@ -277,5 +271,6 @@ func setup(justifiedEpoch, finalizedEpoch types.Epoch) *ForkChoice {
 		bestDescendant: NonExistentNode,
 		weight:         0,
 	})
+
 	return f
 }

beacon-chain/forkchoice/protoarray/no_vote_test.go

@@ -15,7 +15,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	ctx := context.Background()
 
 	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), balances)
+	r, err := f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	if r != params.BeaconConfig().ZeroHash {
 		t.Errorf("Incorrect head with genesis")
@@ -28,7 +28,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err := prepareForkchoiceState(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -39,7 +39,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -52,7 +52,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -65,7 +65,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
 
@@ -80,7 +80,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
 
@@ -92,8 +92,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//  head -> 4  3
 	//          |
 	//          5 <- starting from 5 with justified epoch 0 should error
-	f.store.justifiedCheckpoint.Root = indexToHash(5)
-	_, err = f.Head(context.Background(), balances)
+	_, err = f.Head(context.Background(), indexToHash(5), balances)
 	wanted := "head at slot 0 with weight 0 is not eligible, finalizedEpoch 1 != 1, justifiedEpoch 2 != 1"
 	require.ErrorContains(t, wanted, err)
 
@@ -105,8 +104,8 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//          4  3
 	//          |
 	//          5 <- head
-	f.store.justifiedCheckpoint.Epoch = 2
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 2
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(5), r, "Incorrect head for with justified epoch at 2")
 
@@ -123,7 +122,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(6), indexToHash(5), params.BeaconConfig().ZeroHash, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 2")
 }

beacon-chain/forkchoice/protoarray/proposer_boost_test.go

@@ -35,7 +35,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
 		// The head should always start at the finalized block.
-		headRoot, err := f.Head(ctx, balances)
+		headRoot, err := f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, zeroHash, headRoot, "Incorrect head with genesis")
 
@@ -57,7 +57,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		f.ProcessAttestation(ctx, []uint64{0}, newRoot, fEpoch)
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 1")
 
@@ -81,7 +81,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		f.ProcessAttestation(ctx, []uint64{1}, newRoot, fEpoch)
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 2")
 
@@ -107,7 +107,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		f.ProcessAttestation(ctx, []uint64{2}, newRoot, fEpoch)
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
 
@@ -142,7 +142,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 			SecondsIntoSlot: 0,
 		}
 		require.NoError(t, f.BoostProposerRoot(ctx, args))
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
 
@@ -180,7 +180,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// Regression: process attestations for C, check that it
 		// becomes head, we need two attestations to have C.weight = 30 > 24 = D.weight
 		f.ProcessAttestation(ctx, []uint64{4, 5}, indexToHash(3), fEpoch)
-		headRoot, err = f.Head(ctx, balances)
+		headRoot, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, indexToHash(3), headRoot, "Incorrect head for justified epoch at slot 4")
 	})
@@ -188,7 +188,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
 		// The head should always start at the finalized block.
-		r, err := f.Head(ctx, balances)
+		r, err := f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, zeroHash, r, "Incorrect head with genesis")
 
@@ -213,7 +213,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
@@ -232,7 +232,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure the head is C, the honest block.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
@@ -253,7 +253,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.ProcessAttestation(ctx, votes, honestBlock, fEpoch)
 
 		// Ensure the head is STILL C, the honest block, as the honest block had proposer boost.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 	})
@@ -261,7 +261,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
 		// The head should always start at the finalized block.
-		r, err := f.Head(ctx, balances)
+		r, err := f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, zeroHash, r, "Incorrect head with genesis")
 
@@ -288,7 +288,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure C is the head.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
@@ -307,7 +307,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure C is still the head after the malicious proposer reveals their block.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
@@ -326,7 +326,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
 
 		// Expect the head to have switched to B.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, maliciouslyWithheldBlock, r, "Expected B to become the head")
 	})
@@ -348,7 +348,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		a := zeroHash
 
 		// The head should always start at the finalized block.
-		r, err := f.Head(ctx, balances)
+		r, err := f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, zeroHash, r, "Incorrect head with genesis")
 
@@ -367,7 +367,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure C is the head.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
 
@@ -395,7 +395,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// Ensure C is still the head.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
 
@@ -419,7 +419,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		// D cannot win without a boost.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, c, r, "Expected C to remain the head")
 
@@ -435,7 +435,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// Ensure D becomes the head thanks to boosting.
-		r, err = f.Head(ctx, balances)
+		r, err = f.Head(ctx, zeroHash, balances)
 		require.NoError(t, err)
 		assert.Equal(t, d, r, "Expected D to become the head")
 	})

beacon-chain/forkchoice/protoarray/store.go

@@ -29,17 +29,17 @@ const defaultPruneThreshold = 256
 var lastHeadRoot [32]byte
 
 // New initializes a new fork choice store.
-func New() *ForkChoice {
+func New(justifiedEpoch, finalizedEpoch types.Epoch) *ForkChoice {
 	s := &Store{
-		justifiedCheckpoint: &forkchoicetypes.Checkpoint{},
-		finalizedCheckpoint: &forkchoicetypes.Checkpoint{},
-		proposerBoostRoot:   [32]byte{},
-		nodes:               make([]*Node, 0),
-		nodesIndices:        make(map[[32]byte]uint64),
-		payloadIndices:      make(map[[32]byte]uint64),
-		canonicalNodes:      make(map[[32]byte]bool),
-		slashedIndices:      make(map[types.ValidatorIndex]bool),
-		pruneThreshold:      defaultPruneThreshold,
+		justifiedEpoch:    justifiedEpoch,
+		finalizedEpoch:    finalizedEpoch,
+		proposerBoostRoot: [32]byte{},
+		nodes:             make([]*Node, 0),
+		nodesIndices:      make(map[[32]byte]uint64),
+		payloadIndices:    make(map[[32]byte]uint64),
+		canonicalNodes:    make(map[[32]byte]bool),
+		slashedIndices:    make(map[types.ValidatorIndex]bool),
+		pruneThreshold:    defaultPruneThreshold,
 	}
 
 	b := make([]uint64, 0)
@@ -49,7 +49,11 @@ func New() *ForkChoice {
 
 // 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, justifiedStateBalances []uint64) ([32]byte, error) {
+func (f *ForkChoice) Head(
+	ctx context.Context,
+	justifiedRoot [32]byte,
+	justifiedStateBalances []uint64,
+) ([32]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "protoArrayForkChoice.Head")
 	defer span.End()
 	f.votesLock.Lock()
@@ -72,7 +76,7 @@ func (f *ForkChoice) Head(ctx context.Context, justifiedStateBalances []uint64)
 	}
 	f.balances = newBalances
 
-	return f.store.head(ctx)
+	return f.store.head(ctx, justifiedRoot)
 }
 
 // ProcessAttestation processes attestation for vote accounting, it iterates around validator indices
@@ -269,18 +273,14 @@ func (s *Store) PruneThreshold() uint64 {
 	return s.pruneThreshold
 }
 
-// JustifiedCheckpoint of fork choice store.
-func (f *ForkChoice) JustifiedCheckpoint() *forkchoicetypes.Checkpoint {
-	f.store.checkpointsLock.RLock()
-	defer f.store.checkpointsLock.RUnlock()
-	return f.store.justifiedCheckpoint
+// JustifiedEpoch of fork choice store.
+func (f *ForkChoice) JustifiedEpoch() types.Epoch {
+	return f.store.justifiedEpoch
 }
 
-// FinalizedCheckpoint of fork choice store.
-func (f *ForkChoice) FinalizedCheckpoint() *forkchoicetypes.Checkpoint {
-	f.store.checkpointsLock.RLock()
-	defer f.store.checkpointsLock.RUnlock()
-	return f.store.finalizedCheckpoint
+// FinalizedEpoch of fork choice store.
+func (f *ForkChoice) FinalizedEpoch() types.Epoch {
+	return f.store.finalizedEpoch
 }
 
 // proposerBoost of fork choice store.
@@ -291,23 +291,20 @@ func (s *Store) proposerBoost() [fieldparams.RootLength]byte {
 }
 
 // head starts from justified root and then follows the best descendant links
-// to find the best block for head. It assumes the caller has a lock on nodes.
-func (s *Store) head(ctx context.Context) ([32]byte, error) {
+// to find the best block for head.
+func (s *Store) head(ctx context.Context, justifiedRoot [32]byte) ([32]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "protoArrayForkChoice.head")
 	defer span.End()
 
 	// Justified index has to be valid in node indices map, and can not be out of bound.
-	if s.justifiedCheckpoint == nil {
-		return [32]byte{}, errInvalidNilCheckpoint
-	}
-
-	justifiedIndex, ok := s.nodesIndices[s.justifiedCheckpoint.Root]
+	justifiedIndex, ok := s.nodesIndices[justifiedRoot]
 	if !ok {
 		return [32]byte{}, errUnknownJustifiedRoot
 	}
 	if justifiedIndex >= uint64(len(s.nodes)) {
 		return [32]byte{}, errInvalidJustifiedIndex
 	}
+
 	justifiedNode := s.nodes[justifiedIndex]
 	bestDescendantIndex := justifiedNode.bestDescendant
 	// If the justified node doesn't have a best descendant,
@@ -318,11 +315,12 @@ func (s *Store) head(ctx context.Context) ([32]byte, error) {
 	if bestDescendantIndex >= uint64(len(s.nodes)) {
 		return [32]byte{}, errInvalidBestDescendantIndex
 	}
+
 	bestNode := s.nodes[bestDescendantIndex]
 
 	if !s.viableForHead(bestNode) {
 		return [32]byte{}, fmt.Errorf("head at slot %d with weight %d is not eligible, finalizedEpoch %d != %d, justifiedEpoch %d != %d",
-			bestNode.slot, bestNode.weight/10e9, bestNode.finalizedEpoch, s.finalizedCheckpoint.Epoch, bestNode.justifiedEpoch, s.justifiedCheckpoint.Epoch)
+			bestNode.slot, bestNode.weight/10e9, bestNode.finalizedEpoch, s.finalizedEpoch, bestNode.justifiedEpoch, s.justifiedEpoch)
 	}
 
 	// Update metrics.
@@ -745,12 +743,10 @@ func (s *Store) leadsToViableHead(node *Node) (bool, error) {
 // Any node with diff finalized or justified epoch than the ones in fork choice store
 // should not be viable to head.
 func (s *Store) viableForHead(node *Node) bool {
-	s.checkpointsLock.RLock()
-	defer s.checkpointsLock.RUnlock()
 	// `node` is viable if its justified epoch and finalized epoch are the same as the one in `Store`.
 	// It's also viable if we are in genesis epoch.
-	justified := s.justifiedCheckpoint.Epoch == node.justifiedEpoch || s.justifiedCheckpoint.Epoch == 0
-	finalized := s.finalizedCheckpoint.Epoch == node.finalizedEpoch || s.finalizedCheckpoint.Epoch == 0
+	justified := s.justifiedEpoch == node.justifiedEpoch || s.justifiedEpoch == 0
+	finalized := s.finalizedEpoch == node.finalizedEpoch || s.finalizedEpoch == 0
 
 	return justified && finalized
 }
@@ -861,25 +857,25 @@ func (f *ForkChoice) InsertSlashedIndex(ctx context.Context, index types.Validat
 	}
 }
 
-// UpdateJustifiedCheckpoint sets the justified checkpoint to the given one
-func (f *ForkChoice) UpdateJustifiedCheckpoint(jc *forkchoicetypes.Checkpoint) error {
+// UpdateJustifiedCheckpoint sets the justified epoch to the given one
+func (f *ForkChoice) UpdateJustifiedCheckpoint(jc *pbrpc.Checkpoint) error {
 	if jc == nil {
 		return errInvalidNilCheckpoint
 	}
-	f.store.checkpointsLock.Lock()
-	defer f.store.checkpointsLock.Unlock()
-	f.store.justifiedCheckpoint = jc
+	f.store.nodesLock.Lock()
+	defer f.store.nodesLock.Unlock()
+	f.store.justifiedEpoch = jc.Epoch
 	return nil
 }
 
-// UpdateFinalizedCheckpoint sets the finalized checkpoint to the given one
-func (f *ForkChoice) UpdateFinalizedCheckpoint(fc *forkchoicetypes.Checkpoint) error {
+// UpdateFinalizedCheckpoint sets the finalized epoch to the given one
+func (f *ForkChoice) UpdateFinalizedCheckpoint(fc *pbrpc.Checkpoint) error {
 	if fc == nil {
 		return errInvalidNilCheckpoint
 	}
-	f.store.checkpointsLock.Lock()
-	defer f.store.checkpointsLock.Unlock()
-	f.store.finalizedCheckpoint = fc
+	f.store.nodesLock.Lock()
+	defer f.store.nodesLock.Unlock()
+	f.store.finalizedEpoch = fc.Epoch
 	return nil
 }
 
@@ -899,7 +895,7 @@ func (f *ForkChoice) InsertOptimisticChain(ctx context.Context, chain []*forkcho
 		}
 		if err := f.store.insert(ctx,
 			b.Slot(), r, parentRoot, payloadHash,
-			chain[i].JustifiedCheckpoint.Epoch, chain[i].FinalizedCheckpoint.Epoch); err != nil {
+			chain[i].JustifiedEpoch, chain[i].FinalizedEpoch); err != nil {
 			return err
 		}
 	}

beacon-chain/forkchoice/protoarray/store_test.go

@@ -28,13 +28,13 @@ 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.JustifiedCheckpoint().Epoch)
+	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.FinalizedCheckpoint().Epoch)
+	require.Equal(t, j, f.FinalizedEpoch())
 }
 
 func TestForkChoice_HasNode(t *testing.T) {
@@ -51,9 +51,8 @@ func TestForkChoice_HasNode(t *testing.T) {
 
 func TestStore_Head_UnknownJustifiedRoot(t *testing.T) {
 	s := &Store{nodesIndices: make(map[[32]byte]uint64)}
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: [32]byte{'a'}}
 
-	_, err := s.head(context.Background())
+	_, err := s.head(context.Background(), [32]byte{})
 	assert.ErrorContains(t, errUnknownJustifiedRoot.Error(), err)
 }
 
@@ -62,9 +61,8 @@ func TestStore_Head_UnknownJustifiedIndex(t *testing.T) {
 	indices := make(map[[32]byte]uint64)
 	indices[r] = 1
 	s := &Store{nodesIndices: indices}
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: r}
 
-	_, err := s.head(context.Background())
+	_, err := s.head(context.Background(), r)
 	assert.ErrorContains(t, errInvalidJustifiedIndex.Error(), err)
 }
 
@@ -75,9 +73,7 @@ func TestStore_Head_Itself(t *testing.T) {
 	// Since the justified node does not have a best descendant so the best node
 	// is itself.
 	s := &Store{nodesIndices: indices, nodes: []*Node{{root: r, parent: NonExistentNode, bestDescendant: NonExistentNode}}, canonicalNodes: make(map[[32]byte]bool)}
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: r}
-	s.finalizedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: r}
-	h, err := s.head(context.Background())
+	h, err := s.head(context.Background(), r)
 	require.NoError(t, err)
 	assert.Equal(t, r, h)
 }
@@ -90,9 +86,7 @@ func TestStore_Head_BestDescendant(t *testing.T) {
 	// Since the justified node's best descendant is at index 1, and its root is `best`,
 	// the head should be `best`.
 	s := &Store{nodesIndices: indices, nodes: []*Node{{root: r, bestDescendant: 1, parent: NonExistentNode}, {root: best, parent: 0}}, canonicalNodes: make(map[[32]byte]bool)}
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: r}
-	s.finalizedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: r}
-	h, err := s.head(context.Background())
+	h, err := s.head(context.Background(), r)
 	require.NoError(t, err)
 	assert.Equal(t, best, h)
 }
@@ -105,9 +99,7 @@ func TestStore_Head_ContextCancelled(t *testing.T) {
 
 	s := &Store{nodesIndices: indices, nodes: []*Node{{root: r, parent: NonExistentNode, bestDescendant: 1}, {root: best, parent: 0}}, canonicalNodes: make(map[[32]byte]bool)}
 	cancel()
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: r}
-	s.finalizedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: r}
-	_, err := s.head(ctx)
+	_, err := s.head(ctx, r)
 	require.ErrorContains(t, "context canceled", err)
 }
 
@@ -131,8 +123,6 @@ func TestStore_Insert_KnownParent(t *testing.T) {
 	p := [32]byte{'B'}
 	s.nodesIndices[p] = 0
 	payloadHash := [32]byte{'c'}
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{}
-	s.finalizedCheckpoint = &forkchoicetypes.Checkpoint{}
 	require.NoError(t, s.insert(context.Background(), 100, [32]byte{'A'}, p, payloadHash, 1, 1))
 	assert.Equal(t, 2, len(s.nodes), "Did not insert block")
 	assert.Equal(t, 2, len(s.nodesIndices), "Did not insert block")
@@ -160,8 +150,6 @@ func TestStore_ApplyScoreChanges_UpdateWeightsPositiveDelta(t *testing.T) {
 
 	// Each node gets one unique vote. The weight should look like 103 <- 102 <- 101 because
 	// they get propagated back.
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{}
-	s.finalizedCheckpoint = &forkchoicetypes.Checkpoint{}
 	require.NoError(t, s.applyWeightChanges(context.Background(), []uint64{}, []int{1, 1, 1}))
 	assert.Equal(t, uint64(103), s.nodes[0].weight)
 	assert.Equal(t, uint64(102), s.nodes[1].weight)
@@ -177,8 +165,6 @@ func TestStore_ApplyScoreChanges_UpdateWeightsNegativeDelta(t *testing.T) {
 
 	// Each node gets one unique vote which contributes to negative delta.
 	// The weight should look like 97 <- 98 <- 99 because they get propagated back.
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{}
-	s.finalizedCheckpoint = &forkchoicetypes.Checkpoint{}
 	require.NoError(t, s.applyWeightChanges(context.Background(), []uint64{}, []int{-1, -1, -1}))
 	assert.Equal(t, uint64(97), s.nodes[0].weight)
 	assert.Equal(t, uint64(98), s.nodes[1].weight)
@@ -193,8 +179,6 @@ func TestStore_ApplyScoreChanges_UpdateWeightsMixedDelta(t *testing.T) {
 		{parent: 1, root: [32]byte{'A'}, weight: 100}}}
 
 	// Each node gets one mixed vote. The weight should look like 100 <- 200 <- 250.
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{}
-	s.finalizedCheckpoint = &forkchoicetypes.Checkpoint{}
 	require.NoError(t, s.applyWeightChanges(context.Background(), []uint64{}, []int{-100, -50, 150}))
 	assert.Equal(t, uint64(100), s.nodes[0].weight)
 	assert.Equal(t, uint64(200), s.nodes[1].weight)
@@ -203,9 +187,7 @@ func TestStore_ApplyScoreChanges_UpdateWeightsMixedDelta(t *testing.T) {
 
 func TestStore_UpdateBestChildAndDescendant_RemoveChild(t *testing.T) {
 	// Make parent's best child equal's to input child index and child is not viable.
-	jc := &forkchoicetypes.Checkpoint{Epoch: 1}
-	fc := &forkchoicetypes.Checkpoint{Epoch: 1}
-	s := &Store{nodes: []*Node{{bestChild: 1}, {}}, justifiedCheckpoint: jc, finalizedCheckpoint: fc}
+	s := &Store{nodes: []*Node{{bestChild: 1}, {}}, justifiedEpoch: 1, finalizedEpoch: 1}
 	require.NoError(t, s.updateBestChildAndDescendant(0, 1))
 
 	// Verify parent's best child and best descendant are `none`.
@@ -216,8 +198,6 @@ func TestStore_UpdateBestChildAndDescendant_RemoveChild(t *testing.T) {
 func TestStore_UpdateBestChildAndDescendant_UpdateDescendant(t *testing.T) {
 	// Make parent's best child equal to child index and child is viable.
 	s := &Store{nodes: []*Node{{bestChild: 1}, {bestDescendant: NonExistentNode}}}
-	s.justifiedCheckpoint = &forkchoicetypes.Checkpoint{}
-	s.finalizedCheckpoint = &forkchoicetypes.Checkpoint{}
 	require.NoError(t, s.updateBestChildAndDescendant(0, 1))
 
 	// Verify parent's best child is the same and best descendant is not set to child index.
@@ -228,11 +208,9 @@ func TestStore_UpdateBestChildAndDescendant_UpdateDescendant(t *testing.T) {
 func TestStore_UpdateBestChildAndDescendant_ChangeChildByViability(t *testing.T) {
 	// Make parent's best child not equal to child index, child leads to viable index and
 	// parent's best child doesn't lead to viable index.
-	jc := &forkchoicetypes.Checkpoint{Epoch: 1}
-	fc := &forkchoicetypes.Checkpoint{Epoch: 1}
 	s := &Store{
-		justifiedCheckpoint: jc,
-		finalizedCheckpoint: fc,
+		justifiedEpoch: 1,
+		finalizedEpoch: 1,
 		nodes: []*Node{{bestChild: 1, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode},
 			{bestDescendant: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1}}}
@@ -246,11 +224,9 @@ func TestStore_UpdateBestChildAndDescendant_ChangeChildByViability(t *testing.T)
 func TestStore_UpdateBestChildAndDescendant_ChangeChildByWeight(t *testing.T) {
 	// Make parent's best child not equal to child index, child leads to viable index and
 	// parents best child leads to viable index but child has more weight than parent's best child.
-	jc := &forkchoicetypes.Checkpoint{Epoch: 1}
-	fc := &forkchoicetypes.Checkpoint{Epoch: 1}
 	s := &Store{
-		justifiedCheckpoint: jc,
-		finalizedCheckpoint: fc,
+		justifiedEpoch: 1,
+		finalizedEpoch: 1,
 		nodes: []*Node{{bestChild: 1, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1, weight: 1}}}
@@ -263,11 +239,9 @@ func TestStore_UpdateBestChildAndDescendant_ChangeChildByWeight(t *testing.T) {
 
 func TestStore_UpdateBestChildAndDescendant_ChangeChildAtLeaf(t *testing.T) {
 	// Make parent's best child to none and input child leads to viable index.
-	jc := &forkchoicetypes.Checkpoint{Epoch: 1}
-	fc := &forkchoicetypes.Checkpoint{Epoch: 1}
 	s := &Store{
-		justifiedCheckpoint: jc,
-		finalizedCheckpoint: fc,
+		justifiedEpoch: 1,
+		finalizedEpoch: 1,
 		nodes: []*Node{{bestChild: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1}}}
@@ -281,11 +255,9 @@ func TestStore_UpdateBestChildAndDescendant_ChangeChildAtLeaf(t *testing.T) {
 func TestStore_UpdateBestChildAndDescendant_NoChangeByViability(t *testing.T) {
 	// Make parent's best child not equal to child index, child leads to not viable index and
 	// parents best child leads to viable index.
-	jc := &forkchoicetypes.Checkpoint{Epoch: 1}
-	fc := &forkchoicetypes.Checkpoint{Epoch: 1}
 	s := &Store{
-		justifiedCheckpoint: jc,
-		finalizedCheckpoint: fc,
+		justifiedEpoch: 1,
+		finalizedEpoch: 1,
 		nodes: []*Node{{bestChild: 1, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode}}}
@@ -299,11 +271,9 @@ func TestStore_UpdateBestChildAndDescendant_NoChangeByViability(t *testing.T) {
 func TestStore_UpdateBestChildAndDescendant_NoChangeByWeight(t *testing.T) {
 	// Make parent's best child not equal to child index, child leads to viable index and
 	// parents best child leads to viable index but parent's best child has more weight.
-	jc := &forkchoicetypes.Checkpoint{Epoch: 1}
-	fc := &forkchoicetypes.Checkpoint{Epoch: 1}
 	s := &Store{
-		justifiedCheckpoint: jc,
-		finalizedCheckpoint: fc,
+		justifiedEpoch: 1,
+		finalizedEpoch: 1,
 		nodes: []*Node{{bestChild: 1, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1, weight: 1},
 			{bestDescendant: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1}}}
@@ -316,11 +286,9 @@ func TestStore_UpdateBestChildAndDescendant_NoChangeByWeight(t *testing.T) {
 
 func TestStore_UpdateBestChildAndDescendant_NoChangeAtLeaf(t *testing.T) {
 	// Make parent's best child to none and input child does not lead to viable index.
-	jc := &forkchoicetypes.Checkpoint{Epoch: 1}
-	fc := &forkchoicetypes.Checkpoint{Epoch: 1}
 	s := &Store{
-		justifiedCheckpoint: jc,
-		finalizedCheckpoint: fc,
+		justifiedEpoch: 1,
+		finalizedEpoch: 1,
 		nodes: []*Node{{bestChild: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode, justifiedEpoch: 1, finalizedEpoch: 1},
 			{bestDescendant: NonExistentNode}}}
@@ -818,12 +786,10 @@ func TestStore_LeadsToViableHead(t *testing.T) {
 		{&Node{finalizedEpoch: 3, justifiedEpoch: 4}, 4, 3, true},
 	}
 	for _, tc := range tests {
-		jc := &forkchoicetypes.Checkpoint{Epoch: tc.justifiedEpoch}
-		fc := &forkchoicetypes.Checkpoint{Epoch: tc.finalizedEpoch}
 		s := &Store{
-			justifiedCheckpoint: jc,
-			finalizedCheckpoint: fc,
-			nodes:               []*Node{tc.n},
+			justifiedEpoch: tc.justifiedEpoch,
+			finalizedEpoch: tc.finalizedEpoch,
+			nodes:          []*Node{tc.n},
 		}
 		got, err := s.leadsToViableHead(tc.n)
 		require.NoError(t, err)
@@ -846,11 +812,9 @@ func TestStore_ViableForHead(t *testing.T) {
 		{&Node{finalizedEpoch: 3, justifiedEpoch: 4}, 4, 3, true},
 	}
 	for _, tc := range tests {
-		jc := &forkchoicetypes.Checkpoint{Epoch: tc.justifiedEpoch}
-		fc := &forkchoicetypes.Checkpoint{Epoch: tc.finalizedEpoch}
 		s := &Store{
-			justifiedCheckpoint: jc,
-			finalizedCheckpoint: fc,
+			justifiedEpoch: tc.justifiedEpoch,
+			finalizedEpoch: tc.finalizedEpoch,
 		}
 		assert.Equal(t, tc.want, s.viableForHead(tc.n))
 	}
@@ -1020,7 +984,7 @@ func TestStore_RemoveEquivocating(t *testing.T) {
 	state, blkRoot, err := prepareForkchoiceState(ctx, 1, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	head, err := f.Head(ctx, []uint64{})
+	head, err := f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'a'}, head)
 
@@ -1031,20 +995,20 @@ func TestStore_RemoveEquivocating(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	head, err = f.Head(ctx, []uint64{})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
 	// Insert two attestations for block b, it becomes head
 	f.ProcessAttestation(ctx, []uint64{1, 2}, [32]byte{'b'}, 1)
 	f.ProcessAttestation(ctx, []uint64{3}, [32]byte{'c'}, 1)
-	head, err = f.Head(ctx, []uint64{100, 200, 200, 300})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{100, 200, 200, 300})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'b'}, head)
 
 	// Process b's slashing, c is now head
 	f.InsertSlashedIndex(ctx, 1)
-	head, err = f.Head(ctx, []uint64{100, 200, 200, 300})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{100, 200, 200, 300})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 	require.Equal(t, uint64(200), f.store.nodes[2].weight)
@@ -1052,7 +1016,7 @@ func TestStore_RemoveEquivocating(t *testing.T) {
 
 	// Process the same slashing again, should be a noop
 	f.InsertSlashedIndex(ctx, 1)
-	head, err = f.Head(ctx, []uint64{100, 200, 200, 300})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{100, 200, 200, 300})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 	require.Equal(t, uint64(200), f.store.nodes[2].weight)
@@ -1068,12 +1032,12 @@ func TestStore_UpdateCheckpoints(t *testing.T) {
 	f := setup(1, 1)
 	jr := [32]byte{'j'}
 	fr := [32]byte{'f'}
-	jc := &forkchoicetypes.Checkpoint{Root: jr, Epoch: 3}
-	fc := &forkchoicetypes.Checkpoint{Root: fr, Epoch: 2}
+	jc := &ethpb.Checkpoint{Root: jr[:], Epoch: 3}
+	fc := &ethpb.Checkpoint{Root: fr[:], Epoch: 2}
 	require.NoError(t, f.UpdateJustifiedCheckpoint(jc))
 	require.NoError(t, f.UpdateFinalizedCheckpoint(fc))
-	require.Equal(t, f.store.justifiedCheckpoint, jc)
-	require.Equal(t, f.store.finalizedCheckpoint, fc)
+	require.Equal(t, f.store.justifiedEpoch, jc.Epoch)
+	require.Equal(t, f.store.finalizedEpoch, fc.Epoch)
 }
 
 func TestStore_InsertOptimisticChain(t *testing.T) {
@@ -1087,10 +1051,8 @@ func TestStore_InsertOptimisticChain(t *testing.T) {
 	require.NoError(t, err)
 	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
-	blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(),
-		JustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-	})
+	blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(), JustifiedEpoch: 1,
+		FinalizedEpoch: 1})
 	for i := uint64(2); i < 11; i++ {
 		blk := util.NewBeaconBlock()
 		blk.Block.Slot = types.Slot(i)
@@ -1098,10 +1060,8 @@ func TestStore_InsertOptimisticChain(t *testing.T) {
 		blk.Block.ParentRoot = copiedRoot[:]
 		wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
 		require.NoError(t, err)
-		blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(),
-			JustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-			FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-		})
+		blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(), JustifiedEpoch: 1,
+			FinalizedEpoch: 1})
 		root, err = blk.Block.HashTreeRoot()
 		require.NoError(t, err)
 	}

beacon-chain/forkchoice/protoarray/types.go

@@ -3,7 +3,6 @@ package protoarray
 import (
 	"sync"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 )
@@ -19,8 +18,8 @@ type ForkChoice struct {
 // Store defines the fork choice store which includes block nodes and the last view of checkpoint information.
 type Store struct {
 	pruneThreshold             uint64                                  // do not prune tree unless threshold is reached.
-	justifiedCheckpoint        *forkchoicetypes.Checkpoint             // latest justified checkpoint in store.
-	finalizedCheckpoint        *forkchoicetypes.Checkpoint             // latest finalized checkpoint in store.
+	justifiedEpoch             types.Epoch                             // latest justified epoch in store.
+	finalizedEpoch             types.Epoch                             // latest finalized epoch in store.
 	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.
@@ -31,7 +30,6 @@ type Store struct {
 	slashedIndices             map[types.ValidatorIndex]bool           // The list of equivocating validators
 	nodesLock                  sync.RWMutex
 	proposerBoostLock          sync.RWMutex
-	checkpointsLock            sync.RWMutex
 }
 
 // Node defines the individual block which includes its block parent, ancestor and how much weight accounted for it.

beacon-chain/forkchoice/protoarray/unrealized_justification.go

@@ -55,11 +55,11 @@ func (f *ForkChoice) UpdateUnrealizedCheckpoints() {
 	for _, node := range f.store.nodes {
 		node.justifiedEpoch = node.unrealizedJustifiedEpoch
 		node.finalizedEpoch = node.unrealizedFinalizedEpoch
-		if node.justifiedEpoch > f.store.justifiedCheckpoint.Epoch {
-			f.store.justifiedCheckpoint.Epoch = node.justifiedEpoch
+		if node.justifiedEpoch > f.store.justifiedEpoch {
+			f.store.justifiedEpoch = node.justifiedEpoch
 		}
-		if node.finalizedEpoch > f.store.finalizedCheckpoint.Epoch {
-			f.store.finalizedCheckpoint.Epoch = node.finalizedEpoch
+		if node.finalizedEpoch > f.store.finalizedEpoch {
+			f.store.finalizedEpoch = node.finalizedEpoch
 		}
 	}
 }

beacon-chain/forkchoice/protoarray/unrealized_justification_test.go

@@ -5,9 +5,9 @@ import (
 
 	"context"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
@@ -81,25 +81,25 @@ func TestStore_LongFork(t *testing.T) {
 
 	// Add an attestation to c, it is head
 	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'c'}, 1)
-	headRoot, err := f.Head(ctx, []uint64{100})
+	headRoot, err := f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, headRoot)
 
 	// D is head even though its weight is lower.
-	ha := [32]byte{'a'}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'b'}, [32]byte{'D'}, 2, 1)
+	hr := [32]byte{'d'}
+	state, blkRoot, err = prepareForkchoiceState(ctx, 103, hr, [32]byte{'b'}, [32]byte{'D'}, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	require.NoError(t, f.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 2, Root: ha}))
-	headRoot, err = f.Head(ctx, []uint64{100})
+	require.NoError(t, f.UpdateJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 2, Root: hr[:]}))
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
-	require.Equal(t, [32]byte{'d'}, headRoot)
+	require.Equal(t, hr, headRoot)
 	require.Equal(t, uint64(0), f.store.nodes[4].weight)
 	require.Equal(t, uint64(100), f.store.nodes[3].weight)
 
 	// Update unrealized justification, c becomes head
 	f.UpdateUnrealizedCheckpoints()
-	headRoot, err = f.Head(ctx, []uint64{100})
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, headRoot)
 }
@@ -158,31 +158,30 @@ func TestStore_NoDeadLock(t *testing.T) {
 
 	// Epoch 3
 	// Current Head is H
-	headRoot, err := f.Head(ctx, []uint64{100})
+	headRoot, err := f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'h'}, headRoot)
-	require.Equal(t, types.Epoch(0), f.JustifiedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(0), f.JustifiedEpoch())
 
 	// Insert Block I, it becomes Head
 	hr := [32]byte{'i'}
 	state, blkRoot, err = prepareForkchoiceState(ctx, 108, hr, [32]byte{'f'}, [32]byte{'I'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	ha := [32]byte{'a'}
-	require.NoError(t, f.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: 1, Root: ha}))
-	headRoot, err = f.Head(ctx, []uint64{100})
+	require.NoError(t, f.UpdateJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 1, Root: hr[:]}))
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, hr, headRoot)
-	require.Equal(t, types.Epoch(1), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, types.Epoch(0), f.FinalizedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(1), f.JustifiedEpoch())
+	require.Equal(t, types.Epoch(0), f.FinalizedEpoch())
 
 	// Realized Justified checkpoints, H becomes head
 	f.UpdateUnrealizedCheckpoints()
-	headRoot, err = f.Head(ctx, []uint64{100})
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'h'}, headRoot)
-	require.Equal(t, types.Epoch(2), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, types.Epoch(1), f.FinalizedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(2), f.JustifiedEpoch())
+	require.Equal(t, types.Epoch(1), f.FinalizedEpoch())
 }
 
 //    Epoch  1       |         Epoch 2
@@ -227,10 +226,10 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 
 	// Insert an attestation to H, H is head
 	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'h'}, 1)
-	headRoot, err := f.Head(ctx, []uint64{100})
+	headRoot, err := f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'h'}, headRoot)
-	require.Equal(t, types.Epoch(0), f.JustifiedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(0), f.JustifiedEpoch())
 
 	// D arrives late, D is head
 	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 0, 0)
@@ -238,10 +237,10 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'d'}, 1))
 	f.UpdateUnrealizedCheckpoints()
-	headRoot, err = f.Head(ctx, []uint64{100})
+	headRoot, err = f.Head(ctx, [32]byte{}, []uint64{100})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'d'}, headRoot)
-	require.Equal(t, types.Epoch(1), f.JustifiedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(1), f.JustifiedEpoch())
 	// nodes[8] = D since it's late!
 	require.Equal(t, uint64(0), f.store.nodes[8].weight)
 	require.Equal(t, uint64(100), f.store.nodes[7].weight)

beacon-chain/forkchoice/protoarray/vote_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -16,7 +15,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	ctx := context.Background()
 
 	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), balances)
+	r, err := f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
 
@@ -28,7 +27,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -40,7 +39,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -49,7 +48,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//           / \
 	//          2  1 <- +vote, new head
 	f.ProcessAttestation(context.Background(), []uint64{0}, indexToHash(1), 2)
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(1), r, "Incorrect head for with justified epoch at 1")
 
@@ -58,7 +57,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//                    / \
 	// vote, new head -> 2  1
 	f.ProcessAttestation(context.Background(), []uint64{1}, indexToHash(2), 2)
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -72,7 +71,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -83,7 +82,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//             |
 	//             3 <- new vote
 	f.ProcessAttestation(context.Background(), []uint64{0}, indexToHash(3), 3)
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -94,7 +93,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//                |
 	//                3 <- head
 	f.ProcessAttestation(context.Background(), []uint64{1}, indexToHash(1), 3)
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(3), r, "Incorrect head for with justified epoch at 1")
 
@@ -110,7 +109,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
 
@@ -128,7 +127,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
 
@@ -189,7 +188,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 1")
 
@@ -210,11 +209,9 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//           8
 	//           |
 	//           9 <- head
-	jc := &forkchoicetypes.Checkpoint{Epoch: 2, Root: indexToHash(5)}
-	fc := &forkchoicetypes.Checkpoint{Epoch: 2, Root: indexToHash(5)}
-	f.store.justifiedCheckpoint = jc
-	f.store.finalizedCheckpoint = fc
-	r, err = f.Head(context.Background(), balances)
+	f.store.justifiedEpoch = 2
+	f.store.finalizedEpoch = 2
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
 
@@ -240,7 +237,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
 
@@ -249,28 +246,28 @@ func TestVotes_CanFindHead(t *testing.T) {
 	// 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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	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(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 1")
 
@@ -279,7 +276,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, f.store.prune(context.Background(), indexToHash(5)))
 	assert.Equal(t, 11, len(f.store.nodes), "Incorrect nodes length after prune")
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
 
@@ -303,7 +300,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, f.store.prune(context.Background(), indexToHash(5)))
 	assert.Equal(t, 5, len(f.store.nodes), "Incorrect nodes length after prune")
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(9), r, "Incorrect head for with justified epoch at 2")
 
@@ -321,7 +318,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(11), r, "Incorrect head for with justified epoch at 2")
 }

beacon-chain/forkchoice/types/BUILD.bazel

@@ -6,9 +6,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types",
     visibility = ["//visibility:public"],
     deps = [
-        "//config/fieldparams:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
     ],
 )

beacon-chain/forkchoice/types/types.go

@@ -1,10 +1,8 @@
 package types
 
 import (
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
 
 // ProposerBoostRootArgs to call the BoostProposerRoot function.
@@ -15,17 +13,9 @@ type ProposerBoostRootArgs struct {
 	SecondsIntoSlot uint64
 }
 
-// Checkpoint is an array version of ethpb.Checkpoint. It is used internally in
-// forkchoice, while the slice version is used in the interface to legagy code
-// in other packages
-type Checkpoint struct {
-	Epoch types.Epoch
-	Root  [fieldparams.RootLength]byte
-}
-
 // BlockAndCheckpoints to call the InsertOptimisticChain function
 type BlockAndCheckpoints struct {
-	Block               interfaces.BeaconBlock
-	JustifiedCheckpoint *ethpb.Checkpoint
-	FinalizedCheckpoint *ethpb.Checkpoint
+	Block          interfaces.BeaconBlock
+	JustifiedEpoch types.Epoch
+	FinalizedEpoch types.Epoch
 }

beacon-chain/node/node.go

@@ -348,9 +348,9 @@ func (b *BeaconNode) Close() {
 
 func (b *BeaconNode) startForkChoice() {
 	if features.Get().EnableForkChoiceDoublyLinkedTree {
-		b.forkChoiceStore = doublylinkedtree.New()
+		b.forkChoiceStore = doublylinkedtree.New(0, 0)
 	} else {
-		b.forkChoiceStore = protoarray.New()
+		b.forkChoiceStore = protoarray.New(0, 0)
 	}
 }
 

beacon-chain/powchain/check_transition_config.go

@@ -142,7 +142,5 @@ func (s *Service) logTtdStatus(ctx context.Context, ttd *uint256.Int) (bool, err
 		"latestDifficulty":   latestTtd.String(),
 		"terminalDifficulty": ttd.ToBig().String(),
 	}).Info("terminal difficulty has not been reached yet")
-
-	totalTerminalDifficulty.Set(float64(latestTtd.Uint64()))
 	return false, nil
 }

beacon-chain/powchain/metrics.go

@@ -6,10 +6,6 @@ import (
 )
 
 var (
-	totalTerminalDifficulty = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "total_terminal_difficulty",
-		Help: "The total terminal difficulty of the execution chain before merge",
-	})
 	newPayloadLatency = promauto.NewHistogram(
 		prometheus.HistogramOpts{
 			Name:    "new_payload_v1_latency_milliseconds",

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

@@ -7,7 +7,6 @@ import (
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/proto/migration"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"go.opencensus.io/trace"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -24,7 +23,7 @@ func (ds *Server) GetBeaconState(ctx context.Context, req *ethpbv1.StateRequest)
 		return nil, helpers.PrepareStateFetchGRPCError(err)
 	}
 
-	if beaconSt.Version() != version.Phase0 {
+	if beaconSt.Version().IsHigherOrEqualToAltair() {
 		return nil, status.Error(codes.Internal, "State has incorrect type")
 	}
 	protoSt, err := migration.BeaconStateToProto(beaconSt)
@@ -69,8 +68,8 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
 	}
 
-	switch beaconSt.Version() {
-	case version.Phase0:
+	switch {
+	case beaconSt.Version().IsAltairCompatible():
 		protoSt, err := migration.BeaconStateToProto(beaconSt)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not convert state to proto: %v", err)
@@ -82,7 +81,7 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 			},
 			ExecutionOptimistic: isOptimistic,
 		}, nil
-	case version.Altair:
+	case beaconSt.Version().IsAltairCompatible():
 		protoState, err := migration.BeaconStateAltairToProto(beaconSt)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not convert state to proto: %v", err)
@@ -94,7 +93,7 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 			},
 			ExecutionOptimistic: isOptimistic,
 		}, nil
-	case version.Bellatrix:
+	case beaconSt.Version().IsBellatrixCompatible():
 		protoState, err := migration.BeaconStateBellatrixToProto(beaconSt)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not convert state to proto: %v", err)
@@ -126,12 +125,12 @@ func (ds *Server) GetBeaconStateSSZV2(ctx context.Context, req *ethpbv2.StateReq
 		return nil, status.Errorf(codes.Internal, "Could not marshal state into SSZ: %v", err)
 	}
 	var ver ethpbv2.Version
-	switch st.Version() {
-	case version.Phase0:
+	switch {
+	case st.Version().IsPhase0Compatible():
 		ver = ethpbv2.Version_PHASE0
-	case version.Altair:
+	case st.Version().IsAltairCompatible():
 		ver = ethpbv2.Version_ALTAIR
-	case version.Bellatrix:
+	case st.Version().IsBellatrixCompatible():
 		ver = ethpbv2.Version_BELLATRIX
 	default:
 		return nil, status.Error(codes.Internal, "Unsupported state version")

beacon-chain/rpc/eth/helpers/sync.go

@@ -1,7 +1,6 @@
 package helpers
 
 import (
-	"bytes"
 	"context"
 	"strconv"
 
@@ -10,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/sync"
-	"github.com/prysmaticlabs/prysm/config/params"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
@@ -42,15 +40,12 @@ func ValidateSync(ctx context.Context, syncChecker sync.Checker, headFetcher blo
 
 // IsOptimistic checks whether the latest block header of the passed in beacon state is the header of an optimistic block.
 func IsOptimistic(ctx context.Context, st state.BeaconState, optimisticSyncFetcher blockchain.OptimisticModeFetcher) (bool, error) {
-	header := st.LatestBlockHeader()
-	// This happens when the block at the state's slot is not missing.
-	if bytes.Equal(header.StateRoot, params.BeaconConfig().ZeroHash[:]) {
-		root, err := st.HashTreeRoot(ctx)
-		if err != nil {
-			return false, errors.Wrap(err, "could not get state root")
-		}
-		header.StateRoot = root[:]
+	root, err := st.HashTreeRoot(ctx)
+	if err != nil {
+		return false, errors.Wrap(err, "could not get state root")
 	}
+	header := st.LatestBlockHeader()
+	header.StateRoot = root[:]
 	headRoot, err := header.HashTreeRoot()
 	if err != nil {
 		return false, errors.Wrap(err, "could not get header root")

beacon-chain/rpc/eth/helpers/sync_test.go

@@ -69,29 +69,4 @@ func TestIsOptimistic(t *testing.T) {
 		require.NoError(t, err)
 		assert.Equal(t, false, o)
 	})
-	t.Run("zero state root", func(t *testing.T) {
-		zeroRootSt, err := util.NewBeaconState()
-		require.NoError(t, err)
-		h := zeroRootSt.LatestBlockHeader()
-		h.StateRoot = make([]byte, 32)
-		require.NoError(t, zeroRootSt.SetLatestBlockHeader(h))
-		mockOptSyncFetcher := &chainmock.ChainService{}
-		_, err = IsOptimistic(ctx, st, mockOptSyncFetcher)
-		require.NoError(t, err)
-		assert.DeepEqual(
-			t,
-			[32]byte{0xfc, 0x0, 0xe9, 0x6d, 0xb, 0x8b, 0x2, 0x2f, 0x61, 0xeb, 0x92, 0x10, 0xfd, 0x80, 0x84, 0x2b, 0x26, 0x61, 0xdc, 0x94, 0x5f, 0x7a, 0xf0, 0x0, 0xbc, 0x38, 0x6, 0x38, 0x71, 0x95, 0x43, 0x1},
-			mockOptSyncFetcher.OptimisticCheckRootReceived,
-		)
-	})
-	t.Run("non-zero state root", func(t *testing.T) {
-		mockOptSyncFetcher := &chainmock.ChainService{}
-		_, err = IsOptimistic(ctx, st, mockOptSyncFetcher)
-		require.NoError(t, err)
-		assert.DeepEqual(
-			t,
-			[32]byte{0xfc, 0x0, 0xe9, 0x6d, 0xb, 0x8b, 0x2, 0x2f, 0x61, 0xeb, 0x92, 0x10, 0xfd, 0x80, 0x84, 0x2b, 0x26, 0x61, 0xdc, 0x94, 0x5f, 0x7a, 0xf0, 0x0, 0xbc, 0x38, 0x6, 0x38, 0x71, 0x95, 0x43, 0x1},
-			mockOptSyncFetcher.OptimisticCheckRootReceived,
-		)
-	})
 }

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

@@ -393,10 +393,6 @@ func (bs *Server) chainHeadRetrieval(ctx context.Context) (*ethpb.ChainHead, err
 	if err != nil {
 		return nil, status.Error(codes.Internal, "Could not get head block")
 	}
-	optimisticStatus, err := bs.OptimisticModeFetcher.IsOptimistic(ctx)
-	if err != nil {
-		return nil, status.Error(codes.Internal, "Could not get optimistic status")
-	}
 	if err := wrapper.BeaconBlockIsNil(headBlock); err != nil {
 		return nil, status.Errorf(codes.NotFound, "Head block of chain was nil: %v", err)
 	}
@@ -478,6 +474,5 @@ func (bs *Server) chainHeadRetrieval(ctx context.Context) (*ethpb.ChainHead, err
 		PreviousJustifiedSlot:      pjSlot,
 		PreviousJustifiedEpoch:     prevJustifiedCheckpoint.Epoch,
 		PreviousJustifiedBlockRoot: prevJustifiedCheckpoint.Root,
-		OptimisticStatus:           optimisticStatus,
 	}, nil
 }

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

@@ -426,7 +426,6 @@ func TestServer_GetChainHead_NoGenesis(t *testing.T) {
 				FinalizedCheckPoint:         s.FinalizedCheckpoint(),
 				CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
 				PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint()},
-			OptimisticModeFetcher: &chainMock.ChainService{},
 		}
 		_, err = bs.GetChainHead(context.Background(), nil)
 		require.ErrorContains(t, "Could not get genesis block", err)
@@ -462,7 +461,6 @@ func TestServer_GetChainHead_NoFinalizedBlock(t *testing.T) {
 			FinalizedCheckPoint:         s.FinalizedCheckpoint(),
 			CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
 			PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint()},
-		OptimisticModeFetcher: &chainMock.ChainService{},
 	}
 
 	_, err = bs.GetChainHead(context.Background(), nil)
@@ -471,8 +469,7 @@ func TestServer_GetChainHead_NoFinalizedBlock(t *testing.T) {
 
 func TestServer_GetChainHead_NoHeadBlock(t *testing.T) {
 	bs := &Server{
-		HeadFetcher:           &chainMock.ChainService{Block: nil},
-		OptimisticModeFetcher: &chainMock.ChainService{},
+		HeadFetcher: &chainMock.ChainService{Block: nil},
 	}
 	_, err := bs.GetChainHead(context.Background(), nil)
 	assert.ErrorContains(t, "Head block of chain was nil", err)
@@ -534,9 +531,8 @@ func TestServer_GetChainHead(t *testing.T) {
 	wsb, err = wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	bs := &Server{
-		BeaconDB:              db,
-		HeadFetcher:           &chainMock.ChainService{Block: wsb, State: s},
-		OptimisticModeFetcher: &chainMock.ChainService{},
+		BeaconDB:    db,
+		HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
 		FinalizationFetcher: &chainMock.ChainService{
 			FinalizedCheckPoint:         s.FinalizedCheckpoint(),
 			CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
@@ -554,7 +550,6 @@ func TestServer_GetChainHead(t *testing.T) {
 	assert.DeepEqual(t, pjRoot[:], head.PreviousJustifiedBlockRoot, "Unexpected PreviousJustifiedBlockRoot")
 	assert.DeepEqual(t, jRoot[:], head.JustifiedBlockRoot, "Unexpected JustifiedBlockRoot")
 	assert.DeepEqual(t, fRoot[:], head.FinalizedBlockRoot, "Unexpected FinalizedBlockRoot")
-	assert.Equal(t, false, head.OptimisticStatus)
 }
 
 func TestServer_StreamChainHead_ContextCanceled(t *testing.T) {
@@ -650,7 +645,6 @@ func TestServer_StreamChainHead_OnHeadUpdated(t *testing.T) {
 			FinalizedCheckPoint:         s.FinalizedCheckpoint(),
 			CurrentJustifiedCheckPoint:  s.CurrentJustifiedCheckpoint(),
 			PreviousJustifiedCheckPoint: s.PreviousJustifiedCheckpoint()},
-		OptimisticModeFetcher: &chainMock.ChainService{},
 	}
 	exitRoutine := make(chan bool)
 	ctrl := gomock.NewController(t)

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

@@ -47,5 +47,4 @@ type Server struct {
 	SyncChecker                 sync.Checker
 	ReplayerBuilder             stategen.ReplayerBuilder
 	HeadUpdater                 blockchain.HeadUpdater
-	OptimisticModeFetcher       blockchain.OptimisticModeFetcher
 }

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

@@ -12,8 +12,8 @@ func (ds *Server) GetForkChoice(_ context.Context, _ *empty.Empty) (*pbrpc.ForkC
 	store := ds.ForkFetcher.ForkChoicer()
 
 	return &pbrpc.ForkChoiceResponse{
-		JustifiedEpoch:  store.JustifiedCheckpoint().Epoch,
-		FinalizedEpoch:  store.FinalizedCheckpoint().Epoch,
+		JustifiedEpoch:  store.JustifiedEpoch(),
+		FinalizedEpoch:  store.FinalizedEpoch(),
 		ForkchoiceNodes: store.ForkChoiceNodes(),
 	}, nil
 }

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

@@ -12,10 +12,10 @@ import (
 )
 
 func TestServer_GetForkChoice_ProtoArray(t *testing.T) {
-	store := protoarray.New()
+	store := protoarray.New(0, 0)
 	bs := &Server{ForkFetcher: &mock.ChainService{ForkChoiceStore: store}}
 	res, err := bs.GetForkChoice(context.Background(), &empty.Empty{})
 	require.NoError(t, err)
-	assert.Equal(t, store.JustifiedCheckpoint().Epoch, res.JustifiedEpoch, "Did not get wanted justified epoch")
-	assert.Equal(t, store.FinalizedCheckpoint().Epoch, res.FinalizedEpoch, "Did not get wanted finalized epoch")
+	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/service.go

@@ -268,7 +268,6 @@ func (s *Service) Start() {
 		AttestationsPool:            s.cfg.AttestationsPool,
 		SlashingsPool:               s.cfg.SlashingsPool,
 		HeadUpdater:                 s.cfg.HeadUpdater,
-		OptimisticModeFetcher:       s.cfg.OptimisticModeFetcher,
 		HeadFetcher:                 s.cfg.HeadFetcher,
 		FinalizationFetcher:         s.cfg.FinalizationFetcher,
 		CanonicalFetcher:            s.cfg.CanonicalFetcher,

beacon-chain/state/BUILD.bazel

@@ -13,6 +13,7 @@ go_library(
         "//config/fieldparams:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version: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_go_bitfield//:go_default_library",

beacon-chain/state/interfaces.go

@@ -10,6 +10,7 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // BeaconState has read and write access to beacon state methods.
@@ -26,7 +27,6 @@ type BeaconState interface {
 // SpecParametersProvider provides fork-specific configuration parameters as
 // defined in the consensus specification for the beacon chain.
 type SpecParametersProvider interface {
-	MinSlashingPenaltyQuotient() (uint64, error)
 	InactivityPenaltyQuotient() (uint64, error)
 	ProportionalSlashingMultiplier() (uint64, error)
 }
@@ -60,7 +60,7 @@ type ReadOnlyBeaconState interface {
 	FieldReferencesCount() map[string]uint64
 	MarshalSSZ() ([]byte, error)
 	IsNil() bool
-	Version() int
+	Version() version.ForkVersion
 	LatestExecutionPayloadHeader() (*ethpb.ExecutionPayloadHeader, error)
 }
 

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

@@ -13,12 +13,13 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	eth2types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // BeaconState defines a struct containing utilities for the Ethereum Beacon Chain state, defining
 // getters and setters for its respective values and helpful functions such as HashTreeRoot().
 type BeaconState struct {
-	version                      int
+	version                      version.ForkVersion
 	genesisTime                  uint64                        `ssz-gen:"true"`
 	genesisValidatorsRoot        customtypes.Byte32            `ssz-gen:"true" ssz-size:"32"`
 	slot                         eth2types.Slot                `ssz-gen:"true"`

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

@@ -13,12 +13,13 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	eth2types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // BeaconState defines a struct containing utilities for the Ethereum Beacon Chain state, defining
 // getters and setters for its respective values and helpful functions such as HashTreeRoot().
 type BeaconState struct {
-	version                      int
+	version                      version.ForkVersion
 	genesisTime                  uint64                        `ssz-gen:"true"`
 	genesisValidatorsRoot        customtypes.Byte32            `ssz-gen:"true" ssz-size:"32"`
 	slot                         eth2types.Slot                `ssz-gen:"true"`

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

@@ -2,12 +2,11 @@ package state_native
 
 import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // PreviousEpochAttestations corresponding to blocks on the beacon chain.
 func (b *BeaconState) PreviousEpochAttestations() ([]*ethpb.PendingAttestation, error) {
-	if b.version != version.Phase0 {
+	if !b.version.IsPhase0Compatible() {
 		return nil, errNotSupported("PreviousEpochAttestations", b.version)
 	}
 
@@ -29,7 +28,7 @@ func (b *BeaconState) previousEpochAttestationsVal() []*ethpb.PendingAttestation
 
 // CurrentEpochAttestations corresponding to blocks on the beacon chain.
 func (b *BeaconState) CurrentEpochAttestations() ([]*ethpb.PendingAttestation, error) {
-	if b.version != version.Phase0 {
+	if !b.version.IsPhase0Compatible() {
 		return nil, errNotSupported("CurrentEpochAttestations", b.version)
 	}
 

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

@@ -3,6 +3,7 @@ package state_native
 import (
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // GenesisTime of the beacon state as a uint64.
@@ -24,7 +25,7 @@ func (b *BeaconState) GenesisValidatorsRoot() []byte {
 // Version of the beacon state. This method
 // is strictly meant to be used without a lock
 // internally.
-func (b *BeaconState) Version() int {
+func (b *BeaconState) Version() version.ForkVersion {
 	return b.version
 }
 

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

@@ -3,12 +3,11 @@ package state_native
 import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // CurrentEpochParticipation corresponding to participation bits on the beacon chain.
 func (b *BeaconState) CurrentEpochParticipation() ([]byte, error) {
-	if b.version == version.Phase0 {
+	if !b.version.IsParticipationBitsCompatible() {
 		return nil, errNotSupported("CurrentEpochParticipation", b.version)
 	}
 
@@ -24,7 +23,7 @@ func (b *BeaconState) CurrentEpochParticipation() ([]byte, error) {
 
 // PreviousEpochParticipation corresponding to participation bits on the beacon chain.
 func (b *BeaconState) PreviousEpochParticipation() ([]byte, error) {
-	if b.version == version.Phase0 {
+	if !b.version.IsParticipationBitsCompatible() {
 		return nil, errNotSupported("PreviousEpochParticipation", b.version)
 	}
 
@@ -42,7 +41,7 @@ func (b *BeaconState) PreviousEpochParticipation() ([]byte, error) {
 // current epoch and target attested in previous epoch. This function is used to
 // compute the "unrealized justification" that a synced Beacon Block will have.
 func (b *BeaconState) UnrealizedCheckpointBalances() (uint64, uint64, uint64, error) {
-	if b.version == version.Phase0 {
+	if !b.version.IsParticipationBitsCompatible() {
 		return 0, 0, 0, errNotSupported("UnrealizedCheckpointBalances", b.version)
 	}
 

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

@@ -2,12 +2,11 @@ package state_native
 
 import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // LatestExecutionPayloadHeader of the beacon state.
 func (b *BeaconState) LatestExecutionPayloadHeader() (*ethpb.ExecutionPayloadHeader, error) {
-	if b.version == version.Phase0 || b.version == version.Altair {
+	if !b.version.IsExecutionPayloadCompatible() {
 		return nil, errNotSupported("LatestExecutionPayloadHeader", b.version)
 	}
 

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

@@ -17,8 +17,8 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 
 	gvrCopy := b.genesisValidatorsRoot
 
-	switch b.version {
-	case version.Phase0:
+	switch {
+	case b.version.IsPhase0Compatible():
 		return &ethpb.BeaconState{
 			GenesisTime:                 b.genesisTime,
 			GenesisValidatorsRoot:       gvrCopy[:],
@@ -42,7 +42,7 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 			CurrentJustifiedCheckpoint:  b.currentJustifiedCheckpoint,
 			FinalizedCheckpoint:         b.finalizedCheckpoint,
 		}
-	case version.Altair:
+	case b.version.IsAltairCompatible():
 		return &ethpb.BeaconStateAltair{
 			GenesisTime:                 b.genesisTime,
 			GenesisValidatorsRoot:       gvrCopy[:],
@@ -69,7 +69,7 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 			CurrentSyncCommittee:        b.currentSyncCommittee,
 			NextSyncCommittee:           b.nextSyncCommittee,
 		}
-	case version.Bellatrix:
+	case b.version.IsBellatrixCompatible():
 		return &ethpb.BeaconStateBellatrix{
 			GenesisTime:                  b.genesisTime,
 			GenesisValidatorsRoot:        gvrCopy[:],

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

@@ -28,15 +28,3 @@ func (b *BeaconState) InactivityPenaltyQuotient() (uint64, error) {
 	}
 	return 0, errNotSupported("InactivityPenaltyQuotient()", b.version)
 }
-
-func (b *BeaconState) MinSlashingPenaltyQuotient() (uint64, error) {
-	switch b.version {
-	case version.Bellatrix:
-		return params.BeaconConfig().MinSlashingPenaltyQuotientBellatrix, nil
-	case version.Altair:
-		return params.BeaconConfig().MinSlashingPenaltyQuotientAltair, nil
-	case version.Phase0:
-		return params.BeaconConfig().MinSlashingPenaltyQuotient, nil
-	}
-	return 0, errNotSupported("MinSlashingPenaltyQuotient()", b.version)
-}

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

@@ -31,6 +31,6 @@ func init() {
 // to its corresponding data type.
 var fieldMap map[nativetypes.FieldIndex]types.DataType
 
-func errNotSupported(funcName string, ver int) error {
-	return fmt.Errorf("%s is not supported for %s", funcName, version.String(ver))
+func errNotSupported(funcName string, ver version.ForkVersion) error {
+	return fmt.Errorf("%s is not supported for %s", funcName, ver.String())
 }

beacon-chain/state/state-native/types/BUILD.bazel

@@ -5,5 +5,8 @@ go_library(
     srcs = ["types.go"],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/state/state-native/types",
     visibility = ["//visibility:public"],
-    deps = ["@com_github_pkg_errors//:go_default_library"],
+    deps = [
+        "//runtime/version:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
 )

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

@@ -2,6 +2,7 @@ package types
 
 import (
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // FieldIndex represents the relevant field position in the
@@ -9,7 +10,7 @@ import (
 type FieldIndex int
 
 // String returns the name of the field index.
-func (f FieldIndex) String(_ int) string {
+func (f FieldIndex) String(_ version.ForkVersion) string {
 	switch f {
 	case GenesisTime:
 		return "genesisTime"

beacon-chain/state/stategen/replay.go

@@ -211,7 +211,7 @@ func ReplayProcessSlots(ctx context.Context, state state.BeaconState, slot types
 					return nil, errors.Wrap(err, "could not process epoch")
 				}
 			default:
-				return nil, fmt.Errorf("unsupported beacon state version: %s", version.String(state.Version()))
+				return nil, fmt.Errorf("unsupported beacon state version: %s", state.Version().String())
 			}
 		}
 		if err := state.SetSlot(state.Slot() + 1); err != nil {

beacon-chain/state/types/types.go

@@ -27,14 +27,14 @@ const (
 
 // BeaconStateField represents a field of the beacon state.
 type BeaconStateField interface {
-	String(stateVersion int) string
+	String(stateVersion version.ForkVersion) string
 	RealPosition() int
 	ElemsInChunk() (uint64, error)
 	Native() bool
 }
 
 // String returns the name of the field index.
-func (f FieldIndex) String(stateVersion int) string {
+func (f FieldIndex) String(stateVersion version.ForkVersion) string {
 	switch f {
 	case GenesisTime:
 		return "genesisTime"
@@ -67,12 +67,12 @@ func (f FieldIndex) String(stateVersion int) string {
 	case Slashings:
 		return "slashings"
 	case PreviousEpochAttestations:
-		if version.Altair == stateVersion || version.Bellatrix == stateVersion {
+		if stateVersion.IsParticipationBitsCompatible() {
 			return "previousEpochParticipationBits"
 		}
 		return "previousEpochAttestations"
 	case CurrentEpochAttestations:
-		if version.Altair == stateVersion || version.Bellatrix == stateVersion {
+		if stateVersion.IsParticipationBitsCompatible() {
 			return "currentEpochParticipationBits"
 		}
 		return "currentEpochAttestations"

beacon-chain/state/v1/getters_misc.go

@@ -63,7 +63,7 @@ func (b *BeaconState) genesisValidatorsRoot() []byte {
 // Version of the beacon state. This method
 // is strictly meant to be used without a lock
 // internally.
-func (_ *BeaconState) Version() int {
+func (_ *BeaconState) Version() version.ForkVersion {
 	return version.Phase0
 }
 

beacon-chain/state/v1/spec_parameters.go

@@ -9,7 +9,3 @@ func (b *BeaconState) ProportionalSlashingMultiplier() (uint64, error) {
 func (b *BeaconState) InactivityPenaltyQuotient() (uint64, error) {
 	return params.BeaconConfig().InactivityPenaltyQuotient, nil
 }
-
-func (b *BeaconState) MinSlashingPenaltyQuotient() (uint64, error) {
-	return params.BeaconConfig().MinSlashingPenaltyQuotient, nil
-}

beacon-chain/state/v2/getters_misc.go

@@ -64,7 +64,7 @@ func (b *BeaconState) genesisValidatorsRoot() []byte {
 // Version of the beacon state. This method
 // is strictly meant to be used without a lock
 // internally.
-func (_ *BeaconState) Version() int {
+func (_ *BeaconState) Version() version.ForkVersion {
 	return version.Altair
 }
 

beacon-chain/state/v2/spec_parameters.go

@@ -9,7 +9,3 @@ func (b *BeaconState) ProportionalSlashingMultiplier() (uint64, error) {
 func (b *BeaconState) InactivityPenaltyQuotient() (uint64, error) {
 	return params.BeaconConfig().InactivityPenaltyQuotientAltair, nil
 }
-
-func (b *BeaconState) MinSlashingPenaltyQuotient() (uint64, error) {
-	return params.BeaconConfig().MinSlashingPenaltyQuotientAltair, nil
-}

beacon-chain/state/v3/getters_misc.go

@@ -63,7 +63,7 @@ func (b *BeaconState) genesisValidatorsRoot() []byte {
 // Version of the beacon state. This method
 // is strictly meant to be used without a lock
 // internally.
-func (_ *BeaconState) Version() int {
+func (_ *BeaconState) Version() version.ForkVersion {
 	return version.Bellatrix
 }
 

beacon-chain/state/v3/spec_parameters.go

@@ -9,7 +9,3 @@ func (b *BeaconState) ProportionalSlashingMultiplier() (uint64, error) {
 func (b *BeaconState) InactivityPenaltyQuotient() (uint64, error) {
 	return params.BeaconConfig().InactivityPenaltyQuotientBellatrix, nil
 }
-
-func (b *BeaconState) MinSlashingPenaltyQuotient() (uint64, error) {
-	return params.BeaconConfig().MinSlashingPenaltyQuotientBellatrix, nil
-}

config/features/BUILD.bazel

@@ -11,7 +11,6 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/config/features",
     visibility = ["//visibility:public"],
     deps = [
-        "//cmd:go_default_library",
         "//config/params:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",

config/features/config.go

@@ -23,7 +23,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/cmd"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
@@ -131,11 +130,7 @@ func configureTestnet(ctx *cli.Context) error {
 		}
 		params.UseRopstenNetworkConfig()
 	} else {
-		if ctx.IsSet(cmd.ChainConfigFileFlag.Name) {
-			log.Warn("Running on custom Ethereum network specified in a chain configuration yaml file")
-		} else {
-			log.Warn("Running on Ethereum Mainnet")
-		}
+		log.Warn("Running on Ethereum Consensus Mainnet")
 		if err := params.SetActive(params.MainnetConfig().Copy()); err != nil {
 			return err
 		}

consensus-types/blocks/BUILD.bazel

@@ -1,46 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "factory.go",
-        "getters.go",
-        "proto.go",
-        "types.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/consensus-types/blocks",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/validator-client:go_default_library",
-        "//runtime/version:go_default_library",
-        "@com_github_ferranbt_fastssz//:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "factory_test.go",
-        "getters_test.go",
-        "proto_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/validator-client:go_default_library",
-        "//runtime/version:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_ferranbt_fastssz//:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-    ],
-)

consensus-types/blocks/factory.go

@@ -1,130 +0,0 @@
-package blocks
-
-import (
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-)
-
-var (
-	// ErrUnsupportedSignedBeaconBlock is returned when the struct type is not a supported signed
-	// beacon block type.
-	ErrUnsupportedSignedBeaconBlock = errors.New("unsupported signed beacon block")
-	// errUnsupportedBeaconBlock is returned when the struct type is not a supported beacon block
-	// type.
-	errUnsupportedBeaconBlock = errors.New("unsupported beacon block")
-	// errUnsupportedBeaconBlockBody is returned when the struct type is not a supported beacon block body
-	// type.
-	errUnsupportedBeaconBlockBody = errors.New("unsupported beacon block body")
-	// ErrNilObjectWrapped is returned in a constructor when the underlying object is nil.
-	ErrNilObjectWrapped     = errors.New("attempted to wrap nil object")
-	errNilSignedBeaconBlock = errors.New("signed beacon block can't be nil")
-	errNilBeaconBlock       = errors.New("beacon block can't be nil")
-	errNilBeaconBlockBody   = errors.New("beacon block body can't be nil")
-)
-
-// NewSignedBeaconBlock creates a signed beacon block from a protobuf signed beacon block.
-func NewSignedBeaconBlock(i interface{}) (*SignedBeaconBlock, error) {
-	switch b := i.(type) {
-	case *eth.GenericSignedBeaconBlock_Phase0:
-		return initSignedBlockFromProtoPhase0(b.Phase0)
-	case *eth.SignedBeaconBlock:
-		return initSignedBlockFromProtoPhase0(b)
-	case *eth.GenericSignedBeaconBlock_Altair:
-		return initSignedBlockFromProtoAltair(b.Altair)
-	case *eth.SignedBeaconBlockAltair:
-		return initSignedBlockFromProtoAltair(b)
-	case *eth.GenericSignedBeaconBlock_Bellatrix:
-		return initSignedBlockFromProtoBellatrix(b.Bellatrix)
-	case *eth.SignedBeaconBlockBellatrix:
-		return initSignedBlockFromProtoBellatrix(b)
-	case *eth.GenericSignedBeaconBlock_BlindedBellatrix:
-		return initBlindedSignedBlockFromProtoBellatrix(b.BlindedBellatrix)
-	case *eth.SignedBlindedBeaconBlockBellatrix:
-		return initBlindedSignedBlockFromProtoBellatrix(b)
-	case nil:
-		return nil, ErrNilObjectWrapped
-	default:
-		return nil, errors.Wrapf(ErrUnsupportedSignedBeaconBlock, "unable to create block from type %T", i)
-	}
-}
-
-// NewBeaconBlock creates a beacon block from a protobuf beacon block.
-func NewBeaconBlock(i interface{}) (*BeaconBlock, error) {
-	switch b := i.(type) {
-	case *eth.GenericBeaconBlock_Phase0:
-		return initBlockFromProtoPhase0(b.Phase0)
-	case *eth.BeaconBlock:
-		return initBlockFromProtoPhase0(b)
-	case *eth.GenericBeaconBlock_Altair:
-		return initBlockFromProtoAltair(b.Altair)
-	case *eth.BeaconBlockAltair:
-		return initBlockFromProtoAltair(b)
-	case *eth.GenericBeaconBlock_Bellatrix:
-		return initBlockFromProtoBellatrix(b.Bellatrix)
-	case *eth.BeaconBlockBellatrix:
-		return initBlockFromProtoBellatrix(b)
-	case *eth.GenericBeaconBlock_BlindedBellatrix:
-		return initBlindedBlockFromProtoBellatrix(b.BlindedBellatrix)
-	case *eth.BlindedBeaconBlockBellatrix:
-		return initBlindedBlockFromProtoBellatrix(b)
-	case nil:
-		return nil, ErrNilObjectWrapped
-	default:
-		return nil, errors.Wrapf(errUnsupportedBeaconBlock, "unable to create block from type %T", i)
-	}
-}
-
-// NewBeaconBlockBody creates a beacon block body from a protobuf beacon block body.
-func NewBeaconBlockBody(i interface{}) (*BeaconBlockBody, error) {
-	switch b := i.(type) {
-	case *eth.BeaconBlockBody:
-		return initBlockBodyFromProtoPhase0(b)
-	case *eth.BeaconBlockBodyAltair:
-		return initBlockBodyFromProtoAltair(b)
-	case *eth.BeaconBlockBodyBellatrix:
-		return initBlockBodyFromProtoBellatrix(b)
-	case *eth.BlindedBeaconBlockBodyBellatrix:
-		return initBlindedBlockBodyFromProtoBellatrix(b)
-	case nil:
-		return nil, ErrNilObjectWrapped
-	default:
-		return nil, errors.Wrapf(errUnsupportedBeaconBlockBody, "unable to create block body from type %T", i)
-	}
-}
-
-// BuildSignedBeaconBlock assembles a block.SignedBeaconBlock interface compatible struct from a
-// given beacon block and the appropriate signature. This method may be used to easily create a
-// signed beacon block.
-func BuildSignedBeaconBlock(blk interfaces.BeaconBlock, signature []byte) (*SignedBeaconBlock, error) {
-	pb := blk.Proto()
-	switch blk.Version() {
-	case version.Phase0:
-		pb, ok := pb.(*eth.BeaconBlock)
-		if !ok {
-			return nil, errIncorrectBlockVersion
-		}
-		return NewSignedBeaconBlock(&eth.SignedBeaconBlock{Block: pb, Signature: signature})
-	case version.Altair:
-		pb, ok := pb.(*eth.BeaconBlockAltair)
-		if !ok {
-			return nil, errIncorrectBlockVersion
-		}
-		return NewSignedBeaconBlock(&eth.SignedBeaconBlockAltair{Block: pb, Signature: signature})
-	case version.Bellatrix:
-		pb, ok := pb.(*eth.BeaconBlockBellatrix)
-		if !ok {
-			return nil, errIncorrectBlockVersion
-		}
-		return NewSignedBeaconBlock(&eth.SignedBeaconBlockBellatrix{Block: pb, Signature: signature})
-	case version.BellatrixBlind:
-		pb, ok := pb.(*eth.BlindedBeaconBlockBellatrix)
-		if !ok {
-			return nil, errIncorrectBlockVersion
-		}
-		return NewSignedBeaconBlock(&eth.SignedBlindedBeaconBlockBellatrix{Block: pb, Signature: signature})
-	default:
-		return nil, errUnsupportedBeaconBlock
-	}
-}

consensus-types/blocks/factory_test.go

@@ -1,184 +0,0 @@
-package blocks
-
-import (
-	"bytes"
-	"testing"
-
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func Test_NewSignedBeaconBlock(t *testing.T) {
-	t.Run("GenericSignedBeaconBlock_Phase0", func(t *testing.T) {
-		pb := &eth.GenericSignedBeaconBlock_Phase0{
-			Phase0: &eth.SignedBeaconBlock{
-				Block: &eth.BeaconBlock{
-					Body: &eth.BeaconBlockBody{}}}}
-		b, err := NewSignedBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Phase0, b.version)
-	})
-	t.Run("SignedBeaconBlock", func(t *testing.T) {
-		pb := &eth.SignedBeaconBlock{
-			Block: &eth.BeaconBlock{
-				Body: &eth.BeaconBlockBody{}}}
-		b, err := NewSignedBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Phase0, b.version)
-	})
-	t.Run("GenericSignedBeaconBlock_Altair", func(t *testing.T) {
-		pb := &eth.GenericSignedBeaconBlock_Altair{
-			Altair: &eth.SignedBeaconBlockAltair{
-				Block: &eth.BeaconBlockAltair{
-					Body: &eth.BeaconBlockBodyAltair{}}}}
-		b, err := NewSignedBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Altair, b.version)
-	})
-	t.Run("SignedBeaconBlockAltair", func(t *testing.T) {
-		pb := &eth.SignedBeaconBlockAltair{
-			Block: &eth.BeaconBlockAltair{
-				Body: &eth.BeaconBlockBodyAltair{}}}
-		b, err := NewSignedBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Altair, b.version)
-	})
-	t.Run("GenericSignedBeaconBlock_Bellatrix", func(t *testing.T) {
-		pb := &eth.GenericSignedBeaconBlock_Bellatrix{
-			Bellatrix: &eth.SignedBeaconBlockBellatrix{
-				Block: &eth.BeaconBlockBellatrix{
-					Body: &eth.BeaconBlockBodyBellatrix{}}}}
-		b, err := NewSignedBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Bellatrix, b.version)
-	})
-	t.Run("SignedBeaconBlockBellatrix", func(t *testing.T) {
-		pb := &eth.SignedBeaconBlockBellatrix{
-			Block: &eth.BeaconBlockBellatrix{
-				Body: &eth.BeaconBlockBodyBellatrix{}}}
-		b, err := NewSignedBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Bellatrix, b.version)
-	})
-	t.Run("GenericSignedBeaconBlock_BlindedBellatrix", func(t *testing.T) {
-		pb := &eth.GenericSignedBeaconBlock_BlindedBellatrix{
-			BlindedBellatrix: &eth.SignedBlindedBeaconBlockBellatrix{
-				Block: &eth.BlindedBeaconBlockBellatrix{
-					Body: &eth.BlindedBeaconBlockBodyBellatrix{}}}}
-		b, err := NewSignedBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.BellatrixBlind, b.version)
-	})
-	t.Run("SignedBlindedBeaconBlockBellatrix", func(t *testing.T) {
-		pb := &eth.SignedBlindedBeaconBlockBellatrix{
-			Block: &eth.BlindedBeaconBlockBellatrix{
-				Body: &eth.BlindedBeaconBlockBodyBellatrix{}}}
-		b, err := NewSignedBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.BellatrixBlind, b.version)
-	})
-	t.Run("nil", func(t *testing.T) {
-		_, err := NewSignedBeaconBlock(nil)
-		assert.ErrorContains(t, "attempted to wrap nil object", err)
-	})
-	t.Run("unsupported type", func(t *testing.T) {
-		_, err := NewSignedBeaconBlock(&bytes.Reader{})
-		assert.ErrorContains(t, "unable to create block from type *bytes.Reader", err)
-	})
-}
-
-func Test_NewBeaconBlock(t *testing.T) {
-	t.Run("GenericBeaconBlock_Phase0", func(t *testing.T) {
-		pb := &eth.GenericBeaconBlock_Phase0{Phase0: &eth.BeaconBlock{Body: &eth.BeaconBlockBody{}}}
-		b, err := NewBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Phase0, b.version)
-	})
-	t.Run("BeaconBlock", func(t *testing.T) {
-		pb := &eth.BeaconBlock{Body: &eth.BeaconBlockBody{}}
-		b, err := NewBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Phase0, b.version)
-	})
-	t.Run("GenericBeaconBlock_Altair", func(t *testing.T) {
-		pb := &eth.GenericBeaconBlock_Altair{Altair: &eth.BeaconBlockAltair{Body: &eth.BeaconBlockBodyAltair{}}}
-		b, err := NewBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Altair, b.version)
-	})
-	t.Run("BeaconBlockAltair", func(t *testing.T) {
-		pb := &eth.BeaconBlockAltair{Body: &eth.BeaconBlockBodyAltair{}}
-		b, err := NewBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Altair, b.version)
-	})
-	t.Run("GenericBeaconBlock_Bellatrix", func(t *testing.T) {
-		pb := &eth.GenericBeaconBlock_Bellatrix{Bellatrix: &eth.BeaconBlockBellatrix{Body: &eth.BeaconBlockBodyBellatrix{}}}
-		b, err := NewBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Bellatrix, b.version)
-	})
-	t.Run("BeaconBlockBellatrix", func(t *testing.T) {
-		pb := &eth.BeaconBlockBellatrix{Body: &eth.BeaconBlockBodyBellatrix{}}
-		b, err := NewBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Bellatrix, b.version)
-	})
-	t.Run("GenericBeaconBlock_BlindedBellatrix", func(t *testing.T) {
-		pb := &eth.GenericBeaconBlock_BlindedBellatrix{BlindedBellatrix: &eth.BlindedBeaconBlockBellatrix{Body: &eth.BlindedBeaconBlockBodyBellatrix{}}}
-		b, err := NewBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.BellatrixBlind, b.version)
-	})
-	t.Run("BlindedBeaconBlockBellatrix", func(t *testing.T) {
-		pb := &eth.BlindedBeaconBlockBellatrix{Body: &eth.BlindedBeaconBlockBodyBellatrix{}}
-		b, err := NewBeaconBlock(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.BellatrixBlind, b.version)
-	})
-	t.Run("nil", func(t *testing.T) {
-		_, err := NewBeaconBlock(nil)
-		assert.ErrorContains(t, "attempted to wrap nil object", err)
-	})
-	t.Run("unsupported type", func(t *testing.T) {
-		_, err := NewBeaconBlock(&bytes.Reader{})
-		assert.ErrorContains(t, "unable to create block from type *bytes.Reader", err)
-	})
-}
-
-func Test_NewBeaconBlockBody(t *testing.T) {
-	t.Run("BeaconBlockBody", func(t *testing.T) {
-		pb := &eth.BeaconBlockBody{}
-		b, err := NewBeaconBlockBody(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Phase0, b.version)
-	})
-	t.Run("BeaconBlockBodyAltair", func(t *testing.T) {
-		pb := &eth.BeaconBlockBodyAltair{}
-		b, err := NewBeaconBlockBody(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Altair, b.version)
-	})
-	t.Run("BeaconBlockBodyBellatrix", func(t *testing.T) {
-		pb := &eth.BeaconBlockBodyBellatrix{}
-		b, err := NewBeaconBlockBody(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.Bellatrix, b.version)
-	})
-	t.Run("BlindedBeaconBlockBodyBellatrix", func(t *testing.T) {
-		pb := &eth.BlindedBeaconBlockBodyBellatrix{}
-		b, err := NewBeaconBlockBody(pb)
-		require.NoError(t, err)
-		assert.Equal(t, version.BellatrixBlind, b.version)
-	})
-	t.Run("nil", func(t *testing.T) {
-		_, err := NewBeaconBlockBody(nil)
-		assert.ErrorContains(t, "attempted to wrap nil object", err)
-	})
-	t.Run("unsupported type", func(t *testing.T) {
-		_, err := NewBeaconBlockBody(&bytes.Reader{})
-		assert.ErrorContains(t, "unable to create block body from type *bytes.Reader", err)
-	})
-}

consensus-types/blocks/getters.go

@@ -1,592 +0,0 @@
-package blocks
-
-import (
-	ssz "github.com/ferranbt/fastssz"
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	validatorpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/validator-client"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-)
-
-// 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 interfaces.SignedBeaconBlock) error {
-	if b == nil || b.IsNil() {
-		return errNilSignedBeaconBlock
-	}
-	if b.Block().IsNil() {
-		return errNilBeaconBlock
-	}
-	if b.Block().Body().IsNil() {
-		return errNilBeaconBlockBody
-	}
-	return nil
-}
-
-// Signature returns the respective block signature.
-func (b *SignedBeaconBlock) Signature() []byte {
-	return b.signature
-}
-
-// Block returns the underlying beacon block object.
-func (b *SignedBeaconBlock) Block() *BeaconBlock {
-	return b.block
-}
-
-// IsNil checks if the underlying beacon block is nil.
-func (b *SignedBeaconBlock) IsNil() bool {
-	return b == nil || b.block.IsNil()
-}
-
-// Copy performs a deep copy of the signed beacon block object.
-func (b *SignedBeaconBlock) Copy() (*SignedBeaconBlock, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return nil, err
-	}
-	switch b.version {
-	case version.Phase0:
-		cp := eth.CopySignedBeaconBlock(pb.(*eth.SignedBeaconBlock))
-		return initSignedBlockFromProtoPhase0(cp)
-	case version.Altair:
-		cp := eth.CopySignedBeaconBlockAltair(pb.(*eth.SignedBeaconBlockAltair))
-		return initSignedBlockFromProtoAltair(cp)
-	case version.Bellatrix:
-		cp := eth.CopySignedBeaconBlockBellatrix(pb.(*eth.SignedBeaconBlockBellatrix))
-		return initSignedBlockFromProtoBellatrix(cp)
-	case version.BellatrixBlind:
-		cp := eth.CopySignedBlindedBeaconBlockBellatrix(pb.(*eth.SignedBlindedBeaconBlockBellatrix))
-		return initBlindedSignedBlockFromProtoBellatrix(cp)
-	default:
-		return nil, errIncorrectBlockVersion
-	}
-}
-
-// PbGenericBlock returns a generic signed beacon block.
-func (b *SignedBeaconBlock) PbGenericBlock() (*eth.GenericSignedBeaconBlock, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return nil, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return &eth.GenericSignedBeaconBlock{
-			Block: &eth.GenericSignedBeaconBlock_Phase0{Phase0: pb.(*eth.SignedBeaconBlock)},
-		}, nil
-	case version.Altair:
-		return &eth.GenericSignedBeaconBlock{
-			Block: &eth.GenericSignedBeaconBlock_Altair{Altair: pb.(*eth.SignedBeaconBlockAltair)},
-		}, nil
-	case version.Bellatrix:
-		return &eth.GenericSignedBeaconBlock{
-			Block: &eth.GenericSignedBeaconBlock_Bellatrix{Bellatrix: pb.(*eth.SignedBeaconBlockBellatrix)},
-		}, nil
-	case version.BellatrixBlind:
-		return &eth.GenericSignedBeaconBlock{
-			Block: &eth.GenericSignedBeaconBlock_BlindedBellatrix{BlindedBellatrix: pb.(*eth.SignedBlindedBeaconBlockBellatrix)},
-		}, nil
-	default:
-		return nil, errIncorrectBlockVersion
-	}
-
-}
-
-// PbPhase0Block returns the underlying protobuf object.
-func (b *SignedBeaconBlock) PbPhase0Block() (*eth.SignedBeaconBlock, error) {
-	if b.version != version.Phase0 {
-		return nil, errNotSupported("PbPhase0Block", b.version)
-	}
-	pb, err := b.Proto()
-	if err != nil {
-		return nil, err
-	}
-	return pb.(*eth.SignedBeaconBlock), nil
-}
-
-// PbAltairBlock returns the underlying protobuf object.
-func (b *SignedBeaconBlock) PbAltairBlock() (*eth.SignedBeaconBlockAltair, error) {
-	if b.version != version.Altair {
-		return nil, errNotSupported("PbAltairBlock", b.version)
-	}
-	pb, err := b.Proto()
-	if err != nil {
-		return nil, err
-	}
-	return pb.(*eth.SignedBeaconBlockAltair), nil
-}
-
-// PbBellatrixBlock returns the underlying protobuf object.
-func (b *SignedBeaconBlock) PbBellatrixBlock() (*eth.SignedBeaconBlockBellatrix, error) {
-	if b.version != version.Bellatrix {
-		return nil, errNotSupported("PbBellatrixBlock", b.version)
-	}
-	pb, err := b.Proto()
-	if err != nil {
-		return nil, err
-	}
-	return pb.(*eth.SignedBeaconBlockBellatrix), nil
-}
-
-// PbBlindedBellatrixBlock returns the underlying protobuf object.
-func (b *SignedBeaconBlock) PbBlindedBellatrixBlock() (*eth.SignedBlindedBeaconBlockBellatrix, error) {
-	if b.version != version.BellatrixBlind {
-		return nil, errNotSupported("PbBlindedBellatrixBlock", b.version)
-	}
-	pb, err := b.Proto()
-	if err != nil {
-		return nil, err
-	}
-	return pb.(*eth.SignedBlindedBeaconBlockBellatrix), nil
-}
-
-// Version of the underlying protobuf object.
-func (b *SignedBeaconBlock) Version() int {
-	return b.version
-}
-
-// Header converts the underlying protobuf object from blinded block to header format.
-func (b *SignedBeaconBlock) Header() (*eth.SignedBeaconBlockHeader, error) {
-	if b.IsNil() {
-		return nil, errNilBlock
-	}
-	root, err := b.block.body.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrapf(err, "could not hash block body")
-	}
-
-	return &eth.SignedBeaconBlockHeader{
-		Header: &eth.BeaconBlockHeader{
-			Slot:          b.block.slot,
-			ProposerIndex: b.block.proposerIndex,
-			ParentRoot:    b.block.parentRoot,
-			StateRoot:     b.block.stateRoot,
-			BodyRoot:      root[:],
-		},
-		Signature: b.signature,
-	}, nil
-}
-
-// MarshalSSZ marshals the signed beacon block to its relevant ssz form.
-func (b *SignedBeaconBlock) MarshalSSZ() ([]byte, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return []byte{}, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return pb.(*eth.SignedBeaconBlock).MarshalSSZ()
-	case version.Altair:
-		return pb.(*eth.SignedBeaconBlockAltair).MarshalSSZ()
-	case version.Bellatrix:
-		return pb.(*eth.SignedBeaconBlockBellatrix).MarshalSSZ()
-	case version.BellatrixBlind:
-		return pb.(*eth.SignedBlindedBeaconBlockBellatrix).MarshalSSZ()
-	default:
-		return []byte{}, errIncorrectBlockVersion
-	}
-}
-
-// MarshalSSZTo marshals the signed beacon block's ssz
-// form to the provided byte buffer.
-func (b *SignedBeaconBlock) MarshalSSZTo(dst []byte) ([]byte, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return []byte{}, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return pb.(*eth.SignedBeaconBlock).MarshalSSZTo(dst)
-	case version.Altair:
-		return pb.(*eth.SignedBeaconBlockAltair).MarshalSSZTo(dst)
-	case version.Bellatrix:
-		return pb.(*eth.SignedBeaconBlockBellatrix).MarshalSSZTo(dst)
-	case version.BellatrixBlind:
-		return pb.(*eth.SignedBlindedBeaconBlockBellatrix).MarshalSSZTo(dst)
-	default:
-		return []byte{}, errIncorrectBlockVersion
-	}
-}
-
-// SizeSSZ returns the size of the serialized signed block
-func (b *SignedBeaconBlock) SizeSSZ() (int, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return 0, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return pb.(*eth.SignedBeaconBlock).SizeSSZ(), nil
-	case version.Altair:
-		return pb.(*eth.SignedBeaconBlockAltair).SizeSSZ(), nil
-	case version.Bellatrix:
-		return pb.(*eth.SignedBeaconBlockBellatrix).SizeSSZ(), nil
-	case version.BellatrixBlind:
-		return pb.(*eth.SignedBlindedBeaconBlockBellatrix).SizeSSZ(), nil
-	default:
-		return 0, errIncorrectBlockVersion
-	}
-}
-
-// UnmarshalSSZ unmarshals the signed beacon block from its relevant ssz form.
-func (b *SignedBeaconBlock) UnmarshalSSZ(buf []byte) error {
-	var newBlock *SignedBeaconBlock
-	switch b.version {
-	case version.Phase0:
-		pb := &eth.SignedBeaconBlock{}
-		if err := pb.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-		var err error
-		newBlock, err = initSignedBlockFromProtoPhase0(pb)
-		if err != nil {
-			return err
-		}
-	case version.Altair:
-		pb := &eth.SignedBeaconBlockAltair{}
-		if err := pb.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-		var err error
-		newBlock, err = initSignedBlockFromProtoAltair(pb)
-		if err != nil {
-			return err
-		}
-	case version.Bellatrix:
-		pb := &eth.SignedBeaconBlockBellatrix{}
-		if err := pb.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-		var err error
-		newBlock, err = initSignedBlockFromProtoBellatrix(pb)
-		if err != nil {
-			return err
-		}
-	case version.BellatrixBlind:
-		pb := &eth.SignedBlindedBeaconBlockBellatrix{}
-		if err := pb.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-		var err error
-		newBlock, err = initBlindedSignedBlockFromProtoBellatrix(pb)
-		if err != nil {
-			return err
-		}
-	default:
-		return errIncorrectBlockVersion
-	}
-	*b = *newBlock
-	return nil
-}
-
-// Slot returns the respective slot of the block.
-func (b *BeaconBlock) Slot() types.Slot {
-	return b.slot
-}
-
-// ProposerIndex returns the proposer index of the beacon block.
-func (b *BeaconBlock) ProposerIndex() types.ValidatorIndex {
-	return b.proposerIndex
-}
-
-// ParentRoot returns the parent root of beacon block.
-func (b *BeaconBlock) ParentRoot() []byte {
-	return b.parentRoot
-}
-
-// StateRoot returns the state root of the beacon block.
-func (b *BeaconBlock) StateRoot() []byte {
-	return b.stateRoot
-}
-
-// Body returns the underlying block body.
-func (b *BeaconBlock) Body() *BeaconBlockBody {
-	return b.body
-}
-
-// IsNil checks if the beacon block is nil.
-func (b *BeaconBlock) IsNil() bool {
-	return b == nil || b.Body().IsNil()
-}
-
-// IsBlinded checks if the beacon block is a blinded block.
-func (b *BeaconBlock) IsBlinded() bool {
-	switch b.version {
-	case version.Phase0, version.Altair, version.Bellatrix:
-		return false
-	case version.BellatrixBlind:
-		return true
-	default:
-		return false
-	}
-}
-
-// Version of the underlying protobuf object.
-func (b *BeaconBlock) Version() int {
-	return b.version
-}
-
-// HashTreeRoot returns the ssz root of the block.
-func (b *BeaconBlock) HashTreeRoot() ([32]byte, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return [32]byte{}, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return pb.(*eth.BeaconBlock).HashTreeRoot()
-	case version.Altair:
-		return pb.(*eth.BeaconBlockAltair).HashTreeRoot()
-	case version.Bellatrix:
-		return pb.(*eth.BeaconBlockBellatrix).HashTreeRoot()
-	case version.BellatrixBlind:
-		return pb.(*eth.BlindedBeaconBlockBellatrix).HashTreeRoot()
-	default:
-		return [32]byte{}, errIncorrectBlockVersion
-	}
-}
-
-// HashTreeRootWith ssz hashes the BeaconBlock object with a hasher.
-func (b *BeaconBlock) HashTreeRootWith(h *ssz.Hasher) error {
-	pb, err := b.Proto()
-	if err != nil {
-		return err
-	}
-	switch b.version {
-	case version.Phase0:
-		return pb.(*eth.BeaconBlock).HashTreeRootWith(h)
-	case version.Altair:
-		return pb.(*eth.BeaconBlockAltair).HashTreeRootWith(h)
-	case version.Bellatrix:
-		return pb.(*eth.BeaconBlockBellatrix).HashTreeRootWith(h)
-	case version.BellatrixBlind:
-		return pb.(*eth.BlindedBeaconBlockBellatrix).HashTreeRootWith(h)
-	default:
-		return errIncorrectBlockVersion
-	}
-}
-
-// MarshalSSZ marshals the block into its respective
-// ssz form.
-func (b *BeaconBlock) MarshalSSZ() ([]byte, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return []byte{}, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return pb.(*eth.BeaconBlock).MarshalSSZ()
-	case version.Altair:
-		return pb.(*eth.BeaconBlockAltair).MarshalSSZ()
-	case version.Bellatrix:
-		return pb.(*eth.BeaconBlockBellatrix).MarshalSSZ()
-	case version.BellatrixBlind:
-		return pb.(*eth.BlindedBeaconBlockBellatrix).MarshalSSZ()
-	default:
-		return []byte{}, errIncorrectBlockVersion
-	}
-}
-
-// MarshalSSZTo marshals the beacon block's ssz
-// form to the provided byte buffer.
-func (b *BeaconBlock) MarshalSSZTo(dst []byte) ([]byte, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return []byte{}, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return pb.(*eth.BeaconBlock).MarshalSSZTo(dst)
-	case version.Altair:
-		return pb.(*eth.BeaconBlockAltair).MarshalSSZTo(dst)
-	case version.Bellatrix:
-		return pb.(*eth.BeaconBlockBellatrix).MarshalSSZTo(dst)
-	case version.BellatrixBlind:
-		return pb.(*eth.BlindedBeaconBlockBellatrix).MarshalSSZTo(dst)
-	default:
-		return []byte{}, errIncorrectBlockVersion
-	}
-}
-
-// SizeSSZ returns the size of the serialized block.
-func (b *BeaconBlock) SizeSSZ() (int, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return 0, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return pb.(*eth.BeaconBlock).SizeSSZ(), nil
-	case version.Altair:
-		return pb.(*eth.BeaconBlockAltair).SizeSSZ(), nil
-	case version.Bellatrix:
-		return pb.(*eth.BeaconBlockBellatrix).SizeSSZ(), nil
-	case version.BellatrixBlind:
-		return pb.(*eth.BlindedBeaconBlockBellatrix).SizeSSZ(), nil
-	default:
-		return 0, errIncorrectBlockVersion
-	}
-}
-
-// UnmarshalSSZ unmarshals the beacon block from its relevant ssz form.
-func (b *BeaconBlock) UnmarshalSSZ(buf []byte) error {
-	var newBlock *BeaconBlock
-	switch b.version {
-	case version.Phase0:
-		pb := &eth.BeaconBlock{}
-		if err := pb.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-		var err error
-		newBlock, err = initBlockFromProtoPhase0(pb)
-		if err != nil {
-			return err
-		}
-	case version.Altair:
-		pb := &eth.BeaconBlockAltair{}
-		if err := pb.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-		var err error
-		newBlock, err = initBlockFromProtoAltair(pb)
-		if err != nil {
-			return err
-		}
-	case version.Bellatrix:
-		pb := &eth.BeaconBlockBellatrix{}
-		if err := pb.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-		var err error
-		newBlock, err = initBlockFromProtoBellatrix(pb)
-		if err != nil {
-			return err
-		}
-	case version.BellatrixBlind:
-		pb := &eth.BlindedBeaconBlockBellatrix{}
-		if err := pb.UnmarshalSSZ(buf); err != nil {
-			return err
-		}
-		var err error
-		newBlock, err = initBlindedBlockFromProtoBellatrix(pb)
-		if err != nil {
-			return err
-		}
-	default:
-		return errIncorrectBlockVersion
-	}
-	*b = *newBlock
-	return nil
-}
-
-// AsSignRequestObject returns the underlying sign request object.
-func (b *BeaconBlock) AsSignRequestObject() (validatorpb.SignRequestObject, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return nil, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return &validatorpb.SignRequest_Block{Block: pb.(*eth.BeaconBlock)}, nil
-	case version.Altair:
-		return &validatorpb.SignRequest_BlockV2{BlockV2: pb.(*eth.BeaconBlockAltair)}, nil
-	case version.Bellatrix:
-		return &validatorpb.SignRequest_BlockV3{BlockV3: pb.(*eth.BeaconBlockBellatrix)}, nil
-	case version.BellatrixBlind:
-		return &validatorpb.SignRequest_BlindedBlockV3{BlindedBlockV3: pb.(*eth.BlindedBeaconBlockBellatrix)}, nil
-	default:
-		return nil, errIncorrectBlockVersion
-	}
-}
-
-// IsNil checks if the block body is nil.
-func (b *BeaconBlockBody) IsNil() bool {
-	return b == nil
-}
-
-// RandaoReveal returns the randao reveal from the block body.
-func (b *BeaconBlockBody) RandaoReveal() []byte {
-	return b.randaoReveal
-}
-
-// Eth1Data returns the eth1 data in the block.
-func (b *BeaconBlockBody) Eth1Data() *eth.Eth1Data {
-	return b.eth1Data
-}
-
-// Graffiti returns the graffiti in the block.
-func (b *BeaconBlockBody) Graffiti() []byte {
-	return b.graffiti
-}
-
-// ProposerSlashings returns the proposer slashings in the block.
-func (b *BeaconBlockBody) ProposerSlashings() []*eth.ProposerSlashing {
-	return b.proposerSlashings
-}
-
-// AttesterSlashings returns the attester slashings in the block.
-func (b *BeaconBlockBody) AttesterSlashings() []*eth.AttesterSlashing {
-	return b.attesterSlashings
-}
-
-// Attestations returns the stored attestations in the block.
-func (b *BeaconBlockBody) Attestations() []*eth.Attestation {
-	return b.attestations
-}
-
-// Deposits returns the stored deposits in the block.
-func (b *BeaconBlockBody) Deposits() []*eth.Deposit {
-	return b.deposits
-}
-
-// VoluntaryExits returns the voluntary exits in the block.
-func (b *BeaconBlockBody) VoluntaryExits() []*eth.SignedVoluntaryExit {
-	return b.voluntaryExits
-}
-
-// SyncAggregate returns the sync aggregate in the block.
-func (b *BeaconBlockBody) SyncAggregate() (*eth.SyncAggregate, error) {
-	if b.version == version.Phase0 {
-		return nil, errNotSupported("SyncAggregate", b.version)
-	}
-	return b.syncAggregate, nil
-}
-
-// ExecutionPayload returns the execution payload of the block body.
-func (b *BeaconBlockBody) ExecutionPayload() (*enginev1.ExecutionPayload, error) {
-	if b.version != version.Bellatrix {
-		return nil, errNotSupported("ExecutionPayload", b.version)
-	}
-	return b.executionPayload, nil
-}
-
-// ExecutionPayloadHeader returns the execution payload header of the block body.
-func (b *BeaconBlockBody) ExecutionPayloadHeader() (*eth.ExecutionPayloadHeader, error) {
-	if b.version != version.BellatrixBlind {
-		return nil, errNotSupported("ExecutionPayloadHeader", b.version)
-	}
-	return b.executionPayloadHeader, nil
-}
-
-// HashTreeRoot returns the ssz root of the block body.
-func (b *BeaconBlockBody) HashTreeRoot() ([32]byte, error) {
-	pb, err := b.Proto()
-	if err != nil {
-		return [32]byte{}, err
-	}
-	switch b.version {
-	case version.Phase0:
-		return pb.(*eth.BeaconBlockBody).HashTreeRoot()
-	case version.Altair:
-		return pb.(*eth.BeaconBlockBodyAltair).HashTreeRoot()
-	case version.Bellatrix:
-		return pb.(*eth.BeaconBlockBodyBellatrix).HashTreeRoot()
-	case version.BellatrixBlind:
-		return pb.(*eth.BlindedBeaconBlockBodyBellatrix).HashTreeRoot()
-	default:
-		return [32]byte{}, errIncorrectBodyVersion
-	}
-}

consensus-types/blocks/getters_test.go

@@ -1,314 +0,0 @@
-package blocks
-
-import (
-	"testing"
-
-	ssz "github.com/ferranbt/fastssz"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	validatorpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/validator-client"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-)
-
-func Test_SignedBeaconBlock_Signature(t *testing.T) {
-	sb := &SignedBeaconBlock{signature: []byte("signature")}
-	assert.DeepEqual(t, []byte("signature"), sb.Signature())
-}
-
-func Test_SignedBeaconBlock_Block(t *testing.T) {
-	b := &BeaconBlock{}
-	sb := &SignedBeaconBlock{block: b}
-	assert.Equal(t, b, sb.Block())
-}
-
-func Test_SignedBeaconBlock_IsNil(t *testing.T) {
-	t.Run("nil signed block", func(t *testing.T) {
-		var sb *SignedBeaconBlock
-		assert.Equal(t, true, sb.IsNil())
-	})
-	t.Run("nil block", func(t *testing.T) {
-		sb := &SignedBeaconBlock{}
-		assert.Equal(t, true, sb.IsNil())
-	})
-	t.Run("nil body", func(t *testing.T) {
-		sb := &SignedBeaconBlock{block: &BeaconBlock{}}
-		assert.Equal(t, true, sb.IsNil())
-	})
-	t.Run("not nil", func(t *testing.T) {
-		sb := &SignedBeaconBlock{block: &BeaconBlock{body: &BeaconBlockBody{}}}
-		assert.Equal(t, false, sb.IsNil())
-	})
-}
-
-func Test_SignedBeaconBlock_Copy(t *testing.T) {
-	bb := &BeaconBlockBody{}
-	b := &BeaconBlock{body: bb}
-	sb := &SignedBeaconBlock{block: b}
-	cp, err := sb.Copy()
-	require.NoError(t, err)
-	assert.NotEqual(t, cp, sb)
-	assert.NotEqual(t, cp.block, sb.block)
-	assert.NotEqual(t, cp.block.body, sb.block.body)
-}
-
-func Test_SignedBeaconBlock_Version(t *testing.T) {
-	sb := &SignedBeaconBlock{version: 128}
-	assert.Equal(t, 128, sb.Version())
-}
-
-func Test_SignedBeaconBlock_Header(t *testing.T) {
-	bb := &BeaconBlockBody{
-		version:      version.Phase0,
-		randaoReveal: make([]byte, 96),
-		eth1Data: &eth.Eth1Data{
-			DepositRoot: make([]byte, 32),
-			BlockHash:   make([]byte, 32),
-		},
-		graffiti: make([]byte, 32),
-	}
-	sb := &SignedBeaconBlock{
-		version: version.Phase0,
-		block: &BeaconBlock{
-			version:       version.Phase0,
-			slot:          128,
-			proposerIndex: 128,
-			parentRoot:    []byte("parentroot"),
-			stateRoot:     []byte("stateroot"),
-			body:          bb,
-		},
-		signature: []byte("signature"),
-	}
-	h, err := sb.Header()
-	require.NoError(t, err)
-	assert.DeepEqual(t, sb.signature, h.Signature)
-	assert.Equal(t, sb.block.slot, h.Header.Slot)
-	assert.Equal(t, sb.block.proposerIndex, h.Header.ProposerIndex)
-	assert.DeepEqual(t, sb.block.parentRoot, h.Header.ParentRoot)
-	assert.DeepEqual(t, sb.block.stateRoot, h.Header.StateRoot)
-	expectedHTR, err := bb.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR[:], h.Header.BodyRoot)
-}
-
-func Test_SignedBeaconBlock_UnmarshalSSZ(t *testing.T) {
-	pb := util.HydrateSignedBeaconBlock(&eth.SignedBeaconBlock{})
-	buf, err := pb.MarshalSSZ()
-	require.NoError(t, err)
-	expectedHTR, err := pb.HashTreeRoot()
-	require.NoError(t, err)
-	sb := &SignedBeaconBlock{}
-	require.NoError(t, sb.UnmarshalSSZ(buf))
-	msg, err := sb.Proto()
-	require.NoError(t, err)
-	actualPb, ok := msg.(*eth.SignedBeaconBlock)
-	require.Equal(t, true, ok)
-	actualHTR, err := actualPb.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, actualHTR)
-}
-
-func Test_BeaconBlock_Slot(t *testing.T) {
-	b := &BeaconBlock{slot: 128}
-	assert.Equal(t, types.Slot(128), b.Slot())
-}
-
-func Test_BeaconBlock_ProposerIndex(t *testing.T) {
-	b := &BeaconBlock{proposerIndex: 128}
-	assert.Equal(t, types.ValidatorIndex(128), b.ProposerIndex())
-}
-
-func Test_BeaconBlock_ParentRoot(t *testing.T) {
-	b := &BeaconBlock{parentRoot: []byte("parentroot")}
-	assert.DeepEqual(t, []byte("parentroot"), b.ParentRoot())
-}
-
-func Test_BeaconBlock_StateRoot(t *testing.T) {
-	b := &BeaconBlock{stateRoot: []byte("stateroot")}
-	assert.DeepEqual(t, []byte("stateroot"), b.StateRoot())
-}
-
-func Test_BeaconBlock_Body(t *testing.T) {
-	bb := &BeaconBlockBody{}
-	b := &BeaconBlock{body: bb}
-	assert.Equal(t, bb, b.Body())
-}
-
-func Test_BeaconBlock_IsNil(t *testing.T) {
-	t.Run("nil block", func(t *testing.T) {
-		var b *BeaconBlock
-		assert.Equal(t, true, b.IsNil())
-	})
-	t.Run("nil block body", func(t *testing.T) {
-		b := &BeaconBlock{}
-		assert.Equal(t, true, b.IsNil())
-	})
-	t.Run("not nil", func(t *testing.T) {
-		b := &BeaconBlock{body: &BeaconBlockBody{}}
-		assert.Equal(t, false, b.IsNil())
-	})
-}
-
-func Test_BeaconBlock_IsBlinded(t *testing.T) {
-	assert.Equal(t, false, (&BeaconBlock{version: version.Phase0}).IsBlinded())
-	assert.Equal(t, false, (&BeaconBlock{version: version.Altair}).IsBlinded())
-	assert.Equal(t, false, (&BeaconBlock{version: version.Bellatrix}).IsBlinded())
-	assert.Equal(t, true, (&BeaconBlock{version: version.BellatrixBlind}).IsBlinded())
-	assert.Equal(t, false, (&BeaconBlock{version: 128}).IsBlinded())
-}
-
-func Test_BeaconBlock_Version(t *testing.T) {
-	b := &BeaconBlock{version: 128}
-	assert.Equal(t, 128, b.Version())
-}
-
-func Test_BeaconBlock_HashTreeRoot(t *testing.T) {
-	pb := util.HydrateBeaconBlock(&eth.BeaconBlock{})
-	expectedHTR, err := pb.HashTreeRoot()
-	require.NoError(t, err)
-	b, err := initBlockFromProtoPhase0(pb)
-	require.NoError(t, err)
-	actualHTR, err := b.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, actualHTR)
-}
-
-func Test_BeaconBlock_HashTreeRootWith(t *testing.T) {
-	pb := util.HydrateBeaconBlock(&eth.BeaconBlock{})
-	expectedHTR, err := pb.HashTreeRoot()
-	require.NoError(t, err)
-	b, err := initBlockFromProtoPhase0(pb)
-	require.NoError(t, err)
-	h := ssz.DefaultHasherPool.Get()
-	require.NoError(t, b.HashTreeRootWith(h))
-	actualHTR, err := h.HashRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, actualHTR)
-}
-
-func Test_BeaconBlock_UnmarshalSSZ(t *testing.T) {
-	pb := util.HydrateBeaconBlock(&eth.BeaconBlock{})
-	buf, err := pb.MarshalSSZ()
-	require.NoError(t, err)
-	expectedHTR, err := pb.HashTreeRoot()
-	require.NoError(t, err)
-	b := &BeaconBlock{}
-	require.NoError(t, b.UnmarshalSSZ(buf))
-	msg, err := b.Proto()
-	require.NoError(t, err)
-	actualPb, ok := msg.(*eth.BeaconBlock)
-	require.Equal(t, true, ok)
-	actualHTR, err := actualPb.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, actualHTR)
-}
-
-func Test_BeaconBlock_AsSignRequestObject(t *testing.T) {
-	pb := util.HydrateBeaconBlock(&eth.BeaconBlock{})
-	expectedHTR, err := pb.HashTreeRoot()
-	require.NoError(t, err)
-	b, err := initBlockFromProtoPhase0(pb)
-	require.NoError(t, err)
-	signRequestObj, err := b.AsSignRequestObject()
-	require.NoError(t, err)
-	actualSignRequestObj, ok := signRequestObj.(*validatorpb.SignRequest_Block)
-	require.Equal(t, true, ok)
-	actualHTR, err := actualSignRequestObj.Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, actualHTR)
-}
-
-func Test_BeaconBlockBody_IsNil(t *testing.T) {
-	t.Run("nil block body", func(t *testing.T) {
-		var bb *BeaconBlockBody
-		assert.Equal(t, true, bb.IsNil())
-	})
-	t.Run("not nil", func(t *testing.T) {
-		bb := &BeaconBlockBody{}
-		assert.Equal(t, false, bb.IsNil())
-	})
-}
-
-func Test_BeaconBlockBody_RandaoReveal(t *testing.T) {
-	bb := &BeaconBlockBody{randaoReveal: []byte("randaoreveal")}
-	assert.DeepEqual(t, []byte("randaoreveal"), bb.RandaoReveal())
-}
-
-func Test_BeaconBlockBody_Eth1Data(t *testing.T) {
-	e := &eth.Eth1Data{}
-	bb := &BeaconBlockBody{eth1Data: e}
-	assert.Equal(t, e, bb.Eth1Data())
-}
-
-func Test_BeaconBlockBody_Graffiti(t *testing.T) {
-	bb := &BeaconBlockBody{graffiti: []byte("graffiti")}
-	assert.DeepEqual(t, []byte("graffiti"), bb.Graffiti())
-}
-
-func Test_BeaconBlockBody_ProposerSlashings(t *testing.T) {
-	ps := make([]*eth.ProposerSlashing, 0)
-	bb := &BeaconBlockBody{proposerSlashings: ps}
-	assert.DeepSSZEqual(t, ps, bb.ProposerSlashings())
-}
-
-func Test_BeaconBlockBody_AttesterSlashings(t *testing.T) {
-	as := make([]*eth.AttesterSlashing, 0)
-	bb := &BeaconBlockBody{attesterSlashings: as}
-	assert.DeepSSZEqual(t, as, bb.AttesterSlashings())
-}
-
-func Test_BeaconBlockBody_Attestations(t *testing.T) {
-	a := make([]*eth.Attestation, 0)
-	bb := &BeaconBlockBody{attestations: a}
-	assert.DeepSSZEqual(t, a, bb.Attestations())
-}
-
-func Test_BeaconBlockBody_Deposits(t *testing.T) {
-	d := make([]*eth.Deposit, 0)
-	bb := &BeaconBlockBody{deposits: d}
-	assert.DeepSSZEqual(t, d, bb.Deposits())
-}
-
-func Test_BeaconBlockBody_VoluntaryExits(t *testing.T) {
-	ve := make([]*eth.SignedVoluntaryExit, 0)
-	bb := &BeaconBlockBody{voluntaryExits: ve}
-	assert.DeepSSZEqual(t, ve, bb.VoluntaryExits())
-}
-
-func Test_BeaconBlockBody_SyncAggregate(t *testing.T) {
-	sa := &eth.SyncAggregate{}
-	bb := &BeaconBlockBody{version: version.Altair, syncAggregate: sa}
-	result, err := bb.SyncAggregate()
-	require.NoError(t, err)
-	assert.Equal(t, result, sa)
-}
-
-func Test_BeaconBlockBody_ExecutionPayload(t *testing.T) {
-	ep := &enginev1.ExecutionPayload{}
-	bb := &BeaconBlockBody{version: version.Bellatrix, executionPayload: ep}
-	result, err := bb.ExecutionPayload()
-	require.NoError(t, err)
-	assert.Equal(t, result, ep)
-}
-
-func Test_BeaconBlockBody_ExecutionPayloadHeader(t *testing.T) {
-	eph := &eth.ExecutionPayloadHeader{}
-	bb := &BeaconBlockBody{version: version.BellatrixBlind, executionPayloadHeader: eph}
-	result, err := bb.ExecutionPayloadHeader()
-	require.NoError(t, err)
-	assert.Equal(t, result, eph)
-}
-
-func Test_BeaconBlockBody_HashTreeRoot(t *testing.T) {
-	pb := util.HydrateBeaconBlockBody(&eth.BeaconBlockBody{})
-	expectedHTR, err := pb.HashTreeRoot()
-	require.NoError(t, err)
-	b, err := initBlockBodyFromProtoPhase0(pb)
-	require.NoError(t, err)
-	actualHTR, err := b.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, actualHTR)
-}

consensus-types/blocks/proto.go

@@ -1,416 +0,0 @@
-package blocks
-
-import (
-	"github.com/pkg/errors"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-	"google.golang.org/protobuf/proto"
-)
-
-// Proto returns the underlying protobuf signed beacon block.
-func (b *SignedBeaconBlock) Proto() (proto.Message, error) {
-	if b == nil {
-		return nil, errNilBlock
-	}
-
-	blockMessage, err := b.block.Proto()
-	if err != nil {
-		return nil, err
-	}
-
-	switch b.version {
-	case version.Phase0:
-		block, ok := blockMessage.(*eth.BeaconBlock)
-		if !ok {
-			return nil, errors.Wrap(err, incorrectBlockVersion)
-		}
-		return &eth.SignedBeaconBlock{
-			Block:     block,
-			Signature: b.signature,
-		}, nil
-	case version.Altair:
-		block, ok := blockMessage.(*eth.BeaconBlockAltair)
-		if !ok {
-			return nil, errors.Wrap(err, incorrectBlockVersion)
-		}
-		return &eth.SignedBeaconBlockAltair{
-			Block:     block,
-			Signature: b.signature,
-		}, nil
-	case version.Bellatrix:
-		block, ok := blockMessage.(*eth.BeaconBlockBellatrix)
-		if !ok {
-			return nil, errors.Wrap(err, incorrectBlockVersion)
-		}
-		return &eth.SignedBeaconBlockBellatrix{
-			Block:     block,
-			Signature: b.signature,
-		}, nil
-	case version.BellatrixBlind:
-		block, ok := blockMessage.(*eth.BlindedBeaconBlockBellatrix)
-		if !ok {
-			return nil, errors.Wrap(err, incorrectBlockVersion)
-		}
-		return &eth.SignedBlindedBeaconBlockBellatrix{
-			Block:     block,
-			Signature: b.signature,
-		}, nil
-	default:
-		return nil, errors.New("unsupported signed beacon block version")
-	}
-}
-
-// Proto returns the underlying protobuf beacon block.
-func (b *BeaconBlock) Proto() (proto.Message, error) {
-	if b == nil {
-		return nil, errNilBlock
-	}
-
-	bodyMessage, err := b.body.Proto()
-	if err != nil {
-		return nil, err
-	}
-
-	switch b.version {
-	case version.Phase0:
-		body, ok := bodyMessage.(*eth.BeaconBlockBody)
-		if !ok {
-			return nil, errors.Wrap(err, incorrectBodyVersion)
-		}
-		return &eth.BeaconBlock{
-			Slot:          b.slot,
-			ProposerIndex: b.proposerIndex,
-			ParentRoot:    b.parentRoot,
-			StateRoot:     b.stateRoot,
-			Body:          body,
-		}, nil
-	case version.Altair:
-		body, ok := bodyMessage.(*eth.BeaconBlockBodyAltair)
-		if !ok {
-			return nil, errors.Wrap(err, incorrectBodyVersion)
-		}
-		return &eth.BeaconBlockAltair{
-			Slot:          b.slot,
-			ProposerIndex: b.proposerIndex,
-			ParentRoot:    b.parentRoot,
-			StateRoot:     b.stateRoot,
-			Body:          body,
-		}, nil
-	case version.Bellatrix:
-		body, ok := bodyMessage.(*eth.BeaconBlockBodyBellatrix)
-		if !ok {
-			return nil, errors.Wrap(err, incorrectBodyVersion)
-		}
-		return &eth.BeaconBlockBellatrix{
-			Slot:          b.slot,
-			ProposerIndex: b.proposerIndex,
-			ParentRoot:    b.parentRoot,
-			StateRoot:     b.stateRoot,
-			Body:          body,
-		}, nil
-	case version.BellatrixBlind:
-		body, ok := bodyMessage.(*eth.BlindedBeaconBlockBodyBellatrix)
-		if !ok {
-			return nil, errors.Wrap(err, incorrectBodyVersion)
-		}
-		return &eth.BlindedBeaconBlockBellatrix{
-			Slot:          b.slot,
-			ProposerIndex: b.proposerIndex,
-			ParentRoot:    b.parentRoot,
-			StateRoot:     b.stateRoot,
-			Body:          body,
-		}, nil
-	default:
-		return nil, errors.New("unsupported beacon block version")
-	}
-}
-
-// Proto returns the underlying protobuf beacon block body.
-func (b *BeaconBlockBody) Proto() (proto.Message, error) {
-	if b == nil {
-		return nil, errNilBody
-	}
-
-	switch b.version {
-	case version.Phase0:
-		return &eth.BeaconBlockBody{
-			RandaoReveal:      b.randaoReveal,
-			Eth1Data:          b.eth1Data,
-			Graffiti:          b.graffiti,
-			ProposerSlashings: b.proposerSlashings,
-			AttesterSlashings: b.attesterSlashings,
-			Attestations:      b.attestations,
-			Deposits:          b.deposits,
-			VoluntaryExits:    b.voluntaryExits,
-		}, nil
-	case version.Altair:
-		return &eth.BeaconBlockBodyAltair{
-			RandaoReveal:      b.randaoReveal,
-			Eth1Data:          b.eth1Data,
-			Graffiti:          b.graffiti,
-			ProposerSlashings: b.proposerSlashings,
-			AttesterSlashings: b.attesterSlashings,
-			Attestations:      b.attestations,
-			Deposits:          b.deposits,
-			VoluntaryExits:    b.voluntaryExits,
-			SyncAggregate:     b.syncAggregate,
-		}, nil
-	case version.Bellatrix:
-		return &eth.BeaconBlockBodyBellatrix{
-			RandaoReveal:      b.randaoReveal,
-			Eth1Data:          b.eth1Data,
-			Graffiti:          b.graffiti,
-			ProposerSlashings: b.proposerSlashings,
-			AttesterSlashings: b.attesterSlashings,
-			Attestations:      b.attestations,
-			Deposits:          b.deposits,
-			VoluntaryExits:    b.voluntaryExits,
-			SyncAggregate:     b.syncAggregate,
-			ExecutionPayload:  b.executionPayload,
-		}, nil
-	case version.BellatrixBlind:
-		return &eth.BlindedBeaconBlockBodyBellatrix{
-			RandaoReveal:           b.randaoReveal,
-			Eth1Data:               b.eth1Data,
-			Graffiti:               b.graffiti,
-			ProposerSlashings:      b.proposerSlashings,
-			AttesterSlashings:      b.attesterSlashings,
-			Attestations:           b.attestations,
-			Deposits:               b.deposits,
-			VoluntaryExits:         b.voluntaryExits,
-			SyncAggregate:          b.syncAggregate,
-			ExecutionPayloadHeader: b.executionPayloadHeader,
-		}, nil
-	default:
-		return nil, errors.New("unsupported beacon block body version")
-	}
-}
-
-func initSignedBlockFromProtoPhase0(pb *eth.SignedBeaconBlock) (*SignedBeaconBlock, error) {
-	if pb == nil {
-		return nil, errNilBlock
-	}
-
-	block, err := initBlockFromProtoPhase0(pb.Block)
-	if err != nil {
-		return nil, err
-	}
-	b := &SignedBeaconBlock{
-		version:   version.Phase0,
-		block:     block,
-		signature: pb.Signature,
-	}
-	return b, nil
-}
-
-func initSignedBlockFromProtoAltair(pb *eth.SignedBeaconBlockAltair) (*SignedBeaconBlock, error) {
-	if pb == nil {
-		return nil, errNilBlock
-	}
-
-	block, err := initBlockFromProtoAltair(pb.Block)
-	if err != nil {
-		return nil, err
-	}
-	b := &SignedBeaconBlock{
-		version:   version.Altair,
-		block:     block,
-		signature: pb.Signature,
-	}
-	return b, nil
-}
-
-func initSignedBlockFromProtoBellatrix(pb *eth.SignedBeaconBlockBellatrix) (*SignedBeaconBlock, error) {
-	if pb == nil {
-		return nil, errNilBlock
-	}
-
-	block, err := initBlockFromProtoBellatrix(pb.Block)
-	if err != nil {
-		return nil, err
-	}
-	b := &SignedBeaconBlock{
-		version:   version.Bellatrix,
-		block:     block,
-		signature: pb.Signature,
-	}
-	return b, nil
-}
-
-func initBlindedSignedBlockFromProtoBellatrix(pb *eth.SignedBlindedBeaconBlockBellatrix) (*SignedBeaconBlock, error) {
-	if pb == nil {
-		return nil, errNilBlock
-	}
-
-	block, err := initBlindedBlockFromProtoBellatrix(pb.Block)
-	if err != nil {
-		return nil, err
-	}
-	b := &SignedBeaconBlock{
-		version:   version.BellatrixBlind,
-		block:     block,
-		signature: pb.Signature,
-	}
-	return b, nil
-}
-
-func initBlockFromProtoPhase0(pb *eth.BeaconBlock) (*BeaconBlock, error) {
-	if pb == nil {
-		return nil, errNilBlock
-	}
-
-	body, err := initBlockBodyFromProtoPhase0(pb.Body)
-	if err != nil {
-		return nil, err
-	}
-	b := &BeaconBlock{
-		version:       version.Phase0,
-		slot:          pb.Slot,
-		proposerIndex: pb.ProposerIndex,
-		parentRoot:    pb.ParentRoot,
-		stateRoot:     pb.StateRoot,
-		body:          body,
-	}
-	return b, nil
-}
-
-func initBlockFromProtoAltair(pb *eth.BeaconBlockAltair) (*BeaconBlock, error) {
-	if pb == nil {
-		return nil, errNilBlock
-	}
-
-	body, err := initBlockBodyFromProtoAltair(pb.Body)
-	if err != nil {
-		return nil, err
-	}
-	b := &BeaconBlock{
-		version:       version.Altair,
-		slot:          pb.Slot,
-		proposerIndex: pb.ProposerIndex,
-		parentRoot:    pb.ParentRoot,
-		stateRoot:     pb.StateRoot,
-		body:          body,
-	}
-	return b, nil
-}
-
-func initBlockFromProtoBellatrix(pb *eth.BeaconBlockBellatrix) (*BeaconBlock, error) {
-	if pb == nil {
-		return nil, errNilBlock
-	}
-
-	body, err := initBlockBodyFromProtoBellatrix(pb.Body)
-	if err != nil {
-		return nil, err
-	}
-	b := &BeaconBlock{
-		version:       version.Bellatrix,
-		slot:          pb.Slot,
-		proposerIndex: pb.ProposerIndex,
-		parentRoot:    pb.ParentRoot,
-		stateRoot:     pb.StateRoot,
-		body:          body,
-	}
-	return b, nil
-}
-
-func initBlindedBlockFromProtoBellatrix(pb *eth.BlindedBeaconBlockBellatrix) (*BeaconBlock, error) {
-	if pb == nil {
-		return nil, errNilBlock
-	}
-
-	body, err := initBlindedBlockBodyFromProtoBellatrix(pb.Body)
-	if err != nil {
-		return nil, err
-	}
-	b := &BeaconBlock{
-		version:       version.BellatrixBlind,
-		slot:          pb.Slot,
-		proposerIndex: pb.ProposerIndex,
-		parentRoot:    pb.ParentRoot,
-		stateRoot:     pb.StateRoot,
-		body:          body,
-	}
-	return b, nil
-}
-
-func initBlockBodyFromProtoPhase0(pb *eth.BeaconBlockBody) (*BeaconBlockBody, error) {
-	if pb == nil {
-		return nil, errNilBody
-	}
-
-	b := &BeaconBlockBody{
-		version:           version.Phase0,
-		randaoReveal:      pb.RandaoReveal,
-		eth1Data:          pb.Eth1Data,
-		graffiti:          pb.Graffiti,
-		proposerSlashings: pb.ProposerSlashings,
-		attesterSlashings: pb.AttesterSlashings,
-		attestations:      pb.Attestations,
-		deposits:          pb.Deposits,
-		voluntaryExits:    pb.VoluntaryExits,
-	}
-	return b, nil
-}
-
-func initBlockBodyFromProtoAltair(pb *eth.BeaconBlockBodyAltair) (*BeaconBlockBody, error) {
-	if pb == nil {
-		return nil, errNilBody
-	}
-
-	b := &BeaconBlockBody{
-		version:           version.Altair,
-		randaoReveal:      pb.RandaoReveal,
-		eth1Data:          pb.Eth1Data,
-		graffiti:          pb.Graffiti,
-		proposerSlashings: pb.ProposerSlashings,
-		attesterSlashings: pb.AttesterSlashings,
-		attestations:      pb.Attestations,
-		deposits:          pb.Deposits,
-		voluntaryExits:    pb.VoluntaryExits,
-		syncAggregate:     pb.SyncAggregate,
-	}
-	return b, nil
-}
-
-func initBlockBodyFromProtoBellatrix(pb *eth.BeaconBlockBodyBellatrix) (*BeaconBlockBody, error) {
-	if pb == nil {
-		return nil, errNilBody
-	}
-
-	b := &BeaconBlockBody{
-		version:           version.Bellatrix,
-		randaoReveal:      pb.RandaoReveal,
-		eth1Data:          pb.Eth1Data,
-		graffiti:          pb.Graffiti,
-		proposerSlashings: pb.ProposerSlashings,
-		attesterSlashings: pb.AttesterSlashings,
-		attestations:      pb.Attestations,
-		deposits:          pb.Deposits,
-		voluntaryExits:    pb.VoluntaryExits,
-		syncAggregate:     pb.SyncAggregate,
-		executionPayload:  pb.ExecutionPayload,
-	}
-	return b, nil
-}
-
-func initBlindedBlockBodyFromProtoBellatrix(pb *eth.BlindedBeaconBlockBodyBellatrix) (*BeaconBlockBody, error) {
-	if pb == nil {
-		return nil, errNilBody
-	}
-
-	b := &BeaconBlockBody{
-		version:                version.BellatrixBlind,
-		randaoReveal:           pb.RandaoReveal,
-		eth1Data:               pb.Eth1Data,
-		graffiti:               pb.Graffiti,
-		proposerSlashings:      pb.ProposerSlashings,
-		attesterSlashings:      pb.AttesterSlashings,
-		attestations:           pb.Attestations,
-		deposits:               pb.Deposits,
-		voluntaryExits:         pb.VoluntaryExits,
-		syncAggregate:          pb.SyncAggregate,
-		executionPayloadHeader: pb.ExecutionPayloadHeader,
-	}
-	return b, nil
-}

consensus-types/blocks/proto_test.go

@@ -1,871 +0,0 @@
-package blocks
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/go-bitfield"
-	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-type fields struct {
-	b20               []byte
-	b32               []byte
-	b48               []byte
-	b96               []byte
-	b256              []byte
-	deposits          []*eth.Deposit
-	atts              []*eth.Attestation
-	proposerSlashings []*eth.ProposerSlashing
-	attesterSlashings []*eth.AttesterSlashing
-	voluntaryExits    []*eth.SignedVoluntaryExit
-	syncAggregate     *eth.SyncAggregate
-	execPayload       *enginev1.ExecutionPayload
-	execPayloadHeader *eth.ExecutionPayloadHeader
-}
-
-func Test_SignedBeaconBlock_Proto(t *testing.T) {
-	f := getFields()
-
-	t.Run("Phase0", func(t *testing.T) {
-		expectedBlock := &eth.SignedBeaconBlock{
-			Block: &eth.BeaconBlock{
-				Slot:          128,
-				ProposerIndex: 128,
-				ParentRoot:    f.b32,
-				StateRoot:     f.b32,
-				Body:          bodyPbPhase0(),
-			},
-			Signature: f.b96,
-		}
-		block := &SignedBeaconBlock{
-			version: version.Phase0,
-			block: &BeaconBlock{
-				version:       version.Phase0,
-				slot:          128,
-				proposerIndex: 128,
-				parentRoot:    f.b32,
-				stateRoot:     f.b32,
-				body:          bodyPhase0(),
-			},
-			signature: f.b96,
-		}
-
-		result, err := block.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.SignedBeaconBlock)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBlock.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-	t.Run("Altair", func(t *testing.T) {
-		expectedBlock := &eth.SignedBeaconBlockAltair{
-			Block: &eth.BeaconBlockAltair{
-				Slot:          128,
-				ProposerIndex: 128,
-				ParentRoot:    f.b32,
-				StateRoot:     f.b32,
-				Body:          bodyPbAltair(),
-			},
-			Signature: f.b96,
-		}
-		block := &SignedBeaconBlock{
-			version: version.Altair,
-			block: &BeaconBlock{
-				version:       version.Altair,
-				slot:          128,
-				proposerIndex: 128,
-				parentRoot:    f.b32,
-				stateRoot:     f.b32,
-				body:          bodyAltair(),
-			},
-			signature: f.b96,
-		}
-
-		result, err := block.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.SignedBeaconBlockAltair)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBlock.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-	t.Run("Bellatrix", func(t *testing.T) {
-		expectedBlock := &eth.SignedBeaconBlockBellatrix{
-			Block: &eth.BeaconBlockBellatrix{
-				Slot:          128,
-				ProposerIndex: 128,
-				ParentRoot:    f.b32,
-				StateRoot:     f.b32,
-				Body:          bodyPbBellatrix(),
-			},
-			Signature: f.b96,
-		}
-		block := &SignedBeaconBlock{
-			version: version.Bellatrix,
-			block: &BeaconBlock{
-				version:       version.Bellatrix,
-				slot:          128,
-				proposerIndex: 128,
-				parentRoot:    f.b32,
-				stateRoot:     f.b32,
-				body:          bodyBellatrix(),
-			},
-			signature: f.b96,
-		}
-
-		result, err := block.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.SignedBeaconBlockBellatrix)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBlock.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-	t.Run("BellatrixBlind", func(t *testing.T) {
-		expectedBlock := &eth.SignedBlindedBeaconBlockBellatrix{
-			Block: &eth.BlindedBeaconBlockBellatrix{
-				Slot:          128,
-				ProposerIndex: 128,
-				ParentRoot:    f.b32,
-				StateRoot:     f.b32,
-				Body:          bodyPbBlindedBellatrix(),
-			},
-			Signature: f.b96,
-		}
-		block := &SignedBeaconBlock{
-			version: version.BellatrixBlind,
-			block: &BeaconBlock{
-				version:       version.BellatrixBlind,
-				slot:          128,
-				proposerIndex: 128,
-				parentRoot:    f.b32,
-				stateRoot:     f.b32,
-				body:          bodyBlindedBellatrix(),
-			},
-			signature: f.b96,
-		}
-
-		result, err := block.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.SignedBlindedBeaconBlockBellatrix)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBlock.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-}
-
-func Test_BeaconBlock_Proto(t *testing.T) {
-	f := getFields()
-
-	t.Run("Phase0", func(t *testing.T) {
-		expectedBlock := &eth.BeaconBlock{
-			Slot:          128,
-			ProposerIndex: 128,
-			ParentRoot:    f.b32,
-			StateRoot:     f.b32,
-			Body:          bodyPbPhase0(),
-		}
-		block := &BeaconBlock{
-			version:       version.Phase0,
-			slot:          128,
-			proposerIndex: 128,
-			parentRoot:    f.b32,
-			stateRoot:     f.b32,
-			body:          bodyPhase0(),
-		}
-
-		result, err := block.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.BeaconBlock)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBlock.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-	t.Run("Altair", func(t *testing.T) {
-		expectedBlock := &eth.BeaconBlockAltair{
-			Slot:          128,
-			ProposerIndex: 128,
-			ParentRoot:    f.b32,
-			StateRoot:     f.b32,
-			Body:          bodyPbAltair(),
-		}
-		block := &BeaconBlock{
-			version:       version.Altair,
-			slot:          128,
-			proposerIndex: 128,
-			parentRoot:    f.b32,
-			stateRoot:     f.b32,
-			body:          bodyAltair(),
-		}
-
-		result, err := block.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.BeaconBlockAltair)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBlock.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-	t.Run("Bellatrix", func(t *testing.T) {
-		expectedBlock := &eth.BeaconBlockBellatrix{
-			Slot:          128,
-			ProposerIndex: 128,
-			ParentRoot:    f.b32,
-			StateRoot:     f.b32,
-			Body:          bodyPbBellatrix(),
-		}
-		block := &BeaconBlock{
-			version:       version.Bellatrix,
-			slot:          128,
-			proposerIndex: 128,
-			parentRoot:    f.b32,
-			stateRoot:     f.b32,
-			body:          bodyBellatrix(),
-		}
-
-		result, err := block.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.BeaconBlockBellatrix)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBlock.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-	t.Run("BellatrixBlind", func(t *testing.T) {
-		expectedBlock := &eth.BlindedBeaconBlockBellatrix{
-			Slot:          128,
-			ProposerIndex: 128,
-			ParentRoot:    f.b32,
-			StateRoot:     f.b32,
-			Body:          bodyPbBlindedBellatrix(),
-		}
-		block := &BeaconBlock{
-			version:       version.BellatrixBlind,
-			slot:          128,
-			proposerIndex: 128,
-			parentRoot:    f.b32,
-			stateRoot:     f.b32,
-			body:          bodyBlindedBellatrix(),
-		}
-
-		result, err := block.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.BlindedBeaconBlockBellatrix)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBlock.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-}
-
-func Test_BeaconBlockBody_Proto(t *testing.T) {
-	t.Run("Phase0", func(t *testing.T) {
-		expectedBody := bodyPbPhase0()
-		body := bodyPhase0()
-
-		result, err := body.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.BeaconBlockBody)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBody.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-	t.Run("Altair", func(t *testing.T) {
-		expectedBody := bodyPbAltair()
-		body := bodyAltair()
-		result, err := body.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.BeaconBlockBodyAltair)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBody.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-	t.Run("Bellatrix", func(t *testing.T) {
-		expectedBody := bodyPbBellatrix()
-		body := bodyBellatrix()
-		result, err := body.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.BeaconBlockBodyBellatrix)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBody.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-	t.Run("BellatrixBlind", func(t *testing.T) {
-		expectedBody := bodyPbBlindedBellatrix()
-		body := bodyBlindedBellatrix()
-		result, err := body.Proto()
-		require.NoError(t, err)
-		resultBlock, ok := result.(*eth.BlindedBeaconBlockBodyBellatrix)
-		require.Equal(t, true, ok)
-		resultHTR, err := resultBlock.HashTreeRoot()
-		require.NoError(t, err)
-		expectedHTR, err := expectedBody.HashTreeRoot()
-		require.NoError(t, err)
-		assert.DeepEqual(t, expectedHTR, resultHTR)
-	})
-}
-
-func Test_initSignedBlockFromProtoPhase0(t *testing.T) {
-	f := getFields()
-	expectedBlock := &eth.SignedBeaconBlock{
-		Block: &eth.BeaconBlock{
-			Slot:          128,
-			ProposerIndex: 128,
-			ParentRoot:    f.b32,
-			StateRoot:     f.b32,
-			Body:          bodyPbPhase0(),
-		},
-		Signature: f.b96,
-	}
-	resultBlock, err := initSignedBlockFromProtoPhase0(expectedBlock)
-	require.NoError(t, err)
-	resultHTR, err := resultBlock.block.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-	assert.DeepEqual(t, expectedBlock.Signature, resultBlock.signature)
-}
-
-func Test_initSignedBlockFromProtoAltair(t *testing.T) {
-	f := getFields()
-	expectedBlock := &eth.SignedBeaconBlockAltair{
-		Block: &eth.BeaconBlockAltair{
-			Slot:          128,
-			ProposerIndex: 128,
-			ParentRoot:    f.b32,
-			StateRoot:     f.b32,
-			Body:          bodyPbAltair(),
-		},
-		Signature: f.b96,
-	}
-	resultBlock, err := initSignedBlockFromProtoAltair(expectedBlock)
-	require.NoError(t, err)
-	resultHTR, err := resultBlock.block.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-	assert.DeepEqual(t, expectedBlock.Signature, resultBlock.signature)
-}
-
-func Test_initSignedBlockFromProtoBellatrix(t *testing.T) {
-	f := getFields()
-	expectedBlock := &eth.SignedBeaconBlockBellatrix{
-		Block: &eth.BeaconBlockBellatrix{
-			Slot:          128,
-			ProposerIndex: 128,
-			ParentRoot:    f.b32,
-			StateRoot:     f.b32,
-			Body:          bodyPbBellatrix(),
-		},
-		Signature: f.b96,
-	}
-	resultBlock, err := initSignedBlockFromProtoBellatrix(expectedBlock)
-	require.NoError(t, err)
-	resultHTR, err := resultBlock.block.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-	assert.DeepEqual(t, expectedBlock.Signature, resultBlock.signature)
-}
-
-func Test_initBlindedSignedBlockFromProtoBellatrix(t *testing.T) {
-	f := getFields()
-	expectedBlock := &eth.SignedBlindedBeaconBlockBellatrix{
-		Block: &eth.BlindedBeaconBlockBellatrix{
-			Slot:          128,
-			ProposerIndex: 128,
-			ParentRoot:    f.b32,
-			StateRoot:     f.b32,
-			Body:          bodyPbBlindedBellatrix(),
-		},
-		Signature: f.b96,
-	}
-	resultBlock, err := initBlindedSignedBlockFromProtoBellatrix(expectedBlock)
-	require.NoError(t, err)
-	resultHTR, err := resultBlock.block.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-	assert.DeepEqual(t, expectedBlock.Signature, resultBlock.signature)
-}
-
-func Test_initBlockFromProtoPhase0(t *testing.T) {
-	f := getFields()
-	expectedBlock := &eth.BeaconBlock{
-		Slot:          128,
-		ProposerIndex: 128,
-		ParentRoot:    f.b32,
-		StateRoot:     f.b32,
-		Body:          bodyPbPhase0(),
-	}
-	resultBlock, err := initBlockFromProtoPhase0(expectedBlock)
-	require.NoError(t, err)
-	resultHTR, err := resultBlock.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBlock.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-}
-
-func Test_initBlockFromProtoAltair(t *testing.T) {
-	f := getFields()
-	expectedBlock := &eth.BeaconBlockAltair{
-		Slot:          128,
-		ProposerIndex: 128,
-		ParentRoot:    f.b32,
-		StateRoot:     f.b32,
-		Body:          bodyPbAltair(),
-	}
-	resultBlock, err := initBlockFromProtoAltair(expectedBlock)
-	require.NoError(t, err)
-	resultHTR, err := resultBlock.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBlock.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-}
-
-func Test_initBlockFromProtoBellatrix(t *testing.T) {
-	f := getFields()
-	expectedBlock := &eth.BeaconBlockBellatrix{
-		Slot:          128,
-		ProposerIndex: 128,
-		ParentRoot:    f.b32,
-		StateRoot:     f.b32,
-		Body:          bodyPbBellatrix(),
-	}
-	resultBlock, err := initBlockFromProtoBellatrix(expectedBlock)
-	require.NoError(t, err)
-	resultHTR, err := resultBlock.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBlock.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-}
-
-func Test_initBlockFromProtoBlindedBellatrix(t *testing.T) {
-	f := getFields()
-	expectedBlock := &eth.BlindedBeaconBlockBellatrix{
-		Slot:          128,
-		ProposerIndex: 128,
-		ParentRoot:    f.b32,
-		StateRoot:     f.b32,
-		Body:          bodyPbBlindedBellatrix(),
-	}
-	resultBlock, err := initBlindedBlockFromProtoBellatrix(expectedBlock)
-	require.NoError(t, err)
-	resultHTR, err := resultBlock.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBlock.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-}
-
-func Test_initBlockBodyFromProtoPhase0(t *testing.T) {
-	expectedBody := bodyPbPhase0()
-	resultBody, err := initBlockBodyFromProtoPhase0(expectedBody)
-	require.NoError(t, err)
-	resultHTR, err := resultBody.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBody.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-}
-
-func Test_initBlockBodyFromProtoAltair(t *testing.T) {
-	expectedBody := bodyPbAltair()
-	resultBody, err := initBlockBodyFromProtoAltair(expectedBody)
-	require.NoError(t, err)
-	resultHTR, err := resultBody.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBody.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-}
-
-func Test_initBlockBodyFromProtoBellatrix(t *testing.T) {
-	expectedBody := bodyPbBellatrix()
-	resultBody, err := initBlockBodyFromProtoBellatrix(expectedBody)
-	require.NoError(t, err)
-	resultHTR, err := resultBody.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBody.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-}
-
-func Test_initBlockBodyFromProtoBlindedBellatrix(t *testing.T) {
-	expectedBody := bodyPbBlindedBellatrix()
-	resultBody, err := initBlindedBlockBodyFromProtoBellatrix(expectedBody)
-	require.NoError(t, err)
-	resultHTR, err := resultBody.HashTreeRoot()
-	require.NoError(t, err)
-	expectedHTR, err := expectedBody.HashTreeRoot()
-	require.NoError(t, err)
-	assert.DeepEqual(t, expectedHTR, resultHTR)
-}
-
-func bodyPbPhase0() *eth.BeaconBlockBody {
-	f := getFields()
-	return &eth.BeaconBlockBody{
-		RandaoReveal: f.b96,
-		Eth1Data: &eth.Eth1Data{
-			DepositRoot:  f.b32,
-			DepositCount: 128,
-			BlockHash:    f.b32,
-		},
-		Graffiti:          f.b32,
-		ProposerSlashings: f.proposerSlashings,
-		AttesterSlashings: f.attesterSlashings,
-		Attestations:      f.atts,
-		Deposits:          f.deposits,
-		VoluntaryExits:    f.voluntaryExits,
-	}
-}
-
-func bodyPbAltair() *eth.BeaconBlockBodyAltair {
-	f := getFields()
-	return &eth.BeaconBlockBodyAltair{
-		RandaoReveal: f.b96,
-		Eth1Data: &eth.Eth1Data{
-			DepositRoot:  f.b32,
-			DepositCount: 128,
-			BlockHash:    f.b32,
-		},
-		Graffiti:          f.b32,
-		ProposerSlashings: f.proposerSlashings,
-		AttesterSlashings: f.attesterSlashings,
-		Attestations:      f.atts,
-		Deposits:          f.deposits,
-		VoluntaryExits:    f.voluntaryExits,
-		SyncAggregate:     f.syncAggregate,
-	}
-}
-
-func bodyPbBellatrix() *eth.BeaconBlockBodyBellatrix {
-	f := getFields()
-	return &eth.BeaconBlockBodyBellatrix{
-		RandaoReveal: f.b96,
-		Eth1Data: &eth.Eth1Data{
-			DepositRoot:  f.b32,
-			DepositCount: 128,
-			BlockHash:    f.b32,
-		},
-		Graffiti:          f.b32,
-		ProposerSlashings: f.proposerSlashings,
-		AttesterSlashings: f.attesterSlashings,
-		Attestations:      f.atts,
-		Deposits:          f.deposits,
-		VoluntaryExits:    f.voluntaryExits,
-		SyncAggregate:     f.syncAggregate,
-		ExecutionPayload:  f.execPayload,
-	}
-}
-
-func bodyPbBlindedBellatrix() *eth.BlindedBeaconBlockBodyBellatrix {
-	f := getFields()
-	return &eth.BlindedBeaconBlockBodyBellatrix{
-		RandaoReveal: f.b96,
-		Eth1Data: &eth.Eth1Data{
-			DepositRoot:  f.b32,
-			DepositCount: 128,
-			BlockHash:    f.b32,
-		},
-		Graffiti:               f.b32,
-		ProposerSlashings:      f.proposerSlashings,
-		AttesterSlashings:      f.attesterSlashings,
-		Attestations:           f.atts,
-		Deposits:               f.deposits,
-		VoluntaryExits:         f.voluntaryExits,
-		SyncAggregate:          f.syncAggregate,
-		ExecutionPayloadHeader: f.execPayloadHeader,
-	}
-}
-
-func bodyPhase0() *BeaconBlockBody {
-	f := getFields()
-	return &BeaconBlockBody{
-		version:      version.Phase0,
-		randaoReveal: f.b96,
-		eth1Data: &eth.Eth1Data{
-			DepositRoot:  f.b32,
-			DepositCount: 128,
-			BlockHash:    f.b32,
-		},
-		graffiti:          f.b32,
-		proposerSlashings: f.proposerSlashings,
-		attesterSlashings: f.attesterSlashings,
-		attestations:      f.atts,
-		deposits:          f.deposits,
-		voluntaryExits:    f.voluntaryExits,
-	}
-}
-
-func bodyAltair() *BeaconBlockBody {
-	f := getFields()
-	return &BeaconBlockBody{
-		version:      version.Altair,
-		randaoReveal: f.b96,
-		eth1Data: &eth.Eth1Data{
-			DepositRoot:  f.b32,
-			DepositCount: 128,
-			BlockHash:    f.b32,
-		},
-		graffiti:          f.b32,
-		proposerSlashings: f.proposerSlashings,
-		attesterSlashings: f.attesterSlashings,
-		attestations:      f.atts,
-		deposits:          f.deposits,
-		voluntaryExits:    f.voluntaryExits,
-		syncAggregate:     f.syncAggregate,
-	}
-}
-
-func bodyBellatrix() *BeaconBlockBody {
-	f := getFields()
-	return &BeaconBlockBody{
-		version:      version.Bellatrix,
-		randaoReveal: f.b96,
-		eth1Data: &eth.Eth1Data{
-			DepositRoot:  f.b32,
-			DepositCount: 128,
-			BlockHash:    f.b32,
-		},
-		graffiti:          f.b32,
-		proposerSlashings: f.proposerSlashings,
-		attesterSlashings: f.attesterSlashings,
-		attestations:      f.atts,
-		deposits:          f.deposits,
-		voluntaryExits:    f.voluntaryExits,
-		syncAggregate:     f.syncAggregate,
-		executionPayload:  f.execPayload,
-	}
-}
-
-func bodyBlindedBellatrix() *BeaconBlockBody {
-	f := getFields()
-	return &BeaconBlockBody{
-		version:      version.BellatrixBlind,
-		randaoReveal: f.b96,
-		eth1Data: &eth.Eth1Data{
-			DepositRoot:  f.b32,
-			DepositCount: 128,
-			BlockHash:    f.b32,
-		},
-		graffiti:               f.b32,
-		proposerSlashings:      f.proposerSlashings,
-		attesterSlashings:      f.attesterSlashings,
-		attestations:           f.atts,
-		deposits:               f.deposits,
-		voluntaryExits:         f.voluntaryExits,
-		syncAggregate:          f.syncAggregate,
-		executionPayloadHeader: f.execPayloadHeader,
-	}
-}
-
-func getFields() fields {
-	b20 := make([]byte, 20)
-	b32 := make([]byte, 32)
-	b48 := make([]byte, 48)
-	b96 := make([]byte, 96)
-	b256 := make([]byte, 256)
-	b20[0], b20[5], b20[10] = 'q', 'u', 'x'
-	b32[0], b32[5], b32[10] = 'f', 'o', 'o'
-	b48[0], b48[5], b48[10] = 'b', 'a', 'r'
-	b96[0], b96[5], b96[10] = 'b', 'a', 'z'
-	b256[0], b256[5], b256[10] = 'x', 'y', 'z'
-	deposits := make([]*eth.Deposit, 16)
-	for i := range deposits {
-		deposits[i] = &eth.Deposit{}
-		deposits[i].Proof = make([][]byte, 33)
-		for j := range deposits[i].Proof {
-			deposits[i].Proof[j] = b32
-		}
-		deposits[i].Data = &eth.Deposit_Data{
-			PublicKey:             b48,
-			WithdrawalCredentials: b32,
-			Amount:                128,
-			Signature:             b96,
-		}
-	}
-	atts := make([]*eth.Attestation, 128)
-	for i := range atts {
-		atts[i] = &eth.Attestation{}
-		atts[i].Signature = b96
-		atts[i].AggregationBits = bitfield.NewBitlist(1)
-		atts[i].Data = &eth.AttestationData{
-			Slot:            128,
-			CommitteeIndex:  128,
-			BeaconBlockRoot: b32,
-			Source: &eth.Checkpoint{
-				Epoch: 128,
-				Root:  b32,
-			},
-			Target: &eth.Checkpoint{
-				Epoch: 128,
-				Root:  b32,
-			},
-		}
-	}
-	proposerSlashing := &eth.ProposerSlashing{
-		Header_1: &eth.SignedBeaconBlockHeader{
-			Header: &eth.BeaconBlockHeader{
-				Slot:          128,
-				ProposerIndex: 128,
-				ParentRoot:    b32,
-				StateRoot:     b32,
-				BodyRoot:      b32,
-			},
-			Signature: b96,
-		},
-		Header_2: &eth.SignedBeaconBlockHeader{
-			Header: &eth.BeaconBlockHeader{
-				Slot:          128,
-				ProposerIndex: 128,
-				ParentRoot:    b32,
-				StateRoot:     b32,
-				BodyRoot:      b32,
-			},
-			Signature: b96,
-		},
-	}
-	attesterSlashing := &eth.AttesterSlashing{
-		Attestation_1: &eth.IndexedAttestation{
-			AttestingIndices: []uint64{1, 2, 8},
-			Data: &eth.AttestationData{
-				Slot:            128,
-				CommitteeIndex:  128,
-				BeaconBlockRoot: b32,
-				Source: &eth.Checkpoint{
-					Epoch: 128,
-					Root:  b32,
-				},
-				Target: &eth.Checkpoint{
-					Epoch: 128,
-					Root:  b32,
-				},
-			},
-			Signature: b96,
-		},
-		Attestation_2: &eth.IndexedAttestation{
-			AttestingIndices: []uint64{1, 2, 8},
-			Data: &eth.AttestationData{
-				Slot:            128,
-				CommitteeIndex:  128,
-				BeaconBlockRoot: b32,
-				Source: &eth.Checkpoint{
-					Epoch: 128,
-					Root:  b32,
-				},
-				Target: &eth.Checkpoint{
-					Epoch: 128,
-					Root:  b32,
-				},
-			},
-			Signature: b96,
-		},
-	}
-	voluntaryExit := &eth.SignedVoluntaryExit{
-		Exit: &eth.VoluntaryExit{
-			Epoch:          128,
-			ValidatorIndex: 128,
-		},
-		Signature: b96,
-	}
-	syncCommitteeBits := bitfield.NewBitvector512()
-	syncCommitteeBits.SetBitAt(1, true)
-	syncCommitteeBits.SetBitAt(2, true)
-	syncCommitteeBits.SetBitAt(8, true)
-	syncAggregate := &eth.SyncAggregate{
-		SyncCommitteeBits:      syncCommitteeBits,
-		SyncCommitteeSignature: b96,
-	}
-	execPayload := &enginev1.ExecutionPayload{
-		ParentHash:    b32,
-		FeeRecipient:  b20,
-		StateRoot:     b32,
-		ReceiptsRoot:  b32,
-		LogsBloom:     b256,
-		PrevRandao:    b32,
-		BlockNumber:   128,
-		GasLimit:      128,
-		GasUsed:       128,
-		Timestamp:     128,
-		ExtraData:     b32,
-		BaseFeePerGas: b32,
-		BlockHash:     b32,
-		Transactions: [][]byte{
-			[]byte("transaction1"),
-			[]byte("transaction2"),
-			[]byte("transaction8"),
-		},
-	}
-	execPayloadHeader := &eth.ExecutionPayloadHeader{
-		ParentHash:       b32,
-		FeeRecipient:     b20,
-		StateRoot:        b32,
-		ReceiptsRoot:     b32,
-		LogsBloom:        b256,
-		PrevRandao:       b32,
-		BlockNumber:      128,
-		GasLimit:         128,
-		GasUsed:          128,
-		Timestamp:        128,
-		ExtraData:        b32,
-		BaseFeePerGas:    b32,
-		BlockHash:        b32,
-		TransactionsRoot: b32,
-	}
-
-	return fields{
-		b20:               b20,
-		b32:               b32,
-		b48:               b48,
-		b96:               b96,
-		b256:              b256,
-		deposits:          deposits,
-		atts:              atts,
-		proposerSlashings: []*eth.ProposerSlashing{proposerSlashing},
-		attesterSlashings: []*eth.AttesterSlashing{attesterSlashing},
-		voluntaryExits:    []*eth.SignedVoluntaryExit{voluntaryExit},
-		syncAggregate:     syncAggregate,
-		execPayload:       execPayload,
-		execPayloadHeader: execPayloadHeader,
-	}
-}

consensus-types/blocks/testing/BUILD.bazel

@@ -1,20 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    testonly = True,
-    srcs = [
-        "factory.go",
-        "mutator.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/consensus-types/blocks/testing",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)

consensus-types/blocks/testing/factory.go

@@ -1,27 +0,0 @@
-package testing
-
-import (
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-)
-
-// NewSignedBeaconBlockFromGeneric creates a signed beacon block
-// from a protobuf generic signed beacon block.
-func NewSignedBeaconBlockFromGeneric(gb *eth.GenericSignedBeaconBlock) (*blocks.SignedBeaconBlock, error) {
-	if gb == nil {
-		return nil, blocks.ErrNilObjectWrapped
-	}
-	switch bb := gb.Block.(type) {
-	case *eth.GenericSignedBeaconBlock_Phase0:
-		return blocks.NewSignedBeaconBlock(bb.Phase0)
-	case *eth.GenericSignedBeaconBlock_Altair:
-		return blocks.NewSignedBeaconBlock(bb.Altair)
-	case *eth.GenericSignedBeaconBlock_Bellatrix:
-		return blocks.NewSignedBeaconBlock(bb.Bellatrix)
-	case *eth.GenericSignedBeaconBlock_BlindedBellatrix:
-		return blocks.NewSignedBeaconBlock(bb.BlindedBellatrix)
-	default:
-		return nil, errors.Wrapf(blocks.ErrUnsupportedSignedBeaconBlock, "unable to create block from type %T", gb)
-	}
-}

consensus-types/blocks/testing/mutator.go

@@ -1,79 +0,0 @@
-package testing
-
-import (
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-)
-
-type blockMutator struct {
-	Phase0    func(beaconBlock *eth.SignedBeaconBlock)
-	Altair    func(beaconBlock *eth.SignedBeaconBlockAltair)
-	Bellatrix func(beaconBlock *eth.SignedBeaconBlockBellatrix)
-}
-
-func (m blockMutator) apply(b interfaces.SignedBeaconBlock) error {
-	switch b.Version() {
-	case version.Phase0:
-		bb, err := b.PbPhase0Block()
-		if err != nil {
-			return err
-		}
-		m.Phase0(bb)
-		return nil
-	case version.Altair:
-		bb, err := b.PbAltairBlock()
-		if err != nil {
-			return err
-		}
-		m.Altair(bb)
-		return nil
-	case version.Bellatrix:
-		bb, err := b.PbBellatrixBlock()
-		if err != nil {
-			return err
-		}
-		m.Bellatrix(bb)
-		return nil
-	default:
-		return blocks.ErrUnsupportedSignedBeaconBlock
-	}
-}
-
-// SetBlockStateRoot modifies the block's state root.
-func SetBlockStateRoot(b interfaces.SignedBeaconBlock, sr [32]byte) error {
-	return blockMutator{
-		Phase0:    func(bb *eth.SignedBeaconBlock) { bb.Block.StateRoot = sr[:] },
-		Altair:    func(bb *eth.SignedBeaconBlockAltair) { bb.Block.StateRoot = sr[:] },
-		Bellatrix: func(bb *eth.SignedBeaconBlockBellatrix) { bb.Block.StateRoot = sr[:] },
-	}.apply(b)
-}
-
-// SetBlockParentRoot modifies the block's parent root.
-func SetBlockParentRoot(b interfaces.SignedBeaconBlock, pr [32]byte) error {
-	return blockMutator{
-		Phase0:    func(bb *eth.SignedBeaconBlock) { bb.Block.ParentRoot = pr[:] },
-		Altair:    func(bb *eth.SignedBeaconBlockAltair) { bb.Block.ParentRoot = pr[:] },
-		Bellatrix: func(bb *eth.SignedBeaconBlockBellatrix) { bb.Block.ParentRoot = pr[:] },
-	}.apply(b)
-}
-
-// SetBlockSlot modifies the block's slot.
-func SetBlockSlot(b interfaces.SignedBeaconBlock, s types.Slot) error {
-	return blockMutator{
-		Phase0:    func(bb *eth.SignedBeaconBlock) { bb.Block.Slot = s },
-		Altair:    func(bb *eth.SignedBeaconBlockAltair) { bb.Block.Slot = s },
-		Bellatrix: func(bb *eth.SignedBeaconBlockBellatrix) { bb.Block.Slot = s },
-	}.apply(b)
-}
-
-// SetProposerIndex modifies the block's proposer index.
-func SetProposerIndex(b interfaces.SignedBeaconBlock, idx types.ValidatorIndex) error {
-	return blockMutator{
-		Phase0:    func(bb *eth.SignedBeaconBlock) { bb.Block.ProposerIndex = idx },
-		Altair:    func(bb *eth.SignedBeaconBlockAltair) { bb.Block.ProposerIndex = idx },
-		Bellatrix: func(bb *eth.SignedBeaconBlockBellatrix) { bb.Block.ProposerIndex = idx },
-	}.apply(b)
-}

consensus-types/blocks/types.go

@@ -1,62 +0,0 @@
-package blocks
-
-import (
-	"fmt"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	engine "github.com/prysmaticlabs/prysm/proto/engine/v1"
-	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-)
-
-const (
-	incorrectBlockVersion = "incorrect beacon block version"
-	incorrectBodyVersion  = "incorrect beacon block body version"
-)
-
-var (
-	// ErrUnsupportedGetter is returned when a getter access is not supported for a specific beacon block version.
-	ErrUnsupportedGetter     = errors.New("unsupported getter")
-	errNilBlock              = errors.New("received nil beacon block")
-	errNilBody               = errors.New("received nil beacon block body")
-	errIncorrectBlockVersion = errors.New(incorrectBlockVersion)
-	errIncorrectBodyVersion  = errors.New(incorrectBodyVersion)
-)
-
-// BeaconBlockBody is the main beacon block body structure. It can represent any block type.
-type BeaconBlockBody struct {
-	version                int
-	randaoReveal           []byte
-	eth1Data               *eth.Eth1Data
-	graffiti               []byte
-	proposerSlashings      []*eth.ProposerSlashing
-	attesterSlashings      []*eth.AttesterSlashing
-	attestations           []*eth.Attestation
-	deposits               []*eth.Deposit
-	voluntaryExits         []*eth.SignedVoluntaryExit
-	syncAggregate          *eth.SyncAggregate
-	executionPayload       *engine.ExecutionPayload
-	executionPayloadHeader *eth.ExecutionPayloadHeader
-}
-
-// BeaconBlock is the main beacon block structure. It can represent any block type.
-type BeaconBlock struct {
-	version       int
-	slot          types.Slot
-	proposerIndex types.ValidatorIndex
-	parentRoot    []byte
-	stateRoot     []byte
-	body          *BeaconBlockBody
-}
-
-// SignedBeaconBlock is the main signed beacon block structure. It can represent any block type.
-type SignedBeaconBlock struct {
-	version   int
-	block     *BeaconBlock
-	signature []byte
-}
-
-func errNotSupported(funcName string, ver int) error {
-	return errors.Wrap(ErrUnsupportedGetter, fmt.Sprintf("%s is not supported for %s", funcName, version.String(ver)))
-}