test changes

Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>

.gitignore

@@ -35,3 +35,6 @@ bin
 
 # p2p metaData
 metaData
+
+# execution API authentication
+jwt.hex

README.md

@@ -2,7 +2,8 @@
 
 [![Build status](https://badge.buildkite.com/b555891daf3614bae4284dcf365b2340cefc0089839526f096.svg?branch=master)](https://buildkite.com/prysmatic-labs/prysm)
 [![Go Report Card](https://goreportcard.com/badge/github.com/prysmaticlabs/prysm)](https://goreportcard.com/report/github.com/prysmaticlabs/prysm)
-[![Consensus_Spec_Version 1.1.10](https://img.shields.io/badge/Consensus%20Spec%20Version-v1.1.10-blue.svg)](https://github.com/ethereum/consensus-specs/tree/v1.1.10)
+[![Consensus_Spec_Version 1.2.0-rc.1](https://img.shields.io/badge/Consensus%20Spec%20Version-v1.2.0.rc.1-blue.svg)](https://github.com/ethereum/consensus-specs/tree/v1.2.0-rc.1)
+[![Execution_API_Version 1.0.0-alpha.9](https://img.shields.io/badge/Execution%20API%20Version-v1.0.0.alpha.9-blue.svg)](https://github.com/ethereum/execution-apis/tree/v1.0.0-alpha.9/src/engine)
 [![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)
 
 This is the core repository for Prysm, a [Golang](https://golang.org/) implementation of the [Ethereum Consensus](https://ethereum.org/en/eth2/) specification, developed by [Prysmatic Labs](https://prysmaticlabs.com). See the [Changelog](https://github.com/prysmaticlabs/prysm/releases) for details of the latest releases and upcoming breaking 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")

api/client/builder/BUILD.bazel

@@ -29,7 +29,7 @@ go_test(
     data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     deps = [
-        "//config/fieldparams:go_default_library",
+        "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",

api/client/builder/client_test.go

@@ -11,7 +11,7 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/go-bitfield"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -98,7 +98,7 @@ func TestClient_RegisterValidator(t *testing.T) {
 	}
 	reg := &eth.SignedValidatorRegistrationV1{
 		Message: &eth.ValidatorRegistrationV1{
-			FeeRecipient: ezDecode(t, fieldparams.EthBurnAddressHex),
+			FeeRecipient: ezDecode(t, params.BeaconConfig().EthBurnAddressHex),
 			GasLimit:     23,
 			Timestamp:    42,
 			Pubkey:       ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),

beacon-chain/blockchain/chain_info_test.go

@@ -337,7 +337,7 @@ func TestService_ChainHeads_ProtoArray(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0)
@@ -349,10 +349,19 @@ func TestService_ChainHeads_ProtoArray(t *testing.T) {
 	require.DeepEqual(t, []types.Slot{102, 103, 104}, slots)
 }
 
+//
+//  A <- B <- C
+//   \    \
+//    \    ---------- E
+//     ---------- D
+
 func TestService_ChainHeads_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 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))
+	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))
 	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0)

beacon-chain/blockchain/execution_engine.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
@@ -20,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"
@@ -142,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()
@@ -154,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 {
@@ -270,10 +270,10 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 	recipient, err := s.cfg.BeaconDB.FeeRecipientByValidatorID(ctx, proposerID)
 	switch {
 	case errors.Is(err, kv.ErrNotFoundFeeRecipient):
-		if feeRecipient.String() == fieldparams.EthBurnAddressHex {
+		if feeRecipient.String() == params.BeaconConfig().EthBurnAddressHex {
 			logrus.WithFields(logrus.Fields{
 				"validatorIndex": proposerID,
-				"burnAddress":    fieldparams.EthBurnAddressHex,
+				"burnAddress":    params.BeaconConfig().EthBurnAddressHex,
 			}).Warn("Fee recipient is currently using the burn address, " +
 				"you will not be rewarded transaction fees on this setting. " +
 				"Please set a different eth address as the fee recipient. " +

beacon-chain/blockchain/execution_engine_test.go

@@ -806,7 +806,7 @@ func Test_GetPayloadAttribute(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, hasPayload)
 	require.Equal(t, suggestedVid, vId)
-	require.Equal(t, fieldparams.EthBurnAddressHex, common.BytesToAddress(attr.SuggestedFeeRecipient).String())
+	require.Equal(t, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(attr.SuggestedFeeRecipient).String())
 	require.LogsContain(t, hook, "Fee recipient is currently using the burn address")
 
 	// Cache hit, advance state, has fee recipient

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

@@ -317,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 {
@@ -378,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))
@@ -459,9 +459,12 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, preState, lastBR); err != nil {
 		return errors.Wrap(err, "could not insert last block in batch to forkchoice")
 	}
-	// Prune forkchoice store
-	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")
+	// 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.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")
+		}
 	}
 
 	// Set their optimistic status
@@ -681,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
 	}
 
@@ -698,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_test.go

@@ -343,6 +343,69 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 	require.Equal(t, types.Epoch(2), service.cfg.ForkChoiceStore.JustifiedEpoch())
 }
 
+func TestStore_OnBlockBatch_PruneOK(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+	}
+	service, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+
+	genesisStateRoot := [32]byte{}
+	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	gRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	service.saveInitSyncBlock(gRoot, wsb)
+
+	st, keys := util.DeterministicGenesisState(t, 64)
+
+	bState := st.Copy()
+
+	var blks []interfaces.SignedBeaconBlock
+	var blkRoots [][32]byte
+	var firstState state.BeaconState
+	for i := 1; i < 128; i++ {
+		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
+		require.NoError(t, err)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		bState, err = transition.ExecuteStateTransition(ctx, bState, wsb)
+		if i == 32 {
+			firstState = bState.Copy()
+		}
+		require.NoError(t, err)
+		root, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		wsb, err = wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		service.saveInitSyncBlock(root, wsb)
+		wsb, err = wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		blks = append(blks, wsb)
+		blkRoots = append(blkRoots, root)
+	}
+
+	for i := 0; i < 32; i++ {
+		require.NoError(t, beaconDB.SaveBlock(context.Background(), blks[i]))
+	}
+	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: blkRoots[31][:], Epoch: 1}, [32]byte{'a'})
+	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: blkRoots[31][:], Epoch: 1}, [32]byte{'b'})
+	require.NoError(t, service.cfg.StateGen.SaveState(ctx, blkRoots[31], firstState))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, firstState, blkRoots[31]))
+	err = service.onBlockBatch(ctx, blks[32:], blkRoots[32:])
+	require.NoError(t, err)
+}
+
 func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)

beacon-chain/blockchain/service.go

@@ -206,7 +206,7 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	s.store = store.New(justified, finalized)
 
 	var forkChoicer f.ForkChoicer
-	fRoot := bytesutil.ToBytes32(finalized.Root)
+	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
 	if features.Get().EnableForkChoiceDoublyLinkedTree {
 		forkChoicer = doublylinkedtree.New(justified.Epoch, finalized.Epoch)
 	} else {

beacon-chain/builder/BUILD.bazel

@@ -3,6 +3,8 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     srcs = [
+        "error.go",
+        "metric.go",
         "option.go",
         "service.go",
     ],
@@ -10,13 +12,19 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//api/client/builder:go_default_library",
+        "//beacon-chain/blockchain:go_default_library",
+        "//beacon-chain/db:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//network:go_default_library",
         "//network/authorization:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )

beacon-chain/builder/error.go

@@ -0,0 +1,7 @@
+package builder
+
+import "github.com/pkg/errors"
+
+var (
+	ErrNotRunning = errors.New("builder is not running")
+)

beacon-chain/builder/metric.go

@@ -0,0 +1,37 @@
+package builder
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+var (
+	submitBlindedBlockLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "submit_blinded_block_latency_milliseconds",
+			Help:    "Captures RPC latency for submitting blinded block in milliseconds",
+			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+		},
+	)
+	getHeaderLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "get_header_latency_milliseconds",
+			Help:    "Captures RPC latency for get header in milliseconds",
+			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+		},
+	)
+	getStatusLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "get_status_latency_milliseconds",
+			Help:    "Captures RPC latency for get status in milliseconds",
+			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+		},
+	)
+	registerValidatorLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "register_validator_latency_milliseconds",
+			Help:    "Captures RPC latency for register validator in milliseconds",
+			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+		},
+	)
+)

beacon-chain/builder/option.go

@@ -1,6 +1,7 @@
 package builder
 
 import (
+	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/network"
 	"github.com/prysmaticlabs/prysm/network/authorization"
@@ -26,6 +27,14 @@ func WithBuilderEndpoints(endpoint string) Option {
 	}
 }
 
