Merge branch 'kiln' of github.com:prysmaticlabs/prysm into kilnv2

* add changes

* fix for vectorize

* fix bug

* add new bench

* use new algorithms

* add latest updates

* save progress

* hack even more

* add more changes

* change library

* go mod

* fix deps

* fix dumb bug

* add flag and remove redundant code

* clean up better

* remove those ones

* clean up benches

* clean up benches

* cleanup

* gaz

* revert change

* potuz's review

* potuz's review

* potuz's review

* gaz

* potuz's review

* remove cyclical import

* revert ide changes

* potuz's review

* return

.github/workflows/go.yml

@@ -39,7 +39,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
+          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
 
   build:
     name: Build

BUILD.bazel

@@ -86,50 +86,51 @@ nogo(
     config = "nogo_config.json",
     visibility = ["//visibility:public"],
     deps = [
-        "@org_golang_x_tools//go/analysis/passes/unsafeptr:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/unreachable:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/unmarshal:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/tests:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/structtag:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/stdmethods:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/shift:go_tool_library",
-        # "@org_golang_x_tools//go/analysis/passes/shadow:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/printf:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/pkgfact:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/nilness:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/nilfunc:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/loopclosure:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/httpresponse:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/findcall:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/ctrlflow:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/copylock:go_tool_library",
-        #  "@org_golang_x_tools//go/analysis/passes/cgocall:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/buildtag:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/buildssa:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/bools:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/atomicalign:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/atomic:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/assign:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/inspect:go_tool_library",
-        "@org_golang_x_tools//go/analysis/passes/asmdecl:go_tool_library",
-        "//tools/analyzers/maligned:go_tool_library",
-        "//tools/analyzers/cryptorand:go_tool_library",
-        "//tools/analyzers/errcheck:go_tool_library",
-        "//tools/analyzers/featureconfig:go_tool_library",
-        "//tools/analyzers/comparesame:go_tool_library",
-        "//tools/analyzers/shadowpredecl:go_tool_library",
-        "//tools/analyzers/nop:go_tool_library",
-        "//tools/analyzers/slicedirect:go_tool_library",
-        "//tools/analyzers/interfacechecker:go_tool_library",
-        "//tools/analyzers/ineffassign:go_tool_library",
-        "//tools/analyzers/properpermissions:go_tool_library",
+        "@org_golang_x_tools//go/analysis/passes/unsafeptr:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/unreachable:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/unmarshal:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/tests:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/structtag:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/stdmethods:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/shift:go_default_library",
+        # "@org_golang_x_tools//go/analysis/passes/shadow:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/printf:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/pkgfact:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/nilness:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/nilfunc:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/loopclosure:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/httpresponse:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/findcall:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/deepequalerrors:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/ctrlflow:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/copylock:go_default_library",
+        #  "@org_golang_x_tools//go/analysis/passes/cgocall:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/buildtag:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/buildssa:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/bools:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/atomicalign:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/atomic:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/assign:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/inspect:go_default_library",
+        "@org_golang_x_tools//go/analysis/passes/asmdecl:go_default_library",
+        "//tools/analyzers/maligned:go_default_library",
+        "//tools/analyzers/cryptorand:go_default_library",
+        "//tools/analyzers/errcheck:go_default_library",
+        "//tools/analyzers/featureconfig:go_default_library",
+        "//tools/analyzers/comparesame:go_default_library",
+        "//tools/analyzers/shadowpredecl:go_default_library",
+        "//tools/analyzers/nop:go_default_library",
+        "//tools/analyzers/slicedirect:go_default_library",
+        "//tools/analyzers/interfacechecker:go_default_library",
+        "//tools/analyzers/ineffassign:go_default_library",
+        "//tools/analyzers/properpermissions:go_default_library",
+        "//tools/analyzers/recursivelock:go_default_library",
     ] + select({
         # nogo checks that fail with coverage enabled.
         ":coverage_enabled": [],
         "//conditions:default": [
-            "@org_golang_x_tools//go/analysis/passes/lostcancel:go_tool_library",
-            "@org_golang_x_tools//go/analysis/passes/composite:go_tool_library",
+            "@org_golang_x_tools//go/analysis/passes/lostcancel:go_default_library",
+            "@org_golang_x_tools//go/analysis/passes/composite:go_default_library",
         ],
     }),
 )

CONTRIBUTING.md

@@ -190,7 +190,7 @@ Anyone can become a part-time contributor and help out on implementing Ethereum
 
 Core contributors are remote contractors of Prysmatic Labs, LLC. and are considered critical team members of our organization. Core devs have all of the responsibilities of part-time contributors plus the majority of the following:
 
--   Stay up to date on the latest beacon chain sepcification
+-   Stay up to date on the latest beacon chain specification
 -   Monitor github issues and PR’s to make sure owner, labels, descriptions are correct
 -   Formulate independent ideas, suggest new work to do, point out improvements to existing approaches
 -   Participate in code review, ensure code quality is excellent, and have ensure high code coverage

WORKSPACE

@@ -60,10 +60,10 @@ bazel_skylib_workspace()
 
 http_archive(
     name = "bazel_gazelle",
-    sha256 = "62ca106be173579c0a167deb23358fdfe71ffa1e4cfdddf5582af26520f1c66f",
+    sha256 = "de69a09dc70417580aabf20a28619bb3ef60d038470c7cf8442fafcf627c21cb",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.23.0/bazel-gazelle-v0.23.0.tar.gz",
-        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.23.0/bazel-gazelle-v0.23.0.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.24.0/bazel-gazelle-v0.24.0.tar.gz",
+        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.24.0/bazel-gazelle-v0.24.0.tar.gz",
     ],
 )
 
@@ -85,16 +85,13 @@ http_archive(
     name = "io_bazel_rules_go",
     patch_args = ["-p1"],
     patches = [
-        # Required until https://github.com/bazelbuild/rules_go/pull/2450 merges otherwise nilness
-        # nogo check fails for certain third_party dependencies.
-        "//third_party:io_bazel_rules_go.patch",
         # Expose internals of go_test for custom build transitions.
         "//third_party:io_bazel_rules_go_test.patch",
     ],
-    sha256 = "7c10271940c6bce577d51a075ae77728964db285dac0a46614a7934dc34303e6",
+    sha256 = "2b1641428dff9018f9e85c0384f03ec6c10660d935b750e3fa1492a281a53b0f",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.26.0/rules_go-v0.26.0.tar.gz",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.26.0/rules_go-v0.26.0.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.29.0/rules_go-v0.29.0.zip",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.29.0/rules_go-v0.29.0.zip",
     ],
 )
 
@@ -186,7 +183,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.16.4",
+    go_version = "1.17.6",
     nogo = "@//:nogo",
 )
 
@@ -225,7 +222,7 @@ filegroup(
     url = "https://github.com/eth-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
 )
 
-consensus_spec_version = "v1.1.8"
+consensus_spec_version = "v1.1.9"
 
 bls_test_version = "v0.1.1"
 
