Merge branch 'develop' of https://github.com/prysmaticlabs/geth-sharding into moveCoreMethods

.github/CODEOWNERS

@@ -9,8 +9,8 @@ deps.bzl @prysmaticlabs/core-team
 
 # Radek and Nishant are responsible for changes that can affect the native state feature.
 # See https://www.notion.so/prysmaticlabs/Native-Beacon-State-Redesign-6cc9744b4ec1439bb34fa829b36a35c1
-/beacon-chain/state/fieldtrie/ @rkapka @nisdas @rauljordan
-/beacon-chain/state/v1/ @rkapka @nisdas @rauljordan
-/beacon-chain/state/v2/ @rkapka @nisdas @rauljordan
-/beacon-chain/state/v3/ @rkapka @nisdas @rauljordan
-/beacon-chain/state/state-native/ @rkapka @nisdas @rauljordan
+/beacon-chain/state/fieldtrie/ @rkapka @nisdas
+/beacon-chain/state/v1/ @rkapka @nisdas
+/beacon-chain/state/v2/ @rkapka @nisdas
+/beacon-chain/state/v3/ @rkapka @nisdas
+/beacon-chain/state/state-native/ @rkapka @nisdas

.github/workflows/approval_check.yaml

@@ -1,16 +0,0 @@
-name: PR approved and labeled
-
-on:
-  pull_request:
-    types: [ labeled ]
-
-jobs:
-  build:
-    if: ${{ github.event.label.name == 'CI' }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: trstringer/manual-approval@v1
-        with:
-          secret: ${{ github.TOKEN }}
-          approvers: potuz
-          minimum-approvals: 1

.github/workflows/go.yml

@@ -64,6 +64,7 @@ jobs:
       - name: Golangci-lint
         uses: golangci/golangci-lint-action@v2
         with:
+          args: --print-issued-lines --sort-results --no-config --timeout=10m --disable-all -E deadcode  -E errcheck -E gosimple --skip-files=validator/web/site_data.go --skip-dirs=proto --go=1.18
           version: v1.45.2
           skip-go-installation: true
 
@@ -87,14 +88,11 @@ jobs:
       - name: Build
         # Use blst tag to allow go and bazel builds for blst.
         run: go build -v ./...
-        env: 
-           CGO_CFLAGS: "-O -D__BLST_PORTABLE__"
+
         # fuzz leverage go tag based stubs at compile time.
         # Building and testing with these tags should be checked and enforced at pre-submit.
       - name: Test for fuzzing
         run: go test  -tags=fuzz,develop ./...  -test.run=^Fuzz
-        env: 
-           CGO_CFLAGS: "-O -D__BLST_PORTABLE__"
 
 # Tests run via Bazel for now...
 #      - name: Test

.gitignore

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

.golangci.yml

@@ -1,26 +1,69 @@
-run:
-  skip-files:
-    - validator/web/site_data.go
-    - .*_test.go
-  skip-dirs:
-    - proto
-    - tools/analyzers
-  timeout: 10m
-  go: '1.18'
+linters-settings:
+  govet:
+    check-shadowing: true
+    settings:
+      printf:
+        funcs:
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Infof
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Warnf
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Errorf
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Fatalf
+  golint:
+    min-confidence: 0
+  gocyclo:
+    min-complexity: 10
+  maligned:
+    suggest-new: true
+  dupl:
+    threshold: 100
+  goconst:
+    min-len: 2
+    min-occurrences: 2
+  depguard:
+    list-type: blacklist
+    packages:
+      # logging is allowed only by logutils.Log, logrus
+      # is allowed to use only in logutils package
+      - github.com/sirupsen/logrus
+  misspell:
+    locale: US
+  lll:
+    line-length: 140
+  goimports:
+    local-prefixes: github.com/golangci/golangci-lint
+  gocritic:
+    enabled-tags:
+      - performance
+      - style
+      - experimental
+    disabled-checks:
+      - wrapperFunc
 
 linters:
-  disable-all: true
   enable:
     - deadcode
-    - errcheck
-    - gosimple
-    - gocognit
+    - goconst
+    - goimports
+    - golint
+    - gosec
+    - misspell
+    - structcheck
+    - typecheck
+    - unparam
+    - varcheck
+    - gofmt
+    - unused
+  disable-all: true
 
-linters-settings:
-  gocognit:
-    # TODO: We should target for < 50
-    min-complexity: 97
+run:
+  skip-dirs:
+    - proto/
+    - ^contracts/
+  deadline: 10m
 
-output:
-  print-issued-lines: true
-  sort-results: true
+# golangci.com configuration
+# https://github.com/golangci/golangci/wiki/Configuration
+service:
+  golangci-lint-version: 1.15.0 # use the fixed version to not introduce new linters unexpectedly
+  prepare:
+    - echo "here I can run custom commands, but no preparation needed for this repo"

README.md

@@ -2,8 +2,7 @@
 
 [![Build status](https://badge.buildkite.com/b555891daf3614bae4284dcf365b2340cefc0089839526f096.svg?branch=master)](https://buildkite.com/prysmatic-labs/prysm)
 [![Go Report Card](https://goreportcard.com/badge/github.com/prysmaticlabs/prysm)](https://goreportcard.com/report/github.com/prysmaticlabs/prysm)
-[![Consensus_Spec_Version 1.2.0-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)
+[![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)
 [![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/builder/BUILD.bazel

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

api/client/builder/client.go

@@ -28,7 +28,6 @@ const (
 )
 
 var errMalformedHostname = errors.New("hostname must include port, separated by one colon, like example.com:3500")
-var errMalformedRequest = errors.New("required request data are missing")
 
 // ClientOpt is a functional option for the Client type (http.Client wrapper)
 type ClientOpt func(*Client)
@@ -200,15 +199,9 @@ func (c *Client) GetHeader(ctx context.Context, slot types.Slot, parentHash [32]
 
 // RegisterValidator encodes the SignedValidatorRegistrationV1 message to json (including hex-encoding the byte
 // fields with 0x prefixes) and posts to the builder validator registration endpoint.
-func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValidatorRegistrationV1) error {
-	if len(svr) == 0 {
-		return errors.Wrap(errMalformedRequest, "empty validator registration list")
-	}
-	vs := make([]*SignedValidatorRegistration, len(svr))
-	for i := 0; i < len(svr); i++ {
-		vs[i] = &SignedValidatorRegistration{SignedValidatorRegistrationV1: svr[i]}
-	}
-	body, err := json.Marshal(vs)
+func (c *Client) RegisterValidator(ctx context.Context, svr *ethpb.SignedValidatorRegistrationV1) error {
+	v := &SignedValidatorRegistration{SignedValidatorRegistrationV1: svr}
+	body, err := json.Marshal(v)
 	if err != nil {
 		return errors.Wrap(err, "error encoding the SignedValidatorRegistration value body in RegisterValidator")
 	}

api/client/builder/client_test.go

@@ -11,7 +11,7 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/config/params"
+	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -73,7 +73,7 @@ func TestClient_Status(t *testing.T) {
 
 func TestClient_RegisterValidator(t *testing.T) {
 	ctx := context.Background()
-	expectedBody := `[{"message":{"fee_recipient":"0x0000000000000000000000000000000000000000","gas_limit":"23","timestamp":"42","pubkey":"0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"}}]`
+	expectedBody := `{"message":{"fee_recipient":"0x0000000000000000000000000000000000000000","gas_limit":"23","timestamp":"42","pubkey":"0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"}}`
 	expectedPath := "/eth/v1/builder/validators"
 	hc := &http.Client{
 		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
@@ -98,13 +98,13 @@ func TestClient_RegisterValidator(t *testing.T) {
 	}
 	reg := &eth.SignedValidatorRegistrationV1{
 		Message: &eth.ValidatorRegistrationV1{
-			FeeRecipient: ezDecode(t, params.BeaconConfig().EthBurnAddressHex),
+			FeeRecipient: ezDecode(t, fieldparams.EthBurnAddressHex),
 			GasLimit:     23,
 			Timestamp:    42,
 			Pubkey:       ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
 		},
 	}
-	require.NoError(t, c.RegisterValidator(ctx, []*eth.SignedValidatorRegistrationV1{reg}))
+	require.NoError(t, c.RegisterValidator(ctx, reg))
 }
 
 func TestClient_GetHeader(t *testing.T) {

api/client/builder/types.go

@@ -63,7 +63,7 @@ func sszBytesToUint256(b []byte) Uint256 {
 
 // SSZBytes creates an ssz-style (little-endian byte slice) representation of the Uint256
 func (s Uint256) SSZBytes() []byte {
-	return bytesutil.PadTo(bytesutil.ReverseByteOrder(s.Int.Bytes()), 32)
+	return bytesutil.ReverseByteOrder(s.Int.Bytes())
 }
 
 var errUnmarshalUint256Failed = errors.New("unable to UnmarshalText into a Uint256 value")

api/client/builder/types_test.go

@@ -694,10 +694,9 @@ func TestMarshalBlindedBeaconBlockBodyBellatrix(t *testing.T) {
 }
 
 func TestRoundTripUint256(t *testing.T) {
-	vs := "4523128485832663883733241601901871400518358776001584532791311875309106626"
+	vs := "452312848583266388373324160190187140051835877600158453279131187530910662656"
 	u := stringToUint256(vs)
 	sb := u.SSZBytes()
-	require.Equal(t, 32, len(sb))
 	uu := sszBytesToUint256(sb)
 	require.Equal(t, true, bytes.Equal(u.SSZBytes(), uu.SSZBytes()))
 	require.Equal(t, vs, uu.String())

api/gateway/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "gateway.go",
         "log.go",
-        "modifiers.go",
         "options.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/api/gateway",
@@ -24,7 +23,6 @@ go_library(
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//connectivity:go_default_library",
         "@org_golang_google_grpc//credentials:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
 

api/gateway/apimiddleware/BUILD.bazel

@@ -15,7 +15,6 @@ go_library(
     deps = [
         "//api/grpc:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_gorilla_mux//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

api/gateway/apimiddleware/api_middleware.go

@@ -111,7 +111,7 @@ func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
 			}
 		}
 
-		if req.Method == "DELETE" && req.Body != http.NoBody {
+		if req.Method == "DELETE" {
 			if errJson := handleDeleteRequestForEndpoint(endpoint, req); errJson != nil {
 				WriteError(w, errJson, nil)
 				return

api/gateway/apimiddleware/process_field.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/go-bytesutil"
@@ -32,26 +31,26 @@ func processField(s interface{}, processors []fieldProcessor) error {
 			sliceElem := t.Field(i).Type.Elem()
 			kind := sliceElem.Kind()
 			// Recursively process slices to struct pointers.
-			switch {
-			case kind == reflect.Ptr && sliceElem.Elem().Kind() == reflect.Struct:
+			if kind == reflect.Ptr && sliceElem.Elem().Kind() == reflect.Struct {
 				for j := 0; j < v.Field(i).Len(); j++ {
 					if err := processField(v.Field(i).Index(j).Interface(), processors); err != nil {
 						return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
 					}
 				}
+			}
 			// Process each string in string slices.
-			case kind == reflect.String:
+			if kind == reflect.String {
 				for _, proc := range processors {
 					_, hasTag := t.Field(i).Tag.Lookup(proc.tag)
-					if !hasTag {
-						continue
-					}
-					for j := 0; j < v.Field(i).Len(); j++ {
-						if err := proc.f(v.Field(i).Index(j)); err != nil {
-							return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
+					if hasTag {
+						for j := 0; j < v.Field(i).Len(); j++ {
+							if err := proc.f(v.Field(i).Index(j)); err != nil {
+								return errors.Wrapf(err, "could not process field '%s'", t.Field(i).Name)
+							}
 						}
 					}
 				}
+
 			}
 		// Recursively process struct pointers.
 		case reflect.Ptr:
@@ -101,20 +100,6 @@ func base64ToHexProcessor(v reflect.Value) error {
 	return nil
 }
 
-func base64ToChecksumAddressProcessor(v reflect.Value) error {
-	if v.String() == "" {
-		// Empty hex values are represented as "0x".
-		v.SetString("0x")
-		return nil
-	}
-	b, err := base64.StdEncoding.DecodeString(v.String())
-	if err != nil {
-		return err
-	}
-	v.SetString(common.BytesToAddress(b).Hex())
-	return nil
-}
-
 func base64ToUint256Processor(v reflect.Value) error {
 	if v.String() == "" {
 		return nil

api/gateway/apimiddleware/process_request.go

@@ -104,8 +104,6 @@ func ReadGrpcResponseBody(r io.Reader) ([]byte, ErrorJson) {
 }
 
 // HandleGrpcResponseError acts on an error that resulted from a grpc-gateway's response.
-// Whether there was an error is indicated by the bool return value. In case of an error,
-// there is no need to write to the response because it's taken care of by the function.
 func HandleGrpcResponseError(errJson ErrorJson, resp *http.Response, respBody []byte, w http.ResponseWriter) (bool, ErrorJson) {
 	responseHasError := false
 	if err := json.Unmarshal(respBody, errJson); err != nil {
@@ -151,10 +149,6 @@ func ProcessMiddlewareResponseFields(responseContainer interface{}) ErrorJson {
 			tag: "hex",
 			f:   base64ToHexProcessor,
 		},
-		{
-			tag: "address",
-			f:   base64ToChecksumAddressProcessor,
-		},
 		{
 			tag: "enum",
 			f:   enumToLowercaseProcessor,

api/gateway/apimiddleware/process_request_test.go

@@ -31,25 +31,21 @@ func defaultRequestContainer() *testRequestContainer {
 }
 
 type testResponseContainer struct {
-	TestString       string
-	TestHex          string `hex:"true"`
-	TestEmptyHex     string `hex:"true"`
-	TestAddress      string `address:"true"`
-	TestEmptyAddress string `address:"true"`
-	TestUint256      string `uint256:"true"`
-	TestEnum         string `enum:"true"`
-	TestTime         string `time:"true"`
+	TestString   string
+	TestHex      string `hex:"true"`
+	TestEmptyHex string `hex:"true"`
+	TestUint256  string `uint256:"true"`
+	TestEnum     string `enum:"true"`
+	TestTime     string `time:"true"`
 }
 
 func defaultResponseContainer() *testResponseContainer {
 	return &testResponseContainer{
-		TestString:       "test string",
-		TestHex:          "Zm9v", // base64 encoding of "foo"
-		TestEmptyHex:     "",
-		TestAddress:      "Zm9v",
-		TestEmptyAddress: "",
-		TestEnum:         "Test Enum",
-		TestTime:         "2006-01-02T15:04:05Z",
+		TestString:   "test string",
+		TestHex:      "Zm9v", // base64 encoding of "foo"
+		TestEmptyHex: "",
+		TestEnum:     "Test Enum",
+		TestTime:     "2006-01-02T15:04:05Z",
 
 		// base64 encoding of 4196 in little-endian
 		TestUint256: "ZBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
@@ -251,8 +247,6 @@ func TestProcessMiddlewareResponseFields(t *testing.T) {
 		require.Equal(t, true, errJson == nil)
 		assert.Equal(t, "0x666f6f", container.TestHex)
 		assert.Equal(t, "0x", container.TestEmptyHex)
-		assert.Equal(t, "0x0000000000000000000000000000000000666F6f", container.TestAddress)
-		assert.Equal(t, "0x", container.TestEmptyAddress)
 		assert.Equal(t, "4196", container.TestUint256)
 		assert.Equal(t, "test enum", container.TestEnum)
 		assert.Equal(t, "1136214245", container.TestTime)
@@ -298,7 +292,7 @@ func TestWriteMiddlewareResponseHeadersAndBody(t *testing.T) {
 		v, ok = writer.Header()["Content-Length"]
 		require.Equal(t, true, ok, "header not found")
 		require.Equal(t, 1, len(v), "wrong number of header values")
-		assert.Equal(t, "224", v[0])
+		assert.Equal(t, "181", v[0])
 		assert.Equal(t, 204, writer.Code)
 		assert.DeepEqual(t, responseJson, writer.Body.Bytes())
 	})

api/gateway/gateway.go

@@ -121,9 +121,8 @@ func (g *Gateway) Start() {
 	}
 
 	g.server = &http.Server{
-		Addr:              g.cfg.gatewayAddr,
-		Handler:           corsMux,
-		ReadHeaderTimeout: time.Second,
+		Addr:    g.cfg.gatewayAddr,
+		Handler: corsMux,
 	}
 
 	go func() {

api/gateway/modifiers.go

@@ -1,30 +0,0 @@
-package gateway
-
-import (
-	"context"
-	"net/http"
-	"strconv"
-
-	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	"google.golang.org/protobuf/proto"
-)
-
-func HttpResponseModifier(ctx context.Context, w http.ResponseWriter, resp proto.Message) error {
-	md, ok := gwruntime.ServerMetadataFromContext(ctx)
-	if !ok {
-		return nil
-	}
-	// set http status code
-	if vals := md.HeaderMD.Get("x-http-code"); len(vals) > 0 {
-		code, err := strconv.Atoi(vals[0])
-		if err != nil {
-			return err
-		}
-		// delete the headers to not expose any grpc-metadata in http response
-		delete(md.HeaderMD, "x-http-code")
-		delete(w.Header(), "Grpc-Metadata-X-Http-Code")
-		w.WriteHeader(code)
-	}
-
-	return nil
-}

beacon-chain/blockchain/BUILD.bazel

@@ -10,7 +10,6 @@ go_library(
         "head_sync_committee_info.go",
         "init_sync_process_block.go",
         "log.go",
-        "merge_ascii_art.go",
         "metrics.go",
         "new_slot.go",
         "options.go",

beacon-chain/blockchain/chain_info_test.go

@@ -37,8 +37,8 @@ func prepareForkchoiceState(
 	blockRoot [32]byte,
 	parentRoot [32]byte,
 	payloadHash [32]byte,
-	justified *ethpb.Checkpoint,
-	finalized *ethpb.Checkpoint,
+	justifiedEpoch types.Epoch,
+	finalizedEpoch types.Epoch,
 ) (state.BeaconState, [32]byte, error) {
 	blockHeader := &ethpb.BeaconBlockHeader{
 		ParentRoot: parentRoot[:],
@@ -48,12 +48,20 @@ func prepareForkchoiceState(
 		BlockHash: payloadHash[:],
 	}
 
+	justifiedCheckpoint := &ethpb.Checkpoint{
+		Epoch: justifiedEpoch,
+	}
+
+	finalizedCheckpoint := &ethpb.Checkpoint{
+		Epoch: finalizedEpoch,
+	}
+
 	base := &ethpb.BeaconStateBellatrix{
 		Slot:                         slot,
 		RandaoMixes:                  make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 		BlockRoots:                   make([][]byte, 1),
-		CurrentJustifiedCheckpoint:   justified,
-		FinalizedCheckpoint:          finalized,
+		CurrentJustifiedCheckpoint:   justifiedCheckpoint,
+		FinalizedCheckpoint:          finalizedCheckpoint,
 		LatestExecutionPayloadHeader: executionHeader,
 		LatestBlockHeader:            blockHeader,
 	}
@@ -72,9 +80,9 @@ func TestHeadRoot_Nil(t *testing.T) {
 }
 
 func TestService_ForkChoiceStore(t *testing.T) {
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
+	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}}
 	p := c.ForkChoiceStore()
-	require.Equal(t, types.Epoch(0), p.FinalizedCheckpoint().Epoch)
+	require.Equal(t, 0, int(p.FinalizedEpoch()))
 }
 
 func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
@@ -319,22 +327,20 @@ func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
 }
 func TestService_ChainHeads_ProtoArray(t *testing.T) {
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0)}}
+	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [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, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	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{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [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, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
@@ -343,33 +349,22 @@ 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()}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	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)
 	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, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [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, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	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, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [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, 103, [32]byte{'d'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
-	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, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
@@ -448,13 +443,11 @@ func TestService_IsOptimistic_ProtoArray(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
@@ -470,13 +463,11 @@ func TestService_IsOptimistic_DoublyLinkedTree(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 
 	ctx := context.Background()
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
@@ -495,13 +486,11 @@ func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
 
 func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) {
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
@@ -512,13 +501,11 @@ func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) {
 
 func TestService_IsOptimisticForRoot_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
-	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
@@ -530,7 +517,7 @@ func TestService_IsOptimisticForRoot_DoublyLinkedTree(t *testing.T) {
 func TestService_IsOptimisticForRoot_DB_ProtoArray(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
@@ -595,7 +582,7 @@ func TestService_IsOptimisticForRoot_DB_ProtoArray(t *testing.T) {
 func TestService_IsOptimisticForRoot_DB_DoublyLinkedTree(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10
@@ -659,7 +646,7 @@ func TestService_IsOptimisticForRoot_DB_DoublyLinkedTree(t *testing.T) {
 func TestService_IsOptimisticForRoot_DB_non_canonical(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
 	c.head = &head{root: params.BeaconConfig().ZeroHash}
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 10

beacon-chain/blockchain/checktags_test.go

@@ -1,4 +1,5 @@
 //go:build !develop
+// +build !develop
 
 package blockchain
 

beacon-chain/blockchain/execution_engine.go

@@ -12,6 +12,7 @@ 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"
@@ -90,7 +91,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 				return nil, err
 			}
 
-			r, err := s.cfg.ForkChoiceStore.Head(ctx, s.justifiedBalances.balances)
+			r, err := s.updateHead(ctx, s.justifiedBalances.balances)
 			if err != nil {
 				return nil, err
 			}
@@ -269,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() == params.BeaconConfig().EthBurnAddressHex {
+		if feeRecipient.String() == fieldparams.EthBurnAddressHex {
 			logrus.WithFields(logrus.Fields{
 				"validatorIndex": proposerID,
-				"burnAddress":    params.BeaconConfig().EthBurnAddressHex,
+				"burnAddress":    fieldparams.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

@@ -11,7 +11,6 @@ import (
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	bstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -44,7 +43,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, altairBlk))
 	require.NoError(t, beaconDB.SaveBlock(ctx, bellatrixBlk))
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -57,15 +56,13 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 		state: st,
 	}
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -187,7 +184,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 			st, _ := util.DeterministicGenesisState(t, 1)
 			require.NoError(t, beaconDB.SaveState(ctx, st, tt.finalizedRoot))
 			require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, tt.finalizedRoot))
-			fc := &ethpb.Checkpoint{Epoch: 0, Root: tt.finalizedRoot[:]}
+			fc := &ethpb.Checkpoint{Epoch: 1, Root: tt.finalizedRoot[:]}
 			service.store.SetFinalizedCheckptAndPayloadHash(fc, [32]byte{'a'})
 			service.store.SetJustifiedCheckptAndPayloadHash(fc, [32]byte{'b'})
 			arg := &notifyForkchoiceUpdateArg{
@@ -292,7 +289,7 @@ func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, wbg))
 
 	// Insert blocks into forkchoice
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -302,27 +299,25 @@ func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	service.justifiedBalances.balances = []uint64{50, 100, 200}
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 5, bre, brb, [32]byte{'E'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 5, bre, brb, [32]byte{'E'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 6, brf, bre, [32]byte{'F'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 6, brf, bre, [32]byte{'F'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 7, brg, bre, [32]byte{'G'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 7, brg, bre, [32]byte{'G'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -331,9 +326,7 @@ func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
 	fcs.ProcessAttestation(ctx, []uint64{0}, brd, 1)
 	fcs.ProcessAttestation(ctx, []uint64{1}, brf, 1)
 	fcs.ProcessAttestation(ctx, []uint64{2}, brg, 1)
-	jc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: bra}
-	require.NoError(t, fcs.UpdateJustifiedCheckpoint(jc))
-	headRoot, err := fcs.Head(ctx, []uint64{50, 100, 200})
+	headRoot, err := fcs.Head(ctx, bra, []uint64{50, 100, 200})
 	require.NoError(t, err)
 	require.Equal(t, brg, headRoot)
 
@@ -354,7 +347,7 @@ func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
 	_, err = service.notifyForkchoiceUpdate(ctx, a)
 	require.ErrorIs(t, ErrInvalidPayload, err)
 	// Ensure Head is D
-	headRoot, err = fcs.Head(ctx, service.justifiedBalances.balances)
+	headRoot, err = fcs.Head(ctx, bra, service.justifiedBalances.balances)
 	require.NoError(t, err)
 	require.Equal(t, brd, headRoot)
 
@@ -371,7 +364,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -409,16 +402,12 @@ func Test_NotifyNewPayload(t *testing.T) {
 	require.NoError(t, err)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
-	service.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
 	r, err := bellatrixBlk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, r, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, r, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -567,7 +556,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 			}
 			service.cfg.ExecutionEngineCaller = e
 			root := [32]byte{'a'}
-			state, blkRoot, err := prepareForkchoiceState(ctx, 0, root, root, params.BeaconConfig().ZeroHash, ojc, ofc)
+			state, blkRoot, err := prepareForkchoiceState(ctx, 0, root, root, params.BeaconConfig().ZeroHash, 0, 0)
 			require.NoError(t, err)
 			require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 			postVersion, postHeader, err := getStateVersionAndPayload(tt.postState)
@@ -593,7 +582,7 @@ func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -636,7 +625,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -817,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, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(attr.SuggestedFeeRecipient).String())
+	require.Equal(t, fieldparams.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
@@ -838,7 +827,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	stateGen := stategen.New(beaconDB)
-	fcs := doublylinkedtree.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stateGen),
@@ -854,15 +843,9 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	genesisRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
 	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	fjc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash}
-	require.NoError(t, fcs.UpdateJustifiedCheckpoint(fjc))
-	require.NoError(t, fcs.UpdateFinalizedCheckpoint(fjc))
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, genesisRoot, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, genesisRoot, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	fcs.SetOriginRoot(genesisRoot)
 	genesisSummary := &ethpb.StateSummary{
 		Root: genesisStateRoot[:],
 		Slot: 0,
@@ -893,9 +876,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 		Slot: 320,
 	}
 	require.NoError(t, beaconDB.SaveStateSummary(ctx, opStateSummary))
-	tenjc := &ethpb.Checkpoint{Epoch: 10, Root: genesisRoot[:]}
-	tenfc := &ethpb.Checkpoint{Epoch: 10, Root: genesisRoot[:]}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 320, opRoot, genesisRoot, params.BeaconConfig().ZeroHash, tenjc, tenfc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 320, opRoot, genesisRoot, params.BeaconConfig().ZeroHash, 10, 10)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, opRoot))
@@ -924,9 +905,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 		Slot: 640,
 	}
 	require.NoError(t, beaconDB.SaveStateSummary(ctx, validSummary))
-	twentyjc := &ethpb.Checkpoint{Epoch: 20, Root: validRoot[:]}
-	twentyfc := &ethpb.Checkpoint{Epoch: 20, Root: validRoot[:]}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 640, validRoot, genesisRoot, params.BeaconConfig().ZeroHash, twentyjc, twentyfc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 640, validRoot, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 20, 20)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, fcs.SetOptimisticToValid(ctx, validRoot))
@@ -948,7 +927,7 @@ func TestService_removeInvalidBlockAndState(t *testing.T) {
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -1004,7 +983,7 @@ func TestService_getPayloadHash(t *testing.T) {
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)

beacon-chain/blockchain/head.go

@@ -10,7 +10,10 @@ import (
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
+	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/features"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
@@ -36,7 +39,7 @@ func (s *Service) UpdateAndSaveHeadWithBalances(ctx context.Context) error {
 		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", jp.Root)
 		return errors.Wrap(err, msg)
 	}
-	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx, balances)
+	headRoot, err := s.updateHead(ctx, balances)
 	if err != nil {
 		return errors.Wrap(err, "could not update head")
 	}
@@ -59,6 +62,51 @@ type head struct {
 	state state.BeaconState            // current head state.
 }
 
+// Determined the head from the fork choice service and saves its new data
+// (head root, head block, and head state) to the local service cache.
+func (s *Service) updateHead(ctx context.Context, balances []uint64) ([32]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.updateHead")
+	defer span.End()
+
+	// Get head from the fork choice service.
+	f, err := s.store.FinalizedCheckpt()
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not get finalized checkpoint")
+	}
+	j, err := s.store.JustifiedCheckpt()
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not get justified checkpoint")
+	}
+	// To get head before the first justified epoch, the fork choice will start with origin root
+	// instead of zero hashes.
+	headStartRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(j.Root))
+
+	// In order to process head, fork choice store requires justified info.
+	// If the fork choice store is missing justified block info, a node should
+	// re-initiate fork choice store using the latest justified info.
+	// This recovers a fatal condition and should not happen in run time.
+	if !s.cfg.ForkChoiceStore.HasNode(headStartRoot) {
+		jb, err := s.getBlock(ctx, headStartRoot)
+		if err != nil {
+			return [32]byte{}, err
+		}
+		st, err := s.cfg.StateGen.StateByRoot(ctx, s.ensureRootNotZeros(headStartRoot))
+		if err != nil {
+			return [32]byte{}, err
+		}
+		if features.Get().EnableForkChoiceDoublyLinkedTree {
+			s.cfg.ForkChoiceStore = doublylinkedtree.New(j.Epoch, f.Epoch)
+		} else {
+			s.cfg.ForkChoiceStore = protoarray.New(j.Epoch, f.Epoch)
+		}
+		if err := s.insertBlockToForkChoiceStore(ctx, jb.Block(), headStartRoot, st, f, j); err != nil {
+			return [32]byte{}, err
+		}
+	}
+
+	return s.cfg.ForkChoiceStore.Head(ctx, headStartRoot, balances)
+}
+
 // This saves head info to the local service cache, it also saves the
 // new head root to the DB.
 func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock interfaces.SignedBeaconBlock, headState state.BeaconState) error {

beacon-chain/blockchain/head_test.go

@@ -52,9 +52,7 @@ func TestSaveHead_Different(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
 	oldRoot, err := oldBlock.Block().HashTreeRoot()
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, bytesutil.ToBytes32(oldBlock.Block().ParentRoot()), [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, bytesutil.ToBytes32(oldBlock.Block().ParentRoot()), [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	service.head = &head{
@@ -72,7 +70,7 @@ func TestSaveHead_Different(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wsb))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, bytesutil.ToBytes32(wsb.Block().ParentRoot()), [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, bytesutil.ToBytes32(wsb.Block().ParentRoot()), [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	headState, err := util.NewBeaconState()
@@ -104,9 +102,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
 	oldRoot, err := oldBlock.Block().HashTreeRoot()
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, bytesutil.ToBytes32(oldBlock.Block().ParentRoot()), [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, bytesutil.ToBytes32(oldBlock.Block().ParentRoot()), [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	service.head = &head{
@@ -126,7 +122,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wsb))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, bytesutil.ToBytes32(wsb.Block().ParentRoot()), [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, bytesutil.ToBytes32(wsb.Block().ParentRoot()), [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	headState, err := util.NewBeaconState()
@@ -162,6 +158,28 @@ func TestCacheJustifiedStateBalances_CanCache(t *testing.T) {
 	require.DeepEqual(t, balances, state.Balances(), "Incorrect justified balances")
 }
 
+func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+
+	b := util.NewBeaconBlock()
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wsb))
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	state, _ := util.DeterministicGenesisState(t, 1)
+	require.NoError(t, service.cfg.BeaconDB.SaveState(context.Background(), state, r))
+
+	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: r[:]}, [32]byte{'a'})
+	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{}, [32]byte{'b'})
+	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{})
+	headRoot, err := service.updateHead(context.Background(), []uint64{})
+	require.NoError(t, err)
+	st, _ := util.DeterministicGenesisState(t, 1)
+	require.NoError(t, service.saveHead(context.Background(), headRoot, wsb, st))
+}
+
 func Test_notifyNewHeadEvent(t *testing.T) {
 	t.Run("genesis_state_root", func(t *testing.T) {
 		bState, _ := util.DeterministicGenesisState(t, 10)
@@ -272,9 +290,7 @@ func TestSaveOrphanedAtts_NoCommonAncestor(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-		ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
 		b, err := wrapper.WrappedSignedBeaconBlock(blk)
@@ -327,13 +343,11 @@ func TestSaveOrphanedAtts(t *testing.T) {
 	blk4.Block.ParentRoot = rG[:]
 	r4, err := blk4.Block.HashTreeRoot()
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
 		b, err := wrapper.WrappedSignedBeaconBlock(blk)
@@ -390,13 +404,11 @@ func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
 	blk4.Block.ParentRoot = rG[:]
 	r4, err := blk4.Block.HashTreeRoot()
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
 		b, err := wrapper.WrappedSignedBeaconBlock(blk)
@@ -454,12 +466,10 @@ func TestSaveOrphanedAtts_NoCommonAncestor_DoublyLinkedTrie(t *testing.T) {
 	r4, err := blk4.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
 		b, err := wrapper.WrappedSignedBeaconBlock(blk)
@@ -518,12 +528,10 @@ func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
 	r4, err := blk4.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
 		b, err := wrapper.WrappedSignedBeaconBlock(blk)
@@ -586,12 +594,10 @@ func TestSaveOrphanedAtts_CanFilter_DoublyLinkedTrie(t *testing.T) {
 	r4, err := blk4.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, service.ForkChoicer().InsertNode(ctx, state, blkRoot))
 		b, err := wrapper.WrappedSignedBeaconBlock(blk)
@@ -607,7 +613,7 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 	ctx := context.Background()
 
 	beaconDB := testDB.SetupDB(t)
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -616,10 +622,6 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	ojp := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, ojp, ojp)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, st, blkRoot))
 
 	bellatrixBlk, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlockBellatrix())
 	require.NoError(t, err)
@@ -628,7 +630,7 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, bellatrixBlk))
 	fcp := &ethpb.Checkpoint{
 		Root:  bellatrixBlkRoot[:],
-		Epoch: 0,
+		Epoch: 1,
 	}
 	service.store.SetFinalizedCheckptAndPayloadHash(fcp, [32]byte{'a'})
 	service.store.SetJustifiedCheckptAndPayloadHash(fcp, [32]byte{'b'})
@@ -641,10 +643,10 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 	headRoot := service.headRoot()
 	require.Equal(t, [32]byte{}, headRoot)
 
-	st, blkRoot, err = prepareForkchoiceState(ctx, 0, bellatrixBlkRoot, [32]byte{}, [32]byte{}, fcp, fcp)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 0, bellatrixBlkRoot, [32]byte{}, [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, blkRoot))
-	newRoot, err := service.cfg.ForkChoiceStore.Head(ctx, []uint64{1, 2})
+	newRoot, err := service.updateHead(ctx, []uint64{1, 2})
 	require.NoError(t, err)
 	require.NotEqual(t, headRoot, newRoot)
 	require.Equal(t, headRoot, service.headRoot())

beacon-chain/blockchain/log.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
@@ -82,30 +80,3 @@ func logBlockSyncStatus(block interfaces.BeaconBlock, blockRoot [32]byte, justif
 	}).Info("Synced new block")
 	return nil
 }
-
-// logs payload related data every slot.
-func logPayload(block interfaces.BeaconBlock) error {
-	isExecutionBlk, err := blocks.IsExecutionBlock(block.Body())
-	if err != nil {
-		return errors.Wrap(err, "could not determine if block is execution block")
-	}
-	if !isExecutionBlk {
-		return nil
-	}
-	payload, err := block.Body().ExecutionPayload()
-	if err != nil {
-		return err
-	}
-	if payload.GasLimit == 0 {
-		return errors.New("gas limit should not be 0")
-	}
-	gasUtilized := float64(payload.GasUsed) / float64(payload.GasLimit)
-
-	log.WithFields(logrus.Fields{
-		"blockHash":   fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
-		"parentHash":  fmt.Sprintf("%#x", bytesutil.Trunc(payload.ParentHash)),
-		"blockNumber": payload.BlockNumber,
-		"gasUtilized": fmt.Sprintf("%.2f", gasUtilized),
-	}).Debug("Synced new payload")
-	return nil
-}

beacon-chain/blockchain/merge_ascii_art.go

@@ -1,81 +0,0 @@
-package blockchain
-
-var mergeAsciiArt = `                                                                                                                                                  	                                                                                                                                                      
-		                                                                                                                                                      
-		                                 +?$$$$$$?*;                         ;*?$$$$?*;                         +!$$$$$$?!;                                   
-		                                 !##$???$@##$+                      !&#@$??$&#@*                      +@#&$????$##+                                   
-		                                 !##;     +@#&;                    !##*     ;$##*                     @#$      ;&#+                                   
-		                                 !##;      !##+                   ;##$        @#@                     $#&*      ++;                                   
-		                                 !##;     ;@#&;                   *##*        ?##;                    ;$##&$!+;                                       
-		                                 !##?!!!?$##$+                    !##+        !##+                      ;!$@##&$!;                                    
-		                                 !##@@@@$$!+                      *##*        ?##;                          ;*?@#&!                                   
-		                                 !##;                             ;##$        @#@                    ;?$;       ?##+                                  
-		                                 !##;                              ?##!     ;?##+                    ;##+      ;$#&;                                  
-		                                 !##;                               !&#&$??$&#@*                     ;&#&$$??$$&#@+                                   
-		                                 +??;                                ;*?$$$$?+                        ;+!?$$$$$!+                                     
-		                                                                                                ;;;;                                                  
-		                                      ;+!??$$$?!*+;                                       ;*?$@&&&&&@@$!*;                                            
-		                                   *?@############&$?+                                 ;!@###############&$!;                                         
-		                                ;!@####&@$????$$@#####@!                             ;?&####$?*++;++*!?@####&?;                                       
-		                               *@###&$*;         ;*$&###@*                          *&###@!;            ;!@###&!                                      
-		                              !###&!;               ;?&###?                        *####!                  *&###?                                     
-		                             !###@+                   ;$###$                      +###&+                    ;$###?                                    
-		                            ;###&;                      $###?   ;;+*!??$$$$$$$$??!$###*                      ;@###*                                   
-		                            !###!                        &###?$@&#####################@$?!+;                  +###$                                   
-		                            $###+                     ;*?&#################################&$?*;               &##&;                                  
-		                            $###+                  ;!$&########################################&$!;            &###;                                  
-		                            *###?               ;!$################################################$*;        +###@                                   
-		                            ;@###+            +$&####################################################&?;      $###!                                   
-		                             +###&+         *$##########################################################$+  ;$###$;                                   
-		                              *&###?;     +$##############################################################?*@###$;                                    
-		                               +$###&?+ ;$#####################################################################?;                                     
-		                                 *@####@&#####################################################################*                                       
-		                                   +$&##################@?!*++*!$&###################&$?*++*!?$###############&*                                      
-		                                     $###############&?+         ;!@###############@!;         ;!@##############!                                     
-		                                   ;$##############&!;              *&###########&!;              !&#############!                                    
-		                                   $##############@+    +@*          ;$#########$;          +@*    ;$#############!                                   
-		                                  ?##############$;    *###*           $#######$;          +&##!     ?#############+                                  
-		                                 +##############$     !#####!           $#####@;          *#####?     ?############@;                                 
-		                                 @#############@;    !#######!          ;&####+          *#######?     $############?                                 
-		                                +##############+    ?#########?          $###$          !#########$    +############&;                                
-		                                $#############$   ;$###########?         !###?         !###########$;   $############!                                
-		                                @#############*   !#############!        ?###$        *#############?   +############@                                
-		                               ;&############&;    +?@#######&$+;       ;&####;       ;+?@#######&?+;    @############;                               
-		                               ;#############@        +$&#&$*;         ;$#####@;          +$&#&$*;       $############+                               
-		                               ;#############$    *+    ;+;   ;*;     *&#######&!     ;*;   ;+;    +*;   $############*                               
-		                                &############@    ;$@!;     +$@!    ;?###########$;    *@$*     ;*$@+    $############*                               
-		                                $############&;    ;$#&$*+!@##*    +@#############@+    +&#@?++$&#@;     @############+                               
-		                                *#############*      $######&+    !#################?    +@######$;     +#############;                               
-		                                 @############$       ?####@+   ;$###################$;   ;@####$       $############@                                
-		                                 *#############*       !##@;   +@#####################&*   ;$##?       +#############!                                
-		                                  $#############+       *$;   ?#########################?;   $!       +&############&;                                
-		                                  ;&#############!          +$###########################@+          *&#############?                                 
-		                                   +##############$*;     ;?###############################$+      *$##############@;                                 
-		                                    *###############&$?!!$###################################$?!?$&################+                                  
-		                                     *###################################&@$$$$@&#################################!                                   
-		                                      +&##############################&?+;      ;+?&#############################?                                    
-		                                       ;$############################@;            ;@###########################!                                     
-		                                         ?###########################*              *##########################*                                      
-		                                          +@#############&$!+$#######?              ?########$+!$&###########@+                                       
-		                                            !&###########&;   $#######$+          +$########?   +&##########?;                                        
-		                                             ;?###########&*   *@#######@$!;   ;$@########@*   *##########$+                                          
-		                                               ;?&##########?;  ;*$&####&$*    ;!$&####&$*   ;$#########@*                                            
-		                                                 ;!@#########@!;   ;++*+;   ;*;   ;+*++;   ;!&########$*                                              
-		                                                    *$&########&$*;      ;*$&#&$*;      +*$&#######&?+                                                
-		                                                      ;*$&#########&@$$@&#########&@$$@&########&$*;                                                  
-		                                                         ;+?$&##############################&$?+;                                                     
-		                                                             ;+!?$@&###################&$$!+;                                                         
-		                                                                   ;++*!??$$$$$$$?!!*+;                                                               
-		                                                                                                                                                      
-		                  ;;;           ;;+*++;   ;;;++;;;++;;;  ;+++;;;++++; ;;;         ;;      ;;;      ;;;++;;;+++;;   ;;;+++++++;   ;+++++;              
-		                 ;@#&+        +$&&@$@&#?  @#@@@&#&@@@#$ ;$@@@@#&@@@@! !#@        !#$     +&#&;     !#&@@@#&@@@&&;  !#&@@@@@@@*   $#&@@@&&$+           
-		                 $#?#@;      ?#&!;   *#$  &&;;;$#!;;*#$   ;;;*#@;;;;   $#?      +#&;    ;@#?#$     !#!;;*#@;;;@#;  ?#$;;;;;;;    @#*   ;!&#?          
-		                *#$ ?#$     *#&;     ;+;  ++   $#!  ;+;      *#$       ;&#+     $#*     ?#? $#!    ;+;  +#@   ++   ?#$           $#*     ;&#*         
-		               ;&&;  @#*    $#$                $#!           *#$        !#@;   !#$     +#@  ;&#;        +#@        ?#@??????!    $#*      $#$         
-		               $#!;;;*#&;   $#?                $#!           *#$         $#?  ;&&;    ;@#*;;;!#$        +#@        ?#@??????!    $#*      $#$         
-		              !##@@@@@&#$   !#@;               $#!           *#$         ;&#+ $#*     ?#&@@@@@##!       +#@        ?#$           $#*      @#*         
-		             ;&&+;;;;;;@#*  ;$#$+     @$       $#!           *#$          *#@!#?     *#@;;;;;;+##+      +#@        ?#$           $#*    +$#$          
-		             $#*       +#&;  ;?&#@$$$$#$    +$$&#@$$;   ;$$$$@##$$$$*      $##@;    ;&#+       !#@;   $$@##$$*     ?#&$$$$$$$!   @#@$$$@&@!           
-		            ;**         +*;     +*!?!*+;    ;*******    ;***********+      ;**;     ;*+         **;   *******+     ;*********+   +*!!!!*;             
-		                                                                                                                                                      	                                                                                                                                                      
-`

beacon-chain/blockchain/metrics.go

@@ -263,8 +263,8 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 	currentEth1DataDepositCount.Set(float64(postState.Eth1Data().DepositCount))
 	processedDepositsCount.Set(float64(postState.Eth1DepositIndex() + 1))
 
-	var b *precompute.Balance
-	var v []*precompute.Validator
+	var b *types.Balance
+	var v []*types.Validator
 	var err error
 	switch headState.Version() {
 	case version.Phase0:

beacon-chain/blockchain/mock_test.go

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

beacon-chain/blockchain/new_slot.go

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

beacon-chain/blockchain/new_slot_test.go

@@ -20,7 +20,7 @@ import (
 
 func TestService_newSlot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -35,22 +35,20 @@ func TestService_newSlot(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	bj, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) // genesis
-	state, blkRoot, err = prepareForkchoiceState(ctx, 32, [32]byte{'a'}, [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 32, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) // finalized
-	state, blkRoot, err = prepareForkchoiceState(ctx, 64, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 64, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) // justified
-	state, blkRoot, err = prepareForkchoiceState(ctx, 96, bj, [32]byte{'a'}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 96, bj, [32]byte{'a'}, [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) // best justified
-	state, blkRoot, err = prepareForkchoiceState(ctx, 97, [32]byte{'d'}, [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 97, [32]byte{'d'}, [32]byte{}, [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot)) // bad
 

beacon-chain/blockchain/pow_block.go

@@ -78,8 +78,6 @@ func (s *Service) validateMergeBlock(ctx context.Context, b interfaces.SignedBea
 		"mergeBlockParentTotalDifficulty": mergeBlockParentTD,
 	}).Info("Validated terminal block")
 
-	log.Info(mergeAsciiArt)
-
 	return nil
 }
 

beacon-chain/blockchain/pow_block_test.go

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

beacon-chain/blockchain/process_attestation_test.go

@@ -9,7 +9,6 @@ import (
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -29,7 +28,7 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 
 	opts := []Option{
 		WithDatabase(beaconDB),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 		WithStateGen(stategen.New(beaconDB)),
 	}
 	service, err := NewService(ctx, opts...)
@@ -141,7 +140,7 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
 
 	opts := []Option{
 		WithDatabase(beaconDB),
-		WithForkChoiceStore(doublylinkedtree.New()),
+		WithForkChoiceStore(doublylinkedtree.New(0, 0)),
 		WithStateGen(stategen.New(beaconDB)),
 	}
 	service, err := NewService(ctx, opts...)
@@ -251,7 +250,7 @@ func TestStore_OnAttestation_Ok_ProtoArray(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -269,9 +268,7 @@ func TestStore_OnAttestation_Ok_ProtoArray(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	ojc := &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, service.OnAttestation(ctx, att[0]))
@@ -281,7 +278,7 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -299,9 +296,7 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	ojc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-	ofc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, service.OnAttestation(ctx, att[0]))
@@ -492,7 +487,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -527,7 +522,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -608,18 +603,14 @@ func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, b32.Block.Slot, r32, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, b32.Block.Slot, r32, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, b33.Block.Slot, r33, r32, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, b33.Block.Slot, r33, r32, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
-	jc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r32}
-	require.NoError(t, service.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(jc))
-	_, err = service.cfg.ForkChoiceStore.Head(ctx, []uint64{})
+	_, err = service.cfg.ForkChoiceStore.Head(ctx, r32, []uint64{})
 	require.NoError(t, err)
 	err = service.VerifyFinalizedConsistency(context.Background(), r33[:])
 	require.NoError(t, err)

beacon-chain/blockchain/process_block.go

@@ -221,6 +221,13 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 			return err
 		}
 		s.store.SetJustifiedCheckptAndPayloadHash(postState.CurrentJustifiedCheckpoint(), h)
+		// Update Forkchoice checkpoints
+		if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(psj); err != nil {
+			return err
+		}
+		if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(psf); err != nil {
+			return err
+		}
 	}
 
 	balances, err := s.justifiedBalances.get(ctx, bytesutil.ToBytes32(justified.Root))
@@ -228,7 +235,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", justified.Root)
 		return errors.Wrap(err, msg)
 	}
-	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx, balances)
+	headRoot, err := s.updateHead(ctx, balances)
 	if err != nil {
 		log.WithError(err).Warn("Could not update head")
 	}
@@ -434,8 +441,8 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 			}
 		}
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
-			JustifiedCheckpoint: jCheckpoints[i],
-			FinalizedCheckpoint: fCheckpoints[i]}
+			JustifiedEpoch: jCheckpoints[i].Epoch,
+			FinalizedEpoch: fCheckpoints[i].Epoch}
 		pendingNodes[len(blks)-i-1] = args
 		s.saveInitSyncBlock(blockRoots[i], b)
 		if err = s.handleBlockAfterBatchVerify(ctx, b, blockRoots[i], fCheckpoints[i], jCheckpoints[i]); err != nil {
@@ -452,12 +459,9 @@ 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 only if the new finalized checkpoint is higher
-	// than the finalized checkpoint in forkchoice store.
-	if fCheckpoints[len(blks)-1].Epoch > s.cfg.ForkChoiceStore.FinalizedCheckpoint().Epoch {
-		if 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
+	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
@@ -536,8 +540,7 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed interf
 			return err
 		}
 		s.store.SetFinalizedCheckptAndPayloadHash(fCheckpoint, h)
-		if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{
-			Epoch: fCheckpoint.Epoch, Root: bytesutil.ToBytes32(fCheckpoint.Root)}); err != nil {
+		if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(fCheckpoint); err != nil {
 			return err
 		}
 	}
@@ -650,6 +653,10 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interface
 // This removes the attestations from the mem pool. It will only remove the attestations if input root `r` is canonical,
 // meaning the block `b` is part of the canonical chain.
 func (s *Service) pruneCanonicalAttsFromPool(ctx context.Context, r [32]byte, b interfaces.SignedBeaconBlock) error {
+	if !features.Get().CorrectlyPruneCanonicalAtts {
+		return nil
+	}
+
 	canonical, err := s.IsCanonical(ctx, r)
 	if err != nil {
 		return err

beacon-chain/blockchain/process_block_helpers.go

@@ -217,7 +217,12 @@ func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaco
 			return err
 		}
 		s.store.SetJustifiedCheckptAndPayloadHash(cpt, h)
+		// Update forkchoice's justified checkpoint
+		if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(cpt); err != nil {
+			return err
+		}
 	}
+
 	return nil
 }
 
@@ -239,8 +244,7 @@ func (s *Service) updateJustifiedInitSync(ctx context.Context, cp *ethpb.Checkpo
 		return err
 	}
 	s.store.SetJustifiedCheckptAndPayloadHash(cp, h)
-	return s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{
-		Epoch: cp.Epoch, Root: bytesutil.ToBytes32(cp.Root)})
+	return s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(cp)
 }
 
 func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) error {
@@ -315,8 +319,7 @@ func (s *Service) ancestorByForkChoiceStore(ctx context.Context, r [32]byte, slo
 	if !s.cfg.ForkChoiceStore.HasParent(r) {
 		return nil, errors.New("could not find root in fork choice store")
 	}
-	root, err := s.cfg.ForkChoiceStore.AncestorRoot(ctx, r, slot)
-	return root[:], err
+	return s.cfg.ForkChoiceStore.AncestorRoot(ctx, r, slot)
 }
 
 // This retrieves an ancestor root using DB. The look up is recursively looking up DB. Slower than `ancestorByForkChoiceStore`.
@@ -357,7 +360,7 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa
 		return err
 	}
 	pendingNodes = append(pendingNodes, &forkchoicetypes.BlockAndCheckpoints{Block: blk,
-		JustifiedCheckpoint: jCheckpoint, FinalizedCheckpoint: fCheckpoint})
+		JustifiedEpoch: jCheckpoint.Epoch, FinalizedEpoch: fCheckpoint.Epoch})
 	// As long as parent node is not in fork choice store, and parent node is in DB.
 	root := bytesutil.ToBytes32(blk.ParentRoot())
 	for !s.cfg.ForkChoiceStore.HasNode(root) && s.cfg.BeaconDB.HasBlock(ctx, root) {
@@ -370,8 +373,8 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa
 		}
 		root = bytesutil.ToBytes32(b.Block().ParentRoot())
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
-			JustifiedCheckpoint: jCheckpoint,
-			FinalizedCheckpoint: fCheckpoint}
+			JustifiedEpoch: jCheckpoint.Epoch,
+			FinalizedEpoch: fCheckpoint.Epoch}
 		pendingNodes = append(pendingNodes, args)
 	}
 	if len(pendingNodes) == 1 {

beacon-chain/blockchain/process_block_test.go

@@ -21,11 +21,11 @@ import (
 	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
+	"github.com/prysmaticlabs/prysm/config/features"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
@@ -47,7 +47,7 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 	ctx := context.Background()
 
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -150,7 +150,7 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
 
 	beaconDB := testDB.SetupDB(t)
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -253,7 +253,7 @@ func TestStore_OnBlock_ProposerBoostEarly(t *testing.T) {
 	ctx := context.Background()
 
 	beaconDB := testDB.SetupDB(t)
-	fcs := doublylinkedtree.New()
+	fcs := doublylinkedtree.New(0, 0)
 	opts := []Option{
 		WithStateGen(stategen.New(beaconDB)),
 		WithForkChoiceStore(fcs),
@@ -268,7 +268,7 @@ func TestStore_OnBlock_ProposerBoostEarly(t *testing.T) {
 		SecondsIntoSlot: 0,
 	}
 	require.NoError(t, service.cfg.ForkChoiceStore.BoostProposerRoot(ctx, args))
-	_, err = service.cfg.ForkChoiceStore.Head(ctx, []uint64{})
+	_, err = service.cfg.ForkChoiceStore.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{})
 	require.ErrorContains(t, "could not apply proposer boost score: invalid proposer boost root", err)
 }
 
@@ -293,7 +293,7 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
 	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'b'})
 
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -340,70 +340,7 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	jroot := bytesutil.ToBytes32(jcp.Root)
 	require.Equal(t, blkRoots[63], jroot)
-	require.Equal(t, types.Epoch(2), service.cfg.ForkChoiceStore.JustifiedCheckpoint().Epoch)
-}
-
-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()
-	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)
+	require.Equal(t, types.Epoch(2), service.cfg.ForkChoiceStore.JustifiedEpoch())
 }
 
 func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
@@ -427,7 +364,7 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
 	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'b'})
 
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -474,7 +411,7 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	jroot := bytesutil.ToBytes32(jcp.Root)
 	require.Equal(t, blkRoots[63], jroot)
-	require.Equal(t, types.Epoch(2), service.cfg.ForkChoiceStore.JustifiedCheckpoint().Epoch)
+	require.Equal(t, types.Epoch(2), service.cfg.ForkChoiceStore.JustifiedEpoch())
 }
 
 func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
@@ -496,7 +433,7 @@ func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'a'})
 	service.store.SetJustifiedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{'b'})
 
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	service.saveInitSyncBlock(gRoot, wsb)
 	st, keys := util.DeterministicGenesisState(t, 64)
 	bState := st.Copy()
@@ -577,7 +514,7 @@ func TestShouldUpdateJustified_ReturnFalse_ProtoArray(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	lastJustifiedBlk := util.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
 	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
@@ -610,7 +547,7 @@ func TestShouldUpdateJustified_ReturnFalse_DoublyLinkedTree(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	lastJustifiedBlk := util.NewBeaconBlock()
 	lastJustifiedBlk.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, 32)
 	lastJustifiedRoot, err := lastJustifiedBlk.Block.HashTreeRoot()
@@ -657,7 +594,7 @@ func TestCachedPreState_CanGetFromStateSummary_ProtoArray(t *testing.T) {
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -694,7 +631,7 @@ func TestCachedPreState_CanGetFromStateSummary_DoublyLinkedTree(t *testing.T) {
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -728,7 +665,7 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{Root: gRoot[:]}, [32]byte{})
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
 	require.NoError(t, err)
 	service.saveInitSyncBlock(gRoot, wsb)
@@ -759,7 +696,7 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -805,7 +742,7 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -851,7 +788,7 @@ func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -898,7 +835,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -947,7 +884,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -996,7 +933,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = protoarray.New()
+	service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -1063,7 +1000,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -1131,7 +1068,7 @@ func TestFillForkChoiceMissingBlocks_FinalizedSibling_DoublyLinkedTree(t *testin
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore = doublylinkedtree.New()
+	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -1272,7 +1209,7 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -1341,15 +1278,13 @@ func TestAncestor_CanUseForkchoice(t *testing.T) {
 	b200.Block.ParentRoot = r100[:]
 	r200, err := b200.Block.HashTreeRoot()
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
 		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	}
@@ -1365,7 +1300,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -1389,8 +1324,6 @@ func TestAncestor_CanUseDB(t *testing.T) {
 	b200.Block.ParentRoot = r100[:]
 	r200, err := b200.Block.HashTreeRoot()
 	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
 		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
@@ -1400,7 +1333,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 		require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb)) // Saves blocks to DB.
 	}
 
-	state, blkRoot, err := prepareForkchoiceState(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
@@ -1429,7 +1362,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -1574,7 +1507,7 @@ func TestHandleEpochBoundary_UpdateFirstSlot(t *testing.T) {
 func TestOnBlock_CanFinalize(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -1583,7 +1516,6 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 		WithForkChoiceStore(fcs),
 		WithDepositCache(depositCache),
 		WithStateNotifier(&mock.MockStateNotifier{}),
-		WithAttestationPool(attestations.NewPool()),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -1631,7 +1563,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 func TestOnBlock_NilBlock(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -1650,7 +1582,7 @@ func TestOnBlock_NilBlock(t *testing.T) {
 func TestOnBlock_InvalidSignature(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -1691,7 +1623,7 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -1700,7 +1632,6 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 		WithForkChoiceStore(fcs),
 		WithDepositCache(depositCache),
 		WithStateNotifier(&mock.MockStateNotifier{}),
-		WithAttestationPool(attestations.NewPool()),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -1823,6 +1754,11 @@ func TestInsertFinalizedDeposits_MultipleFinalizedRoutines(t *testing.T) {
 }
 
 func TestRemoveBlockAttestationsInPool_Canonical(t *testing.T) {
+	resetCfg := features.InitWithReset(&features.Flags{
+		CorrectlyPruneCanonicalAtts: true,
+	})
+	defer resetCfg()
+
 	genesis, keys := util.DeterministicGenesisState(t, 64)
 	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
 	assert.NoError(t, err)
@@ -1844,6 +1780,11 @@ func TestRemoveBlockAttestationsInPool_Canonical(t *testing.T) {
 }
 
 func TestRemoveBlockAttestationsInPool_NonCanonical(t *testing.T) {
+	resetCfg := features.InitWithReset(&features.Flags{
+		CorrectlyPruneCanonicalAtts: true,
+	})
+	defer resetCfg()
+
 	genesis, keys := util.DeterministicGenesisState(t, 64)
 	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
 	assert.NoError(t, err)
@@ -1920,13 +1861,12 @@ func Test_validateMergeTransitionBlock(t *testing.T) {
 
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
 		WithForkChoiceStore(fcs),
 		WithProposerIdsCache(cache.NewProposerPayloadIDsCache()),
-		WithAttestationPool(attestations.NewPool()),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -2049,7 +1989,7 @@ func Test_validateMergeTransitionBlock(t *testing.T) {
 func TestService_insertSlashingsToForkChoiceStore(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),
@@ -2100,7 +2040,7 @@ func TestService_insertSlashingsToForkChoiceStore(t *testing.T) {
 func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	depositCache, err := depositcache.New()
 	require.NoError(t, err)
 	opts := []Option{
@@ -2109,7 +2049,6 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 		WithForkChoiceStore(fcs),
 		WithDepositCache(depositCache),
 		WithStateNotifier(&mock.MockStateNotifier{}),
-		WithAttestationPool(attestations.NewPool()),
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -2173,7 +2112,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r2))
 		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r3))
 		require.NoError(t, service.cfg.BeaconDB.DeleteBlock(ctx, r4))
-		service.cfg.ForkChoiceStore = protoarray.New()
+		service.cfg.ForkChoiceStore = protoarray.New(0, 0)
 	}
 }
 
@@ -2181,7 +2120,7 @@ func Test_verifyBlkFinalizedSlot_invalidBlock(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
-	fcs := protoarray.New()
+	fcs := protoarray.New(0, 0)
 	opts := []Option{
 		WithDatabase(beaconDB),
 		WithStateGen(stategen.New(beaconDB)),

beacon-chain/blockchain/receive_attestation.go

@@ -160,7 +160,7 @@ func (s *Service) UpdateHead(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	newHeadRoot, err := s.cfg.ForkChoiceStore.Head(ctx, balances)
+	newHeadRoot, err := s.updateHead(ctx, balances)
 	if err != nil {
 		log.WithError(err).Warn("Resolving fork due to new attestation")
 	}

beacon-chain/blockchain/receive_attestation_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
@@ -121,9 +120,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
@@ -214,58 +211,38 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	ctx := context.Background()
 	opts := testServiceOptsWithDB(t)
-	fcs := protoarray.New()
-	opts = append(opts,
-		WithAttestationPool(attestations.NewPool()),
-		WithStateNotifier(&mockBeaconNode{}),
-		WithForkChoiceStore(fcs),
-	)
+	opts = append(opts, WithAttestationPool(attestations.NewPool()), WithStateNotifier(&mockBeaconNode{}))
 
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	service.genesisTime = prysmTime.Now().Add(-2 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
+	service.genesisTime = prysmTime.Now().Add(-1 * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
 	genesisState, pks := util.DeterministicGenesisState(t, 64)
+	require.NoError(t, genesisState.SetGenesisTime(uint64(prysmTime.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
+	atts, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
+	require.NoError(t, err)
+	tRoot := bytesutil.ToBytes32(atts[0].Data.Target.Root)
 	copied := genesisState.Copy()
-	// Generate a new block for attesters to attest
-	blk, err := util.GenerateFullBlock(copied, pks, util.DefaultBlockGenConfig(), 1)
+	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
-	tRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, service.onBlock(ctx, wsb, tRoot))
-	copied, err = service.cfg.StateGen.StateByRoot(ctx, tRoot)
-	require.NoError(t, err)
-	require.Equal(t, 2, fcs.NodeCount())
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
-
-	// Generate attestatios for this block in Slot 1
-	atts, err := util.GenerateAttestations(copied, pks, 1, 1, false)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
-	// Verify the target is in forchoice
-	require.Equal(t, true, fcs.HasNode(bytesutil.ToBytes32(atts[0].Data.BeaconBlockRoot)))
-
-	// Insert a new block to forkchoice
-	ojc := &ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}
-	b, err := util.GenerateFullBlock(genesisState, pks, util.DefaultBlockGenConfig(), 2)
-	require.NoError(t, err)
-	b.Block.ParentRoot = service.originBlockRoot[:]
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wb))
-	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, ojc, ojc)
+	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
+	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: tRoot[:]}))
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
+	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
+	b := util.NewBeaconBlock()
+	wb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wb))
+	state, blkRoot, err = prepareForkchoiceState(ctx, wb.Block().Slot(), r, bytesutil.ToBytes32(wb.Block().ParentRoot()), [32]byte{}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	require.Equal(t, 3, fcs.NodeCount())
 	service.head.root = r // Old head
-
 	require.Equal(t, 1, len(service.cfg.AttPool.ForkchoiceAttestations()))
 	require.NoError(t, err, service.UpdateHead(ctx))
-
-	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations())) // Validate att pool is empty
 	require.Equal(t, tRoot, service.head.root)                             // Validate head is the new one
+	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations())) // Validate att pool is empty
 }

beacon-chain/blockchain/receive_block.go

@@ -71,15 +71,11 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaco
 
 	// Log block sync status.
 	if err := logBlockSyncStatus(blockCopy.Block(), blockRoot, justified, finalized, receivedTime, uint64(s.genesisTime.Unix())); err != nil {
-		log.WithError(err).Error("Unable to log block sync status")
-	}
-	// Log payload data
-	if err := logPayload(blockCopy.Block()); err != nil {
-		log.WithError(err).Error("Unable to log debug block payload data")
+		return err
 	}
 	// Log state transition data.
 	if err := logStateTransitionData(blockCopy.Block()); err != nil {
-		log.WithError(err).Error("Unable to log state transition data")
+		return err
 	}
 
 	return nil

beacon-chain/blockchain/receive_block_test.go

@@ -127,7 +127,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 
 			opts := []Option{
 				WithDatabase(beaconDB),
-				WithForkChoiceStore(protoarray.New()),
+				WithForkChoiceStore(protoarray.New(0, 0)),
 				WithAttestationPool(attestations.NewPool()),
 				WithExitPool(voluntaryexits.NewPool()),
 				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
@@ -168,7 +168,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	require.NoError(t, beaconDB.SaveState(ctx, genesis, genesisBlockRoot))
 	opts := []Option{
 		WithDatabase(beaconDB),
-		WithForkChoiceStore(protoarray.New()),
+		WithForkChoiceStore(protoarray.New(0, 0)),
 		WithAttestationPool(attestations.NewPool()),
 		WithExitPool(voluntaryexits.NewPool()),
 		WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
@@ -248,7 +248,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			beaconDB := testDB.SetupDB(t)
 			opts := []Option{
 				WithDatabase(beaconDB),
-				WithForkChoiceStore(protoarray.New()),
+				WithForkChoiceStore(protoarray.New(0, 0)),
 				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
 				WithStateGen(stategen.New(beaconDB)),
 			}
@@ -322,8 +322,6 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	s, err := NewService(context.Background(), opts...)
 	require.NoError(t, err)
-	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
-	s.genesisTime = time.Now().Add(time.Duration(-1*int64(st)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
 	s.store.SetFinalizedCheckptAndPayloadHash(&ethpb.Checkpoint{}, [32]byte{})
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	s.genesisTime = time.Now()

beacon-chain/blockchain/service.go

@@ -23,7 +23,6 @@ import (
 	f "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
@@ -207,23 +206,13 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	s.store = store.New(justified, finalized)
 
 	var forkChoicer f.ForkChoicer
-	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
+	fRoot := bytesutil.ToBytes32(finalized.Root)
 	if features.Get().EnableForkChoiceDoublyLinkedTree {
-		forkChoicer = doublylinkedtree.New()
+		forkChoicer = doublylinkedtree.New(justified.Epoch, finalized.Epoch)
 	} else {
-		forkChoicer = protoarray.New()
+		forkChoicer = protoarray.New(justified.Epoch, finalized.Epoch)
 	}
 	s.cfg.ForkChoiceStore = forkChoicer
-	if err := forkChoicer.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: justified.Epoch,
-		Root: bytesutil.ToBytes32(justified.Root)}); err != nil {
-		return errors.Wrap(err, "could not update forkchoice's justified checkpoint")
-	}
-	if err := forkChoicer.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,
-		Root: bytesutil.ToBytes32(finalized.Root)}); err != nil {
-		return errors.Wrap(err, "could not update forkchoice's finalized checkpoint")
-	}
-	forkChoicer.SetGenesisTime(uint64(s.genesisTime.Unix()))
-
 	st, err := s.cfg.StateGen.StateByRoot(s.ctx, fRoot)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint state")
@@ -479,12 +468,9 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, genesisState, genesisBlkRoot); err != nil {
 		log.Fatalf("Could not process genesis block for fork choice: %v", err)
 	}
-	s.cfg.ForkChoiceStore.SetOriginRoot(genesisBlkRoot)
-	// Set genesis as fully validated
 	if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, genesisBlkRoot); err != nil {
-		return errors.Wrap(err, "Could not set optimistic status of genesis block to false")
+		log.Fatalf("Could not set optimistic status of genesis block to false: %v", err)
 	}
-	s.cfg.ForkChoiceStore.SetGenesisTime(uint64(s.genesisTime.Unix()))
 
 	s.setHead(genesisBlkRoot, genesisBlk, genesisState)
 	return nil

beacon-chain/blockchain/service_test.go

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

beacon-chain/blockchain/testing/BUILD.bazel

@@ -11,7 +11,6 @@ go_library(
     ],
     deps = [
         "//async/event:go_default_library",
-        "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/block:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",

beacon-chain/blockchain/testing/mock.go

@@ -10,7 +10,6 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/async/event"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	blockfeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/block"
 	opfeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/operation"
@@ -40,7 +39,7 @@ type ChainService struct {
 	CurrentJustifiedCheckPoint  *ethpb.Checkpoint
 	PreviousJustifiedCheckPoint *ethpb.Checkpoint
 	Slot                        *types.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
-	Balance                     *precompute.Balance
+	Balance                     *types.Balance
 	CanonicalRoots              map[[32]byte]bool
 	Fork                        *ethpb.Fork
 	ETH1Data                    *ethpb.Eth1Data
@@ -62,7 +61,6 @@ type ChainService struct {
 	Genesis                     time.Time
 	ForkChoiceStore             forkchoice.ForkChoicer
 	ReceiveBlockMockErr         error
-	OptimisticCheckRootReceived [32]byte
 }
 
 // ForkChoicer mocks the same method in the chain service
@@ -339,7 +337,7 @@ func (s *ChainService) CurrentSlot() types.Slot {
 }
 
 // Participation mocks the same method in the chain service.
-func (s *ChainService) Participation(_ uint64) *precompute.Balance {
+func (s *ChainService) Participation(_ uint64) *types.Balance {
 	return s.Balance
 }
 
@@ -448,8 +446,7 @@ func (s *ChainService) IsOptimistic(_ context.Context) (bool, error) {
 }
 
 // IsOptimisticForRoot mocks the same method in the chain service.
-func (s *ChainService) IsOptimisticForRoot(_ context.Context, root [32]byte) (bool, error) {
-	s.OptimisticCheckRootReceived = root
+func (s *ChainService) IsOptimisticForRoot(_ context.Context, _ [32]byte) (bool, error) {
 	return s.Optimistic, nil
 }
 

beacon-chain/blockchain/weak_subjectivity_checks.go

@@ -30,8 +30,8 @@ type WeakSubjectivityVerifier struct {
 // NewWeakSubjectivityVerifier validates a checkpoint, and if valid, uses it to initialize a weak subjectivity verifier.
 func NewWeakSubjectivityVerifier(wsc *ethpb.Checkpoint, db weakSubjectivityDB) (*WeakSubjectivityVerifier, error) {
 	if wsc == nil || len(wsc.Root) == 0 || wsc.Epoch == 0 {
-		log.Info("--weak-subjectivity-checkpoint not provided. Prysm recommends providing a weak subjectivity checkpoint" +
-			"for nodes synced from genesis, or manual verification of block and state roots for checkpoint sync nodes.")
+		log.Info("No checkpoint for syncing provided, node will begin syncing from genesis. Checkpoint Sync is an optional feature that allows your node to sync from a more recent checkpoint, " +
+			"which enhances the security of your local beacon node and the broader network. See https://docs.prylabs.network/docs/next/prysm-usage/checkpoint-sync/ to learn how to configure Checkpoint Sync.")
 		return &WeakSubjectivityVerifier{
 			enabled: false,
 		}, nil

beacon-chain/builder/BUILD.bazel

@@ -3,8 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     srcs = [
-        "error.go",
-        "metric.go",
         "option.go",
         "service.go",
     ],
@@ -12,20 +10,13 @@ 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_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
     ],
 )

beacon-chain/builder/error.go

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

beacon-chain/builder/metric.go

@@ -1,37 +0,0 @@
-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,7 +1,6 @@
 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"
@@ -27,14 +26,6 @@ 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,34 +2,26 @@ 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"
-	log "github.com/sirupsen/logrus"
-	"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(ctx context.Context) error
+	Status() 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.
@@ -64,71 +56,22 @@ func (*Service) Stop() error {
 	return nil
 }
 
-// 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)
+// SubmitBlindedBlock is currently a stub.
+func (*Service) SubmitBlindedBlock(context.Context, *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, 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)
+// 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")
 }
 
-// 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)
+// Status is currently a stub.
+func (*Service) Status() 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()))
-	}()
-
-	idxs := make([]types.ValidatorIndex, 0)
-	msgs := make([]*ethpb.ValidatorRegistrationV1, 0)
-	valid := make([]*ethpb.SignedValidatorRegistrationV1, 0)
-	for i := 0; i < len(reg); i++ {
-		r := reg[i]
-		nx, exists := s.cfg.headFetcher.HeadPublicKeyToValidatorIndex(bytesutil.ToBytes48(r.Message.Pubkey))
-		if !exists {
-			// we want to allow validators to set up keys that haven't been added to the beaconstate validator list yet,
-			// so we should tolerate keys that do not seem to be valid by skipping past them.
-			log.Warnf("Skipping validator registration for pubkey=%#x - not in current validator set.", r.Message.Pubkey)
-			continue
-		}
-		idxs = append(idxs, nx)
-		msgs = append(msgs, r.Message)
-		valid = append(valid, r)
-	}
-	if err := s.c.RegisterValidator(ctx, valid); err != nil {
-		return errors.Wrap(err, "could not register validator(s)")
-	}
-
-	return s.cfg.beaconDB.SaveRegistrationsByValidatorIDs(ctx, idxs, msgs)
+// RegisterValidator is currently a stub.
+func (*Service) RegisterValidator(context.Context, *ethpb.SignedValidatorRegistrationV1) error {
+	return errors.New("not implemented")
 }

beacon-chain/cache/active_balance.go

@@ -1,4 +1,5 @@
 //go:build !fuzz
+// +build !fuzz
 
 package cache
 

beacon-chain/cache/active_balance_disabled.go

@@ -1,4 +1,5 @@
 //go:build fuzz
+// +build fuzz
 
 package cache
 

beacon-chain/cache/active_balance_test.go

@@ -1,4 +1,5 @@
 //go:build !fuzz
+// +build !fuzz
 
 package cache
 

beacon-chain/cache/committee.go

@@ -1,4 +1,5 @@
 //go:build !fuzz
+// +build !fuzz
 
 package cache
 

beacon-chain/cache/committee_disabled.go

@@ -1,4 +1,5 @@
 //go:build fuzz
+// +build fuzz
 
 // This file is used in fuzzer builds to bypass global committee caches.
 package cache

beacon-chain/cache/committee_fuzz_test.go

@@ -1,4 +1,5 @@
 //go:build !fuzz
+// +build !fuzz
 
 package cache
 

beacon-chain/cache/committee_test.go

@@ -1,4 +1,5 @@
 //go:build !fuzz
+// +build !fuzz
 
 package cache
 

beacon-chain/cache/proposer_indices.go

@@ -1,4 +1,5 @@
 //go:build !fuzz
+// +build !fuzz
 
 package cache
 

beacon-chain/cache/proposer_indices_disabled.go

@@ -1,4 +1,5 @@
 //go:build fuzz
+// +build fuzz
 
 // This file is used in fuzzer builds to bypass proposer indices caches.
 package cache

beacon-chain/cache/proposer_indices_test.go

@@ -1,4 +1,5 @@
 //go:build !fuzz
+// +build !fuzz
 
 package cache
 

beacon-chain/cache/sync_committee.go

@@ -1,4 +1,5 @@
 //go:build !fuzz
+// +build !fuzz
 
 package cache
 

beacon-chain/cache/sync_committee_disabled.go

@@ -1,4 +1,5 @@
 //go:build fuzz
+// +build fuzz
 
 package cache
 

beacon-chain/core/altair/BUILD.bazel

@@ -66,7 +66,6 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/core/epoch:go_default_library",
-        "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/altair/epoch_precompute.go

@@ -9,16 +9,17 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"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/math"
 	"go.opencensus.io/trace"
 )
 
 // InitializePrecomputeValidators precomputes individual validator for its attested balances and the total sum of validators attested balances of the epoch.
-func InitializePrecomputeValidators(ctx context.Context, beaconState state.BeaconState) ([]*precompute.Validator, *precompute.Balance, error) {
+func InitializePrecomputeValidators(ctx context.Context, beaconState state.BeaconState) ([]*types.Validator, *types.Balance, error) {
 	_, span := trace.StartSpan(ctx, "altair.InitializePrecomputeValidators")
 	defer span.End()
-	vals := make([]*precompute.Validator, beaconState.NumValidators())
-	bal := &precompute.Balance{}
+	vals := make([]*types.Validator, beaconState.NumValidators())
+	bal := &types.Balance{}
 	prevEpoch := time.PrevEpoch(beaconState)
 	currentEpoch := time.CurrentEpoch(beaconState)
 	inactivityScores, err := beaconState.InactivityScores()
@@ -33,7 +34,7 @@ func InitializePrecomputeValidators(ctx context.Context, beaconState state.Beaco
 	}
 	if err := beaconState.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
 		// Set validator's balance, inactivity score and slashed/withdrawable status.
-		v := &precompute.Validator{
+		v := &types.Validator{
 			CurrentEpochEffectiveBalance: val.EffectiveBalance(),
 			InactivityScore:              inactivityScores[idx],
 			IsSlashed:                    val.Slashed(),
@@ -74,57 +75,18 @@ func InitializePrecomputeValidators(ctx context.Context, beaconState state.Beaco
 func ProcessInactivityScores(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	vals []*precompute.Validator,
-) (state.BeaconState, []*precompute.Validator, error) {
+	vals []*types.Validator,
+) (state.BeaconState, []*types.Validator, error) {
 	_, span := trace.StartSpan(ctx, "altair.ProcessInactivityScores")
 	defer span.End()
 
-	cfg := params.BeaconConfig()
-	if time.CurrentEpoch(beaconState) == cfg.GenesisEpoch {
-		return beaconState, vals, nil
-	}
-
-	inactivityScores, err := beaconState.InactivityScores()
+	currEpoch := time.CurrentEpoch(beaconState)
+	prevEpoch := time.PrevEpoch(beaconState)
+	finalizedEpoch := beaconState.FinalizedCheckpointEpoch()
+	vals, err := beaconState.ProcessInactivityScores(ctx, currEpoch, prevEpoch, finalizedEpoch, vals)
 	if err != nil {
 		return nil, nil, err
 	}
-
-	bias := cfg.InactivityScoreBias
-	recoveryRate := cfg.InactivityScoreRecoveryRate
-	prevEpoch := time.PrevEpoch(beaconState)
-	finalizedEpoch := beaconState.FinalizedCheckpointEpoch()
-	for i, v := range vals {
-		if !precompute.EligibleForRewards(v) {
-			continue
-		}
-
-		if v.IsPrevEpochTargetAttester && !v.IsSlashed {
-			// Decrease inactivity score when validator gets target correct.
-			if v.InactivityScore > 0 {
-				v.InactivityScore -= 1
-			}
-		} else {
-			v.InactivityScore, err = math.Add64(v.InactivityScore, bias)
-			if err != nil {
-				return nil, nil, err
-			}
-		}
-
-		if !helpers.IsInInactivityLeak(prevEpoch, finalizedEpoch) {
-			score := recoveryRate
-			// Prevents underflow below 0.
-			if score > v.InactivityScore {
-				score = v.InactivityScore
-			}
-			v.InactivityScore -= score
-		}
-		inactivityScores[i] = v.InactivityScore
-	}
-
-	if err := beaconState.SetInactivityScores(inactivityScores); err != nil {
-		return nil, nil, err
-	}
-
 	return beaconState, vals, nil
 }
 
@@ -141,9 +103,9 @@ func ProcessInactivityScores(
 func ProcessEpochParticipation(
 	ctx context.Context,
 	beaconState state.BeaconState,
-	bal *precompute.Balance,
-	vals []*precompute.Validator,
-) ([]*precompute.Validator, *precompute.Balance, error) {
+	bal *types.Balance,
+	vals []*types.Validator,
+) ([]*types.Validator, *types.Balance, error) {
 	_, span := trace.StartSpan(ctx, "altair.ProcessEpochParticipation")
 	defer span.End()
 
@@ -209,8 +171,8 @@ func ProcessEpochParticipation(
 // This is an optimized version by passing in precomputed validator attesting records and and total epoch balances.
 func ProcessRewardsAndPenaltiesPrecompute(
 	beaconState state.BeaconState,
-	bal *precompute.Balance,
-	vals []*precompute.Validator,
+	bal *types.Balance,
+	vals []*types.Validator,
 ) (state.BeaconState, error) {
 	// Don't process rewards and penalties in genesis epoch.
 	cfg := params.BeaconConfig()
@@ -253,7 +215,7 @@ func ProcessRewardsAndPenaltiesPrecompute(
 
 // AttestationsDelta computes and returns the rewards and penalties differences for individual validators based on the
 // voting records.
-func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, vals []*precompute.Validator) (rewards, penalties []uint64, err error) {
+func AttestationsDelta(beaconState state.BeaconState, bal *types.Balance, vals []*types.Validator) (rewards, penalties []uint64, err error) {
 	numOfVals := beaconState.NumValidators()
 	rewards = make([]uint64, numOfVals)
 	penalties = make([]uint64, numOfVals)
@@ -285,8 +247,8 @@ func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, v
 }
 
 func attestationDelta(
-	bal *precompute.Balance,
-	val *precompute.Validator,
+	bal *types.Balance,
+	val *types.Validator,
 	baseRewardMultiplier, inactivityDenominator uint64,
 	inactivityLeak bool) (reward, penalty uint64, err error) {
 	eligible := val.IsActivePrevEpoch || (val.IsSlashed && !val.IsWithdrawableCurrentEpoch)

beacon-chain/core/altair/epoch_precompute_test.go

@@ -5,7 +5,6 @@ import (
 	"math"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
 	v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3"
@@ -35,29 +34,29 @@ func TestInitializeEpochValidators_Ok(t *testing.T) {
 	require.NoError(t, err)
 	v, b, err := InitializePrecomputeValidators(context.Background(), s)
 	require.NoError(t, err)
-	assert.DeepEqual(t, &precompute.Validator{
+	assert.DeepEqual(t, &types.Validator{
 		IsSlashed:                    true,
 		CurrentEpochEffectiveBalance: 100,
 		InactivityScore:              0,
 	}, v[0], "Incorrect validator 0 status")
-	assert.DeepEqual(t, &precompute.Validator{
+	assert.DeepEqual(t, &types.Validator{
 		IsWithdrawableCurrentEpoch:   true,
 		CurrentEpochEffectiveBalance: 100,
 		InactivityScore:              1,
 	}, v[1], "Incorrect validator 1 status")
-	assert.DeepEqual(t, &precompute.Validator{
+	assert.DeepEqual(t, &types.Validator{
 		IsActivePrevEpoch:            true,
 		IsActiveCurrentEpoch:         true,
 		CurrentEpochEffectiveBalance: 100,
 		InactivityScore:              2,
 	}, v[2], "Incorrect validator 2 status")
-	assert.DeepEqual(t, &precompute.Validator{
+	assert.DeepEqual(t, &types.Validator{
 		IsActivePrevEpoch:            true,
 		CurrentEpochEffectiveBalance: 100,
 		InactivityScore:              3,
 	}, v[3], "Incorrect validator 3 status")
 
-	wantedBalances := &precompute.Balance{
+	wantedBalances := &types.Balance{
 		ActiveCurrentEpoch: 100,
 		ActivePrevEpoch:    200,
 	}
@@ -96,13 +95,13 @@ func TestProcessEpochParticipation(t *testing.T) {
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	require.DeepEqual(t, &precompute.Validator{
+	require.DeepEqual(t, &types.Validator{
 		IsActiveCurrentEpoch:         true,
 		IsActivePrevEpoch:            true,
 		IsWithdrawableCurrentEpoch:   true,
 		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
 	}, validators[0])
-	require.DeepEqual(t, &precompute.Validator{
+	require.DeepEqual(t, &types.Validator{
 		IsActiveCurrentEpoch:         true,
 		IsActivePrevEpoch:            true,
 		IsWithdrawableCurrentEpoch:   true,
@@ -111,7 +110,7 @@ func TestProcessEpochParticipation(t *testing.T) {
 		IsPrevEpochAttester:          true,
 		IsPrevEpochSourceAttester:    true,
 	}, validators[1])
-	require.DeepEqual(t, &precompute.Validator{
+	require.DeepEqual(t, &types.Validator{
 		IsActiveCurrentEpoch:         true,
 		IsActivePrevEpoch:            true,
 		IsWithdrawableCurrentEpoch:   true,
@@ -122,7 +121,7 @@ func TestProcessEpochParticipation(t *testing.T) {
 		IsCurrentEpochTargetAttester: true,
 		IsPrevEpochTargetAttester:    true,
 	}, validators[2])
-	require.DeepEqual(t, &precompute.Validator{
+	require.DeepEqual(t, &types.Validator{
 		IsActiveCurrentEpoch:         true,
 		IsActivePrevEpoch:            true,
 		IsWithdrawableCurrentEpoch:   true,
@@ -174,13 +173,13 @@ func TestProcessEpochParticipation_InactiveValidator(t *testing.T) {
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), st, balance, validators)
 	require.NoError(t, err)
-	require.DeepEqual(t, &precompute.Validator{
+	require.DeepEqual(t, &types.Validator{
 		IsActiveCurrentEpoch:         false,
 		IsActivePrevEpoch:            false,
 		IsWithdrawableCurrentEpoch:   true,
 		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
 	}, validators[0])
-	require.DeepEqual(t, &precompute.Validator{
+	require.DeepEqual(t, &types.Validator{
 		IsActiveCurrentEpoch:         false,
 		IsActivePrevEpoch:            true,
 		IsPrevEpochAttester:          true,
@@ -189,7 +188,7 @@ func TestProcessEpochParticipation_InactiveValidator(t *testing.T) {
 		IsWithdrawableCurrentEpoch:   true,
 		CurrentEpochEffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
 	}, validators[1])
-	require.DeepEqual(t, &precompute.Validator{
+	require.DeepEqual(t, &types.Validator{
 		IsActiveCurrentEpoch:         true,
 		IsActivePrevEpoch:            true,
 		IsWithdrawableCurrentEpoch:   true,
@@ -413,7 +412,7 @@ func TestProcessRewardsAndPenaltiesPrecompute_BadState(t *testing.T) {
 	require.NoError(t, err)
 	_, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	_, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, []*precompute.Validator{})
+	_, err = ProcessRewardsAndPenaltiesPrecompute(s, balance, []*types.Validator{})
 	require.ErrorContains(t, "validator registries not the same length as state's validator registries", err)
 }
 

beacon-chain/core/epoch/precompute/BUILD.bazel

@@ -8,7 +8,6 @@ go_library(
         "new.go",
         "reward_penalty.go",
         "slashing.go",
-        "type.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute",
     visibility = [
@@ -39,7 +38,6 @@ go_test(
         "attestation_test.go",
         "justification_finalization_test.go",
         "new_test.go",
-        "precompute_test.go",
         "reward_penalty_test.go",
         "slashing_test.go",
     ],

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

@@ -22,13 +22,13 @@ import (
 func ProcessAttestations(
 	ctx context.Context,
 	state state.ReadOnlyBeaconState,
-	vp []*Validator,
-	pBal *Balance,
-) ([]*Validator, *Balance, error) {
+	vp []*types.Validator,
+	pBal *types.Balance,
+) ([]*types.Validator, *types.Balance, error) {
 	ctx, span := trace.StartSpan(ctx, "precomputeEpoch.ProcessAttestations")
 	defer span.End()
 
-	v := &Validator{}
+	v := &types.Validator{}
 	var err error
 
 	prevAtt, err := state.PreviousEpochAttestations()
@@ -141,7 +141,7 @@ func SameHead(state state.ReadOnlyBeaconState, a *ethpb.PendingAttestation) (boo
 }
 
 // UpdateValidator updates pre computed validator store.
-func UpdateValidator(vp []*Validator, record *Validator, indices []uint64, a *ethpb.PendingAttestation, aSlot types.Slot) []*Validator {
+func UpdateValidator(vp []*types.Validator, record *types.Validator, indices []uint64, a *ethpb.PendingAttestation, aSlot types.Slot) []*types.Validator {
 	inclusionSlot := aSlot + a.InclusionDelay
 
 	for _, i := range indices {
@@ -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 []*types.Validator, bBal *types.Balance, stateVersion int) *types.Balance {
 	for _, v := range vp {
 		if !v.IsSlashed {
 			if v.IsCurrentEpochAttester {
@@ -200,7 +200,7 @@ func UpdateBalance(vp []*Validator, bBal *Balance, stateVersion int) *Balance {
 
 // EnsureBalancesLowerBound ensures all the balances such as active current epoch, active previous epoch and more
 // have EffectiveBalanceIncrement(1 eth) as a lower bound.
-func EnsureBalancesLowerBound(bBal *Balance) *Balance {
+func EnsureBalancesLowerBound(bBal *types.Balance) *types.Balance {
 	ebi := params.BeaconConfig().EffectiveBalanceIncrement
 	if ebi > bBal.ActiveCurrentEpoch {
 		bBal.ActiveCurrentEpoch = ebi

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

@@ -8,6 +8,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"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/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/runtime/version"
@@ -18,36 +19,36 @@ import (
 
 func TestUpdateValidator_Works(t *testing.T) {
 	e := params.BeaconConfig().FarFutureSlot
-	vp := []*precompute.Validator{{}, {InclusionSlot: e}, {}, {InclusionSlot: e}, {}, {InclusionSlot: e}}
-	record := &precompute.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true,
+	vp := []*types.Validator{{}, {InclusionSlot: e}, {}, {InclusionSlot: e}, {}, {InclusionSlot: e}}
+	record := &types.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true,
 		IsPrevEpochAttester: true, IsPrevEpochTargetAttester: true, IsPrevEpochHeadAttester: true}
 	a := &ethpb.PendingAttestation{InclusionDelay: 1, ProposerIndex: 2}
 
 	// Indices 1 3 and 5 attested
 	vp = precompute.UpdateValidator(vp, record, []uint64{1, 3, 5}, a, 100)
 
-	wanted := &precompute.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true,
+	wanted := &types.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true,
 		IsPrevEpochAttester: true, IsPrevEpochTargetAttester: true, IsPrevEpochHeadAttester: true,
 		ProposerIndex: 2, InclusionDistance: 1, InclusionSlot: 101}
-	wantedVp := []*precompute.Validator{{}, wanted, {}, wanted, {}, wanted}
+	wantedVp := []*types.Validator{{}, wanted, {}, wanted, {}, wanted}
 	assert.DeepEqual(t, wantedVp, vp, "Incorrect attesting validator calculations")
 }
 
 func TestUpdateValidator_InclusionOnlyCountsPrevEpoch(t *testing.T) {
 	e := params.BeaconConfig().FarFutureSlot
-	vp := []*precompute.Validator{{InclusionSlot: e}}
-	record := &precompute.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true}
+	vp := []*types.Validator{{InclusionSlot: e}}
+	record := &types.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true}
 	a := &ethpb.PendingAttestation{InclusionDelay: 1, ProposerIndex: 2}
 
 	// Verify inclusion info doesnt get updated.
 	vp = precompute.UpdateValidator(vp, record, []uint64{0}, a, 100)
-	wanted := &precompute.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true, InclusionSlot: e}
-	wantedVp := []*precompute.Validator{wanted}
+	wanted := &types.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true, InclusionSlot: e}
+	wantedVp := []*types.Validator{wanted}
 	assert.DeepEqual(t, wantedVp, vp, "Incorrect attesting validator calculations")
 }
 
 func TestUpdateBalance(t *testing.T) {
-	vp := []*precompute.Validator{
+	vp := []*types.Validator{
 		{IsCurrentEpochAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
 		{IsCurrentEpochTargetAttester: true, IsCurrentEpochAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
 		{IsCurrentEpochTargetAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
@@ -57,7 +58,7 @@ func TestUpdateBalance(t *testing.T) {
 		{IsPrevEpochAttester: true, IsPrevEpochHeadAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
 		{IsSlashed: true, IsCurrentEpochAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
 	}
-	wantedPBal := &precompute.Balance{
+	wantedPBal := &types.Balance{
 		ActiveCurrentEpoch:         params.BeaconConfig().EffectiveBalanceIncrement,
 		ActivePrevEpoch:            params.BeaconConfig().EffectiveBalanceIncrement,
 		CurrentEpochAttested:       200 * params.BeaconConfig().EffectiveBalanceIncrement,
@@ -66,12 +67,12 @@ func TestUpdateBalance(t *testing.T) {
 		PrevEpochTargetAttested:    100 * params.BeaconConfig().EffectiveBalanceIncrement,
 		PrevEpochHeadAttested:      200 * params.BeaconConfig().EffectiveBalanceIncrement,
 	}
-	pBal := precompute.UpdateBalance(vp, &precompute.Balance{}, version.Phase0)
+	pBal := precompute.UpdateBalance(vp, &types.Balance{}, version.Phase0)
 	assert.DeepEqual(t, wantedPBal, pBal, "Incorrect balance calculations")
 }
 
 func TestUpdateBalanceBellatrixVersion(t *testing.T) {
-	vp := []*precompute.Validator{
+	vp := []*types.Validator{
 		{IsCurrentEpochAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
 		{IsCurrentEpochTargetAttester: true, IsCurrentEpochAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
 		{IsCurrentEpochTargetAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
@@ -81,7 +82,7 @@ func TestUpdateBalanceBellatrixVersion(t *testing.T) {
 		{IsPrevEpochAttester: true, IsPrevEpochHeadAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
 		{IsSlashed: true, IsCurrentEpochAttester: true, CurrentEpochEffectiveBalance: 100 * params.BeaconConfig().EffectiveBalanceIncrement},
 	}
-	wantedPBal := &precompute.Balance{
+	wantedPBal := &types.Balance{
 		ActiveCurrentEpoch:         params.BeaconConfig().EffectiveBalanceIncrement,
 		ActivePrevEpoch:            params.BeaconConfig().EffectiveBalanceIncrement,
 		CurrentEpochAttested:       200 * params.BeaconConfig().EffectiveBalanceIncrement,
@@ -90,7 +91,7 @@ func TestUpdateBalanceBellatrixVersion(t *testing.T) {
 		PrevEpochTargetAttested:    100 * params.BeaconConfig().EffectiveBalanceIncrement,
 		PrevEpochHeadAttested:      200 * params.BeaconConfig().EffectiveBalanceIncrement,
 	}
-	pBal := precompute.UpdateBalance(vp, &precompute.Balance{}, version.Bellatrix)
+	pBal := precompute.UpdateBalance(vp, &types.Balance{}, version.Bellatrix)
 	assert.DeepEqual(t, wantedPBal, pBal, "Incorrect balance calculations")
 }
 
@@ -199,11 +200,11 @@ func TestProcessAttestations(t *testing.T) {
 	err = beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{Data: att2.Data, AggregationBits: bf, InclusionDelay: 1})
 	require.NoError(t, err)
 
-	pVals := make([]*precompute.Validator, validators)
+	pVals := make([]*types.Validator, validators)
 	for i := 0; i < len(pVals); i++ {
-		pVals[i] = &precompute.Validator{CurrentEpochEffectiveBalance: 100}
+		pVals[i] = &types.Validator{CurrentEpochEffectiveBalance: 100}
 	}
-	pVals, _, err = precompute.ProcessAttestations(context.Background(), beaconState, pVals, &precompute.Balance{})
+	pVals, _, err = precompute.ProcessAttestations(context.Background(), beaconState, pVals, &types.Balance{})
 	require.NoError(t, err)
 
 	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att1.Data.Slot, att1.Data.CommitteeIndex)
@@ -227,7 +228,7 @@ func TestProcessAttestations(t *testing.T) {
 }
 
 func TestEnsureBalancesLowerBound(t *testing.T) {
-	b := &precompute.Balance{}
+	b := &types.Balance{}
 	b = precompute.EnsureBalancesLowerBound(b)
 	balanceIncrement := params.BeaconConfig().EffectiveBalanceIncrement
 	assert.Equal(t, balanceIncrement, b.ActiveCurrentEpoch, "Did not get wanted active current balance")

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

@@ -6,6 +6,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
@@ -44,7 +45,7 @@ func UnrealizedCheckpoints(st state.BeaconState) (*ethpb.Checkpoint, *ethpb.Chec
 //    previous_target_balance = get_attesting_balance(state, previous_attestations)
 //    current_target_balance = get_attesting_balance(state, current_attestations)
 //    weigh_justification_and_finalization(state, total_active_balance, previous_target_balance, current_target_balance)
-func ProcessJustificationAndFinalizationPreCompute(state state.BeaconState, pBal *Balance) (state.BeaconState, error) {
+func ProcessJustificationAndFinalizationPreCompute(state state.BeaconState, pBal *types.Balance) (state.BeaconState, error) {
 	canProcessSlot, err := slots.EpochStart(2 /*epoch*/)
 	if err != nil {
 		return nil, err
@@ -149,14 +150,14 @@ func computeCheckpoints(state state.BeaconState, newBits bitfield.Bitvector4) (*
 	finalizedCheckpoint := state.FinalizedCheckpoint()
 
 	// If 2/3 or more of the total balance attested in the current epoch.
-	if newBits.BitAt(0) && currentEpoch >= justifiedCheckpoint.Epoch {
+	if newBits.BitAt(0) {
 		blockRoot, err := helpers.BlockRoot(state, currentEpoch)
 		if err != nil {
 			return nil, nil, errors.Wrapf(err, "could not get block root for current epoch %d", currentEpoch)
 		}
 		justifiedCheckpoint.Epoch = currentEpoch
 		justifiedCheckpoint.Root = blockRoot
-	} else if newBits.BitAt(1) && prevEpoch >= justifiedCheckpoint.Epoch {
+	} else if newBits.BitAt(1) {
 		// If 2/3 or more of total balance attested in the previous epoch.
 		blockRoot, err := helpers.BlockRoot(state, prevEpoch)
 		if err != nil {

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

@@ -43,7 +43,7 @@ func TestProcessJustificationAndFinalizationPreCompute_ConsecutiveEpochs(t *test
 	state, err := v1.InitializeFromProto(base)
 	require.NoError(t, err)
 	attestedBalance := 4 * uint64(e) * 3 / 2
-	b := &precompute.Balance{PrevEpochTargetAttested: attestedBalance}
+	b := &types.Balance{PrevEpochTargetAttested: attestedBalance}
 	newState, err := precompute.ProcessJustificationAndFinalizationPreCompute(state, b)
 	require.NoError(t, err)
 	rt := [32]byte{byte(64)}
@@ -80,7 +80,7 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyCurrentEpoch(t *te
 	state, err := v1.InitializeFromProto(base)
 	require.NoError(t, err)
 	attestedBalance := 4 * uint64(e) * 3 / 2
-	b := &precompute.Balance{PrevEpochTargetAttested: attestedBalance}
+	b := &types.Balance{PrevEpochTargetAttested: attestedBalance}
 	newState, err := precompute.ProcessJustificationAndFinalizationPreCompute(state, b)
 	require.NoError(t, err)
 	rt := [32]byte{byte(64)}
@@ -116,7 +116,7 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyPrevEpoch(t *testi
 	state, err := v1.InitializeFromProto(base)
 	require.NoError(t, err)
 	attestedBalance := 4 * uint64(e) * 3 / 2
-	b := &precompute.Balance{PrevEpochTargetAttested: attestedBalance}
+	b := &types.Balance{PrevEpochTargetAttested: attestedBalance}
 	newState, err := precompute.ProcessJustificationAndFinalizationPreCompute(state, b)
 	require.NoError(t, err)
 	rt := [32]byte{byte(64)}
@@ -250,18 +250,3 @@ func TestUnrealizedCheckpoints(t *testing.T) {
 		})
 	}
 }
-
-func Test_ComputeCheckpoints_CantUpdateToLower(t *testing.T) {
-	st, err := v2.InitializeFromProto(&ethpb.BeaconStateAltair{
-		Slot: params.BeaconConfig().SlotsPerEpoch * 2,
-		CurrentJustifiedCheckpoint: &ethpb.Checkpoint{
-			Epoch: 2,
-		},
-	})
-	require.NoError(t, err)
-	jb := make(bitfield.Bitvector4, 1)
-	jb.SetBitAt(1, true)
-	cp, _, err := precompute.ComputeCheckpoints(st, jb)
-	require.NoError(t, err)
-	require.Equal(t, types.Epoch(2), cp.Epoch)
-}

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

@@ -11,18 +11,19 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
+	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"go.opencensus.io/trace"
 )
 
 // New gets called at the beginning of process epoch cycle to return
 // pre computed instances of validators attesting records and total
 // balances attested in an epoch.
-func New(ctx context.Context, s state.BeaconState) ([]*Validator, *Balance, error) {
+func New(ctx context.Context, s state.BeaconState) ([]*types.Validator, *types.Balance, error) {
 	_, span := trace.StartSpan(ctx, "precomputeEpoch.New")
 	defer span.End()
 
-	pValidators := make([]*Validator, s.NumValidators())
-	pBal := &Balance{}
+	pValidators := make([]*types.Validator, s.NumValidators())
+	pBal := &types.Balance{}
 
 	currentEpoch := time.CurrentEpoch(s)
 	prevEpoch := time.PrevEpoch(s)
@@ -30,7 +31,7 @@ func New(ctx context.Context, s state.BeaconState) ([]*Validator, *Balance, erro
 	if err := s.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
 		// Was validator withdrawable or slashed
 		withdrawable := prevEpoch+1 >= val.WithdrawableEpoch()
-		pVal := &Validator{
+		pVal := &types.Validator{
 			IsSlashed:                    val.Slashed(),
 			IsWithdrawableCurrentEpoch:   withdrawable,
 			CurrentEpochEffectiveBalance: val.EffectiveBalance(),

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

@@ -7,6 +7,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
+	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -31,33 +32,33 @@ func TestNew(t *testing.T) {
 	e := params.BeaconConfig().FarFutureSlot
 	v, b, err := precompute.New(context.Background(), s)
 	require.NoError(t, err)
-	assert.DeepEqual(t, &precompute.Validator{
+	assert.DeepEqual(t, &types.Validator{
 		IsSlashed:                    true,
 		CurrentEpochEffectiveBalance: 100,
 		InclusionDistance:            e,
 		InclusionSlot:                e,
 	}, v[0], "Incorrect validator 0 status")
-	assert.DeepEqual(t, &precompute.Validator{
+	assert.DeepEqual(t, &types.Validator{
 		IsWithdrawableCurrentEpoch:   true,
 		CurrentEpochEffectiveBalance: 100,
 		InclusionDistance:            e,
 		InclusionSlot:                e,
 	}, v[1], "Incorrect validator 1 status")
-	assert.DeepEqual(t, &precompute.Validator{
+	assert.DeepEqual(t, &types.Validator{
 		IsActiveCurrentEpoch:         true,
 		IsActivePrevEpoch:            true,
 		CurrentEpochEffectiveBalance: 100,
 		InclusionDistance:            e,
 		InclusionSlot:                e,
 	}, v[2], "Incorrect validator 2 status")
-	assert.DeepEqual(t, &precompute.Validator{
+	assert.DeepEqual(t, &types.Validator{
 		IsActivePrevEpoch:            true,
 		CurrentEpochEffectiveBalance: 100,
 		InclusionDistance:            e,
 		InclusionSlot:                e,
 	}, v[3], "Incorrect validator 3 status")
 
-	wantedBalances := &precompute.Balance{
+	wantedBalances := &types.Balance{
 		ActiveCurrentEpoch: 100,
 		ActivePrevEpoch:    200,
 	}

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

@@ -1,3 +0,0 @@
-package precompute
-
-var ComputeCheckpoints = computeCheckpoints

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

@@ -10,15 +10,15 @@ import (
 	"github.com/prysmaticlabs/prysm/math"
 )
 
-type attesterRewardsFunc func(state.ReadOnlyBeaconState, *Balance, []*Validator) ([]uint64, []uint64, error)
-type proposerRewardsFunc func(state.ReadOnlyBeaconState, *Balance, []*Validator) ([]uint64, error)
+type attesterRewardsFunc func(state.ReadOnlyBeaconState, *types.Balance, []*types.Validator) ([]uint64, []uint64, error)
+type proposerRewardsFunc func(state.ReadOnlyBeaconState, *types.Balance, []*types.Validator) ([]uint64, error)
 
 // ProcessRewardsAndPenaltiesPrecompute processes the rewards and penalties of individual validator.
 // This is an optimized version by passing in precomputed validator attesting records and and total epoch balances.
 func ProcessRewardsAndPenaltiesPrecompute(
 	state state.BeaconState,
-	pBal *Balance,
-	vp []*Validator,
+	pBal *types.Balance,
+	vp []*types.Validator,
 	attRewardsFunc attesterRewardsFunc,
 	proRewardsFunc proposerRewardsFunc,
 ) (state.BeaconState, error) {
@@ -65,7 +65,7 @@ func ProcessRewardsAndPenaltiesPrecompute(
 
 // AttestationsDelta computes and returns the rewards and penalties differences for individual validators based on the
 // voting records.
-func AttestationsDelta(state state.ReadOnlyBeaconState, pBal *Balance, vp []*Validator) ([]uint64, []uint64, error) {
+func AttestationsDelta(state state.ReadOnlyBeaconState, pBal *types.Balance, vp []*types.Validator) ([]uint64, []uint64, error) {
 	numOfVals := state.NumValidators()
 	rewards := make([]uint64, numOfVals)
 	penalties := make([]uint64, numOfVals)
@@ -79,7 +79,7 @@ func AttestationsDelta(state state.ReadOnlyBeaconState, pBal *Balance, vp []*Val
 	return rewards, penalties, nil
 }
 
-func attestationDelta(pBal *Balance, sqrtActiveCurrentEpoch uint64, v *Validator, prevEpoch, finalizedEpoch types.Epoch) (uint64, uint64) {
+func attestationDelta(pBal *types.Balance, sqrtActiveCurrentEpoch uint64, v *types.Validator, prevEpoch, finalizedEpoch types.Epoch) (uint64, uint64) {
 	if !EligibleForRewards(v) || pBal.ActiveCurrentEpoch == 0 {
 		return 0, 0
 	}
@@ -156,7 +156,7 @@ func attestationDelta(pBal *Balance, sqrtActiveCurrentEpoch uint64, v *Validator
 
 // ProposersDelta computes and returns the rewards and penalties differences for individual validators based on the
 // proposer inclusion records.
-func ProposersDelta(state state.ReadOnlyBeaconState, pBal *Balance, vp []*Validator) ([]uint64, error) {
+func ProposersDelta(state state.ReadOnlyBeaconState, pBal *types.Balance, vp []*types.Validator) ([]uint64, error) {
 	numofVals := state.NumValidators()
 	rewards := make([]uint64, numofVals)
 
@@ -190,6 +190,6 @@ func ProposersDelta(state state.ReadOnlyBeaconState, pBal *Balance, vp []*Valida
 //
 // Spec code:
 // if is_active_validator(v, previous_epoch) or (v.slashed and previous_epoch + 1 < v.withdrawable_epoch)
-func EligibleForRewards(v *Validator) bool {
+func EligibleForRewards(v *types.Validator) bool {
 	return v.IsActivePrevEpoch || (v.IsSlashed && !v.IsWithdrawableCurrentEpoch)
 }

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

@@ -307,8 +307,8 @@ func TestProposerDeltaPrecompute_HappyCase(t *testing.T) {
 	require.NoError(t, err)
 
 	proposerIndex := types.ValidatorIndex(1)
-	b := &Balance{ActiveCurrentEpoch: 1000}
-	v := []*Validator{
+	b := &types.Balance{ActiveCurrentEpoch: 1000}
+	v := []*types.Validator{
 		{IsPrevEpochAttester: true, CurrentEpochEffectiveBalance: 32, ProposerIndex: proposerIndex},
 	}
 	r, err := ProposersDelta(beaconState, b, v)
@@ -329,8 +329,8 @@ func TestProposerDeltaPrecompute_ValidatorIndexOutOfRange(t *testing.T) {
 	require.NoError(t, err)
 
 	proposerIndex := types.ValidatorIndex(validatorCount)
-	b := &Balance{ActiveCurrentEpoch: 1000}
-	v := []*Validator{
+	b := &types.Balance{ActiveCurrentEpoch: 1000}
+	v := []*types.Validator{
 		{IsPrevEpochAttester: true, CurrentEpochEffectiveBalance: 32, ProposerIndex: proposerIndex},
 	}
 	_, err = ProposersDelta(beaconState, b, v)
@@ -345,8 +345,8 @@ func TestProposerDeltaPrecompute_SlashedCase(t *testing.T) {
 	require.NoError(t, err)
 
 	proposerIndex := types.ValidatorIndex(1)
-	b := &Balance{ActiveCurrentEpoch: 1000}
-	v := []*Validator{
+	b := &types.Balance{ActiveCurrentEpoch: 1000}
+	v := []*types.Validator{
 		{IsPrevEpochAttester: true, CurrentEpochEffectiveBalance: 32, ProposerIndex: proposerIndex, IsSlashed: true},
 	}
 	r, err := ProposersDelta(beaconState, b, v)

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

@@ -12,7 +12,7 @@ import (
 
 // ProcessSlashingsPrecompute processes the slashed validators during epoch processing.
 // This is an optimized version by passing in precomputed total epoch balances.
-func ProcessSlashingsPrecompute(s state.BeaconState, pBal *Balance) error {
+func ProcessSlashingsPrecompute(s state.BeaconState, pBal *types.Balance) error {
 	currentEpoch := time.CurrentEpoch(s)
 	exitLength := params.BeaconConfig().EpochsPerSlashingsVector
 

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

@@ -7,6 +7,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
+	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -21,7 +22,7 @@ func TestProcessSlashingsPrecompute_NotSlashedWithSlashedTrue(t *testing.T) {
 		Slashings:  []uint64{0, 1e9},
 	})
 	require.NoError(t, err)
-	pBal := &precompute.Balance{ActiveCurrentEpoch: params.BeaconConfig().MaxEffectiveBalance}
+	pBal := &types.Balance{ActiveCurrentEpoch: params.BeaconConfig().MaxEffectiveBalance}
 	require.NoError(t, precompute.ProcessSlashingsPrecompute(s, pBal))
 
 	wanted := params.BeaconConfig().MaxEffectiveBalance
@@ -36,7 +37,7 @@ func TestProcessSlashingsPrecompute_NotSlashedWithSlashedFalse(t *testing.T) {
 		Slashings:  []uint64{0, 1e9},
 	})
 	require.NoError(t, err)
-	pBal := &precompute.Balance{ActiveCurrentEpoch: params.BeaconConfig().MaxEffectiveBalance}
+	pBal := &types.Balance{ActiveCurrentEpoch: params.BeaconConfig().MaxEffectiveBalance}
 	require.NoError(t, precompute.ProcessSlashingsPrecompute(s, pBal))
 
 	wanted := params.BeaconConfig().MaxEffectiveBalance
@@ -120,7 +121,7 @@ func TestProcessSlashingsPrecompute_SlashedLess(t *testing.T) {
 				}
 				ab += b
 			}
-			pBal := &precompute.Balance{ActiveCurrentEpoch: ab}
+			pBal := &types.Balance{ActiveCurrentEpoch: ab}
 
 			original := proto.Clone(tt.state)
 			state, err := v1.InitializeFromProto(tt.state)

beacon-chain/core/helpers/rewards_penalties.go

@@ -76,8 +76,6 @@ func TotalActiveBalance(s state.ReadOnlyBeaconState) (uint64, error) {
 		return 0, err
 	}
 
-	// Spec defines `EffectiveBalanceIncrement` as min to avoid divisions by zero.
-	total = mathutil.Max(params.BeaconConfig().EffectiveBalanceIncrement, total)
 	if err := balanceCache.AddTotalEffectiveBalance(s, total); err != nil {
 		return 0, err
 	}

beacon-chain/core/helpers/rewards_penalties_test.go

@@ -74,27 +74,6 @@ func TestTotalActiveBalance(t *testing.T) {
 	}
 }
 
-func TestTotalActiveBal_ReturnMin(t *testing.T) {
-	tests := []struct {
-		vCount int
-	}{
-		{1},
-		{10},
-		{10000},
-	}
-	for _, test := range tests {
-		validators := make([]*ethpb.Validator, 0)
-		for i := 0; i < test.vCount; i++ {
-			validators = append(validators, &ethpb.Validator{EffectiveBalance: 1, ExitEpoch: 1})
-		}
-		state, err := v1.InitializeFromProto(&ethpb.BeaconState{Validators: validators})
-		require.NoError(t, err)
-		bal, err := TotalActiveBalance(state)
-		require.NoError(t, err)
-		require.Equal(t, params.BeaconConfig().EffectiveBalanceIncrement, bal)
-	}
-}
-
 func TestTotalActiveBalance_WithCache(t *testing.T) {
 	tests := []struct {
 		vCount    int

beacon-chain/core/signing/BUILD.bazel

@@ -42,6 +42,7 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
     ],
 )

beacon-chain/core/signing/signature.go

@@ -3,6 +3,7 @@ package signing
 import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/config/params"
+	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
 
@@ -10,19 +11,17 @@ var ErrNilRegistration = errors.New("nil signed registration")
 
 // VerifyRegistrationSignature verifies the signature of a validator's registration.
 func VerifyRegistrationSignature(
+	e types.Epoch,
+	f *ethpb.Fork,
 	sr *ethpb.SignedValidatorRegistrationV1,
+	genesisRoot []byte,
 ) error {
 	if sr == nil || sr.Message == nil {
 		return ErrNilRegistration
 	}
 
 	d := params.BeaconConfig().DomainApplicationBuilder
-	// Per spec, we want the fork version and genesis validator to be nil.
-	// Which is genesis value and zero by default.
-	sd, err := ComputeDomain(
-		d,
-		nil, /* fork version */
-		nil /* genesis val root */)
+	sd, err := Domain(f, e, d, genesisRoot)
 	if err != nil {
 		return err
 	}

beacon-chain/core/signing/signature_test.go

@@ -10,6 +10,8 @@ import (
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
+	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
 func TestVerifyRegistrationSignature(t *testing.T) {
@@ -21,22 +23,22 @@ func TestVerifyRegistrationSignature(t *testing.T) {
 		Timestamp:    uint64(time.Now().Unix()),
 		Pubkey:       sk.PublicKey().Marshal(),
 	}
+	st, _ := util.DeterministicGenesisState(t, 1)
 	d := params.BeaconConfig().DomainApplicationBuilder
-	domain, err := signing.ComputeDomain(d, nil, nil)
+	e := slots.ToEpoch(st.Slot())
+	sig, err := signing.ComputeDomainAndSign(st, e, reg, d, sk)
 	require.NoError(t, err)
-	sr, err := signing.ComputeSigningRoot(reg, domain)
-	require.NoError(t, err)
-	sk.Sign(sr[:]).Marshal()
-
 	sReg := &ethpb.SignedValidatorRegistrationV1{
 		Message:   reg,
-		Signature: sk.Sign(sr[:]).Marshal(),
+		Signature: sig,
 	}
-	require.NoError(t, signing.VerifyRegistrationSignature(sReg))
+	f := st.Fork()
+	g := st.GenesisValidatorsRoot()
+	require.NoError(t, signing.VerifyRegistrationSignature(e, f, sReg, g))
 
 	sReg.Signature = []byte("bad")
-	require.ErrorIs(t, signing.VerifyRegistrationSignature(sReg), signing.ErrSigFailedToVerify)
+	require.ErrorIs(t, signing.VerifyRegistrationSignature(e, f, sReg, g), signing.ErrSigFailedToVerify)
 
 	sReg.Message = nil
-	require.ErrorIs(t, signing.VerifyRegistrationSignature(sReg), signing.ErrNilRegistration)
+	require.ErrorIs(t, signing.VerifyRegistrationSignature(e, f, sReg, g), signing.ErrNilRegistration)
 }

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) ([]interfaces.SignedBeaconBlock, error)
+	BlocksBySlot(ctx context.Context, slot types.Slot) (bool, []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)
-	HighestRootsBelowSlot(ctx context.Context, slot types.Slot) (types.Slot, [][32]byte, error)
+	HighestSlotBlocksBelow(ctx context.Context, slot types.Slot) ([]interfaces.SignedBeaconBlock, 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,7 +86,6 @@ 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

@@ -185,19 +185,17 @@ 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) ([]interfaces.SignedBeaconBlock, error) {
+func (s *Store) BlocksBySlot(ctx context.Context, slot types.Slot) (bool, []interfaces.SignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.BlocksBySlot")
 	defer span.End()
-
 	blocks := make([]interfaces.SignedBeaconBlock, 0)
+
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blocksBucket)
-		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[:])
+
+		keys := blockRootsBySlot(ctx, tx, slot)
+		for i := 0; i < len(keys); i++ {
+			encoded := bkt.Get(keys[i])
 			blk, err := unmarshalBlock(ctx, encoded)
 			if err != nil {
 				return err
@@ -206,7 +204,7 @@ func (s *Store) BlocksBySlot(ctx context.Context, slot types.Slot) ([]interfaces
 		}
 		return nil
 	})
-	return blocks, err
+	return len(blocks) > 0, blocks, err
 }
 
 // BlockRootsBySlot retrieves a list of beacon block roots by slot
@@ -215,9 +213,11 @@ 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 {
-		var err error
-		blockRoots, err = blockRootsBySlot(ctx, tx, slot)
-		return err
+		keys := blockRootsBySlot(ctx, tx, slot)
+		for i := 0; i < len(keys); i++ {
+			blockRoots = append(blockRoots, bytesutil.ToBytes32(keys[i]))
+		}
+		return nil
 	})
 	if err != nil {
 		return false, nil, errors.Wrap(err, "could not retrieve block roots by slot")
@@ -398,17 +398,14 @@ func (s *Store) SaveBackfillBlockRoot(ctx context.Context, blockRoot [32]byte) e
 	})
 }
 
-// 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")
+// 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")
 	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:
@@ -433,28 +430,34 @@ func (s *Store) HighestRootsBelowSlot(ctx context.Context, slot types.Slot) (fs
 			if r == nil {
 				continue
 			}
-			fs = bytesutil.BytesToSlotBigEndian(sl)
+			bs := 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 > fs {
-				roots, err = splitRoots(r)
-				if err != nil {
-					return errors.Wrapf(err, "error parsing packed roots %#x", r)
-				}
-				return nil
+			if slot > bs {
+				root = bytesutil.ToBytes32(r)
+				break
 			}
 		}
 		return nil
 	})
 	if err != nil {
-		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
+		return nil, err
 	}
 
-	return fs, roots, nil
+	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
 }
 
 // FeeRecipientByValidatorID returns the fee recipient for a validator id.
@@ -678,22 +681,21 @@ func blockRootsBySlotRange(
 }
 
 // blockRootsBySlot retrieves the block roots by slot
-func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) ([][32]byte, error) {
+func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) [][]byte {
 	_, 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) {
-		r, err := splitRoots(v)
-		if err != nil {
-			return nil, errors.Wrapf(err, "corrupt value in block slot index for slot=%d", slot)
+		for i := 0; i < len(v); i += 32 {
+			roots = append(roots, v[i:i+32])
 		}
-		return r, nil
 	}
-	return [][32]byte{}, nil
+	return roots
 }
 
 // createBlockIndicesFromBlock takes in a beacon block and returns

beacon-chain/db/kv/blocks_test.go

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

beacon-chain/db/kv/kv.go

@@ -105,6 +105,7 @@ func NewKVStore(ctx context.Context, dirPath string, config *Config) (*Store, er
 		}
 	}
 	datafile := KVStoreDatafilePath(dirPath)
+	start := time.Now()
 	log.Infof("Opening Bolt DB at %s", datafile)
 	boltDB, err := bolt.Open(
 		datafile,
@@ -115,29 +116,40 @@ func NewKVStore(ctx context.Context, dirPath string, config *Config) (*Store, er
 		},
 	)
 	if err != nil {
+		log.WithField("elapsed", time.Since(start)).Error("Failed to open Bolt DB")
 		if errors.Is(err, bolt.ErrTimeout) {
 			return nil, errors.New("cannot obtain database lock, database may be in use by another process")
 		}
 		return nil, err
 	}
+	log.WithField("elapsed", time.Since(start)).Info("Opened Bolt DB")
+
 	boltDB.AllocSize = boltAllocSize
+	start = time.Now()
+	log.Infof("Creating block cache...")
 	blockCache, err := ristretto.NewCache(&ristretto.Config{
 		NumCounters: 1000,           // number of keys to track frequency of (1000).
 		MaxCost:     BlockCacheSize, // maximum cost of cache (1000 Blocks).
 		BufferItems: 64,             // number of keys per Get buffer.
 	})
 	if err != nil {
+		log.WithField("elapsed", time.Since(start)).Error("Failed to create block cache")
 		return nil, err
 	}
+	log.WithField("elapsed", time.Since(start)).Info("Created block cache")
 
+	start = time.Now()
+	log.Infof("Creating validator cache...")
 	validatorCache, err := ristretto.NewCache(&ristretto.Config{
 		NumCounters: NumOfValidatorEntries, // number of entries in cache (2 Million).
 		MaxCost:     ValidatorEntryMaxCost, // maximum size of the cache (64Mb)
 		BufferItems: 64,                    // number of keys per Get buffer.
 	})
 	if err != nil {
+		log.WithField("elapsed", time.Since(start)).Error("Failed to to create validator cache")
 		return nil, err
 	}
+	log.WithField("elapsed", time.Since(start)).Info("Created validator cache")
 
 	kv := &Store{
 		db:                  boltDB,
@@ -147,6 +159,8 @@ func NewKVStore(ctx context.Context, dirPath string, config *Config) (*Store, er
 		stateSummaryCache:   newStateSummaryCache(),
 		ctx:                 ctx,
 	}
+	start = time.Now()
+	log.Infof("Updating DB and creating buckets...")
 	if err := kv.db.Update(func(tx *bolt.Tx) error {
 		return createBuckets(
 			tx,
@@ -181,9 +195,13 @@ func NewKVStore(ctx context.Context, dirPath string, config *Config) (*Store, er
 			registrationBucket,
 		)
 	}); err != nil {
+		log.WithField("elapsed", time.Since(start)).Error("Failed to update db and create buckets")
 		return nil, err
 	}
+	log.WithField("elapsed", time.Since(start)).Info("Updated db and created buckets")
+
 	err = prometheus.Register(createBoltCollector(kv.db))
+
 	return kv, err
 }
 

beacon-chain/db/kv/state.go

@@ -162,27 +162,12 @@ func (s *Store) SaveStatesEfficient(ctx context.Context, states []state.ReadOnly
 	if states == nil {
 		return errors.New("nil state")
 	}
-	validatorKeys, validatorsEntries, err := getValidators(states)
-	if err != nil {
-		return err
-	}
-
-	if err := s.db.Update(func(tx *bolt.Tx) error {
-		return s.saveStatesEfficientInternal(ctx, tx, blockRoots, states, validatorKeys, validatorsEntries)
-	}); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func getValidators(states []state.ReadOnlyBeaconState) ([][]byte, map[string]*ethpb.Validator, error) {
 	validatorsEntries := make(map[string]*ethpb.Validator) // It's a map to make sure that you store only new validator entries.
 	validatorKeys := make([][]byte, len(states))           // For every state, this stores a compressed list of validator keys.
 	for i, st := range states {
 		pb, ok := st.InnerStateUnsafe().(withValidators)
 		if !ok {
-			return nil, nil, errors.New("could not cast state to interface with GetValidators()")
+			return errors.New("could not cast state to interface with GetValidators()")
 		}
 		validators := pb.GetValidators()
 
@@ -192,7 +177,7 @@ func getValidators(states []state.ReadOnlyBeaconState) ([][]byte, map[string]*et
 			// create the unique hash for that validator entry.
 			hash, hashErr := val.HashTreeRoot()
 			if hashErr != nil {
-				return nil, nil, hashErr
+				return hashErr
 			}
 			hashes = append(hashes, hash[:]...)
 
@@ -202,113 +187,117 @@ func getValidators(states []state.ReadOnlyBeaconState) ([][]byte, map[string]*et
 		}
 		validatorKeys[i] = snappy.Encode(nil, hashes)
 	}
-	return validatorKeys, validatorsEntries, nil
-}
 
-func (s *Store) saveStatesEfficientInternal(ctx context.Context, tx *bolt.Tx, blockRoots [][32]byte, states []state.ReadOnlyBeaconState, validatorKeys [][]byte, validatorsEntries map[string]*ethpb.Validator) error {
-	bucket := tx.Bucket(stateBucket)
-	valIdxBkt := tx.Bucket(blockRootValidatorHashesBucket)
-	for i, rt := range blockRoots {
-		indicesByBucket := createStateIndicesFromStateSlot(ctx, states[i].Slot())
-		if err := updateValueForIndices(ctx, indicesByBucket, rt[:], tx); err != nil {
-			return errors.Wrap(err, "could not update DB indices")
+	if err := s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(stateBucket)
+		valIdxBkt := tx.Bucket(blockRootValidatorHashesBucket)
+		for i, rt := range blockRoots {
+			indicesByBucket := createStateIndicesFromStateSlot(ctx, states[i].Slot())
+			if err := updateValueForIndices(ctx, indicesByBucket, rt[:], tx); err != nil {
+				return errors.Wrap(err, "could not update DB indices")
+			}
+
+			// There is a gap when the states that are passed are used outside this
+			// thread. But while storing the state object, we should not store the
+			// validator entries.To bring the gap closer, we empty the validators
+			// just before Put() and repopulate that state with original validators.
+			// look at issue https://github.com/prysmaticlabs/prysm/issues/9262.
+			switch rawType := states[i].InnerStateUnsafe().(type) {
+			case *ethpb.BeaconState:
+				var pbState *ethpb.BeaconState
+				var err error
+				if features.Get().EnableNativeState {
+					pbState, err = state_native.ProtobufBeaconStatePhase0(rawType)
+				} else {
+					pbState, err = v1.ProtobufBeaconState(rawType)
+				}
+				if err != nil {
+					return err
+				}
+				if pbState == nil {
+					return errors.New("nil state")
+				}
+				valEntries := pbState.Validators
+				pbState.Validators = make([]*ethpb.Validator, 0)
+				encodedState, err := encode(ctx, pbState)
+				if err != nil {
+					return err
+				}
+				if err := bucket.Put(rt[:], encodedState); err != nil {
+					return err
+				}
+				pbState.Validators = valEntries
+				if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
+					return err
+				}
+			case *ethpb.BeaconStateAltair:
+				var pbState *ethpb.BeaconStateAltair
+				var err error
+				if features.Get().EnableNativeState {
+					pbState, err = state_native.ProtobufBeaconStateAltair(rawType)
+				} else {
+					pbState, err = v2.ProtobufBeaconState(rawType)
+				}
+				if err != nil {
+					return err
+				}
+				if pbState == nil {
+					return errors.New("nil state")
+				}
+				valEntries := pbState.Validators
+				pbState.Validators = make([]*ethpb.Validator, 0)
+				rawObj, err := pbState.MarshalSSZ()
+				if err != nil {
+					return err
+				}
+				encodedState := snappy.Encode(nil, append(altairKey, rawObj...))
+				if err := bucket.Put(rt[:], encodedState); err != nil {
+					return err
+				}
+				pbState.Validators = valEntries
+				if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
+					return err
+				}
+			case *ethpb.BeaconStateBellatrix:
+				var pbState *ethpb.BeaconStateBellatrix
+				var err error
+				if features.Get().EnableNativeState {
+					pbState, err = state_native.ProtobufBeaconStateBellatrix(rawType)
+				} else {
+					pbState, err = v3.ProtobufBeaconState(rawType)
+				}
+				if err != nil {
+					return err
+				}
+				if pbState == nil {
+					return errors.New("nil state")
+				}
+				valEntries := pbState.Validators
+				pbState.Validators = make([]*ethpb.Validator, 0)
+				rawObj, err := pbState.MarshalSSZ()
+				if err != nil {
+					return err
+				}
+				encodedState := snappy.Encode(nil, append(bellatrixKey, rawObj...))
+				if err := bucket.Put(rt[:], encodedState); err != nil {
+					return err
+				}
+				pbState.Validators = valEntries
+				if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
+					return err
+				}
+			default:
+				return errors.New("invalid state type")
+			}
 		}
 
-		// There is a gap when the states that are passed are used outside this
-		// thread. But while storing the state object, we should not store the
-		// validator entries.To bring the gap closer, we empty the validators
-		// just before Put() and repopulate that state with original validators.
-		// look at issue https://github.com/prysmaticlabs/prysm/issues/9262.
-		switch rawType := states[i].InnerStateUnsafe().(type) {
-		case *ethpb.BeaconState:
-			var pbState *ethpb.BeaconState
-			var err error
-			if features.Get().EnableNativeState {
-				pbState, err = state_native.ProtobufBeaconStatePhase0(rawType)
-			} else {
-				pbState, err = v1.ProtobufBeaconState(rawType)
-			}
-			if err != nil {
-				return err
-			}
-			if pbState == nil {
-				return errors.New("nil state")
-			}
-			valEntries := pbState.Validators
-			pbState.Validators = make([]*ethpb.Validator, 0)
-			encodedState, err := encode(ctx, pbState)
-			if err != nil {
-				return err
-			}
-			if err := bucket.Put(rt[:], encodedState); err != nil {
-				return err
-			}
-			pbState.Validators = valEntries
-			if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
-				return err
-			}
-		case *ethpb.BeaconStateAltair:
-			var pbState *ethpb.BeaconStateAltair
-			var err error
-			if features.Get().EnableNativeState {
-				pbState, err = state_native.ProtobufBeaconStateAltair(rawType)
-			} else {
-				pbState, err = v2.ProtobufBeaconState(rawType)
-			}
-			if err != nil {
-				return err
-			}
-			if pbState == nil {
-				return errors.New("nil state")
-			}
-			valEntries := pbState.Validators
-			pbState.Validators = make([]*ethpb.Validator, 0)
-			rawObj, err := pbState.MarshalSSZ()
-			if err != nil {
-				return err
-			}
-			encodedState := snappy.Encode(nil, append(altairKey, rawObj...))
-			if err := bucket.Put(rt[:], encodedState); err != nil {
-				return err
-			}
-			pbState.Validators = valEntries
-			if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
-				return err
-			}
-		case *ethpb.BeaconStateBellatrix:
-			var pbState *ethpb.BeaconStateBellatrix
-			var err error
-			if features.Get().EnableNativeState {
-				pbState, err = state_native.ProtobufBeaconStateBellatrix(rawType)
-			} else {
-				pbState, err = v3.ProtobufBeaconState(rawType)
-			}
-			if err != nil {
-				return err
-			}
-			if pbState == nil {
-				return errors.New("nil state")
-			}
-			valEntries := pbState.Validators
-			pbState.Validators = make([]*ethpb.Validator, 0)
-			rawObj, err := pbState.MarshalSSZ()
-			if err != nil {
-				return err
-			}
-			encodedState := snappy.Encode(nil, append(bellatrixKey, rawObj...))
-			if err := bucket.Put(rt[:], encodedState); err != nil {
-				return err
-			}
-			pbState.Validators = valEntries
-			if err := valIdxBkt.Put(rt[:], validatorKeys[i]); err != nil {
-				return err
-			}
-		default:
-			return errors.New("invalid state type")
-		}
+		// store the validator entries separately to save space.
+		return s.storeValidatorEntriesSeparately(ctx, tx, validatorsEntries)
+	}); err != nil {
+		return err
 	}
-	// store the validator entries separately to save space.
-	return s.storeValidatorEntriesSeparately(ctx, tx, validatorsEntries)
+
+	return nil
 }
 
 func (s *Store) storeValidatorEntriesSeparately(ctx context.Context, tx *bolt.Tx, validatorsEntries map[string]*ethpb.Validator) error {

beacon-chain/db/kv/utils.go

@@ -4,8 +4,6 @@ import (
 	"bytes"
 	"context"
 
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	bolt "go.etcd.io/bbolt"
 	"go.opencensus.io/trace"
 )
@@ -101,16 +99,3 @@ 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,60 +138,3 @@ 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/forkchoice/doubly-linked-tree/BUILD.bazel

@@ -30,7 +30,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
@@ -62,6 +61,7 @@ go_test(
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
         "//crypto/hash:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",

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

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

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

@@ -13,24 +13,22 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
 
 // New initializes a new fork choice store.
-func New() *ForkChoice {
+func New(justifiedEpoch, finalizedEpoch types.Epoch) *ForkChoice {
 	s := &Store{
-		justifiedCheckpoint:     &forkchoicetypes.Checkpoint{},
-		bestJustifiedCheckpoint: &forkchoicetypes.Checkpoint{},
-		finalizedCheckpoint:     &forkchoicetypes.Checkpoint{},
-		proposerBoostRoot:       [32]byte{},
-		nodeByRoot:              make(map[[fieldparams.RootLength]byte]*Node),
-		nodeByPayload:           make(map[[fieldparams.RootLength]byte]*Node),
-		slashedIndices:          make(map[types.ValidatorIndex]bool),
-		pruneThreshold:          defaultPruneThreshold,
+		justifiedEpoch:    justifiedEpoch,
+		finalizedEpoch:    finalizedEpoch,
+		proposerBoostRoot: [32]byte{},
+		nodeByRoot:        make(map[[fieldparams.RootLength]byte]*Node),
+		nodeByPayload:     make(map[[fieldparams.RootLength]byte]*Node),
+		slashedIndices:    make(map[types.ValidatorIndex]bool),
+		pruneThreshold:    defaultPruneThreshold,
 	}
 
 	b := make([]uint64, 0)
@@ -49,6 +47,7 @@ func (f *ForkChoice) NodeCount() int {
 // It firsts computes validator's balance changes then recalculates block tree from leaves to root.
 func (f *ForkChoice) Head(
 	ctx context.Context,
+	justifiedRoot [32]byte,
 	justifiedStateBalances []uint64,
 ) ([32]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.Head")
@@ -74,12 +73,10 @@ func (f *ForkChoice) Head(
 		return [32]byte{}, errors.Wrap(err, "could not apply weight changes")
 	}
 
-	jc := f.JustifiedCheckpoint()
-	fc := f.FinalizedCheckpoint()
-	if err := f.store.treeRootNode.updateBestDescendant(ctx, jc.Epoch, fc.Epoch); err != nil {
+	if err := f.store.treeRootNode.updateBestDescendant(ctx, f.store.justifiedEpoch, f.store.finalizedEpoch); err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not update best descendant")
 	}
-	return f.store.head(ctx)
+	return f.store.head(ctx, justifiedRoot)
 }
 
 // ProcessAttestation processes attestation for vote accounting, it iterates around validator indices
@@ -141,55 +138,7 @@ func (f *ForkChoice) InsertNode(ctx context.Context, state state.ReadOnlyBeaconS
 		return errInvalidNilCheckpoint
 	}
 	finalizedEpoch := fc.Epoch
-	err := f.store.insert(ctx, slot, root, parentRoot, payloadHash, justifiedEpoch, finalizedEpoch)
-	if err != nil {
-		return err
-	}
-	return f.updateCheckpoints(ctx, jc, fc)
-}
-
-// updateCheckpoints update the checkpoints when inserting a new node.
-func (f *ForkChoice) updateCheckpoints(ctx context.Context, jc, fc *ethpb.Checkpoint) error {
-	f.store.checkpointsLock.Lock()
-	defer f.store.checkpointsLock.Unlock()
-	if jc.Epoch > f.store.justifiedCheckpoint.Epoch {
-		if jc.Epoch > f.store.bestJustifiedCheckpoint.Epoch {
-			f.store.bestJustifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: jc.Epoch,
-				Root: bytesutil.ToBytes32(jc.Root)}
-		}
-		currentSlot := slots.CurrentSlot(f.store.genesisTime)
-		if slots.SinceEpochStarts(currentSlot) < params.BeaconConfig().SafeSlotsToUpdateJustified {
-			f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: jc.Epoch,
-				Root: bytesutil.ToBytes32(jc.Root)}
-		} else {
-			currentJcp := f.store.justifiedCheckpoint
-			currentRoot := currentJcp.Root
-			if currentRoot == params.BeaconConfig().ZeroHash {
-				currentRoot = f.store.originRoot
-			}
-			jSlot, err := slots.EpochStart(currentJcp.Epoch)
-			if err != nil {
-				return err
-			}
-			jcRoot := bytesutil.ToBytes32(jc.Root)
-			root, err := f.AncestorRoot(ctx, jcRoot, jSlot)
-			if err != nil {
-				return err
-			}
-			if root == currentRoot {
-				f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: jc.Epoch,
-					Root: jcRoot}
-			}
-		}
-	}
-	// Update finalization
-	if fc.Epoch > f.store.finalizedCheckpoint.Epoch {
-		f.store.finalizedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: fc.Epoch,
-			Root: bytesutil.ToBytes32(fc.Root)}
-		f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: jc.Epoch,
-			Root: bytesutil.ToBytes32(jc.Root)}
-	}
-	return nil
+	return f.store.insert(ctx, slot, root, parentRoot, payloadHash, justifiedEpoch, finalizedEpoch)
 }
 
 // Prune prunes the fork choice store with the new finalized root. The store is only pruned if the input
@@ -258,7 +207,7 @@ func (f *ForkChoice) IsOptimistic(root [32]byte) (bool, error) {
 }
 
 // AncestorRoot returns the ancestor root of input block root at a given slot.
-func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot types.Slot) ([32]byte, error) {
+func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot types.Slot) ([]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "protoArray.AncestorRoot")
 	defer span.End()
 
@@ -267,22 +216,22 @@ func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot types
 
 	node, ok := f.store.nodeByRoot[root]
 	if !ok || node == nil {
-		return [32]byte{}, errors.Wrap(ErrNilNode, "could not determine ancestor root")
+		return nil, errors.Wrap(ErrNilNode, "could not determine ancestor root")
 	}
 
 	n := node
 	for n != nil && n.slot > slot {
 		if ctx.Err() != nil {
-			return [32]byte{}, ctx.Err()
+			return nil, ctx.Err()
 		}
 		n = n.parent
 	}
 
 	if n == nil {
-		return [32]byte{}, errors.Wrap(ErrNilNode, "could not determine ancestor root")
+		return nil, errors.Wrap(ErrNilNode, "could not determine ancestor root")
 	}
 
-	return n.root, nil
+	return n.root[:], nil
 }
 
 // updateBalances updates the balances that directly voted for each block taking into account the
@@ -377,24 +326,20 @@ func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [fieldparams
 	return node.setNodeAndParentValidated(ctx)
 }
 
-// JustifiedCheckpoint of fork choice store.
-func (f *ForkChoice) JustifiedCheckpoint() *forkchoicetypes.Checkpoint {
-	f.store.checkpointsLock.RLock()
-	defer f.store.checkpointsLock.RUnlock()
-	return f.store.justifiedCheckpoint
+// JustifiedEpoch of fork choice store.
+func (f *ForkChoice) JustifiedEpoch() types.Epoch {
+	return f.store.justifiedEpoch
 }
 
-// FinalizedCheckpoint of fork choice store.
-func (f *ForkChoice) FinalizedCheckpoint() *forkchoicetypes.Checkpoint {
-	f.store.checkpointsLock.RLock()
-	defer f.store.checkpointsLock.RUnlock()
-	return f.store.finalizedCheckpoint
+// FinalizedEpoch of fork choice store.
+func (f *ForkChoice) FinalizedEpoch() types.Epoch {
+	return f.store.finalizedEpoch
 }
 
-func (f *ForkChoice) ForkChoiceNodes() []*ethpb.ForkChoiceNode {
+func (f *ForkChoice) ForkChoiceNodes() []*pbrpc.ForkChoiceNode {
 	f.store.nodesLock.RLock()
 	defer f.store.nodesLock.RUnlock()
-	ret := make([]*ethpb.ForkChoiceNode, len(f.store.nodeByRoot))
+	ret := make([]*pbrpc.ForkChoiceNode, len(f.store.nodeByRoot))
 	return f.store.treeRootNode.rpcNodes(ret)
 }
 
@@ -439,29 +384,25 @@ func (f *ForkChoice) InsertSlashedIndex(_ context.Context, index types.Validator
 	}
 }
 
-// UpdateJustifiedCheckpoint sets the justified checkpoint to the given one
-func (f *ForkChoice) UpdateJustifiedCheckpoint(jc *forkchoicetypes.Checkpoint) error {
+// UpdateJustifiedCheckpoint sets the justified epoch to the given one
+func (f *ForkChoice) UpdateJustifiedCheckpoint(jc *pbrpc.Checkpoint) error {
 	if jc == nil {
 		return errInvalidNilCheckpoint
 	}
-	f.store.checkpointsLock.Lock()
-	defer f.store.checkpointsLock.Unlock()
-	f.store.justifiedCheckpoint = jc
-	bj := f.store.bestJustifiedCheckpoint
-	if bj == nil || jc.Epoch > bj.Epoch {
-		f.store.bestJustifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: jc.Epoch, Root: jc.Root}
-	}
+	f.store.nodesLock.Lock()
+	defer f.store.nodesLock.Unlock()
+	f.store.justifiedEpoch = jc.Epoch
 	return nil
 }
 
-// UpdateFinalizedCheckpoint sets the finalized checkpoint to the given one
-func (f *ForkChoice) UpdateFinalizedCheckpoint(fc *forkchoicetypes.Checkpoint) error {
+// UpdateFinalizedCheckpoint sets the finalized epoch to the given one
+func (f *ForkChoice) UpdateFinalizedCheckpoint(fc *pbrpc.Checkpoint) error {
 	if fc == nil {
 		return errInvalidNilCheckpoint
 	}
-	f.store.checkpointsLock.Lock()
-	defer f.store.checkpointsLock.Unlock()
-	f.store.finalizedCheckpoint = fc
+	f.store.nodesLock.Lock()
+	defer f.store.nodesLock.Unlock()
+	f.store.finalizedEpoch = fc.Epoch
 	return nil
 }
 
@@ -494,8 +435,6 @@ 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
 			}
@@ -532,19 +471,9 @@ func (f *ForkChoice) InsertOptimisticChain(ctx context.Context, chain []*forkcho
 		}
 		if err := f.store.insert(ctx,
 			b.Slot(), r, parentRoot, payloadHash,
-			chain[i].JustifiedCheckpoint.Epoch, chain[i].FinalizedCheckpoint.Epoch); err != nil {
+			chain[i].JustifiedEpoch, chain[i].FinalizedEpoch); err != nil {
 			return err
 		}
 	}
 	return nil
 }
-
-// SetGenesisTime sets the genesisTime tracked by forkchoice
-func (f *ForkChoice) SetGenesisTime(genesisTime uint64) {
-	f.store.genesisTime = genesisTime
-}
-
-// SetOriginRoot sets the genesis block root
-func (f *ForkChoice) SetOriginRoot(root [32]byte) {
-	f.store.originRoot = root
-}

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

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/binary"
 	"testing"
-	"time"
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
@@ -14,6 +13,7 @@ import (
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -211,9 +211,7 @@ func TestForkChoice_IsCanonicalReorg(t *testing.T) {
 	require.DeepEqual(t, [32]byte{'3'}, f.store.treeRootNode.bestDescendant.root)
 	f.store.nodesLock.Unlock()
 
-	r1 := [32]byte{'1'}
-	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 1, Root: r1}
-	h, err := f.store.head(ctx)
+	h, err := f.store.head(ctx, [32]byte{'1'})
 	require.NoError(t, err)
 	require.DeepEqual(t, [32]byte{'3'}, h)
 	require.DeepEqual(t, h, f.store.headNode.root)
@@ -244,7 +242,7 @@ func TestForkChoice_AncestorRoot(t *testing.T) {
 
 	r, err := f.AncestorRoot(ctx, indexToHash(3), 6)
 	assert.NoError(t, err)
-	assert.Equal(t, r, indexToHash(3))
+	assert.Equal(t, bytesutil.ToBytes32(r), indexToHash(3))
 
 	_, err = f.AncestorRoot(ctx, indexToHash(3), 0)
 	assert.ErrorContains(t, ErrNilNode.Error(), err)
@@ -252,11 +250,11 @@ func TestForkChoice_AncestorRoot(t *testing.T) {
 	root, err := f.AncestorRoot(ctx, indexToHash(3), 5)
 	require.NoError(t, err)
 	hash3 := indexToHash(3)
-	require.DeepEqual(t, hash3, root)
+	require.DeepEqual(t, hash3[:], root)
 	root, err = f.AncestorRoot(ctx, indexToHash(3), 1)
 	require.NoError(t, err)
 	hash1 := indexToHash(1)
-	require.DeepEqual(t, hash1, root)
+	require.DeepEqual(t, hash1[:], root)
 }
 
 func TestForkChoice_AncestorEqualSlot(t *testing.T) {
@@ -271,7 +269,8 @@ func TestForkChoice_AncestorEqualSlot(t *testing.T) {
 
 	r, err := f.AncestorRoot(ctx, [32]byte{'3'}, 100)
 	require.NoError(t, err)
-	require.Equal(t, r, [32]byte{'1'})
+	root := bytesutil.ToBytes32(r)
+	require.Equal(t, root, [32]byte{'1'})
 }
 
 func TestForkChoice_AncestorLowerSlot(t *testing.T) {
@@ -286,7 +285,8 @@ func TestForkChoice_AncestorLowerSlot(t *testing.T) {
 
 	r, err := f.AncestorRoot(ctx, [32]byte{'3'}, 150)
 	require.NoError(t, err)
-	require.Equal(t, r, [32]byte{'1'})
+	root := bytesutil.ToBytes32(r)
+	require.Equal(t, root, [32]byte{'1'})
 }
 
 func TestForkChoice_RemoveEquivocating(t *testing.T) {
@@ -296,7 +296,7 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 	state, blkRoot, err := prepareForkchoiceState(ctx, 1, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	head, err := f.Head(ctx, []uint64{})
+	head, err := f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'a'}, head)
 
@@ -307,21 +307,21 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(ctx, 3, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	head, err = f.Head(ctx, []uint64{})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
 	// Insert two attestations for block b, one for c it becomes head
 	f.ProcessAttestation(ctx, []uint64{1, 2}, [32]byte{'b'}, 1)
 	f.ProcessAttestation(ctx, []uint64{3}, [32]byte{'c'}, 1)
-	head, err = f.Head(ctx, []uint64{100, 200, 200, 300})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{100, 200, 200, 300})
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'b'}, head)
 
 	// Process b's slashing, c is now head
 	f.InsertSlashedIndex(ctx, 1)
 	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
-	head, err = f.Head(ctx, []uint64{100, 200, 200, 300})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{100, 200, 200, 300})
 	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
 	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
@@ -330,7 +330,7 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 	// Process b's slashing again, should be a noop
 	f.InsertSlashedIndex(ctx, 1)
 	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
-	head, err = f.Head(ctx, []uint64{100, 200, 200, 300})
+	head, err = f.Head(ctx, params.BeaconConfig().ZeroHash, []uint64{100, 200, 200, 300})
 	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
 	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
@@ -348,18 +348,16 @@ func indexToHash(i uint64) [32]byte {
 	return hash.Hash(b[:])
 }
 
-func TestForkChoice_UpdateJustifiedAndFinalizedCheckpoints(t *testing.T) {
+func TestStore_UpdateCheckpoints(t *testing.T) {
 	f := setup(1, 1)
 	jr := [32]byte{'j'}
 	fr := [32]byte{'f'}
-	jc := &forkchoicetypes.Checkpoint{Root: jr, Epoch: 3}
-	fc := &forkchoicetypes.Checkpoint{Root: fr, Epoch: 2}
+	jc := &ethpb.Checkpoint{Root: jr[:], Epoch: 3}
+	fc := &ethpb.Checkpoint{Root: fr[:], Epoch: 2}
 	require.NoError(t, f.UpdateJustifiedCheckpoint(jc))
 	require.NoError(t, f.UpdateFinalizedCheckpoint(fc))
-	require.Equal(t, f.store.justifiedCheckpoint.Epoch, jc.Epoch)
-	require.Equal(t, f.store.justifiedCheckpoint.Root, jc.Root)
-	require.Equal(t, f.store.finalizedCheckpoint.Epoch, fc.Epoch)
-	require.Equal(t, f.store.finalizedCheckpoint.Root, fc.Root)
+	require.Equal(t, f.store.justifiedEpoch, jc.Epoch)
+	require.Equal(t, f.store.finalizedEpoch, fc.Epoch)
 }
 
 func TestStore_CommonAncestor(t *testing.T) {
@@ -537,17 +535,9 @@ 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)
-	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
+	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))
 	// broken link
 	_, err = f.CommonAncestorRoot(ctx, [32]byte{'y'}, [32]byte{'a'})
 	require.ErrorIs(t, err, forkchoice.ErrUnknownCommonAncestor)
@@ -564,10 +554,8 @@ func TestStore_InsertOptimisticChain(t *testing.T) {
 	require.NoError(t, err)
 	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
-	blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(),
-		JustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-	})
+	blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(), JustifiedEpoch: 1,
+		FinalizedEpoch: 1})
 	for i := uint64(2); i < 11; i++ {
 		blk := util.NewBeaconBlock()
 		blk.Block.Slot = types.Slot(i)
@@ -575,10 +563,8 @@ func TestStore_InsertOptimisticChain(t *testing.T) {
 		blk.Block.ParentRoot = copiedRoot[:]
 		wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
 		require.NoError(t, err)
-		blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(),
-			JustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-			FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
-		})
+		blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: wsb.Block(), JustifiedEpoch: 1,
+			FinalizedEpoch: 1})
 		root, err = blk.Block.HashTreeRoot()
 		require.NoError(t, err)
 	}
@@ -591,145 +577,3 @@ func TestStore_InsertOptimisticChain(t *testing.T) {
 	f = setup(1, 1)
 	require.NoError(t, f.InsertOptimisticChain(context.Background(), args[2:]))
 }
-
-func TestForkChoice_UpdateCheckpoints(t *testing.T) {
-	ctx := context.Background()
-	tests := []struct {
-		name                string
-		justified           *forkchoicetypes.Checkpoint
-		bestJustified       *forkchoicetypes.Checkpoint
-		finalized           *forkchoicetypes.Checkpoint
-		newJustified        *forkchoicetypes.Checkpoint
-		newFinalized        *forkchoicetypes.Checkpoint
-		wantedJustified     *forkchoicetypes.Checkpoint
-		wantedBestJustified *forkchoicetypes.Checkpoint
-		wantedFinalized     *forkchoicetypes.Checkpoint
-		currentSlot         types.Slot
-		wantedErr           string
-	}{
-		{
-			name:                "lower than store justified and finalized",
-			justified:           &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			finalized:           &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-			bestJustified:       &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			newJustified:        &forkchoicetypes.Checkpoint{Epoch: 1},
-			newFinalized:        &forkchoicetypes.Checkpoint{Epoch: 0},
-			wantedJustified:     &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			wantedBestJustified: &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			wantedFinalized:     &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-		},
-		{
-			name:                "higher than store justified, early slot, direct descendant",
-			justified:           &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			bestJustified:       &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			finalized:           &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-			newJustified:        &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'b'}},
-			newFinalized:        &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'g'}},
-			wantedJustified:     &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'b'}},
-			wantedBestJustified: &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'b'}},
-			wantedFinalized:     &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-		},
-		{
-			name:                "higher than store justified, early slot, not a descendant",
-			justified:           &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			bestJustified:       &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			finalized:           &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-			newJustified:        &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'c'}},
-			newFinalized:        &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'g'}},
-			wantedJustified:     &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'c'}},
-			wantedBestJustified: &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'c'}},
-			wantedFinalized:     &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-		},
-		{
-			name:                "higher than store justified, late slot, descendant",
-			justified:           &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			bestJustified:       &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			finalized:           &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-			newJustified:        &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'b'}},
-			newFinalized:        &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'g'}},
-			wantedJustified:     &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'b'}},
-			wantedFinalized:     &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-			wantedBestJustified: &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'b'}},
-			currentSlot:         params.BeaconConfig().SafeSlotsToUpdateJustified.Add(1),
-		},
-		{
-			name:                "higher than store justified, late slot, not descendant",
-			justified:           &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			bestJustified:       &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			finalized:           &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-			newJustified:        &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'c'}},
-			newFinalized:        &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'g'}},
-			wantedJustified:     &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			wantedFinalized:     &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-			wantedBestJustified: &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'c'}},
-			currentSlot:         params.BeaconConfig().SafeSlotsToUpdateJustified.Add(1),
-		},
-		{
-			name:                "higher than store finalized, late slot, not descendant",
-			justified:           &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			bestJustified:       &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			finalized:           &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-			newJustified:        &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'c'}},
-			newFinalized:        &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'h'}},
-			wantedJustified:     &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'c'}},
-			wantedFinalized:     &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'h'}},
-			wantedBestJustified: &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'c'}},
-			currentSlot:         params.BeaconConfig().SafeSlotsToUpdateJustified.Add(1),
-		},
-		{
-			name:          "Unknown checkpoint root, late slot",
-			justified:     &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			bestJustified: &forkchoicetypes.Checkpoint{Epoch: 2, Root: [32]byte{'j'}},
-			finalized:     &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'f'}},
-			newJustified:  &forkchoicetypes.Checkpoint{Epoch: 3, Root: [32]byte{'d'}},
-			newFinalized:  &forkchoicetypes.Checkpoint{Epoch: 1, Root: [32]byte{'h'}},
-			currentSlot:   params.BeaconConfig().SafeSlotsToUpdateJustified.Add(1),
-			wantedErr:     "could not determine ancestor root",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			fcs := setup(tt.justified.Epoch, tt.finalized.Epoch)
-			fcs.store.justifiedCheckpoint = tt.justified
-			fcs.store.finalizedCheckpoint = tt.finalized
-			fcs.store.bestJustifiedCheckpoint = tt.bestJustified
-			fcs.store.genesisTime = uint64(time.Now().Unix()) - uint64(tt.currentSlot)*params.BeaconConfig().SecondsPerSlot
-
-			state, blkRoot, err := prepareForkchoiceState(ctx, 32, [32]byte{'f'},
-				[32]byte{}, [32]byte{}, tt.finalized.Epoch, tt.finalized.Epoch)
-			require.NoError(t, err)
-			require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-			state, blkRoot, err = prepareForkchoiceState(ctx, 64, [32]byte{'j'},
-				[32]byte{'f'}, [32]byte{}, tt.justified.Epoch, tt.finalized.Epoch)
-			require.NoError(t, err)
-			require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-			state, blkRoot, err = prepareForkchoiceState(ctx, 96, [32]byte{'b'},
-				[32]byte{'j'}, [32]byte{}, tt.newJustified.Epoch, tt.newFinalized.Epoch)
-			require.NoError(t, err)
-			require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-			state, blkRoot, err = prepareForkchoiceState(ctx, 96, [32]byte{'c'},
-				[32]byte{'f'}, [32]byte{}, tt.newJustified.Epoch, tt.newFinalized.Epoch)
-			require.NoError(t, err)
-			require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-			// restart justifications cause insertion messed it up
-			fcs.store.justifiedCheckpoint = tt.justified
-			fcs.store.finalizedCheckpoint = tt.finalized
-			fcs.store.bestJustifiedCheckpoint = tt.bestJustified
-
-			jc := &ethpb.Checkpoint{Epoch: tt.newJustified.Epoch, Root: tt.newJustified.Root[:]}
-			fc := &ethpb.Checkpoint{Epoch: tt.newFinalized.Epoch, Root: tt.newFinalized.Root[:]}
-			err = fcs.updateCheckpoints(ctx, jc, fc)
-			if len(tt.wantedErr) > 0 {
-				require.ErrorContains(t, tt.wantedErr, err)
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, tt.wantedJustified.Epoch, fcs.store.justifiedCheckpoint.Epoch)
-				require.Equal(t, tt.wantedFinalized.Epoch, fcs.store.finalizedCheckpoint.Epoch)
-				require.Equal(t, tt.wantedJustified.Root, fcs.store.justifiedCheckpoint.Root)
-				require.Equal(t, tt.wantedFinalized.Root, fcs.store.finalizedCheckpoint.Root)
-				require.Equal(t, tt.wantedBestJustified.Epoch, fcs.store.bestJustifiedCheckpoint.Epoch)
-				require.Equal(t, tt.wantedBestJustified.Root, fcs.store.bestJustifiedCheckpoint.Root)
-			}
-		})
-	}
-}

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

@@ -15,7 +15,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	ctx := context.Background()
 
 	// The head should always start at the finalized block.
-	r, err := f.Head(context.Background(), balances)
+	r, err := f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	if r != params.BeaconConfig().ZeroHash {
 		t.Errorf("Incorrect head with genesis")
@@ -28,7 +28,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err := prepareForkchoiceState(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -39,7 +39,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -52,7 +52,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(2), r, "Incorrect head for with justified epoch at 1")
 
@@ -65,11 +65,11 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
 
-	// Insert block 5 with justified epoch of 2, verify head is 5
+	// Insert block 5 with justified epoch of 2, verify head is still at 4.
 	//            0
 	//           / \
 	//          2  1
@@ -80,7 +80,32 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), params.BeaconConfig().ZeroHash, balances)
+	require.NoError(t, err)
+	assert.Equal(t, indexToHash(4), r, "Incorrect head for with justified epoch at 1")
+
+	// Verify there's an error when starting from a block with wrong justified epoch.
+	//            0
+	//           / \
+	//          2  1
+	//          |  |
+	//  head -> 4  3
+	//          |
+	//          5 <- starting from 5 with justified epoch 0 should error
+	_, err = f.Head(context.Background(), indexToHash(5), balances)
+	wanted := "head at slot 0 with weight 0 is not eligible, finalizedEpoch 1 != 1, justifiedEpoch 2 != 1"
+	require.ErrorContains(t, wanted, err)
+
+	// Set the justified epoch to 2 and start block to 5 to verify head is 5.
+	//            0
+	//           / \
+	//          2  1
+	//          |  |
+	//          4  3
+	//          |
+	//          5 <- head
+	f.store.justifiedEpoch = 2
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(5), r, "Incorrect head for with justified epoch at 2")
 
@@ -97,7 +122,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(6), indexToHash(5), params.BeaconConfig().ZeroHash, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	r, err = f.Head(context.Background(), balances)
+	r, err = f.Head(context.Background(), indexToHash(5), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 2")
 }

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

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

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

@@ -60,23 +60,14 @@ func (s *Store) PruneThreshold() uint64 {
 
 // head starts from justified root and then follows the best descendant links
 // to find the best block for head. This function assumes a lock on s.nodesLock
-func (s *Store) head(ctx context.Context) ([32]byte, error) {
+func (s *Store) head(ctx context.Context, justifiedRoot [32]byte) ([32]byte, error) {
 	_, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.head")
 	defer span.End()
-	s.checkpointsLock.RLock()
-	defer s.checkpointsLock.RUnlock()
 
 	// JustifiedRoot has to be known
-	justifiedNode, ok := s.nodeByRoot[s.justifiedCheckpoint.Root]
+	justifiedNode, ok := s.nodeByRoot[justifiedRoot]
 	if !ok || justifiedNode == nil {
-		// If the justifiedCheckpoint is from genesis, then the root is
-		// zeroHash. In this case it should be the root of forkchoice
-		// tree.
-		if s.justifiedCheckpoint.Epoch == params.BeaconConfig().GenesisEpoch {
-			justifiedNode = s.treeRootNode
-		} else {
-			return [32]byte{}, errUnknownJustifiedRoot
-		}
+		return [32]byte{}, errUnknownJustifiedRoot
 	}
 
 	// If the justified node doesn't have a best descendant,
@@ -86,9 +77,9 @@ func (s *Store) head(ctx context.Context) ([32]byte, error) {
 		bestDescendant = justifiedNode
 	}
 
-	if !bestDescendant.viableForHead(s.justifiedCheckpoint.Epoch, s.finalizedCheckpoint.Epoch) {
-		return [32]byte{}, fmt.Errorf("head at slot %d with weight %d is not eligible, finalizedEpoch, justified Epoch %d, %d != %d, %d",
-			bestDescendant.slot, bestDescendant.weight/10e9, bestDescendant.finalizedEpoch, bestDescendant.justifiedEpoch, s.finalizedCheckpoint.Epoch, s.justifiedCheckpoint.Epoch)
+	if !bestDescendant.viableForHead(s.justifiedEpoch, s.finalizedEpoch) {
+		return [32]byte{}, fmt.Errorf("head at slot %d with weight %d is not eligible, finalizedEpoch %d != %d, justifiedEpoch %d != %d",
+			bestDescendant.slot, bestDescendant.weight/10e9, bestDescendant.finalizedEpoch, s.finalizedEpoch, bestDescendant.justifiedEpoch, s.justifiedEpoch)
 	}
 
 	// Update metrics.
@@ -134,21 +125,19 @@ func (s *Store) insert(ctx context.Context,
 
 	s.nodeByPayload[payloadHash] = n
 	s.nodeByRoot[root] = n
-	if parent == nil {
-		if s.treeRootNode == nil {
-			s.treeRootNode = n
-			s.headNode = n
-		} else {
-			return errInvalidParentRoot
-		}
-	} else {
+	if parent != nil {
 		parent.children = append(parent.children, n)
-		if err := s.treeRootNode.updateBestDescendant(ctx,
-			s.justifiedCheckpoint.Epoch, s.finalizedCheckpoint.Epoch); err != nil {
+		if err := s.treeRootNode.updateBestDescendant(ctx, s.justifiedEpoch, s.finalizedEpoch); err != nil {
 			return err
 		}
 	}
 
+	// 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/forkchoice/doubly-linked-tree/store_test.go

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

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

@@ -3,7 +3,6 @@ package doublylinkedtree
 import (
 	"sync"
 
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 )
@@ -18,9 +17,8 @@ type ForkChoice struct {
 
 // Store defines the fork choice store which includes block nodes and the last view of checkpoint information.
 type Store struct {
-	justifiedCheckpoint        *forkchoicetypes.Checkpoint            // latest justified epoch in store.
-	bestJustifiedCheckpoint    *forkchoicetypes.Checkpoint            // best justified checkpoint in store.
-	finalizedCheckpoint        *forkchoicetypes.Checkpoint            // latest finalized epoch in store.
+	justifiedEpoch             types.Epoch                            // latest justified epoch in store.
+	finalizedEpoch             types.Epoch                            // latest finalized epoch in store.
 	pruneThreshold             uint64                                 // do not prune tree unless threshold is reached.
 	proposerBoostRoot          [fieldparams.RootLength]byte           // latest block root that was boosted after being received in a timely manner.
 	previousProposerBoostRoot  [fieldparams.RootLength]byte           // previous block root that was boosted after being received in a timely manner.
@@ -30,11 +28,8 @@ type Store struct {
 	nodeByRoot                 map[[fieldparams.RootLength]byte]*Node // nodes indexed by roots.
 	nodeByPayload              map[[fieldparams.RootLength]byte]*Node // nodes indexed by payload Hash
 	slashedIndices             map[types.ValidatorIndex]bool          // the list of equivocating validator indices
-	originRoot                 [fieldparams.RootLength]byte           // The genesis block root
 	nodesLock                  sync.RWMutex
 	proposerBoostLock          sync.RWMutex
-	checkpointsLock            sync.RWMutex
-	genesisTime                uint64
 }
 
 // Node defines the individual block which includes its block parent, ancestor and how much weight accounted for it.