+// WithDatabase sets the database for the beacon chain builder service.
+func WithDatabase(database db.HeadAccessDatabase) Option {
+	return func(s *Service) error {
+		s.cfg.beaconDB = database
+		return nil
+	}
+}
+
 func covertEndPoint(ep string) network.Endpoint {
 	return network.Endpoint{
 		Url: ep,

beacon-chain/builder/service.go

@@ -2,26 +2,33 @@ package builder
 
 import (
 	"context"
+	"time"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/api/client/builder"
+	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
+	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/network"
 	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"go.opencensus.io/trace"
 )
 
 // BlockBuilder defines the interface for interacting with the block builder
 type BlockBuilder interface {
 	SubmitBlindedBlock(ctx context.Context, block *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, error)
 	GetHeader(ctx context.Context, slot types.Slot, parentHash [32]byte, pubKey [48]byte) (*ethpb.SignedBuilderBid, error)
-	Status() error
+	Status(ctx context.Context) error
 	RegisterValidator(ctx context.Context, reg *ethpb.SignedValidatorRegistrationV1) error
 }
 
 // config defines a config struct for dependencies into the service.
 type config struct {
 	builderEndpoint network.Endpoint
+	beaconDB        db.HeadAccessDatabase
+	headFetcher     blockchain.HeadFetcher
 }
 
 // Service defines a service that provides a client for interacting with the beacon chain and MEV relay network.
@@ -56,22 +63,59 @@ func (*Service) Stop() error {
 	return nil
 }
 
-// SubmitBlindedBlock is currently a stub.
-func (*Service) SubmitBlindedBlock(context.Context, *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, error) {
-	return nil, errors.New("not implemented")
+// SubmitBlindedBlock submits a blinded block to the builder relay network.
+func (s *Service) SubmitBlindedBlock(ctx context.Context, b *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, error) {
+	ctx, span := trace.StartSpan(ctx, "builder.SubmitBlindedBlock")
+	defer span.End()
+	start := time.Now()
+	defer func() {
+		submitBlindedBlockLatency.Observe(float64(time.Since(start).Milliseconds()))
+	}()
+
+	return s.c.SubmitBlindedBlock(ctx, b)
 }
 
-// GetHeader is currently a stub.
-func (*Service) GetHeader(context.Context, types.Slot, [32]byte, [48]byte) (*ethpb.SignedBuilderBid, error) {
-	return nil, errors.New("not implemented")
+// GetHeader retrieves the header for a given slot and parent hash from the builder relay network.
+func (s *Service) GetHeader(ctx context.Context, slot types.Slot, parentHash [32]byte, pubKey [48]byte) (*ethpb.SignedBuilderBid, error) {
+	ctx, span := trace.StartSpan(ctx, "builder.GetHeader")
+	defer span.End()
+	start := time.Now()
+	defer func() {
+		getHeaderLatency.Observe(float64(time.Since(start).Milliseconds()))
+	}()
+
+	return s.c.GetHeader(ctx, slot, parentHash, pubKey)
 }
 
-// Status is currently a stub.
-func (*Service) Status() error {
-	return errors.New("not implemented")
+// Status retrieves the status of the builder relay network.
+func (s *Service) Status(ctx context.Context) error {
+	ctx, span := trace.StartSpan(ctx, "builder.Status")
+	defer span.End()
+	start := time.Now()
+	defer func() {
+		getStatusLatency.Observe(float64(time.Since(start).Milliseconds()))
+	}()
+
+	return s.c.Status(ctx)
 }
 
-// RegisterValidator is currently a stub.
-func (*Service) RegisterValidator(context.Context, *ethpb.SignedValidatorRegistrationV1) error {
-	return errors.New("not implemented")
+// RegisterValidator registers a validator with the builder relay network.
+// It also saves the registration object to the DB.
+func (s *Service) RegisterValidator(ctx context.Context, reg *ethpb.SignedValidatorRegistrationV1) error {
+	ctx, span := trace.StartSpan(ctx, "builder.RegisterValidator")
+	defer span.End()
+	start := time.Now()
+	defer func() {
+		registerValidatorLatency.Observe(float64(time.Since(start).Milliseconds()))
+	}()
+
+	idx, exists := s.cfg.headFetcher.HeadPublicKeyToValidatorIndex(bytesutil.ToBytes48(reg.Message.Pubkey))
+	if !exists {
+		return nil // If the pubkey is not found, it is not a validator. Do nothing.
+	}
+	if err := s.c.RegisterValidator(ctx, reg); err != nil {
+		return errors.Wrap(err, "could not register validator")
+	}
+
+	return s.cfg.beaconDB.SaveRegistrationsByValidatorIDs(ctx, []types.ValidatorIndex{idx}, []*ethpb.ValidatorRegistrationV1{reg.Message})
 }

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

@@ -12,7 +12,6 @@ import (
 	"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/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"google.golang.org/protobuf/proto"
 )
@@ -77,11 +76,11 @@ func ProcessProposerSlashing(
 	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/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/iface/interface.go

@@ -23,14 +23,14 @@ type ReadOnlyDatabase interface {
 	Block(ctx context.Context, blockRoot [32]byte) (interfaces.SignedBeaconBlock, error)
 	Blocks(ctx context.Context, f *filters.QueryFilter) ([]interfaces.SignedBeaconBlock, [][32]byte, error)
 	BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][32]byte, error)
-	BlocksBySlot(ctx context.Context, slot types.Slot) (bool, []interfaces.SignedBeaconBlock, error)
+	BlocksBySlot(ctx context.Context, slot types.Slot) ([]interfaces.SignedBeaconBlock, error)
 	BlockRootsBySlot(ctx context.Context, slot types.Slot) (bool, [][32]byte, error)
 	HasBlock(ctx context.Context, blockRoot [32]byte) bool
 	GenesisBlock(ctx context.Context) (interfaces.SignedBeaconBlock, error)
 	GenesisBlockRoot(ctx context.Context) ([32]byte, error)
 	IsFinalizedBlock(ctx context.Context, blockRoot [32]byte) bool
 	FinalizedChildBlock(ctx context.Context, blockRoot [32]byte) (interfaces.SignedBeaconBlock, error)
-	HighestSlotBlocksBelow(ctx context.Context, slot types.Slot) ([]interfaces.SignedBeaconBlock, error)
+	HighestRootsBelowSlot(ctx context.Context, slot types.Slot) (types.Slot, [][32]byte, error)
 	// State related methods.
 	State(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
 	StateOrError(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
@@ -86,6 +86,7 @@ type NoHeadAccessDatabase interface {
 	RunMigrations(ctx context.Context) error
 	// Fee reicipients operations.
 	SaveFeeRecipientsByValidatorIDs(ctx context.Context, ids []types.ValidatorIndex, addrs []common.Address) error
+	SaveRegistrationsByValidatorIDs(ctx context.Context, ids []types.ValidatorIndex, regs []*ethpb.ValidatorRegistrationV1) error
 
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint types.Slot) error
 }

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"
@@ -185,17 +184,19 @@ func (s *Store) HasBlock(ctx context.Context, blockRoot [32]byte) bool {
 }
 
 // BlocksBySlot retrieves a list of beacon blocks and its respective roots by slot.
-func (s *Store) BlocksBySlot(ctx context.Context, slot types.Slot) (bool, []interfaces.SignedBeaconBlock, error) {
+func (s *Store) BlocksBySlot(ctx context.Context, slot types.Slot) ([]interfaces.SignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.BlocksBySlot")
 	defer span.End()
-	blocks := make([]interfaces.SignedBeaconBlock, 0)
 
+	blocks := make([]interfaces.SignedBeaconBlock, 0)
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blocksBucket)
-
-		keys := blockRootsBySlot(ctx, tx, slot)
-		for i := 0; i < len(keys); i++ {
-			encoded := bkt.Get(keys[i])
+		roots, err := blockRootsBySlot(ctx, tx, slot)
+		if err != nil {
+			return errors.Wrap(err, "could not retrieve blocks by slot")
+		}
+		for _, r := range roots {
+			encoded := bkt.Get(r[:])
 			blk, err := unmarshalBlock(ctx, encoded)
 			if err != nil {
 				return err
@@ -204,7 +205,7 @@ func (s *Store) BlocksBySlot(ctx context.Context, slot types.Slot) (bool, []inte
 		}
 		return nil
 	})
-	return len(blocks) > 0, blocks, err
+	return blocks, err
 }
 
 // BlockRootsBySlot retrieves a list of beacon block roots by slot
@@ -213,11 +214,9 @@ func (s *Store) BlockRootsBySlot(ctx context.Context, slot types.Slot) (bool, []
 	defer span.End()
 	blockRoots := make([][32]byte, 0)
 	err := s.db.View(func(tx *bolt.Tx) error {
-		keys := blockRootsBySlot(ctx, tx, slot)
-		for i := 0; i < len(keys); i++ {
-			blockRoots = append(blockRoots, bytesutil.ToBytes32(keys[i]))
-		}
-		return nil
+		var err error
+		blockRoots, err = blockRootsBySlot(ctx, tx, slot)
+		return err
 	})
 	if err != nil {
 		return false, nil, errors.Wrap(err, "could not retrieve block roots by slot")
@@ -398,14 +397,17 @@ func (s *Store) SaveBackfillBlockRoot(ctx context.Context, blockRoot [32]byte) e
 	})
 }
 
-// HighestSlotBlocksBelow returns the block with the highest slot below the input slot from the db.
-func (s *Store) HighestSlotBlocksBelow(ctx context.Context, slot types.Slot) ([]interfaces.SignedBeaconBlock, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.HighestSlotBlocksBelow")
+// HighestRootsBelowSlot returns roots from the database slot index from the highest slot below the input slot.
+// The slot value at the beginning of the return list is the slot where the roots were found. This is helpful so that
+// calling code can make decisions based on the slot without resolving the blocks to discover their slot (for instance
+// checking which root is canonical in fork choice, which operates purely on roots,
+// then if no canonical block is found, continuing to search through lower slots).
+func (s *Store) HighestRootsBelowSlot(ctx context.Context, slot types.Slot) (fs types.Slot, roots [][32]byte, err error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.HighestRootsBelowSlot")
 	defer span.End()
 
-	var root [32]byte
 	sk := bytesutil.Uint64ToBytesBigEndian(uint64(slot))
-	err := s.db.View(func(tx *bolt.Tx) error {
+	err = s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blockSlotIndicesBucket)
 		c := bkt.Cursor()
 		// The documentation for Seek says:
@@ -430,34 +432,28 @@ func (s *Store) HighestSlotBlocksBelow(ctx context.Context, slot types.Slot) ([]
 			if r == nil {
 				continue
 			}
-			bs := bytesutil.BytesToSlotBigEndian(sl)
+			fs = bytesutil.BytesToSlotBigEndian(sl)
 			// Iterating through the index using .Prev will move from higher to lower, so the first key we find behind
 			// the requested slot must be the highest block below that slot.
-			if slot > bs {
-				root = bytesutil.ToBytes32(r)
-				break
+			if slot > fs {
+				roots, err = splitRoots(r)
+				if err != nil {
+					return errors.Wrapf(err, "error parsing packed roots %#x", r)
+				}
+				return nil
 			}
 		}
 		return nil
 	})
 	if err != nil {
-		return nil, err
+		return 0, nil, err
+	}
+	if len(roots) == 0 || (len(roots) == 1 && roots[0] == params.BeaconConfig().ZeroHash) {
+		gr, err := s.GenesisBlockRoot(ctx)
+		return 0, [][32]byte{gr}, err
 	}
 
-	var blk interfaces.SignedBeaconBlock
-	if root != params.BeaconConfig().ZeroHash {
-		blk, err = s.Block(ctx, root)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if blk == nil || blk.IsNil() {
-		blk, err = s.GenesisBlock(ctx)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return []interfaces.SignedBeaconBlock{blk}, nil
+	return fs, roots, nil
 }
 
 // FeeRecipientByValidatorID returns the fee recipient for a validator id.
@@ -681,21 +677,22 @@ func blockRootsBySlotRange(
 }
 
 // blockRootsBySlot retrieves the block roots by slot
-func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) [][]byte {
+func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) ([][32]byte, error) {
 	_, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlot")
 	defer span.End()
 
-	roots := make([][]byte, 0)
 	bkt := tx.Bucket(blockSlotIndicesBucket)
 	key := bytesutil.SlotToBytesBigEndian(slot)
 	c := bkt.Cursor()
 	k, v := c.Seek(key)
 	if k != nil && bytes.Equal(k, key) {
-		for i := 0; i < len(v); i += 32 {
-			roots = append(roots, v[i:i+32])
+		r, err := splitRoots(v)
+		if err != nil {
+			return nil, errors.Wrapf(err, "corrupt value in block slot index for slot=%d", slot)
 		}
+		return r, nil
 	}
-	return roots
+	return [][32]byte{}, nil
 }
 
 // createBlockIndicesFromBlock takes in a beacon block and returns
@@ -796,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/blocks_test.go

@@ -517,18 +517,32 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			require.NoError(t, db.SaveBlock(ctx, block2))
 			require.NoError(t, db.SaveBlock(ctx, block3))
 
-			highestAt, err := db.HighestSlotBlocksBelow(ctx, 2)
+			_, roots, err := db.HighestRootsBelowSlot(ctx, 2)
 			require.NoError(t, err)
-			assert.Equal(t, false, len(highestAt) <= 0, "Got empty highest at slice")
-			assert.Equal(t, true, proto.Equal(block1.Proto(), highestAt[0].Proto()), "Wanted: %v, received: %v", block1, highestAt[0])
-			highestAt, err = db.HighestSlotBlocksBelow(ctx, 11)
+			assert.Equal(t, false, len(roots) <= 0, "Got empty highest at slice")
+			require.Equal(t, 1, len(roots))
+			root := roots[0]
+			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
-			assert.Equal(t, false, len(highestAt) <= 0, "Got empty highest at slice")
-			assert.Equal(t, true, proto.Equal(block2.Proto(), highestAt[0].Proto()), "Wanted: %v, received: %v", block2, highestAt[0])
-			highestAt, err = db.HighestSlotBlocksBelow(ctx, 101)
+			assert.Equal(t, true, proto.Equal(block1.Proto(), b.Proto()), "Wanted: %v, received: %v", block1, b)
+
+			_, roots, err = db.HighestRootsBelowSlot(ctx, 11)
 			require.NoError(t, err)
-			assert.Equal(t, false, len(highestAt) <= 0, "Got empty highest at slice")
-			assert.Equal(t, true, proto.Equal(block3.Proto(), highestAt[0].Proto()), "Wanted: %v, received: %v", block3, highestAt[0])
+			assert.Equal(t, false, len(roots) <= 0, "Got empty highest at slice")
+			require.Equal(t, 1, len(roots))
+			root = roots[0]
+			b, err = db.Block(ctx, root)
+			require.NoError(t, err)
+			assert.Equal(t, true, proto.Equal(block2.Proto(), b.Proto()), "Wanted: %v, received: %v", block2, b)
+
+			_, roots, err = db.HighestRootsBelowSlot(ctx, 101)
+			require.NoError(t, err)
+			assert.Equal(t, false, len(roots) <= 0, "Got empty highest at slice")
+			require.Equal(t, 1, len(roots))
+			root = roots[0]
+			b, err = db.Block(ctx, root)
+			require.NoError(t, err)
+			assert.Equal(t, true, proto.Equal(block3.Proto(), b.Proto()), "Wanted: %v, received: %v", block3, b)
 		})
 	}
 }
@@ -549,15 +563,29 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			require.NoError(t, err)
 			require.NoError(t, db.SaveBlock(ctx, block1))
 
-			highestAt, err := db.HighestSlotBlocksBelow(ctx, 2)
+			_, roots, err := db.HighestRootsBelowSlot(ctx, 2)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(block1.Proto(), highestAt[0].Proto()), "Wanted: %v, received: %v", block1, highestAt[0])
-			highestAt, err = db.HighestSlotBlocksBelow(ctx, 1)
+			require.Equal(t, 1, len(roots))
+			root := roots[0]
+			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(genesisBlock.Proto(), highestAt[0].Proto()), "Wanted: %v, received: %v", genesisBlock, highestAt[0])
-			highestAt, err = db.HighestSlotBlocksBelow(ctx, 0)
+			assert.Equal(t, true, proto.Equal(block1.Proto(), b.Proto()), "Wanted: %v, received: %v", block1, b)
+
+			_, roots, err = db.HighestRootsBelowSlot(ctx, 1)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(genesisBlock.Proto(), highestAt[0].Proto()), "Wanted: %v, received: %v", genesisBlock, highestAt[0])
+			require.Equal(t, 1, len(roots))
+			root = roots[0]
+			b, err = db.Block(ctx, root)
+			require.NoError(t, err)
+			assert.Equal(t, true, proto.Equal(genesisBlock.Proto(), b.Proto()), "Wanted: %v, received: %v", genesisBlock, b)
+
+			_, roots, err = db.HighestRootsBelowSlot(ctx, 0)
+			require.NoError(t, err)
+			require.Equal(t, 1, len(roots))
+			root = roots[0]
+			b, err = db.Block(ctx, root)
+			require.NoError(t, err)
+			assert.Equal(t, true, proto.Equal(genesisBlock.Proto(), b.Proto()), "Wanted: %v, received: %v", genesisBlock, b)
 		})
 	}
 }
@@ -638,22 +666,21 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			r3, err := b3.Block().HashTreeRoot()
 			require.NoError(t, err)
 
-			hasBlocks, retrievedBlocks, err := db.BlocksBySlot(ctx, 1)
+			retrievedBlocks, err := db.BlocksBySlot(ctx, 1)
 			require.NoError(t, err)
 			assert.Equal(t, 0, len(retrievedBlocks), "Unexpected number of blocks received, expected none")
-			assert.Equal(t, false, hasBlocks, "Expected no blocks")
-			hasBlocks, retrievedBlocks, err = db.BlocksBySlot(ctx, 20)
+			retrievedBlocks, err = db.BlocksBySlot(ctx, 20)
 			require.NoError(t, err)
 			assert.Equal(t, true, proto.Equal(b1.Proto(), retrievedBlocks[0].Proto()), "Wanted: %v, received: %v", b1, retrievedBlocks[0])
-			assert.Equal(t, true, hasBlocks, "Expected to have blocks")
-			hasBlocks, retrievedBlocks, err = db.BlocksBySlot(ctx, 100)
+			assert.Equal(t, true, len(retrievedBlocks) > 0, "Expected to have blocks")
+			retrievedBlocks, err = db.BlocksBySlot(ctx, 100)
 			require.NoError(t, err)
 			if len(retrievedBlocks) != 2 {
 				t.Fatalf("Expected 2 blocks, received %d blocks", len(retrievedBlocks))
 			}
 			assert.Equal(t, true, proto.Equal(b2.Proto(), retrievedBlocks[0].Proto()), "Wanted: %v, received: %v", b2, retrievedBlocks[0])
 			assert.Equal(t, true, proto.Equal(b3.Proto(), retrievedBlocks[1].Proto()), "Wanted: %v, received: %v", b3, retrievedBlocks[1])
-			assert.Equal(t, true, hasBlocks, "Expected to have blocks")
+			assert.Equal(t, true, len(retrievedBlocks) > 0, "Expected to have blocks")
 
 			hasBlockRoots, retrievedBlockRoots, err := db.BlockRootsBySlot(ctx, 1)
 			require.NoError(t, err)

beacon-chain/db/kv/utils.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"context"
 
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	bolt "go.etcd.io/bbolt"
 	"go.opencensus.io/trace"
 )
@@ -99,3 +101,16 @@ func deleteValueForIndices(ctx context.Context, indicesByBucket map[string][]byt
 	}
 	return nil
 }
+
+var errMisalignedRootList = errors.New("incorrectly packed root list, length is not a multiple of 32")
+
+func splitRoots(b []byte) ([][32]byte, error) {
+	rl := make([][32]byte, 0)
+	if len(b)%32 != 0 {
+		return nil, errors.Wrapf(errMisalignedRootList, "root list len=%d", len(b))
+	}
+	for s, f := 0, 32; f <= len(b); s, f = f, f+32 {
+		rl = append(rl, bytesutil.ToBytes32(b[s:f]))
+	}
+	return rl, nil
+}