@@ -241,7 +238,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "e4d2b7830e85734442d7172887dcd4edc0985d6256bafedb3353ab477a1433c0",
+    sha256 = "207d9c326ba4fa1f34bab7b6169201c32f2611755db030909a3405873445e0ba",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -257,7 +254,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "4a88d01ad12260220ab5c8efdeec6534bac48a47f29ba4f7977ea14c9d07b0fe",
+    sha256 = "a3995b39f412db236b2f1db909f288218da53cb53b9923b71dda9d144d68f40a",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -273,7 +270,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "0033fe107d9d2adb8d4fcb60dfb1c43fc5a54f0af970525c962124221757c266",
+    sha256 = "76cea7a4c8e32d458ad456b54bfbb30bc772481a91954a4cd97e229aa3023b1d",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -288,7 +285,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "3fc3b8809d140a1ab61350fbd410f33add2851a63829d874dcb620babba603de",
+    sha256 = "0fc429684775f943250dce1f9c485ac25e26c6395d7f585c8d1317becec2ace7",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -352,9 +349,9 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 """,
-    sha256 = "f196fe4367c2d2d01d36565c0dc6eecfa4f03adba1fc03a61d62953fce606e1f",
+    sha256 = "4797a7e594a5b1f4c1c8080701613f3ee451b01ec0861499ea7d9b60877a6b23",
     urls = [
-        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.2/prysm-web-ui.tar.gz",
+        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.3/prysm-web-ui.tar.gz",
     ],
 )
 

api/gateway/apimiddleware/api_middleware.go

@@ -3,6 +3,7 @@ package apimiddleware
 import (
 	"net/http"
 	"reflect"
+	"time"
 
 	"github.com/gorilla/mux"
 )
@@ -14,6 +15,7 @@ import (
 type ApiProxyMiddleware struct {
 	GatewayAddress  string
 	EndpointCreator EndpointFactory
+	Timeout         time.Duration
 	router          *mux.Router
 }
 
@@ -120,7 +122,7 @@ func (m *ApiProxyMiddleware) WithMiddleware(path string) http.HandlerFunc {
 			WriteError(w, errJson, nil)
 			return
 		}
-		grpcResp, errJson := ProxyRequest(req)
+		grpcResp, errJson := m.ProxyRequest(req)
 		if errJson != nil {
 			WriteError(w, errJson, nil)
 			return

api/gateway/apimiddleware/process_request.go

@@ -5,10 +5,10 @@ import (
 	"encoding/json"
 	"io"
 	"io/ioutil"
+	"net"
 	"net/http"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/api/grpc"
@@ -75,11 +75,14 @@ func (m *ApiProxyMiddleware) PrepareRequestForProxying(endpoint Endpoint, req *h
 }
 
 // ProxyRequest proxies the request to grpc-gateway.
-func ProxyRequest(req *http.Request) (*http.Response, ErrorJson) {
+func (m *ApiProxyMiddleware) ProxyRequest(req *http.Request) (*http.Response, ErrorJson) {
 	// We do not use http.DefaultClient because it does not have any timeout.
-	netClient := &http.Client{Timeout: time.Minute * 2}
+	netClient := &http.Client{Timeout: m.Timeout}
 	grpcResp, err := netClient.Do(req)
 	if err != nil {
+		if err, ok := err.(net.Error); ok && err.Timeout() {
+			return nil, TimeoutError()
+		}
 		return nil, InternalServerErrorWithMessage(err, "could not proxy request")
 	}
 	if grpcResp == nil {
@@ -111,9 +114,14 @@ func HandleGrpcResponseError(errJson ErrorJson, resp *http.Response, respBody []
 				w.Header().Set(h, v)
 			}
 		}
-		// Set code to HTTP code because unmarshalled body contained gRPC code.
-		errJson.SetCode(resp.StatusCode)
-		WriteError(w, errJson, resp.Header)
+		// Handle gRPC timeout.
+		if resp.StatusCode == http.StatusGatewayTimeout {
+			WriteError(w, TimeoutError(), resp.Header)
+		} else {
+			// Set code to HTTP code because unmarshalled body contained gRPC code.
+			errJson.SetCode(resp.StatusCode)
+			WriteError(w, errJson, resp.Header)
+		}
 	}
 	return responseHasError, nil
 }

api/gateway/apimiddleware/structs.go

@@ -41,6 +41,13 @@ func InternalServerError(err error) *DefaultErrorJson {
 	}
 }
 
+func TimeoutError() *DefaultErrorJson {
+	return &DefaultErrorJson{
+		Message: "Request timeout",
+		Code:    http.StatusRequestTimeout,
+	}
+}
+
 // StatusCode returns the error's underlying error code.
 func (e *DefaultErrorJson) StatusCode() int {
 	return e.Code

api/gateway/gateway.go

@@ -52,6 +52,7 @@ type config struct {
 	muxHandler                   MuxHandler
 	pbHandlers                   []*PbMux
 	router                       *mux.Router
+	timeout                      time.Duration
 }
 
 // Gateway is the gRPC gateway to serve HTTP JSON traffic as a proxy and forward it to the gRPC server.
@@ -248,6 +249,7 @@ func (g *Gateway) registerApiMiddleware() {
 	g.proxy = &apimiddleware.ApiProxyMiddleware{
 		GatewayAddress:  g.cfg.gatewayAddr,
 		EndpointCreator: g.cfg.apiMiddlewareEndpointFactory,
+		Timeout:         g.cfg.timeout,
 	}
 	log.Info("Starting API middleware")
 	g.proxy.Run(g.cfg.router)

api/gateway/options.go

@@ -1,7 +1,10 @@
 package gateway
 
 import (
+	"time"
+
 	"github.com/gorilla/mux"
+	gwruntime "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/prysmaticlabs/prysm/api/gateway/apimiddleware"
 )
 
@@ -79,3 +82,12 @@ func WithApiMiddleware(endpointFactory apimiddleware.EndpointFactory) Option {
 		return nil
 	}
 }
+
+// WithTimeout allows changing the timeout value for API calls.
+func WithTimeout(seconds uint64) Option {
+	return func(g *Gateway) error {
+		g.cfg.timeout = time.Second * time.Duration(seconds)
+		gwruntime.DefaultContextTimeout = time.Second * time.Duration(seconds)
+		return nil
+	}
+}

beacon-chain/blockchain/BUILD.bazel

@@ -4,13 +4,17 @@ go_library(
     name = "go_default_library",
     srcs = [
         "chain_info.go",
+        "error.go",
         "head.go",
         "head_sync_committee_info.go",
         "info.go",
         "init_sync_process_block.go",
         "log.go",
         "metrics.go",
+        "new_slot.go",
+        "optimistic_sync.go",
         "options.go",
+        "pow_block.go",
         "process_attestation.go",
         "process_attestation_helpers.go",
         "process_block.go",
@@ -26,13 +30,16 @@ go_library(
         "//beacon-chain:__subpackages__",
         "//cmd/beacon-chain:__subpackages__",
         "//testing/slasher/simulator:__pkg__",
+        "//testing/spectest:__subpackages__",
     ],
     deps = [
         "//async:go_default_library",
         "//async/event:go_default_library",
+        "//beacon-chain/blockchain/store:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
@@ -49,6 +56,7 @@ go_library(
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/powchain:go_default_library",
+        "//beacon-chain/powchain/engine-api-client/v1:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
@@ -58,6 +66,7 @@ go_library(
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
@@ -66,6 +75,9 @@ go_library(
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_emicklei_dot//:go_default_library",
+        "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_holiman_uint256//:go_default_library",
         "@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",
@@ -96,7 +108,10 @@ go_test(
         "init_test.go",
         "log_test.go",
         "metrics_test.go",
+        "mock_engine_test.go",
         "mock_test.go",
+        "optimistic_sync_test.go",
+        "pow_block_test.go",
         "process_attestation_test.go",
         "process_block_test.go",
         "receive_attestation_test.go",

beacon-chain/blockchain/chain_info.go

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
 )
 
@@ -36,7 +37,7 @@ type TimeFetcher interface {
 
 // GenesisFetcher retrieves the Ethereum consensus data related to its genesis.
 type GenesisFetcher interface {
-	GenesisValidatorRoot() [32]byte
+	GenesisValidatorsRoot() [32]byte
 }
 
 // HeadFetcher defines a common interface for methods in blockchain service which
@@ -48,12 +49,14 @@ type HeadFetcher interface {
 	HeadState(ctx context.Context) (state.BeaconState, error)
 	HeadValidatorsIndices(ctx context.Context, epoch types.Epoch) ([]types.ValidatorIndex, error)
 	HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, error)
-	HeadGenesisValidatorRoot() [32]byte
+	HeadGenesisValidatorsRoot() [32]byte
 	HeadETH1Data() *ethpb.Eth1Data
 	HeadPublicKeyToValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool)
 	HeadValidatorIndexToPublicKey(ctx context.Context, index types.ValidatorIndex) ([fieldparams.BLSPubkeyLength]byte, error)
 	ProtoArrayStore() *protoarray.Store
 	ChainHeads() ([][32]byte, []types.Slot)
+	IsOptimistic(ctx context.Context) (bool, error)
+	IsOptimisticForRoot(ctx context.Context, root [32]byte, slot types.Slot) (bool, error)
 	HeadSyncCommitteeFetcher
 	HeadDomainFetcher
 }
@@ -77,31 +80,45 @@ type FinalizationFetcher interface {
 	PreviousJustifiedCheckpt() *ethpb.Checkpoint
 }
 
-// FinalizedCheckpt returns the latest finalized checkpoint from head state.
+// FinalizedCheckpt returns the latest finalized checkpoint from chain store.
 func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
-	if s.finalizedCheckpt == nil {
+	cp := s.store.FinalizedCheckpt()
+	if cp == nil {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	return ethpb.CopyCheckpoint(s.finalizedCheckpt)
+	return ethpb.CopyCheckpoint(cp)
 }
 
-// CurrentJustifiedCheckpt returns the current justified checkpoint from head state.
+// CurrentJustifiedCheckpt returns the current justified checkpoint from chain store.
 func (s *Service) CurrentJustifiedCheckpt() *ethpb.Checkpoint {
-	if s.justifiedCheckpt == nil {
+	cp := s.store.JustifiedCheckpt()
+	if cp == nil {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	return ethpb.CopyCheckpoint(s.justifiedCheckpt)
+	return ethpb.CopyCheckpoint(cp)
 }
 
-// PreviousJustifiedCheckpt returns the previous justified checkpoint from head state.
+// PreviousJustifiedCheckpt returns the previous justified checkpoint from chain store.
 func (s *Service) PreviousJustifiedCheckpt() *ethpb.Checkpoint {
-	if s.prevJustifiedCheckpt == nil {
+	cp := s.store.PrevJustifiedCheckpt()
+	if cp == nil {
 		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	}
 
-	return ethpb.CopyCheckpoint(s.prevJustifiedCheckpt)
+	return ethpb.CopyCheckpoint(cp)
+}
+
+// BestJustifiedCheckpt returns the best justified checkpoint from store.
+func (s *Service) BestJustifiedCheckpt() *ethpb.Checkpoint {
+	cp := s.store.BestJustifiedCheckpt()
+	// If there is no best justified checkpoint, return the checkpoint with root as zeros to be used for genesis cases.
+	if cp == nil {
+		return &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
+	}
+
+	return ethpb.CopyCheckpoint(cp)
 }
 
 // HeadSlot returns the slot of the head of the chain.
@@ -198,8 +215,8 @@ func (s *Service) HeadSeed(ctx context.Context, epoch types.Epoch) ([32]byte, er
 	return helpers.Seed(s.headState(ctx), epoch, params.BeaconConfig().DomainBeaconAttester)
 }
 
-// HeadGenesisValidatorRoot returns genesis validator root of the head state.
-func (s *Service) HeadGenesisValidatorRoot() [32]byte {
+// HeadGenesisValidatorsRoot returns genesis validators root of the head state.
+func (s *Service) HeadGenesisValidatorsRoot() [32]byte {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
@@ -207,7 +224,7 @@ func (s *Service) HeadGenesisValidatorRoot() [32]byte {
 		return [32]byte{}
 	}
 
-	return s.headGenesisValidatorRoot()
+	return s.headGenesisValidatorsRoot()
 }
 
 // HeadETH1Data returns the eth1data of the current head state.
@@ -231,16 +248,16 @@ func (s *Service) GenesisTime() time.Time {
 	return s.genesisTime
 }
 
-// GenesisValidatorRoot returns the genesis validator
+// GenesisValidatorsRoot returns the genesis validator
 // root of the chain.
-func (s *Service) GenesisValidatorRoot() [32]byte {
+func (s *Service) GenesisValidatorsRoot() [32]byte {
 	s.headLock.RLock()
 	defer s.headLock.RUnlock()
 
 	if !s.hasHeadState() {
 		return [32]byte{}
 	}
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
+	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
 }
 
 // CurrentFork retrieves the latest fork information of the beacon chain.
@@ -313,3 +330,25 @@ func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index types.V
 	}
 	return v.PublicKey(), nil
 }
+
+// IsOptimistic returns true if the current head is optimistic.
+func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
+	if slots.ToEpoch(s.CurrentSlot()) < params.BeaconConfig().BellatrixForkEpoch {
+		return false, nil
+	}
+
+	return s.cfg.ForkChoiceStore.Optimistic(ctx, s.head.root, s.head.slot)
+}
+
+// IsOptimisticForRoot takes the root and slot as aguments instead of the current head
+// and returns true if it is optimistic.
+func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte, slot types.Slot) (bool, error) {
+	return s.cfg.ForkChoiceStore.Optimistic(ctx, root, slot)
+}
+
+// SetGenesisTime sets the genesis time of beacon chain.
+func (s *Service) SetGenesisTime(t time.Time) {
+	s.genesisTime = t
+}

beacon-chain/blockchain/chain_info_test.go

@@ -45,7 +45,7 @@ func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
 
 	cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
 	c := setupBeaconChain(t, beaconDB)
-	c.finalizedCheckpt = cp
+	c.store.SetFinalizedCheckpt(cp)
 
 	assert.Equal(t, cp.Epoch, c.FinalizedCheckpt().Epoch, "Unexpected finalized epoch")
 }
@@ -56,7 +56,7 @@ func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
 	genesisRoot := [32]byte{'A'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
 	c := setupBeaconChain(t, beaconDB)
-	c.finalizedCheckpt = cp
+	c.store.SetFinalizedCheckpt(cp)
 	c.originBlockRoot = genesisRoot
 	assert.DeepEqual(t, c.originBlockRoot[:], c.FinalizedCheckpt().Root)
 }
@@ -67,7 +67,7 @@ func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
 	c := setupBeaconChain(t, beaconDB)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
 	cp := &ethpb.Checkpoint{Epoch: 6, Root: bytesutil.PadTo([]byte("foo"), 32)}
-	c.justifiedCheckpt = cp
+	c.store.SetJustifiedCheckpt(cp)
 	assert.Equal(t, cp.Epoch, c.CurrentJustifiedCheckpt().Epoch, "Unexpected justified epoch")
 }
 
@@ -77,7 +77,7 @@ func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
 	c := setupBeaconChain(t, beaconDB)
 	genesisRoot := [32]byte{'B'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
-	c.justifiedCheckpt = cp
+	c.store.SetJustifiedCheckpt(cp)
 	c.originBlockRoot = genesisRoot
 	assert.DeepEqual(t, c.originBlockRoot[:], c.CurrentJustifiedCheckpt().Root)
 }
@@ -88,7 +88,7 @@ func TestPreviousJustifiedCheckpt_CanRetrieve(t *testing.T) {
 	cp := &ethpb.Checkpoint{Epoch: 7, Root: bytesutil.PadTo([]byte("foo"), 32)}
 	c := setupBeaconChain(t, beaconDB)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, bytesutil.ToBytes32(c.CurrentJustifiedCheckpt().Root), "Unexpected justified epoch")
-	c.prevJustifiedCheckpt = cp
+	c.store.SetPrevJustifiedCheckpt(cp)
 	assert.Equal(t, cp.Epoch, c.PreviousJustifiedCheckpt().Epoch, "Unexpected previous justified epoch")
 }
 
@@ -98,7 +98,7 @@ func TestPrevJustifiedCheckpt_GenesisRootOk(t *testing.T) {
 	genesisRoot := [32]byte{'C'}
 	cp := &ethpb.Checkpoint{Root: genesisRoot[:]}
 	c := setupBeaconChain(t, beaconDB)
-	c.prevJustifiedCheckpt = cp
+	c.store.SetPrevJustifiedCheckpt(cp)
 	c.originBlockRoot = genesisRoot
 	assert.DeepEqual(t, c.originBlockRoot[:], c.PreviousJustifiedCheckpt().Root)
 }
@@ -185,15 +185,15 @@ func TestCurrentFork_NilHeadSTate(t *testing.T) {
 	}
 }
 
-func TestGenesisValidatorRoot_CanRetrieve(t *testing.T) {
+func TestGenesisValidatorsRoot_CanRetrieve(t *testing.T) {
 	// Should not panic if head state is nil.
 	c := &Service{}
-	assert.Equal(t, [32]byte{}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
+	assert.Equal(t, [32]byte{}, c.GenesisValidatorsRoot(), "Did not get correct genesis validators root")
 
 	s, err := v1.InitializeFromProto(&ethpb.BeaconState{GenesisValidatorsRoot: []byte{'a'}})
 	require.NoError(t, err)
 	c.head = &head{state: s}
-	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorRoot(), "Did not get correct genesis validator root")
+	assert.Equal(t, [32]byte{'a'}, c.GenesisValidatorsRoot(), "Did not get correct genesis validators root")
 }
 
 func TestHeadETH1Data_Nil(t *testing.T) {
@@ -265,17 +265,17 @@ func TestService_HeadSeed(t *testing.T) {
 	require.DeepEqual(t, seed, root)
 }
 
-func TestService_HeadGenesisValidatorRoot(t *testing.T) {
+func TestService_HeadGenesisValidatorsRoot(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 1)
 	c := &Service{}
 
 	c.head = &head{}
-	root := c.HeadGenesisValidatorRoot()
+	root := c.HeadGenesisValidatorsRoot()
 	require.Equal(t, [32]byte{}, root)
 
 	c.head = &head{state: s}
-	root = c.HeadGenesisValidatorRoot()
-	require.DeepEqual(t, root[:], s.GenesisValidatorRoot())
+	root = c.HeadGenesisValidatorsRoot()
+	require.DeepEqual(t, root[:], s.GenesisValidatorsRoot())
 }
 
 func TestService_ProtoArrayStore(t *testing.T) {
@@ -355,3 +355,38 @@ func TestService_HeadValidatorIndexToPublicKeyNil(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, [fieldparams.BLSPubkeyLength]byte{}, p)
 }
+
+func TestService_IsOptimistic(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig()
+	cfg.BellatrixForkEpoch = 0
+	params.OverrideBeaconConfig(cfg)
+
+	ctx := context.Background()
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0))
+
+	opt, err := c.IsOptimistic(ctx)
+	require.NoError(t, err)
+	require.Equal(t, true, opt)
+}
+
+func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
+	ctx := context.Background()
+	c := &Service{genesisTime: time.Now()}
+	opt, err := c.IsOptimistic(ctx)
+	require.NoError(t, err)
+	require.Equal(t, false, opt)
+}
+
+func TestService_IsOptimisticForRoot(t *testing.T) {
+	ctx := context.Background()
+	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.ProcessBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0))
+
+	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'}, 100)
+	require.NoError(t, err)
+	require.Equal(t, true, opt)
+}

beacon-chain/blockchain/error.go

@@ -0,0 +1,12 @@
+package blockchain
+
+import "github.com/pkg/errors"
+
+var (
+	// errNilJustifiedInStore is returned when a nil justified checkpt is returned from store.
+	errNilJustifiedInStore = errors.New("nil justified checkpoint returned from store")
+	// errNilBestJustifiedInStore is returned when a nil justified checkpt is returned from store.
+	errNilBestJustifiedInStore = errors.New("nil best justified checkpoint returned from store")
+	// errNilFinalizedInStore is returned when a nil finalized checkpt is returned from store.
+	errNilFinalizedInStore = errors.New("nil finalized checkpoint returned from store")
+)

beacon-chain/blockchain/head.go

@@ -23,6 +23,21 @@ import (
 	"go.opencensus.io/trace"
 )
 
+// UpdateHeadWithBalances updates the beacon state head after getting justified balanced from cache.
+func (s *Service) UpdateHeadWithBalances(ctx context.Context) error {
+	cp := s.store.JustifiedCheckpt()
+	if cp == nil {
+		return errors.New("no justified checkpoint")
+	}
+	balances, err := s.justifiedBalances.get(ctx, bytesutil.ToBytes32(cp.Root))
+	if err != nil {
+		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", cp.Root)
+		return errors.Wrap(err, msg)
+	}
+
+	return s.updateHead(ctx, balances)
+}
+
 // This defines the current chain service's view of head.
 type head struct {
 	slot  types.Slot              // current head slot.
@@ -37,16 +52,15 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.updateHead")
 	defer span.End()
 
-	// To get the proper head update, a node first checks its best justified
-	// can become justified. This is designed to prevent bounce attack and
-	// ensure head gets its best justified info.
-	if s.bestJustifiedCheckpt.Epoch > s.justifiedCheckpt.Epoch {
-		s.justifiedCheckpt = s.bestJustifiedCheckpt
-	}
-
 	// Get head from the fork choice service.
-	f := s.finalizedCheckpt
-	j := s.justifiedCheckpt
+	f := s.store.FinalizedCheckpt()
+	if f == nil {
+		return errNilFinalizedInStore
+	}
+	j := s.store.JustifiedCheckpt()
+	if j == nil {
+		return errNilJustifiedInStore
+	}
 	// To get head before the first justified epoch, the fork choice will start with origin root
 	// instead of zero hashes.
 	headStartRoot := bytesutil.ToBytes32(j.Root)
@@ -251,10 +265,10 @@ func (s *Service) headState(ctx context.Context) state.BeaconState {
 	return s.head.state.Copy()
 }
 
-// This returns the genesis validator root of the head state.
+// This returns the genesis validators root of the head state.
 // This is a lock free version.
-func (s *Service) headGenesisValidatorRoot() [32]byte {
-	return bytesutil.ToBytes32(s.head.state.GenesisValidatorRoot())
+func (s *Service) headGenesisValidatorsRoot() [32]byte {
+	return bytesutil.ToBytes32(s.head.state.GenesisValidatorsRoot())
 }
 
 // This returns the validator referenced by the provided index in

beacon-chain/blockchain/head_sync_committee_info.go

@@ -130,7 +130,7 @@ func (s *Service) domainWithHeadState(ctx context.Context, slot types.Slot, doma
 	if err != nil {
 		return nil, err
 	}
-	return signing.Domain(headState.Fork(), slots.ToEpoch(headState.Slot()), domain, headState.GenesisValidatorRoot())
+	return signing.Domain(headState.Fork(), slots.ToEpoch(headState.Slot()), domain, headState.GenesisValidatorsRoot())
 }
 
 // returns the head state that is advanced up to `slot`. It utilizes the cache `syncCommitteeHeadState` by retrieving using `slot` as key.
@@ -157,11 +157,9 @@ func (s *Service) getSyncCommitteeHeadState(ctx context.Context, slot types.Slot
 		if headState == nil || headState.IsNil() {
 			return nil, errors.New("nil state")
 		}
-		if slot > headState.Slot() {
-			headState, err = transition.ProcessSlots(ctx, headState, slot)
-			if err != nil {
-				return nil, err
-			}
+		headState, err = transition.ProcessSlotsIfPossible(ctx, headState, slot)
+		if err != nil {
+			return nil, err
 		}
 		syncHeadStateMiss.Inc()
 		err = syncCommitteeHeadStateCache.Put(slot, headState)

beacon-chain/blockchain/head_sync_committee_info_test.go

@@ -122,7 +122,7 @@ func TestService_HeadSyncCommitteeDomain(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorRoot())
+	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 
 	d, err := c.HeadSyncCommitteeDomain(context.Background(), 0)
@@ -136,7 +136,7 @@ func TestService_HeadSyncContributionProofDomain(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, s.GenesisValidatorRoot())
+	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainContributionAndProof, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 
 	d, err := c.HeadSyncContributionProofDomain(context.Background(), 0)
@@ -150,7 +150,7 @@ func TestService_HeadSyncSelectionProofDomain(t *testing.T) {
 	c := &Service{}
 	c.head = &head{state: s}
 
-	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, s.GenesisValidatorRoot())
+	wanted, err := signing.Domain(s.Fork(), slots.ToEpoch(s.Slot()), params.BeaconConfig().DomainSyncCommitteeSelectionProof, s.GenesisValidatorsRoot())
 	require.NoError(t, err)
 
 	d, err := c.HeadSyncSelectionProofDomain(context.Background(), 0)

beacon-chain/blockchain/head_test.go

@@ -143,9 +143,9 @@ func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
-	service.finalizedCheckpt = &ethpb.Checkpoint{}
-	service.bestJustifiedCheckpt = &ethpb.Checkpoint{}
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{})
+	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{})
 
 	require.NoError(t, service.updateHead(context.Background(), []uint64{}))
 }

beacon-chain/blockchain/mock_engine_test.go

@@ -0,0 +1,47 @@
+package blockchain
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/pkg/errors"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+)
+
+type mockEngineService struct {
+	blks map[[32]byte]*enginev1.ExecutionBlock
+}
+
+func (*mockEngineService) NewPayload(context.Context, *enginev1.ExecutionPayload) ([]byte, error) {
+	return nil, nil
+}
+
+func (*mockEngineService) ForkchoiceUpdated(context.Context, *enginev1.ForkchoiceState, *enginev1.PayloadAttributes) (*enginev1.PayloadIDBytes, []byte, error) {
+	return nil, nil, nil
+}
+
+func (*mockEngineService) GetPayloadV1(
+	_ context.Context, _ enginev1.PayloadIDBytes,
+) *enginev1.ExecutionPayload {
+	return nil
+}
+
+func (*mockEngineService) GetPayload(context.Context, [8]byte) (*enginev1.ExecutionPayload, error) {
+	return nil, nil
+}
+
+func (*mockEngineService) ExchangeTransitionConfiguration(context.Context, *enginev1.TransitionConfiguration) error {
+	return nil
+}
+
+func (*mockEngineService) LatestExecutionBlock(context.Context) (*enginev1.ExecutionBlock, error) {
+	return nil, nil
+}
+
+func (m *mockEngineService) ExecutionBlockByHash(_ context.Context, hash common.Hash) (*enginev1.ExecutionBlock, error) {
+	blk, ok := m.blks[common.BytesToHash(hash.Bytes())]
+	if !ok {
+		return nil, errors.New("block not found")
+	}
+	return blk, nil
+}

beacon-chain/blockchain/new_slot.go

@@ -0,0 +1,72 @@
+package blockchain
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/time/slots"
+)
+
+// NewSlot mimics the implementation of `on_tick` in fork choice consensus spec.
+// It resets the proposer boost root in fork choice, and it updates store's justified checkpoint
+// if a better checkpoint on the store's finalized checkpoint chain.
+// This should only be called at the start of every slot interval.
+//
+// Spec pseudocode definition:
+//    # Reset store.proposer_boost_root if this is a new slot
+//    if current_slot > previous_slot:
+//        store.proposer_boost_root = Root()
+//
+//    # Not a new epoch, return
+//    if not (current_slot > previous_slot and compute_slots_since_epoch_start(current_slot) == 0):
+//        return
+//
+//    # Update store.justified_checkpoint if a better checkpoint on the store.finalized_checkpoint chain
+//    if store.best_justified_checkpoint.epoch > store.justified_checkpoint.epoch:
+//        finalized_slot = compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)
+//        ancestor_at_finalized_slot = get_ancestor(store, store.best_justified_checkpoint.root, finalized_slot)
+//        if ancestor_at_finalized_slot == store.finalized_checkpoint.root:
+//            store.justified_checkpoint = store.best_justified_checkpoint
+func (s *Service) NewSlot(ctx context.Context, slot types.Slot) error {
+
+	// Reset proposer boost root in fork choice.
+	if err := s.cfg.ForkChoiceStore.ResetBoostedProposerRoot(ctx); err != nil {
+		return errors.Wrap(err, "could not reset boosted proposer root in fork choice")
+	}
+
+	// Return if it's not a new epoch.
+	if !slots.IsEpochStart(slot) {
+		return nil
+	}
+
+	// Update store.justified_checkpoint if a better checkpoint on the store.finalized_checkpoint chain
+	bj := s.store.BestJustifiedCheckpt()
+	if bj == nil {
+		return errNilBestJustifiedInStore
+	}
+	j := s.store.JustifiedCheckpt()
+	if j == nil {
+		return errNilJustifiedInStore
+	}
+	f := s.store.FinalizedCheckpt()
+	if f == nil {
+		return errNilFinalizedInStore
+	}
+	if bj.Epoch > j.Epoch {
+		finalizedSlot, err := slots.EpochStart(f.Epoch)
+		if err != nil {
+			return err
+		}
+		r, err := s.ancestor(ctx, bj.Root, finalizedSlot)
+		if err != nil {
+			return err
+		}
+		if bytes.Equal(r, f.Root) {
+			s.store.SetJustifiedCheckpt(bj)
+		}
+	}
+	return nil
+
+}

beacon-chain/blockchain/new_slot_test.go

@@ -0,0 +1,100 @@
+package blockchain
+
+import (
+	"context"
+	"testing"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain/store"
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/testing/require"
+)
+
+func TestService_newSlot(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+	fcs := protoarray.New(0, 0, [32]byte{})
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+	}
+	ctx := context.Background()
+
+	require.NoError(t, fcs.ProcessBlock(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, 0, 0))        // genesis
+	require.NoError(t, fcs.ProcessBlock(ctx, 32, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0))    // finalized
+	require.NoError(t, fcs.ProcessBlock(ctx, 64, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0)) // justified
+	require.NoError(t, fcs.ProcessBlock(ctx, 96, [32]byte{'c'}, [32]byte{'a'}, [32]byte{}, 0, 0)) // best justified
+	require.NoError(t, fcs.ProcessBlock(ctx, 97, [32]byte{'d'}, [32]byte{}, [32]byte{}, 0, 0))    // bad
+
+	type args struct {
+		slot          types.Slot
+		finalized     *ethpb.Checkpoint
+		justified     *ethpb.Checkpoint
+		bestJustified *ethpb.Checkpoint
+		shouldEqual   bool
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "Not epoch boundary. No change",
+			args: args{
+				slot:          params.BeaconConfig().SlotsPerEpoch + 1,
+				finalized:     &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'a'}, 32)},
+				justified:     &ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'b'}, 32)},
+				bestJustified: &ethpb.Checkpoint{Epoch: 3, Root: bytesutil.PadTo([]byte{'c'}, 32)},
+				shouldEqual:   false,
+			},
+		},
+		{
+			name: "Justified higher than best justified. No change",
+			args: args{
+				slot:          params.BeaconConfig().SlotsPerEpoch,
+				finalized:     &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'a'}, 32)},
+				justified:     &ethpb.Checkpoint{Epoch: 3, Root: bytesutil.PadTo([]byte{'b'}, 32)},
+				bestJustified: &ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'c'}, 32)},
+				shouldEqual:   false,
+			},
+		},
+		{
+			name: "Best justified not on the same chain as finalized. No change",
+			args: args{
+				slot:          params.BeaconConfig().SlotsPerEpoch,
+				finalized:     &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'a'}, 32)},
+				justified:     &ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'b'}, 32)},
+				bestJustified: &ethpb.Checkpoint{Epoch: 3, Root: bytesutil.PadTo([]byte{'d'}, 32)},
+				shouldEqual:   false,
+			},
+		},
+		{
+			name: "Best justified on the same chain as finalized. Yes change",
+			args: args{
+				slot:          params.BeaconConfig().SlotsPerEpoch,
+				finalized:     &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'a'}, 32)},
+				justified:     &ethpb.Checkpoint{Epoch: 2, Root: bytesutil.PadTo([]byte{'b'}, 32)},
+				bestJustified: &ethpb.Checkpoint{Epoch: 3, Root: bytesutil.PadTo([]byte{'c'}, 32)},
+				shouldEqual:   true,
+			},
+		},
+	}
+	for _, test := range tests {
+		service, err := NewService(ctx, opts...)
+		require.NoError(t, err)
+		store := store.New(test.args.justified, test.args.finalized)
+		store.SetBestJustifiedCheckpt(test.args.bestJustified)
+		service.store = store
+
+		require.NoError(t, service.NewSlot(ctx, test.args.slot))
+		if test.args.shouldEqual {
+			require.DeepSSZEqual(t, service.store.BestJustifiedCheckpt(), service.store.JustifiedCheckpt())
+		} else {
+			require.DeepNotSSZEqual(t, service.store.BestJustifiedCheckpt(), service.store.JustifiedCheckpt())
+		}
+	}
+}

beacon-chain/blockchain/optimistic_sync.go

@@ -0,0 +1,171 @@
+package blockchain
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	v1 "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/runtime/version"
+	"github.com/sirupsen/logrus"
+)
+
+// notifyForkchoiceUpdate signals execution engine the fork choice updates. Execution engine should:
+// 1. Re-organizes the execution payload chain and corresponding state to make head_block_hash the head.
+// 2. Applies finality to the execution state: it irreversibly persists the chain of all execution payloads and corresponding state, up to and including finalized_block_hash.
+func (s *Service) notifyForkchoiceUpdate(ctx context.Context, headBlk block.BeaconBlock, finalizedRoot [32]byte) (*enginev1.PayloadIDBytes, error) {
+	// Must not call fork choice updated until the transition conditions are met on the Pow network.
+	switch headBlk.Version() {
+	case version.Phase0, version.Altair:
+		return nil, nil
+	}
+	isExecutionBlk, err := blocks.ExecutionBlock(headBlk.Body())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not determine if block is execution block")
+	}
+	if !isExecutionBlk {
+		return nil, nil
+	}
+	headPayload, err := headBlk.Body().ExecutionPayload()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution payload")
+	}
+	finalizedBlock, err := s.cfg.BeaconDB.Block(ctx, s.ensureRootNotZeros(finalizedRoot))
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get finalized block")
+	}
+	var finalizedHash []byte
+	switch finalizedBlock.Version() {
+	case version.Phase0, version.Altair:
+		// Before a post-transition block is finalized, finalized hash field must be Hash32().
+		finalizedHash = params.BeaconConfig().ZeroHash[:]
+	default:
+		payload, err := finalizedBlock.Block().Body().ExecutionPayload()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get finalized block execution payload")
+		}
+		finalizedHash = payload.BlockHash
+	}
+
+	fcs := &enginev1.ForkchoiceState{
+		HeadBlockHash:      headPayload.BlockHash,
+		SafeBlockHash:      headPayload.BlockHash,
+		FinalizedBlockHash: finalizedHash,
+	}
+
+	payloadID, _, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, nil /*payload attribute*/)
+	if err != nil {
+		switch err {
+		case v1.ErrAcceptedSyncingPayloadStatus:
+			log.WithFields(logrus.Fields{
+				"headSlot":      headBlk.Slot(),
+				"headHash":      fmt.Sprintf("%#x", bytesutil.Trunc(headPayload.BlockHash)),
+				"finalizedHash": fmt.Sprintf("%#x", bytesutil.Trunc(finalizedHash)),
+			}).Info("Called fork choice updated with optimistic block")
+			return payloadID, nil
+		default:
+			return nil, errors.Wrap(err, "could not notify forkchoice update from execution engine")
+		}
+	}
+	return payloadID, nil
+}
+
+// notifyForkchoiceUpdate signals execution engine on a new payload
+func (s *Service) notifyNewPayload(ctx context.Context, preState, postState state.BeaconState, blk block.SignedBeaconBlock) error {
+	// Execution payload is only supported in Bellatrix and beyond.
+	switch postState.Version() {
+	case version.Phase0, version.Altair:
+		return nil
+	}
+	if err := helpers.BeaconBlockIsNil(blk); err != nil {
+		return err
+	}
+	body := blk.Block().Body()
+	enabled, err := blocks.ExecutionEnabled(postState, blk.Block().Body())
+	if err != nil {
+		return errors.Wrap(err, "could not determine if execution is enabled")
+	}
+	if !enabled {
+		return nil
+	}
+	payload, err := body.ExecutionPayload()
+	if err != nil {
+		return errors.Wrap(err, "could not get execution payload")
+	}
+	_, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload)
+	if err != nil {
+		switch err {
+		case v1.ErrAcceptedSyncingPayloadStatus:
+			log.WithFields(logrus.Fields{
+				"slot":      postState.Slot(),
+				"blockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
+			}).Info("Called new payload with optimistic block")
+			return nil
+		default:
+			return errors.Wrap(err, "could not validate execution payload from execution engine")
+		}
+	}
+
+	// During the transition event, the transition block should be verified for sanity.
+	switch preState.Version() {
+	case version.Phase0, version.Altair:
+		return nil
+	}
+	atTransition, err := blocks.MergeTransitionBlock(preState, body)
+	if err != nil {
+		return errors.Wrap(err, "could not check if merge block is terminal")
+	}
+	if !atTransition {
+		return nil
+	}
+	return s.validateMergeBlock(ctx, blk)
+}
+
+// optimisticCandidateBlock returns true if this block can be optimistically synced.
+//
+// Spec pseudocode definition:
+// def is_optimistic_candidate_block(opt_store: OptimisticStore, current_slot: Slot, block: BeaconBlock) -> bool:
+//     justified_root = opt_store.block_states[opt_store.head_block_root].current_justified_checkpoint.root
+//     justified_is_execution_block = is_execution_block(opt_store.blocks[justified_root])
+//     block_is_deep = block.slot + SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY <= current_slot
+//     return justified_is_execution_block or block_is_deep
+func (s *Service) optimisticCandidateBlock(ctx context.Context, blk block.BeaconBlock) (bool, error) {
+	if blk.Slot()+params.BeaconConfig().SafeSlotsToImportOptimistically <= s.CurrentSlot() {
+		return true, nil
+	}
+	j := s.store.JustifiedCheckpt()
+	if j == nil {
+		return false, errNilJustifiedInStore
+	}
+	jBlock, err := s.cfg.BeaconDB.Block(ctx, bytesutil.ToBytes32(j.Root))
+	if err != nil {
+		return false, err
+	}
+	return blocks.ExecutionBlock(jBlock.Block().Body())
+}
+
+// loadSyncedTips loads a previously saved synced Tips from DB
+// if no synced tips are saved, then it creates one from the given
+// root and slot number.
+func (s *Service) loadSyncedTips(root [32]byte, slot types.Slot) error {
+	// Initialize synced tips
+	tips, err := s.cfg.BeaconDB.ValidatedTips(s.ctx)
+	if err != nil || len(tips) == 0 {
+		tips[root] = slot
+		if err != nil {
+			log.WithError(err).Warn("Could not read synced tips from DB, using finalized checkpoint as synced tip")
+		}
+	}
+	if err := s.cfg.ForkChoiceStore.SetSyncedTips(tips); err != nil {
+		return errors.Wrap(err, "could not set synced tips")
+	}
+	return nil
+}

beacon-chain/blockchain/optimistic_sync_test.go

@@ -0,0 +1,141 @@
+package blockchain
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
+	"github.com/prysmaticlabs/prysm/time/slots"
+)
+
+func Test_IsOptimisticCandidateBlock(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	params.OverrideBeaconConfig(params.MainnetConfig())
+
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	fcs := protoarray.New(0, 0, [32]byte{'a'})
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+	}
+
+	service, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+
+	params.BeaconConfig().SafeSlotsToImportOptimistically = 128
+	service.genesisTime = time.Now().Add(-time.Second * 12 * 2 * 128)
+
+	tests := []struct {
+		name      string
+		blk       block.BeaconBlock
+		justified block.SignedBeaconBlock
+		want      bool
+	}{
+		{
+			name: "deep block",
+			blk: func(tt *testing.T) block.BeaconBlock {
+				blk := util.NewBeaconBlockBellatrix()
+				blk.Block.Slot = 1
+				wr, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
+				require.NoError(tt, err)
+				return wr
+			}(t),
+			justified: func(tt *testing.T) block.SignedBeaconBlock {
+				blk := util.NewBeaconBlockBellatrix()
+				blk.Block.Slot = 32
+				wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk)
+				require.NoError(tt, err)
+				return wr
+			}(t),
+			want: true,
+		},
+		{
+			name: "shallow block, Altair justified chkpt",
+			blk: func(tt *testing.T) block.BeaconBlock {
+				blk := util.NewBeaconBlockAltair()
+				blk.Block.Slot = 200
+				wr, err := wrapper.WrappedAltairBeaconBlock(blk.Block)
+				require.NoError(tt, err)
+				return wr
+			}(t),
+			justified: func(tt *testing.T) block.SignedBeaconBlock {
+				blk := util.NewBeaconBlockAltair()
+				blk.Block.Slot = 32
+				wr, err := wrapper.WrappedAltairSignedBeaconBlock(blk)
+				require.NoError(tt, err)
+				return wr
+			}(t),
+			want: false,
+		},
+		{
+			name: "shallow block, Bellatrix justified chkpt without execution",
+			blk: func(tt *testing.T) block.BeaconBlock {
+				blk := util.NewBeaconBlockBellatrix()
+				blk.Block.Slot = 200
+				wr, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
+				require.NoError(tt, err)
+				return wr
+			}(t),
+			justified: func(tt *testing.T) block.SignedBeaconBlock {
+				blk := util.NewBeaconBlockBellatrix()
+				blk.Block.Slot = 32
+				wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk)
+				require.NoError(tt, err)
+				return wr
+			}(t),
+			want: false,
+		},
+		{
+			name: "shallow block, execution enabled justified chkpt",
+			blk: func(tt *testing.T) block.BeaconBlock {
+				blk := util.NewBeaconBlockBellatrix()
+				blk.Block.Slot = 200
+				wr, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
+				require.NoError(tt, err)
+				return wr
+			}(t),
+			justified: func(tt *testing.T) block.SignedBeaconBlock {
+				blk := util.NewBeaconBlockBellatrix()
+				blk.Block.Slot = 32
+				blk.Block.Body.ExecutionPayload.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				blk.Block.Body.ExecutionPayload.FeeRecipient = bytesutil.PadTo([]byte{'a'}, fieldparams.FeeRecipientLength)
+				blk.Block.Body.ExecutionPayload.StateRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				blk.Block.Body.ExecutionPayload.ReceiptsRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				blk.Block.Body.ExecutionPayload.LogsBloom = bytesutil.PadTo([]byte{'a'}, fieldparams.LogsBloomLength)
+				blk.Block.Body.ExecutionPayload.PrevRandao = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				blk.Block.Body.ExecutionPayload.BaseFeePerGas = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				blk.Block.Body.ExecutionPayload.BlockHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk)
+				require.NoError(tt, err)
+				return wr
+			}(t),
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		jroot, err := tt.justified.Block().HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, tt.justified))
+		service.store.SetJustifiedCheckpt(
+			&ethpb.Checkpoint{
+				Root:  jroot[:],
+				Epoch: slots.ToEpoch(tt.justified.Block().Slot()),
+			})
+		candidate, err := service.optimisticCandidateBlock(ctx, tt.blk)
+		require.NoError(t, err)
+		require.Equal(t, tt.want, candidate, tt.name)
+	}
+}

beacon-chain/blockchain/options.go

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

beacon-chain/blockchain/pow_block.go

@@ -0,0 +1,141 @@
+package blockchain
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/holiman/uint256"
+	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/time/slots"
+	"github.com/sirupsen/logrus"
+)
+
+// validateMergeBlock validates terminal block hash in the event of manual overrides before checking for total difficulty.
+//
+// def validate_merge_block(block: BeaconBlock) -> None:
+//    if TERMINAL_BLOCK_HASH != Hash32():
+//        # If `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
+//        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
+//        assert block.body.execution_payload.parent_hash == TERMINAL_BLOCK_HASH
+//        return
+//
+//    pow_block = get_pow_block(block.body.execution_payload.parent_hash)
+//    # Check if `pow_block` is available
+//    assert pow_block is not None
+//    pow_parent = get_pow_block(pow_block.parent_hash)
+//    # Check if `pow_parent` is available
+//    assert pow_parent is not None
+//    # Check if `pow_block` is a valid terminal PoW block
+//    assert is_valid_terminal_pow_block(pow_block, pow_parent)
+func (s *Service) validateMergeBlock(ctx context.Context, b block.SignedBeaconBlock) error {
+	if err := helpers.BeaconBlockIsNil(b); err != nil {
+		return err
+	}
+	payload, err := b.Block().Body().ExecutionPayload()
+	if err != nil {
+		return err
+	}
+	if payload == nil {
+		return errors.New("nil execution payload")
+	}
+	if err := validateTerminalBlockHash(b.Block().Slot(), payload); err != nil {
+		return errors.Wrap(err, "could not validate terminal block hash")
+	}
+	mergeBlockParentHash, mergeBlockTD, err := s.getBlkParentHashAndTD(ctx, payload.ParentHash)
+	if err != nil {
+		return errors.Wrap(err, "could not get merge block parent hash and total difficulty")
+	}
+	_, mergeBlockParentTD, err := s.getBlkParentHashAndTD(ctx, mergeBlockParentHash)
+	if err != nil {
+		return errors.Wrap(err, "could not get merge parent block total difficulty")
+	}
+	valid, err := validateTerminalBlockDifficulties(mergeBlockTD, mergeBlockParentTD)
+	if err != nil {
+		return err
+	}
+	if !valid {
+		return fmt.Errorf("invalid TTD, configTTD: %s, currentTTD: %s, parentTTD: %s",
+			params.BeaconConfig().TerminalTotalDifficulty, mergeBlockTD, mergeBlockParentTD)
+	}
+
+	log.WithFields(logrus.Fields{
+		"slot":                            b.Block().Slot(),
+		"mergeBlockHash":                  common.BytesToHash(payload.ParentHash).String(),
+		"mergeBlockParentHash":            common.BytesToHash(mergeBlockParentHash).String(),
+		"terminalTotalDifficulty":         params.BeaconConfig().TerminalTotalDifficulty,
+		"mergeBlockTotalDifficulty":       mergeBlockTD,
+		"mergeBlockParentTotalDifficulty": mergeBlockParentTD,
+	}).Info("Validated terminal block")
+
+	return nil
+}
+
+// getBlkParentHashAndTD retrieves the parent hash and total difficulty of the given block.
+func (s *Service) getBlkParentHashAndTD(ctx context.Context, blkHash []byte) ([]byte, *uint256.Int, error) {
+	blk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(ctx, common.BytesToHash(blkHash))
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "could not get pow block")
+	}
+	if blk == nil {
+		return nil, nil, errors.New("pow block is nil")
+	}
+	blkTDBig, err := hexutil.DecodeBig(blk.TotalDifficulty)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "could not decode merge block total difficulty")
+	}
+	blkTDUint256, overflows := uint256.FromBig(blkTDBig)
+	if overflows {
+		return nil, nil, errors.New("total difficulty overflows")
+	}
+	return blk.ParentHash, blkTDUint256, nil
+}
+
+// validateTerminalBlockHash validates if the merge block is a valid terminal PoW block.
+// spec code:
+// if TERMINAL_BLOCK_HASH != Hash32():
+//        # If `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
+//        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
+//        assert block.body.execution_payload.parent_hash == TERMINAL_BLOCK_HASH
+//        return
+func validateTerminalBlockHash(blkSlot types.Slot, payload *enginev1.ExecutionPayload) error {
+	if bytesutil.ToBytes32(params.BeaconConfig().TerminalBlockHash.Bytes()) == [32]byte{} {
+		return nil
+	}
+	if params.BeaconConfig().TerminalBlockHashActivationEpoch > slots.ToEpoch(blkSlot) {
+		return errors.New("terminal block hash activation epoch not reached")
+	}
+	if !bytes.Equal(payload.ParentHash, params.BeaconConfig().TerminalBlockHash.Bytes()) {
+		return errors.New("parent hash does not match terminal block hash")
+	}
+	return nil
+}
+
+// validateTerminalBlockDifficulties validates terminal pow block by comparing own total difficulty with parent's total difficulty.
+//
+// def is_valid_terminal_pow_block(block: PowBlock, parent: PowBlock) -> bool:
+//    is_total_difficulty_reached = block.total_difficulty >= TERMINAL_TOTAL_DIFFICULTY
+//    is_parent_total_difficulty_valid = parent.total_difficulty < TERMINAL_TOTAL_DIFFICULTY
+//    return is_total_difficulty_reached and is_parent_total_difficulty_valid
+func validateTerminalBlockDifficulties(currentDifficulty *uint256.Int, parentDifficulty *uint256.Int) (bool, error) {
+	b, ok := new(big.Int).SetString(params.BeaconConfig().TerminalTotalDifficulty, 10)
+	if !ok {
+		return false, errors.New("failed to parse terminal total difficulty")
+	}
+	ttd, of := uint256.FromBig(b)
+	if of {
+		return false, errors.New("overflow terminal total difficulty")
+	}
+	totalDifficultyReached := currentDifficulty.Cmp(ttd) >= 0
+	parentTotalDifficultyValid := ttd.Cmp(parentDifficulty) > 0
+	return totalDifficultyReached && parentTotalDifficultyValid, nil
+}

beacon-chain/blockchain/pow_block_test.go

@@ -0,0 +1,210 @@
+package blockchain
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"testing"
+
+	"github.com/holiman/uint256"
+	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/testing/require"
+)
+
+func Test_validTerminalPowBlock(t *testing.T) {
+	tests := []struct {
+		name              string
+		currentDifficulty *uint256.Int
+		parentDifficulty  *uint256.Int
+		ttd               uint64
+		want              bool
+	}{
+		{
+			name:              "current > ttd, parent > ttd",
+			currentDifficulty: uint256.NewInt(2),
+			parentDifficulty:  uint256.NewInt(2),
+			ttd:               1,
+			want:              false,
+		},
+		{
+			name:              "current < ttd, parent < ttd",
+			currentDifficulty: uint256.NewInt(2),
+			parentDifficulty:  uint256.NewInt(2),
+			ttd:               3,
+			want:              false,
+		},
+		{
+			name:              "current == ttd, parent == ttd",
+			currentDifficulty: uint256.NewInt(2),
+			parentDifficulty:  uint256.NewInt(2),
+			ttd:               2,
+			want:              false,
+		},
+		{
+			name:              "current > ttd, parent == ttd",
+			currentDifficulty: uint256.NewInt(2),
+			parentDifficulty:  uint256.NewInt(1),
+			ttd:               1,
+			want:              false,
+		},
+		{
+			name:              "current == ttd, parent < ttd",
+			currentDifficulty: uint256.NewInt(2),
+			parentDifficulty:  uint256.NewInt(1),
+			ttd:               2,
+			want:              true,
+		},
+		{
+			name:              "current > ttd, parent < ttd",
+			currentDifficulty: uint256.NewInt(3),
+			parentDifficulty:  uint256.NewInt(1),
+			ttd:               2,
+			want:              true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cfg := params.BeaconConfig()
+			cfg.TerminalTotalDifficulty = fmt.Sprint(tt.ttd)
+			params.OverrideBeaconConfig(cfg)
+			got, err := validateTerminalBlockDifficulties(tt.currentDifficulty, tt.parentDifficulty)
+			require.NoError(t, err)
+			if got != tt.want {
+				t.Errorf("validateTerminalBlockDifficulties() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_validTerminalPowBlockSpecConfig(t *testing.T) {
+	cfg := params.BeaconConfig()
+	cfg.TerminalTotalDifficulty = "115792089237316195423570985008687907853269984665640564039457584007913129638912"
+	params.OverrideBeaconConfig(cfg)
+
+	i, _ := new(big.Int).SetString("115792089237316195423570985008687907853269984665640564039457584007913129638912", 10)
+	current, of := uint256.FromBig(i)
+	require.Equal(t, of, false)
+	i, _ = new(big.Int).SetString("115792089237316195423570985008687907853269984665640564039457584007913129638911", 10)
+	parent, of := uint256.FromBig(i)
+	require.Equal(t, of, false)
+
+	got, err := validateTerminalBlockDifficulties(current, parent)
+	require.NoError(t, err)
+	require.Equal(t, true, got)
+}
+
+func Test_validateMergeBlock(t *testing.T) {
+	cfg := params.BeaconConfig()
+	cfg.TerminalTotalDifficulty = "2"
+	params.OverrideBeaconConfig(cfg)
+
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	fcs := protoarray.New(0, 0, [32]byte{'a'})
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+	}
+	service, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+
+	engine := &mockEngineService{blks: map[[32]byte]*enginev1.ExecutionBlock{}}
+	service.cfg.ExecutionEngineCaller = engine
+	engine.blks[[32]byte{'a'}] = &enginev1.ExecutionBlock{
+		ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
+		TotalDifficulty: "0x2",
+	}
+	engine.blks[[32]byte{'b'}] = &enginev1.ExecutionBlock{
+		ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
+		TotalDifficulty: "0x1",
+	}
+	blk := &ethpb.SignedBeaconBlockBellatrix{
+		Block: &ethpb.BeaconBlockBellatrix{
+			Slot: 1,
+			Body: &ethpb.BeaconBlockBodyBellatrix{
+				ExecutionPayload: &enginev1.ExecutionPayload{
+					ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
+				},
+			},
+		},
+	}
+	b, err := wrapper.WrappedSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	require.NoError(t, service.validateMergeBlock(ctx, b))
+
+	cfg.TerminalTotalDifficulty = "1"
+	params.OverrideBeaconConfig(cfg)
+	require.ErrorContains(t, "invalid TTD, configTTD: 1, currentTTD: 2, parentTTD: 1", service.validateMergeBlock(ctx, b))
+}
+
+func Test_getBlkParentHashAndTD(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	fcs := protoarray.New(0, 0, [32]byte{'a'})
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+	}
+	service, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+
+	engine := &mockEngineService{blks: map[[32]byte]*enginev1.ExecutionBlock{}}
+	service.cfg.ExecutionEngineCaller = engine
+	h := [32]byte{'a'}
+	p := [32]byte{'b'}
+	td := "0x1"
+	engine.blks[h] = &enginev1.ExecutionBlock{
+		ParentHash:      p[:],
+		TotalDifficulty: td,
+	}
+	parentHash, totalDifficulty, err := service.getBlkParentHashAndTD(ctx, h[:])
+	require.NoError(t, err)
+	require.Equal(t, p, bytesutil.ToBytes32(parentHash))
+	require.Equal(t, td, totalDifficulty.String())
+
+	_, _, err = service.getBlkParentHashAndTD(ctx, []byte{'c'})
+	require.ErrorContains(t, "could not get pow block: block not found", err)
+
+	engine.blks[h] = nil
+	_, _, err = service.getBlkParentHashAndTD(ctx, h[:])
+	require.ErrorContains(t, "pow block is nil", err)
+
+	engine.blks[h] = &enginev1.ExecutionBlock{
+		ParentHash:      p[:],
+		TotalDifficulty: "1",
+	}
+	_, _, err = service.getBlkParentHashAndTD(ctx, h[:])
+	require.ErrorContains(t, "could not decode merge block total difficulty: hex string without 0x prefix", err)
+
+	engine.blks[h] = &enginev1.ExecutionBlock{
+		ParentHash:      p[:],
+		TotalDifficulty: "0XFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
+	}
+	_, _, err = service.getBlkParentHashAndTD(ctx, h[:])
+	require.ErrorContains(t, "could not decode merge block total difficulty: hex number > 256 bits", err)
+}
+
+func Test_validateTerminalBlockHash(t *testing.T) {
+	require.NoError(t, validateTerminalBlockHash(1, &enginev1.ExecutionPayload{}))
+
+	cfg := params.BeaconConfig()
+	cfg.TerminalBlockHash = [32]byte{0x01}
+	params.OverrideBeaconConfig(cfg)
+	require.ErrorContains(t, "terminal block hash activation epoch not reached", validateTerminalBlockHash(1, &enginev1.ExecutionPayload{}))
+
+	cfg.TerminalBlockHashActivationEpoch = 0
+	params.OverrideBeaconConfig(cfg)
+	require.ErrorContains(t, "parent hash does not match terminal block hash", validateTerminalBlockHash(1, &enginev1.ExecutionPayload{}))
+
+	require.NoError(t, validateTerminalBlockHash(1, &enginev1.ExecutionPayload{ParentHash: cfg.TerminalBlockHash.Bytes()}))
+}

beacon-chain/blockchain/process_attestation.go

@@ -2,6 +2,7 @@ package blockchain
 
 import (
 	"context"
+	"time"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -9,12 +10,11 @@ import (
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
-	"github.com/prysmaticlabs/prysm/time"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
 )
 
-// onAttestation is called whenever an attestation is received, verifies the attestation is valid and saves
+// OnAttestation is called whenever an attestation is received, verifies the attestation is valid and saves
 // it to the DB. As a stateless function, this does not hold nor delay attestation based on the spec descriptions.
 // The delay is handled by the caller in `processAttestations`.
 //
@@ -36,7 +36,7 @@ import (
 //
 //    # Update latest messages for attesting indices
 //    update_latest_messages(store, indexed_attestation.attesting_indices, attestation)
-func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) error {
+func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onAttestation")
 	defer span.End()
 
@@ -59,7 +59,7 @@ func (s *Service) onAttestation(ctx context.Context, a *ethpb.Attestation) error
 		return err
 	}
 
-	genesisTime := baseState.GenesisTime()
+	genesisTime := uint64(s.genesisTime.Unix())
 
 	// Verify attestation target is from current epoch or previous epoch.
 	if err := verifyAttTargetEpoch(ctx, genesisTime, uint64(time.Now().Unix()), tgt); err != nil {

beacon-chain/blockchain/process_attestation_helpers.go

@@ -42,11 +42,9 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 	if err != nil {
 		return nil, err
 	}
-	if epochStartSlot > baseState.Slot() {
-		baseState, err = transition.ProcessSlots(ctx, baseState, epochStartSlot)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
-		}
+	baseState, err = transition.ProcessSlotsIfPossible(ctx, baseState, epochStartSlot)
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not process slots up to epoch %d", c.Epoch)
 	}
 
 	// Sharing the same state across caches is perfectly fine here, the fetching

beacon-chain/blockchain/process_attestation_test.go

@@ -3,6 +3,7 @@ package blockchain
 import (
 	"context"
 	"testing"
+	"time"
 
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
@@ -17,7 +18,6 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/prysmaticlabs/prysm/time"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
@@ -117,7 +117,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := service.onAttestation(ctx, tt.a)
+			err := service.OnAttestation(ctx, tt.a)
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
@@ -140,7 +140,7 @@ func TestStore_OnAttestation_Ok(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	genesisState, pks := util.DeterministicGenesisState(t, 64)
-	require.NoError(t, genesisState.SetGenesisTime(uint64(time.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
+	service.SetGenesisTime(time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
 	att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
 	require.NoError(t, err)
@@ -150,7 +150,7 @@ func TestStore_OnAttestation_Ok(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
 	require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(ctx, 0, tRoot, tRoot, tRoot, 1, 1))
-	require.NoError(t, service.onAttestation(ctx, att[0]))
+	require.NoError(t, service.OnAttestation(ctx, att[0]))
 }
 
 func TestStore_SaveCheckpointState(t *testing.T) {
@@ -179,10 +179,10 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	r := [32]byte{'g'}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, r))
 
-	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
-	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
-	service.finalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
-	service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
+	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: r[:]})
+	service.store.SetPrevFinalizedCheckpt(&ethpb.Checkpoint{Root: r[:]})
 
 	r = bytesutil.ToBytes32([]byte{'A'})
 	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)}
@@ -213,10 +213,10 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	assert.Equal(t, 2*params.BeaconConfig().SlotsPerEpoch, s2.Slot(), "Unexpected state slot")
 
 	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch+1))
-	service.justifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
-	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: r[:]}
-	service.finalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
-	service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
+	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: r[:]})
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: r[:]})
+	service.store.SetPrevFinalizedCheckpt(&ethpb.Checkpoint{Root: r[:]})
 	cp3 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'C'})))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}))
@@ -349,8 +349,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot(t *testing.T) {
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1}
-
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 1})
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
@@ -375,7 +374,7 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: r32[:], Epoch: 1})
 
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
@@ -400,7 +399,7 @@ func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1, Root: r32[:]}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: r32[:], Epoch: 1})
 
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33

beacon-chain/blockchain/process_block.go

@@ -21,6 +21,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
 )
@@ -97,16 +98,44 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	if err != nil {
 		return err
 	}
+	// TODO_MERGE: Optimize this copy.
+	copiedPreState := preState.Copy()
 
 	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
 		return err
 	}
 
+	if err := s.notifyNewPayload(ctx, copiedPreState, postState, signed); err != nil {
+		return errors.Wrap(err, "could not verify new payload")
+	}
+
+	// We add a proposer score boost to fork choice for the block root if applicable, right after
+	// running a successful state transition for the block.
+	if err := s.cfg.ForkChoiceStore.BoostProposerRoot(
+		ctx, signed.Block().Slot(), blockRoot, s.genesisTime,
+	); err != nil {
+		return err
+	}
+
 	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, false /* reg sync */); err != nil {
 		return err
 	}
 
+	// update forkchoice synced tips if the block is not optimistic
+	if postState.Version() == version.Bellatrix {
+		root, err := b.HashTreeRoot()
+		if err != nil {
+			return err
+		}
+		if err := s.cfg.ForkChoiceStore.UpdateSyncedTipsWithValidRoot(ctx, root); err != nil {
+			return err
+		}
+		if err := s.saveSyncedTipsDB(ctx); err != nil {
+			return err
+		}
+	}
+
 	// If slasher is configured, forward the attestations in the block via
 	// an event feed for processing.
 	if features.Get().EnableSlasher {
@@ -135,31 +164,42 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	}
 
 	// Update justified check point.
-	currJustifiedEpoch := s.justifiedCheckpt.Epoch
+	justified := s.store.JustifiedCheckpt()
+	if justified == nil {
+		return errNilJustifiedInStore
+	}
+	currJustifiedEpoch := justified.Epoch
 	if postState.CurrentJustifiedCheckpoint().Epoch > currJustifiedEpoch {
 		if err := s.updateJustified(ctx, postState); err != nil {
 			return err
 		}
 	}
 
-	newFinalized := postState.FinalizedCheckpointEpoch() > s.finalizedCheckpt.Epoch
+	finalized := s.store.FinalizedCheckpt()
+	if finalized == nil {
+		return errNilFinalizedInStore
+	}
+	newFinalized := postState.FinalizedCheckpointEpoch() > finalized.Epoch
 	if newFinalized {
-		if err := s.finalizedImpliesNewJustified(ctx, postState); err != nil {
-			return errors.Wrap(err, "could not save new justified")
-		}
-		s.prevFinalizedCheckpt = s.finalizedCheckpt
-		s.finalizedCheckpt = postState.FinalizedCheckpoint()
+		s.store.SetPrevFinalizedCheckpt(finalized)
+		s.store.SetFinalizedCheckpt(postState.FinalizedCheckpoint())
+		s.store.SetPrevJustifiedCheckpt(justified)
+		s.store.SetJustifiedCheckpt(postState.CurrentJustifiedCheckpoint())
 	}
 
-	balances, err := s.justifiedBalances.get(ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+	balances, err := s.justifiedBalances.get(ctx, bytesutil.ToBytes32(justified.Root))
 	if err != nil {
-		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", s.justifiedCheckpt.Root)
+		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", justified.Root)
 		return errors.Wrap(err, msg)
 	}
 	if err := s.updateHead(ctx, balances); err != nil {
 		log.WithError(err).Warn("Could not update head")
 	}
 
+	if _, err := s.notifyForkchoiceUpdate(ctx, s.headBlock().Block(), bytesutil.ToBytes32(finalized.Root)); err != nil {
+		return err
+	}
+
 	if err := s.pruneCanonicalAttsFromPool(ctx, blockRoot, signed); err != nil {
 		return err
 	}
@@ -176,18 +216,16 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	})
 
 	// Updating next slot state cache can happen in the background. It shouldn't block rest of the process.
-	if features.Get().EnableNextSlotStateCache {
-		go func() {
-			// Use a custom deadline here, since this method runs asynchronously.
-			// We ignore the parent method's context and instead create a new one
-			// with a custom deadline, therefore using the background context instead.
-			slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
-			defer cancel()
-			if err := transition.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
-				log.WithError(err).Debug("could not update next slot state cache")
-			}
-		}()
-	}
+	go func() {
+		// Use a custom deadline here, since this method runs asynchronously.
+		// We ignore the parent method's context and instead create a new one
+		// with a custom deadline, therefore using the background context instead.
+		slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
+		defer cancel()
+		if err := transition.UpdateNextSlotCache(slotCtx, blockRoot[:], postState); err != nil {
+			log.WithError(err).Debug("could not update next slot state cache")
+		}
+	}()
 
 	// Save justified check point to db.
 	if postState.CurrentJustifiedCheckpoint().Epoch > currJustifiedEpoch {
@@ -234,32 +272,33 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 }
 
 func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlock,
-	blockRoots [][32]byte) ([]*ethpb.Checkpoint, []*ethpb.Checkpoint, error) {
+	blockRoots [][32]byte) ([]*ethpb.Checkpoint, []*ethpb.Checkpoint, []bool, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
 	defer span.End()
 
 	if len(blks) == 0 || len(blockRoots) == 0 {
-		return nil, nil, errors.New("no blocks provided")
+		return nil, nil, nil, errors.New("no blocks provided")
 	}
 	if err := helpers.BeaconBlockIsNil(blks[0]); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	b := blks[0].Block()
 
 	// Retrieve incoming block's pre state.
 	if err := s.verifyBlkPreState(ctx, b); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	preState, err := s.cfg.StateGen.StateByRootInitialSync(ctx, bytesutil.ToBytes32(b.ParentRoot()))
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	if preState == nil || preState.IsNil() {
-		return nil, nil, fmt.Errorf("nil pre state for slot %d", b.Slot())
+		return nil, nil, nil, fmt.Errorf("nil pre state for slot %d", b.Slot())
 	}
 
 	jCheckpoints := make([]*ethpb.Checkpoint, len(blks))
 	fCheckpoints := make([]*ethpb.Checkpoint, len(blks))
+	optimistic := make([]bool, len(blks))
 	sigSet := &bls.SignatureBatch{
 		Signatures: [][]byte{},
 		PublicKeys: []bls.PublicKey{},
@@ -268,43 +307,49 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 	var set *bls.SignatureBatch
 	boundaries := make(map[[32]byte]state.BeaconState)
 	for i, b := range blks {
+		preStateCopied := preState.Copy()
 		set, preState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
 		if err != nil {
-			return nil, nil, err
+			return nil, nil, nil, err
 		}
+		if err := s.notifyNewPayload(ctx, preStateCopied, preState, b); err != nil {
+			return nil, nil, nil, err
+		}
+
 		// Save potential boundary states.
 		if slots.IsEpochStart(preState.Slot()) {
 			boundaries[blockRoots[i]] = preState.Copy()
 			if err := s.handleEpochBoundary(ctx, preState); err != nil {
-				return nil, nil, errors.Wrap(err, "could not handle epoch boundary state")
+				return nil, nil, nil, errors.Wrap(err, "could not handle epoch boundary state")
 			}
 		}
 		jCheckpoints[i] = preState.CurrentJustifiedCheckpoint()
 		fCheckpoints[i] = preState.FinalizedCheckpoint()
+
 		sigSet.Join(set)
 	}
 	verify, err := sigSet.Verify()
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	if !verify {
-		return nil, nil, errors.New("batch block signature verification failed")
+		return nil, nil, nil, errors.New("batch block signature verification failed")
 	}
 	for r, st := range boundaries {
 		if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
-			return nil, nil, err
+			return nil, nil, nil, err
 		}
 	}
 	// Also saves the last post state which to be used as pre state for the next batch.
 	lastB := blks[len(blks)-1]
 	lastBR := blockRoots[len(blockRoots)-1]
 	if err := s.cfg.StateGen.SaveState(ctx, lastBR, preState); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	if err := s.saveHeadNoDB(ctx, lastB, lastBR, preState); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
-	return fCheckpoints, jCheckpoints, nil
+	return fCheckpoints, jCheckpoints, optimistic, nil
 }
 
 // handles a block after the block's batch has been verified, where we can save blocks
@@ -317,6 +362,9 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.
 	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
+	if _, err := s.notifyForkchoiceUpdate(ctx, b, bytesutil.ToBytes32(fCheckpoint.Root)); err != nil {
+		return err
+	}
 	if err := s.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
 		Slot: signed.Block().Slot(),
 		Root: blockRoot[:],
@@ -332,19 +380,27 @@ func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.
 		s.clearInitSyncBlocks()
 	}
 
-	if jCheckpoint.Epoch > s.justifiedCheckpt.Epoch {
+	justified := s.store.JustifiedCheckpt()
+	if justified == nil {
+		return errNilJustifiedInStore
+	}
+	if jCheckpoint.Epoch > justified.Epoch {
 		if err := s.updateJustifiedInitSync(ctx, jCheckpoint); err != nil {
 			return err
 		}
 	}
 
+	finalized := s.store.FinalizedCheckpt()
+	if finalized == nil {
+		return errNilFinalizedInStore
+	}
 	// Update finalized check point. Prune the block cache and helper caches on every new finalized epoch.
-	if fCheckpoint.Epoch > s.finalizedCheckpt.Epoch {
+	if fCheckpoint.Epoch > finalized.Epoch {
 		if err := s.updateFinalized(ctx, fCheckpoint); err != nil {
 			return err
 		}
-		s.prevFinalizedCheckpt = s.finalizedCheckpt
-		s.finalizedCheckpt = fCheckpoint
+		s.store.SetPrevFinalizedCheckpt(finalized)
+		s.store.SetFinalizedCheckpt(fCheckpoint)
 	}
 	return nil
 }
@@ -480,3 +536,12 @@ func (s *Service) pruneCanonicalAttsFromPool(ctx context.Context, r [32]byte, b
 	}
 	return nil
 }
+
+// Saves synced and validated tips to DB.
+func (s *Service) saveSyncedTipsDB(ctx context.Context) error {
+	tips := s.cfg.ForkChoiceStore.SyncedTips()
+	if len(tips) == 0 {
+		return nil
+	}
+	return s.cfg.BeaconDB.UpdateValidatedTips(ctx, tips)
+}

beacon-chain/blockchain/process_block_helpers.go

@@ -13,7 +13,6 @@ import (
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"go.opencensus.io/trace"
@@ -45,7 +44,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b block.BeaconBlock) (st
 	}
 
 	// Verify block slot time is not from the future.
-	if err := slots.VerifyTime(preState.GenesisTime(), b.Slot(), params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+	if err := slots.VerifyTime(uint64(s.genesisTime.Unix()), b.Slot(), params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
 		return nil, err
 	}
 
@@ -92,7 +91,11 @@ func (s *Service) verifyBlkPreState(ctx context.Context, b block.BeaconBlock) er
 func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.VerifyBlkDescendant")
 	defer span.End()
-	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.finalizedCheckpt.Root))
+	finalized := s.store.FinalizedCheckpt()
+	if finalized == nil {
+		return errNilFinalizedInStore
+	}
+	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
 	finalizedBlkSigned, err := s.cfg.BeaconDB.Block(ctx, fRoot)
 	if err != nil {
 		return err
@@ -110,7 +113,7 @@ func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error
 	}
 
 	if !bytes.Equal(bFinalizedRoot, fRoot[:]) {
-		err := fmt.Errorf("block %#x is not a descendent of the current finalized block slot %d, %#x != %#x",
+		err := fmt.Errorf("block %#x is not a descendant of the current finalized block slot %d, %#x != %#x",
 			bytesutil.Trunc(root[:]), finalizedBlk.Slot(), bytesutil.Trunc(bFinalizedRoot),
 			bytesutil.Trunc(fRoot[:]))
 		tracing.AnnotateError(span, err)
@@ -122,7 +125,11 @@ func (s *Service) VerifyBlkDescendant(ctx context.Context, root [32]byte) error
 // verifyBlkFinalizedSlot validates input block is not less than or equal
 // to current finalized slot.
 func (s *Service) verifyBlkFinalizedSlot(b block.BeaconBlock) error {
-	finalizedSlot, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
+	finalized := s.store.FinalizedCheckpt()
+	if finalized == nil {
+		return errNilFinalizedInStore
+	}
+	finalizedSlot, err := slots.EpochStart(finalized.Epoch)
 	if err != nil {
 		return err
 	}
@@ -160,8 +167,8 @@ func (s *Service) shouldUpdateCurrentJustified(ctx context.Context, newJustified
 	if slots.SinceEpochStarts(s.CurrentSlot()) < params.BeaconConfig().SafeSlotsToUpdateJustified {
 		return true, nil
 	}
-
-	jSlot, err := slots.EpochStart(s.justifiedCheckpt.Epoch)
+	justified := s.store.JustifiedCheckpt()
+	jSlot, err := slots.EpochStart(justified.Epoch)
 	if err != nil {
 		return false, err
 	}
@@ -170,7 +177,7 @@ func (s *Service) shouldUpdateCurrentJustified(ctx context.Context, newJustified
 	if err != nil {
 		return false, err
 	}
-	if !bytes.Equal(b, s.justifiedCheckpt.Root) {
+	if !bytes.Equal(b, justified.Root) {
 		return false, nil
 	}
 
@@ -182,8 +189,12 @@ func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaco
 	defer span.End()
 
 	cpt := state.CurrentJustifiedCheckpoint()
-	if cpt.Epoch > s.bestJustifiedCheckpt.Epoch {
-		s.bestJustifiedCheckpt = cpt
+	bestJustified := s.store.BestJustifiedCheckpt()
+	if bestJustified == nil {
+		return errNilBestJustifiedInStore
+	}
+	if cpt.Epoch > bestJustified.Epoch {
+		s.store.SetBestJustifiedCheckpt(cpt)
 	}
 	canUpdate, err := s.shouldUpdateCurrentJustified(ctx, cpt)
 	if err != nil {
@@ -191,8 +202,12 @@ func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaco
 	}
 
 	if canUpdate {
-		s.prevJustifiedCheckpt = s.justifiedCheckpt
-		s.justifiedCheckpt = cpt
+		justified := s.store.JustifiedCheckpt()
+		if justified == nil {
+			return errNilJustifiedInStore
+		}
+		s.store.SetPrevJustifiedCheckpt(justified)
+		s.store.SetJustifiedCheckpt(cpt)
 	}
 
 	return nil
@@ -202,12 +217,16 @@ func (s *Service) updateJustified(ctx context.Context, state state.ReadOnlyBeaco
 // caches justified checkpoint balances for fork choice and save justified checkpoint in DB.
 // This method does not have defense against fork choice bouncing attack, which is why it's only recommend to be used during initial syncing.
 func (s *Service) updateJustifiedInitSync(ctx context.Context, cp *ethpb.Checkpoint) error {
-	s.prevJustifiedCheckpt = s.justifiedCheckpt
+	justified := s.store.JustifiedCheckpt()
+	if justified == nil {
+		return errNilJustifiedInStore
+	}
+	s.store.SetPrevJustifiedCheckpt(justified)
 
 	if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, cp); err != nil {
 		return err
 	}
-	s.justifiedCheckpt = cp
+	s.store.SetJustifiedCheckpt(cp)
 
 	return nil
 }
@@ -308,48 +327,6 @@ func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot types.Slot)
 	return s.ancestorByDB(ctx, bytesutil.ToBytes32(b.ParentRoot()), slot)
 }
 
-// This updates justified check point in store, if the new justified is later than stored justified or
-// the store's justified is not in chain with finalized check point.
-//
-// Spec definition:
-//   # Potentially update justified if different from store
-//        if store.justified_checkpoint != state.current_justified_checkpoint:
-//            # Update justified if new justified is later than store justified
-//            if state.current_justified_checkpoint.epoch > store.justified_checkpoint.epoch:
-//                store.justified_checkpoint = state.current_justified_checkpoint
-//                return
-//            # Update justified if store justified is not in chain with finalized checkpoint
-//            finalized_slot = compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)
-//            ancestor_at_finalized_slot = get_ancestor(store, store.justified_checkpoint.root, finalized_slot)
-//            if ancestor_at_finalized_slot != store.finalized_checkpoint.root:
-//                store.justified_checkpoint = state.current_justified_checkpoint
-func (s *Service) finalizedImpliesNewJustified(ctx context.Context, state state.BeaconState) error {
-	// Update justified if it's different than the one cached in the store.
-	if !attestation.CheckPointIsEqual(s.justifiedCheckpt, state.CurrentJustifiedCheckpoint()) {
-		if state.CurrentJustifiedCheckpoint().Epoch > s.justifiedCheckpt.Epoch {
-			s.justifiedCheckpt = state.CurrentJustifiedCheckpoint()
-			// we don't need to check if the previous justified checkpoint was an ancestor since the new
-			// finalized checkpoint is overriding it.
-			return nil
-		}
-
-		// Update justified if store justified is not in chain with finalized check point.
-		finalizedSlot, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
-		if err != nil {
-			return err
-		}
-		justifiedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(s.justifiedCheckpt.Root))
-		anc, err := s.ancestor(ctx, justifiedRoot[:], finalizedSlot)
-		if err != nil {
-			return err
-		}
-		if !bytes.Equal(anc, s.finalizedCheckpt.Root) {
-			s.justifiedCheckpt = state.CurrentJustifiedCheckpoint()
-		}
-	}
-	return nil
-}
-
 // This retrieves missing blocks from DB (ie. the blocks that couldn't be received over sync) and inserts them to fork choice store.
 // This is useful for block tree visualizer and additional vote accounting.
 func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk block.BeaconBlock,
@@ -360,7 +337,11 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk block.B
 	parentRoot := bytesutil.ToBytes32(blk.ParentRoot())
 	slot := blk.Slot()
 	// Fork choice only matters from last finalized slot.
-	fSlot, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
+	finalized := s.store.FinalizedCheckpt()
+	if finalized == nil {
+		return errNilFinalizedInStore
+	}
+	fSlot, err := slots.EpochStart(finalized.Epoch)
 	if err != nil {
 		return err
 	}

beacon-chain/blockchain/process_block_test.go

@@ -25,7 +25,6 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -101,7 +100,7 @@ func TestStore_OnBlock(t *testing.T) {
 				return b
 			}(),
 			s:             st.Copy(),
-			wantErrString: "is not a descendent of the current finalized block",
+			wantErrString: "is not a descendant of the current finalized block",
 		},
 		{
 			name: "same slot as finalized block",
@@ -118,11 +117,10 @@ func TestStore_OnBlock(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			service.justifiedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
-			service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
-			service.finalizedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
-			service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
-			service.finalizedCheckpt.Root = roots[0]
+			service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
+			service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
+			service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: roots[0]})
+			service.store.SetPrevFinalizedCheckpt(&ethpb.Checkpoint{Root: validGenesisRoot[:]})
 
 			root, err := tt.blk.Block.HashTreeRoot()
 			assert.NoError(t, err)
@@ -148,9 +146,8 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.finalizedCheckpt = &ethpb.Checkpoint{
-		Root: gRoot[:],
-	}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
+
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
@@ -181,7 +178,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	rBlock.Block.ParentRoot = gRoot[:]
 	require.NoError(t, beaconDB.SaveBlock(context.Background(), blks[0]))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, blkRoots[0], firstState))
-	_, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
+	_, _, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
 	require.NoError(t, err)
 }
 
@@ -212,7 +209,7 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
-	service.justifiedCheckpt = &ethpb.Checkpoint{Root: lastJustifiedRoot[:]}
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: lastJustifiedRoot[:]})
 	update, err = service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
 	require.NoError(t, err)
 	assert.Equal(t, true, update, "Should be able to update justified")
@@ -240,7 +237,7 @@ func TestShouldUpdateJustified_ReturnFalse(t *testing.T) {
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
-	service.justifiedCheckpt = &ethpb.Checkpoint{Root: lastJustifiedRoot[:]}
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: lastJustifiedRoot[:]})
 
 	update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: newJustifiedRoot[:]})
 	require.NoError(t, err)
@@ -266,9 +263,7 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.finalizedCheckpt = &ethpb.Checkpoint{
-		Root: gRoot[:],
-	}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
@@ -296,15 +291,13 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.finalizedCheckpt = &ethpb.Checkpoint{
-		Root: gRoot[:],
-	}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
 	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
-	service.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	err = service.verifyBlkPreState(ctx, wrapper.WrappedPhase0BeaconBlock(b.Block))
 	wanted := "could not reconstruct parent state"
 	assert.ErrorContains(t, wanted, err)
@@ -333,8 +326,8 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(signedBlock)))
 	r, err := signedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	service.justifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
-	service.bestJustifiedCheckpt = &ethpb.Checkpoint{Root: []byte{'A'}}
+	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: []byte{'A'}})
+	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: []byte{'A'}})
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, st.Copy(), r))
@@ -345,13 +338,13 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	require.NoError(t, s.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{Epoch: 1, Root: r[:]}))
 	require.NoError(t, service.updateJustified(context.Background(), s))
 
-	assert.Equal(t, s.CurrentJustifiedCheckpoint().Epoch, service.bestJustifiedCheckpt.Epoch, "Incorrect justified epoch in service")
+	assert.Equal(t, s.CurrentJustifiedCheckpoint().Epoch, service.store.BestJustifiedCheckpt().Epoch, "Incorrect justified epoch in service")
 
 	// Could not update
-	service.bestJustifiedCheckpt.Epoch = 2
+	service.store.SetBestJustifiedCheckpt(&ethpb.Checkpoint{Root: []byte{'A'}, Epoch: 2})
 	require.NoError(t, service.updateJustified(context.Background(), s))
 
-	assert.Equal(t, types.Epoch(2), service.bestJustifiedCheckpt.Epoch, "Incorrect justified epoch in service")
+	assert.Equal(t, types.Epoch(2), service.store.BestJustifiedCheckpt().Epoch, "Incorrect justified epoch in service")
 }
 
 func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
@@ -365,7 +358,7 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
-	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: make([]byte, 32)})
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -406,7 +399,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
-	service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: make([]byte, 32)})
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -451,7 +444,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
 	require.NoError(t, err)
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
 	// Set finalized epoch to 1.
-	service.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 1}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 1})
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -743,89 +736,6 @@ func TestEnsureRootNotZeroHashes(t *testing.T) {
 	assert.Equal(t, root, r, "Did not get wanted justified root")
 }
 
-func TestFinalizedImpliesNewJustified(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	fcs := protoarray.New(0, 0, [32]byte{'a'})
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-		WithForkChoiceStore(fcs),
-	}
-	ctx := context.Background()
-	type args struct {
-		cachedCheckPoint        *ethpb.Checkpoint
-		stateCheckPoint         *ethpb.Checkpoint
-		diffFinalizedCheckPoint bool
-	}
-	tests := []struct {
-		name string
-		args args
-		want *ethpb.Checkpoint
-	}{
-		{
-			name: "Same justified, do nothing",
-			args: args{
-				cachedCheckPoint: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
-				stateCheckPoint:  &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
-			},
-			want: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
-		},
-		{
-			name: "Different justified, higher epoch, cache new justified",
-			args: args{
-				cachedCheckPoint: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
-				stateCheckPoint:  &ethpb.Checkpoint{Epoch: 2, Root: []byte{'b'}},
-			},
-			want: &ethpb.Checkpoint{Epoch: 2, Root: []byte{'b'}},
-		},
-		{
-			name: "finalized has different justified, cache new justified",
-			args: args{
-				cachedCheckPoint:        &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}},
-				stateCheckPoint:         &ethpb.Checkpoint{Epoch: 1, Root: []byte{'b'}},
-				diffFinalizedCheckPoint: true,
-			},
-			want: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'b'}},
-		},
-	}
-	for _, test := range tests {
-		beaconState, err := util.NewBeaconState()
-		require.NoError(t, err)
-		require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(test.args.stateCheckPoint))
-		service, err := NewService(ctx, opts...)
-		require.NoError(t, err)
-		service.justifiedCheckpt = test.args.cachedCheckPoint
-		require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo(test.want.Root, 32)}))
-		genesisState, err := util.NewBeaconState()
-		require.NoError(t, err)
-		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, genesisState, bytesutil.ToBytes32(test.want.Root)))
-
-		if test.args.diffFinalizedCheckPoint {
-			b1 := util.NewBeaconBlock()
-			b1.Block.Slot = 1
-			b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
-			r1, err := b1.Block.HashTreeRoot()
-			require.NoError(t, err)
-			b100 := util.NewBeaconBlock()
-			b100.Block.Slot = 100
-			b100.Block.ParentRoot = r1[:]
-			r100, err := b100.Block.HashTreeRoot()
-			require.NoError(t, err)
-			for _, b := range []*ethpb.SignedBeaconBlock{b1, b100} {
-				beaconBlock := util.NewBeaconBlock()
-				beaconBlock.Block.Slot = b.Block.Slot
-				beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
-				require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)))
-			}
-			service.finalizedCheckpt = &ethpb.Checkpoint{Root: []byte{'c'}, Epoch: 1}
-			service.justifiedCheckpt.Root = r100[:]
-		}
-
-		require.NoError(t, service.finalizedImpliesNewJustified(ctx, beaconState))
-		assert.Equal(t, true, attestation.CheckPointIsEqual(test.want, service.justifiedCheckpt), "Did not get wanted check point")
-	}
-}
-
 func TestVerifyBlkDescendant(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	ctx := context.Background()
@@ -879,7 +789,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
 				finalizedRoot: r1,
 				parentRoot:    r,
 			},
-			wantedErr: "is not a descendent of the current finalized block slot",
+			wantedErr: "is not a descendant of the current finalized block slot",
 		},
 		{
 			name: "is descendant",
@@ -892,9 +802,7 @@ func TestVerifyBlkDescendant(t *testing.T) {
 	for _, tt := range tests {
 		service, err := NewService(ctx, opts...)
 		require.NoError(t, err)
-		service.finalizedCheckpt = &ethpb.Checkpoint{
-			Root: tt.args.finalizedRoot[:],
-		}
+		service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: tt.args.finalizedRoot[:]})
 		err = service.VerifyBlkDescendant(ctx, tt.args.parentRoot)
 		if tt.wantedErr != "" {
 			assert.ErrorContains(t, tt.wantedErr, err)
@@ -920,12 +828,12 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, beaconState, gRoot))
 	service.originBlockRoot = gRoot
 	currentCp := &ethpb.Checkpoint{Epoch: 1}
-	service.justifiedCheckpt = currentCp
+	service.store.SetJustifiedCheckpt(currentCp)
 	newCp := &ethpb.Checkpoint{Epoch: 2, Root: gRoot[:]}
 
 	require.NoError(t, service.updateJustifiedInitSync(ctx, newCp))
 
-	assert.DeepSSZEqual(t, currentCp, service.prevJustifiedCheckpt, "Incorrect previous justified checkpoint")
+	assert.DeepSSZEqual(t, currentCp, service.PreviousJustifiedCheckpt(), "Incorrect previous justified checkpoint")
 	assert.DeepSSZEqual(t, newCp, service.CurrentJustifiedCheckpt(), "Incorrect current justified checkpoint in cache")
 	cp, err := service.cfg.BeaconDB.JustifiedCheckpoint(ctx)
 	require.NoError(t, err)
@@ -981,7 +889,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 	require.NoError(t, err)
 	gRoot, err := gBlk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	service.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 
 	testState := gs.Copy()
 	for i := types.Slot(1); i <= 4*params.BeaconConfig().SlotsPerEpoch; i++ {
@@ -1020,7 +928,7 @@ func TestInsertFinalizedDeposits(t *testing.T) {
 	require.NoError(t, err)
 	gRoot, err := gBlk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	service.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	gs = gs.Copy()
 	assert.NoError(t, gs.SetEth1Data(&ethpb.Eth1Data{DepositCount: 10}))
 	assert.NoError(t, service.cfg.StateGen.SaveState(ctx, [32]byte{'m', 'o', 'c', 'k'}, gs))
@@ -1088,3 +996,49 @@ func TestRemoveBlockAttestationsInPool_NonCanonical(t *testing.T) {
 	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	require.Equal(t, 1, service.cfg.AttPool.AggregatedAttestationCount())
 }
+
+func TestService_saveSyncedTipsDB(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+
+	b1 := util.NewBeaconBlock()
+	b1.Block.Slot = 1
+	b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
+	r1, err := b1.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b100 := util.NewBeaconBlock()
+	b100.Block.Slot = 100
+	b100.Block.ParentRoot = r1[:]
+	r100, err := b100.Block.HashTreeRoot()
+	require.NoError(t, err)
+	b200 := util.NewBeaconBlock()
+	b200.Block.Slot = 200
+	b200.Block.ParentRoot = r1[:]
+	r200, err := b200.Block.HashTreeRoot()
+	require.NoError(t, err)
+	for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
+		beaconBlock := util.NewBeaconBlock()
+		beaconBlock.Block.Slot = b.Block.Slot
+		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
+		r, err := b.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, service.cfg.ForkChoiceStore.ProcessBlock(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), [32]byte{}, 0, 0))
+	}
+
+	require.NoError(t, service.cfg.ForkChoiceStore.UpdateSyncedTipsWithValidRoot(ctx, r100))
+	require.NoError(t, service.saveSyncedTipsDB(ctx))
+	savedTips, err := service.cfg.BeaconDB.ValidatedTips(ctx)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(savedTips))
+	require.Equal(t, types.Slot(1), savedTips[r1])
+	require.Equal(t, types.Slot(100), savedTips[r100])
+
+	// Delete invalid root
+	require.NoError(t, service.cfg.ForkChoiceStore.UpdateSyncedTipsWithInvalidRoot(ctx, r200))
+	require.NoError(t, service.saveSyncedTipsDB(ctx))
+	savedTips, err = service.cfg.BeaconDB.ValidatedTips(ctx)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(savedTips))
+	require.Equal(t, types.Slot(100), savedTips[r100])
+}

beacon-chain/blockchain/receive_attestation.go

@@ -42,7 +42,7 @@ func (s *Service) ReceiveAttestationNoPubsub(ctx context.Context, att *ethpb.Att
 	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveAttestationNoPubsub")
 	defer span.End()
 
-	if err := s.onAttestation(ctx, att); err != nil {
+	if err := s.OnAttestation(ctx, att); err != nil {
 		return errors.Wrap(err, "could not process attestation")
 	}
 
@@ -88,6 +88,9 @@ func (s *Service) VerifyFinalizedConsistency(ctx context.Context, root []byte) e
 	}
 
 	f := s.FinalizedCheckpt()
+	if f == nil {
+		return errNilFinalizedInStore
+	}
 	ss, err := slots.EpochStart(f.Epoch)
 	if err != nil {
 		return err
@@ -136,6 +139,11 @@ func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
 			case <-s.ctx.Done():
 				return
 			case <-st.C():
+				if err := s.NewSlot(s.ctx, s.CurrentSlot()); err != nil {
+					log.WithError(err).Error("Could not process new slot")
+					return
+				}
+
 				// Continue when there's no fork choice attestation, there's nothing to process and update head.
 				// This covers the condition when the node is still initial syncing to the head of the chain.
 				if s.cfg.AttPool.ForkchoiceAttestationCount() == 0 {
@@ -143,9 +151,14 @@ func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
 				}
 				s.processAttestations(s.ctx)
 
-				balances, err := s.justifiedBalances.get(s.ctx, bytesutil.ToBytes32(s.justifiedCheckpt.Root))
+				justified := s.store.JustifiedCheckpt()
+				if justified == nil {
+					log.WithError(errNilJustifiedInStore).Error("Could not get justified checkpoint")
+					continue
+				}
+				balances, err := s.justifiedBalances.get(s.ctx, bytesutil.ToBytes32(justified.Root))
 				if err != nil {
-					log.WithError(err).Errorf("Unable to get justified balances for root %v", s.justifiedCheckpt.Root)
+					log.WithError(err).Errorf("Unable to get justified balances for root %v", justified.Root)
 					continue
 				}
 				if err := s.updateHead(s.ctx, balances); err != nil {

beacon-chain/blockchain/receive_block.go

@@ -53,10 +53,14 @@ func (s *Service) ReceiveBlock(ctx context.Context, block block.SignedBeaconBloc
 	}
 
 	// Reports on block and fork choice metrics.
-	reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
+	finalized := s.store.FinalizedCheckpt()
+	if finalized == nil {
+		return errNilFinalizedInStore
+	}
+	reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
 
 	// Log block sync status.
-	if err := logBlockSyncStatus(blockCopy.Block(), blockRoot, s.finalizedCheckpt, receivedTime, uint64(s.genesisTime.Unix())); err != nil {
+	if err := logBlockSyncStatus(blockCopy.Block(), blockRoot, finalized, receivedTime, uint64(s.genesisTime.Unix())); err != nil {
 		return err
 	}
 	// Log state transition data.
@@ -73,7 +77,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBe
 	defer span.End()
 
 	// Apply state transition on the incoming newly received blockCopy without verifying its BLS contents.
-	fCheckpoints, jCheckpoints, err := s.onBlockBatch(ctx, blocks, blkRoots)
+	fCheckpoints, jCheckpoints, optimistic, err := s.onBlockBatch(ctx, blocks, blkRoots)
 	if err != nil {
 		err := errors.Wrap(err, "could not process block in batch")
 		tracing.AnnotateError(span, err)
@@ -86,6 +90,19 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBe
 			tracing.AnnotateError(span, err)
 			return err
 		}
+		if !optimistic[i] {
+			root, err := b.Block().HashTreeRoot()
+			if err != nil {
+				return err
+			}
+			if err := s.cfg.ForkChoiceStore.UpdateSyncedTipsWithValidRoot(ctx, root); err != nil {
+				return err
+			}
+			if err := s.saveSyncedTipsDB(ctx); err != nil {
+				return errors.Wrap(err, "could not save synced tips")
+			}
+		}
+
 		// Send notification of the processed block to the state feed.
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.BlockProcessed,
@@ -98,13 +115,21 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []block.SignedBe
 		})
 
 		// Reports on blockCopy and fork choice metrics.
-		reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), s.finalizedCheckpt)
+		finalized := s.store.FinalizedCheckpt()
+		if finalized == nil {
+			return errNilFinalizedInStore
+		}
+		reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
 	}
 
 	if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {
 		return err
 	}
-	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, s.finalizedCheckpt.Epoch); err != nil {
+	finalized := s.store.FinalizedCheckpt()
+	if finalized == nil {
+		return errNilFinalizedInStore
+	}
+	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, finalized.Epoch); err != nil {
 		// log.Fatalf will prevent defer from being called
 		span.End()
 		// Exit run time if the node failed to verify weak subjectivity checkpoint.
@@ -148,8 +173,12 @@ func (s *Service) checkSaveHotStateDB(ctx context.Context) error {
 	currentEpoch := slots.ToEpoch(s.CurrentSlot())
 	// Prevent `sinceFinality` going underflow.
 	var sinceFinality types.Epoch
-	if currentEpoch > s.finalizedCheckpt.Epoch {
-		sinceFinality = currentEpoch - s.finalizedCheckpt.Epoch
+	finalized := s.store.FinalizedCheckpt()
+	if finalized == nil {
+		return errNilFinalizedInStore
+	}
+	if currentEpoch > finalized.Epoch {
+		sinceFinality = currentEpoch - finalized.Epoch
 	}
 
 	if sinceFinality >= epochsSinceFinalitySaveHotStateDB {

beacon-chain/blockchain/receive_block_test.go

@@ -140,7 +140,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 			require.NoError(t, err)
 			gRoot, err := gBlk.Block().HashTreeRoot()
 			require.NoError(t, err)
-			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
 			err = s.ReceiveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block), root)
@@ -178,7 +178,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	require.NoError(t, err)
 	gRoot, err := gBlk.Block().HashTreeRoot()
 	require.NoError(t, err)
-	s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	wg := sync.WaitGroup{}
@@ -257,7 +257,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 
 			gRoot, err := gBlk.Block().HashTreeRoot()
 			require.NoError(t, err)
-			s.finalizedCheckpt = &ethpb.Checkpoint{Root: gRoot[:]}
+			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
 			blks := []block.SignedBeaconBlock{wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block)}
@@ -295,7 +295,7 @@ func TestCheckSaveHotStateDB_Enabling(t *testing.T) {
 	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.finalizedCheckpt = &ethpb.Checkpoint{}
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{})
 
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	assert.LogsContain(t, hook, "Entering mode to save hot states in DB")
@@ -306,7 +306,7 @@ func TestCheckSaveHotStateDB_Disabling(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	s, err := NewService(context.Background(), opts...)
 	require.NoError(t, err)
-	s.finalizedCheckpt = &ethpb.Checkpoint{}
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{})
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	s.genesisTime = time.Now()
 
@@ -319,7 +319,7 @@ func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	s, err := NewService(context.Background(), opts...)
 	require.NoError(t, err)
-	s.finalizedCheckpt = &ethpb.Checkpoint{Epoch: 10000000}
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 10000000})
 	s.genesisTime = time.Now()
 
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))

beacon-chain/blockchain/service.go

@@ -12,6 +12,7 @@ import (
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/async/event"
+	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain/store"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
@@ -26,6 +27,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
+	enginev1 "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
@@ -54,11 +56,6 @@ type Service struct {
 	headLock    sync.RWMutex
 	// originBlockRoot is the genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
 	originBlockRoot       [32]byte
-	justifiedCheckpt      *ethpb.Checkpoint
-	prevJustifiedCheckpt  *ethpb.Checkpoint
-	bestJustifiedCheckpt  *ethpb.Checkpoint
-	finalizedCheckpt      *ethpb.Checkpoint
-	prevFinalizedCheckpt  *ethpb.Checkpoint
 	nextEpochBoundarySlot types.Slot
 	boundaryRoots         [][32]byte
 	checkpointStateCache  *cache.CheckpointStateCache
@@ -66,6 +63,7 @@ type Service struct {
 	initSyncBlocksLock    sync.RWMutex
 	justifiedBalances     *stateBalanceCache
 	wsVerifier            *WeakSubjectivityVerifier
+	store                 *store.Store
 }
 
 // config options for the service.
@@ -85,7 +83,9 @@ type config struct {
 	StateGen                *stategen.State
 	SlasherAttestationsFeed *event.Feed
 	WeakSubjectivityCheckpt *ethpb.Checkpoint
+	BlockFetcher            powchain.POWBlockFetcher
 	FinalizedStateAtStartUp state.BeaconState
+	ExecutionEngineCaller   enginev1.Caller
 }
 
 // NewService instantiates a new block service instance that will
@@ -99,6 +99,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		checkpointStateCache: cache.NewCheckpointStateCache(),
 		initSyncBlocks:       make(map[[32]byte]block.SignedBeaconBlock),
 		cfg:                  &config{},
+		store:                &store.Store{},
 	}
 	for _, opt := range opts {
 		if err := opt(srv); err != nil {
@@ -180,21 +181,20 @@ func (s *Service) startFromSavedState(saved state.BeaconState) error {
 	if err != nil {
 		return errors.Wrap(err, "could not get justified checkpoint")
 	}
-	s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(justified)
-	s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(justified)
-	s.justifiedCheckpt = ethpb.CopyCheckpoint(justified)
-
 	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint")
 	}
-	s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(finalized)
-	s.finalizedCheckpt = ethpb.CopyCheckpoint(finalized)
+	s.store = store.New(justified, finalized)
 
 	store := protoarray.New(justified.Epoch, finalized.Epoch, bytesutil.ToBytes32(finalized.Root))
 	s.cfg.ForkChoiceStore = store
 
-	ss, err := slots.EpochStart(s.finalizedCheckpt.Epoch)
+	if err := s.loadSyncedTips(originRoot, saved.Slot()); err != nil {
+		return err
+	}
+
+	ss, err := slots.EpochStart(finalized.Epoch)
 	if err != nil {
 		return errors.Wrap(err, "could not get start slot of finalized epoch")
 	}
@@ -204,14 +204,14 @@ func (s *Service) startFromSavedState(saved state.BeaconState) error {
 			"startSlot": ss,
 			"endSlot":   h.Slot(),
 		}).Info("Loading blocks to fork choice store, this may take a while.")
-		if err := s.fillInForkChoiceMissingBlocks(s.ctx, h, s.finalizedCheckpt, s.justifiedCheckpt); err != nil {
+		if err := s.fillInForkChoiceMissingBlocks(s.ctx, h, finalized, justified); err != nil {
 			return errors.Wrap(err, "could not fill in fork choice store missing blocks")
 		}
 	}
 
 	// not attempting to save initial sync blocks here, because there shouldn't be any until
 	// after the statefeed.Initialized event is fired (below)
-	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, s.finalizedCheckpt.Epoch); err != nil {
+	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, finalized.Epoch); err != nil {
 		// Exit run time if the node failed to verify weak subjectivity checkpoint.
 		return errors.Wrap(err, "could not verify initial checkpoint provided for chain sync")
 	}
@@ -220,7 +220,7 @@ func (s *Service) startFromSavedState(saved state.BeaconState) error {
 		Type: statefeed.Initialized,
 		Data: &statefeed.InitializedData{
 			StartTime:             s.genesisTime,
-			GenesisValidatorsRoot: saved.GenesisValidatorRoot(),
+			GenesisValidatorsRoot: saved.GenesisValidatorsRoot(),
 		},
 	})
 
@@ -382,7 +382,7 @@ func (s *Service) onPowchainStart(ctx context.Context, genesisTime time.Time) {
 		Type: statefeed.Initialized,
 		Data: &statefeed.InitializedData{
 			StartTime:             genesisTime,
-			GenesisValidatorsRoot: initializedState.GenesisValidatorRoot(),
+			GenesisValidatorsRoot: initializedState.GenesisValidatorsRoot(),
 		},
 	})
 }
@@ -446,12 +446,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 
 	// Finalized checkpoint at genesis is a zero hash.
 	genesisCheckpoint := genesisState.FinalizedCheckpoint()
-
-	s.justifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
-	s.prevJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
-	s.bestJustifiedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
-	s.finalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
-	s.prevFinalizedCheckpt = ethpb.CopyCheckpoint(genesisCheckpoint)
+	s.store = store.New(genesisCheckpoint, genesisCheckpoint)
 
 	if err := s.cfg.ForkChoiceStore.ProcessBlock(ctx,
 		genesisBlk.Block().Slot(),

beacon-chain/blockchain/service_test.go

@@ -8,7 +8,9 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/async/event"
+	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain/store"
 	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
@@ -162,6 +164,74 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	require.LogsContain(t, hook, "data already exists")
 }
 
+func TestChainStart_SyncedTipsInDB(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	chainService := setupBeaconChain(t, beaconDB)
+
+	genesisBlk := util.NewBeaconBlock()
+	blkRoot, err := genesisBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
+	s, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, s.SetSlot(1))
+	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
+	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, blkRoot))
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
+	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+	chainService.cfg.FinalizedStateAtStartUp = s
+
+	tips := make(map[[32]byte]types.Slot)
+	tips[bytesutil.ToBytes32([]byte{'a'})] = 1
+	tips[bytesutil.ToBytes32([]byte{'b'})] = 2
+	require.NoError(t, beaconDB.UpdateValidatedTips(ctx, tips))
+
+	// Test the start function.
+	chainService.Start()
+
+	// Test synced Tips in DB
+	tips2 := chainService.cfg.ForkChoiceStore.SyncedTips()
+	require.Equal(t, len(tips2), len(tips))
+	for k, v := range tips {
+		v2, ok := tips2[k]
+		require.Equal(t, true, ok)
+		require.Equal(t, v, v2)
+	}
+}
+
+func TestChainStart_SyncedTipsNotInDB(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+
+	chainService := setupBeaconChain(t, beaconDB)
+
+	genesisBlk := util.NewBeaconBlock()
+	blkRoot, err := genesisBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
+	s, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, s.SetSlot(1))
+	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
+	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, blkRoot))
+	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
+	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
+	chainService.cfg.FinalizedStateAtStartUp = s
+	// Test the start function.
+	chainService.Start()
+
+	// Test synced Tips in DB
+	tips := chainService.cfg.ForkChoiceStore.SyncedTips()
+	require.Equal(t, 1, len(tips))
+	slot, ok := tips[blkRoot]
+	require.Equal(t, true, ok)
+	require.Equal(t, types.Slot(1), slot)
+}
+
 func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctx := context.Background()
@@ -253,8 +323,8 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
 	// Test the start function.
 	chainService.Start()
 
-	require.DeepEqual(t, blkRoot[:], chainService.finalizedCheckpt.Root, "Finalize Checkpoint root is incorrect")
-	require.DeepEqual(t, params.BeaconConfig().ZeroHash[:], chainService.justifiedCheckpt.Root, "Justified Checkpoint root is incorrect")
+	require.DeepEqual(t, blkRoot[:], chainService.store.FinalizedCheckpt().Root, "Finalize Checkpoint root is incorrect")
+	require.DeepEqual(t, params.BeaconConfig().ZeroHash[:], chainService.store.JustifiedCheckpt().Root, "Justified Checkpoint root is incorrect")
 
 	require.NoError(t, chainService.Stop(), "Unable to stop chain service")
 
@@ -277,7 +347,7 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
-	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
@@ -321,7 +391,7 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(finalizedSlot))
-	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
@@ -377,7 +447,7 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(headBlock.Block.Slot))
-	require.NoError(t, headState.SetGenesisValidatorRoot(params.BeaconConfig().ZeroHash[:]))
+	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, finalizedRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
@@ -449,9 +519,10 @@ func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	s := &Service{
-		cfg:              &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
-		finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
+		cfg:   &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
+		store: &store.Store{},
 	}
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
 	block := util.NewBeaconBlock()
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -515,9 +586,10 @@ func BenchmarkHasBlockForkChoiceStore(b *testing.B) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(b)
 	s := &Service{
-		cfg:              &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
-		finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
+		cfg:   &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{}), BeaconDB: beaconDB},
+		store: &store.Store{},
 	}
+	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
 	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)

beacon-chain/blockchain/state_balance_cache.go

@@ -73,7 +73,8 @@ func (c *stateBalanceCache) update(ctx context.Context, justifiedRoot [32]byte)
 func (c *stateBalanceCache) get(ctx context.Context, justifiedRoot [32]byte) ([]uint64, error) {
 	c.Lock()
 	defer c.Unlock()
-	if justifiedRoot == c.root {
+
+	if justifiedRoot != [32]byte{} && justifiedRoot == c.root {
 		stateBalanceCacheHit.Inc()
 		return c.balances, nil
 	}

beacon-chain/blockchain/state_balance_cache_test.go

@@ -150,7 +150,6 @@ func TestStateBalanceCache(t *testing.T) {
 		{
 			sbc: &stateBalanceCache{
 				stateGen: &mockStateByRooter{
-					//state: generateTestValidators(1, testWithBadEpoch),
 					err: sentinelCacheMiss,
 				},
 				root: bytesutil.ToBytes32([]byte{'B'}),
@@ -204,6 +203,18 @@ func TestStateBalanceCache(t *testing.T) {
 			root:     bytesutil.ToBytes32([]byte{'A'}),
 			name:     "happy path",
 		},
+		{
+			sbc: &stateBalanceCache{
+				stateGen: &mockStateByRooter{
+					state: testStateFixture(
+						testStateWithSlot(99),
+						testStateWithValidators(allValidValidators)),
+				},
+			},
+			balances: allValidBalances,
+			root:     [32]byte{},
+			name:     "zero root",
+		},
 	}
 	ctx := context.Background()
 	for _, c := range cases {

beacon-chain/blockchain/store/BUILD.bazel

@@ -0,0 +1,27 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "new.go",
+        "setter_getter.go",
+        "type.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/store",
+    visibility = ["//beacon-chain:__subpackages__"],
+    deps = ["//proto/prysm/v1alpha1:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "new_test.go",
+        "setter_getter_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+    ],
+)

beacon-chain/blockchain/store/doc.go

@@ -0,0 +1,4 @@
+// Package store implements the store object defined in the phase0 fork choice spec.
+// It serves as a helpful middleware layer in between blockchain pkg and fork choice protoarray pkg.
+// All the getters and setters are concurrent thread safe
+package store

beacon-chain/blockchain/store/new.go

@@ -0,0 +1,15 @@
+package store
+
+import (
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+)
+
+func New(justifiedCheckpt *ethpb.Checkpoint, finalizedCheckpt *ethpb.Checkpoint) *Store {
+	return &Store{
+		justifiedCheckpt:     justifiedCheckpt,
+		prevJustifiedCheckpt: justifiedCheckpt,
+		bestJustifiedCheckpt: justifiedCheckpt,
+		finalizedCheckpt:     finalizedCheckpt,
+		prevFinalizedCheckpt: finalizedCheckpt,
+	}
+}

beacon-chain/blockchain/store/new_test.go

@@ -0,0 +1,25 @@
+package store
+
+import (
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/testing/require"
+)
+
+func TestNew(t *testing.T) {
+	j := &ethpb.Checkpoint{
+		Epoch: 0,
+		Root:  []byte("hi"),
+	}
+	f := &ethpb.Checkpoint{
+		Epoch: 0,
+		Root:  []byte("hello"),
+	}
+	s := New(j, f)
+	require.DeepSSZEqual(t, s.JustifiedCheckpt(), j)
+	require.DeepSSZEqual(t, s.BestJustifiedCheckpt(), j)
+	require.DeepSSZEqual(t, s.PrevJustifiedCheckpt(), j)
+	require.DeepSSZEqual(t, s.FinalizedCheckpt(), f)
+	require.DeepSSZEqual(t, s.PrevFinalizedCheckpt(), f)
+}

beacon-chain/blockchain/store/setter_getter.go

@@ -0,0 +1,73 @@
+package store
+
+import ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+
+// PrevJustifiedCheckpt returns the previous justified checkpoint in the Store.
+func (s *Store) PrevJustifiedCheckpt() *ethpb.Checkpoint {
+	s.RLock()
+	defer s.RUnlock()
+	return s.prevJustifiedCheckpt
+}
+
+// BestJustifiedCheckpt returns the best justified checkpoint in the Store.
+func (s *Store) BestJustifiedCheckpt() *ethpb.Checkpoint {
+	s.RLock()
+	defer s.RUnlock()
+	return s.bestJustifiedCheckpt
+}
+
+// JustifiedCheckpt returns the justified checkpoint in the Store.
+func (s *Store) JustifiedCheckpt() *ethpb.Checkpoint {
+	s.RLock()
+	defer s.RUnlock()
+	return s.justifiedCheckpt
+}
+
+// PrevFinalizedCheckpt returns the previous finalized checkpoint in the Store.
+func (s *Store) PrevFinalizedCheckpt() *ethpb.Checkpoint {
+	s.RLock()
+	defer s.RUnlock()
+	return s.prevFinalizedCheckpt
+}
+
+// FinalizedCheckpt returns the finalized checkpoint in the Store.
+func (s *Store) FinalizedCheckpt() *ethpb.Checkpoint {
+	s.RLock()
+	defer s.RUnlock()
+	return s.finalizedCheckpt
+}
+
+// SetPrevJustifiedCheckpt sets the previous justified checkpoint in the Store.
+func (s *Store) SetPrevJustifiedCheckpt(cp *ethpb.Checkpoint) {
+	s.Lock()
+	defer s.Unlock()
+	s.prevJustifiedCheckpt = cp
+}
+
+// SetBestJustifiedCheckpt sets the best justified checkpoint in the Store.
+func (s *Store) SetBestJustifiedCheckpt(cp *ethpb.Checkpoint) {
+	s.Lock()
+	defer s.Unlock()
+	s.bestJustifiedCheckpt = cp
+}
+
+// SetJustifiedCheckpt sets the justified checkpoint in the Store.
+func (s *Store) SetJustifiedCheckpt(cp *ethpb.Checkpoint) {
+	s.Lock()
+	defer s.Unlock()
+	s.justifiedCheckpt = cp
+}
+
+// SetFinalizedCheckpt sets the finalized checkpoint in the Store.
+func (s *Store) SetFinalizedCheckpt(cp *ethpb.Checkpoint) {
+	s.Lock()
+	defer s.Unlock()
+	s.finalizedCheckpt = cp
+}
+
+// SetPrevFinalizedCheckpt sets the previous finalized checkpoint in the Store.
+func (s *Store) SetPrevFinalizedCheckpt(cp *ethpb.Checkpoint) {
+	s.Lock()
+	defer s.Unlock()
+	s.prevFinalizedCheckpt = cp
+}

beacon-chain/blockchain/store/setter_getter_test.go

@@ -0,0 +1,53 @@
+package store
+
+import (
+	"testing"
+
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/testing/require"
+)
+
+func Test_store_PrevJustifiedCheckpt(t *testing.T) {
+	s := &Store{}
+	var cp *ethpb.Checkpoint
+	require.Equal(t, cp, s.PrevJustifiedCheckpt())
+	cp = &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}}
+	s.SetPrevJustifiedCheckpt(cp)
+	require.Equal(t, cp, s.PrevJustifiedCheckpt())
+}
+
+func Test_store_BestJustifiedCheckpt(t *testing.T) {
+	s := &Store{}
+	var cp *ethpb.Checkpoint
+	require.Equal(t, cp, s.BestJustifiedCheckpt())
+	cp = &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}}
+	s.SetBestJustifiedCheckpt(cp)
+	require.Equal(t, cp, s.BestJustifiedCheckpt())
+}
+
+func Test_store_JustifiedCheckpt(t *testing.T) {
+	s := &Store{}
+	var cp *ethpb.Checkpoint
+	require.Equal(t, cp, s.JustifiedCheckpt())
+	cp = &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}}
+	s.SetJustifiedCheckpt(cp)
+	require.Equal(t, cp, s.JustifiedCheckpt())
+}
+
+func Test_store_FinalizedCheckpt(t *testing.T) {
+	s := &Store{}
+	var cp *ethpb.Checkpoint
+	require.Equal(t, cp, s.FinalizedCheckpt())
+	cp = &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}}
+	s.SetFinalizedCheckpt(cp)
+	require.Equal(t, cp, s.FinalizedCheckpt())
+}
+
+func Test_store_PrevFinalizedCheckpt(t *testing.T) {
+	s := &Store{}
+	var cp *ethpb.Checkpoint
+	require.Equal(t, cp, s.PrevFinalizedCheckpt())
+	cp = &ethpb.Checkpoint{Epoch: 1, Root: []byte{'a'}}
+	s.SetPrevFinalizedCheckpt(cp)
+	require.Equal(t, cp, s.PrevFinalizedCheckpt())
+}

beacon-chain/blockchain/store/type.go

@@ -0,0 +1,28 @@
+package store
+
+import (
+	"sync"
+
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+)
+
+// Store is defined in the fork choice consensus spec for tracking current time and various versions of checkpoints.
+//
+// Spec code:
+// class Store(object):
+//    time: uint64
+//    genesis_time: uint64
+//    justified_checkpoint: Checkpoint
+//    finalized_checkpoint: Checkpoint
+//    best_justified_checkpoint: Checkpoint
+//    proposerBoostRoot: Root
+type Store struct {
+	justifiedCheckpt     *ethpb.Checkpoint
+	finalizedCheckpt     *ethpb.Checkpoint
+	bestJustifiedCheckpt *ethpb.Checkpoint
+	sync.RWMutex
+	// These are not part of the consensus spec, but we do use them to return gRPC API requests.
+	// TODO(10094): Consider removing in v3.
+	prevFinalizedCheckpt *ethpb.Checkpoint
+	prevJustifiedCheckpt *ethpb.Checkpoint
+}

beacon-chain/blockchain/testing/BUILD.bazel

@@ -20,7 +20,6 @@ go_library(
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/v1:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/blockchain/testing/mock.go

@@ -20,7 +20,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
@@ -29,36 +28,39 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+var ErrNilState = errors.New("nil state")
+
 // ChainService defines the mock interface for testing
 type ChainService struct {
-	State                       state.BeaconState
-	Root                        []byte
-	Block                       block.SignedBeaconBlock
+	Optimistic                  bool
+	ValidAttestation            bool
+	ValidatorsRoot              [32]byte
+	PublicKey                   [fieldparams.BLSPubkeyLength]byte
 	FinalizedCheckPoint         *ethpb.Checkpoint
 	CurrentJustifiedCheckPoint  *ethpb.Checkpoint
 	PreviousJustifiedCheckPoint *ethpb.Checkpoint
-	BlocksReceived              []block.SignedBeaconBlock
+	Slot                        *types.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
 	Balance                     *precompute.Balance
-	Genesis                     time.Time
-	ValidatorsRoot              [32]byte
+	ForkChoiceStore             *protoarray.Store
 	CanonicalRoots              map[[32]byte]bool
 	Fork                        *ethpb.Fork
 	ETH1Data                    *ethpb.Eth1Data
+	InitSyncBlockRoots          map[[32]byte]bool
 	DB                          db.Database
+	State                       state.BeaconState
+	Block                       block.SignedBeaconBlock
+	VerifyBlkDescendantErr      error
 	stateNotifier               statefeed.Notifier
+	BlocksReceived              []block.SignedBeaconBlock
+	SyncCommitteeIndices        []types.CommitteeIndex
 	blockNotifier               blockfeed.Notifier
 	opNotifier                  opfeed.Notifier
-	ValidAttestation            bool
-	ForkChoiceStore             *protoarray.Store
-	VerifyBlkDescendantErr      error
-	Slot                        *types.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
-	SyncCommitteeIndices        []types.CommitteeIndex
+	Root                        []byte
 	SyncCommitteeDomain         []byte
 	SyncSelectionProofDomain    []byte
 	SyncContributionProofDomain []byte
-	PublicKey                   [fieldparams.BLSPubkeyLength]byte
 	SyncCommitteePubkeys        [][]byte
-	InitSyncBlockRoots          map[[32]byte]bool
+	Genesis                     time.Time
 }
 
 // StateNotifier mocks the same method in the chain service.
@@ -159,7 +161,7 @@ func (mon *MockOperationNotifier) OperationFeed() *event.Feed {
 // ReceiveBlockInitialSync mocks ReceiveBlockInitialSync method in chain service.
 func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block block.SignedBeaconBlock, _ [32]byte) error {
 	if s.State == nil {
-		s.State = &v1.BeaconState{}
+		return ErrNilState
 	}
 	if !bytes.Equal(s.Root, block.Block().ParentRoot()) {
 		return errors.Errorf("wanted %#x but got %#x", s.Root, block.Block().ParentRoot())
@@ -186,7 +188,7 @@ func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block block.
 // ReceiveBlockBatch processes blocks in batches from initial-sync.
 func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []block.SignedBeaconBlock, _ [][32]byte) error {
 	if s.State == nil {
-		s.State = &v1.BeaconState{}
+		return ErrNilState
 	}
 	for _, block := range blks {
 		if !bytes.Equal(s.Root, block.Block().ParentRoot()) {
@@ -215,7 +217,7 @@ func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []block.Signe
 // ReceiveBlock mocks ReceiveBlock method in chain service.
 func (s *ChainService) ReceiveBlock(ctx context.Context, block block.SignedBeaconBlock, _ [32]byte) error {
 	if s.State == nil {
-		s.State = &v1.BeaconState{}
+		return ErrNilState
 	}
 	if !bytes.Equal(s.Root, block.Block().ParentRoot()) {
 		return errors.Errorf("wanted %#x but got %#x", s.Root, block.Block().ParentRoot())
@@ -328,8 +330,8 @@ func (s *ChainService) GenesisTime() time.Time {
 	return s.Genesis
 }
 
-// GenesisValidatorRoot mocks the same method in the chain service.
-func (s *ChainService) GenesisValidatorRoot() [32]byte {
+// GenesisValidatorsRoot mocks the same method in the chain service.
+func (s *ChainService) GenesisValidatorsRoot() [32]byte {
 	return s.ValidatorsRoot
 }
 
@@ -369,8 +371,8 @@ func (s *ChainService) HasInitSyncBlock(rt [32]byte) bool {
 	return s.InitSyncBlockRoots[rt]
 }
 
-// HeadGenesisValidatorRoot mocks HeadGenesisValidatorRoot method in chain service.
-func (_ *ChainService) HeadGenesisValidatorRoot() [32]byte {
+// HeadGenesisValidatorsRoot mocks HeadGenesisValidatorsRoot method in chain service.
+func (_ *ChainService) HeadGenesisValidatorsRoot() [32]byte {
 	return [32]byte{}
 }
 
@@ -438,3 +440,13 @@ func (s *ChainService) HeadSyncSelectionProofDomain(_ context.Context, _ types.S
 func (s *ChainService) HeadSyncContributionProofDomain(_ context.Context, _ types.Slot) ([]byte, error) {
 	return s.SyncContributionProofDomain, nil
 }
+
+// IsOptimistic mocks the same method in the chain service.
+func (s *ChainService) IsOptimistic(_ context.Context) (bool, error) {
+	return s.Optimistic, nil
+}
+
+// IsOptimisticForRoot mocks the same method in the chain service.
+func (s *ChainService) IsOptimisticForRoot(_ context.Context, _ [32]byte, _ types.Slot) (bool, error) {
+	return false, nil
+}

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain/store"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
@@ -67,11 +68,12 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 			wv, err := NewWeakSubjectivityVerifier(tt.checkpt, beaconDB)
 			require.NoError(t, err)
 			s := &Service{
-				cfg:              &config{BeaconDB: beaconDB, WeakSubjectivityCheckpt: tt.checkpt},
-				finalizedCheckpt: &ethpb.Checkpoint{Epoch: tt.finalizedEpoch},
-				wsVerifier:       wv,
+				cfg:        &config{BeaconDB: beaconDB, WeakSubjectivityCheckpt: tt.checkpt},
+				store:      &store.Store{},
+				wsVerifier: wv,
 			}
-			err = s.wsVerifier.VerifyWeakSubjectivity(context.Background(), s.finalizedCheckpt.Epoch)
+			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: tt.finalizedEpoch})
+			err = s.wsVerifier.VerifyWeakSubjectivity(context.Background(), s.store.FinalizedCheckpt().Epoch)
 			if tt.wantErr == nil {
 				require.NoError(t, err)
 			} else {

beacon-chain/cache/BUILD.bazel

@@ -30,9 +30,6 @@ go_library(
     ],
     deps = [
         "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/v1:go_default_library",
-        "//beacon-chain/state/v2:go_default_library",
-        "//beacon-chain/state/v3:go_default_library",
         "//cache/lru:go_default_library",
         "//config/features:go_default_library",
         "//config/params:go_default_library",
@@ -42,6 +39,7 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "@com_github_hashicorp_golang_lru//:go_default_library",
         "@com_github_patrickmn_go_cache//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/cache/depositcache/BUILD.bazel

@@ -8,7 +8,10 @@ go_library(
         "pending_deposits.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache",
-    visibility = ["//beacon-chain:__subpackages__"],
+    visibility = [
+        "//beacon-chain:__subpackages__",
+        "//testing/spectest:__subpackages__",
+    ],
     deps = [
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

beacon-chain/cache/depositcache/deposits_cache.go

@@ -180,6 +180,10 @@ func (dc *DepositCache) AllDeposits(ctx context.Context, untilBlk *big.Int) []*e
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
 
+	return dc.allDeposits(untilBlk)
+}
+
+func (dc *DepositCache) allDeposits(untilBlk *big.Int) []*ethpb.Deposit {
 	var deposits []*ethpb.Deposit
 	for _, ctnr := range dc.deposits {
 		if untilBlk == nil || untilBlk.Uint64() >= ctnr.Eth1BlockHeight {
@@ -249,7 +253,7 @@ func (dc *DepositCache) NonFinalizedDeposits(ctx context.Context, untilBlk *big.
 	defer dc.depositsLock.RUnlock()
 
 	if dc.finalizedDeposits == nil {
-		return dc.AllDeposits(ctx, untilBlk)
+		return dc.allDeposits(untilBlk)
 	}
 
 	lastFinalizedDepositIndex := dc.finalizedDeposits.MerkleTrieIndex

beacon-chain/cache/sync_committee_head_state.go

@@ -6,10 +6,8 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
-	v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3"
 	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 )
 
 // SyncCommitteeHeadStateCache for the latest head state requested by a sync committee participant.
@@ -34,8 +32,7 @@ func (c *SyncCommitteeHeadStateCache) Put(slot types.Slot, st state.BeaconState)
 		return ErrNilValueProvided
 	}
 
-	_, ok := st.(*v1.BeaconState)
-	if ok {
+	if st.Version() == version.Phase0 {
 		return ErrIncorrectType
 	}
 
@@ -51,13 +48,14 @@ func (c *SyncCommitteeHeadStateCache) Get(slot types.Slot) (state.BeaconState, e
 	if !exists {
 		return nil, ErrNotFound
 	}
-	var st state.BeaconState
-	st, ok := val.(*v2.BeaconState)
+	st, ok := val.(state.BeaconState)
 	if !ok {
-		st, ok = val.(*v3.BeaconState)
-		if !ok {
-			return nil, ErrIncorrectType
-		}
+		return nil, ErrIncorrectType
+	}
+	switch st.Version() {
+	case version.Altair, version.Bellatrix:
+	default:
+		return nil, ErrIncorrectType
 	}
 	return st, nil
 }

beacon-chain/core/altair/block.go

@@ -102,7 +102,7 @@ func FilterSyncCommitteeVotes(s state.BeaconStateAltair, sync *ethpb.SyncAggrega
 // VerifySyncCommitteeSig verifies sync committee signature `syncSig` is valid with respect to public keys `syncKeys`.
 func VerifySyncCommitteeSig(s state.BeaconStateAltair, syncKeys []bls.PublicKey, syncSig []byte) error {
 	ps := slots.PrevSlot(s.Slot())
-	d, err := signing.Domain(s.Fork(), slots.ToEpoch(ps), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorRoot())
+	d, err := signing.Domain(s.Fork(), slots.ToEpoch(ps), params.BeaconConfig().DomainSyncCommittee, s.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}

beacon-chain/core/altair/epoch_precompute.go

@@ -274,7 +274,7 @@ func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, v
 	case version.Altair:
 		inactivityDenominator = bias * cfg.InactivityPenaltyQuotientAltair
 	case version.Bellatrix:
-		inactivityDenominator = bias * cfg.InactivityPenaltyQuotientMerge
+		inactivityDenominator = bias * cfg.InactivityPenaltyQuotientBellatrix
 	default:
 		return nil, nil, errors.Errorf("invalid state type version: %T", beaconState.Version())
 	}

beacon-chain/core/altair/sync_committee_test.go

@@ -8,7 +8,9 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
+	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -18,7 +20,7 @@ import (
 )
 
 func TestSyncCommitteeIndices_CanGet(t *testing.T) {
-	getState := func(t *testing.T, count uint64) *stateAltair.BeaconState {
+	getState := func(t *testing.T, count uint64) state.BeaconStateAltair {
 		validators := make([]*ethpb.Validator, count)
 		for i := 0; i < len(validators); i++ {
 			validators[i] = &ethpb.Validator{
@@ -35,7 +37,7 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 	}
 
 	type args struct {
-		state *stateAltair.BeaconState
+		state state.BeaconStateAltair
 		epoch types.Epoch
 	}
 	tests := []struct {
@@ -45,9 +47,9 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 		errString string
 	}{
 		{
-			name: "nil state",
+			name: "nil inner state",
 			args: args{
-				state: nil,
+				state: &v2.BeaconState{},
 			},
 			wantErr:   true,
 			errString: "nil inner state",
@@ -93,7 +95,7 @@ func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 
 func TestSyncCommitteeIndices_DifferentPeriods(t *testing.T) {
 	helpers.ClearCache()
-	getState := func(t *testing.T, count uint64) *stateAltair.BeaconState {
+	getState := func(t *testing.T, count uint64) state.BeaconStateAltair {
 		validators := make([]*ethpb.Validator, count)
 		for i := 0; i < len(validators); i++ {
 			validators[i] = &ethpb.Validator{
@@ -127,7 +129,7 @@ func TestSyncCommitteeIndices_DifferentPeriods(t *testing.T) {
 }
 
 func TestSyncCommittee_CanGet(t *testing.T) {
-	getState := func(t *testing.T, count uint64) *stateAltair.BeaconState {
+	getState := func(t *testing.T, count uint64) state.BeaconStateAltair {
 		validators := make([]*ethpb.Validator, count)
 		for i := 0; i < len(validators); i++ {
 			blsKey, err := bls.RandKey()
@@ -147,7 +149,7 @@ func TestSyncCommittee_CanGet(t *testing.T) {
 	}
 
 	type args struct {
-		state *stateAltair.BeaconState
+		state state.BeaconStateAltair
 		epoch types.Epoch
 	}
 	tests := []struct {
@@ -157,9 +159,9 @@ func TestSyncCommittee_CanGet(t *testing.T) {
 		errString string
 	}{
 		{
-			name: "nil state",
+			name: "nil inner state",
 			args: args{
-				state: nil,
+				state: &v2.BeaconState{},
 			},
 			wantErr:   true,
 			errString: "nil inner state",
@@ -382,7 +384,7 @@ func Test_ValidateSyncMessageTime(t *testing.T) {
 	}
 }
 
-func getState(t *testing.T, count uint64) *stateAltair.BeaconState {
+func getState(t *testing.T, count uint64) state.BeaconStateAltair {
 	validators := make([]*ethpb.Validator, count)
 	for i := 0; i < len(validators); i++ {
 		blsKey, err := bls.RandKey()

beacon-chain/core/altair/transition.go

@@ -78,7 +78,7 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			return nil, err
 		}
 	case version.Bellatrix:
-		state, err = e.ProcessSlashings(state, cfg.ProportionalSlashingMultiplierMerge)
+		state, err = e.ProcessSlashings(state, cfg.ProportionalSlashingMultiplierBellatrix)
 		if err != nil {
 			return nil, err
 		}

beacon-chain/core/altair/transition_test.go

@@ -43,7 +43,7 @@ func TestProcessEpoch_CanProcess(t *testing.T) {
 }
 
 func TestProcessEpoch_CanProcessBellatrix(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateMerge(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	st, _ := util.DeterministicGenesisStateBellatrix(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch))
 	newState, err := altair.ProcessEpoch(context.Background(), st)
 	require.NoError(t, err)

beacon-chain/core/altair/upgrade.go

@@ -68,7 +68,7 @@ func UpgradeToAltair(ctx context.Context, state state.BeaconState) (state.Beacon
 	numValidators := state.NumValidators()
 	s := &ethpb.BeaconStateAltair{
 		GenesisTime:           state.GenesisTime(),
-		GenesisValidatorsRoot: state.GenesisValidatorRoot(),
+		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
 		Slot:                  state.Slot(),
 		Fork: &ethpb.Fork{
 			PreviousVersion: state.Fork().CurrentVersion,
@@ -137,7 +137,7 @@ func UpgradeToAltair(ctx context.Context, state state.BeaconState) (state.Beacon
 //        for index in get_attesting_indices(state, data, attestation.aggregation_bits):
 //            for flag_index in participation_flag_indices:
 //                epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
-func TranslateParticipation(ctx context.Context, state *statealtair.BeaconState, atts []*ethpb.PendingAttestation) (*statealtair.BeaconState, error) {
+func TranslateParticipation(ctx context.Context, state state.BeaconStateAltair, atts []*ethpb.PendingAttestation) (state.BeaconStateAltair, error) {
 	epochParticipation, err := state.PreviousEpochParticipation()
 	if err != nil {
 		return nil, err

beacon-chain/core/altair/upgrade_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
 	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
@@ -20,12 +19,10 @@ import (
 func TestTranslateParticipation(t *testing.T) {
 	ctx := context.Background()
 	s, _ := util.DeterministicGenesisStateAltair(t, 64)
-	st, ok := s.(*stateAltair.BeaconState)
-	require.Equal(t, true, ok)
-	require.NoError(t, st.SetSlot(st.Slot()+params.BeaconConfig().MinAttestationInclusionDelay))
+	require.NoError(t, s.SetSlot(s.Slot()+params.BeaconConfig().MinAttestationInclusionDelay))
 
 	var err error
-	newState, err := altair.TranslateParticipation(ctx, st, nil)
+	newState, err := altair.TranslateParticipation(ctx, s, nil)
 	require.NoError(t, err)
 	participation, err := newState.PreviousEpochParticipation()
 	require.NoError(t, err)
@@ -56,7 +53,7 @@ func TestTranslateParticipation(t *testing.T) {
 	require.NoError(t, err)
 	require.DeepNotSSZEqual(t, make([]byte, 64), participation)
 
-	committee, err := helpers.BeaconCommitteeFromState(ctx, st, pendingAtts[0].Data.Slot, pendingAtts[0].Data.CommitteeIndex)
+	committee, err := helpers.BeaconCommitteeFromState(ctx, s, pendingAtts[0].Data.Slot, pendingAtts[0].Data.CommitteeIndex)
 	require.NoError(t, err)
 	indices, err := attestation.AttestingIndices(pendingAtts[0].AggregationBits, committee)
 	require.NoError(t, err)
@@ -80,7 +77,7 @@ func TestUpgradeToAltair(t *testing.T) {
 	require.NoError(t, err)
 
 	require.Equal(t, preForkState.GenesisTime(), aState.GenesisTime())
-	require.DeepSSZEqual(t, preForkState.GenesisValidatorRoot(), aState.GenesisValidatorRoot())
+	require.DeepSSZEqual(t, preForkState.GenesisValidatorsRoot(), aState.GenesisValidatorsRoot())
 	require.Equal(t, preForkState.Slot(), aState.Slot())
 	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), aState.LatestBlockHeader())
 	require.DeepSSZEqual(t, preForkState.BlockRoots(), aState.BlockRoots())

beacon-chain/core/blocks/BUILD.bazel

@@ -40,6 +40,7 @@ go_library(
         "//encoding/ssz:go_default_library",
         "//math:go_default_library",
         "//network/forks:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/block:go_default_library",
@@ -91,11 +92,13 @@ go_test(
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/attestation/aggregation:go_default_library",
         "//proto/prysm/v1alpha1/attestation/aggregation/attestations:go_default_library",
         "//proto/prysm/v1alpha1/wrapper:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

beacon-chain/core/blocks/attestation.go

@@ -208,7 +208,7 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState state.ReadOnlyBea
 		beaconState.Fork(),
 		indexedAtt.Data.Target.Epoch,
 		params.BeaconConfig().DomainBeaconAttester,
-		beaconState.GenesisValidatorRoot(),
+		beaconState.GenesisValidatorsRoot(),
 	)
 	if err != nil {
 		return err

beacon-chain/core/blocks/attestation_test.go

@@ -337,7 +337,9 @@ func TestValidateIndexedAttestation_AboveMaxLength(t *testing.T) {
 	}
 
 	want := "validator indices count exceeds MAX_VALIDATORS_PER_COMMITTEE"
-	err := blocks.VerifyIndexedAttestation(context.Background(), &v1.BeaconState{}, indexedAtt1)
+	st, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
+	err = blocks.VerifyIndexedAttestation(context.Background(), st, indexedAtt1)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -415,7 +417,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 			Slot: 1,
 		},
 	})
-	prevDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	prevDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err := signing.ComputeSigningRoot(att1.Data, prevDomain)
 	require.NoError(t, err)
@@ -435,7 +437,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 			CommitteeIndex: 1,
 		},
 	})
-	currDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	currDomain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err = signing.ComputeSigningRoot(att2.Data, currDomain)
 	require.NoError(t, err)
@@ -474,7 +476,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 			Slot: 1,
 		},
 	})
-	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err := signing.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err)
@@ -538,7 +540,7 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 			Slot: 1,
 		},
 	})
-	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
+	domain, err := signing.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err := signing.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err)

beacon-chain/core/blocks/attester_slashing.go

@@ -84,7 +84,7 @@ func ProcessAttesterSlashing(
 			case beaconState.Version() == version.Altair:
 				slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
 			case beaconState.Version() == version.Bellatrix:
-				slashingQuotient = cfg.MinSlashingPenaltyQuotientMerge
+				slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
 			default:
 				return nil, errors.New("unknown state version")
 			}

beacon-chain/core/blocks/attester_slashing_test.go

@@ -108,7 +108,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	signingRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	assert.NoError(t, err, "Could not get signing root of beacon block header")
@@ -177,7 +177,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	signingRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	assert.NoError(t, err, "Could not get signing root of beacon block header")
@@ -235,7 +235,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 }
 
 func TestProcessAttesterSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateMerge(t, 100)
+	beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100)
 	for _, vv := range beaconState.Validators() {
 		vv.WithdrawableEpoch = types.Epoch(params.BeaconConfig().SlotsPerEpoch)
 	}
@@ -246,7 +246,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	signingRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	assert.NoError(t, err, "Could not get signing root of beacon block header")

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -74,7 +74,8 @@ func TestFuzzverifyDepositDataSigningRoot_10000(_ *testing.T) {
 func TestFuzzProcessEth1DataInBlock_10000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	e := &ethpb.Eth1Data{}
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(e)

beacon-chain/core/blocks/block_regression_test.go

@@ -44,7 +44,7 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 		AttestingIndices: setA,
 		Signature:        make([]byte, 96),
 	}
-	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	signingRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err, "Could not get signing root of beacon block header")

beacon-chain/core/blocks/eth1_data_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
@@ -175,12 +176,10 @@ func TestProcessEth1Data_SetsCorrectly(t *testing.T) {
 	}
 
 	period := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().EpochsPerEth1VotingPeriod)))
-	var ok bool
 	for i := uint64(0); i < period; i++ {
 		processedState, err := blocks.ProcessEth1DataInBlock(context.Background(), beaconState, b.Block.Body.Eth1Data)
 		require.NoError(t, err)
-		beaconState, ok = processedState.(*v1.BeaconState)
-		require.Equal(t, true, ok)
+		require.Equal(t, true, processedState.Version() == version.Phase0)
 	}
 
 	newETH1DataVotes := beaconState.Eth1DataVotes()

beacon-chain/core/blocks/exit.go

@@ -57,7 +57,7 @@ func ProcessVoluntaryExits(
 		if err != nil {
 			return nil, err
 		}
-		if err := VerifyExitAndSignature(val, beaconState.Slot(), beaconState.Fork(), exit, beaconState.GenesisValidatorRoot()); err != nil {
+		if err := VerifyExitAndSignature(val, beaconState.Slot(), beaconState.Fork(), exit, beaconState.GenesisValidatorsRoot()); err != nil {
 			return nil, errors.Wrapf(err, "could not verify exit %d", idx)
 		}
 		beaconState, err = v.InitiateValidatorExit(ctx, beaconState, exit.Exit.ValidatorIndex)

beacon-chain/core/blocks/payload.go

@@ -2,6 +2,7 @@ package blocks
 
 import (
 	"bytes"
+	"strings"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -10,18 +11,19 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/encoding/ssz"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
-// MergeComplete returns true if the transition to merge has completed.
+// MergeTransitionComplete returns true if the transition to Bellatrix has completed.
 // Meaning the payload header in beacon state is not `ExecutionPayloadHeader()` (i.e. not empty).
 //
 // Spec code:
-// def is_merge_complete(state: BeaconState) -> bool:
+// def is_merge_transition_complete(state: BeaconState) -> bool:
 //    return state.latest_execution_payload_header != ExecutionPayloadHeader()
-func MergeComplete(st state.BeaconState) (bool, error) {
+func MergeTransitionComplete(st state.BeaconState) (bool, error) {
 	h, err := st.LatestExecutionPayloadHeader()
 	if err != nil {
 		return false, err
@@ -30,15 +32,15 @@ func MergeComplete(st state.BeaconState) (bool, error) {
 	return !isEmptyHeader(h), nil
 }
 
-// IsMergeBlock returns true if the input block is the terminal merge block.
+// MergeTransitionBlock returns true if the input block is the terminal merge block.
 // Meaning the header in beacon state is  `ExecutionPayloadHeader()` (i.e. empty).
 // And the input block has a non-empty header.
 //
 // Spec code:
-// def is_merge_block(state: BeaconState, body: BeaconBlockBody) -> bool:
-//    return not is_merge_complete(state) and body.execution_payload != ExecutionPayload()
-func IsMergeBlock(st state.BeaconState, blk block.BeaconBlockBody) (bool, error) {
-	mergeComplete, err := MergeComplete(st)
+// def is_merge_transition_block(state: BeaconState, body: BeaconBlockBody) -> bool:
+//    return not is_merge_transition_complete(state) and body.execution_payload != ExecutionPayload()
+func MergeTransitionBlock(st state.BeaconState, body block.BeaconBlockBody) (bool, error) {
+	mergeComplete, err := MergeTransitionComplete(st)
 	if err != nil {
 		return false, err
 	}
@@ -46,8 +48,20 @@ func IsMergeBlock(st state.BeaconState, blk block.BeaconBlockBody) (bool, error)
 		return false, err
 	}
 
-	payload, err := blk.ExecutionPayload()
+	return ExecutionBlock(body)
+}
+
+// ExecutionBlock returns whether the block has a non-empty ExecutionPayload.
+//
+// Spec code:
+// def is_execution_block(block: BeaconBlock) -> bool:
+//     return block.body.execution_payload != ExecutionPayload()
+func ExecutionBlock(body block.BeaconBlockBody) (bool, error) {
+	payload, err := body.ExecutionPayload()
 	if err != nil {
+		if strings.HasPrefix(err.Error(), "ExecutionPayload is not supported in") {
+			return false, nil
+		}
 		return false, err
 	}
 	return !isEmptyPayload(payload), nil
@@ -59,15 +73,15 @@ func IsMergeBlock(st state.BeaconState, blk block.BeaconBlockBody) (bool, error)
 // Spec code:
 // def is_execution_enabled(state: BeaconState, body: BeaconBlockBody) -> bool:
 //    return is_merge_block(state, body) or is_merge_complete(state)
-func ExecutionEnabled(st state.BeaconState, blk block.BeaconBlockBody) (bool, error) {
-	mergeBlock, err := IsMergeBlock(st, blk)
+func ExecutionEnabled(st state.BeaconState, body block.BeaconBlockBody) (bool, error) {
+	mergeBlock, err := MergeTransitionBlock(st, body)
 	if err != nil {
 		return false, err
 	}
 	if mergeBlock {
 		return true, nil
 	}
-	return MergeComplete(st)
+	return MergeTransitionComplete(st)
 }
 
 // ValidatePayloadWhenMergeCompletes validates if payload is valid versus input beacon state.
@@ -77,8 +91,8 @@ func ExecutionEnabled(st state.BeaconState, blk block.BeaconBlockBody) (bool, er
 //    # Verify consistency of the parent hash with respect to the previous execution payload header
 //    if is_merge_complete(state):
 //        assert payload.parent_hash == state.latest_execution_payload_header.block_hash
-func ValidatePayloadWhenMergeCompletes(st state.BeaconState, payload *ethpb.ExecutionPayload) error {
-	complete, err := MergeComplete(st)
+func ValidatePayloadWhenMergeCompletes(st state.BeaconState, payload *enginev1.ExecutionPayload) error {
+	complete, err := MergeTransitionComplete(st)
 	if err != nil {
 		return err
 	}
@@ -104,14 +118,14 @@ func ValidatePayloadWhenMergeCompletes(st state.BeaconState, payload *ethpb.Exec
 //    assert payload.random == get_randao_mix(state, get_current_epoch(state))
 //    # Verify timestamp
 //    assert payload.timestamp == compute_timestamp_at_slot(state, state.slot)
-func ValidatePayload(st state.BeaconState, payload *ethpb.ExecutionPayload) error {
+func ValidatePayload(st state.BeaconState, payload *enginev1.ExecutionPayload) error {
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	if err != nil {
 		return err
 	}
 
-	if !bytes.Equal(payload.Random, random) {
-		return errors.New("incorrect random")
+	if !bytes.Equal(payload.PrevRandao, random) {
+		return errors.New("incorrect prev randao")
 	}
 	t, err := slots.ToTime(st.GenesisTime(), st.Slot())
 	if err != nil {
@@ -155,7 +169,7 @@ func ValidatePayload(st state.BeaconState, payload *ethpb.ExecutionPayload) erro
 //        block_hash=payload.block_hash,
 //        transactions_root=hash_tree_root(payload.transactions),
 //    )
-func ProcessPayload(st state.BeaconState, payload *ethpb.ExecutionPayload) (state.BeaconState, error) {
+func ProcessPayload(st state.BeaconState, payload *enginev1.ExecutionPayload) (state.BeaconState, error) {
 	if err := ValidatePayloadWhenMergeCompletes(st, payload); err != nil {
 		return nil, err
 	}
@@ -175,7 +189,7 @@ func ProcessPayload(st state.BeaconState, payload *ethpb.ExecutionPayload) (stat
 }
 
 // PayloadToHeader converts `payload` into execution payload header format.
-func PayloadToHeader(payload *ethpb.ExecutionPayload) (*ethpb.ExecutionPayloadHeader, error) {
+func PayloadToHeader(payload *enginev1.ExecutionPayload) (*ethpb.ExecutionPayloadHeader, error) {
 	txRoot, err := ssz.TransactionsRoot(payload.Transactions)
 	if err != nil {
 		return nil, err
@@ -185,9 +199,9 @@ func PayloadToHeader(payload *ethpb.ExecutionPayload) (*ethpb.ExecutionPayloadHe
 		ParentHash:       bytesutil.SafeCopyBytes(payload.ParentHash),
 		FeeRecipient:     bytesutil.SafeCopyBytes(payload.FeeRecipient),
 		StateRoot:        bytesutil.SafeCopyBytes(payload.StateRoot),
-		ReceiptRoot:      bytesutil.SafeCopyBytes(payload.ReceiptRoot),
+		ReceiptRoot:      bytesutil.SafeCopyBytes(payload.ReceiptsRoot),
 		LogsBloom:        bytesutil.SafeCopyBytes(payload.LogsBloom),
-		Random:           bytesutil.SafeCopyBytes(payload.Random),
+		PrevRandao:       bytesutil.SafeCopyBytes(payload.PrevRandao),
 		BlockNumber:      payload.BlockNumber,
 		GasLimit:         payload.GasLimit,
 		GasUsed:          payload.GasUsed,
@@ -199,7 +213,7 @@ func PayloadToHeader(payload *ethpb.ExecutionPayload) (*ethpb.ExecutionPayloadHe
 	}, nil
 }
 
-func isEmptyPayload(p *ethpb.ExecutionPayload) bool {
+func isEmptyPayload(p *enginev1.ExecutionPayload) bool {
 	if !bytes.Equal(p.ParentHash, make([]byte, fieldparams.RootLength)) {
 		return false
 	}
@@ -209,13 +223,13 @@ func isEmptyPayload(p *ethpb.ExecutionPayload) bool {
 	if !bytes.Equal(p.StateRoot, make([]byte, fieldparams.RootLength)) {
 		return false
 	}
-	if !bytes.Equal(p.ReceiptRoot, make([]byte, fieldparams.RootLength)) {
+	if !bytes.Equal(p.ReceiptsRoot, make([]byte, fieldparams.RootLength)) {
 		return false
 	}
 	if !bytes.Equal(p.LogsBloom, make([]byte, fieldparams.LogsBloomLength)) {
 		return false
 	}
-	if !bytes.Equal(p.Random, make([]byte, fieldparams.RootLength)) {
+	if !bytes.Equal(p.PrevRandao, make([]byte, fieldparams.RootLength)) {
 		return false
 	}
 	if !bytes.Equal(p.BaseFeePerGas, make([]byte, fieldparams.RootLength)) {
@@ -261,7 +275,7 @@ func isEmptyHeader(h *ethpb.ExecutionPayloadHeader) bool {
 	if !bytes.Equal(h.LogsBloom, make([]byte, fieldparams.LogsBloomLength)) {
 		return false
 	}
-	if !bytes.Equal(h.Random, make([]byte, fieldparams.RootLength)) {
+	if !bytes.Equal(h.PrevRandao, make([]byte, fieldparams.RootLength)) {
 		return false
 	}
 	if !bytes.Equal(h.BaseFeePerGas, make([]byte, fieldparams.RootLength)) {

beacon-chain/core/blocks/payload_test.go

@@ -10,6 +10,7 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/encoding/ssz"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -77,7 +78,7 @@ func Test_MergeComplete(t *testing.T) {
 			name: "has random",
 			payload: func() *ethpb.ExecutionPayloadHeader {
 				h := emptyPayloadHeader()
-				h.Random = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				h.PrevRandao = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return h
 			}(),
 			want: true,
@@ -157,9 +158,9 @@ func Test_MergeComplete(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			st, _ := util.DeterministicGenesisStateMerge(t, 1)
+			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.payload))
-			got, err := blocks.MergeComplete(st)
+			got, err := blocks.MergeTransitionComplete(st)
 			require.NoError(t, err)
 			if got != tt.want {
 				t.Errorf("mergeComplete() got = %v, want %v", got, tt.want)
@@ -171,7 +172,7 @@ func Test_MergeComplete(t *testing.T) {
 func Test_MergeBlock(t *testing.T) {
 	tests := []struct {
 		name    string
-		payload *ethpb.ExecutionPayload
+		payload *enginev1.ExecutionPayload
 		header  *ethpb.ExecutionPayloadHeader
 		want    bool
 	}{
@@ -193,7 +194,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has parent hash",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return p
@@ -203,7 +204,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has fee recipient",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.FeeRecipient = bytesutil.PadTo([]byte{'a'}, fieldparams.FeeRecipientLength)
 				return p
@@ -213,7 +214,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has state root",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.StateRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return p
@@ -223,9 +224,9 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has receipt root",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
-				p.ReceiptRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				p.ReceiptsRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return p
 			}(),
 			header: emptyPayloadHeader(),
@@ -233,7 +234,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has logs bloom",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.LogsBloom = bytesutil.PadTo([]byte{'a'}, fieldparams.LogsBloomLength)
 				return p
@@ -243,9 +244,9 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has random",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
-				p.Random = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				p.PrevRandao = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return p
 			}(),
 			header: emptyPayloadHeader(),
@@ -253,7 +254,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has base fee",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.BaseFeePerGas = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return p
@@ -263,7 +264,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has block hash",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.BlockHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return p
@@ -273,7 +274,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has tx",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.Transactions = [][]byte{{'a'}}
 				return p
@@ -283,7 +284,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has extra data",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.ExtraData = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return p
@@ -293,7 +294,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has block number",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.BlockNumber = 1
 				return p
@@ -303,7 +304,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has gas limit",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.GasLimit = 1
 				return p
@@ -313,7 +314,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has gas used",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.GasUsed = 1
 				return p
@@ -323,7 +324,7 @@ func Test_MergeBlock(t *testing.T) {
 		},
 		{
 			name: "empty header, payload has timestamp",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.Timestamp = 1
 				return p
@@ -334,25 +335,59 @@ func Test_MergeBlock(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			st, _ := util.DeterministicGenesisStateMerge(t, 1)
+			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.header))
-			blk := util.NewBeaconBlockMerge()
+			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
-			body, err := wrapper.WrappedMergeBeaconBlockBody(blk.Block.Body)
+			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
-			got, err := blocks.IsMergeBlock(st, body)
+			got, err := blocks.MergeTransitionBlock(st, body)
 			require.NoError(t, err)
 			if got != tt.want {
-				t.Errorf("IsMergeBlock() got = %v, want %v", got, tt.want)
+				t.Errorf("MergeTransitionBlock() got = %v, want %v", got, tt.want)
 			}
 		})
 	}
 }
 
+func Test_IsExecutionBlock(t *testing.T) {
+	tests := []struct {
+		name    string
+		payload *enginev1.ExecutionPayload
+		want    bool
+	}{
+		{
+			name:    "empty payload",
+			payload: emptyPayload(),
+			want:    false,
+		},
+		{
+			name: "non-empty payload",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return p
+			}(),
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			blk := util.NewBeaconBlockBellatrix()
+			blk.Block.Body.ExecutionPayload = tt.payload
+			wrappedBlock, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
+			require.NoError(t, err)
+			got, err := blocks.ExecutionBlock(wrappedBlock.Body())
+			require.NoError(t, err)
+			require.Equal(t, tt.want, got)
+		})
+	}
+}
+
 func Test_ExecutionEnabled(t *testing.T) {
 	tests := []struct {
 		name    string
-		payload *ethpb.ExecutionPayload
+		payload *enginev1.ExecutionPayload
 		header  *ethpb.ExecutionPayloadHeader
 		want    bool
 	}{
@@ -375,7 +410,7 @@ func Test_ExecutionEnabled(t *testing.T) {
 		{
 			name:   "empty header, non-empty payload",
 			header: emptyPayloadHeader(),
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.Timestamp = 1
 				return p
@@ -389,7 +424,7 @@ func Test_ExecutionEnabled(t *testing.T) {
 				h.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return h
 			}(),
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.Timestamp = 1
 				return p
@@ -399,11 +434,11 @@ func Test_ExecutionEnabled(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			st, _ := util.DeterministicGenesisStateMerge(t, 1)
+			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.header))
-			blk := util.NewBeaconBlockMerge()
+			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
-			body, err := wrapper.WrappedMergeBeaconBlockBody(blk.Block.Body)
+			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
 			got, err := blocks.ExecutionEnabled(st, body)
 			require.NoError(t, err)
@@ -417,7 +452,7 @@ func Test_ExecutionEnabled(t *testing.T) {
 func Test_ValidatePayloadWhenMergeCompletes(t *testing.T) {
 	tests := []struct {
 		name    string
-		payload *ethpb.ExecutionPayload
+		payload *enginev1.ExecutionPayload
 		header  *ethpb.ExecutionPayloadHeader
 		err     error
 	}{
@@ -429,7 +464,7 @@ func Test_ValidatePayloadWhenMergeCompletes(t *testing.T) {
 		},
 		{
 			name: "validate passes",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return p
@@ -443,7 +478,7 @@ func Test_ValidatePayloadWhenMergeCompletes(t *testing.T) {
 		},
 		{
 			name: "incorrect blockhash",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				p := emptyPayload()
 				p.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
 				return p
@@ -458,7 +493,7 @@ func Test_ValidatePayloadWhenMergeCompletes(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			st, _ := util.DeterministicGenesisStateMerge(t, 1)
+			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.header))
 			err := blocks.ValidatePayloadWhenMergeCompletes(st, tt.payload)
 			if err != nil {
@@ -471,35 +506,35 @@ func Test_ValidatePayloadWhenMergeCompletes(t *testing.T) {
 }
 
 func Test_ValidatePayload(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateMerge(t, 1)
+	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	require.NoError(t, err)
 	ts, err := slots.ToTime(st.GenesisTime(), st.Slot())
 	require.NoError(t, err)
 	tests := []struct {
 		name    string
-		payload *ethpb.ExecutionPayload
+		payload *enginev1.ExecutionPayload
 		err     error
 	}{
 		{
 			name: "validate passes",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				h := emptyPayload()
-				h.Random = random
+				h.PrevRandao = random
 				h.Timestamp = uint64(ts.Unix())
 				return h
 			}(), err: nil,
 		},
 		{
-			name:    "incorrect random",
+			name:    "incorrect prev randao",
 			payload: emptyPayload(),
-			err:     errors.New("incorrect random"),
+			err:     errors.New("incorrect prev randao"),
 		},
 		{
 			name: "incorrect timestamp",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				h := emptyPayload()
-				h.Random = random
+				h.PrevRandao = random
 				h.Timestamp = 1
 				return h
 			}(),
@@ -519,35 +554,35 @@ func Test_ValidatePayload(t *testing.T) {
 }
 
 func Test_ProcessPayload(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateMerge(t, 1)
+	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	require.NoError(t, err)
 	ts, err := slots.ToTime(st.GenesisTime(), st.Slot())
 	require.NoError(t, err)
 	tests := []struct {
 		name    string
-		payload *ethpb.ExecutionPayload
+		payload *enginev1.ExecutionPayload
 		err     error
 	}{
 		{
 			name: "process passes",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				h := emptyPayload()
-				h.Random = random
+				h.PrevRandao = random
 				h.Timestamp = uint64(ts.Unix())
 				return h
 			}(), err: nil,
 		},
 		{
-			name:    "incorrect random",
+			name:    "incorrect prev randao",
 			payload: emptyPayload(),
-			err:     errors.New("incorrect random"),
+			err:     errors.New("incorrect prev randao"),
 		},
 		{
 			name: "incorrect timestamp",
-			payload: func() *ethpb.ExecutionPayload {
+			payload: func() *enginev1.ExecutionPayload {
 				h := emptyPayload()
-				h.Random = random
+				h.PrevRandao = random
 				h.Timestamp = 1
 				return h
 			}(),
@@ -584,9 +619,9 @@ func Test_PayloadToHeader(t *testing.T) {
 	p.ParentHash = b
 	p.FeeRecipient = b
 	p.StateRoot = b
-	p.ReceiptRoot = b
+	p.ReceiptsRoot = b
 	p.LogsBloom = b
-	p.Random = b
+	p.PrevRandao = b
 	p.ExtraData = b
 	p.BaseFeePerGas = b
 	p.BlockHash = b
@@ -600,7 +635,7 @@ func Test_PayloadToHeader(t *testing.T) {
 	require.DeepSSZEqual(t, h.StateRoot, make([]byte, fieldparams.RootLength))
 	require.DeepSSZEqual(t, h.ReceiptRoot, make([]byte, fieldparams.RootLength))
 	require.DeepSSZEqual(t, h.LogsBloom, make([]byte, fieldparams.LogsBloomLength))
-	require.DeepSSZEqual(t, h.Random, make([]byte, fieldparams.RootLength))
+	require.DeepSSZEqual(t, h.PrevRandao, make([]byte, fieldparams.RootLength))
 	require.DeepSSZEqual(t, h.ExtraData, make([]byte, 0))
 	require.DeepSSZEqual(t, h.BaseFeePerGas, make([]byte, fieldparams.RootLength))
 	require.DeepSSZEqual(t, h.BlockHash, make([]byte, fieldparams.RootLength))
@@ -611,12 +646,12 @@ func Test_PayloadToHeader(t *testing.T) {
 }
 
 func BenchmarkBellatrixComplete(b *testing.B) {
-	st, _ := util.DeterministicGenesisStateMerge(b, 1)
+	st, _ := util.DeterministicGenesisStateBellatrix(b, 1)
 	require.NoError(b, st.SetLatestExecutionPayloadHeader(emptyPayloadHeader()))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_, err := blocks.MergeComplete(st)
+		_, err := blocks.MergeTransitionComplete(st)
 		require.NoError(b, err)
 	}
 }
@@ -628,7 +663,7 @@ func emptyPayloadHeader() *ethpb.ExecutionPayloadHeader {
 		StateRoot:        make([]byte, fieldparams.RootLength),
 		ReceiptRoot:      make([]byte, fieldparams.RootLength),
 		LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
-		Random:           make([]byte, fieldparams.RootLength),
+		PrevRandao:       make([]byte, fieldparams.RootLength),
 		BaseFeePerGas:    make([]byte, fieldparams.RootLength),
 		BlockHash:        make([]byte, fieldparams.RootLength),
 		TransactionsRoot: make([]byte, fieldparams.RootLength),
@@ -636,14 +671,14 @@ func emptyPayloadHeader() *ethpb.ExecutionPayloadHeader {
 	}
 }
 
-func emptyPayload() *ethpb.ExecutionPayload {
-	return &ethpb.ExecutionPayload{
+func emptyPayload() *enginev1.ExecutionPayload {
+	return &enginev1.ExecutionPayload{
 		ParentHash:    make([]byte, fieldparams.RootLength),
 		FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
 		StateRoot:     make([]byte, fieldparams.RootLength),
-		ReceiptRoot:   make([]byte, fieldparams.RootLength),
+		ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 		LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
-		Random:        make([]byte, fieldparams.RootLength),
+		PrevRandao:    make([]byte, fieldparams.RootLength),
 		BaseFeePerGas: make([]byte, fieldparams.RootLength),
 		BlockHash:     make([]byte, fieldparams.RootLength),
 		Transactions:  make([][]byte, 0),

beacon-chain/core/blocks/proposer_slashing.go

@@ -82,7 +82,7 @@ func ProcessProposerSlashing(
 	case beaconState.Version() == version.Altair:
 		slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
 	case beaconState.Version() == version.Bellatrix:
-		slashingQuotient = cfg.MinSlashingPenaltyQuotientMerge
+		slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
 	default:
 		return nil, errors.New("unknown state version")
 	}

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -237,7 +237,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 func TestProcessProposerSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 	// We test the case when data is correct and verify the validator
 	// registry has been updated.
-	beaconState, privKeys := util.DeterministicGenesisStateMerge(t, 100)
+	beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100)
 	proposerIdx := types.ValidatorIndex(1)
 
 	header1 := &ethpb.SignedBeaconBlockHeader{
@@ -378,7 +378,7 @@ func TestVerifyProposerSlashing(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 
 			sk := sks[tt.args.slashing.Header_1.Header.ProposerIndex]
-			d, err := signing.Domain(tt.args.beaconState.Fork(), slots.ToEpoch(tt.args.slashing.Header_1.Header.Slot), params.BeaconConfig().DomainBeaconProposer, tt.args.beaconState.GenesisValidatorRoot())
+			d, err := signing.Domain(tt.args.beaconState.Fork(), slots.ToEpoch(tt.args.slashing.Header_1.Header.Slot), params.BeaconConfig().DomainBeaconProposer, tt.args.beaconState.GenesisValidatorsRoot())
 			require.NoError(t, err)
 			if tt.args.slashing.Header_1.Signature == nil {
 				sr, err := signing.ComputeSigningRoot(tt.args.slashing.Header_1.Header, d)

beacon-chain/core/blocks/randao_test.go

@@ -26,7 +26,7 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	epoch := types.Epoch(0)
 	buf := make([]byte, 32)
 	binary.LittleEndian.PutUint64(buf, uint64(epoch))
-	domain, err := signing.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	root, err := (&ethpb.SigningData{ObjectRoot: buf, Domain: domain}).HashTreeRoot()
 	require.NoError(t, err)

beacon-chain/core/blocks/signature.go

@@ -68,7 +68,7 @@ func VerifyBlockSignature(beaconState state.ReadOnlyBeaconState,
 	sig []byte,
 	rootFunc func() ([32]byte, error)) error {
 	currentEpoch := slots.ToEpoch(beaconState.Slot())
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}
@@ -83,7 +83,7 @@ func VerifyBlockSignature(beaconState state.ReadOnlyBeaconState,
 // VerifyBlockHeaderSignature verifies the proposer signature of a beacon block header.
 func VerifyBlockHeaderSignature(beaconState state.BeaconState, header *ethpb.SignedBeaconBlockHeader) error {
 	currentEpoch := slots.ToEpoch(beaconState.Slot())
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}
@@ -104,7 +104,7 @@ func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState,
 	if err != nil {
 		return err
 	}
-	domain, err := signing.Domain(fork, currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(fork, currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}
@@ -122,7 +122,7 @@ func BlockSignatureBatch(beaconState state.ReadOnlyBeaconState,
 	sig []byte,
 	rootFunc func() ([32]byte, error)) (*bls.SignatureBatch, error) {
 	currentEpoch := slots.ToEpoch(beaconState.Slot())
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}
@@ -164,7 +164,7 @@ func randaoSigningData(ctx context.Context, beaconState state.ReadOnlyBeaconStat
 	buf := make([]byte, 32)
 	binary.LittleEndian.PutUint64(buf, uint64(currentEpoch))
 
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -231,7 +231,7 @@ func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBe
 	}
 
 	fork := beaconState.Fork()
-	gvr := beaconState.GenesisValidatorRoot()
+	gvr := beaconState.GenesisValidatorsRoot()
 	dt := params.BeaconConfig().DomainBeaconAttester
 
 	// Split attestations by fork. Note: the signature domain will differ based on the fork.

beacon-chain/core/blocks/signature_test.go

@@ -41,7 +41,7 @@ func TestVerifyBlockHeaderSignature(t *testing.T) {
 		beaconState.Fork(),
 		0,
 		params.BeaconConfig().DomainBeaconProposer,
-		beaconState.GenesisValidatorRoot(),
+		beaconState.GenesisValidatorsRoot(),
 	)
 	require.NoError(t, err)
 	htr, err := blockHeader.Header.HashTreeRoot()
@@ -77,7 +77,7 @@ func TestVerifyBlockSignatureUsingCurrentFork(t *testing.T) {
 		CurrentVersion:  params.BeaconConfig().AltairForkVersion,
 		PreviousVersion: params.BeaconConfig().GenesisForkVersion,
 	}
-	domain, err := signing.Domain(fData, 100, params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorRoot())
+	domain, err := signing.Domain(fData, 100, params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorsRoot())
 	assert.NoError(t, err)
 	rt, err := signing.ComputeSigningRoot(altairBlk.Block, domain)
 	assert.NoError(t, err)

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

@@ -16,6 +16,7 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/math"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
@@ -47,8 +48,7 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
 
 	processedState, err := ProcessRewardsAndPenaltiesPrecompute(beaconState, bp, vp, AttestationsDelta, ProposersDelta)
 	require.NoError(t, err)
-	beaconState, ok := processedState.(*v1.BeaconState)
-	require.Equal(t, true, ok)
+	require.Equal(t, true, processedState.Version() == version.Phase0)
 
 	// Indices that voted everything except for head, lost a bit money
 	wanted := uint64(31999810265)

beacon-chain/core/execution/upgrade.go

@@ -10,9 +10,9 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
 
-// UpgradeToMerge updates inputs a generic state to return the version Merge state.
+// UpgradeToBellatrix updates inputs a generic state to return the version Bellatrix state.
 // It inserts an empty `ExecutionPayloadHeader` into the state.
-func UpgradeToMerge(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
+func UpgradeToBellatrix(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
 	epoch := time.CurrentEpoch(state)
 
 	currentSyncCommittee, err := state.CurrentSyncCommittee()
@@ -38,7 +38,7 @@ func UpgradeToMerge(ctx context.Context, state state.BeaconState) (state.BeaconS
 
 	s := &ethpb.BeaconStateBellatrix{
 		GenesisTime:           state.GenesisTime(),
-		GenesisValidatorsRoot: state.GenesisValidatorRoot(),
+		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
 		Slot:                  state.Slot(),
 		Fork: &ethpb.Fork{
 			PreviousVersion: state.Fork().CurrentVersion,
@@ -71,7 +71,7 @@ func UpgradeToMerge(ctx context.Context, state state.BeaconState) (state.BeaconS
 			StateRoot:        make([]byte, 32),
 			ReceiptRoot:      make([]byte, 32),
 			LogsBloom:        make([]byte, 256),
-			Random:           make([]byte, 32),
+			PrevRandao:       make([]byte, 32),
 			BlockNumber:      0,
 			GasLimit:         0,
 			GasUsed:          0,

beacon-chain/core/execution/upgrade_test.go

@@ -15,11 +15,11 @@ import (
 func TestUpgradeToBellatrix(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	preForkState := st.Copy()
-	mSt, err := execution.UpgradeToMerge(context.Background(), st)
+	mSt, err := execution.UpgradeToBellatrix(context.Background(), st)
 	require.NoError(t, err)
 
 	require.Equal(t, preForkState.GenesisTime(), mSt.GenesisTime())
-	require.DeepSSZEqual(t, preForkState.GenesisValidatorRoot(), mSt.GenesisValidatorRoot())
+	require.DeepSSZEqual(t, preForkState.GenesisValidatorsRoot(), mSt.GenesisValidatorsRoot())
 	require.Equal(t, preForkState.Slot(), mSt.Slot())
 	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), mSt.LatestBlockHeader())
 	require.DeepSSZEqual(t, preForkState.BlockRoots(), mSt.BlockRoots())
@@ -67,7 +67,7 @@ func TestUpgradeToBellatrix(t *testing.T) {
 		StateRoot:        make([]byte, 32),
 		ReceiptRoot:      make([]byte, 32),
 		LogsBloom:        make([]byte, 256),
-		Random:           make([]byte, 32),
+		PrevRandao:       make([]byte, 32),
 		BlockNumber:      0,
 		GasLimit:         0,
 		GasUsed:          0,

beacon-chain/core/signing/signing_root.go

@@ -23,7 +23,7 @@ var ErrSigFailedToVerify = errors.New("signature did not verify")
 
 // ComputeDomainAndSign computes the domain and signing root and sign it using the passed in private key.
 func ComputeDomainAndSign(st state.ReadOnlyBeaconState, epoch types.Epoch, obj fssz.HashRoot, domain [4]byte, key bls.SecretKey) ([]byte, error) {
-	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorRoot())
+	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorsRoot())
 	if err != nil {
 		return nil, err
 	}
@@ -69,7 +69,7 @@ func ComputeDomainVerifySigningRoot(st state.ReadOnlyBeaconState, index types.Va
 	if err != nil {
 		return err
 	}
-	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorRoot())
+	d, err := Domain(st.Fork(), epoch, domain, st.GenesisValidatorsRoot())
 	if err != nil {
 		return err
 	}
@@ -219,7 +219,7 @@ func computeForkDataRoot(version, root []byte) ([32]byte, error) {
 	return r, nil
 }
 
-// ComputeForkDigest returns the fork for the current version and genesis validator root
+// ComputeForkDigest returns the fork for the current version and genesis validators root
 //
 // Spec pseudocode definition:
 //	def compute_fork_digest(current_version: Version, genesis_validators_root: Root) -> ForkDigest:

beacon-chain/core/transition/BUILD.bazel

@@ -35,7 +35,6 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
@@ -88,6 +87,7 @@ go_test(
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/wrapper:go_default_library",

beacon-chain/core/transition/bellatrix_transition_no_verify_sig_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -25,7 +26,7 @@ import (
 )
 
 func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateMerge(t, 100)
+	beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100)
 
 	syncCommittee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
@@ -57,7 +58,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), nextSlotState)
 	require.NoError(t, err)
-	block := util.NewBeaconBlockMerge()
+	block := util.NewBeaconBlockBellatrix()
 	block.Block.ProposerIndex = proposerIdx
 	block.Block.Slot = beaconState.Slot() + 1
 	block.Block.ParentRoot = parentRoot[:]
@@ -91,7 +92,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 		SyncCommitteeSignature: aggregatedSig,
 	}
 	block.Block.Body.SyncAggregate = syncAggregate
-	wsb, err := wrapper.WrappedMergeSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block)
 	require.NoError(t, err)
 	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -102,7 +103,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	wsb, err = wrapper.WrappedMergeSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedBellatrixSignedBeaconBlock(block)
 	require.NoError(t, err)
 	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -112,7 +113,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 }
 
 func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *testing.T) {
-	beaconState, privKeys := util.DeterministicGenesisStateMerge(t, 100)
+	beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100)
 
 	syncCommittee, err := altair.NextSyncCommittee(context.Background(), beaconState)
 	require.NoError(t, err)
@@ -144,7 +145,7 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	require.NoError(t, err)
 	proposerIdx, err := helpers.BeaconProposerIndex(context.Background(), nextSlotState)
 	require.NoError(t, err)
-	block := util.NewBeaconBlockMerge()
+	block := util.NewBeaconBlockBellatrix()
 	block.Block.ProposerIndex = proposerIdx
 	block.Block.Slot = beaconState.Slot() + 1
 	block.Block.ParentRoot = parentRoot[:]
@@ -179,7 +180,7 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	}
 	block.Block.Body.SyncAggregate = syncAggregate
 
-	wsb, err := wrapper.WrappedMergeSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block)
 	require.NoError(t, err)
 	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -191,14 +192,14 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	block.Signature = sig.Marshal()
 
 	block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
-	wsb, err = wrapper.WrappedMergeSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedBellatrixSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "could not validate state root", err)
 }
 
 func TestProcessEpoch_BadBalanceBellatrix(t *testing.T) {
-	s, _ := util.DeterministicGenesisStateMerge(t, 100)
+	s, _ := util.DeterministicGenesisStateBellatrix(t, 100)
 	assert.NoError(t, s.SetSlot(63))
 	assert.NoError(t, s.UpdateBalancesAtIndex(0, math.MaxUint64))
 	participation := byte(0)
@@ -219,15 +220,15 @@ func TestProcessEpoch_BadBalanceBellatrix(t *testing.T) {
 }
 
 func createFullBellatrixBlockWithOperations(t *testing.T) (state.BeaconState,
-	*ethpb.SignedBeaconBlockMerge) {
+	*ethpb.SignedBeaconBlockBellatrix) {
 	_, altairBlk := createFullAltairBlockWithOperations(t)
-	blk := &ethpb.SignedBeaconBlockMerge{
-		Block: &ethpb.BeaconBlockMerge{
+	blk := &ethpb.SignedBeaconBlockBellatrix{
+		Block: &ethpb.BeaconBlockBellatrix{
 			Slot:          altairBlk.Block.Slot,
 			ProposerIndex: altairBlk.Block.ProposerIndex,
 			ParentRoot:    altairBlk.Block.ParentRoot,
 			StateRoot:     altairBlk.Block.StateRoot,
-			Body: &ethpb.BeaconBlockBodyMerge{
+			Body: &ethpb.BeaconBlockBodyBellatrix{
 				RandaoReveal:      altairBlk.Block.Body.RandaoReveal,
 				Eth1Data:          altairBlk.Block.Body.Eth1Data,
 				Graffiti:          altairBlk.Block.Body.Graffiti,
@@ -237,13 +238,13 @@ func createFullBellatrixBlockWithOperations(t *testing.T) (state.BeaconState,
 				Deposits:          altairBlk.Block.Body.Deposits,
 				VoluntaryExits:    altairBlk.Block.Body.VoluntaryExits,
 				SyncAggregate:     altairBlk.Block.Body.SyncAggregate,
-				ExecutionPayload: &ethpb.ExecutionPayload{
+				ExecutionPayload: &enginev1.ExecutionPayload{
 					ParentHash:    make([]byte, fieldparams.RootLength),
 					FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
 					StateRoot:     make([]byte, fieldparams.RootLength),
-					ReceiptRoot:   make([]byte, fieldparams.RootLength),
+					ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 					LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
-					Random:        make([]byte, fieldparams.RootLength),
+					PrevRandao:    make([]byte, fieldparams.RootLength),
 					BaseFeePerGas: make([]byte, fieldparams.RootLength),
 					BlockHash:     make([]byte, fieldparams.RootLength),
 					Transactions:  make([][]byte, 0),
@@ -253,6 +254,6 @@ func createFullBellatrixBlockWithOperations(t *testing.T) (state.BeaconState,
 		},
 		Signature: nil,
 	}
-	beaconState, _ := util.DeterministicGenesisStateMerge(t, 32)
+	beaconState, _ := util.DeterministicGenesisStateBellatrix(t, 32)
 	return beaconState, blk
 }

beacon-chain/core/transition/skip_slot_cache_test.go

@@ -10,6 +10,7 @@ import (
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
@@ -33,8 +34,7 @@ func TestSkipSlotCache_OK(t *testing.T) {
 	require.NoError(t, err)
 	executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wrapper.WrappedPhase0SignedBeaconBlock(blk))
 	require.NoError(t, err, "Could not run state transition")
-	originalState, ok := executedState.(*v1.BeaconState)
-	require.Equal(t, true, ok)
+	require.Equal(t, true, executedState.Version() == version.Phase0)
 	bState, err = transition.ExecuteStateTransition(context.Background(), bState, wrapper.WrappedPhase0SignedBeaconBlock(blk))
 	require.NoError(t, err, "Could not process state transition")
 
@@ -59,8 +59,7 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 	require.NoError(t, err)
 	executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wrapper.WrappedPhase0SignedBeaconBlock(blk))
 	require.NoError(t, err, "Could not run state transition")
-	originalState, ok := executedState.(*v1.BeaconState)
-	require.Equal(t, true, ok)
+	require.Equal(t, true, executedState.Version() == version.Phase0)
 
 	// Create two shallow but different forks
 	var s1, s0 state.BeaconState

beacon-chain/core/transition/state_fuzz_test.go

@@ -7,6 +7,7 @@ import (
 	fuzz "github.com/google/gofuzz"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestGenesisBeaconState_1000(t *testing.T) {
@@ -37,7 +38,8 @@ func TestOptimizedGenesisBeaconState_1000(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)
 	var genesisTime uint64
-	preState := &v1.BeaconState{}
+	preState, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	eth1Data := &ethpb.Eth1Data{}
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(&genesisTime)

beacon-chain/core/transition/trailing_slot_state_cache.go

@@ -35,7 +35,7 @@ var (
 func NextSlotState(_ context.Context, root []byte) (state.BeaconState, error) {
 	nsc.RLock()
 	defer nsc.RUnlock()
-	if !bytes.Equal(root, nsc.root) {
+	if !bytes.Equal(root, nsc.root) || bytes.Equal(root, []byte{}) {
 		nextSlotCacheMiss.Inc()
 		return nil, nil
 	}

beacon-chain/core/transition/transition.go

@@ -143,23 +143,36 @@ func ProcessSlotsUsingNextSlotCache(
 	if err != nil {
 		return nil, err
 	}
+	cachedStateExists := nextSlotState != nil && !nextSlotState.IsNil()
 	// If the next slot state is not nil (i.e. cache hit).
 	// We replace next slot state with parent state.
-	if nextSlotState != nil && !nextSlotState.IsNil() {
+	if cachedStateExists {
 		parentState = nextSlotState
 	}
 
+	// In the event our cached state has advanced our
+	// state to the desired slot, we exit early.
+	if cachedStateExists && parentState.Slot() == slot {
+		return parentState, nil
+	}
 	// Since next slot cache only advances state by 1 slot,
 	// we check if there's more slots that need to process.
-	if slot > parentState.Slot() {
-		parentState, err = ProcessSlots(ctx, parentState, slot)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not process slots")
-		}
+	parentState, err = ProcessSlots(ctx, parentState, slot)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process slots")
 	}
 	return parentState, nil
 }
 
+// ProcessSlotsIfPossible executes ProcessSlots on the input state when target slot is above the state's slot.
+// Otherwise, it returns the input state unchanged.
+func ProcessSlotsIfPossible(ctx context.Context, state state.BeaconState, targetSlot types.Slot) (state.BeaconState, error) {
+	if targetSlot > state.Slot() {
+		return ProcessSlots(ctx, state, targetSlot)
+	}
+	return state, nil
+}
+
 // ProcessSlots process through skip slots and apply epoch transition when it's needed
 //
 // Spec pseudocode definition:
@@ -266,7 +279,7 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot types.Slot)
 		}
 
 		if time.CanUpgradeToBellatrix(state.Slot()) {
-			state, err = execution.UpgradeToMerge(ctx, state)
+			state, err = execution.UpgradeToBellatrix(ctx, state)
 			if err != nil {
 				tracing.AnnotateError(span, err)
 				return nil, err

beacon-chain/core/transition/transition_fuzz_test.go

@@ -10,13 +10,15 @@ import (
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
+	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
 func TestFuzzExecuteStateTransition_1000(t *testing.T) {
 	SkipSlotCache.Disable()
 	defer SkipSlotCache.Enable()
 	ctx := context.Background()
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	sb := &ethpb.SignedBeaconBlock{}
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)
@@ -34,7 +36,8 @@ func TestFuzzCalculateStateRoot_1000(t *testing.T) {
 	SkipSlotCache.Disable()
 	defer SkipSlotCache.Enable()
 	ctx := context.Background()
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	sb := &ethpb.SignedBeaconBlock{}
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)
@@ -52,7 +55,8 @@ func TestFuzzProcessSlot_1000(t *testing.T) {
 	SkipSlotCache.Disable()
 	defer SkipSlotCache.Enable()
 	ctx := context.Background()
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)
 	for i := 0; i < 1000; i++ {
@@ -68,7 +72,8 @@ func TestFuzzProcessSlots_1000(t *testing.T) {
 	SkipSlotCache.Disable()
 	defer SkipSlotCache.Enable()
 	ctx := context.Background()
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	slot := types.Slot(0)
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)
@@ -86,7 +91,8 @@ func TestFuzzprocessOperationsNoVerify_1000(t *testing.T) {
 	SkipSlotCache.Disable()
 	defer SkipSlotCache.Enable()
 	ctx := context.Background()
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	bb := &ethpb.SignedBeaconBlock{}
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)
@@ -100,10 +106,11 @@ func TestFuzzprocessOperationsNoVerify_1000(t *testing.T) {
 	}
 }
 
-func TestFuzzverifyOperationLengths_10000(_ *testing.T) {
+func TestFuzzverifyOperationLengths_10000(t *testing.T) {
 	SkipSlotCache.Disable()
 	defer SkipSlotCache.Enable()
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	bb := &ethpb.SignedBeaconBlock{}
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)
@@ -115,10 +122,11 @@ func TestFuzzverifyOperationLengths_10000(_ *testing.T) {
 	}
 }
 
-func TestFuzzCanProcessEpoch_10000(_ *testing.T) {
+func TestFuzzCanProcessEpoch_10000(t *testing.T) {
 	SkipSlotCache.Disable()
 	defer SkipSlotCache.Enable()
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)
 	for i := 0; i < 10000; i++ {
@@ -131,7 +139,8 @@ func TestFuzzProcessEpochPrecompute_1000(t *testing.T) {
 	SkipSlotCache.Disable()
 	defer SkipSlotCache.Enable()
 	ctx := context.Background()
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)
 	for i := 0; i < 1000; i++ {
@@ -147,7 +156,8 @@ func TestFuzzProcessBlockForStateRoot_1000(t *testing.T) {
 	SkipSlotCache.Disable()
 	defer SkipSlotCache.Enable()
 	ctx := context.Background()
-	state := &v1.BeaconState{}
+	state, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
 	sb := &ethpb.SignedBeaconBlock{}
 	fuzzer := fuzz.NewWithSeed(0)
 	fuzzer.NilChance(0.1)

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition/interop"
 	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
@@ -60,16 +59,9 @@ func ExecuteStateTransitionNoVerifyAnySig(
 	interop.WriteBlockToDisk(signed, false /* Has the block failed */)
 	interop.WriteStateToDisk(state)
 
-	if features.Get().EnableNextSlotStateCache {
-		state, err = ProcessSlotsUsingNextSlotCache(ctx, state, signed.Block().ParentRoot(), signed.Block().Slot())
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "could not process slots")
-		}
-	} else {
-		state, err = ProcessSlots(ctx, state, signed.Block().Slot())
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "could not process slot")
-		}
+	state, err = ProcessSlotsUsingNextSlotCache(ctx, state, signed.Block().ParentRoot(), signed.Block().Slot())
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "could not process slots")
 	}
 
 	// Execute per block transition.
@@ -135,16 +127,9 @@ func CalculateStateRoot(
 
 	// Execute per slots transition.
 	var err error
-	if features.Get().EnableNextSlotStateCache {
-		state, err = ProcessSlotsUsingNextSlotCache(ctx, state, signed.Block().ParentRoot(), signed.Block().Slot())
-		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not process slots")
-		}
-	} else {
-		state, err = ProcessSlots(ctx, state, signed.Block().Slot())
-		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not process slot")
-		}
+	state, err = ProcessSlotsUsingNextSlotCache(ctx, state, signed.Block().ParentRoot(), signed.Block().Slot())
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not process slots")
 	}
 
 	// Execute per block transition.

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -153,7 +153,7 @@ func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
 
 func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) {
 	beaconState, block := createFullBellatrixBlockWithOperations(t)
-	wsb, err := wrapper.WrappedMergeSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block)
 	require.NoError(t, err)
 	beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
 	require.NoError(t, err)

beacon-chain/core/transition/transition_test.go

@@ -253,7 +253,7 @@ func createFullBlockWithOperations(t *testing.T) (state.BeaconState,
 		},
 		AttestingIndices: []uint64{0, 1},
 	})
-	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
 	require.NoError(t, err)
 	hashTreeRoot, err := signing.ComputeSigningRoot(att1.Data, domain)
 	require.NoError(t, err)
@@ -394,7 +394,9 @@ func TestProcessBlock_OverMaxProposerSlashings(t *testing.T) {
 	}
 	want := fmt.Sprintf("number of proposer slashings (%d) in block body exceeds allowed threshold of %d",
 		len(b.Block.Body.ProposerSlashings), params.BeaconConfig().MaxProposerSlashings)
-	_, err := transition.VerifyOperationLengths(context.Background(), &v1.BeaconState{}, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -409,7 +411,9 @@ func TestProcessBlock_OverMaxAttesterSlashings(t *testing.T) {
 	}
 	want := fmt.Sprintf("number of attester slashings (%d) in block body exceeds allowed threshold of %d",
 		len(b.Block.Body.AttesterSlashings), params.BeaconConfig().MaxAttesterSlashings)
-	_, err := transition.VerifyOperationLengths(context.Background(), &v1.BeaconState{}, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -423,7 +427,9 @@ func TestProcessBlock_OverMaxAttestations(t *testing.T) {
 	}
 	want := fmt.Sprintf("number of attestations (%d) in block body exceeds allowed threshold of %d",
 		len(b.Block.Body.Attestations), params.BeaconConfig().MaxAttestations)
-	_, err := transition.VerifyOperationLengths(context.Background(), &v1.BeaconState{}, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -438,7 +444,9 @@ func TestProcessBlock_OverMaxVoluntaryExits(t *testing.T) {
 	}
 	want := fmt.Sprintf("number of voluntary exits (%d) in block body exceeds allowed threshold of %d",
 		len(b.Block.Body.VoluntaryExits), maxExits)
-	_, err := transition.VerifyOperationLengths(context.Background(), &v1.BeaconState{}, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -558,7 +566,7 @@ func TestProcessSlots_OnlyBellatrixEpoch(t *testing.T) {
 	params.OverrideBeaconConfig(conf)
 	defer params.UseMainnetConfig()
 
-	st, _ := util.DeterministicGenesisStateMerge(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	st, _ := util.DeterministicGenesisStateBellatrix(t, params.BeaconConfig().MaxValidatorsPerCommittee)
 	require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*6))
 	require.Equal(t, version.Bellatrix, st.Version())
 	st, err := transition.ProcessSlots(context.Background(), st, params.BeaconConfig().SlotsPerEpoch*10)
@@ -588,7 +596,7 @@ func TestProcessSlots_OnlyBellatrixEpoch(t *testing.T) {
 	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
 }
 
-func TestProcessSlots_ThroughMergeEpoch(t *testing.T) {
+func TestProcessSlots_ThroughBellatrixEpoch(t *testing.T) {
 	transition.SkipSlotCache.Disable()
 	params.SetupTestConfigCleanup(t)
 	conf := params.BeaconConfig()
@@ -610,3 +618,29 @@ func TestProcessSlotsUsingNextSlotCache(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, types.Slot(5), s.Slot())
 }
+
+func TestProcessSlotsConditionally(t *testing.T) {
+	ctx := context.Background()
+	s, _ := util.DeterministicGenesisState(t, 1)
+
+	t.Run("target slot below current slot", func(t *testing.T) {
+		require.NoError(t, s.SetSlot(5))
+		s, err := transition.ProcessSlotsIfPossible(ctx, s, 4)
+		require.NoError(t, err)
+		assert.Equal(t, types.Slot(5), s.Slot())
+	})
+
+	t.Run("target slot equal current slot", func(t *testing.T) {
+		require.NoError(t, s.SetSlot(5))
+		s, err := transition.ProcessSlotsIfPossible(ctx, s, 5)
+		require.NoError(t, err)
+		assert.Equal(t, types.Slot(5), s.Slot())
+	})
+
+	t.Run("target slot above current slot", func(t *testing.T) {
+		require.NoError(t, s.SetSlot(5))
+		s, err := transition.ProcessSlotsIfPossible(ctx, s, 6)
+		require.NoError(t, err)
+		assert.Equal(t, types.Slot(6), s.Slot())
+	})
+}

beacon-chain/core/validators/BUILD.bazel

@@ -31,6 +31,7 @@ go_test(
         "//beacon-chain/state/v1:go_default_library",
         "//config/params:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",

beacon-chain/core/validators/validator_test.go

@@ -10,6 +10,7 @@ import (
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
@@ -129,8 +130,7 @@ func TestSlashValidator_OK(t *testing.T) {
 	cfg := params.BeaconConfig()
 	slashedState, err := SlashValidator(context.Background(), state, slashedIdx, cfg.MinSlashingPenaltyQuotient, cfg.ProposerRewardQuotient)
 	require.NoError(t, err, "Could not slash validator")
-	state, ok := slashedState.(*v1.BeaconState)
-	require.Equal(t, true, ok)
+	require.Equal(t, true, slashedState.Version() == version.Phase0)
 
 	v, err := state.ValidatorAtIndex(slashedIdx)
 	require.NoError(t, err)

beacon-chain/db/iface/interface.go

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

beacon-chain/db/kv/BUILD.bazel

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

beacon-chain/db/kv/blocks.go

@@ -204,54 +204,30 @@ func (s *Store) BlockRootsBySlot(ctx context.Context, slot types.Slot) (bool, []
 	return len(blockRoots) > 0, blockRoots, nil
 }
 
-// deleteBlock by block root.
-func (s *Store) deleteBlock(ctx context.Context, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteBlock")
+// DeleteBlock from the db
+// This deletes the root entry from all buckets in the blocks DB
+// If the block is finalized this function returns an error
+func (s *Store) DeleteBlock(ctx context.Context, root [32]byte) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.DeleteBlock")
 	defer span.End()
+
+	if err := s.DeleteState(ctx, root); err != nil {
+		return errDeleteFinalized
+	}
+
 	return s.db.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(blocksBucket)
-		enc := bkt.Get(blockRoot[:])
-		if enc == nil {
-			return nil
+		bkt := tx.Bucket(finalizedBlockRootsIndexBucket)
+		if b := bkt.Get(root[:]); b != nil {
+			return errDeleteFinalized
 		}
-		blk, err := unmarshalBlock(ctx, enc)
-		if err != nil {
+
+		if err := tx.Bucket(blocksBucket).Delete(root[:]); err != nil {
 			return err
 		}
-		indicesByBucket := createBlockIndicesFromBlock(ctx, blk.Block())
-		if err := deleteValueForIndices(ctx, indicesByBucket, blockRoot[:], tx); err != nil {
-			return errors.Wrap(err, "could not delete root for DB indices")
-		}
-		s.blockCache.Del(string(blockRoot[:]))
-		return bkt.Delete(blockRoot[:])
-	})
-}
-
-// deleteBlocks by block roots.
-func (s *Store) deleteBlocks(ctx context.Context, blockRoots [][32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteBlocks")
-	defer span.End()
-
-	return s.db.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(blocksBucket)
-		for _, blockRoot := range blockRoots {
-			enc := bkt.Get(blockRoot[:])
-			if enc == nil {
-				return nil
-			}
-			blk, err := unmarshalBlock(ctx, enc)
-			if err != nil {
-				return err
-			}
-			indicesByBucket := createBlockIndicesFromBlock(ctx, blk.Block())
-			if err := deleteValueForIndices(ctx, indicesByBucket, blockRoot[:], tx); err != nil {
-				return errors.Wrap(err, "could not delete root for DB indices")
-			}
-			s.blockCache.Del(string(blockRoot[:]))
-			if err := bkt.Delete(blockRoot[:]); err != nil {
-				return err
-			}
+		if err := tx.Bucket(blockParentRootIndicesBucket).Delete(root[:]); err != nil {
+			return err
 		}
+		s.blockCache.Del(string(root[:]))
 		return nil
 	})
 }
@@ -267,7 +243,6 @@ func (s *Store) SaveBlock(ctx context.Context, signed block.SignedBeaconBlock) e
 	if v, ok := s.blockCache.Get(string(blockRoot[:])); v != nil && ok {
 		return nil
 	}
-
 	return s.SaveBlocks(ctx, []block.SignedBeaconBlock{signed})
 }
 
@@ -636,13 +611,13 @@ func unmarshalBlock(_ context.Context, enc []byte) (block.SignedBeaconBlock, err
 			return nil, err
 		}
 		return wrapper.WrappedAltairSignedBeaconBlock(rawBlock)
-	case hasMergeKey(enc):
-		rawBlock := &ethpb.SignedBeaconBlockMerge{}
+	case hasBellatrixKey(enc):
+		rawBlock := &ethpb.SignedBeaconBlockBellatrix{}
 		err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):])
 		if err != nil {
 			return nil, err
 		}
-		return wrapper.WrappedMergeSignedBeaconBlock(rawBlock)
+		return wrapper.WrappedBellatrixSignedBeaconBlock(rawBlock)
 	default:
 		// Marshal block bytes to phase 0 beacon block.
 		rawBlock := &ethpb.SignedBeaconBlock{}

beacon-chain/db/kv/blocks_test.go

@@ -2,13 +2,13 @@ package kv
 
 import (
 	"context"
-	"sort"
 	"testing"
 
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -46,12 +46,12 @@ var blockTests = []struct {
 	{
 		name: "bellatrix",
 		newBlock: func(slot types.Slot, root []byte) (block.SignedBeaconBlock, error) {
-			b := util.NewBeaconBlockMerge()
+			b := util.NewBeaconBlockBellatrix()
 			b.Block.Slot = slot
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return wrapper.WrappedMergeSignedBeaconBlock(b)
+			return wrapper.WrappedBellatrixSignedBeaconBlock(b)
 		},
 	},
 }
@@ -109,48 +109,6 @@ func TestStore_BlocksCRUD(t *testing.T) {
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
 			assert.Equal(t, true, proto.Equal(blk.Proto(), retrievedBlock.Proto()), "Wanted: %v, received: %v", blk, retrievedBlock)
-			require.NoError(t, db.deleteBlock(ctx, blockRoot))
-			assert.Equal(t, false, db.HasBlock(ctx, blockRoot), "Expected block to have been deleted from the db")
-		})
-	}
-}
-
-func TestStore_BlocksBatchDelete(t *testing.T) {
-	for _, tt := range blockTests {
-		t.Run(tt.name, func(t *testing.T) {
-			db := setupDB(t)
-			ctx := context.Background()
-			numBlocks := 10
-			totalBlocks := make([]block.SignedBeaconBlock, numBlocks)
-			blockRoots := make([][32]byte, 0)
-			oddBlocks := make([]block.SignedBeaconBlock, 0)
-			for i := 0; i < len(totalBlocks); i++ {
-				b, err := tt.newBlock(types.Slot(i), bytesutil.PadTo([]byte("parent"), 32))
-				require.NoError(t, err)
-				totalBlocks[i] = b
-				if i%2 == 0 {
-					r, err := totalBlocks[i].Block().HashTreeRoot()
-					require.NoError(t, err)
-					blockRoots = append(blockRoots, r)
-				} else {
-					oddBlocks = append(oddBlocks, totalBlocks[i])
-				}
-			}
-			require.NoError(t, db.SaveBlocks(ctx, totalBlocks))
-			retrieved, _, err := db.Blocks(ctx, filters.NewFilter().SetParentRoot(bytesutil.PadTo([]byte("parent"), 32)))
-			require.NoError(t, err)
-			assert.Equal(t, numBlocks, len(retrieved), "Unexpected number of blocks received")
-			// We delete all even indexed blocks.
-			require.NoError(t, db.deleteBlocks(ctx, blockRoots))
-			// When we retrieve the data, only the odd indexed blocks should remain.
-			retrieved, _, err = db.Blocks(ctx, filters.NewFilter().SetParentRoot(bytesutil.PadTo([]byte("parent"), 32)))
-			require.NoError(t, err)
-			sort.Slice(retrieved, func(i, j int) bool {
-				return retrieved[i].Block().Slot() < retrieved[j].Block().Slot()
-			})
-			for i, blk := range retrieved {
-				assert.Equal(t, true, proto.Equal(blk.Proto(), oddBlocks[i].Proto()), "Wanted: %v, received: %v", blk, oddBlocks[i])
-			}
 		})
 	}
 }
@@ -206,6 +164,44 @@ func TestStore_BlocksHandleInvalidEndSlot(t *testing.T) {
 	}
 }
 
+func TestStore_DeleteBlock(t *testing.T) {
+	slotsPerEpoch := uint64(params.BeaconConfig().SlotsPerEpoch)
+	db := setupDB(t)
+	ctx := context.Background()
+
+	require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisBlockRoot))
+	blks := makeBlocks(t, 0, slotsPerEpoch*4, genesisBlockRoot)
+	require.NoError(t, db.SaveBlocks(ctx, blks))
+
+	root, err := blks[slotsPerEpoch].Block().HashTreeRoot()
+	require.NoError(t, err)
+	cp := &ethpb.Checkpoint{
+		Epoch: 1,
+		Root:  root[:],
+	}
+	st, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, db.SaveState(ctx, st, root))
+	require.NoError(t, db.SaveFinalizedCheckpoint(ctx, cp))
+
+	root2, err := blks[4*slotsPerEpoch-2].Block().HashTreeRoot()
+	require.NoError(t, err)
+	b, err := db.Block(ctx, root2)
+	require.NoError(t, err)
+	require.NotNil(t, b)
+	require.NoError(t, db.DeleteBlock(ctx, root2))
+	st, err = db.State(ctx, root2)
+	require.NoError(t, err)
+	require.Equal(t, st, nil)
+
+	b, err = db.Block(ctx, root2)
+	require.NoError(t, err)
+	require.Equal(t, b, nil)
+
+	require.ErrorIs(t, db.DeleteBlock(ctx, root), errDeleteFinalized)
+
+}
+
 func TestStore_GenesisBlock(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
@@ -238,8 +234,6 @@ func TestStore_BlocksCRUD_NoCache(t *testing.T) {
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
 			assert.Equal(t, true, proto.Equal(blk.Proto(), retrievedBlock.Proto()), "Wanted: %v, received: %v", blk, retrievedBlock)
-			require.NoError(t, db.deleteBlock(ctx, blockRoot))
-			assert.Equal(t, false, db.HasBlock(ctx, blockRoot), "Expected block to have been deleted from the db")
 		})
 	}
 }
@@ -454,14 +448,6 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			require.NoError(t, err)
 			assert.Equal(t, false, len(highestAt) <= 0, "Got empty highest at slice")
 			assert.Equal(t, true, proto.Equal(block3.Proto(), highestAt[0].Proto()), "Wanted: %v, received: %v", block3, highestAt[0])
-
-			r3, err := block3.Block().HashTreeRoot()
-			require.NoError(t, err)
-			require.NoError(t, db.deleteBlock(ctx, r3))
-
-			highestAt, err = db.HighestSlotBlocksBelow(ctx, 101)
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(block2.Proto(), highestAt[0].Proto()), "Wanted: %v, received: %v", block2, highestAt[0])
 		})
 	}
 }

beacon-chain/db/kv/error.go

@@ -2,6 +2,9 @@ package kv
 
 import "errors"
 
+// errDeleteFinalized is raised when we attempt to delete a finalized block/state
+var errDeleteFinalized = errors.New("cannot delete finalized block or state")
+
 // ErrNotFound can be used directly, or as a wrapped DBError, whenever a db method needs to
 // indicate that a value couldn't be found.
 var ErrNotFound = errors.New("not found in db")

beacon-chain/db/kv/key.go

@@ -10,7 +10,7 @@ func hasAltairKey(enc []byte) bool {
 	return bytes.Equal(enc[:len(altairKey)], altairKey)
 }
 
-func hasMergeKey(enc []byte) bool {
+func hasBellatrixKey(enc []byte) bool {
 	if len(bellatrixKey) >= len(enc) {
 		return false
 	}

beacon-chain/db/kv/kv.go

@@ -105,6 +105,8 @@ 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,
 		params.BeaconIoConfig().ReadWritePermissions,
@@ -114,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,
@@ -146,7 +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,
@@ -161,6 +175,7 @@ func NewKVStore(ctx context.Context, dirPath string, config *Config) (*Store, er
 			powchainBucket,
 			stateSummaryBucket,
 			stateValidatorsBucket,
+			validatedTips,
 			// Indices buckets.
 			attestationHeadBlockRootBucket,
 			attestationSourceRootIndicesBucket,
@@ -178,8 +193,10 @@ func NewKVStore(ctx context.Context, dirPath string, config *Config) (*Store, er
 			migrationsBucket,
 		)
 	}); 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))
 

beacon-chain/db/kv/migration_state_validators_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/golang/snappy"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	v2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
 	"github.com/prysmaticlabs/prysm/config/features"
@@ -19,12 +20,12 @@ import (
 func Test_migrateStateValidators(t *testing.T) {
 	tests := []struct {
 		name  string
-		setup func(t *testing.T, dbStore *Store, state *v1.BeaconState, vals []*v1alpha1.Validator)
-		eval  func(t *testing.T, dbStore *Store, state *v1.BeaconState, vals []*v1alpha1.Validator)
+		setup func(t *testing.T, dbStore *Store, state state.BeaconState, vals []*v1alpha1.Validator)
+		eval  func(t *testing.T, dbStore *Store, state state.BeaconState, vals []*v1alpha1.Validator)
 	}{
 		{
 			name: "only runs once",
-			setup: func(t *testing.T, dbStore *Store, state *v1.BeaconState, vals []*v1alpha1.Validator) {
+			setup: func(t *testing.T, dbStore *Store, state state.BeaconState, vals []*v1alpha1.Validator) {
 				// create some new buckets that should be present for this migration
 				err := dbStore.db.Update(func(tx *bbolt.Tx) error {
 					_, err := tx.CreateBucketIfNotExists(stateValidatorsBucket)
@@ -35,7 +36,7 @@ func Test_migrateStateValidators(t *testing.T) {
 				})
 				assert.NoError(t, err)
 			},
-			eval: func(t *testing.T, dbStore *Store, state *v1.BeaconState, vals []*v1alpha1.Validator) {
+			eval: func(t *testing.T, dbStore *Store, state state.BeaconState, vals []*v1alpha1.Validator) {
 				// check if the migration is completed, per migration table.
 				err := dbStore.db.View(func(tx *bbolt.Tx) error {
 					migrationCompleteOrNot := tx.Bucket(migrationsBucket).Get(migrationStateValidatorsKey)
@@ -47,7 +48,7 @@ func Test_migrateStateValidators(t *testing.T) {
 		},
 		{
 			name: "once migrated, always enable flag",
-			setup: func(t *testing.T, dbStore *Store, state *v1.BeaconState, vals []*v1alpha1.Validator) {
+			setup: func(t *testing.T, dbStore *Store, state state.BeaconState, vals []*v1alpha1.Validator) {
 				// create some new buckets that should be present for this migration
 				err := dbStore.db.Update(func(tx *bbolt.Tx) error {
 					_, err := tx.CreateBucketIfNotExists(stateValidatorsBucket)
@@ -58,7 +59,7 @@ func Test_migrateStateValidators(t *testing.T) {
 				})
 				assert.NoError(t, err)
 			},
-			eval: func(t *testing.T, dbStore *Store, state *v1.BeaconState, vals []*v1alpha1.Validator) {
+			eval: func(t *testing.T, dbStore *Store, state state.BeaconState, vals []*v1alpha1.Validator) {
 				// disable the flag and see if the code mandates that flag.
 				resetCfg := features.InitWithReset(&features.Flags{
 					EnableHistoricalSpaceRepresentation: false,
@@ -111,7 +112,7 @@ func Test_migrateStateValidators(t *testing.T) {
 		},
 		{
 			name: "migrates validators and adds them to new buckets",
-			setup: func(t *testing.T, dbStore *Store, state *v1.BeaconState, vals []*v1alpha1.Validator) {
+			setup: func(t *testing.T, dbStore *Store, state state.BeaconState, vals []*v1alpha1.Validator) {
 				// create some new buckets that should be present for this migration
 				err := dbStore.db.Update(func(tx *bbolt.Tx) error {
 					_, err := tx.CreateBucketIfNotExists(stateValidatorsBucket)
@@ -122,7 +123,7 @@ func Test_migrateStateValidators(t *testing.T) {
 				})
 				assert.NoError(t, err)
 			},
-			eval: func(t *testing.T, dbStore *Store, state *v1.BeaconState, vals []*v1alpha1.Validator) {
+			eval: func(t *testing.T, dbStore *Store, state state.BeaconState, vals []*v1alpha1.Validator) {
 				// check whether the new buckets are present
 				err := dbStore.db.View(func(tx *bbolt.Tx) error {
 					valBkt := tx.Bucket(stateValidatorsBucket)
@@ -209,12 +210,12 @@ func Test_migrateStateValidators(t *testing.T) {
 func Test_migrateAltairStateValidators(t *testing.T) {
 	tests := []struct {
 		name  string
-		setup func(t *testing.T, dbStore *Store, state *v2.BeaconState, vals []*v1alpha1.Validator)
-		eval  func(t *testing.T, dbStore *Store, state *v2.BeaconState, vals []*v1alpha1.Validator)
+		setup func(t *testing.T, dbStore *Store, state state.BeaconStateAltair, vals []*v1alpha1.Validator)
+		eval  func(t *testing.T, dbStore *Store, state state.BeaconStateAltair, vals []*v1alpha1.Validator)
 	}{
 		{
 			name: "migrates validators and adds them to new buckets",
-			setup: func(t *testing.T, dbStore *Store, state *v2.BeaconState, vals []*v1alpha1.Validator) {
+			setup: func(t *testing.T, dbStore *Store, state state.BeaconStateAltair, vals []*v1alpha1.Validator) {
 				// create some new buckets that should be present for this migration
 				err := dbStore.db.Update(func(tx *bbolt.Tx) error {
 					_, err := tx.CreateBucketIfNotExists(stateValidatorsBucket)
@@ -225,7 +226,7 @@ func Test_migrateAltairStateValidators(t *testing.T) {
 				})
 				assert.NoError(t, err)
 			},
-			eval: func(t *testing.T, dbStore *Store, state *v2.BeaconState, vals []*v1alpha1.Validator) {
+			eval: func(t *testing.T, dbStore *Store, state state.BeaconStateAltair, vals []*v1alpha1.Validator) {
 				// check whether the new buckets are present
 				err := dbStore.db.View(func(tx *bbolt.Tx) error {
 					valBkt := tx.Bucket(stateValidatorsBucket)
@@ -300,9 +301,9 @@ func Test_migrateAltairStateValidators(t *testing.T) {
 			})
 			defer resetCfg()
 
-			tt.setup(t, dbStore, st.(*v2.BeaconState), vals)
+			tt.setup(t, dbStore, st, vals)
 			assert.NoError(t, migrateStateValidators(context.Background(), dbStore.db), "migrateArchivedIndex(tx) error")
-			tt.eval(t, dbStore, st.(*v2.BeaconState), vals)
+			tt.eval(t, dbStore, st, vals)
 		})
 	}
 }

beacon-chain/db/kv/schema.go

@@ -18,6 +18,7 @@ var (
 	checkpointBucket        = []byte("check-point")
 	powchainBucket          = []byte("powchain")
 	stateValidatorsBucket   = []byte("state-validators")
+	validatedTips           = []byte("validated-synced-tips")
 
 	// Deprecated: This bucket was migrated in PR 6461. Do not use, except for migrations.
 	slotsHasObjectBucket = []byte("slots-has-objects")