beacon-chain/db/kv/utils_test.go

@@ -138,3 +138,60 @@ func Test_deleteValueForIndices(t *testing.T) {
 		})
 	}
 }
+
+func testPack(bs [][32]byte) []byte {
+	r := make([]byte, 0)
+	for _, b := range bs {
+		r = append(r, b[:]...)
+	}
+	return r
+}
+
+func TestSplitRoots(t *testing.T) {
+	bt := make([][32]byte, 0)
+	for _, x := range []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} {
+		var b [32]byte
+		for i := 0; i < 32; i++ {
+			b[i] = x
+		}
+		bt = append(bt, b)
+	}
+	cases := []struct {
+		name   string
+		b      []byte
+		expect [][32]byte
+		err    error
+	}{
+		{
+			name: "misaligned",
+			b:    make([]byte, 61),
+			err:  errMisalignedRootList,
+		},
+		{
+			name:   "happy",
+			b:      testPack(bt[0:5]),
+			expect: bt[0:5],
+		},
+		{
+			name:   "single",
+			b:      testPack([][32]byte{bt[0]}),
+			expect: [][32]byte{bt[0]},
+		},
+		{
+			name:   "empty",
+			b:      []byte{},
+			expect: [][32]byte{},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			r, err := splitRoots(c.b)
+			if c.err != nil {
+				require.ErrorIs(t, err, c.err)
+				return
+			}
+			require.NoError(t, err)
+			require.DeepEqual(t, c.expect, r)
+		})
+	}
+}

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

@@ -435,6 +435,8 @@ func (f *ForkChoice) CommonAncestorRoot(ctx context.Context, r1 [32]byte, r2 [32
 		if n1.slot > n2.slot {
 			n1 = n1.parent
 			// Reaches the end of the tree and unable to find common ancestor.
+			// This should not happen at runtime as the finalized
+			// node has to be a common ancestor
 			if n1 == nil {
 				return [32]byte{}, forkchoice.ErrUnknownCommonAncestor
 			}

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

@@ -535,9 +535,17 @@ func TestStore_CommonAncestor(t *testing.T) {
 	require.ErrorIs(t, err, ErrNilNode)
 	_, err = f.CommonAncestorRoot(ctx, [32]byte{'z'}, [32]byte{'a'})
 	require.ErrorIs(t, err, ErrNilNode)
-	state, blkRoot, err = prepareForkchoiceState(ctx, 100, [32]byte{'y'}, [32]byte{'z'}, [32]byte{}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	n := &Node{
+		slot:                     100,
+		root:                     [32]byte{'y'},
+		justifiedEpoch:           1,
+		unrealizedJustifiedEpoch: 1,
+		finalizedEpoch:           1,
+		unrealizedFinalizedEpoch: 1,
+		optimistic:               true,
+	}
+
+	f.store.nodeByRoot[[32]byte{'y'}] = n
 	// broken link
 	_, err = f.CommonAncestorRoot(ctx, [32]byte{'y'}, [32]byte{'a'})
 	require.ErrorIs(t, err, forkchoice.ErrUnknownCommonAncestor)

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

@@ -125,19 +125,20 @@ func (s *Store) insert(ctx context.Context,
 
 	s.nodeByPayload[payloadHash] = n
 	s.nodeByRoot[root] = n
-	if parent != nil {
+	if parent == nil {
+		if s.treeRootNode == nil {
+			s.treeRootNode = n
+			s.headNode = n
+		} else {
+			return errInvalidParentRoot
+		}
+	} else {
 		parent.children = append(parent.children, n)
 		if err := s.treeRootNode.updateBestDescendant(ctx, s.justifiedEpoch, s.finalizedEpoch); err != nil {
 			return err
 		}
 	}
 
-	// Set the node as root if the store was empty
-	if s.treeRootNode == nil {
-		s.treeRootNode = n
-		s.headNode = n
-	}
-
 	// Update metrics.
 	processedBlockCount.Inc()
 	nodeCount.Set(float64(len(s.nodeByRoot)))

beacon-chain/powchain/metrics.go

@@ -10,21 +10,21 @@ var (
 		prometheus.HistogramOpts{
 			Name:    "new_payload_v1_latency_milliseconds",
 			Help:    "Captures RPC latency for newPayloadV1 in milliseconds",
-			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+			Buckets: []float64{25, 50, 100, 200, 500, 1000, 2000, 4000},
 		},
 	)
 	getPayloadLatency = promauto.NewHistogram(
 		prometheus.HistogramOpts{
 			Name:    "get_payload_v1_latency_milliseconds",
 			Help:    "Captures RPC latency for getPayloadV1 in milliseconds",
-			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+			Buckets: []float64{25, 50, 100, 200, 500, 1000, 2000, 4000},
 		},
 	)
 	forkchoiceUpdatedLatency = promauto.NewHistogram(
 		prometheus.HistogramOpts{
 			Name:    "forkchoice_updated_v1_latency_milliseconds",
 			Help:    "Captures RPC latency for forkchoiceUpdatedV1 in milliseconds",
-			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+			Buckets: []float64{25, 50, 100, 200, 500, 1000, 2000, 4000},
 		},
 	)
 )

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

@@ -70,10 +70,14 @@ func (bs *Server) GetWeakSubjectivity(ctx context.Context, _ *empty.Empty) (*eth
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "could not get weak subjectivity slot: %v", err)
 	}
-	cbr, cb, err := bs.CanonicalHistory.BlockForSlot(ctx, wsSlot)
+	cbr, err := bs.CanonicalHistory.BlockRootForSlot(ctx, wsSlot)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, fmt.Sprintf("could not find highest block below slot %d", wsSlot))
 	}
+	cb, err := bs.BeaconDB.Block(ctx, cbr)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, fmt.Sprintf("block with root %#x from slot index %d not found in db", cbr, wsSlot))
+	}
 	stateRoot := bytesutil.ToBytes32(cb.Block().StateRoot())
 	log.Printf("weak subjectivity checkpoint reported as epoch=%d, block root=%#x, state root=%#x", wsEpoch, cbr, stateRoot)
 	return &ethpbv1.WeakSubjectivityResponse{
@@ -150,7 +154,7 @@ func (bs *Server) ListBlockHeaders(ctx context.Context, req *ethpbv1.BlockHeader
 		if req.Slot != nil {
 			slot = *req.Slot
 		}
-		_, blks, err = bs.BeaconDB.BlocksBySlot(ctx, slot)
+		blks, err = bs.BeaconDB.BlocksBySlot(ctx, slot)
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not retrieve blocks for slot %d: %v", req.Slot, err)
 		}
@@ -754,7 +758,7 @@ func (bs *Server) blockFromBlockID(ctx context.Context, blockId []byte) (interfa
 				e := newBlockIdParseError(err)
 				return nil, &e
 			}
-			_, blks, err := bs.BeaconDB.BlocksBySlot(ctx, types.Slot(slot))
+			blks, err := bs.BeaconDB.BlocksBySlot(ctx, types.Slot(slot))
 			if err != nil {
 				return nil, errors.Wrapf(err, "could not retrieve blocks for slot %d", slot)
 			}

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

@@ -1527,8 +1527,8 @@ func TestServer_GetBlockSSZ(t *testing.T) {
 		},
 	}
 
-	ok, blocks, err := beaconDB.BlocksBySlot(ctx, 30)
-	require.Equal(t, true, ok)
+	blocks, err := beaconDB.BlocksBySlot(ctx, 30)
+	require.Equal(t, true, len(blocks) > 0)
 	require.NoError(t, err)
 	sszBlock, err := blocks[0].MarshalSSZ()
 	require.NoError(t, err)
@@ -1567,8 +1567,8 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
 			},
 		}
 
-		ok, blocks, err := beaconDB.BlocksBySlot(ctx, 30)
-		require.Equal(t, true, ok)
+		blocks, err := beaconDB.BlocksBySlot(ctx, 30)
+		require.Equal(t, true, len(blocks) > 0)
 		require.NoError(t, err)
 		sszBlock, err := blocks[0].MarshalSSZ()
 		require.NoError(t, err)
@@ -1606,8 +1606,8 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
 			},
 		}
 
-		ok, blocks, err := beaconDB.BlocksBySlot(ctx, 30)
-		require.Equal(t, true, ok)
+		blocks, err := beaconDB.BlocksBySlot(ctx, 30)
+		require.Equal(t, true, len(blocks) > 0)
 		require.NoError(t, err)
 		sszBlock, err := blocks[0].MarshalSSZ()
 		require.NoError(t, err)
@@ -1645,8 +1645,8 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
 			},
 		}
 
-		ok, blocks, err := beaconDB.BlocksBySlot(ctx, 30)
-		require.Equal(t, true, ok)
+		blocks, err := beaconDB.BlocksBySlot(ctx, 30)
+		require.Equal(t, true, len(blocks) > 0)
 		require.NoError(t, err)
 		sszBlock, err := blocks[0].MarshalSSZ()
 		require.NoError(t, err)

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/prysm/v1alpha1/beacon/blocks.go

@@ -209,11 +209,11 @@ func (bs *Server) listBlocksForRoot(ctx context.Context, _ *ethpb.ListBlocksRequ
 
 // listBlocksForSlot retrieves all blocks for the provided slot.
 func (bs *Server) listBlocksForSlot(ctx context.Context, req *ethpb.ListBlocksRequest, q *ethpb.ListBlocksRequest_Slot) ([]blockContainer, int, string, error) {
-	hasBlocks, blks, err := bs.BeaconDB.BlocksBySlot(ctx, q.Slot)
+	blks, err := bs.BeaconDB.BlocksBySlot(ctx, q.Slot)
 	if err != nil {
 		return nil, 0, strconv.Itoa(0), status.Errorf(codes.Internal, "Could not retrieve blocks for slot %d: %v", q.Slot, err)
 	}
-	if !hasBlocks {
+	if len(blks) == 0 {
 		return []blockContainer{}, 0, strconv.Itoa(0), nil
 	}
 

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

@@ -127,10 +127,10 @@ func (vs *Server) getExecutionPayload(ctx context.Context, slot types.Slot, vIdx
 	case errors.As(err, kv.ErrNotFoundFeeRecipient):
 		// If fee recipient is not found in DB and not set from beacon node CLI,
 		// use the burn address.
-		if feeRecipient.String() == fieldparams.EthBurnAddressHex {
+		if feeRecipient.String() == params.BeaconConfig().EthBurnAddressHex {
 			logrus.WithFields(logrus.Fields{
 				"validatorIndex": vIdx,
-				"burnAddress":    fieldparams.EthBurnAddressHex,
+				"burnAddress":    params.BeaconConfig().EthBurnAddressHex,
 			}).Warn("Fee recipient is currently using the burn address, " +
 				"you will not be rewarded transaction fees on this setting. " +
 				"Please set a different eth address as the fee recipient. " +

beacon-chain/rpc/statefetcher/fetcher.go

@@ -292,11 +292,11 @@ func (p *StateProvider) stateRootBySlot(ctx context.Context, slot types.Slot) ([
 	if slot > currentSlot {
 		return nil, errors.New("slot cannot be in the future")
 	}
-	found, blks, err := p.BeaconDB.BlocksBySlot(ctx, slot)
+	blks, err := p.BeaconDB.BlocksBySlot(ctx, slot)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get blocks")
 	}
-	if !found {
+	if len(blks) == 0 {
 		return nil, errors.New("no block exists")
 	}
 	if len(blks) != 1 {

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/fieldtrie/BUILD.bazel

@@ -15,7 +15,6 @@ go_library(
         "//beacon-chain/state/types:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//encoding/ssz:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",

beacon-chain/state/fieldtrie/field_trie_helpers.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/types"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/encoding/ssz"
 	pmath "github.com/prysmaticlabs/prysm/math"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/runtime/version"
@@ -353,17 +352,7 @@ func handlePendingAttestationSlice(val []*ethpb.PendingAttestation, indices []ui
 // handleBalanceSlice returns the root of a slice of validator balances.
 func handleBalanceSlice(val, indices []uint64, convertAll bool) ([][32]byte, error) {
 	if convertAll {
-		balancesMarshaling := make([][]byte, len(val))
-		for i, b := range val {
-			balanceBuf := make([]byte, 8)
-			binary.LittleEndian.PutUint64(balanceBuf, b)
-			balancesMarshaling[i] = balanceBuf
-		}
-		balancesChunks, err := ssz.PackByChunk(balancesMarshaling)
-		if err != nil {
-			return [][32]byte{}, errors.Wrap(err, "could not pack balances into chunks")
-		}
-		return balancesChunks, nil
+		return stateutil.PackUint64IntoChunks(val)
 	}
 	if len(val) > 0 {
 		numOfElems, err := types.Balances.ElemsInChunk()

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.
@@ -59,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/state_trie.go

@@ -199,6 +199,8 @@ func InitializeFromProtoUnsafePhase0(st *ethpb.BeaconState) (state.BeaconState,
 	b.sharedFieldReferences[nativetypes.CurrentEpochAttestations] = stateutil.NewRef(1)
 
 	state.StateCount.Inc()
+	// Finalizer runs when dst is being destroyed in garbage collection.
+	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
 }
 
@@ -287,6 +289,8 @@ func InitializeFromProtoUnsafeAltair(st *ethpb.BeaconStateAltair) (state.BeaconS
 	b.sharedFieldReferences[nativetypes.InactivityScores] = stateutil.NewRef(1)               // New in Altair.
 
 	state.StateCount.Inc()
+	// Finalizer runs when dst is being destroyed in garbage collection.
+	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
 }
 
@@ -377,6 +381,8 @@ func InitializeFromProtoUnsafeBellatrix(st *ethpb.BeaconStateBellatrix) (state.B
 	b.sharedFieldReferences[nativetypes.LatestExecutionPayloadHeader] = stateutil.NewRef(1) // New in Bellatrix.
 
 	state.StateCount.Inc()
+	// Finalizer runs when dst is being destroyed in garbage collection.
+	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
 }
 
@@ -495,31 +501,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 
 	state.StateCount.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
-	runtime.SetFinalizer(dst, func(b *BeaconState) {
-		for field, v := range b.sharedFieldReferences {
-			v.MinusRef()
-			if b.stateFieldLeaves[field].FieldReference() != nil {
-				b.stateFieldLeaves[field].FieldReference().MinusRef()
-			}
-
-		}
-		for i := range b.dirtyFields {
-			delete(b.dirtyFields, i)
-		}
-		for i := range b.rebuildTrie {
-			delete(b.rebuildTrie, i)
-		}
-		for i := range b.dirtyIndices {
-			delete(b.dirtyIndices, i)
-		}
-		for i := range b.sharedFieldReferences {
-			delete(b.sharedFieldReferences, i)
-		}
-		for i := range b.stateFieldLeaves {
-			delete(b.stateFieldLeaves, i)
-		}
-		state.StateCount.Sub(1)
-	})
+	runtime.SetFinalizer(dst, finalizerCleanup)
 	return dst
 }
 
@@ -792,3 +774,29 @@ func (b *BeaconState) resetFieldTrie(index nativetypes.FieldIndex, elements inte
 	b.dirtyIndices[index] = []uint64{}
 	return nil
 }
+
+func finalizerCleanup(b *BeaconState) {
+	for field, v := range b.sharedFieldReferences {
+		v.MinusRef()
+		if b.stateFieldLeaves[field].FieldReference() != nil {
+			b.stateFieldLeaves[field].FieldReference().MinusRef()
+		}
+
+	}
+	for i := range b.dirtyFields {
+		delete(b.dirtyFields, i)
+	}
+	for i := range b.rebuildTrie {
+		delete(b.rebuildTrie, i)
+	}
+	for i := range b.dirtyIndices {
+		delete(b.dirtyIndices, i)
+	}
+	for i := range b.sharedFieldReferences {
+		delete(b.sharedFieldReferences, i)
+	}
+	for i := range b.stateFieldLeaves {
+		delete(b.stateFieldLeaves, i)
+	}
+	state.StateCount.Sub(1)
+}

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

@@ -46,73 +46,58 @@ func (c *CanonicalHistory) ReplayerForSlot(target types.Slot) Replayer {
 	return &stateReplayer{chainer: c, method: forSlot, target: target}
 }
 
-func (c *CanonicalHistory) BlockForSlot(ctx context.Context, target types.Slot) ([32]byte, interfaces.SignedBeaconBlock, error) {
-	currentSlot := c.cs.CurrentSlot()
-	if target > currentSlot {
-		return [32]byte{}, nil, errors.Wrap(ErrFutureSlotRequested, fmt.Sprintf("requested=%d, current=%d", target, currentSlot))
+func (c *CanonicalHistory) BlockRootForSlot(ctx context.Context, target types.Slot) ([32]byte, error) {
+	if currentSlot := c.cs.CurrentSlot(); target > currentSlot {
+		return [32]byte{}, errors.Wrap(ErrFutureSlotRequested, fmt.Sprintf("requested=%d, current=%d", target, currentSlot))
 	}
-	for target > 0 {
+
+	slotAbove := target + 1
+	// don't bother searching for candidate roots when we know the target slot is genesis
+	for slotAbove > 1 {
 		if ctx.Err() != nil {
-			return [32]byte{}, nil, errors.Wrap(ctx.Err(), "context canceled during canonicalBlockForSlot")
+			return [32]byte{}, errors.Wrap(ctx.Err(), "context canceled during canonicalBlockForSlot")
 		}
-		hbs, err := c.h.HighestSlotBlocksBelow(ctx, target+1)
+		slot, roots, err := c.h.HighestRootsBelowSlot(ctx, slotAbove)
 		if err != nil {
-			return [32]byte{}, nil, errors.Wrap(err, fmt.Sprintf("error finding highest block w/ slot <= %d", target))
+			return [32]byte{}, errors.Wrap(err, fmt.Sprintf("error finding highest block w/ slot < %d", slotAbove))
 		}
-		if len(hbs) == 0 {
-			return [32]byte{}, nil, errors.Wrap(ErrNoBlocksBelowSlot, fmt.Sprintf("slot=%d", target))
+		if len(roots) == 0 {
+			return [32]byte{}, errors.Wrap(ErrNoBlocksBelowSlot, fmt.Sprintf("slot=%d", slotAbove))
 		}
-		r, b, err := c.bestForSlot(ctx, hbs)
+		r, err := c.bestForSlot(ctx, roots)
 		if err == nil {
 			// we found a valid, canonical block!
-			return r, b, nil
+			return r, nil
 		}
 
 		// we found a block, but it wasn't considered canonical - keep looking
 		if errors.Is(err, ErrNoCanonicalBlockForSlot) {
 			// break once we've seen slot 0 (and prevent underflow)
-			if hbs[0].Block().Slot() == params.BeaconConfig().GenesisSlot {
+			if slot == params.BeaconConfig().GenesisSlot {
 				break
 			}
-			target = hbs[0].Block().Slot() - 1
+			slotAbove = slot
 			continue
 		}
-		return [32]byte{}, nil, err
+		return [32]byte{}, err
 	}
-	b, err := c.h.GenesisBlock(ctx)
-	if err != nil {
-		return [32]byte{}, nil, errors.Wrap(err, "db error while retrieving genesis block")
-	}
-	root, _, err := c.bestForSlot(ctx, []interfaces.SignedBeaconBlock{b})
-	if err != nil {
-		return [32]byte{}, nil, errors.Wrap(err, "problem retrieving genesis block")
-	}
-	return root, b, nil
+
+	return c.h.GenesisBlockRoot(ctx)
 }
 
 // bestForSlot encapsulates several messy realities of the underlying db code, looping through multiple blocks,
 // performing null/validity checks, and using CanonicalChecker to only pick canonical blocks.
-func (c *CanonicalHistory) bestForSlot(ctx context.Context, hbs []interfaces.SignedBeaconBlock) ([32]byte, interfaces.SignedBeaconBlock, error) {
-	for _, b := range hbs {
-		if wrapper.BeaconBlockIsNil(b) != nil {
-			continue
-		}
-		root, err := b.Block().HashTreeRoot()
-		if err != nil {
-			// use this error message to wrap a sentinel error for error type matching
-			wrapped := errors.Wrap(ErrInvalidDBBlock, err.Error())
-			msg := fmt.Sprintf("could not compute hash_tree_root for block at slot=%d", b.Block().Slot())
-			return [32]byte{}, nil, errors.Wrap(wrapped, msg)
-		}
+func (c *CanonicalHistory) bestForSlot(ctx context.Context, roots [][32]byte) ([32]byte, error) {
+	for _, root := range roots {
 		canon, err := c.cc.IsCanonical(ctx, root)
 		if err != nil {
-			return [32]byte{}, nil, errors.Wrap(err, "replayer could not check if block is canonical")
+			return [32]byte{}, errors.Wrap(err, "replayer could not check if block is canonical")
 		}
 		if canon {
-			return root, b, nil
+			return root, nil
 		}
 	}
-	return [32]byte{}, nil, errors.Wrap(ErrNoCanonicalBlockForSlot, "no good block for slot")
+	return [32]byte{}, errors.Wrap(ErrNoCanonicalBlockForSlot, "no good block for slot")
 }
 
 // ChainForSlot creates a value that satisfies the Replayer interface via db queries
@@ -122,9 +107,13 @@ func (c *CanonicalHistory) bestForSlot(ctx context.Context, hbs []interfaces.Sig
 func (c *CanonicalHistory) chainForSlot(ctx context.Context, target types.Slot) (state.BeaconState, []interfaces.SignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "canonicalChainer.chainForSlot")
 	defer span.End()
-	_, b, err := c.BlockForSlot(ctx, target)
+	r, err := c.BlockRootForSlot(ctx, target)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, fmt.Sprintf("unable to find replay data for slot=%d", target))
+		return nil, nil, errors.Wrapf(err, "no canonical block root found below slot=%d", target)
+	}
+	b, err := c.h.Block(ctx, r)
+	if err != nil {
+		return nil, nil, errors.Wrapf(err, "unable to retrieve canonical block for slot, root=%#x", r)
 	}
 	s, descendants, err := c.ancestorChain(ctx, b)
 	if err != nil {

beacon-chain/state/stategen/history_test.go

@@ -12,8 +12,6 @@ import (
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
@@ -21,7 +19,7 @@ func TestBlockForSlotFuture(t *testing.T) {
 	ch := &CanonicalHistory{
 		cs: &mockCurrentSlotter{Slot: 0},
 	}
-	_, _, err := ch.BlockForSlot(context.Background(), 1)
+	_, err := ch.BlockRootForSlot(context.Background(), 1)
 	require.ErrorIs(t, err, ErrFutureSlotRequested)
 }
 
@@ -34,84 +32,54 @@ func TestChainForSlotFuture(t *testing.T) {
 }
 
 func TestBestForSlot(t *testing.T) {
-	nilBlock, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
-	require.NoError(t, err)
-	nilBody, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}})
-	require.NoError(t, err)
 	derp := errors.New("fake hash tree root method no hash good")
-	badHTR := &mock.SignedBeaconBlock{BeaconBlock: &mock.BeaconBlock{HtrErr: derp, BeaconBlockBody: &mock.BeaconBlockBody{}}}
 	var goodHTR [32]byte
 	copy(goodHTR[:], []byte{23})
 	var betterHTR [32]byte
 	copy(betterHTR[:], []byte{42})
-	good := &mock.SignedBeaconBlock{BeaconBlock: &mock.BeaconBlock{BeaconBlockBody: &mock.BeaconBlockBody{}, Htr: goodHTR}}
-	better := &mock.SignedBeaconBlock{BeaconBlock: &mock.BeaconBlock{BeaconBlockBody: &mock.BeaconBlockBody{}, Htr: betterHTR}}
 
 	cases := []struct {
 		name   string
 		err    error
 		blocks []interfaces.SignedBeaconBlock
-		best   interfaces.SignedBeaconBlock
+		roots  [][32]byte
 		root   [32]byte
 		cc     CanonicalChecker
 	}{
 		{
-			name:   "empty list",
-			err:    ErrNoCanonicalBlockForSlot,
-			blocks: []interfaces.SignedBeaconBlock{},
+			name:  "empty list",
+			err:   ErrNoCanonicalBlockForSlot,
+			roots: [][32]byte{},
 		},
 		{
-			name:   "empty SignedBeaconBlock",
-			err:    ErrNoCanonicalBlockForSlot,
-			blocks: []interfaces.SignedBeaconBlock{nil},
+			name:  "IsCanonical fail",
+			roots: [][32]byte{goodHTR, betterHTR},
+			cc:    &mockCanonicalChecker{is: true, err: derp},
+			err:   derp,
 		},
 		{
-			name:   "empty BeaconBlock",
-			err:    ErrNoCanonicalBlockForSlot,
-			blocks: []interfaces.SignedBeaconBlock{nilBlock},
+			name:  "all non-canonical",
+			err:   ErrNoCanonicalBlockForSlot,
+			roots: [][32]byte{goodHTR, betterHTR},
+			cc:    &mockCanonicalChecker{is: false},
 		},
 		{
-			name:   "empty BeaconBlockBody",
-			err:    ErrNoCanonicalBlockForSlot,
-			blocks: []interfaces.SignedBeaconBlock{nilBody},
+			name:  "one canonical",
+			cc:    &mockCanonicalChecker{is: true},
+			root:  goodHTR,
+			roots: [][32]byte{goodHTR},
 		},
 		{
-			name:   "bad HTR",
-			err:    ErrInvalidDBBlock,
-			blocks: []interfaces.SignedBeaconBlock{badHTR},
+			name:  "all canonical",
+			cc:    &mockCanonicalChecker{is: true},
+			root:  betterHTR,
+			roots: [][32]byte{betterHTR, goodHTR},
 		},
 		{
-			name:   "IsCanonical fail",
-			blocks: []interfaces.SignedBeaconBlock{good, better},
-			cc:     &mockCanonicalChecker{is: true, err: derp},
-			err:    derp,
-		},
-		{
-			name:   "all non-canonical",
-			err:    ErrNoCanonicalBlockForSlot,
-			blocks: []interfaces.SignedBeaconBlock{good, better},
-			cc:     &mockCanonicalChecker{is: false},
-		},
-		{
-			name:   "one canonical",
-			blocks: []interfaces.SignedBeaconBlock{good},
-			cc:     &mockCanonicalChecker{is: true},
-			root:   goodHTR,
-			best:   good,
-		},
-		{
-			name:   "all canonical",
-			blocks: []interfaces.SignedBeaconBlock{better, good},
-			cc:     &mockCanonicalChecker{is: true},
-			root:   betterHTR,
-			best:   better,
-		},
-		{
-			name:   "first wins",
-			blocks: []interfaces.SignedBeaconBlock{good, better},
-			cc:     &mockCanonicalChecker{is: true},
-			root:   goodHTR,
-			best:   good,
+			name:  "first wins",
+			cc:    &mockCanonicalChecker{is: true},
+			root:  goodHTR,
+			roots: [][32]byte{goodHTR, betterHTR},
 		},
 	}
 	for _, c := range cases {
@@ -121,10 +89,9 @@ func TestBestForSlot(t *testing.T) {
 				chk = c.cc
 			}
 			ch := &CanonicalHistory{cc: chk}
-			r, b, err := ch.bestForSlot(context.Background(), c.blocks)
+			r, err := ch.bestForSlot(context.Background(), c.roots)
 			if c.err == nil {
 				require.NoError(t, err)
-				require.DeepEqual(t, c.best, b)
 				require.Equal(t, c.root, r)
 			} else {
 				require.ErrorIs(t, err, c.err)
@@ -164,13 +131,11 @@ func TestCanonicalBlockForSlotHappy(t *testing.T) {
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
-			bs, err := hist.HighestSlotBlocksBelow(ctx, c.slot+1)
+			_, rs, err := hist.HighestRootsBelowSlot(ctx, c.slot+1)
 			require.NoError(t, err)
-			require.Equal(t, len(bs), 1)
-			r, err := bs[0].Block().HashTreeRoot()
-			require.NoError(t, err)
-			require.Equal(t, hist.slotMap[c.highest], r)
-			cr, _, err := ch.BlockForSlot(ctx, c.slot)
+			require.Equal(t, len(rs), 1)
+			require.Equal(t, hist.slotMap[c.highest], rs[0])
+			cr, err := ch.BlockRootForSlot(ctx, c.slot)
 			require.NoError(t, err)
 			require.Equal(t, hist.slotMap[c.canon], cr)
 		})
@@ -187,47 +152,49 @@ func TestCanonicalBlockForSlotNonHappy(t *testing.T) {
 	}
 	hist := newMockHistory(t, specs, end+1)
 
+	genesis, err := hist.GenesisBlockRoot(ctx)
+	require.NoError(t, err)
 	slotOrderObserved := make([]types.Slot, 0)
-	derp := errors.New("HighestSlotBlocksBelow don't work")
+	derp := errors.New("HighestRootsBelowSlot don't work")
 	// since only the end block and genesis are canonical, once the slot drops below
 	// end, we should always get genesis
 	cases := []struct {
 		name              string
 		slot              types.Slot
 		canon             CanonicalChecker
-		overrideHighest   func(context.Context, types.Slot) ([]interfaces.SignedBeaconBlock, error)
+		overrideHighest   func(context.Context, types.Slot) (types.Slot, [][32]byte, error)
 		slotOrderExpected []types.Slot
 		err               error
 		root              [32]byte
 	}{
 		{
-			name: "HighestSlotBlocksBelow not called for genesis",
-			overrideHighest: func(_ context.Context, _ types.Slot) ([]interfaces.SignedBeaconBlock, error) {
-				return nil, derp
+			name: "HighestRootsBelowSlot not called for genesis",
+			overrideHighest: func(_ context.Context, _ types.Slot) (types.Slot, [][32]byte, error) {
+				return 0, [][32]byte{}, derp
 			},
 			root: hist.slotMap[0],
 		},
 		{
-			name: "wrapped error from HighestSlotBlocksBelow returned",
+			name: "wrapped error from HighestRootsBelowSlot returned",
 			err:  derp,
-			overrideHighest: func(_ context.Context, _ types.Slot) ([]interfaces.SignedBeaconBlock, error) {
-				return nil, derp
+			overrideHighest: func(_ context.Context, _ types.Slot) (types.Slot, [][32]byte, error) {
+				return 0, [][32]byte{}, derp
 			},
 			slot: end,
 		},
 		{
-			name: "HighestSlotBlocksBelow empty list",
+			name: "HighestRootsBelowSlot empty list",
 			err:  ErrNoBlocksBelowSlot,
-			overrideHighest: func(_ context.Context, _ types.Slot) ([]interfaces.SignedBeaconBlock, error) {
-				return []interfaces.SignedBeaconBlock{}, nil
+			overrideHighest: func(_ context.Context, _ types.Slot) (types.Slot, [][32]byte, error) {
+				return 0, [][32]byte{}, nil
 			},
 			slot: end,
 		},
 		{
-			name:  "HighestSlotBlocksBelow no canonical",
-			err:   ErrNoCanonicalBlockForSlot,
+			name:  "HighestRootsBelowSlot no canonical",
 			canon: &mockCanonicalChecker{is: false},
 			slot:  end,
+			root:  genesis,
 		},
 		{
 			name: "slot ordering correct - only genesis canonical",
@@ -237,11 +204,11 @@ func TestCanonicalBlockForSlotNonHappy(t *testing.T) {
 				}
 				return false, nil
 			}},
-			overrideHighest: func(_ context.Context, s types.Slot) ([]interfaces.SignedBeaconBlock, error) {
+			overrideHighest: func(_ context.Context, s types.Slot) (types.Slot, [][32]byte, error) {
 				slotOrderObserved = append(slotOrderObserved, s)
-				// this allows the mock HighestSlotBlocksBelow to continue to execute now that we've recorded
+				// this allows the mock HighestRootsBelowSlot to continue to execute now that we've recorded
 				// the slot in our channel
-				return nil, errFallThroughOverride
+				return 0, nil, errFallThroughOverride
 			},
 			slotOrderExpected: []types.Slot{156, 155, 150, 100},
 			slot:              end,
@@ -255,11 +222,11 @@ func TestCanonicalBlockForSlotNonHappy(t *testing.T) {
 				}
 				return false, nil
 			}},
-			overrideHighest: func(_ context.Context, s types.Slot) ([]interfaces.SignedBeaconBlock, error) {
+			overrideHighest: func(_ context.Context, s types.Slot) (types.Slot, [][32]byte, error) {
 				slotOrderObserved = append(slotOrderObserved, s)
-				// this allows the mock HighestSlotBlocksBelow to continue to execute now that we've recorded
+				// this allows the mock HighestRootsBelowSlot to continue to execute now that we've recorded
 				// the slot in our channel
-				return nil, errFallThroughOverride
+				return 0, nil, errFallThroughOverride
 			},
 			slotOrderExpected: []types.Slot{156, 155, 150},
 			slot:              end,
@@ -274,14 +241,14 @@ func TestCanonicalBlockForSlotNonHappy(t *testing.T) {
 			}
 			ch := &CanonicalHistory{h: hist, cc: canon, cs: hist}
 			hist.overrideHighestSlotBlocksBelow = c.overrideHighest
-			r, _, err := ch.BlockForSlot(ctx, c.slot)
+			r, err := ch.BlockRootForSlot(ctx, c.slot)
 			if c.err == nil {
 				require.NoError(t, err)
 			} else {
 				require.ErrorIs(t, err, c.err)
 			}
 			if len(c.slotOrderExpected) > 0 {
-				require.Equal(t, len(c.slotOrderExpected), len(slotOrderObserved), "HighestSlotBlocksBelow not called the expected number of times")
+				require.Equal(t, len(c.slotOrderExpected), len(slotOrderObserved), "HighestRootsBelowSlot not called the expected number of times")
 				for i := range c.slotOrderExpected {
 					require.Equal(t, c.slotOrderExpected[i], slotOrderObserved[i])
 				}

beacon-chain/state/stategen/migrate.go

@@ -55,24 +55,20 @@ func (s *State) MigrateToCold(ctx context.Context, fRoot [32]byte) error {
 				aRoot = cached.root
 				aState = cached.state
 			} else {
-				blks, err := s.beaconDB.HighestSlotBlocksBelow(ctx, slot)
+				_, roots, err := s.beaconDB.HighestRootsBelowSlot(ctx, slot)
 				if err != nil {
 					return err
 				}
 				// Given the block has been finalized, the db should not have more than one block in a given slot.
 				// We should error out when this happens.
-				if len(blks) != 1 {
+				if len(roots) != 1 {
 					return errUnknownBlock
 				}
-				missingRoot, err := blks[0].Block().HashTreeRoot()
-				if err != nil {
-					return err
-				}
-				aRoot = missingRoot
+				aRoot = roots[0]
 				// There's no need to generate the state if the state already exists in the DB.
 				// We can skip saving the state.
 				if !s.beaconDB.HasState(ctx, aRoot) {
-					aState, err = s.StateByRoot(ctx, missingRoot)
+					aState, err = s.StateByRoot(ctx, aRoot)
 					if err != nil {
 						return err
 					}

beacon-chain/state/stategen/mock_test.go

@@ -81,7 +81,7 @@ type mockHistory struct {
 	states                         map[[32]byte]state.BeaconState
 	hiddenStates                   map[[32]byte]state.BeaconState
 	current                        types.Slot
-	overrideHighestSlotBlocksBelow func(context.Context, types.Slot) ([]interfaces.SignedBeaconBlock, error)
+	overrideHighestSlotBlocksBelow func(context.Context, types.Slot) (types.Slot, [][32]byte, error)
 }
 
 type slotList []types.Slot
@@ -98,13 +98,13 @@ func (m slotList) Swap(i, j int) {
 	m[i], m[j] = m[j], m[i]
 }
 
-var errFallThroughOverride = errors.New("override yielding control back to real HighestSlotBlocksBelow")
+var errFallThroughOverride = errors.New("override yielding control back to real HighestRootsBelowSlot")
 
-func (m *mockHistory) HighestSlotBlocksBelow(_ context.Context, slot types.Slot) ([]interfaces.SignedBeaconBlock, error) {
+func (m *mockHistory) HighestRootsBelowSlot(_ context.Context, slot types.Slot) (types.Slot, [][32]byte, error) {
 	if m.overrideHighestSlotBlocksBelow != nil {
-		s, err := m.overrideHighestSlotBlocksBelow(context.Background(), slot)
+		s, r, err := m.overrideHighestSlotBlocksBelow(context.Background(), slot)
 		if !errors.Is(err, errFallThroughOverride) {
-			return s, err
+			return s, r, err
 		}
 	}
 	if len(m.slotIndex) == 0 && len(m.slotMap) > 0 {
@@ -115,20 +115,20 @@ func (m *mockHistory) HighestSlotBlocksBelow(_ context.Context, slot types.Slot)
 	}
 	for _, s := range m.slotIndex {
 		if s < slot {
-			return []interfaces.SignedBeaconBlock{m.blocks[m.slotMap[s]]}, nil
+			return s, [][32]byte{m.slotMap[s]}, nil
 		}
 	}
-	return []interfaces.SignedBeaconBlock{}, nil
+	return 0, [][32]byte{}, nil
 }
 
 var errGenesisBlockNotFound = errors.New("canonical genesis block not found in db")
 
-func (m *mockHistory) GenesisBlock(_ context.Context) (interfaces.SignedBeaconBlock, error) {
+func (m *mockHistory) GenesisBlockRoot(_ context.Context) ([32]byte, error) {
 	genesisRoot, ok := m.slotMap[0]
 	if !ok {
-		return nil, errGenesisBlockNotFound
+		return [32]byte{}, errGenesisBlockNotFound
 	}
-	return m.blocks[genesisRoot], nil
+	return genesisRoot, nil
 }
 
 func (m *mockHistory) Block(_ context.Context, blockRoot [32]byte) (interfaces.SignedBeaconBlock, error) {

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/stategen/replayer.go

@@ -27,8 +27,8 @@ const (
 
 // HistoryAccessor describes the minimum set of database methods needed to support the ReplayerBuilder.
 type HistoryAccessor interface {
-	HighestSlotBlocksBelow(ctx context.Context, slot types.Slot) ([]interfaces.SignedBeaconBlock, error)
-	GenesisBlock(ctx context.Context) (interfaces.SignedBeaconBlock, error)
+	HighestRootsBelowSlot(ctx context.Context, slot types.Slot) (types.Slot, [][32]byte, error)
+	GenesisBlockRoot(ctx context.Context) ([32]byte, error)
 	Block(ctx context.Context, blockRoot [32]byte) (interfaces.SignedBeaconBlock, error)
 	StateOrError(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
 }

beacon-chain/state/stateutil/validator_root.go

@@ -64,13 +64,7 @@ func ValidatorFieldRoots(hasher ssz.HashFn, validator *ethpb.Validator) ([][32]b
 // a list of uint64 and mixed with registry limit.
 func Uint64ListRootWithRegistryLimit(balances []uint64) ([32]byte, error) {
 	hasher := hash.CustomSHA256Hasher()
-	balancesMarshaling := make([][]byte, 0, len(balances))
-	for i := 0; i < len(balances); i++ {
-		balanceBuf := make([]byte, 8)
-		binary.LittleEndian.PutUint64(balanceBuf, balances[i])
-		balancesMarshaling = append(balancesMarshaling, balanceBuf)
-	}
-	balancesChunks, err := ssz.PackByChunk(balancesMarshaling)
+	balancesChunks, err := PackUint64IntoChunks(balances)
 	if err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not pack balances into chunks")
 	}
@@ -87,3 +81,37 @@ func Uint64ListRootWithRegistryLimit(balances []uint64) ([32]byte, error) {
 	binary.LittleEndian.PutUint64(balancesLengthRoot, uint64(len(balances)))
 	return ssz.MixInLength(balancesRootsRoot, balancesLengthRoot), nil
 }
+
+// PackUint64IntoChunks packs a list of uint64 values into 32 byte roots.
+func PackUint64IntoChunks(vals []uint64) ([][32]byte, error) {
+	// Initialize how many uint64 values we can pack
+	// into a single chunk(32 bytes). Each uint64 value
+	// would take up 8 bytes.
+	numOfElems := 4
+	sizeOfElem := 32 / numOfElems
+	// Determine total number of chunks to be
+	// allocated to provided list of unsigned
+	// 64-bit integers.
+	numOfChunks := len(vals) / numOfElems
+	// Add an extra chunk if the list size
+	// is not a perfect multiple of the number
+	// of elements.
+	if len(vals)%numOfElems != 0 {
+		numOfChunks++
+	}
+	chunkList := make([][32]byte, numOfChunks)
+	for idx, b := range vals {
+		// In order to determine how to pack in the uint64 value by index into
+		// our chunk list we need to determine a few things.
+		// 1) The chunk which the particular uint64 value corresponds to.
+		// 2) The position of the value in the chunk itself.
+		//
+		// Once we have determined these 2 values we can simply find the correct
+		// section of contiguous bytes to insert the value in the chunk.
+		chunkIdx := idx / numOfElems
+		idxInChunk := idx % numOfElems
+		chunkPos := idxInChunk * sizeOfElem
+		binary.LittleEndian.PutUint64(chunkList[chunkIdx][chunkPos:chunkPos+sizeOfElem], b)
+	}
+	return chunkList, 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/state_trie.go

@@ -77,6 +77,8 @@ func InitializeFromProtoUnsafe(st *ethpb.BeaconState) (state.BeaconState, error)
 	b.sharedFieldReferences[historicalRoots] = stateutil.NewRef(1)
 
 	state.StateCount.Inc()
+	// Finalizer runs when dst is being destroyed in garbage collection.
+	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
 }
 
@@ -174,24 +176,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 
 	state.StateCount.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
-	runtime.SetFinalizer(dst, func(b *BeaconState) {
-		for field, v := range b.sharedFieldReferences {
-			v.MinusRef()
-			if b.stateFieldLeaves[field].FieldReference() != nil {
-				b.stateFieldLeaves[field].FieldReference().MinusRef()
-			}
-
-		}
-		for i := 0; i < fieldCount; i++ {
-			field := types.FieldIndex(i)
-			delete(b.stateFieldLeaves, field)
-			delete(b.dirtyIndices, field)
-			delete(b.dirtyFields, field)
-			delete(b.sharedFieldReferences, field)
-			delete(b.stateFieldLeaves, field)
-		}
-		state.StateCount.Sub(1)
-	})
+	runtime.SetFinalizer(dst, finalizerCleanup)
 	return dst
 }
 
@@ -439,3 +424,22 @@ func (b *BeaconState) resetFieldTrie(index types.FieldIndex, elements interface{
 	b.dirtyIndices[index] = []uint64{}
 	return nil
 }
+
+func finalizerCleanup(b *BeaconState) {
+	fieldCount := params.BeaconConfig().BeaconStateFieldCount
+	for field, v := range b.sharedFieldReferences {
+		v.MinusRef()
+		if b.stateFieldLeaves[field].FieldReference() != nil {
+			b.stateFieldLeaves[field].FieldReference().MinusRef()
+		}
+	}
+	for i := 0; i < fieldCount; i++ {
+		field := types.FieldIndex(i)
+		delete(b.stateFieldLeaves, field)
+		delete(b.dirtyIndices, field)
+		delete(b.dirtyFields, field)
+		delete(b.sharedFieldReferences, field)
+		delete(b.stateFieldLeaves, field)
+	}
+	state.StateCount.Sub(1)
+}

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

@@ -78,6 +78,8 @@ func InitializeFromProtoUnsafe(st *ethpb.BeaconStateAltair) (state.BeaconState,
 	b.sharedFieldReferences[historicalRoots] = stateutil.NewRef(1)
 
 	state.StateCount.Inc()
+	// Finalizer runs when dst is being destroyed in garbage collection.
+	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
 }
 
@@ -179,23 +181,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 
 	state.StateCount.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
-	runtime.SetFinalizer(dst, func(b *BeaconState) {
-		for field, v := range b.sharedFieldReferences {
-			v.MinusRef()
-			if b.stateFieldLeaves[field].FieldReference() != nil {
-				b.stateFieldLeaves[field].FieldReference().MinusRef()
-			}
-		}
-		for i := 0; i < fieldCount; i++ {
-			field := types.FieldIndex(i)
-			delete(b.stateFieldLeaves, field)
-			delete(b.dirtyIndices, field)
-			delete(b.dirtyFields, field)
-			delete(b.sharedFieldReferences, field)
-			delete(b.stateFieldLeaves, field)
-		}
-		state.StateCount.Sub(1)
-	})
+	runtime.SetFinalizer(dst, finalizerCleanup)
 
 	return dst
 }
@@ -426,3 +412,22 @@ func (b *BeaconState) resetFieldTrie(index types.FieldIndex, elements interface{
 	b.dirtyIndices[index] = []uint64{}
 	return nil
 }
+
+func finalizerCleanup(b *BeaconState) {
+	fieldCount := params.BeaconConfig().BeaconStateAltairFieldCount
+	for field, v := range b.sharedFieldReferences {
+		v.MinusRef()
+		if b.stateFieldLeaves[field].FieldReference() != nil {
+			b.stateFieldLeaves[field].FieldReference().MinusRef()
+		}
+	}
+	for i := 0; i < fieldCount; i++ {
+		field := types.FieldIndex(i)
+		delete(b.stateFieldLeaves, field)
+		delete(b.dirtyIndices, field)
+		delete(b.dirtyFields, field)
+		delete(b.sharedFieldReferences, field)
+		delete(b.stateFieldLeaves, field)
+	}
+	state.StateCount.Sub(1)
+}

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

@@ -78,6 +78,8 @@ func InitializeFromProtoUnsafe(st *ethpb.BeaconStateBellatrix) (state.BeaconStat
 	b.sharedFieldReferences[historicalRoots] = stateutil.NewRef(1)
 	b.sharedFieldReferences[latestExecutionPayloadHeader] = stateutil.NewRef(1) // New in Bellatrix.
 	state.StateCount.Inc()
+	// Finalizer runs when dst is being destroyed in garbage collection.
+	runtime.SetFinalizer(b, finalizerCleanup)
 	return b, nil
 }
 
@@ -179,23 +181,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 	}
 	state.StateCount.Inc()
 	// Finalizer runs when dst is being destroyed in garbage collection.
-	runtime.SetFinalizer(dst, func(b *BeaconState) {
-		for field, v := range b.sharedFieldReferences {
-			v.MinusRef()
-			if b.stateFieldLeaves[field].FieldReference() != nil {
-				b.stateFieldLeaves[field].FieldReference().MinusRef()
-			}
-		}
-		for i := 0; i < fieldCount; i++ {
-			field := types.FieldIndex(i)
-			delete(b.stateFieldLeaves, field)
-			delete(b.dirtyIndices, field)
-			delete(b.dirtyFields, field)
-			delete(b.sharedFieldReferences, field)
-			delete(b.stateFieldLeaves, field)
-		}
-		state.StateCount.Sub(1)
-	})
+	runtime.SetFinalizer(dst, finalizerCleanup)
 
 	return dst
 }
@@ -421,3 +407,22 @@ func (b *BeaconState) resetFieldTrie(index types.FieldIndex, elements interface{
 	b.dirtyIndices[index] = []uint64{}
 	return nil
 }
+
+func finalizerCleanup(b *BeaconState) {
+	fieldCount := params.BeaconConfig().BeaconStateBellatrixFieldCount
+	for field, v := range b.sharedFieldReferences {
+		v.MinusRef()
+		if b.stateFieldLeaves[field].FieldReference() != nil {
+			b.stateFieldLeaves[field].FieldReference().MinusRef()
+		}
+	}
+	for i := 0; i < fieldCount; i++ {
+		field := types.FieldIndex(i)
+		delete(b.stateFieldLeaves, field)
+		delete(b.dirtyIndices, field)
+		delete(b.dirtyFields, field)
+		delete(b.sharedFieldReferences, field)
+		delete(b.stateFieldLeaves, field)
+	}
+	state.StateCount.Sub(1)
+}

cmd/beacon-chain/flags/BUILD.bazel

@@ -18,7 +18,6 @@ go_library(
     ],
     deps = [
         "//cmd:go_default_library",
-        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",

cmd/beacon-chain/flags/base.go

@@ -5,7 +5,6 @@ package flags
 import (
 	"strings"
 
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/urfave/cli/v2"
 )
@@ -215,7 +214,7 @@ var (
 	SuggestedFeeRecipient = &cli.StringFlag{
 		Name:  "suggested-fee-recipient",
 		Usage: "Post bellatrix, this address will receive the transaction fees produced by any blocks from this node. Default to junk whilst bellatrix is in development state. Validator client can override this value through the preparebeaconproposer api.",
-		Value: fieldparams.EthBurnAddressHex,
+		Value: params.BeaconConfig().EthBurnAddressHex,
 	}
 	// TerminalTotalDifficultyOverride specifies the total difficulty to manual overrides the `TERMINAL_TOTAL_DIFFICULTY` parameter.
 	TerminalTotalDifficultyOverride = &cli.StringFlag{

cmd/beacon-chain/jwt/BUILD.bazel

@@ -0,0 +1,29 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["jwt.go"],
+    importpath = "github.com/prysmaticlabs/prysm/cmd/beacon-chain/jwt",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//cmd:go_default_library",
+        "//crypto/rand:go_default_library",
+        "//io/file:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_urfave_cli_v2//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["jwt_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//cmd:go_default_library",
+        "//io/file:go_default_library",
+        "//testing/require:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_urfave_cli_v2//:go_default_library",
+    ],
+)

cmd/beacon-chain/jwt/jwt.go

@@ -0,0 +1,71 @@
+package jwt
+
+import (
+	"errors"
+	"path/filepath"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/prysmaticlabs/prysm/cmd"
+	"github.com/prysmaticlabs/prysm/crypto/rand"
+	"github.com/prysmaticlabs/prysm/io/file"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+const (
+	secretFileName = "jwt.hex"
+)
+
+var Commands = &cli.Command{
+	Name:        "generate-auth-secret",
+	Usage:       "creates a random, 32 byte hex string in a plaintext file to be used for authenticating JSON-RPC requests. If no --output-file flag is defined, the file will be created in the current working directory",
+	Description: `creates a random, 32 byte hex string in a plaintext file to be used for authenticating JSON-RPC requests. If no --output-file flag is defined, the file will be created in the current working directory`,
+	Flags: cmd.WrapFlags([]cli.Flag{
+		cmd.JwtOutputFileFlag,
+	}),
+	Action: generateAuthSecretInFile,
+}
+
+func generateAuthSecretInFile(c *cli.Context) error {
+	fileName := secretFileName
+	specifiedFilePath := c.String(cmd.JwtOutputFileFlag.Name)
+	if len(specifiedFilePath) > 0 {
+		fileName = specifiedFilePath
+	}
+	var err error
+	fileName, err = file.ExpandPath(fileName)
+	if err != nil {
+		return err
+	}
+	fileDir := filepath.Dir(fileName)
+	exists, err := file.HasDir(fileDir)
+	if err != nil {
+		return err
+	}
+	if !exists {
+		if err := file.MkdirAll(fileDir); err != nil {
+			return err
+		}
+	}
+	secret, err := generateRandomHexString()
+	if err != nil {
+		return err
+	}
+	if err := file.WriteFile(fileName, []byte(secret)); err != nil {
+		return err
+	}
+	logrus.Infof("Successfully wrote JSON-RPC authentication secret to file %s", fileName)
+	return nil
+}
+
+func generateRandomHexString() (string, error) {
+	secret := make([]byte, 32)
+	randGen := rand.NewGenerator()
+	n, err := randGen.Read(secret)
+	if err != nil {
+		return "", err
+	} else if n <= 0 {
+		return "", errors.New("rand: unexpected length")
+	}
+	return hexutil.Encode(secret), nil
+}

cmd/beacon-chain/jwt/jwt_test.go

@@ -0,0 +1,86 @@
+package jwt
+
+import (
+	"flag"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/prysmaticlabs/prysm/cmd"
+	"github.com/prysmaticlabs/prysm/io/file"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/urfave/cli/v2"
+)
+
+func Test_generateJWTSecret(t *testing.T) {
+	t.Run("command should be available", func(t *testing.T) {
+		generateJwtCommand := Commands
+		require.Equal(t, true, generateJwtCommand.Name == "generate-auth-secret")
+	})
+	t.Run("should create proper file in current directory", func(t *testing.T) {
+		require.NoError(t, os.RemoveAll(secretFileName))
+		t.Cleanup(func() {
+			require.NoError(t, os.RemoveAll(secretFileName))
+		})
+		app := cli.App{}
+		set := flag.NewFlagSet("test", 0)
+		cliCtx := cli.NewContext(&app, set, nil)
+		err := generateAuthSecretInFile(cliCtx)
+		require.NoError(t, err)
+
+		// We check the file has the contents we expect.
+		checkAuthFileIntegrity(t, secretFileName)
+	})
+	t.Run("should create proper file in specified folder", func(t *testing.T) {
+		customOutput := filepath.Join("data", "item.txt")
+		require.NoError(t, os.RemoveAll(filepath.Dir(customOutput)))
+		t.Cleanup(func() {
+			require.NoError(t, os.RemoveAll(filepath.Dir(customOutput)))
+		})
+		app := cli.App{}
+		set := flag.NewFlagSet("test", 0)
+		set.String(cmd.JwtOutputFileFlag.Name, customOutput, "")
+		require.NoError(t, set.Set(cmd.JwtOutputFileFlag.Name, customOutput))
+
+		cliCtx := cli.NewContext(&app, set, nil)
+		err := generateAuthSecretInFile(cliCtx)
+		require.NoError(t, err)
+
+		// We check the file has the contents we expect.
+		checkAuthFileIntegrity(t, customOutput)
+	})
+	t.Run("creates proper file in nested specified folder", func(t *testing.T) {
+		rootDirectory := "data"
+		customOutputPath := filepath.Join(rootDirectory, "nest", "nested", "item.txt")
+		require.NoError(t, os.RemoveAll(filepath.Dir(customOutputPath)))
+		t.Cleanup(func() {
+			require.NoError(t, os.RemoveAll(rootDirectory))
+			_, err := os.Stat(customOutputPath)
+			require.Equal(t, true, err != nil)
+		})
+		app := cli.App{}
+		set := flag.NewFlagSet("test", 0)
+		set.String(cmd.JwtOutputFileFlag.Name, customOutputPath, "")
+		require.NoError(t, set.Set(cmd.JwtOutputFileFlag.Name, customOutputPath))
+
+		cliCtx := cli.NewContext(&app, set, nil)
+		err := generateAuthSecretInFile(cliCtx)
+		require.NoError(t, err)
+
+		// We check the file has the contents we expect.
+		checkAuthFileIntegrity(t, customOutputPath)
+	})
+}
+
+func checkAuthFileIntegrity(t testing.TB, fPath string) {
+	fileInfo, err := os.Stat(fPath)
+	require.NoError(t, err)
+	require.Equal(t, true, fileInfo != nil)
+
+	enc, err := file.ReadFileAsBytes(fPath)
+	require.NoError(t, err)
+	decoded, err := hexutil.Decode(string(enc))
+	require.NoError(t, err)
+	require.Equal(t, 32, len(decoded))
+}

cmd/flags.go

@@ -1,4 +1,4 @@
-// Package cmd defines the command line flags for the shared utlities.
+// Package cmd defines the command line flags for the shared utilities.
 package cmd
 
 import (
@@ -255,6 +255,12 @@ var (
 		Usage: "Specifies the timeout value for API requests in seconds",
 		Value: 120,
 	}
+	// JwtOutputFileFlag specifies the JWT file path that gets generated into when invoked by generate-jwt-secret.
+	JwtOutputFileFlag = &cli.StringFlag{
+		Name:    "output-file",
+		Usage:   "Target file path for outputting a generated JWT secret to be used for JSON-RPC authentication",
+		Aliases: []string{"o"},
+	}
 )
 
 // LoadFlagsFromConfig sets flags values from config file if ConfigFileFlag is set.

cmd/validator/accounts/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "accounts.go",
+        "backup.go",
         "delete.go",
         "list.go",
         "wallet_utils.go",
@@ -14,6 +15,7 @@ go_library(
         "//cmd:go_default_library",
         "//cmd/validator/flags:go_default_library",
         "//config/features:go_default_library",
+        "//io/prompt:go_default_library",
         "//runtime/tos:go_default_library",
         "//validator/accounts:go_default_library",
         "//validator/accounts/iface:go_default_library",
@@ -29,20 +31,27 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = ["delete_test.go"],
+    srcs = [
+        "backup_test.go",
+        "delete_test.go",
+    ],
     embed = [":go_default_library"],
     deps = [
         "//cmd/validator/flags:go_default_library",
         "//config/params:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//io/file:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//time:go_default_library",
         "//validator/accounts:go_default_library",
+        "//validator/accounts/iface:go_default_library",
         "//validator/accounts/wallet:go_default_library",
         "//validator/keymanager:go_default_library",
+        "//validator/keymanager/derived:go_default_library",
         "//validator/keymanager/local:go_default_library",
+        "//validator/testing:go_default_library",
         "@com_github_google_uuid//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
         "@com_github_wealdtech_go_eth2_wallet_encryptor_keystorev4//:go_default_library",

cmd/validator/accounts/accounts.go

@@ -111,13 +111,16 @@ var Commands = &cli.Command{
 				if err := cmd.LoadFlagsFromConfig(cliCtx, cliCtx.Command.Flags); err != nil {
 					return err
 				}
-				return tos.VerifyTosAcceptedOrPrompt(cliCtx)
-			},
-			Action: func(cliCtx *cli.Context) error {
+				if err := tos.VerifyTosAcceptedOrPrompt(cliCtx); err != nil {
+					return err
+				}
 				if err := features.ConfigureValidator(cliCtx); err != nil {
 					return err
 				}
-				if err := accounts.BackupAccountsCli(cliCtx); err != nil {
+				return nil
+			},
+			Action: func(cliCtx *cli.Context) error {
+				if err := accountsBackup(cliCtx); err != nil {
 					log.Fatalf("Could not backup accounts: %v", err)
 				}
 				return nil

cmd/validator/accounts/backup.go

@@ -0,0 +1,82 @@
+package accounts
+
+import (
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/cmd"
+	"github.com/prysmaticlabs/prysm/cmd/validator/flags"
+	"github.com/prysmaticlabs/prysm/io/prompt"
+	"github.com/prysmaticlabs/prysm/validator/accounts"
+	"github.com/prysmaticlabs/prysm/validator/accounts/userprompt"
+	"github.com/prysmaticlabs/prysm/validator/client"
+	"github.com/urfave/cli/v2"
+)
+
+const backupPromptText = "Enter the directory where your backup.zip file will be written to"
+
+func accountsBackup(c *cli.Context) error {
+	w, km, err := walletWithKeymanager(c)
+	if err != nil {
+		return err
+	}
+	dialOpts := client.ConstructDialOptions(
+		c.Int(cmd.GrpcMaxCallRecvMsgSizeFlag.Name),
+		c.String(flags.CertFlag.Name),
+		c.Uint(flags.GrpcRetriesFlag.Name),
+		c.Duration(flags.GrpcRetryDelayFlag.Name),
+	)
+	grpcHeaders := strings.Split(c.String(flags.GrpcHeadersFlag.Name), ",")
+
+	opts := []accounts.Option{
+		accounts.WithWallet(w),
+		accounts.WithKeymanager(km),
+		accounts.WithGRPCDialOpts(dialOpts),
+		accounts.WithBeaconRPCProvider(c.String(flags.BeaconRPCProviderFlag.Name)),
+		accounts.WithGRPCHeaders(grpcHeaders),
+	}
+
+	// Get full set of public keys from the keymanager.
+	publicKeys, err := km.FetchValidatingPublicKeys(c.Context)
+	if err != nil {
+		return errors.Wrap(err, "could not fetch validating public keys")
+	}
+	// Filter keys either from CLI flag or from interactive session.
+	filteredPubKeys, err := accounts.FilterPublicKeysFromUserInput(
+		c,
+		flags.BackupPublicKeysFlag,
+		publicKeys,
+		userprompt.SelectAccountsBackupPromptText,
+	)
+	if err != nil {
+		return errors.Wrap(err, "could not filter public keys for backup")
+	}
+	opts = append(opts, accounts.WithFilteredPubKeys(filteredPubKeys))
+
+	// Input the directory where they wish to backup their accounts.
+	backupsDir, err := userprompt.InputDirectory(c, backupPromptText, flags.BackupDirFlag)
+	if err != nil {
+		return errors.Wrap(err, "could not parse keys directory")
+	}
+	// Ask the user for their desired password for their backed up accounts.
+	backupsPassword, err := prompt.InputPassword(
+		c,
+		flags.BackupPasswordFile,
+		"Enter a new password for your backed up accounts",
+		"Confirm new password",
+		true,
+		prompt.ValidatePasswordInput,
+	)
+	if err != nil {
+		return errors.Wrap(err, "could not determine password for backed up accounts")
+	}
+
+	opts = append(opts, accounts.WithBackupsDir(backupsDir))
+	opts = append(opts, accounts.WithBackupsPassword(backupsPassword))
+
+	acc, err := accounts.NewCLIManager(opts...)
+	if err != nil {
+		return err
+	}
+	return acc.Backup(c.Context)
+}

cmd/validator/accounts/backup_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/prysmaticlabs/prysm/io/file"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/validator/accounts"
 	"github.com/prysmaticlabs/prysm/validator/accounts/iface"
 	"github.com/prysmaticlabs/prysm/validator/accounts/wallet"
 	"github.com/prysmaticlabs/prysm/validator/keymanager"
@@ -52,7 +53,7 @@ func TestBackupAccounts_Noninteractive_Derived(t *testing.T) {
 		backupPasswordFile: backupPasswordFile,
 		backupDir:          backupDir,
 	})
-	w, err := CreateWalletWithKeymanager(cliCtx.Context, &CreateWalletConfig{
+	w, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
 		WalletCfg: &wallet.Config{
 			WalletDir:      walletDir,
 			KeymanagerKind: keymanager.Derived,
@@ -93,10 +94,10 @@ func TestBackupAccounts_Noninteractive_Derived(t *testing.T) {
 	})
 
 	// Next, we attempt to backup the accounts.
-	require.NoError(t, BackupAccountsCli(cliCtx))
+	require.NoError(t, accountsBackup(cliCtx))
 
 	// We check a backup.zip file was created at the output path.
-	zipFilePath := filepath.Join(backupDir, archiveFilename)
+	zipFilePath := filepath.Join(backupDir, accounts.ArchiveFilename)
 	assert.DeepEqual(t, true, file.FileExists(zipFilePath))
 
 	// We attempt to unzip the file and verify the keystores do match our accounts.
@@ -169,7 +170,7 @@ func TestBackupAccounts_Noninteractive_Imported(t *testing.T) {
 		backupPasswordFile: backupPasswordFile,
 		backupDir:          backupDir,
 	})
-	_, err = CreateWalletWithKeymanager(cliCtx.Context, &CreateWalletConfig{
+	_, err = accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
 		WalletCfg: &wallet.Config{
 			WalletDir:      walletDir,
 			KeymanagerKind: keymanager.Local,
@@ -180,13 +181,13 @@ func TestBackupAccounts_Noninteractive_Imported(t *testing.T) {
 
 	// We attempt to import accounts we wrote to the keys directory
 	// into our newly created wallet.
-	require.NoError(t, ImportAccountsCli(cliCtx))
+	require.NoError(t, accounts.ImportAccountsCli(cliCtx))
 
 	// Next, we attempt to backup the accounts.
-	require.NoError(t, BackupAccountsCli(cliCtx))
+	require.NoError(t, accountsBackup(cliCtx))
 
 	// We check a backup.zip file was created at the output path.
-	zipFilePath := filepath.Join(backupDir, archiveFilename)
+	zipFilePath := filepath.Join(backupDir, accounts.ArchiveFilename)
 	assert.DeepEqual(t, true, file.FileExists(zipFilePath))
 
 	// We attempt to unzip the file and verify the keystores do match our accounts.

cmd/validator/flags/BUILD.bazel

@@ -13,7 +13,7 @@ go_library(
         "//validator:__subpackages__",
     ],
     deps = [
-        "//config/fieldparams:go_default_library",
+        "//config/params:go_default_library",
         "//io/file:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
     ],

cmd/validator/flags/flags.go

@@ -7,7 +7,7 @@ import (
 	"runtime"
 	"time"
 
-	field_params "github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/io/file"
 	"github.com/urfave/cli/v2"
 )
@@ -327,21 +327,36 @@ var (
 	// FeeRecipientConfigFileFlag defines the path or URL to a file with proposer config.
 	FeeRecipientConfigFileFlag = &cli.StringFlag{
 		Name:  "fee-recipient-config-file",
-		Usage: "Set path to a JSON file containing validator mappings to ETH addresses for receiving transaction fees when proposing blocks (i.e. --fee-recipient-config-file=/path/to/proposer.json). File format found in docs",
+		Usage: "DEPRECATED, please use proposer-settings-file",
 		Value: "",
 	}
 	// FeeRecipientConfigURLFlag defines the path or URL to a file with proposer config.
 	FeeRecipientConfigURLFlag = &cli.StringFlag{
 		Name:  "fee-recipient-config-url",
-		Usage: "Set URL to a REST endpoint containing validator mappings to ETH addresses for receiving transaction fees when proposing blocks (i.e. --fee-recipient-config-url=https://example.com/api/getConfig). File format found in docs",
+		Usage: "DEPRECATED, please use proposer-settings-url",
+		Value: "",
+	}
+
+	// ProposerSettingsFlag defines the path or URL to a file with proposer config.
+	ProposerSettingsFlag = &cli.StringFlag{
+		Name:  "proposer-settings-file",
+		Usage: "Set path to a YAML or JSON file containing validator settings used when proposing blocks such as (fee recipient and gas limit) (i.e. --proposer-settings-file=/path/to/proposer.json). File format found in docs",
+		Value: "",
+	}
+	// ProposerSettingsURLFlag defines the path or URL to a file with proposer config.
+	ProposerSettingsURLFlag = &cli.StringFlag{
+		Name:  "proposer-settings-url",
+		Usage: "Set URL to a REST endpoint containing validator settings used when proposing blocks such as (fee recipient) (i.e. --proposer-settings-url=https://example.com/api/getConfig). File format found in docs",
 		Value: "",
 	}
 
 	// SuggestedFeeRecipientFlag defines the address of the fee recipient.
 	SuggestedFeeRecipientFlag = &cli.StringFlag{
-		Name:  "suggested-fee-recipient",
-		Usage: "Sets ALL validators' mapping to a suggested an eth address to receive gas fees when proposing a block. Overrides the --fee-recipient-config-file flag if set",
-		Value: field_params.EthBurnAddressHex,
+		Name: "suggested-fee-recipient",
+		Usage: "Sets ALL validators' mapping to a suggested an eth address to receive gas fees when proposing a block." +
+			" note that this is only a suggestion when integrating with a Builder API, which may choose to specify a different fee recipient as payment for the blocks it builds." +
+			" For additional setting overrides use the --" + ProposerSettingsFlag.Name + " or --" + ProposerSettingsURLFlag.Name + " Flags. ",
+		Value: params.BeaconConfig().EthBurnAddressHex,
 	}
 )
 

cmd/validator/main.go

@@ -78,6 +78,8 @@ var appFlags = []cli.Flag{
 	flags.FeeRecipientConfigFileFlag,
 	flags.FeeRecipientConfigURLFlag,
 	flags.SuggestedFeeRecipientFlag,
+	flags.ProposerSettingsURLFlag,
+	flags.ProposerSettingsFlag,
 	////////////////////
 	cmd.DisableMonitoringFlag,
 	cmd.MonitoringHostFlag,

cmd/validator/usage.go

@@ -111,6 +111,8 @@ var appHelpFlagGroups = []flagGroup{
 			flags.Web3SignerPublicValidatorKeysFlag,
 			flags.FeeRecipientConfigFileFlag,
 			flags.FeeRecipientConfigURLFlag,
+			flags.ProposerSettingsFlag,
+			flags.ProposerSettingsURLFlag,
 			flags.SuggestedFeeRecipientFlag,
 		},
 	},

config/features/config.go

@@ -122,6 +122,12 @@ func configureTestnet(ctx *cli.Context) error {
 		if err := params.SetActive(params.RopstenConfig().Copy()); err != nil {
 			return err
 		}
+		if err := ctx.Set(enableVecHTR.Names()[0], "true"); err != nil {
+			log.WithError(err).Debug("error enabling vectorized HTR flag")
+		}
+		if err := ctx.Set(enableForkChoiceDoublyLinkedTree.Names()[0], "true"); err != nil {
+			log.WithError(err).Debug("error enabling doubly linked tree forkchoice flag")
+		}
 		params.UseRopstenNetworkConfig()
 	} else {
 		log.Warn("Running on Ethereum Consensus Mainnet")

config/fieldparams/mainnet.go

@@ -5,23 +5,22 @@ package field_params
 
 const (
 	Preset                          = "mainnet"
-	BlockRootsLength                = 8192                                         // SLOTS_PER_HISTORICAL_ROOT
-	StateRootsLength                = 8192                                         // SLOTS_PER_HISTORICAL_ROOT
-	RandaoMixesLength               = 65536                                        // EPOCHS_PER_HISTORICAL_VECTOR
-	HistoricalRootsLength           = 16777216                                     // HISTORICAL_ROOTS_LIMIT
-	ValidatorRegistryLimit          = 1099511627776                                // VALIDATOR_REGISTRY_LIMIT
-	Eth1DataVotesLength             = 2048                                         // SLOTS_PER_ETH1_VOTING_PERIOD
-	PreviousEpochAttestationsLength = 4096                                         // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
-	CurrentEpochAttestationsLength  = 4096                                         // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
-	SlashingsLength                 = 8192                                         // EPOCHS_PER_SLASHINGS_VECTOR
-	SyncCommitteeLength             = 512                                          // SYNC_COMMITTEE_SIZE
-	RootLength                      = 32                                           // RootLength defines the byte length of a Merkle root.
-	BLSSignatureLength              = 96                                           // BLSSignatureLength defines the byte length of a BLSSignature.
-	BLSPubkeyLength                 = 48                                           // BLSPubkeyLength defines the byte length of a BLSSignature.
-	MaxTxsPerPayloadLength          = 1048576                                      // MaxTxsPerPayloadLength defines the maximum number of transactions that can be included in a payload.
-	MaxBytesPerTxLength             = 1073741824                                   // MaxBytesPerTxLength defines the maximum number of bytes that can be included in a transaction.
-	FeeRecipientLength              = 20                                           // FeeRecipientLength defines the byte length of a fee recipient.
-	LogsBloomLength                 = 256                                          // LogsBloomLength defines the byte length of a logs bloom.
-	VersionLength                   = 4                                            // VersionLength defines the byte length of a fork version number.
-	EthBurnAddressHex               = "0x0000000000000000000000000000000000000000" // EthBurnAddressHex defines the hex encoded address of the eth1.0 burn contract.
+	BlockRootsLength                = 8192          // SLOTS_PER_HISTORICAL_ROOT
+	StateRootsLength                = 8192          // SLOTS_PER_HISTORICAL_ROOT
+	RandaoMixesLength               = 65536         // EPOCHS_PER_HISTORICAL_VECTOR
+	HistoricalRootsLength           = 16777216      // HISTORICAL_ROOTS_LIMIT
+	ValidatorRegistryLimit          = 1099511627776 // VALIDATOR_REGISTRY_LIMIT
+	Eth1DataVotesLength             = 2048          // SLOTS_PER_ETH1_VOTING_PERIOD
+	PreviousEpochAttestationsLength = 4096          // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
+	CurrentEpochAttestationsLength  = 4096          // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
+	SlashingsLength                 = 8192          // EPOCHS_PER_SLASHINGS_VECTOR
+	SyncCommitteeLength             = 512           // SYNC_COMMITTEE_SIZE
+	RootLength                      = 32            // RootLength defines the byte length of a Merkle root.
+	BLSSignatureLength              = 96            // BLSSignatureLength defines the byte length of a BLSSignature.
+	BLSPubkeyLength                 = 48            // BLSPubkeyLength defines the byte length of a BLSSignature.
+	MaxTxsPerPayloadLength          = 1048576       // MaxTxsPerPayloadLength defines the maximum number of transactions that can be included in a payload.
+	MaxBytesPerTxLength             = 1073741824    // MaxBytesPerTxLength defines the maximum number of bytes that can be included in a transaction.
+	FeeRecipientLength              = 20            // FeeRecipientLength defines the byte length of a fee recipient.
+	LogsBloomLength                 = 256           // LogsBloomLength defines the byte length of a logs bloom.
+	VersionLength                   = 4             // VersionLength defines the byte length of a fork version number.
 )

config/fieldparams/minimal.go

@@ -5,23 +5,22 @@ package field_params
 
 const (
 	Preset                          = "minimal"
-	BlockRootsLength                = 64                                           // SLOTS_PER_HISTORICAL_ROOT
-	StateRootsLength                = 64                                           // SLOTS_PER_HISTORICAL_ROOT
-	RandaoMixesLength               = 64                                           // EPOCHS_PER_HISTORICAL_VECTOR
-	HistoricalRootsLength           = 16777216                                     // HISTORICAL_ROOTS_LIMIT
-	ValidatorRegistryLimit          = 1099511627776                                // VALIDATOR_REGISTRY_LIMIT
-	Eth1DataVotesLength             = 32                                           // SLOTS_PER_ETH1_VOTING_PERIOD
-	PreviousEpochAttestationsLength = 1024                                         // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
-	CurrentEpochAttestationsLength  = 1024                                         // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
-	SlashingsLength                 = 64                                           // EPOCHS_PER_SLASHINGS_VECTOR
-	SyncCommitteeLength             = 32                                           // SYNC_COMMITTEE_SIZE
-	RootLength                      = 32                                           // RootLength defines the byte length of a Merkle root.
-	BLSSignatureLength              = 96                                           // BLSSignatureLength defines the byte length of a BLSSignature.
-	BLSPubkeyLength                 = 48                                           // BLSPubkeyLength defines the byte length of a BLSSignature.
-	MaxTxsPerPayloadLength          = 1048576                                      // MaxTxsPerPayloadLength defines the maximum number of transactions that can be included in a payload.
-	MaxBytesPerTxLength             = 1073741824                                   // MaxBytesPerTxLength defines the maximum number of bytes that can be included in a transaction.
-	FeeRecipientLength              = 20                                           // FeeRecipientLength defines the byte length of a fee recipient.
-	LogsBloomLength                 = 256                                          // LogsBloomLength defines the byte length of a logs bloom.
-	VersionLength                   = 4                                            // VersionLength defines the byte length of a fork version number.
-	EthBurnAddressHex               = "0x0000000000000000000000000000000000000000" // EthBurnAddressHex defines the hex encoded address of the eth1.0 burn contract.
+	BlockRootsLength                = 64            // SLOTS_PER_HISTORICAL_ROOT
+	StateRootsLength                = 64            // SLOTS_PER_HISTORICAL_ROOT
+	RandaoMixesLength               = 64            // EPOCHS_PER_HISTORICAL_VECTOR
+	HistoricalRootsLength           = 16777216      // HISTORICAL_ROOTS_LIMIT
+	ValidatorRegistryLimit          = 1099511627776 // VALIDATOR_REGISTRY_LIMIT
+	Eth1DataVotesLength             = 32            // SLOTS_PER_ETH1_VOTING_PERIOD
+	PreviousEpochAttestationsLength = 1024          // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
+	CurrentEpochAttestationsLength  = 1024          // MAX_ATTESTATIONS * SLOTS_PER_EPOCH
+	SlashingsLength                 = 64            // EPOCHS_PER_SLASHINGS_VECTOR
+	SyncCommitteeLength             = 32            // SYNC_COMMITTEE_SIZE
+	RootLength                      = 32            // RootLength defines the byte length of a Merkle root.
+	BLSSignatureLength              = 96            // BLSSignatureLength defines the byte length of a BLSSignature.
+	BLSPubkeyLength                 = 48            // BLSPubkeyLength defines the byte length of a BLSSignature.
+	MaxTxsPerPayloadLength          = 1048576       // MaxTxsPerPayloadLength defines the maximum number of transactions that can be included in a payload.
+	MaxBytesPerTxLength             = 1073741824    // MaxBytesPerTxLength defines the maximum number of bytes that can be included in a transaction.
+	FeeRecipientLength              = 20            // FeeRecipientLength defines the byte length of a fee recipient.
+	LogsBloomLength                 = 256           // LogsBloomLength defines the byte length of a logs bloom.
+	VersionLength                   = 4             // VersionLength defines the byte length of a fork version number.
 )

config/params/config.go

@@ -192,6 +192,8 @@ type BeaconChainConfig struct {
 	TerminalBlockHashActivationEpoch types.Epoch    `yaml:"TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH" spec:"true"` // TerminalBlockHashActivationEpoch of beacon chain.
 	TerminalTotalDifficulty          string         `yaml:"TERMINAL_TOTAL_DIFFICULTY" spec:"true"`            // TerminalTotalDifficulty is part of the experimental Bellatrix spec. This value is type is currently TBD.
 	DefaultFeeRecipient              common.Address // DefaultFeeRecipient where the transaction fee goes to.
+	EthBurnAddressHex                string         // EthBurnAddressHex is the constant eth address written in hex format to burn fees in that network. the default is 0x0
+	DefaultBuilderGasLimit           uint64         // DefaultBuilderGasLimit is the default used to set the gaslimit for the Builder APIs, typically at around 30M wei.
 }
 
 // InitializeForkSchedule initializes the schedules forks baked into the config.

config/params/mainnet_config.go

@@ -244,6 +244,8 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	TerminalBlockHashActivationEpoch: 18446744073709551615,
 	TerminalBlockHash:                [32]byte{},
 	TerminalTotalDifficulty:          "115792089237316195423570985008687907853269984665640564039457584007913129638912",
+	EthBurnAddressHex:                "0x0000000000000000000000000000000000000000",
+	DefaultBuilderGasLimit:           uint64(30000000),
 }
 
 // MainnetTestConfig provides a version of the mainnet config that has a different name

config/validator/service/BUILD.bazel

@@ -2,7 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library")
 
 go_library(
     name = "go_default_library",
-    srcs = ["fee-recipient-config.go"],
+    srcs = ["proposer-settings.go"],
     importpath = "github.com/prysmaticlabs/prysm/config/validator/service",
     visibility = ["//visibility:public"],
     deps = [

config/validator/service/fee-recipient-config.go

@@ -1,32 +0,0 @@
-package validator_service_config
-
-import (
-	"github.com/ethereum/go-ethereum/common"
-	field_params "github.com/prysmaticlabs/prysm/config/fieldparams"
-)
-
-// FeeRecipientFileConfig is the struct representation of the JSON config file set in the validator through the CLI.
-// ProposeConfig is the map of validator address to fee recipient options all in hex format.
-// DefaultConfig is the default fee recipient address for all validators unless otherwise specified in the propose config.required.
-type FeeRecipientFileConfig struct {
-	ProposeConfig map[string]*FeeRecipientFileOptions `json:"proposer_config"`
-	DefaultConfig *FeeRecipientFileOptions            `json:"default_config"`
-}
-
-// FeeRecipientFileOptions is the struct representation of the JSON config file set in the validator through the CLI.
-// FeeRecipient is set to an eth address in hex string format with 0x prefix.
-type FeeRecipientFileOptions struct {
-	FeeRecipient string `json:"fee_recipient"`
-}
-
-// FeeRecipientConfig is a Prysm internal representation of the fee recipient config on the validator client.
-// FeeRecipientFileConfig maps to FeeRecipientConfig on import through the CLI.
-type FeeRecipientConfig struct {
-	ProposeConfig map[[field_params.BLSPubkeyLength]byte]*FeeRecipientOptions
-	DefaultConfig *FeeRecipientOptions
-}
-
-// FeeRecipientOptions is a Prysm internal representation of the FeeRecipientFileOptions on the validator client in bytes format instead of hex.
-type FeeRecipientOptions struct {
-	FeeRecipient common.Address
-}

config/validator/service/proposer-settings.go

@@ -0,0 +1,35 @@
+package validator_service_config
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	field_params "github.com/prysmaticlabs/prysm/config/fieldparams"
+)
+
+// ProposerSettingsPayload is the struct representation of the JSON or YAML payload set in the validator through the CLI.
+// ProposeConfig is the map of validator address to fee recipient options all in hex format.
+// DefaultConfig is the default fee recipient address for all validators unless otherwise specified in the propose config.required.
+type ProposerSettingsPayload struct {
+	ProposeConfig map[string]*ProposerOptionPayload `json:"proposer_config" yaml:"proposer_config"`
+	DefaultConfig *ProposerOptionPayload            `json:"default_config" yaml:"default_config"`
+}
+
+// ProposerOptionPayload is the struct representation of the JSON config file set in the validator through the CLI.
+// FeeRecipient is set to an eth address in hex string format with 0x prefix.
+// GasLimit is a number set to help the network decide on the maximum gas in each block.
+type ProposerOptionPayload struct {
+	FeeRecipient string `json:"fee_recipient" yaml:"fee_recipient"`
+	GasLimit     uint64 `json:"gas_limit,omitempty" yaml:"gas_limit,omitempty"`
+}
+
+// ProposerSettings is a Prysm internal representation of the fee recipient config on the validator client.
+// ProposerSettingsPayload maps to ProposerSettings on import through the CLI.
+type ProposerSettings struct {
+	ProposeConfig map[[field_params.BLSPubkeyLength]byte]*ProposerOption
+	DefaultConfig *ProposerOption
+}
+
+// ProposerOption is a Prysm internal representation of the ProposerOptionPayload on the validator client in bytes format instead of hex.
+type ProposerOption struct {
+	FeeRecipient common.Address
+	GasLimit     uint64
+}

consensus-types/forks/bellatrix/execution_payload.go

@@ -3,11 +3,11 @@ package bellatrix
 import (
 	"bytes"
 
-	"github.com/prysmaticlabs/prysm/config/fieldparams"
+	field_params "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/encoding/ssz"
-	"github.com/prysmaticlabs/prysm/proto/engine/v1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
 
 // PayloadToHeader converts `payload` into execution payload header format.

consensus-types/interfaces/BUILD.bazel

@@ -13,6 +13,7 @@ go_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",

consensus-types/interfaces/beacon_block.go

@@ -6,6 +6,7 @@ import (
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	validatorpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/validator-client"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -24,7 +25,7 @@ type SignedBeaconBlock interface {
 	PbBlindedBellatrixBlock() (*ethpb.SignedBlindedBeaconBlockBellatrix, error)
 	ssz.Marshaler
 	ssz.Unmarshaler
-	Version() int
+	Version() version.ForkVersion
 	Header() (*ethpb.SignedBeaconBlockHeader, error)
 }
 
@@ -43,7 +44,7 @@ type BeaconBlock interface {
 	ssz.Marshaler
 	ssz.Unmarshaler
 	ssz.HashRoot
-	Version() int
+	Version() version.ForkVersion
 	AsSignRequestObject() validatorpb.SignRequestObject
 }
 

consensus-types/wrapper/beacon_block_altair.go

@@ -114,7 +114,7 @@ func (altairSignedBeaconBlock) PbBlindedBellatrixBlock() (*eth.SignedBlindedBeac
 }
 
 // Version of the underlying protobuf object.
-func (altairSignedBeaconBlock) Version() int {
+func (altairSignedBeaconBlock) Version() version.ForkVersion {
 	return version.Altair
 }
 
@@ -226,7 +226,7 @@ func (w altairBeaconBlock) Proto() proto.Message {
 }
 
 // Version of the underlying protobuf object.
-func (altairBeaconBlock) Version() int {
+func (altairBeaconBlock) Version() version.ForkVersion {
 	return version.Altair
 }
 

consensus-types/wrapper/beacon_block_bellatrix.go

@@ -109,7 +109,7 @@ func (bellatrixSignedBeaconBlock) PbAltairBlock() (*eth.SignedBeaconBlockAltair,
 }
 
 // Version of the underlying protobuf object.
-func (bellatrixSignedBeaconBlock) Version() int {
+func (bellatrixSignedBeaconBlock) Version() version.ForkVersion {
 	return version.Bellatrix
 }
 
@@ -221,7 +221,7 @@ func (w bellatrixBeaconBlock) Proto() proto.Message {
 }
 
 // Version of the underlying protobuf object.
-func (bellatrixBeaconBlock) Version() int {
+func (bellatrixBeaconBlock) Version() version.ForkVersion {
 	return version.Bellatrix
 }
 

consensus-types/wrapper/beacon_block_phase0.go

@@ -110,7 +110,7 @@ func (Phase0SignedBeaconBlock) PbBlindedBellatrixBlock() (*eth.SignedBlindedBeac
 }
 
 // Version of the underlying protobuf object.
-func (Phase0SignedBeaconBlock) Version() int {
+func (Phase0SignedBeaconBlock) Version() version.ForkVersion {
 	return version.Phase0
 }
 
@@ -218,7 +218,7 @@ func (w Phase0BeaconBlock) Proto() proto.Message {
 }
 
 // Version of the underlying protobuf object.
-func (Phase0BeaconBlock) Version() int {
+func (Phase0BeaconBlock) Version() version.ForkVersion {
 	return version.Phase0
 }