Update optimistic_sync.go

.bazelversion

@@ -1 +1 @@
-5.0.0
+4.2.2

.buildkite-bazelrc

@@ -10,26 +10,26 @@
 
 # Prysm specific remote-cache properties.
 #build:remote-cache --disk_cache=
-build:remote-cache --remote_download_minimal
+build:remote-cache --remote_download_toplevel
 build:remote-cache --remote_cache=grpc://bazel-remote-cache:9092
 build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
 build:remote-cache --remote_local_fallback
-build:remote-cache --experimental_remote_cache_async
-build:remote-cache --experimental_remote_merkle_tree_cache
-build:remote-cache --experimental_action_cache_store_output_metadata
-build:remote-cache --experimental_remote_cache_compression
 # Enforce stricter environment rules, which eliminates some non-hermetic
 # behavior and therefore improves both the remote cache hit rate and the
 # correctness and repeatability of the build.
 build:remote-cache --incompatible_strict_action_env=true
 
-build --experimental_use_hermetic_linux_sandbox
-
 # Import workspace options.
 import %workspace%/.bazelrc
 
-startup --host_jvm_args=-Xmx4g --host_jvm_args=-Xms2g
+startup --host_jvm_args=-Xmx2g --host_jvm_args=-Xms2g
+query --repository_cache=/tmp/repositorycache
+query --experimental_repository_cache_hardlinks
+build --repository_cache=/tmp/repositorycache
+build --experimental_repository_cache_hardlinks
 build --experimental_strict_action_env
+build --disk_cache=/tmp/bazelbuilds
+build --experimental_multi_threaded_digest
 build --sandbox_tmpfs_path=/tmp
 build --verbose_failures
 build --announce_rc

.github/actions/gomodtidy/entrypoint.sh

@@ -7,7 +7,7 @@ cd $GITHUB_WORKSPACE
 cp go.mod go.mod.orig
 cp go.sum go.sum.orig
 
-go mod tidy -compat=1.17
+go mod tidy
 
 echo "Checking go.mod and go.sum:"
 checks=0

BUILD.bazel

@@ -3,7 +3,7 @@ load("@com_github_atlassian_bazel_tools//gometalinter:def.bzl", "gometalinter")
 load("@com_github_atlassian_bazel_tools//goimports:def.bzl", "goimports")
 load("@io_kubernetes_build//defs:run_in_workspace.bzl", "workspace_binary")
 load("@io_bazel_rules_go//go:def.bzl", "nogo")
-load("@vaticle_bazel_distribution//common:rules.bzl", "assemble_targz", "assemble_versioned")
+load("@graknlabs_bazel_distribution//common:rules.bzl", "assemble_targz", "assemble_versioned")
 load("@bazel_skylib//rules:common_settings.bzl", "string_setting")
 
 prefix = "github.com/prysmaticlabs/prysm"

WORKSPACE

@@ -117,6 +117,13 @@ http_archive(
     urls = ["https://github.com/fuzzitdev/fuzzit/releases/download/v2.4.76/fuzzit_Linux_x86_64.zip"],
 )
 
+git_repository(
+    name = "graknlabs_bazel_distribution",
+    commit = "962f3a7e56942430c0ec120c24f9e9f2a9c2ce1a",
+    remote = "https://github.com/graknlabs/bazel-distribution",
+    shallow_since = "1569509514 +0300",
+)
+
 load(
     "@io_bazel_rules_docker//repositories:repositories.bzl",
     container_repositories = "repositories",
@@ -215,7 +222,7 @@ filegroup(
     url = "https://github.com/eth-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
 )
 
-consensus_spec_version = "v1.1.10"
+consensus_spec_version = "v1.1.9"
 
 bls_test_version = "v0.1.1"
 
@@ -231,7 +238,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "28043009cc2f6fc9804e73c8c1fc2cb27062f1591e6884f3015ae1dd7a276883",
+    sha256 = "207d9c326ba4fa1f34bab7b6169201c32f2611755db030909a3405873445e0ba",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -247,7 +254,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "bc1a283ca068f310f04d70c4f6a8eaa0b8f7e9318073a8bdc2ee233111b4e339",
+    sha256 = "a3995b39f412db236b2f1db909f288218da53cb53b9923b71dda9d144d68f40a",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -263,7 +270,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "bbabb482c229ff9d4e2c7b77c992edb452f9d0af7c6d8dd4f922f06a7b101e81",
+    sha256 = "76cea7a4c8e32d458ad456b54bfbb30bc772481a91954a4cd97e229aa3023b1d",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -278,7 +285,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "408a5524548ad3fcf387f65ac7ec52781d9ee899499720bb12451b48a15818d4",
+    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,
 )

api/client/beacon/BUILD.bazel

@@ -1,54 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "checkpoint.go",
-        "client.go",
-        "doc.go",
-        "errors.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/api/client/beacon",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/rpc/apimiddleware:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//encoding/ssz/detect:go_default_library",
-        "//io/file:go_default_library",
-        "//network/forks:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/block:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@org_golang_x_mod//semver:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "checkpoint_test.go",
-        "client_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/state:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/ssz/detect:go_default_library",
-        "//network/forks:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/wrapper:go_default_library",
-        "//runtime/version:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
-    ],
-)

api/client/beacon/checkpoint.go

@@ -1,262 +0,0 @@
-package beacon
-
-import (
-	"context"
-	"fmt"
-	"path"
-
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/encoding/ssz/detect"
-	"github.com/prysmaticlabs/prysm/io/file"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/time/slots"
-	log "github.com/sirupsen/logrus"
-	"golang.org/x/mod/semver"
-)
-
-// OriginData represents the BeaconState and SignedBeaconBlock necessary to start an empty Beacon Node
-// using Checkpoint Sync.
-type OriginData struct {
-	wsd *WeakSubjectivityData
-	sb  []byte
-	bb  []byte
-	st  state.BeaconState
-	b   block.SignedBeaconBlock
-	cf  *detect.VersionedUnmarshaler
-}
-
-// CheckpointString returns the standard string representation of a Checkpoint for the block root and epoch for the
-// SignedBeaconBlock value found by DownloadOriginData.
-// The format is a a hex-encoded block root, followed by the epoch of the block, separated by a colon. For example:
-// "0x1c35540cac127315fabb6bf29181f2ae0de1a3fc909d2e76ba771e61312cc49a:74888"
-func (od *OriginData) CheckpointString() string {
-	return fmt.Sprintf("%#x:%d", od.wsd.BlockRoot, od.wsd.Epoch)
-}
-
-// SaveBlock saves the downloaded block to a unique file in the given path.
-// For readability and collision avoidance, the file name includes: type, config name, slot and root
-func (od *OriginData) SaveBlock(dir string) (string, error) {
-	blockPath := path.Join(dir, fname("state", od.cf, od.st.Slot(), od.wsd.BlockRoot))
-	return blockPath, file.WriteFile(blockPath, od.sb)
-}
-
-// SaveState saves the downloaded state to a unique file in the given path.
-// For readability and collision avoidance, the file name includes: type, config name, slot and root
-func (od *OriginData) SaveState(dir string) (string, error) {
-	statePath := path.Join(dir, fname("state", od.cf, od.st.Slot(), od.wsd.StateRoot))
-	return statePath, file.WriteFile(statePath, od.sb)
-}
-
-// StateBytes returns the ssz-encoded bytes of the downloaded BeaconState value.
-func (od *OriginData) StateBytes() []byte {
-	return od.sb
-}
-
-// BlockBytes returns the ssz-encoded bytes of the downloaded SignedBeaconBlock value.
-func (od *OriginData) BlockBytes() []byte {
-	return od.bb
-}
-
-func fname(prefix string, cf *detect.VersionedUnmarshaler, slot types.Slot, root [32]byte) string {
-	return fmt.Sprintf("%s_%s_%s_%d-%#x.ssz", prefix, cf.Config.ConfigName, version.String(cf.Fork), slot, root)
-}
-
-// this method downloads the head state, which can be used to find the correct chain config
-// and use prysm's helper methods to compute the latest weak subjectivity epoch.
-func getWeakSubjectivityEpochFromHead(ctx context.Context, client *Client) (types.Epoch, error) {
-	headBytes, err := client.GetState(ctx, IdHead)
-	if err != nil {
-		return 0, err
-	}
-	cf, err := detect.FromState(headBytes)
-	if err != nil {
-		return 0, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in remote head state, name=%s, fork=%s", cf.Config.ConfigName, version.String(cf.Fork))
-	headState, err := cf.UnmarshalBeaconState(headBytes)
-	if err != nil {
-		return 0, errors.Wrap(err, "error unmarshaling state to correct version")
-	}
-
-	epoch, err := helpers.LatestWeakSubjectivityEpoch(ctx, headState, cf.Config)
-	if err != nil {
-		return 0, errors.Wrap(err, "error computing the weak subjectivity epoch from head state")
-	}
-
-	log.Printf("(computed client-side) weak subjectivity epoch = %d", epoch)
-	return epoch, nil
-}
-
-const (
-	prysmMinimumVersion     = "v2.0.7"
-	prysmImplementationName = "Prysm"
-)
-
-// ErrUnsupportedPrysmCheckpointVersion indicates remote beacon node can't be used for checkpoint retrieval.
-var ErrUnsupportedPrysmCheckpointVersion = errors.New("node does not meet minimum version requirements for checkpoint retrieval")
-
-// for older endpoints or clients that do not support the weak_subjectivity api method
-// we gather the necessary data for a checkpoint sync by:
-// - inspecting the remote server's head state and computing the weak subjectivity epoch locally
-// - requesting the state at the first slot of the epoch
-// - using hash_tree_root(state.latest_block_header) to compute the block the state integrates
-// - requesting that block by its root
-func downloadBackwardsCompatible(ctx context.Context, client *Client) (*OriginData, error) {
-	log.Print("falling back to generic checkpoint derivation, weak_subjectivity API not supported by server")
-	nv, err := client.GetNodeVersion(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to proceed with fallback method without confirming node version")
-	}
-	if nv.implementation == prysmImplementationName && semver.Compare(nv.semver, prysmMinimumVersion) < 0 {
-		return nil, errors.Wrapf(ErrUnsupportedPrysmCheckpointVersion, "%s < minimum (%s)", nv.semver, prysmMinimumVersion)
-	}
-	epoch, err := getWeakSubjectivityEpochFromHead(ctx, client)
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing weak subjectivity epoch via head state inspection")
-	}
-
-	// use first slot of the epoch for the state slot
-	slot, err := slots.EpochStart(epoch)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error computing first slot of epoch=%d", epoch)
-	}
-
-	log.Printf("requesting checkpoint state at slot %d", slot)
-	// get the state at the first slot of the epoch
-	stateBytes, err := client.GetState(ctx, IdFromSlot(slot))
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to request state by slot from api, slot=%d", slot)
-	}
-
-	// ConfigFork is used to unmarshal the BeaconState so we can read the block root in latest_block_header
-	cf, err := detect.FromState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", cf.Config.ConfigName, version.String(cf.Fork))
-
-	st, err := cf.UnmarshalBeaconState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error using detected config fork to unmarshal state bytes")
-	}
-
-	// compute state and block roots
-	stateRoot, err := st.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of state")
-	}
-
-	header := st.LatestBlockHeader()
-	header.StateRoot = stateRoot[:]
-	computedBlockRoot, err := header.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error while computing block root using state data")
-	}
-
-	blockBytes, err := client.GetBlock(ctx, IdFromRoot(computedBlockRoot))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting block by root = %d", computedBlockRoot)
-	}
-	block, err := cf.UnmarshalBeaconBlock(blockBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
-	}
-	blockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root for block obtained via root")
-	}
-
-	log.Printf("BeaconState slot=%d, Block slot=%d", st.Slot(), block.Block().Slot())
-	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", stateRoot, block.Block().StateRoot())
-	log.Printf("BeaconBlock root computed from state=%#x, Block htr=%#x", computedBlockRoot, blockRoot)
-
-	return &OriginData{
-		wsd: &WeakSubjectivityData{
-			BlockRoot: blockRoot,
-			StateRoot: stateRoot,
-			Epoch:     epoch,
-		},
-		st: st,
-		sb: stateBytes,
-		b:  block,
-		bb: blockBytes,
-		cf: cf,
-	}, nil
-}
-
-// DownloadOriginData attempts to use the proposed weak_subjectivity beacon node api
-// to obtain the weak_subjectivity metadata (epoch, block_root, state_root) needed to sync
-// a beacon node from the canonical weak subjectivity checkpoint. As this is a proposed API
-// that will only be supported by prysm at first, in the event of a 404 we fallback to using a
-// different technique where we first download the head state which can be used to compute the
-// weak subjectivity epoch on the client side.
-func DownloadOriginData(ctx context.Context, client *Client) (*OriginData, error) {
-	ws, err := client.GetWeakSubjectivity(ctx)
-	if err != nil {
-		// a 404/405 is expected if querying an endpoint that doesn't support the weak subjectivity checkpoint api
-		if !errors.Is(err, ErrNotOK) {
-			return nil, errors.Wrap(err, "unexpected API response for prysm-only weak subjectivity checkpoint API")
-		}
-		// fall back to vanilla Beacon Node API method
-		return downloadBackwardsCompatible(ctx, client)
-	}
-	log.Printf("server weak subjectivity checkpoint response - epoch=%d, block_root=%#x, state_root=%#x", ws.Epoch, ws.BlockRoot, ws.StateRoot)
-
-	// use first slot of the epoch for the block slot
-	slot, err := slots.EpochStart(ws.Epoch)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error computing first slot of epoch=%d", ws.Epoch)
-	}
-	log.Printf("requesting checkpoint state at slot %d", slot)
-
-	stateBytes, err := client.GetState(ctx, IdFromSlot(slot))
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to request state by slot from api, slot=%d", slot)
-	}
-	cf, err := detect.FromState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", cf.Config.ConfigName, version.String(cf.Fork))
-
-	state, err := cf.UnmarshalBeaconState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error using detected config fork to unmarshal state bytes")
-	}
-	stateRoot, err := state.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to compute htr for state at slot=%d", slot)
-	}
-
-	blockRoot, err := state.LatestBlockHeader().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of latest_block_header")
-	}
-	blockBytes, err := client.GetBlock(ctx, IdFromRoot(ws.BlockRoot))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting block by slot = %d", slot)
-	}
-	block, err := cf.UnmarshalBeaconBlock(blockBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
-	}
-	realBlockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of retrieved block")
-	}
-	log.Printf("BeaconState slot=%d, Block slot=%d", state.Slot(), block.Block().Slot())
-	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", stateRoot, block.Block().StateRoot())
-	log.Printf("BeaconState latest_block_header htr=%#xd, block htr=%#x", blockRoot, realBlockRoot)
-	return &OriginData{
-		wsd: ws,
-		st:  state,
-		b:   block,
-		sb:  stateBytes,
-		bb:  blockBytes,
-		cf:  cf,
-	}, nil
-}

api/client/beacon/checkpoint_test.go

@@ -1,407 +0,0 @@
-package beacon
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/network/forks"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"github.com/prysmaticlabs/prysm/time/slots"
-
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/ssz/detect"
-	"github.com/prysmaticlabs/prysm/runtime/version"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-type testRT struct {
-	rt func(*http.Request) (*http.Response, error)
-}
-
-func (rt *testRT) RoundTrip(req *http.Request) (*http.Response, error) {
-	if rt.rt != nil {
-		return rt.rt(req)
-	}
-	return nil, errors.New("RoundTripper not implemented")
-}
-
-var _ http.RoundTripper = &testRT{}
-
-func marshalToEnvelope(val interface{}) ([]byte, error) {
-	raw, err := json.Marshal(val)
-	if err != nil {
-		return nil, errors.Wrap(err, "error marshaling value to place in data envelope")
-	}
-	env := struct {
-		Data json.RawMessage `json:"data"`
-	}{
-		Data: raw,
-	}
-	return json.Marshal(env)
-}
-
-func TestMarshalToEnvelope(t *testing.T) {
-	d := struct {
-		Version string `json:"version"`
-	}{
-		Version: "Prysm/v2.0.5 (linux amd64)",
-	}
-	encoded, err := marshalToEnvelope(d)
-	require.NoError(t, err)
-	expected := `{"data":{"version":"Prysm/v2.0.5 (linux amd64)"}}`
-	require.Equal(t, expected, string(encoded))
-}
-
-func TestFallbackVersionCheck(t *testing.T) {
-	c := &Client{
-		hc:     &http.Client{},
-		host:   "localhost:3500",
-		scheme: "http",
-	}
-	c.hc.Transport = &testRT{rt: func(req *http.Request) (*http.Response, error) {
-		res := &http.Response{Request: req}
-		switch req.URL.Path {
-		case getNodeVersionPath:
-			res.StatusCode = http.StatusOK
-			b := bytes.NewBuffer(nil)
-			d := struct {
-				Version string `json:"version"`
-			}{
-				Version: "Prysm/v2.0.5 (linux amd64)",
-			}
-			encoded, err := marshalToEnvelope(d)
-			require.NoError(t, err)
-			b.Write(encoded)
-			res.Body = io.NopCloser(b)
-		case getWeakSubjectivityPath:
-			res.StatusCode = http.StatusNotFound
-		}
-
-		return res, nil
-	}}
-
-	ctx := context.Background()
-	_, err := DownloadOriginData(ctx, c)
-	require.ErrorIs(t, err, ErrUnsupportedPrysmCheckpointVersion)
-}
-
-func TestFname(t *testing.T) {
-	vu := &detect.VersionedUnmarshaler{
-		Config: params.MainnetConfig(),
-		Fork:   version.Phase0,
-	}
-	slot := types.Slot(23)
-	prefix := "block"
-	var root [32]byte
-	copy(root[:], []byte{0x23, 0x23, 0x23})
-	expected := "block_mainnet_phase0_23-0x2323230000000000000000000000000000000000000000000000000000000000.ssz"
-	actual := fname(prefix, vu, slot, root)
-	require.Equal(t, expected, actual)
-
-	vu.Config = params.MinimalSpecConfig()
-	vu.Fork = version.Altair
-	slot = 17
-	prefix = "state"
-	copy(root[29:], []byte{0x17, 0x17, 0x17})
-	expected = "state_minimal_altair_17-0x2323230000000000000000000000000000000000000000000000000000171717.ssz"
-	actual = fname(prefix, vu, slot, root)
-	require.Equal(t, expected, actual)
-}
-
-func TestDownloadOriginData(t *testing.T) {
-	ctx := context.Background()
-	cfg := params.MainnetConfig()
-
-	epoch := cfg.AltairForkEpoch - 1
-	// set up checkpoint state, using the epoch that will be computed as the ws checkpoint state based on the head state
-	wSlot, err := slots.EpochStart(epoch)
-	require.NoError(t, err)
-	wst, err := util.NewBeaconState()
-	require.NoError(t, err)
-	fork, err := forkForEpoch(cfg, epoch)
-	require.NoError(t, wst.SetFork(fork))
-
-	// set up checkpoint block
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, wrapper.SetBlockParentRoot(b, cfg.ZeroHash))
-	require.NoError(t, wrapper.SetBlockSlot(b, wSlot))
-	require.NoError(t, wrapper.SetProposerIndex(b, 0))
-
-	// set up state header pointing at checkpoint block - this is how the block is downloaded by root
-	header, err := b.Header()
-	require.NoError(t, err)
-	require.NoError(t, wst.SetLatestBlockHeader(header.Header))
-
-	// order of operations can be confusing here:
-	// - when computing the state root, make sure block header is complete, EXCEPT the state root should be zero-value
-	// - before computing the block root (to match the request route), the block should include the state root
-	//   *computed from the state with a header that does not have a state root set yet*
-	wRoot, err := wst.HashTreeRoot(ctx)
-	require.NoError(t, err)
-
-	require.NoError(t, wrapper.SetBlockStateRoot(b, wRoot))
-	serBlock, err := b.MarshalSSZ()
-	require.NoError(t, err)
-	bRoot, err := b.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	wsSerialized, err := wst.MarshalSSZ()
-	require.NoError(t, err)
-	expectedWSD := WeakSubjectivityData{
-		BlockRoot: bRoot,
-		StateRoot: wRoot,
-		Epoch:     epoch,
-	}
-
-	hc := &http.Client{
-		Transport: &testRT{rt: func(req *http.Request) (*http.Response, error) {
-			res := &http.Response{Request: req}
-			switch req.URL.Path {
-			case getWeakSubjectivityPath:
-				res.StatusCode = http.StatusOK
-				cp := struct {
-					Epoch string `json:"epoch"`
-					Root  string `json:"root"`
-				}{
-					Epoch: fmt.Sprintf("%d", slots.ToEpoch(b.Block().Slot())),
-					Root:  fmt.Sprintf("%#x", bRoot),
-				}
-				wsr := struct {
-					Checkpoint interface{} `json:"ws_checkpoint"`
-					StateRoot  string      `json:"state_root"`
-				}{
-					Checkpoint: cp,
-					StateRoot:  fmt.Sprintf("%#x", wRoot),
-				}
-				rb, err := marshalToEnvelope(wsr)
-				require.NoError(t, err)
-				res.Body = io.NopCloser(bytes.NewBuffer(rb))
-			case renderGetStatePath(IdFromSlot(wSlot)):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(wsSerialized))
-			case renderGetBlockPath(IdFromRoot(bRoot)):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(serBlock))
-			}
-
-			return res, nil
-		}},
-	}
-	c := &Client{
-		hc:     hc,
-		host:   "localhost:3500",
-		scheme: "http",
-	}
-
-	od, err := DownloadOriginData(ctx, c)
-	require.NoError(t, err)
-	require.Equal(t, expectedWSD.Epoch, od.wsd.Epoch)
-	require.Equal(t, expectedWSD.StateRoot, od.wsd.StateRoot)
-	require.Equal(t, expectedWSD.BlockRoot, od.wsd.BlockRoot)
-	require.DeepEqual(t, wsSerialized, od.sb)
-	require.DeepEqual(t, serBlock, od.bb)
-	require.DeepEqual(t, wst.Fork().CurrentVersion, od.cf.Version[:])
-	require.DeepEqual(t, version.Phase0, od.cf.Fork)
-}
-
-// runs downloadBackwardsCompatible directly
-// and via DownloadOriginData with a round tripper that triggers the backwards compatible code path
-func TestDownloadBackwardsCompatibleCombined(t *testing.T) {
-	ctx := context.Background()
-	cfg := params.MainnetConfig()
-
-	st, expectedEpoch := defaultTestHeadState(t, cfg)
-	serialized, err := st.MarshalSSZ()
-	require.NoError(t, err)
-
-	// set up checkpoint state, using the epoch that will be computed as the ws checkpoint state based on the head state
-	wSlot, err := slots.EpochStart(expectedEpoch)
-	require.NoError(t, err)
-	wst, err := util.NewBeaconState()
-	require.NoError(t, err)
-	fork, err := forkForEpoch(cfg, cfg.GenesisEpoch)
-	require.NoError(t, wst.SetFork(fork))
-
-	// set up checkpoint block
-	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, wrapper.SetBlockParentRoot(b, cfg.ZeroHash))
-	require.NoError(t, wrapper.SetBlockSlot(b, wSlot))
-	require.NoError(t, wrapper.SetProposerIndex(b, 0))
-
-	// set up state header pointing at checkpoint block - this is how the block is downloaded by root
-	header, err := b.Header()
-	require.NoError(t, err)
-	require.NoError(t, wst.SetLatestBlockHeader(header.Header))
-
-	// order of operations can be confusing here:
-	// - when computing the state root, make sure block header is complete, EXCEPT the state root should be zero-value
-	// - before computing the block root (to match the request route), the block should include the state root
-	//   *computed from the state with a header that does not have a state root set yet*
-	wRoot, err := wst.HashTreeRoot(ctx)
-	require.NoError(t, err)
-
-	require.NoError(t, wrapper.SetBlockStateRoot(b, wRoot))
-	serBlock, err := b.MarshalSSZ()
-	require.NoError(t, err)
-	bRoot, err := b.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	wsSerialized, err := wst.MarshalSSZ()
-	require.NoError(t, err)
-
-	hc := &http.Client{
-		Transport: &testRT{rt: func(req *http.Request) (*http.Response, error) {
-			res := &http.Response{Request: req}
-			switch req.URL.Path {
-			case getNodeVersionPath:
-				res.StatusCode = http.StatusOK
-				b := bytes.NewBuffer(nil)
-				d := struct {
-					Version string `json:"version"`
-				}{
-					Version: "Lighthouse/v0.1.5 (Linux x86_64)",
-				}
-				encoded, err := marshalToEnvelope(d)
-				require.NoError(t, err)
-				b.Write(encoded)
-				res.Body = io.NopCloser(b)
-			case getWeakSubjectivityPath:
-				res.StatusCode = http.StatusNotFound
-			case renderGetStatePath(IdHead):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(serialized))
-			case renderGetStatePath(IdFromSlot(wSlot)):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(wsSerialized))
-			case renderGetBlockPath(IdFromRoot(bRoot)):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(serBlock))
-			}
-
-			return res, nil
-		}},
-	}
-	c := &Client{
-		hc:     hc,
-		host:   "localhost:3500",
-		scheme: "http",
-	}
-
-	odPub, err := DownloadOriginData(ctx, c)
-	require.NoError(t, err)
-
-	odPriv, err := downloadBackwardsCompatible(ctx, c)
-	require.NoError(t, err)
-	require.DeepEqual(t, odPriv.wsd, odPub.wsd)
-	require.DeepEqual(t, odPriv.sb, odPub.sb)
-	require.DeepEqual(t, odPriv.bb, odPub.bb)
-	require.DeepEqual(t, odPriv.cf.Fork, odPub.cf.Fork)
-	require.DeepEqual(t, odPriv.cf.Version, odPub.cf.Version)
-}
-
-func TestGetWeakSubjectivityEpochFromHead(t *testing.T) {
-	st, expectedEpoch := defaultTestHeadState(t, params.MainnetConfig())
-	serialized, err := st.MarshalSSZ()
-	require.NoError(t, err)
-	hc := &http.Client{
-		Transport: &testRT{rt: func(req *http.Request) (*http.Response, error) {
-			res := &http.Response{Request: req}
-			switch req.URL.Path {
-			case renderGetStatePath(IdHead):
-				res.StatusCode = http.StatusOK
-				res.Body = io.NopCloser(bytes.NewBuffer(serialized))
-			}
-			return res, nil
-		}},
-	}
-	c := &Client{
-		hc:     hc,
-		host:   "localhost:3500",
-		scheme: "http",
-	}
-	actualEpoch, err := getWeakSubjectivityEpochFromHead(context.Background(), c)
-	require.NoError(t, err)
-	require.Equal(t, expectedEpoch, actualEpoch)
-}
-
-func forkForEpoch(cfg *params.BeaconChainConfig, epoch types.Epoch) (*ethpb.Fork, error) {
-	os := forks.NewOrderedSchedule(cfg)
-	currentVersion, err := os.VersionForEpoch(epoch)
-	if err != nil {
-		return nil, err
-	}
-	prevVersion, err := os.Previous(currentVersion)
-	if err != nil {
-		if !errors.Is(err, forks.ErrNoPreviousVersion) {
-			return nil, err
-		}
-		// use same version for both in the case of genesis
-		prevVersion = currentVersion
-	}
-	forkEpoch := cfg.ForkVersionSchedule[currentVersion]
-	return &ethpb.Fork{
-		PreviousVersion: prevVersion[:],
-		CurrentVersion:  currentVersion[:],
-		Epoch:           forkEpoch,
-	}, nil
-}
-
-func defaultTestHeadState(t *testing.T, cfg *params.BeaconChainConfig) (state.BeaconState, types.Epoch) {
-	st, err := util.NewBeaconStateAltair()
-	require.NoError(t, err)
-
-	fork, err := forkForEpoch(cfg, cfg.AltairForkEpoch)
-	require.NoError(t, err)
-	require.NoError(t, st.SetFork(fork))
-
-	slot, err := slots.EpochStart(cfg.AltairForkEpoch)
-	require.NoError(t, err)
-	require.NoError(t, st.SetSlot(slot))
-
-	var validatorCount, avgBalance uint64 = 100, 35
-	require.NoError(t, populateValidators(cfg, st, validatorCount, avgBalance))
-	require.NoError(t, st.SetFinalizedCheckpoint(&ethpb.Checkpoint{
-		Epoch: fork.Epoch - 10,
-		Root:  make([]byte, 32),
-	}))
-	// to see the math for this, look at helpers.LatestWeakSubjectivityEpoch
-	// and for the values use mainnet config values, the validatorCount and avgBalance above, and altair fork epoch
-	expectedEpoch := slots.ToEpoch(st.Slot()) - 224
-	return st, expectedEpoch
-}
-
-// TODO(10429): refactor beacon state options in testing/util to take a state.BeaconState so this can become an option
-func populateValidators(cfg *params.BeaconChainConfig, st state.BeaconState, valCount, avgBalance uint64) error {
-	validators := make([]*ethpb.Validator, valCount)
-	balances := make([]uint64, len(validators))
-	for i := uint64(0); i < valCount; i++ {
-		validators[i] = &ethpb.Validator{
-			PublicKey:             make([]byte, cfg.BLSPubkeyLength),
-			WithdrawalCredentials: make([]byte, 32),
-			EffectiveBalance:      avgBalance * 1e9,
-			ExitEpoch:             cfg.FarFutureEpoch,
-		}
-		balances[i] = validators[i].EffectiveBalance
-	}
-
-	if err := st.SetValidators(validators); err != nil {
-		return err
-	}
-	if err := st.SetBalances(balances); err != nil {
-		return err
-	}
-
-	return nil
-}

api/client/beacon/client.go

@@ -1,437 +0,0 @@
-package beacon
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/url"
-	"path"
-	"regexp"
-	"sort"
-	"strconv"
-	"text/template"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/network/forks"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/apimiddleware"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	log "github.com/sirupsen/logrus"
-)
-
-const (
-	getSignedBlockPath      = "/eth/v2/beacon/blocks"
-	getBlockRootPath        = "/eth/v1/beacon/blocks/{{.Id}}/root"
-	getForkForStatePath     = "/eth/v1/beacon/states/{{.Id}}/fork"
-	getWeakSubjectivityPath = "/eth/v1/beacon/weak_subjectivity"
-	getForkSchedulePath     = "/eth/v1/config/fork_schedule"
-	getStatePath            = "/eth/v2/debug/beacon/states"
-	getNodeVersionPath      = "/eth/v1/node/version"
-)
-
-// StateOrBlockId represents the block_id / state_id parameters that several of the Eth Beacon API methods accept.
-// StateOrBlockId constants are defined for named identifiers, and helper methods are provided
-// for slot and root identifiers. Example text from the Eth Beacon Node API documentation:
-//
-// "Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded blockRoot with 0x prefix>."
-type StateOrBlockId string
-
-const (
-	IdFinalized StateOrBlockId = "finalized"
-	IdGenesis   StateOrBlockId = "genesis"
-	IdHead      StateOrBlockId = "head"
-	IdJustified StateOrBlockId = "justified"
-)
-
-// IdFromRoot encodes a block root in the format expected by the API in places where a root can be used to identify
-// a BeaconState or SignedBeaconBlock.
-func IdFromRoot(r [32]byte) StateOrBlockId {
-	return StateOrBlockId(fmt.Sprintf("%#x", r))
-}
-
-// IdFromRoot encodes a Slot in the format expected by the API in places where a slot can be used to identify
-// a BeaconState or SignedBeaconBlock.
-func IdFromSlot(s types.Slot) StateOrBlockId {
-	return StateOrBlockId(strconv.FormatUint(uint64(s), 10))
-}
-
-// idTemplate is used to create template functions that can interpolate StateOrBlockId values.
-func idTemplate(ts string) func(StateOrBlockId) string {
-	t := template.Must(template.New("").Parse(ts))
-	f := func(id StateOrBlockId) string {
-		b := bytes.NewBuffer(nil)
-		err := t.Execute(b, struct{ Id string }{Id: string(id)})
-		if err != nil {
-			panic(fmt.Sprintf("invalid idTemplate: %s", ts))
-		}
-		return b.String()
-	}
-	// run the template to ensure that it is valid
-	// this should happen load time (using package scoped vars) to ensure runtime errors aren't possible
-	_ = f(IdGenesis)
-	return f
-}
-
-// ClientOpt is a functional option for the Client type (http.Client wrapper)
-type ClientOpt func(*Client)
-
-// WithTimeout sets the .Timeout attribute of the wrapped http.Client.
-func WithTimeout(timeout time.Duration) ClientOpt {
-	return func(c *Client) {
-		c.hc.Timeout = timeout
-	}
-}
-
-// Client provides a collection of helper methods for calling the Eth Beacon Node API endpoints.
-type Client struct {
-	hc     *http.Client
-	host   string
-	scheme string
-}
-
-// NewClient constructs a new client with the provided options (ex WithTimeout).
-// `host` is the base host + port used to construct request urls. This value can be
-// a URL string, or NewClient will assume an http endpoint if just `host:port` is used.
-func NewClient(host string, opts ...ClientOpt) (*Client, error) {
-	host, err := validHostname(host)
-	if err != nil {
-		return nil, err
-	}
-	c := &Client{
-		hc:     &http.Client{},
-		scheme: "http",
-		host:   host,
-	}
-	for _, o := range opts {
-		o(c)
-	}
-	return c, nil
-}
-
-func validHostname(h string) (string, error) {
-	// try to parse as url (being permissive)
-	u, err := url.Parse(h)
-	if err == nil && u.Host != "" {
-		return u.Host, nil
-	}
-	// try to parse as host:port
-	host, port, err := net.SplitHostPort(h)
-	if err != nil {
-		return "", err
-	}
-	return fmt.Sprintf("%s:%s", host, port), nil
-}
-
-func (c *Client) urlForPath(methodPath string) *url.URL {
-	u := &url.URL{
-		Scheme: c.scheme,
-		Host:   c.host,
-	}
-	u.Path = path.Join(u.Path, methodPath)
-	return u
-}
-
-type reqOption func(*http.Request)
-
-func withSSZEncoding() reqOption {
-	return func(req *http.Request) {
-		req.Header.Set("Accept", "application/octet-stream")
-	}
-}
-
-// get is a generic, opinionated GET function to reduce boilerplate amongst the getters in this package.
-func (c *Client) get(ctx context.Context, path string, opts ...reqOption) ([]byte, error) {
-	u := c.urlForPath(path)
-	log.Printf("requesting %s", u.String())
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	for _, o := range opts {
-		o(req)
-	}
-	r, err := c.hc.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		err = r.Body.Close()
-	}()
-	if r.StatusCode != http.StatusOK {
-		return nil, non200Err(r)
-	}
-	b, err := io.ReadAll(r.Body)
-	if err != nil {
-		return nil, errors.Wrap(err, "error reading http response body from GetBlock")
-	}
-	return b, nil
-}
-
-func renderGetBlockPath(id StateOrBlockId) string {
-	return path.Join(getSignedBlockPath, string(id))
-}
-
-// GetBlock retrieves the SignedBeaconBlock for the given block id.
-// Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded blockRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
-// for the named identifiers.
-// The return value contains the ssz-encoded bytes.
-func (c *Client) GetBlock(ctx context.Context, blockId StateOrBlockId) ([]byte, error) {
-	blockPath := renderGetBlockPath(blockId)
-	b, err := c.get(ctx, blockPath, withSSZEncoding())
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting state by id = %s", blockId)
-	}
-	return b, nil
-}
-
-var getBlockRootTpl = idTemplate(getBlockRootPath)
-
-// GetBlockRoot retrieves the hash_tree_root of the BeaconBlock for the given block id.
-// Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded blockRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
-// for the named identifiers.
-func (c *Client) GetBlockRoot(ctx context.Context, blockId StateOrBlockId) ([32]byte, error) {
-	rootPath := getBlockRootTpl(blockId)
-	b, err := c.get(ctx, rootPath)
-	if err != nil {
-		return [32]byte{}, errors.Wrapf(err, "error requesting block root by id = %s", blockId)
-	}
-	jsonr := &struct{ Data struct{ Root string } }{}
-	err = json.Unmarshal(b, jsonr)
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "error decoding json data from get block root response")
-	}
-	rs, err := hexutil.Decode(jsonr.Data.Root)
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, fmt.Sprintf("error decoding hex-encoded value %s", jsonr.Data.Root))
-	}
-	return bytesutil.ToBytes32(rs), nil
-}
-
-var getForkTpl = idTemplate(getForkForStatePath)
-
-// GetFork queries the Beacon Node API for the Fork from the state identified by stateId.
-// Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded blockRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
-// for the named identifiers.
-func (c *Client) GetFork(ctx context.Context, stateId StateOrBlockId) (*ethpb.Fork, error) {
-	body, err := c.get(ctx, getForkTpl(stateId))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting fork by state id = %s", stateId)
-	}
-	fr := &forkResponse{}
-	dataWrapper := &struct{ Data *forkResponse }{Data: fr}
-	err = json.Unmarshal(body, dataWrapper)
-	if err != nil {
-		return nil, errors.Wrap(err, "error decoding json response in GetFork")
-	}
-
-	return fr.Fork()
-}
-
-// GetForkSchedule retrieve all forks, past present and future, of which this node is aware.
-func (c *Client) GetForkSchedule(ctx context.Context) (forks.OrderedSchedule, error) {
-	body, err := c.get(ctx, getForkSchedulePath)
-	if err != nil {
-		return nil, errors.Wrap(err, "error requesting fork schedule")
-	}
-	fsr := &forkScheduleResponse{}
-	err = json.Unmarshal(body, fsr)
-	if err != nil {
-		return nil, err
-	}
-	ofs, err := fsr.OrderedForkSchedule()
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("problem unmarshaling %s response", getForkSchedulePath))
-	}
-	return ofs, nil
-}
-
-type NodeVersion struct {
-	implementation string
-	semver         string
-	systemInfo     string
-}
-
-var versionRE = regexp.MustCompile(`^(\w+)\/(v\d+\.\d+\.\d+) \((.*)\)$`)
-
-func parseNodeVersion(v string) (*NodeVersion, error) {
-	groups := versionRE.FindStringSubmatch(v)
-	if len(groups) != 4 {
-		return nil, errors.Wrapf(ErrInvalidNodeVersion, "could not be parsed: %s", v)
-	}
-	return &NodeVersion{
-		implementation: groups[1],
-		semver:         groups[2],
-		systemInfo:     groups[3],
-	}, nil
-}
-
-// GetNodeVersion requests that the beacon node identify information about its implementation in a format
-// similar to a HTTP User-Agent field. ex: Lighthouse/v0.1.5 (Linux x86_64)
-func (c *Client) GetNodeVersion(ctx context.Context) (*NodeVersion, error) {
-	b, err := c.get(ctx, getNodeVersionPath)
-	if err != nil {
-		return nil, errors.Wrap(err, "error requesting node version")
-	}
-	d := struct {
-		Data struct {
-			Version string `json:"version"`
-		} `json:"data"`
-	}{}
-	err = json.Unmarshal(b, &d)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error unmarshaling response body: %s", string(b))
-	}
-	return parseNodeVersion(d.Data.Version)
-}
-
-func renderGetStatePath(id StateOrBlockId) string {
-	return path.Join(getStatePath, string(id))
-}
-
-// GetState retrieves the BeaconState for the given state id.
-// State identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded stateRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
-// for the named identifiers.
-// The return value contains the ssz-encoded bytes.
-func (c *Client) GetState(ctx context.Context, stateId StateOrBlockId) ([]byte, error) {
-	statePath := path.Join(getStatePath, string(stateId))
-	b, err := c.get(ctx, statePath, withSSZEncoding())
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting state by id = %s", stateId)
-	}
-	return b, nil
-}
-
-// GetWeakSubjectivity calls a proposed API endpoint that is unique to prysm
-// This api method does the following:
-// - computes weak subjectivity epoch
-// - finds the highest non-skipped block preceding the epoch
-// - returns the htr of the found block and returns this + the value of state_root from the block
-func (c *Client) GetWeakSubjectivity(ctx context.Context) (*WeakSubjectivityData, error) {
-	body, err := c.get(ctx, getWeakSubjectivityPath)
-	if err != nil {
-		return nil, err
-	}
-	v := &apimiddleware.WeakSubjectivityResponse{}
-	err = json.Unmarshal(body, v)
-	if err != nil {
-		return nil, err
-	}
-	epoch, err := strconv.ParseUint(v.Data.Checkpoint.Epoch, 10, 64)
-	if err != nil {
-		return nil, err
-	}
-	blockRoot, err := hexutil.Decode(v.Data.Checkpoint.Root)
-	if err != nil {
-		return nil, err
-	}
-	stateRoot, err := hexutil.Decode(v.Data.StateRoot)
-	if err != nil {
-		return nil, err
-	}
-	return &WeakSubjectivityData{
-		Epoch:     types.Epoch(epoch),
-		BlockRoot: bytesutil.ToBytes32(blockRoot),
-		StateRoot: bytesutil.ToBytes32(stateRoot),
-	}, nil
-}
-
-// WeakSubjectivityData represents the state root, block root and epoch of the BeaconState + SignedBeaconBlock
-// that falls at the beginning of the current weak subjectivity period. These values can be used to construct
-// a weak subjectivity checkpoint, or to download a BeaconState+SignedBeaconBlock pair that can be used to bootstrap
-// a new Beacon Node using Checkpoint Sync.
-type WeakSubjectivityData struct {
-	BlockRoot [32]byte
-	StateRoot [32]byte
-	Epoch     types.Epoch
-}
-
-func non200Err(response *http.Response) error {
-	bodyBytes, err := ioutil.ReadAll(response.Body)
-	var body string
-	if err != nil {
-		body = "(Unable to read response body.)"
-	} else {
-		body = "response body:\n" + string(bodyBytes)
-	}
-	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
-	switch response.StatusCode {
-	case 404:
-		return errors.Wrap(ErrNotFound, msg)
-	default:
-		return errors.Wrap(ErrNotOK, msg)
-	}
-}
-
-type forkResponse struct {
-	PreviousVersion string `json:"previous_version"`
-	CurrentVersion  string `json:"current_version"`
-	Epoch           string `json:"epoch"`
-}
-
-func (f *forkResponse) Fork() (*ethpb.Fork, error) {
-	epoch, err := strconv.ParseUint(f.Epoch, 10, 64)
-	if err != nil {
-		return nil, err
-	}
-	cSlice, err := hexutil.Decode(f.CurrentVersion)
-	if err != nil {
-		return nil, err
-	}
-	if len(cSlice) != 4 {
-		return nil, fmt.Errorf("got %d byte version for CurrentVersion, expected 4 bytes. hex=%s", len(cSlice), f.CurrentVersion)
-	}
-	pSlice, err := hexutil.Decode(f.PreviousVersion)
-	if err != nil {
-		return nil, err
-	}
-	if len(pSlice) != 4 {
-		return nil, fmt.Errorf("got %d byte version, expected 4 bytes. version hex=%s", len(pSlice), f.PreviousVersion)
-	}
-	return &ethpb.Fork{
-		CurrentVersion:  cSlice,
-		PreviousVersion: pSlice,
-		Epoch:           types.Epoch(epoch),
-	}, nil
-}
-
-type forkScheduleResponse struct {
-	Data []forkResponse
-}
-
-func (fsr *forkScheduleResponse) OrderedForkSchedule() (forks.OrderedSchedule, error) {
-	ofs := make(forks.OrderedSchedule, 0)
-	for _, d := range fsr.Data {
-		epoch, err := strconv.Atoi(d.Epoch)
-		if err != nil {
-			return nil, err
-		}
-		vSlice, err := hexutil.Decode(d.CurrentVersion)
-		if err != nil {
-			return nil, err
-		}
-		if len(vSlice) != 4 {
-			return nil, fmt.Errorf("got %d byte version, expected 4 bytes. version hex=%s", len(vSlice), d.CurrentVersion)
-		}
-		version := bytesutil.ToBytes4(vSlice)
-		ofs = append(ofs, forks.ForkScheduleEntry{
-			Version: version,
-			Epoch:   types.Epoch(uint64(epoch)),
-		})
-	}
-	sort.Sort(ofs)
-	return ofs, nil
-}

api/client/beacon/client_test.go

@@ -1,58 +0,0 @@
-package beacon
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestParseNodeVersion(t *testing.T) {
-	cases := []struct {
-		name string
-		v    string
-		err  error
-		nv   *NodeVersion
-	}{
-		{
-			name: "empty string",
-			v:    "",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "Prysm as the version string",
-			v:    "Prysm",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "semver only",
-			v:    "v2.0.6",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "implementation and semver only",
-			v:    "Prysm/v2.0.6",
-			err:  ErrInvalidNodeVersion,
-		},
-		{
-			name: "complete version",
-			v:    "Prysm/v2.0.6 (linux amd64)",
-			nv: &NodeVersion{
-				implementation: "Prysm",
-				semver:         "v2.0.6",
-				systemInfo:     "linux amd64",
-			},
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			nv, err := parseNodeVersion(c.v)
-			if c.err != nil {
-				require.ErrorIs(t, err, c.err)
-			} else {
-				require.NoError(t, err)
-				require.DeepEqual(t, c.nv, nv)
-			}
-		})
-	}
-}

api/client/beacon/doc.go

@@ -1,6 +0,0 @@
-/*
-Package beacon provides a client for interacting with the standard Eth Beacon Node API.
-Interactive swagger documentation for the API is available here: https://ethereum.github.io/beacon-APIs/
-
-*/
-package beacon

api/client/beacon/errors.go

@@ -1,13 +0,0 @@
-package beacon
-
-import "github.com/pkg/errors"
-
-// ErrNotOK is used to indicate when an HTTP request to the Beacon Node API failed with any non-2xx response code.
-// More specific errors may be returned, but an error in reaction to a non-2xx response will always wrap ErrNotOK.
-var ErrNotOK = errors.New("did not receive 2xx response from API")
-
-// ErrNotFound specifically means that a '404 - NOT FOUND' response was received from the API.
-var ErrNotFound = errors.Wrap(ErrNotOK, "recv 404 NotFound response from API")
-
-// ErrInvalidNodeVersion indicates that the /eth/v1/node/version api response format was not recognized.
-var ErrInvalidNodeVersion = errors.New("invalid node version response")

beacon-chain/blockchain/BUILD.bazel

@@ -51,7 +51,6 @@ go_library(
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
-        "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -7,8 +7,6 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
-	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
-	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -325,44 +323,13 @@ func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
 		return false, nil
 	}
 
-	return s.IsOptimisticForRoot(ctx, s.head.root)
+	return s.cfg.ForkChoiceStore.IsOptimistic(ctx, s.head.root)
 }
 
 // IsOptimisticForRoot takes the root and slot as aguments instead of the current head
 // and returns true if it is optimistic.
 func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) {
-	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(ctx, root)
-	if err == nil {
-		return optimistic, nil
-	}
-	if err != protoarray.ErrUnknownNodeRoot && err != doublylinkedtree.ErrNilNode {
-		return false, err
-	}
-	ss, err := s.cfg.BeaconDB.StateSummary(ctx, root)
-	if err != nil {
-		return false, err
-	}
-	if ss == nil {
-		return false, errInvalidNilSummary
-	}
-
-	validatedCheckpoint, err := s.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
-	if err != nil {
-		return false, err
-	}
-	if slots.ToEpoch(ss.Slot) > validatedCheckpoint.Epoch {
-		return true, nil
-	}
-
-	if slots.ToEpoch(ss.Slot)+1 < validatedCheckpoint.Epoch {
-		return false, nil
-	}
-
-	lastValidated, err := s.cfg.BeaconDB.StateSummary(ctx, bytesutil.ToBytes32(validatedCheckpoint.Root))
-	if err != nil {
-		return false, err
-	}
-	return ss.Slot > lastValidated.Slot, nil
+	return s.cfg.ForkChoiceStore.IsOptimistic(ctx, root)
 }
 
 // SetGenesisTime sets the genesis time of beacon chain.

beacon-chain/blockchain/chain_info_norace_test.go

@@ -16,13 +16,10 @@ func TestHeadSlot_DataRace(t *testing.T) {
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB},
 	}
-	wait := make(chan struct{})
 	go func() {
-		defer close(wait)
 		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
 	s.HeadSlot()
-	<-wait
 }
 
 func TestHeadRoot_DataRace(t *testing.T) {
@@ -31,32 +28,24 @@ func TestHeadRoot_DataRace(t *testing.T) {
 		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 		head: &head{root: [32]byte{'A'}},
 	}
-	wait := make(chan struct{})
 	go func() {
-		defer close(wait)
 		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
 	_, err := s.HeadRoot(context.Background())
 	require.NoError(t, err)
-	<-wait
 }
 
 func TestHeadBlock_DataRace(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
-	require.NoError(t, err)
 	s := &Service{
 		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
-		head: &head{block: wsb},
+		head: &head{block: wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{})},
 	}
-	wait := make(chan struct{})
 	go func() {
-		defer close(wait)
 		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
-	_, err = s.HeadBlock(context.Background())
+	_, err := s.HeadBlock(context.Background())
 	require.NoError(t, err)
-	<-wait
 }
 
 func TestHeadState_DataRace(t *testing.T) {
@@ -64,12 +53,9 @@ func TestHeadState_DataRace(t *testing.T) {
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 	}
-	wait := make(chan struct{})
 	go func() {
-		defer close(wait)
 		require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
 	}()
 	_, err := s.HeadState(context.Background())
 	require.NoError(t, err)
-	<-wait
 }

beacon-chain/blockchain/chain_info_test.go

@@ -133,9 +133,7 @@ func TestHeadRoot_UseDB(t *testing.T) {
 	b := util.NewBeaconBlock()
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
+	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:]}))
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(context.Background(), br))
 	r, err := c.HeadRoot(context.Background())
@@ -148,10 +146,8 @@ func TestHeadBlock_CanRetrieve(t *testing.T) {
 	b.Block.Slot = 1
 	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
 	c := &Service{}
-	c.head = &head{block: wsb, state: s}
+	c.head = &head{block: wrapper.WrappedPhase0SignedBeaconBlock(b), state: s}
 
 	recevied, err := c.HeadBlock(context.Background())
 	require.NoError(t, err)
@@ -233,9 +229,7 @@ func TestIsCanonical_Ok(t *testing.T) {
 	blk.Block.Slot = 0
 	root, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
 	can, err := c.IsCanonical(ctx, root)
 	require.NoError(t, err)
@@ -294,11 +288,11 @@ func TestService_ChainHeads_ProtoArray(t *testing.T) {
 	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0,
 		params.BeaconConfig().ZeroHash)}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, 0, 0))
 
 	roots, slots := c.ChainHeads()
 	require.DeepEqual(t, [][32]byte{{'c'}, {'d'}, {'e'}}, roots)
@@ -308,11 +302,11 @@ func TestService_ChainHeads_ProtoArray(t *testing.T) {
 func TestService_ChainHeads_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 103, [32]byte{'d'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, 0, 0))
 
 	roots, slots := c.ChainHeads()
 	require.Equal(t, 3, len(roots))
@@ -390,8 +384,8 @@ func TestService_IsOptimistic_ProtoArray(t *testing.T) {
 
 	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0))
 
 	opt, err := c.IsOptimistic(ctx)
 	require.NoError(t, err)
@@ -406,8 +400,8 @@ func TestService_IsOptimistic_DoublyLinkedTree(t *testing.T) {
 
 	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0))
 
 	opt, err := c.IsOptimistic(ctx)
 	require.NoError(t, err)
@@ -425,8 +419,8 @@ func TestService_IsOptimisticBeforeBellatrix(t *testing.T) {
 func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) {
 	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0))
 
 	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
 	require.NoError(t, err)
@@ -436,98 +430,10 @@ func TestService_IsOptimisticForRoot_ProtoArray(t *testing.T) {
 func TestService_IsOptimisticForRoot_DoublyLinkedTree(t *testing.T) {
 	ctx := context.Background()
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 100, [32]byte{'a'}, [32]byte{}, 0, 0))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, 0, 0))
 
 	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
 	require.NoError(t, err)
 	require.Equal(t, true, opt)
 }
-
-func TestService_IsOptimisticForRoot_DB_ProtoArray(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: protoarray.New(0, 0, [32]byte{})}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 10
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
-
-	optimisticBlock := util.NewBeaconBlock()
-	optimisticBlock.Block.Slot = 11
-	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(optimisticBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedBlock := util.NewBeaconBlock()
-	validatedBlock.Block.Slot = 9
-	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(validatedBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err := c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
-	validated, err := c.IsOptimisticForRoot(ctx, validatedRoot)
-	require.NoError(t, err)
-	require.Equal(t, false, validated)
-}
-
-func TestService_IsOptimisticForRoot__DB_DoublyLinkedTree(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New(0, 0)}, head: &head{slot: 101, root: [32]byte{'b'}}}
-	c.head = &head{root: params.BeaconConfig().ZeroHash}
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 10
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
-
-	optimisticBlock := util.NewBeaconBlock()
-	optimisticBlock.Block.Slot = 11
-	optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(optimisticBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedBlock := util.NewBeaconBlock()
-	validatedBlock.Block.Slot = 9
-	validatedRoot, err := validatedBlock.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(validatedBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
-
-	validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: optimisticRoot[:], Slot: 11}))
-	optimistic, err := c.IsOptimisticForRoot(ctx, optimisticRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, optimistic)
-
-	require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: validatedRoot[:], Slot: 9}))
-	validated, err := c.IsOptimisticForRoot(ctx, validatedRoot)
-	require.NoError(t, err)
-	require.Equal(t, false, validated)
-}

beacon-chain/blockchain/checktags_test.go

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

beacon-chain/blockchain/error.go

@@ -9,11 +9,4 @@ var (
 	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")
-	// errInvalidNilSummary is returned when a nil summary is returned from the DB.
-	errInvalidNilSummary = errors.New("nil summary returned from the DB")
-	// errNilParentInDB is returned when a nil parent block is returned from the DB.
-	errNilParentInDB = errors.New("nil parent block in DB")
-	// errWrongBlockCound is returned when the wrong number of blocks or
-	// block roots is used
-	errWrongBlockCount = errors.New("wrong number of blocks or block roots")
 )

beacon-chain/blockchain/head.go

@@ -86,6 +86,11 @@ func (s *Service) updateHead(ctx context.Context, balances []uint64) error {
 		if err := s.insertBlockToForkChoiceStore(ctx, jb.Block(), headStartRoot, f, j); err != nil {
 			return err
 		}
+
+		// TODO(10261) send optimistic status
+		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, headStartRoot); err != nil {
+			return err
+		}
 	}
 
 	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx, j.Epoch, headStartRoot, balances, f.Epoch)
@@ -148,21 +153,16 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 			"oldSlot": fmt.Sprintf("%d", headSlot),
 		}).Debug("Chain reorg occurred")
 		absoluteSlotDifference := slots.AbsoluteValueSlotDifference(newHeadSlot, headSlot)
-		isOptimistic, err := s.IsOptimistic(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not check if node is optimistically synced")
-		}
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Reorg,
 			Data: &ethpbv1.EventChainReorg{
-				Slot:                newHeadSlot,
-				Depth:               absoluteSlotDifference,
-				OldHeadBlock:        oldHeadRoot[:],
-				NewHeadBlock:        headRoot[:],
-				OldHeadState:        oldStateRoot,
-				NewHeadState:        newStateRoot,
-				Epoch:               slots.ToEpoch(newHeadSlot),
-				ExecutionOptimistic: isOptimistic,
+				Slot:         newHeadSlot,
+				Depth:        absoluteSlotDifference,
+				OldHeadBlock: oldHeadRoot[:],
+				NewHeadBlock: headRoot[:],
+				OldHeadState: oldStateRoot,
+				NewHeadState: newStateRoot,
+				Epoch:        slots.ToEpoch(newHeadSlot),
 			},
 		})
 
@@ -184,7 +184,7 @@ func (s *Service) saveHead(ctx context.Context, headRoot [32]byte) error {
 	// Forward an event capturing a new chain head over a common event feed
 	// done in a goroutine to avoid blocking the critical runtime main routine.
 	go func() {
-		if err := s.notifyNewHeadEvent(ctx, newHeadSlot, newHeadState, newStateRoot, headRoot[:]); err != nil {
+		if err := s.notifyNewHeadEvent(newHeadSlot, newHeadState, newStateRoot, headRoot[:]); err != nil {
 			log.WithError(err).Error("Could not notify event feed of new chain head")
 		}
 	}()
@@ -304,7 +304,6 @@ func (s *Service) hasHeadState() bool {
 // Notifies a common event feed of a new chain head event. Called right after a new
 // chain head is determined, set, and saved to disk.
 func (s *Service) notifyNewHeadEvent(
-	ctx context.Context,
 	newHeadSlot types.Slot,
 	newHeadState state.BeaconState,
 	newHeadStateRoot,
@@ -338,10 +337,6 @@ func (s *Service) notifyNewHeadEvent(
 			return errors.Wrap(err, "could not get duty dependent root")
 		}
 	}
-	isOptimistic, err := s.IsOptimistic(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not check if node is optimistically synced")
-	}
 	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.NewHead,
 		Data: &ethpbv1.EventHead{
@@ -351,7 +346,6 @@ func (s *Service) notifyNewHeadEvent(
 			EpochTransition:           slots.IsEpochStart(newHeadSlot),
 			PreviousDutyDependentRoot: previousDutyDependentRoot,
 			CurrentDutyDependentRoot:  currentDutyDependentRoot,
-			ExecutionOptimistic:       isOptimistic,
 		},
 	})
 	return nil

beacon-chain/blockchain/head_test.go

@@ -39,10 +39,9 @@ func TestSaveHead_Different(t *testing.T) {
 	service := setupBeaconChain(t, beaconDB)
 
 	util.NewBeaconBlock()
-	oldBlock, err := wrapper.WrappedSignedBeaconBlock(
+	oldBlock := wrapper.WrappedPhase0SignedBeaconBlock(
 		util.NewBeaconBlock(),
 	)
-	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
 	oldRoot, err := oldBlock.Block().HashTreeRoot()
 	require.NoError(t, err)
@@ -56,9 +55,7 @@ func TestSaveHead_Different(t *testing.T) {
 	newHeadSignedBlock.Block.Slot = 1
 	newHeadBlock := newHeadSignedBlock.Block
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(newHeadSignedBlock)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
 	headState, err := util.NewBeaconState()
@@ -83,10 +80,9 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
 
-	oldBlock, err := wrapper.WrappedSignedBeaconBlock(
+	oldBlock := wrapper.WrappedPhase0SignedBeaconBlock(
 		util.NewBeaconBlock(),
 	)
-	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
 	oldRoot, err := oldBlock.Block().HashTreeRoot()
 	require.NoError(t, err)
@@ -102,9 +98,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:]
 	newHeadBlock := newHeadSignedBlock.Block
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(newHeadSignedBlock)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock)))
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
 	headState, err := util.NewBeaconState()
@@ -145,9 +139,7 @@ func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
 	service := setupBeaconChain(t, beaconDB)
 
 	b := util.NewBeaconBlock()
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -170,7 +162,7 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 		}
 		newHeadStateRoot := [32]byte{2}
 		newHeadRoot := [32]byte{3}
-		err := srv.notifyNewHeadEvent(context.Background(), 1, bState, newHeadStateRoot[:], newHeadRoot[:])
+		err := srv.notifyNewHeadEvent(1, bState, newHeadStateRoot[:], newHeadRoot[:])
 		require.NoError(t, err)
 		events := notifier.ReceivedEvents()
 		require.Equal(t, 1, len(events))
@@ -205,7 +197,7 @@ func Test_notifyNewHeadEvent(t *testing.T) {
 
 		newHeadStateRoot := [32]byte{2}
 		newHeadRoot := [32]byte{3}
-		err = srv.notifyNewHeadEvent(context.Background(), epoch2Start, bState, newHeadStateRoot[:], newHeadRoot[:])
+		err = srv.notifyNewHeadEvent(epoch2Start, bState, newHeadStateRoot[:], newHeadRoot[:])
 		require.NoError(t, err)
 		events := notifier.ReceivedEvents()
 		require.Equal(t, 1, len(events))
@@ -241,9 +233,7 @@ func TestSaveOrphanedAtts(t *testing.T) {
 	service := setupBeaconChain(t, beaconDB)
 	service.genesisTime = time.Now()
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	require.NoError(t, service.saveOrphanedAtts(ctx, r))
 
 	require.Equal(t, len(b.Block.Body.Attestations), service.cfg.AttPool.AggregatedAttestationCount())
@@ -269,9 +259,7 @@ func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
 	service := setupBeaconChain(t, beaconDB)
 	service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	require.NoError(t, service.saveOrphanedAtts(ctx, r))
 
 	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())

beacon-chain/blockchain/log.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	"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/runtime/version"
@@ -18,7 +17,7 @@ import (
 var log = logrus.WithField("prefix", "blockchain")
 
 // logs state transition related data every slot.
-func logStateTransitionData(b block.BeaconBlock) error {
+func logStateTransitionData(b block.BeaconBlock) {
 	log := log.WithField("slot", b.Slot())
 	if len(b.Body().Attestations()) > 0 {
 		log = log.WithField("attestations", len(b.Body().Attestations()))
@@ -35,23 +34,13 @@ func logStateTransitionData(b block.BeaconBlock) error {
 	if len(b.Body().VoluntaryExits()) > 0 {
 		log = log.WithField("voluntaryExits", len(b.Body().VoluntaryExits()))
 	}
-	if b.Version() == version.Altair || b.Version() == version.Bellatrix {
+	if b.Version() == version.Altair {
 		agg, err := b.Body().SyncAggregate()
-		if err != nil {
-			return err
+		if err == nil {
+			log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
 		}
-		log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
-	}
-	if b.Version() == version.Bellatrix {
-		p, err := b.Body().ExecutionPayload()
-		if err != nil {
-			return err
-		}
-		log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash)))
-		log = log.WithField("txCount", len(p.Transactions))
 	}
 	log.Info("Finished applying state transition")
-	return nil
 }
 
 func logBlockSyncStatus(block block.BeaconBlock, blockRoot [32]byte, finalized *ethpb.Checkpoint, receivedTime time.Time, genesisTime uint64) error {

beacon-chain/blockchain/log_test.go

@@ -3,7 +3,6 @@ package blockchain
 import (
 	"testing"
 
-	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/proto/prysm/v1alpha1/wrapper"
@@ -12,17 +11,6 @@ import (
 )
 
 func Test_logStateTransitionData(t *testing.T) {
-	payloadBlk := &ethpb.BeaconBlockBellatrix{
-		Body: &ethpb.BeaconBlockBodyBellatrix{
-			SyncAggregate: &ethpb.SyncAggregate{},
-			ExecutionPayload: &enginev1.ExecutionPayload{
-				BlockHash:    []byte{1, 2, 3},
-				Transactions: [][]byte{{}, {}},
-			},
-		},
-	}
-	wrappedPayloadBlk, err := wrapper.WrappedBeaconBlock(payloadBlk)
-	require.NoError(t, err)
 	tests := []struct {
 		name string
 		b    block.BeaconBlock
@@ -67,15 +55,11 @@ func Test_logStateTransitionData(t *testing.T) {
 				VoluntaryExits:    []*ethpb.SignedVoluntaryExit{{}}}}),
 			want: "\"Finished applying state transition\" attestations=1 attesterSlashings=1 deposits=1 prefix=blockchain proposerSlashings=1 slot=0 voluntaryExits=1",
 		},
-		{name: "has payload",
-			b:    wrappedPayloadBlk,
-			want: "\"Finished applying state transition\" payloadHash=0x010203 prefix=blockchain slot=0 syncBitsCount=0 txCount=2",
-		},
 	}
 	for _, tt := range tests {
 		hook := logTest.NewGlobal()
 		t.Run(tt.name, func(t *testing.T) {
-			require.NoError(t, logStateTransitionData(tt.b))
+			logStateTransitionData(tt.b)
 			require.LogsContain(t, hook, tt.want)
 		})
 	}

beacon-chain/blockchain/new_slot_test.go

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

beacon-chain/blockchain/optimistic_sync.go

@@ -8,27 +8,28 @@ import (
 	"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"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
+	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
 )
 
 // 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, headRoot [32]byte, finalizedRoot [32]byte) (*enginev1.PayloadIDBytes, error) {
-	ctx, span := trace.StartSpan(ctx, "blockChain.notifyForkchoiceUpdate")
-	defer span.End()
-
+func (s *Service) notifyForkchoiceUpdate(ctx context.Context, headBlk block.BeaconBlock, finalizedRoot [32]byte) (*enginev1.PayloadIDBytes, error) {
 	if headBlk == nil || headBlk.IsNil() || headBlk.Body().IsNil() {
 		return nil, errors.New("nil head block")
 	}
 	// Must not call fork choice updated until the transition conditions are met on the Pow network.
-	isExecutionBlk, err := blocks.IsExecutionBlock(headBlk.Body())
+	if isPreBellatrix(headBlk.Version()) {
+		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")
 	}
@@ -44,7 +45,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, headBlk block.Beac
 		return nil, errors.Wrap(err, "could not get finalized block")
 	}
 	var finalizedHash []byte
-	if blocks.IsPreBellatrixVersion(finalizedBlock.Block().Version()) {
+	if isPreBellatrix(finalizedBlock.Block().Version()) {
 		finalizedHash = params.BeaconConfig().ZeroHash[:]
 	} else {
 		payload, err := finalizedBlock.Block().Body().ExecutionPayload()
@@ -61,7 +62,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, headBlk block.Beac
 	}
 
 	// payload attribute is only required when requesting payload, here we are just updating fork choice, so it is nil.
-	payloadID, _, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, nil /*payload attribute*/)
+	payloadID, validHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, nil /*payload attribute*/)
 	if err != nil {
 		switch err {
 		case v1.ErrAcceptedSyncingPayloadStatus:
@@ -71,67 +72,66 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, headBlk block.Beac
 				"finalizedHash": fmt.Sprintf("%#x", bytesutil.Trunc(finalizedHash)),
 			}).Info("Called fork choice updated with optimistic block")
 			return payloadID, nil
+		case v1.ErrInvalidPayloadStatus:
+			if err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, bytesutil.ToBytes32(validHash)); err != nil {
+				return nil, err
+			}
+			return nil, errors.Wrap(err, "Received invalid hash from execution engine")
 		default:
 			return nil, errors.Wrap(err, "could not notify forkchoice update from execution engine")
 		}
 	}
-	if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, headRoot); err != nil {
-		return nil, errors.Wrap(err, "could not set block to valid")
-	}
 	return payloadID, nil
 }
 
 // notifyForkchoiceUpdate signals execution engine on a new payload
-func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion, postStateVersion int,
-	preStateHeader, postStateHeader *ethpb.ExecutionPayloadHeader, blk block.SignedBeaconBlock, root [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "blockChain.notifyNewPayload")
-	defer span.End()
-
-	// Execution payload is only supported in Bellatrix and beyond. Pre
-	// merge blocks are never optimistic
-	if blocks.IsPreBellatrixVersion(postStateVersion) {
-		return s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, root)
+func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int, header *ethpb.ExecutionPayloadHeader, postState state.BeaconState, blk block.SignedBeaconBlock) error {
+	if postState == nil {
+		return errors.New("pre and post states must not be nil")
+	}
+	// Execution payload is only supported in Bellatrix and beyond.
+	if isPreBellatrix(postState.Version()) {
+		return nil
 	}
 	if err := helpers.BeaconBlockIsNil(blk); err != nil {
 		return err
 	}
 	body := blk.Block().Body()
-	enabled, err := blocks.IsExecutionEnabledUsingHeader(postStateHeader, 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 s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, root)
+		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)
+	validHash, err := s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload)
 	if err != nil {
 		switch err {
 		case v1.ErrAcceptedSyncingPayloadStatus:
 			log.WithFields(logrus.Fields{
-				"slot":      blk.Block().Slot(),
+				"slot":      postState.Slot(),
 				"blockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
 			}).Info("Called new payload with optimistic block")
 			return nil
+		case v1.ErrInvalidPayloadStatus:
+			if err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, bytesutil.ToBytes32(validHash)); err != nil {
+				return err
+			}
+			return errors.Wrap(err, "Received invalid hash from execution engine")
 		default:
 			return errors.Wrap(err, "could not validate execution payload from execution engine")
 		}
 	}
 
-	if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, root); err != nil {
-		return errors.Wrap(err, "could not set optimistic status")
-	}
-
 	// During the transition event, the transition block should be verified for sanity.
-	if blocks.IsPreBellatrixVersion(preStateVersion) {
-		// Handle case where pre-state is Altair but block contains payload.
-		// To reach here, the block must have contained a valid payload.
-		return s.validateMergeBlock(ctx, blk)
+	if isPreBellatrix(preStateVersion) {
+		return nil
 	}
-	atTransition, err := blocks.IsMergeTransitionBlockUsingPreStatePayloadHeader(preStateHeader, body)
+	atTransition, err := blocks.IsMergeTransitionBlockUsingPayloadHeader(header, body)
 	if err != nil {
 		return errors.Wrap(err, "could not check if merge block is terminal")
 	}
@@ -141,42 +141,23 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion, postSta
 	return s.validateMergeBlock(ctx, blk)
 }
 
+// isPreBellatrix returns true if input version is before bellatrix fork.
+func isPreBellatrix(v int) bool {
+	return v == version.Phase0 || v == version.Altair
+}
+
 // 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:
-//    if is_execution_block(opt_store.blocks[block.parent_root]):
-//        return True
-//
-//    justified_root = opt_store.block_states[opt_store.head_block_root].current_justified_checkpoint.root
-//    if is_execution_block(opt_store.blocks[justified_root]):
-//        return True
-//
-//    if block.slot + SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY <= current_slot:
-//        return True
-//
-//    return False
+//     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
 	}
-
-	parent, err := s.cfg.BeaconDB.Block(ctx, bytesutil.ToBytes32(blk.ParentRoot()))
-	if err != nil {
-		return false, err
-	}
-	if parent == nil {
-		return false, errNilParentInDB
-	}
-
-	parentIsExecutionBlock, err := blocks.IsExecutionBlock(parent.Block().Body())
-	if err != nil {
-		return false, err
-	}
-	if parentIsExecutionBlock {
-		return true, nil
-	}
-
 	j := s.store.JustifiedCheckpt()
 	if j == nil {
 		return false, errNilJustifiedInStore
@@ -185,5 +166,5 @@ func (s *Service) optimisticCandidateBlock(ctx context.Context, blk block.Beacon
 	if err != nil {
 		return false, err
 	}
-	return blocks.IsExecutionBlock(jBlock.Block().Body())
+	return blocks.ExecutionBlock(jBlock.Block().Body())
 }

beacon-chain/blockchain/optimistic_sync_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	engine "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
@@ -19,7 +18,6 @@ import (
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/runtime/version"
-	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 	"github.com/prysmaticlabs/prysm/time/slots"
@@ -38,6 +36,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, altairBlk))
 	require.NoError(t, beaconDB.SaveBlock(ctx, bellatrixBlk))
+
 	fcs := protoarray.New(0, 0, [32]byte{'a'})
 	opts := []Option{
 		WithDatabase(beaconDB),
@@ -46,7 +45,6 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 	}
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
 
 	tests := []struct {
 		name             string
@@ -157,7 +155,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			engine := &mockEngineService{forkchoiceError: tt.newForkchoiceErr}
 			service.cfg.ExecutionEngineCaller = engine
-			_, err := service.notifyForkchoiceUpdate(ctx, tt.blk, service.headRoot(), tt.finalizedRoot)
+			_, err := service.notifyForkchoiceUpdate(ctx, tt.blk, tt.finalizedRoot)
 			if tt.errString != "" {
 				require.ErrorContains(t, tt.errString, err)
 			} else {
@@ -190,13 +188,6 @@ func Test_NotifyNewPayload(t *testing.T) {
 			},
 		},
 	}
-	a := &ethpb.SignedBeaconBlockAltair{
-		Block: &ethpb.BeaconBlockAltair{
-			Body: &ethpb.BeaconBlockBodyAltair{},
-		},
-	}
-	altairBlk, err := wrapper.WrappedSignedBeaconBlock(a)
-	require.NoError(t, err)
 	bellatrixBlk, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
 	service, err := NewService(ctx, opts...)
@@ -220,6 +211,11 @@ func Test_NotifyNewPayload(t *testing.T) {
 			postState: altairState,
 			preState:  altairState,
 		},
+		{
+			name:      "nil post state",
+			preState:  phase0State,
+			errString: "pre and post states must not be nil",
+		},
 		{
 			name:      "nil beacon block",
 			postState: bellatrixState,
@@ -242,29 +238,10 @@ func Test_NotifyNewPayload(t *testing.T) {
 			errString:     "could not validate execution payload from execution engine: payload status is INVALID",
 		},
 		{
-			name:      "altair pre state, altair block",
+			name:      "altair pre state",
 			postState: bellatrixState,
 			preState:  altairState,
-			blk:       altairBlk,
-		},
-		{
-			name:      "altair pre state, happy case",
-			postState: bellatrixState,
-			preState:  altairState,
-			blk: func() block.SignedBeaconBlock {
-				blk := &ethpb.SignedBeaconBlockBellatrix{
-					Block: &ethpb.BeaconBlockBellatrix{
-						Body: &ethpb.BeaconBlockBodyBellatrix{
-							ExecutionPayload: &v1.ExecutionPayload{
-								ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
-							},
-						},
-					},
-				}
-				b, err := wrapper.WrappedSignedBeaconBlock(blk)
-				require.NoError(t, err)
-				return b
-			}(),
+			blk:       bellatrixBlk,
 		},
 		{
 			name:      "could not get merge block",
@@ -327,85 +304,30 @@ func Test_NotifyNewPayload(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			engine := &mockEngineService{newPayloadError: tt.newPayloadErr, blks: map[[32]byte]*v1.ExecutionBlock{}}
-			engine.blks[[32]byte{'a'}] = &v1.ExecutionBlock{
-				ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
-				TotalDifficulty: "0x2",
-			}
-			engine.blks[[32]byte{'b'}] = &v1.ExecutionBlock{
-				ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
-				TotalDifficulty: "0x1",
-			}
-			service.cfg.ExecutionEngineCaller = engine
-			var payload *ethpb.ExecutionPayloadHeader
-			if tt.preState.Version() == version.Bellatrix {
-				payload, err = tt.preState.LatestExecutionPayloadHeader()
-				require.NoError(t, err)
-			}
-			root := [32]byte{'a'}
-			require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 0, root, root, params.BeaconConfig().ZeroHash, 0, 0))
-			postVersion, postHeader, err := getStateVersionAndPayload(tt.postState)
+		engine := &mockEngineService{newPayloadError: tt.newPayloadErr, blks: map[[32]byte]*v1.ExecutionBlock{}}
+		engine.blks[[32]byte{'a'}] = &v1.ExecutionBlock{
+			ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
+			TotalDifficulty: "0x2",
+		}
+		engine.blks[[32]byte{'b'}] = &v1.ExecutionBlock{
+			ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
+			TotalDifficulty: "0x1",
+		}
+		service.cfg.ExecutionEngineCaller = engine
+		var payload *ethpb.ExecutionPayloadHeader
+		if tt.preState.Version() == version.Bellatrix {
+			payload, err = tt.preState.LatestExecutionPayloadHeader()
 			require.NoError(t, err)
-			err = service.notifyNewPayload(ctx, tt.preState.Version(), postVersion, payload, postHeader, tt.blk, root)
-			if tt.errString != "" {
-				require.ErrorContains(t, tt.errString, err)
-			} else {
-				require.NoError(t, err)
-			}
-		})
+		}
+		err := service.notifyNewPayload(ctx, tt.preState.Version(), payload, tt.postState, tt.blk)
+		if tt.errString != "" {
+			require.ErrorContains(t, tt.errString, err)
+		} else {
+			require.NoError(t, err)
+		}
 	}
 }
 
-func Test_NotifyNewPayload_SetOptimisticToValid(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),
-	}
-	bellatrixState, _ := util.DeterministicGenesisStateBellatrix(t, 2)
-	blk := &ethpb.SignedBeaconBlockBellatrix{
-		Block: &ethpb.BeaconBlockBellatrix{
-			Body: &ethpb.BeaconBlockBodyBellatrix{
-				ExecutionPayload: &v1.ExecutionPayload{
-					ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
-				},
-			},
-		},
-	}
-	bellatrixBlk, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	engine := &mockEngineService{blks: map[[32]byte]*v1.ExecutionBlock{}}
-	engine.blks[[32]byte{'a'}] = &v1.ExecutionBlock{
-		ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
-		TotalDifficulty: "0x2",
-	}
-	engine.blks[[32]byte{'b'}] = &v1.ExecutionBlock{
-		ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
-		TotalDifficulty: "0x1",
-	}
-	service.cfg.ExecutionEngineCaller = engine
-	payload, err := bellatrixState.LatestExecutionPayloadHeader()
-	require.NoError(t, err)
-	root := [32]byte{'c'}
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 1, root, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 0, 0))
-	postVersion, postHeader, err := getStateVersionAndPayload(bellatrixState)
-	require.NoError(t, err)
-	err = service.notifyNewPayload(ctx, bellatrixState.Version(), postVersion, payload, postHeader, bellatrixBlk, root)
-	require.NoError(t, err)
-	optimistic, err := service.IsOptimisticForRoot(ctx, root)
-	require.NoError(t, err)
-	require.Equal(t, false, optimistic)
-}
-
 func Test_IsOptimisticCandidateBlock(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	params.OverrideBeaconConfig(params.MainnetConfig())
@@ -425,12 +347,6 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 	params.BeaconConfig().SafeSlotsToImportOptimistically = 128
 	service.genesisTime = time.Now().Add(-time.Second * 12 * 2 * 128)
 
-	parentBlk := util.NewBeaconBlockBellatrix()
-	wrappedParentBlock, err := wrapper.WrappedSignedBeaconBlock(parentBlk)
-	require.NoError(t, err)
-	parentRoot, err := wrappedParentBlock.Block().HashTreeRoot()
-	require.NoError(t, err)
-
 	tests := []struct {
 		name      string
 		blk       block.BeaconBlock
@@ -442,7 +358,6 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 			blk: func(tt *testing.T) block.BeaconBlock {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 1
-				blk.Block.ParentRoot = parentRoot[:]
 				wr, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
 				require.NoError(tt, err)
 				return wr
@@ -450,8 +365,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 			justified: func(tt *testing.T) block.SignedBeaconBlock {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 32
-				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -462,7 +376,6 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 			blk: func(tt *testing.T) block.BeaconBlock {
 				blk := util.NewBeaconBlockAltair()
 				blk.Block.Slot = 200
-				blk.Block.ParentRoot = parentRoot[:]
 				wr, err := wrapper.WrappedAltairBeaconBlock(blk.Block)
 				require.NoError(tt, err)
 				return wr
@@ -470,8 +383,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 			justified: func(tt *testing.T) block.SignedBeaconBlock {
 				blk := util.NewBeaconBlockAltair()
 				blk.Block.Slot = 32
-				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedAltairSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -482,7 +394,6 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 			blk: func(tt *testing.T) block.BeaconBlock {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 200
-				blk.Block.ParentRoot = parentRoot[:]
 				wr, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
 				require.NoError(tt, err)
 				return wr
@@ -490,8 +401,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 			justified: func(tt *testing.T) block.SignedBeaconBlock {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 32
-				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -502,7 +412,6 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 			blk: func(tt *testing.T) block.BeaconBlock {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 200
-				blk.Block.ParentRoot = parentRoot[:]
 				wr, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
 				require.NoError(tt, err)
 				return wr
@@ -510,7 +419,6 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 			justified: func(tt *testing.T) block.SignedBeaconBlock {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 32
-				blk.Block.ParentRoot = parentRoot[:]
 				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)
@@ -519,7 +427,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				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.WrappedSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -535,158 +443,8 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				Root:  jroot[:],
 				Epoch: slots.ToEpoch(tt.justified.Block().Slot()),
 			})
-		require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrappedParentBlock))
-
 		candidate, err := service.optimisticCandidateBlock(ctx, tt.blk)
 		require.NoError(t, err)
 		require.Equal(t, tt.want, candidate, tt.name)
 	}
 }
-
-func Test_IsOptimisticShallowExecutionParent(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MainnetConfig())
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	params.BeaconConfig().SafeSlotsToImportOptimistically = 128
-	service.genesisTime = time.Now().Add(-time.Second * 12 * 2 * 128)
-	payload := &v1.ExecutionPayload{
-		ParentHash:    make([]byte, 32),
-		FeeRecipient:  make([]byte, 20),
-		StateRoot:     make([]byte, 32),
-		ReceiptsRoot:  make([]byte, 32),
-		LogsBloom:     make([]byte, 256),
-		PrevRandao:    make([]byte, 32),
-		BaseFeePerGas: bytesutil.PadTo([]byte{1, 2, 3, 4}, fieldparams.RootLength),
-		BlockHash:     make([]byte, 32),
-		BlockNumber:   100,
-	}
-	body := &ethpb.BeaconBlockBodyBellatrix{ExecutionPayload: payload}
-	block := &ethpb.BeaconBlockBellatrix{Body: body, Slot: 200}
-	rawSigned := &ethpb.SignedBeaconBlockBellatrix{Block: block}
-	blk := util.HydrateSignedBeaconBlockBellatrix(rawSigned)
-	wr, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wr))
-	blkRoot, err := wr.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	childBlock := util.NewBeaconBlockBellatrix()
-	childBlock.Block.ParentRoot = blkRoot[:]
-	// shallow block
-	childBlock.Block.Slot = 201
-	wrappedChild, err := wrapper.WrappedSignedBeaconBlock(childBlock)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrappedChild))
-	candidate, err := service.optimisticCandidateBlock(ctx, wrappedChild.Block())
-	require.NoError(t, err)
-	require.Equal(t, true, candidate)
-}
-
-func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MainnetConfig())
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	stateGen := stategen.New(beaconDB)
-	fcs := protoarray.New(0, 0, [32]byte{})
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stateGen),
-		WithForkChoiceStore(fcs),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	genesisStateRoot := [32]byte{}
-	genesisBlk := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wr, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wr))
-	genesisRoot, err := genesisBlk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 0, genesisRoot, params.BeaconConfig().ZeroHash,
-		params.BeaconConfig().ZeroHash, 0, 0))
-	genesisSummary := &ethpb.StateSummary{
-		Root: genesisStateRoot[:],
-		Slot: 0,
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, genesisSummary))
-
-	// Get last validated checkpoint
-	origCheckpoint, err := service.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, origCheckpoint))
-
-	// Optimistic finalized checkpoint
-	blk := util.NewBeaconBlock()
-	blk.Block.Slot = 320
-	blk.Block.ParentRoot = genesisRoot[:]
-	wr, err = wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wr))
-	opRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	opCheckpoint := &ethpb.Checkpoint{
-		Root:  opRoot[:],
-		Epoch: 10,
-	}
-	opStateSummary := &ethpb.StateSummary{
-		Root: opRoot[:],
-		Slot: 320,
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, opStateSummary))
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 320, opRoot, genesisRoot,
-		params.BeaconConfig().ZeroHash, 10, 10))
-	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, opRoot))
-	require.NoError(t, service.updateFinalized(ctx, opCheckpoint))
-	cp, err := service.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
-	require.NoError(t, err)
-	require.DeepEqual(t, origCheckpoint.Root, cp.Root)
-	require.Equal(t, origCheckpoint.Epoch, cp.Epoch)
-
-	// Validated finalized checkpoint
-	blk = util.NewBeaconBlock()
-	blk.Block.Slot = 640
-	blk.Block.ParentRoot = opRoot[:]
-	wr, err = wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wr))
-	validRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	validCheckpoint := &ethpb.Checkpoint{
-		Root:  validRoot[:],
-		Epoch: 20,
-	}
-	validSummary := &ethpb.StateSummary{
-		Root: validRoot[:],
-		Slot: 640,
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, validSummary))
-	require.NoError(t, fcs.InsertOptimisticBlock(ctx, 640, validRoot, params.BeaconConfig().ZeroHash,
-		params.BeaconConfig().ZeroHash, 20, 20))
-	require.NoError(t, fcs.SetOptimisticToValid(ctx, validRoot))
-	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, validRoot))
-	require.NoError(t, service.updateFinalized(ctx, validCheckpoint))
-	cp, err = service.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
-	require.NoError(t, err)
-
-	optimistic, err := service.IsOptimisticForRoot(ctx, validRoot)
-	require.NoError(t, err)
-	require.Equal(t, false, optimistic)
-	require.DeepEqual(t, validCheckpoint.Root, cp.Root)
-	require.Equal(t, validCheckpoint.Epoch, cp.Epoch)
-}

beacon-chain/blockchain/process_attestation_test.go

@@ -39,17 +39,13 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 
 	BlkWithOutState := util.NewBeaconBlock()
 	BlkWithOutState.Block.Slot = 0
-	wsb, err := wrapper.WrappedSignedBeaconBlock(BlkWithOutState)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithOutState)))
 	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
 	require.NoError(t, err)
 
 	BlkWithStateBadAtt := util.NewBeaconBlock()
 	BlkWithStateBadAtt.Block.Slot = 1
-	wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithStateBadAtt)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithStateBadAtt)))
 	BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -60,9 +56,7 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 
 	BlkWithValidState := util.NewBeaconBlock()
 	BlkWithValidState.Block.Slot = 2
-	wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithValidState)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState)))
 
 	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -151,17 +145,13 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
 
 	BlkWithOutState := util.NewBeaconBlock()
 	BlkWithOutState.Block.Slot = 0
-	wsb, err := wrapper.WrappedSignedBeaconBlock(BlkWithOutState)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithOutState)))
 	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
 	require.NoError(t, err)
 
 	BlkWithStateBadAtt := util.NewBeaconBlock()
 	BlkWithStateBadAtt.Block.Slot = 1
-	wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithStateBadAtt)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithStateBadAtt)))
 	BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -172,9 +162,7 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
 
 	BlkWithValidState := util.NewBeaconBlock()
 	BlkWithValidState.Block.Slot = 2
-	wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithValidState)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState)))
 
 	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -268,7 +256,7 @@ func TestStore_OnAttestation_Ok_ProtoArray(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 0, tRoot, tRoot, 1, 1))
 	require.NoError(t, service.OnAttestation(ctx, att[0]))
 }
 
@@ -294,7 +282,7 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 0, tRoot, tRoot, 1, 1))
 	require.NoError(t, service.OnAttestation(ctx, att[0]))
 }
 
@@ -450,9 +438,7 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	d := &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: r[:]}
@@ -469,9 +455,7 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	d := &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: r[:]}
@@ -494,9 +478,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -504,9 +486,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -529,9 +509,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -539,9 +517,7 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -558,9 +534,7 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -569,9 +543,7 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -599,8 +571,8 @@ func TestVerifyFinalizedConsistency_IsCanonical(t *testing.T) {
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, b32.Block.Slot, r32, [32]byte{}, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, b33.Block.Slot, r33, r32, params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, b32.Block.Slot, r32, [32]byte{}, 0, 0))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, b33.Block.Slot, r33, r32, 0, 0))
 
 	_, err = service.cfg.ForkChoiceStore.Head(ctx, 0, r32, []uint64{}, 0)
 	require.NoError(t, err)

beacon-chain/blockchain/process_block.go

@@ -6,13 +6,11 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	coreTime "github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -109,26 +107,20 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	if err != nil {
 		return err
 	}
+	if err := s.notifyNewPayload(ctx, preStateVersion, preStateHeader, postState, signed); err != nil {
+		return errors.Wrap(err, "could not verify new payload")
+	}
+
+	// TODO(10261) Check optimistic status
 	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, false /* reg sync */); err != nil {
 		return err
 	}
-	postStateVersion, postStateHeader, err := getStateVersionAndPayload(postState)
-	if err != nil {
-		return err
-	}
-	if err := s.notifyNewPayload(ctx, preStateVersion, postStateVersion, preStateHeader, postStateHeader, signed, blockRoot); 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.
-	secondsIntoSlot := uint64(time.Since(s.genesisTime).Seconds()) % params.BeaconConfig().SecondsPerSlot
-	if err := s.cfg.ForkChoiceStore.BoostProposerRoot(ctx, &forkchoicetypes.ProposerBoostRootArgs{
-		BlockRoot:       blockRoot,
-		BlockSlot:       signed.Block().Slot(),
-		CurrentSlot:     slots.SinceGenesis(s.genesisTime),
-		SecondsIntoSlot: secondsIntoSlot,
-	}); err != nil {
+	if err := s.cfg.ForkChoiceStore.BoostProposerRoot(
+		ctx, signed.Block().Slot(), blockRoot, s.genesisTime,
+	); err != nil {
 		return err
 	}
 
@@ -191,7 +183,7 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	if err := s.updateHead(ctx, balances); err != nil {
 		log.WithError(err).Warn("Could not update head")
 	}
-	if _, err := s.notifyForkchoiceUpdate(ctx, s.headBlock().Block(), s.headRoot(), bytesutil.ToBytes32(finalized.Root)); err != nil {
+	if _, err := s.notifyForkchoiceUpdate(ctx, s.headBlock().Block(), bytesutil.ToBytes32(finalized.Root)); err != nil {
 		return err
 	}
 
@@ -238,19 +230,14 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 		if err := s.cfg.ForkChoiceStore.Prune(ctx, fRoot); err != nil {
 			return errors.Wrap(err, "could not prune proto array fork choice nodes")
 		}
-		isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(ctx, fRoot)
-		if err != nil {
-			return errors.Wrap(err, "could not check if node is optimistically synced")
-		}
 		go func() {
 			// Send an event regarding the new finalized checkpoint over a common event feed.
 			s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 				Type: statefeed.FinalizedCheckpoint,
 				Data: &ethpbv1.EventFinalizedCheckpoint{
-					Epoch:               postState.FinalizedCheckpoint().Epoch,
-					Block:               postState.FinalizedCheckpoint().Root,
-					State:               signed.Block().StateRoot(),
-					ExecutionOptimistic: isOptimistic,
+					Epoch: postState.FinalizedCheckpoint().Epoch,
+					Block: postState.FinalizedCheckpoint().Root,
+					State: signed.Block().StateRoot(),
 				},
 			})
 
@@ -271,17 +258,14 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	return s.handleEpochBoundary(ctx, postState)
 }
 
-func getStateVersionAndPayload(st state.BeaconState) (int, *ethpb.ExecutionPayloadHeader, error) {
-	if st == nil {
-		return 0, nil, errors.New("nil state")
-	}
+func getStateVersionAndPayload(preState state.BeaconState) (int, *ethpb.ExecutionPayloadHeader, error) {
 	var preStateHeader *ethpb.ExecutionPayloadHeader
 	var err error
-	preStateVersion := st.Version()
+	preStateVersion := preState.Version()
 	switch preStateVersion {
 	case version.Phase0, version.Altair:
 	default:
-		preStateHeader, err = st.LatestExecutionPayloadHeader()
+		preStateHeader, err = preState.LatestExecutionPayloadHeader()
 		if err != nil {
 			return 0, nil, err
 		}
@@ -297,11 +281,6 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 	if len(blks) == 0 || len(blockRoots) == 0 {
 		return nil, nil, errors.New("no blocks provided")
 	}
-
-	if len(blks) != len(blockRoots) {
-		return nil, nil, errWrongBlockCount
-	}
-
 	if err := helpers.BeaconBlockIsNil(blks[0]); err != nil {
 		return nil, nil, err
 	}
@@ -326,24 +305,9 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 		PublicKeys: []bls.PublicKey{},
 		Messages:   [][32]byte{},
 	}
-	type versionAndHeader struct {
-		version int
-		header  *ethpb.ExecutionPayloadHeader
-	}
-	preVersionAndHeaders := make([]*versionAndHeader, len(blks))
-	postVersionAndHeaders := make([]*versionAndHeader, len(blks))
 	var set *bls.SignatureBatch
 	boundaries := make(map[[32]byte]state.BeaconState)
 	for i, b := range blks {
-		v, h, err := getStateVersionAndPayload(preState)
-		if err != nil {
-			return nil, nil, err
-		}
-		preVersionAndHeaders[i] = &versionAndHeader{
-			version: v,
-			header:  h,
-		}
-
 		set, preState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
 		if err != nil {
 			return nil, nil, err
@@ -351,18 +315,12 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 		// 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")
+			}
 		}
 		jCheckpoints[i] = preState.CurrentJustifiedCheckpoint()
 		fCheckpoints[i] = preState.FinalizedCheckpoint()
-
-		v, h, err = getStateVersionAndPayload(preState)
-		if err != nil {
-			return nil, nil, err
-		}
-		postVersionAndHeaders[i] = &versionAndHeader{
-			version: v,
-			header:  h,
-		}
 		sigSet.Join(set)
 	}
 	verify, err := sigSet.Verify()
@@ -372,26 +330,6 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 	if !verify {
 		return nil, nil, errors.New("batch block signature verification failed")
 	}
-
-	// blocks have been verified, add them to forkchoice and call the engine
-	for i, b := range blks {
-		s.saveInitSyncBlock(blockRoots[i], b)
-		if err := s.insertBlockToForkChoiceStore(ctx, b.Block(), blockRoots[i], fCheckpoints[i], jCheckpoints[i]); err != nil {
-			return nil, nil, err
-		}
-		if err := s.notifyNewPayload(ctx,
-			preVersionAndHeaders[i].version,
-			postVersionAndHeaders[i].version,
-			preVersionAndHeaders[i].header,
-			postVersionAndHeaders[i].header, b, blockRoots[i]); err != nil {
-			return nil, nil, err
-		}
-
-		if _, err := s.notifyForkchoiceUpdate(ctx, b.Block(), blockRoots[i], bytesutil.ToBytes32(fCheckpoints[i].Root)); err != nil {
-			return nil, nil, err
-		}
-	}
-
 	for r, st := range boundaries {
 		if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
 			return nil, nil, err
@@ -413,6 +351,16 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 // their state summaries and split them off to relative hot/cold storage.
 func (s *Service) handleBlockAfterBatchVerify(ctx context.Context, signed block.SignedBeaconBlock,
 	blockRoot [32]byte, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
+	b := signed.Block()
+
+	s.saveInitSyncBlock(blockRoot, signed)
+	if err := s.insertBlockToForkChoiceStore(ctx, b, blockRoot, fCheckpoint, jCheckpoint); err != nil {
+		return err
+	}
+	// TODO(10261) send optimistic status
+	if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, blockRoot); err != nil {
+		return err
+	}
 
 	if err := s.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
 		Slot: signed.Block().Slot(),
@@ -528,27 +476,14 @@ func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk block.Be
 		return err
 	}
 	// Feed in block to fork choice store.
-
-	payloadHash, err := getBlockPayloadHash(blk)
-	if err != nil {
-		return err
-	}
-	return s.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx,
-		blk.Slot(), root, bytesutil.ToBytes32(blk.ParentRoot()), payloadHash,
+	if err := s.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx,
+		blk.Slot(), root, bytesutil.ToBytes32(blk.ParentRoot()),
 		jCheckpoint.Epoch,
-		fCheckpoint.Epoch)
-}
-
-func getBlockPayloadHash(blk block.BeaconBlock) ([32]byte, error) {
-	payloadHash := [32]byte{}
-	if blocks.IsPreBellatrixVersion(blk.Version()) {
-		return payloadHash, nil
+		fCheckpoint.Epoch); err != nil {
+		return errors.Wrap(err, "could not process block for proto array fork choice")
 	}
-	payload, err := blk.Body().ExecutionPayload()
-	if err != nil {
-		return payloadHash, err
-	}
-	return bytesutil.ToBytes32(payload.BlockHash), nil
+	// TODO(10261) send optimistic status
+	return s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, root)
 }
 
 // This saves post state info to DB or cache. This also saves post state info to fork choice store.

beacon-chain/blockchain/process_block_helpers.go

@@ -247,19 +247,10 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 	}
 
 	fRoot := bytesutil.ToBytes32(cp.Root)
-	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(ctx, fRoot)
-	if err != nil {
-		return err
-	}
-	if !optimistic {
-		err = s.cfg.BeaconDB.SaveLastValidatedCheckpoint(ctx, cp)
-		if err != nil {
-			return err
-		}
-	}
 	if err := s.cfg.StateGen.MigrateToCold(ctx, fRoot); err != nil {
 		return errors.Wrap(err, "could not migrate to cold")
 	}
+
 	return nil
 }
 
@@ -375,16 +366,16 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk block.B
 	for i := len(pendingNodes) - 1; i >= 0; i-- {
 		b := pendingNodes[i]
 		r := pendingRoots[i]
-		payloadHash, err := getBlockPayloadHash(blk)
-		if err != nil {
-			return err
-		}
 		if err := s.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx,
-			b.Slot(), r, bytesutil.ToBytes32(b.ParentRoot()), payloadHash,
+			b.Slot(), r, bytesutil.ToBytes32(b.ParentRoot()),
 			jCheckpoint.Epoch,
 			fCheckpoint.Epoch); err != nil {
 			return errors.Wrap(err, "could not process block for proto array fork choice")
 		}
+		// TODO(10261) send optimistic status
+		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, r); err != nil {
+			return err
+		}
 	}
 	return nil
 }

beacon-chain/blockchain/process_block_test.go

@@ -18,7 +18,6 @@ import (
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
@@ -51,9 +50,7 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -64,9 +61,7 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 	random := util.NewBeaconBlock()
 	random.Block.Slot = 1
 	random.Block.ParentRoot = validGenesisRoot[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(random)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(random)))
 	randomParentRoot, err := random.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
@@ -131,9 +126,7 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 
 			root, err := tt.blk.Block.HashTreeRoot()
 			assert.NoError(t, err)
-			wsb, err = wrapper.WrappedSignedBeaconBlock(tt.blk)
-			require.NoError(t, err)
-			err = service.onBlock(ctx, wsb, root)
+			err = service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.blk), root)
 			assert.ErrorContains(t, tt.wantErrString, err)
 		})
 	}
@@ -154,9 +147,7 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -167,9 +158,7 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
 	random := util.NewBeaconBlock()
 	random.Block.Slot = 1
 	random.Block.ParentRoot = validGenesisRoot[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(random)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(random)))
 	randomParentRoot, err := random.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
@@ -234,9 +223,7 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
 
 			root, err := tt.blk.Block.HashTreeRoot()
 			assert.NoError(t, err)
-			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.blk)
-			require.NoError(t, err)
-			err = service.onBlock(ctx, wsb, root)
+			err = service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.blk), root)
 			assert.ErrorContains(t, tt.wantErrString, err)
 		})
 	}
@@ -254,13 +241,7 @@ func TestStore_OnBlock_ProposerBoostEarly(t *testing.T) {
 
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	args := &forkchoicetypes.ProposerBoostRootArgs{
-		BlockRoot:       [32]byte{'A'},
-		BlockSlot:       types.Slot(0),
-		CurrentSlot:     0,
-		SecondsIntoSlot: 0,
-	}
-	require.NoError(t, service.cfg.ForkChoiceStore.BoostProposerRoot(ctx, args))
+	require.NoError(t, service.cfg.ForkChoiceStore.BoostProposerRoot(ctx, 0, [32]byte{'A'}, time.Now()))
 	_, err = service.cfg.ForkChoiceStore.Head(ctx, 0,
 		params.BeaconConfig().ZeroHash, []uint64{}, 0)
 	require.ErrorContains(t, "could not apply proposer boost score: invalid proposer boost root", err)
@@ -279,17 +260,13 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
-	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	service.saveInitSyncBlock(gRoot, wsb)
+	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
 	st, keys := util.DeterministicGenesisState(t, 64)
 
@@ -301,21 +278,15 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 	for i := 1; i < 10; i++ {
 		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		bState, err = transition.ExecuteStateTransition(ctx, bState, wsb)
+		bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		require.NoError(t, err)
 		if i == 1 {
 			firstState = bState.Copy()
 		}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		wsb, err = wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		service.saveInitSyncBlock(root, wsb)
-		wsb, err = wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		blks = append(blks, wsb)
+		service.saveInitSyncBlock(root, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		blkRoots = append(blkRoots, root)
 	}
 
@@ -324,8 +295,6 @@ func TestStore_OnBlockBatch_ProtoArray(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, blkRoots[1:])
-	require.ErrorIs(t, errWrongBlockCount, err)
 	_, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
 	require.NoError(t, err)
 }
@@ -343,17 +312,13 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 
 	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	service.saveInitSyncBlock(gRoot, wsb)
+	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
 	st, keys := util.DeterministicGenesisState(t, 64)
 
@@ -365,21 +330,15 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
 	for i := 1; i < 10; i++ {
 		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
 		require.NoError(t, err)
-		wsb, err = wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		bState, err = transition.ExecuteStateTransition(ctx, bState, wsb)
+		bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		require.NoError(t, err)
 		if i == 1 {
 			firstState = bState.Copy()
 		}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		service.saveInitSyncBlock(root, wsb)
-		wsb, err = wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		blks = append(blks, wsb)
+		service.saveInitSyncBlock(root, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		blkRoots = append(blkRoots, root)
 	}
 
@@ -388,66 +347,10 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(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, blkRoots[1:])
-	require.ErrorIs(t, errWrongBlockCount, err)
 	_, _, err = service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
 	require.NoError(t, err)
 }
 
-func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB)),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	genesis := blocks.NewGenesisBlock(params.BeaconConfig().ZeroHash[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
-	gRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err)
-	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
-	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	service.saveInitSyncBlock(gRoot, wsb)
-	st, keys := util.DeterministicGenesisState(t, 64)
-	bState := st.Copy()
-
-	var blks []block.SignedBeaconBlock
-	var blkRoots [][32]byte
-	var firstState state.BeaconState
-	blkCount := 4
-	for i := 1; i <= blkCount; i++ {
-		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
-		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		bState, err = transition.ExecuteStateTransition(ctx, bState, wsb)
-		require.NoError(t, err)
-		if i == 1 {
-			firstState = bState.Copy()
-		}
-		root, err := b.Block.HashTreeRoot()
-		require.NoError(t, err)
-		service.saveInitSyncBlock(root, wsb)
-		blks = append(blks, wsb)
-		blkRoots = append(blkRoots, root)
-	}
-
-	rBlock, err := blks[0].PbPhase0Block()
-	assert.NoError(t, err)
-	rBlock.Block.ParentRoot = gRoot[:]
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), blks[0]))
-	require.NoError(t, service.cfg.StateGen.SaveState(ctx, blkRoots[0], firstState))
-	cp1, cp2, err := service.onBlockBatch(ctx, blks[1:], blkRoots[1:])
-	require.NoError(t, err)
-	require.Equal(t, blkCount-1, len(cp1))
-	require.Equal(t, blkCount-1, len(cp2))
-}
-
 func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	ctx := context.Background()
 	params.SetupTestConfigCleanup(t)
@@ -470,12 +373,8 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(newJustifiedBlk)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
-	wsb, err = wrapper.WrappedSignedBeaconBlock(lastJustifiedBlk)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk)))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk)))
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
@@ -502,12 +401,8 @@ func TestShouldUpdateJustified_ReturnFalse_ProtoArray(t *testing.T) {
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(newJustifiedBlk)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
-	wsb, err = wrapper.WrappedSignedBeaconBlock(lastJustifiedBlk)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk)))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk)))
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
@@ -535,12 +430,8 @@ func TestShouldUpdateJustified_ReturnFalse_DoublyLinkedTree(t *testing.T) {
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(newJustifiedBlk)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
-	wsb, err = wrapper.WrappedSignedBeaconBlock(lastJustifiedBlk)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk)))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk)))
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
@@ -567,16 +458,12 @@ func TestCachedPreState_CanGetFromStateSummary_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
-	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	service.saveInitSyncBlock(gRoot, wsb)
+	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
@@ -602,16 +489,12 @@ func TestCachedPreState_CanGetFromStateSummary_DoublyLinkedTree(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	service.saveInitSyncBlock(gRoot, wsb)
+	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
@@ -634,16 +517,12 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	gRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 	service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
-	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	service.saveInitSyncBlock(gRoot, wsb)
+	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
@@ -657,9 +536,7 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: gRoot[:]}))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, gRoot, s))
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.verifyBlkPreState(ctx, wsb.Block()))
+	require.NoError(t, service.verifyBlkPreState(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b).Block()))
 }
 
 func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
@@ -675,9 +552,7 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	require.NoError(t, err)
 
 	signedBlock := util.NewBeaconBlock()
-	wsb, err := wrapper.WrappedSignedBeaconBlock(signedBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(signedBlock)))
 	r, err := signedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: []byte{'A'}})
@@ -716,9 +591,7 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -729,14 +602,12 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	blk := util.NewBeaconBlock()
-	blk.Block.Slot = 9
-	blk.Block.ParentRoot = roots[8]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
+	block := util.NewBeaconBlock()
+	block.Block.Slot = 9
+	block.Block.ParentRoot = roots[8]
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -761,9 +632,7 @@ func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -774,15 +643,12 @@ func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	blk := util.NewBeaconBlock()
-	blk.Block.Slot = 9
-	blk.Block.ParentRoot = roots[8]
-
-	wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
+	block := util.NewBeaconBlock()
+	block.Block.Slot = 9
+	block.Block.ParentRoot = roots[8]
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -807,9 +673,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -820,15 +684,12 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	blk := util.NewBeaconBlock()
-	blk.Block.Slot = 9
-	blk.Block.ParentRoot = roots[8]
-
-	wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
+	block := util.NewBeaconBlock()
+	block.Block.Slot = 9
+	block.Block.ParentRoot = roots[8]
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -856,9 +717,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -869,15 +728,12 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	blk := util.NewBeaconBlock()
-	blk.Block.Slot = 9
-	blk.Block.ParentRoot = roots[8]
-
-	wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
+	block := util.NewBeaconBlock()
+	block.Block.Slot = 9
+	block.Block.ParentRoot = roots[8]
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -906,9 +762,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -919,29 +773,23 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
 	// Define a tree branch, slot 63 <- 64 <- 65
 	b63 := util.NewBeaconBlock()
 	b63.Block.Slot = 63
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b63)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b63)))
 	r63, err := b63.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b64 := util.NewBeaconBlock()
 	b64.Block.Slot = 64
 	b64.Block.ParentRoot = r63[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b64)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b64)))
 	r64, err := b64.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b65 := util.NewBeaconBlock()
 	b65.Block.Slot = 65
 	b65.Block.ParentRoot = r64[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b65)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b65)))
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b65).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// There should be 2 nodes, block 65 and block 64.
@@ -967,9 +815,7 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -980,29 +826,23 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing
 	// Define a tree branch, slot 63 <- 64 <- 65
 	b63 := util.NewBeaconBlock()
 	b63.Block.Slot = 63
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b63)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b63)))
 	r63, err := b63.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b64 := util.NewBeaconBlock()
 	b64.Block.Slot = 64
 	b64.Block.ParentRoot = r63[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b64)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b64)))
 	r64, err := b64.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b65 := util.NewBeaconBlock()
 	b65.Block.Slot = 65
 	b65.Block.ParentRoot = r64[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b65)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b65)))
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b65).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// There should be 2 nodes, block 65 and block 64.
@@ -1082,9 +922,7 @@ func blockTree1(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][]byt
 		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
-		require.NoError(t, err)
-		if err := beaconDB.SaveBlock(context.Background(), wsb); err != nil {
+		if err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)); err != nil {
 			return nil, err
 		}
 		if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
@@ -1152,9 +990,7 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
+		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)))
 	}
 
 	// Slots 100 to 200 are skip slots. Requesting root at 150 will yield root at 100. The last physical block.
@@ -1199,7 +1035,7 @@ func TestAncestor_CanUseForkchoice(t *testing.T) {
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, 0, 0)) // Saves blocks to fork choice store.
+		require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), 0, 0)) // Saves blocks to fork choice store.
 	}
 
 	r, err := service.ancestor(context.Background(), r200[:], 150)
@@ -1241,12 +1077,10 @@ func TestAncestor_CanUseDB(t *testing.T) {
 		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb)) // Saves blocks to DB.
+		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock))) // Saves blocks to DB.
 	}
 
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(context.Background(), 200, r200, r200, 0, 0))
 
 	r, err := service.ancestor(context.Background(), r200[:], 150)
 	require.NoError(t, err)
@@ -1283,18 +1117,14 @@ func TestVerifyBlkDescendant(t *testing.T) {
 	b.Block.Slot = 1
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 
 	b1 := util.NewBeaconBlock()
 	b1.Block.Slot = 1
 	b1.Block.Body.Graffiti = bytesutil.PadTo([]byte{'a'}, 32)
 	r1, err := b1.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b1)))
 
 	type args struct {
 		parentRoot    [32]byte
@@ -1358,9 +1188,7 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 	gBlk := util.NewBeaconBlock()
 	gRoot, err := gBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(gBlk)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(gBlk)))
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, gRoot))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: gRoot[:]}))
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
@@ -1436,9 +1264,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 		require.NoError(t, err)
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wsb, r))
+		require.NoError(t, service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r))
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -1490,9 +1316,7 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 		require.NoError(t, err)
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wsb, r))
+		require.NoError(t, service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r))
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -1556,9 +1380,7 @@ func TestRemoveBlockAttestationsInPool_Canonical(t *testing.T) {
 
 	atts := b.Block.Body.Attestations
 	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wsb))
+	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
 }
 
@@ -1580,9 +1402,7 @@ func TestRemoveBlockAttestationsInPool_NonCanonical(t *testing.T) {
 
 	atts := b.Block.Body.Attestations
 	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wsb))
+	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	require.Equal(t, 1, service.cfg.AttPool.AggregatedAttestationCount())
 }
 

beacon-chain/blockchain/receive_attestation.go

@@ -161,36 +161,14 @@ func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
 					log.WithError(err).Errorf("Unable to get justified balances for root %v", justified.Root)
 					continue
 				}
-				prevHead := s.headRoot()
 				if err := s.updateHead(s.ctx, balances); err != nil {
 					log.WithError(err).Warn("Resolving fork due to new attestation")
 				}
-				s.notifyEngineIfChangedHead(prevHead)
 			}
 		}
 	}()
 }
 
-// This calls notify Forkchoice Update in the event that the head has changed
-func (s *Service) notifyEngineIfChangedHead(prevHead [32]byte) {
-	if s.headRoot() == prevHead {
-		return
-	}
-	finalized := s.store.FinalizedCheckpt()
-	if finalized == nil {
-		log.WithError(errNilFinalizedInStore).Error("could not get finalized checkpoint")
-		return
-	}
-	_, err := s.notifyForkchoiceUpdate(s.ctx,
-		s.headBlock().Block(),
-		s.headRoot(),
-		bytesutil.ToBytes32(finalized.Root),
-	)
-	if err != nil {
-		log.WithError(err).Error("could not notify forkchoice update")
-	}
-}
-
 // This processes fork choice attestations from the pool to account for validator votes and fork choice.
 func (s *Service) processAttestations(ctx context.Context) {
 	atts := s.cfg.AttPool.ForkchoiceAttestations()

beacon-chain/blockchain/receive_attestation_test.go

@@ -47,17 +47,13 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -78,17 +74,13 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -119,45 +111,9 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	copied, err = transition.ProcessSlots(ctx, copied, 1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 0, tRoot, tRoot, 1, 1))
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
 	service.processAttestations(ctx)
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations()))
 	require.LogsDoNotContain(t, hook, "Could not process attestation for fork choice")
 }
-
-func TestNotifyEngineIfChangedHead(t *testing.T) {
-	hook := logTest.NewGlobal()
-	ctx := context.Background()
-	opts := testServiceOptsWithDB(t)
-
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	service.notifyEngineIfChangedHead(service.headRoot())
-	hookErr := "could not notify forkchoice update"
-	finalizedErr := "could not get finalized checkpoint"
-	require.LogsDoNotContain(t, hook, finalizedErr)
-	require.LogsDoNotContain(t, hook, hookErr)
-	service.notifyEngineIfChangedHead([32]byte{'a'})
-	require.LogsContain(t, hook, finalizedErr)
-
-	hook.Reset()
-	b := util.NewBeaconBlock()
-	b.Block.Slot = 1
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	finalized := &ethpb.Checkpoint{Root: r[:], Epoch: 0}
-	service.head = &head{
-		slot:  1,
-		root:  r,
-		block: wsb,
-	}
-	service.store.SetFinalizedCheckpt(finalized)
-	service.notifyEngineIfChangedHead([32]byte{'b'})
-	require.LogsDoNotContain(t, hook, finalizedErr)
-	require.LogsDoNotContain(t, hook, hookErr)
-}

beacon-chain/blockchain/receive_block.go

@@ -64,9 +64,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block block.SignedBeaconBloc
 		return err
 	}
 	// Log state transition data.
-	if err := logStateTransitionData(blockCopy.Block()); err != nil {
-		return err
-	}
+	logStateTransitionData(blockCopy.Block())
 
 	return nil
 }

beacon-chain/blockchain/receive_block_test.go

@@ -132,7 +132,6 @@ func TestService_ReceiveBlock(t *testing.T) {
 				WithExitPool(voluntaryexits.NewPool()),
 				WithStateNotifier(&blockchainTesting.MockStateNotifier{RecordEvents: true}),
 				WithStateGen(stategen.New(beaconDB)),
-				WithFinalizedStateAtStartUp(genesis),
 			}
 			s, err := NewService(ctx, opts...)
 			require.NoError(t, err)
@@ -144,9 +143,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
-			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
-			require.NoError(t, err)
-			err = s.ReceiveBlock(ctx, wsb, root)
+			err = s.ReceiveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block), root)
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
@@ -187,9 +184,7 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	go func() {
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		require.NoError(t, s.ReceiveBlock(ctx, wsb, root))
+		require.NoError(t, s.ReceiveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b), root))
 		wg.Done()
 	}()
 	wg.Wait()
@@ -265,9 +260,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
-			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
-			require.NoError(t, err)
-			blks := []block.SignedBeaconBlock{wsb}
+			blks := []block.SignedBeaconBlock{wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block)}
 			roots := [][32]byte{root}
 			err = s.ReceiveBlockBatch(ctx, blks, roots)
 			if tt.wantedErr != "" {
@@ -289,9 +282,7 @@ func TestService_HasInitSyncBlock(t *testing.T) {
 	if s.HasInitSyncBlock(r) {
 		t.Error("Should not have block")
 	}
-	wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	s.saveInitSyncBlock(r, wsb)
+	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()))
 	if !s.HasInitSyncBlock(r) {
 		t.Error("Should have block")
 	}

beacon-chain/blockchain/service.go

@@ -3,7 +3,6 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"runtime"
@@ -128,7 +127,7 @@ func (s *Service) Start() {
 	saved := s.cfg.FinalizedStateAtStartUp
 
 	if saved != nil && !saved.IsNil() {
-		if err := s.StartFromSavedState(saved); err != nil {
+		if err := s.startFromSavedState(saved); err != nil {
 			log.Fatal(err)
 		}
 	} else {
@@ -165,7 +164,7 @@ func (s *Service) Status() error {
 	return nil
 }
 
-func (s *Service) StartFromSavedState(saved state.BeaconState) error {
+func (s *Service) startFromSavedState(saved state.BeaconState) error {
 	log.Info("Blockchain data already exists in DB, initializing...")
 	s.genesisTime = time.Unix(int64(saved.GenesisTime()), 0) // lint:ignore uintcast -- Genesis time will not exceed int64 in your lifetime.
 	s.cfg.AttService.SetGenesisTime(saved.GenesisTime())
@@ -192,44 +191,21 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	s.store = store.New(justified, finalized)
 
 	var store f.ForkChoicer
-	fRoot := bytesutil.ToBytes32(finalized.Root)
 	if features.Get().EnableForkChoiceDoublyLinkedTree {
 		store = doublylinkedtree.New(justified.Epoch, finalized.Epoch)
 	} else {
-		store = protoarray.New(justified.Epoch, finalized.Epoch, fRoot)
+		store = protoarray.New(justified.Epoch, finalized.Epoch, bytesutil.ToBytes32(finalized.Root))
 	}
 	s.cfg.ForkChoiceStore = store
-	fb, err := s.cfg.BeaconDB.Block(s.ctx, s.ensureRootNotZeros(fRoot))
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint block")
-	}
-	if fb == nil {
-		return errNilFinalizedInStore
-	}
-	payloadHash, err := getBlockPayloadHash(fb.Block())
-	if err != nil {
-		return errors.Wrap(err, "could not get execution payload hash")
-	}
-	fSlot := fb.Block().Slot()
-	if err := store.InsertOptimisticBlock(s.ctx, fSlot, fRoot, params.BeaconConfig().ZeroHash,
-		payloadHash, justified.Epoch, finalized.Epoch); err != nil {
-		return errors.Wrap(err, "could not insert finalized block to forkchoice")
-	}
 
-	lastValidatedCheckpoint, err := s.cfg.BeaconDB.LastValidatedCheckpoint(s.ctx)
+	ss, err := slots.EpochStart(finalized.Epoch)
 	if err != nil {
-		return errors.Wrap(err, "could not get last validated checkpoint")
+		return errors.Wrap(err, "could not get start slot of finalized epoch")
 	}
-	if bytes.Equal(finalized.Root, lastValidatedCheckpoint.Root) {
-		if err := store.SetOptimisticToValid(s.ctx, fRoot); err != nil {
-			return errors.Wrap(err, "could not set finalized block as validated")
-		}
-	}
-
 	h := s.headBlock().Block()
-	if h.Slot() > fSlot {
+	if h.Slot() > ss {
 		log.WithFields(logrus.Fields{
-			"startSlot": fSlot,
+			"startSlot": ss,
 			"endSlot":   h.Slot(),
 		}).Info("Loading blocks to fork choice store, this may take a while.")
 		if err := s.fillInForkChoiceMissingBlocks(s.ctx, h, finalized, justified); err != nil {
@@ -257,7 +233,7 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 
 func (s *Service) originRootFromSavedState(ctx context.Context) ([32]byte, error) {
 	// first check if we have started from checkpoint sync and have a root
-	originRoot, err := s.cfg.BeaconDB.OriginCheckpointBlockRoot(ctx)
+	originRoot, err := s.cfg.BeaconDB.OriginBlockRoot(ctx)
 	if err == nil {
 		return originRoot, nil
 	}
@@ -265,7 +241,7 @@ func (s *Service) originRootFromSavedState(ctx context.Context) ([32]byte, error
 		return originRoot, errors.Wrap(err, "could not retrieve checkpoint sync chain origin data from db")
 	}
 
-	// we got here because OriginCheckpointBlockRoot gave us an ErrNotFound. this means the node was started from a genesis state,
+	// we got here because OriginBlockRoot gave us an ErrNotFound. this means the node was started from a genesis state,
 	// so we should have a value for GenesisBlock
 	genesisBlock, err := s.cfg.BeaconDB.GenesisBlock(ctx)
 	if err != nil {
@@ -473,15 +449,10 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	genesisCheckpoint := genesisState.FinalizedCheckpoint()
 	s.store = store.New(genesisCheckpoint, genesisCheckpoint)
 
-	payloadHash, err := getBlockPayloadHash(genesisBlk.Block())
-	if err != nil {
-		return err
-	}
 	if err := s.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx,
 		genesisBlk.Block().Slot(),
 		genesisBlkRoot,
 		params.BeaconConfig().ZeroHash,
-		payloadHash,
 		genesisCheckpoint.Epoch,
 		genesisCheckpoint.Epoch); err != nil {
 		log.Fatalf("Could not process genesis block for fork choice: %v", err)

beacon-chain/blockchain/service_test.go

@@ -144,9 +144,7 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(1))
@@ -155,11 +153,6 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	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[:]}))
-	ss := &ethpb.StateSummary{
-		Slot: 1,
-		Root: blkRoot[:],
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, ss))
 	chainService.cfg.FinalizedStateAtStartUp = s
 	// Test the start function.
 	chainService.Start()
@@ -181,16 +174,12 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
 	chainService.cfg.FinalizedStateAtStartUp = s
 	// Test the start function.
 	chainService.Start()
@@ -254,9 +243,7 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
 	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(0))
@@ -283,9 +270,7 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
 	headBlock := util.NewBeaconBlock()
@@ -299,17 +284,13 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
-	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
 	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
 	require.NoError(t, err)
-	stateGen := stategen.New(beaconDB)
-	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stateGen), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
+	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stategen.New(beaconDB)), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
 	require.NoError(t, err)
-	require.NoError(t, stateGen.SaveState(ctx, headRoot, headState))
-	require.NoError(t, c.StartFromSavedState(headState))
+	require.NoError(t, c.startFromSavedState(headState))
 	headBlk, err := c.HeadBlock(ctx)
 	require.NoError(t, err)
 	assert.DeepEqual(t, headBlock, headBlk.Proto(), "Head block incorrect")
@@ -333,9 +314,7 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
 
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
 	headBlock := util.NewBeaconBlock()
@@ -349,27 +328,17 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
-	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
 	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
 	require.NoError(t, err)
-	ss := &ethpb.StateSummary{
-		Slot: finalizedSlot,
-		Root: headRoot[:],
-	}
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, ss))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: headRoot[:], Epoch: slots.ToEpoch(finalizedSlot)}))
-	stateGen := stategen.New(beaconDB)
-	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stateGen), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
+	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stategen.New(beaconDB)), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}))
 	require.NoError(t, err)
-
-	require.NoError(t, c.StartFromSavedState(headState))
+	require.NoError(t, c.startFromSavedState(headState))
 	s, err := c.HeadState(ctx)
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
 	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
-	assert.DeepEqual(t, headBlock, c.head.block.Proto())
+	assert.DeepEqual(t, genesis, c.head.block.Proto())
 }
 
 func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
@@ -390,18 +359,14 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	genesisRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock)))
 
 	finalizedBlock := util.NewBeaconBlock()
 	finalizedBlock.Block.Slot = finalizedSlot
 	finalizedBlock.Block.ParentRoot = genesisRoot[:]
 	finalizedRoot, err := finalizedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(finalizedBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(finalizedBlock)))
 
 	// Set head slot close to the finalization point, no head sync is triggered.
 	headBlock := util.NewBeaconBlock()
@@ -409,16 +374,15 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
 
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, headState.SetSlot(headBlock.Block.Slot))
 	require.NoError(t, headState.SetGenesisValidatorsRoot(params.BeaconConfig().ZeroHash[:]))
-	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
+	require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, finalizedRoot))
+	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{
 		Epoch: slots.ToEpoch(finalizedBlock.Block.Slot),
@@ -427,10 +391,9 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 
 	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
 	require.NoError(t, err)
-	stateGen := stategen.New(beaconDB)
-	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stateGen), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
+	c, err := NewService(ctx, WithDatabase(beaconDB), WithStateGen(stategen.New(beaconDB)), WithAttestationService(attSrv), WithStateNotifier(&mock.MockStateNotifier{}), WithFinalizedStateAtStartUp(headState))
 	require.NoError(t, err)
-	require.NoError(t, c.StartFromSavedState(headState))
+	require.NoError(t, c.startFromSavedState(headState))
 	s, err := c.HeadState(ctx)
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
@@ -446,9 +409,7 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err = headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
 
@@ -477,9 +438,7 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	newState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.StateGen.SaveState(ctx, r, newState))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, s.saveHeadNoDB(ctx, wsb, r, newState))
+	require.NoError(t, s.saveHeadNoDB(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r, newState))
 
 	newB, err := s.cfg.BeaconDB.HeadBlock(ctx)
 	require.NoError(t, err)
@@ -501,9 +460,7 @@ func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
+	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
 
 	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
 	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -522,9 +479,7 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
+	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
 
 	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
 	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -542,9 +497,7 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 	block := util.NewBeaconBlock()
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	s.saveInitSyncBlock(r, wsb)
+	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.NoError(t, s.Stop())
 	require.Equal(t, true, s.cfg.BeaconDB.HasBlock(ctx, r))
 }
@@ -570,9 +523,7 @@ func BenchmarkHasBlockDB(b *testing.B) {
 		cfg: &config{BeaconDB: beaconDB},
 	}
 	block := util.NewBeaconBlock()
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(b, err)
-	require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wsb))
+	require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block)))
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)
 
@@ -590,15 +541,13 @@ func BenchmarkHasBlockForkChoiceStore_ProtoArray(b *testing.B) {
 		store: &store.Store{},
 	}
 	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
-	blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
-	r, err := blk.Block.HashTreeRoot()
+	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
+	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)
 	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	beaconState, err := v1.InitializeFromProto(bs)
 	require.NoError(b, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(b, err)
-	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
+	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -619,9 +568,7 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	beaconState, err := v1.InitializeFromProto(bs)
 	require.NoError(b, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(b, err)
-	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
+	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

beacon-chain/blockchain/weak_subjectivity_checks.go

@@ -36,7 +36,6 @@ func NewWeakSubjectivityVerifier(wsc *ethpb.Checkpoint, db weakSubjectivityDB) (
 	// per 7342, a nil checkpoint, zero-root or zero-epoch should all fail validation
 	// and return an error instead of creating a WeakSubjectivityVerifier that permits any chain history.
 	if wsc == nil || len(wsc.Root) == 0 || wsc.Epoch == 0 {
-		log.Warn("No valid weak subjectivity checkpoint specified, running without weak subjectivity verification")
 		return &WeakSubjectivityVerifier{
 			enabled: false,
 		}, nil
@@ -80,17 +79,15 @@ func (v *WeakSubjectivityVerifier) VerifyWeakSubjectivity(ctx context.Context, f
 	if !v.db.HasBlock(ctx, v.root) {
 		return errors.Wrap(errWSBlockNotFound, fmt.Sprintf("missing root %#x", v.root))
 	}
-	endSlot := v.slot + params.BeaconConfig().SlotsPerEpoch
-	filter := filters.NewFilter().SetStartSlot(v.slot).SetEndSlot(endSlot)
+	filter := filters.NewFilter().SetStartSlot(v.slot).SetEndSlot(v.slot + params.BeaconConfig().SlotsPerEpoch)
 	// A node should have the weak subjectivity block corresponds to the correct epoch in the DB.
-	log.Infof("Searching block roots for weak subjectivity root=%#x, between slots %d-%d", v.root, v.slot, endSlot)
 	roots, err := v.db.BlockRoots(ctx, filter)
 	if err != nil {
 		return errors.Wrap(err, "error while retrieving block roots to verify weak subjectivity")
 	}
 	for _, root := range roots {
 		if v.root == root {
-			log.Info("Weak subjectivity check has passed!!")
+			log.Info("Weak subjectivity check has passed")
 			v.verified = true
 			return nil
 		}

beacon-chain/blockchain/weak_subjectivity_checks_test.go

@@ -14,65 +14,58 @@ import (
 	"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 TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 
 	b := util.NewBeaconBlock()
-	b.Block.Slot = 1792480
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
+	b.Block.Slot = 32
+	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-
-	blockEpoch := slots.ToEpoch(b.Block.Slot)
 	tests := []struct {
 		wsVerified     bool
-		disabled       bool
 		wantErr        error
 		checkpt        *ethpb.Checkpoint
 		finalizedEpoch types.Epoch
 		name           string
 	}{
 		{
-			name:     "nil root and epoch",
-			disabled: true,
+			name: "nil root and epoch",
+		},
+		{
+			name:           "already verified",
+			checkpt:        &ethpb.Checkpoint{Epoch: 2},
+			finalizedEpoch: 2,
+			wsVerified:     true,
 		},
 		{
 			name:           "not yet to verify, ws epoch higher than finalized epoch",
-			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, 32), Epoch: blockEpoch},
-			finalizedEpoch: blockEpoch - 1,
+			checkpt:        &ethpb.Checkpoint{Epoch: 2},
+			finalizedEpoch: 1,
 		},
 		{
 			name:           "can't find the block in DB",
 			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength), Epoch: 1},
-			finalizedEpoch: blockEpoch + 1,
+			finalizedEpoch: 3,
 			wantErr:        errWSBlockNotFound,
 		},
 		{
 			name:           "can't find the block corresponds to ws epoch in DB",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch - 2}, // Root belongs in epoch 1.
-			finalizedEpoch: blockEpoch - 1,
+			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 2}, // Root belongs in epoch 1.
+			finalizedEpoch: 3,
 			wantErr:        errWSBlockNotFoundInEpoch,
 		},
 		{
 			name:           "can verify and pass",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch},
-			finalizedEpoch: blockEpoch + 1,
-		},
-		{
-			name:           "equal epoch",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch},
-			finalizedEpoch: blockEpoch,
+			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 1},
+			finalizedEpoch: 3,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			wv, err := NewWeakSubjectivityVerifier(tt.checkpt, beaconDB)
-			require.Equal(t, !tt.disabled, wv.enabled)
 			require.NoError(t, err)
 			s := &Service{
 				cfg:        &config{BeaconDB: beaconDB, WeakSubjectivityCheckpt: tt.checkpt},

beacon-chain/cache/active_balance_disabled.go

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

beacon-chain/cache/committee.go

@@ -44,7 +44,6 @@ type CommitteeCache struct {
 	CommitteeCache *lru.Cache
 	lock           sync.RWMutex
 	inProgress     map[string]bool
-	disabled       bool
 }
 
 // committeeKeyFn takes the seed as the key to retrieve shuffled indices of a committee in a given epoch.
@@ -64,20 +63,9 @@ func NewCommitteesCache() *CommitteeCache {
 	}
 }
 
-func (c *CommitteeCache) Disable() {
-	c.disabled = true
-}
-
-func (c *CommitteeCache) Enable() {
-	c.disabled = false
-}
-
 // Committee fetches the shuffled indices by slot and committee index. Every list of indices
 // represent one committee. Returns true if the list exists with slot and committee index. Otherwise returns false, nil.
 func (c *CommitteeCache) Committee(ctx context.Context, slot types.Slot, seed [32]byte, index types.CommitteeIndex) ([]types.ValidatorIndex, error) {
-	if c.disabled {
-		return nil, nil
-	}
 	if err := c.checkInProgress(ctx, seed); err != nil {
 		return nil, err
 	}
@@ -128,9 +116,6 @@ func (c *CommitteeCache) AddCommitteeShuffledList(committees *Committees) error
 
 // ActiveIndices returns the active indices of a given seed stored in cache.
 func (c *CommitteeCache) ActiveIndices(ctx context.Context, seed [32]byte) ([]types.ValidatorIndex, error) {
-	if c.disabled {
-		return nil, nil
-	}
 	if err := c.checkInProgress(ctx, seed); err != nil {
 		return nil, err
 	}
@@ -153,9 +138,6 @@ func (c *CommitteeCache) ActiveIndices(ctx context.Context, seed [32]byte) ([]ty
 
 // ActiveIndicesCount returns the active indices count of a given seed stored in cache.
 func (c *CommitteeCache) ActiveIndicesCount(ctx context.Context, seed [32]byte) (int, error) {
-	if c.disabled {
-		return 0, nil
-	}
 	if err := c.checkInProgress(ctx, seed); err != nil {
 		return 0, err
 	}
@@ -178,9 +160,6 @@ func (c *CommitteeCache) ActiveIndicesCount(ctx context.Context, seed [32]byte)
 
 // HasEntry returns true if the committee cache has a value.
 func (c *CommitteeCache) HasEntry(seed string) bool {
-	if c.disabled {
-		return false
-	}
 	_, ok := c.CommitteeCache.Get(seed)
 	return ok
 }

beacon-chain/cache/committee_disabled.go

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

beacon-chain/cache/proposer_indices.go

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

beacon-chain/cache/proposer_indices_disabled.go

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

beacon-chain/cache/sync_committee.go

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

beacon-chain/cache/sync_committee_disabled.go

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

beacon-chain/core/altair/attestation.go

@@ -104,30 +104,34 @@ func SetParticipationAndRewardProposer(
 	targetEpoch types.Epoch,
 	indices []uint64,
 	participatedFlags map[uint8]bool, totalBalance uint64) (state.BeaconState, error) {
-	var proposerRewardNumerator uint64
+	var epochParticipation []byte
 	currentEpoch := time.CurrentEpoch(beaconState)
-	var stateErr error
+	var err error
 	if targetEpoch == currentEpoch {
-		stateErr = beaconState.ModifyCurrentParticipationBits(func(val []byte) ([]byte, error) {
-			propRewardNum, epochParticipation, err := EpochParticipation(beaconState, indices, val, participatedFlags, totalBalance)
-			if err != nil {
-				return nil, err
-			}
-			proposerRewardNumerator = propRewardNum
-			return epochParticipation, nil
-		})
+		epochParticipation, err = beaconState.CurrentEpochParticipation()
+		if err != nil {
+			return nil, err
+		}
 	} else {
-		stateErr = beaconState.ModifyPreviousParticipationBits(func(val []byte) ([]byte, error) {
-			propRewardNum, epochParticipation, err := EpochParticipation(beaconState, indices, val, participatedFlags, totalBalance)
-			if err != nil {
-				return nil, err
-			}
-			proposerRewardNumerator = propRewardNum
-			return epochParticipation, nil
-		})
+		epochParticipation, err = beaconState.PreviousEpochParticipation()
+		if err != nil {
+			return nil, err
+		}
 	}
-	if stateErr != nil {
-		return nil, stateErr
+
+	proposerRewardNumerator, epochParticipation, err := EpochParticipation(beaconState, indices, epochParticipation, participatedFlags, totalBalance)
+	if err != nil {
+		return nil, err
+	}
+
+	if targetEpoch == currentEpoch {
+		if err := beaconState.SetCurrentParticipationBits(epochParticipation); err != nil {
+			return nil, err
+		}
+	} else {
+		if err := beaconState.SetPreviousParticipationBits(epochParticipation); err != nil {
+			return nil, err
+		}
 	}
 
 	if err := RewardProposer(ctx, beaconState, proposerRewardNumerator); err != nil {

beacon-chain/core/altair/attestation_test.go

@@ -48,7 +48,7 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 		params.BeaconConfig().MinAttestationInclusionDelay,
 		beaconState.Slot(),
 	)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, want, err)
@@ -79,7 +79,7 @@ func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
 		time.PrevEpoch(beaconState),
 		time.CurrentEpoch(beaconState),
 	)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, want, err)
@@ -108,13 +108,13 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
 
 	want := "source check point not equal to current justified checkpoint"
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, want, err)
 	b.Block.Body.Attestations[0].Data.Source.Epoch = time.CurrentEpoch(beaconState)
 	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b)
+	wsb, err = wrapper.WrappedAltairSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, want, err)
@@ -149,14 +149,14 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 	require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(pfc))
 
 	want := "source check point not equal to previous justified checkpoint"
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, want, err)
 	b.Block.Body.Attestations[0].Data.Source.Epoch = time.PrevEpoch(beaconState)
 	b.Block.Body.Attestations[0].Data.Target.Epoch = time.PrevEpoch(beaconState)
 	b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b)
+	wsb, err = wrapper.WrappedAltairSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, want, err)
@@ -188,7 +188,7 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
 
 	expected := "failed to verify aggregation bitfield: wanted participants bitfield length 3, got: 4"
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, expected, err)
@@ -232,7 +232,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 
 	err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -421,7 +421,7 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 		}
 		s, err := stateAltair.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+		wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
 		require.NoError(t, err)
 		r, err := altair.ProcessAttestationsNoVerifySignature(context.Background(), s, wsb)
 		if err != nil && r != nil {

beacon-chain/core/blocks/BUILD.bazel

@@ -45,7 +45,6 @@ go_library(
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/block:go_default_library",
         "//proto/prysm/v1alpha1/slashings:go_default_library",
-        "//proto/prysm/v1alpha1/wrapper:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -42,9 +42,7 @@ func TestFuzzProcessBlockHeader_10000(t *testing.T) {
 
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-		require.NoError(t, err)
-		_, err = ProcessBlockHeader(context.Background(), s, wsb)
+		_, err = ProcessBlockHeader(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(block))
 		_ = err
 	}
 }
@@ -143,9 +141,7 @@ func TestFuzzProcessRandao_10000(t *testing.T) {
 		fuzzer.Fuzz(b)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := ProcessRandao(context.Background(), s, wsb)
+		r, err := ProcessRandao(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}
@@ -264,9 +260,7 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 		fuzzer.Fuzz(b)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		r, err := ProcessAttestationsNoVerifySignature(ctx, s, wsb)
+		r, err := ProcessAttestationsNoVerifySignature(ctx, s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
 		}

beacon-chain/core/blocks/header_test.go

@@ -68,9 +68,7 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	assert.ErrorContains(t, "block.Slot 10 must be greater than state.LatestBlockHeader.Slot 10", err)
 }
 
@@ -96,9 +94,7 @@ func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
 	block.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx+1])
 	require.NoError(t, err)
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(context.Background(), beaconState, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	want := "signature did not verify"
 	assert.ErrorContains(t, want, err)
 }
@@ -140,9 +136,7 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 		Signature: blockSig,
 	})
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	want := "is different than block slot"
 	assert.ErrorContains(t, want, err)
 }
@@ -181,9 +175,7 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 	block.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, 32)
 	block.Signature = blockSig
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	want := "does not match"
 	assert.ErrorContains(t, want, err)
 }
@@ -225,9 +217,7 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 	block.Block.ParentRoot = parentRoot[:]
 	block.Signature = blockSig
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	want := "was previously slashed"
 	assert.ErrorContains(t, want, err)
 }
@@ -276,9 +266,7 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	newState, err := blocks.ProcessBlockHeader(context.Background(), state, wsb)
+	newState, err := blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.NoError(t, err, "Failed to process block header got")
 	var zeroHash [32]byte
 	nsh := newState.LatestBlockHeader()

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"
@@ -13,96 +14,86 @@ import (
 	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/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
-// IsMergeTransitionComplete returns true if the transition to Bellatrix 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_transition_complete(state: BeaconState) -> bool:
 //    return state.latest_execution_payload_header != ExecutionPayloadHeader()
-func IsMergeTransitionComplete(st state.BeaconState) (bool, error) {
-	if st == nil {
-		return false, errors.New("nil state")
-	}
-	if IsPreBellatrixVersion(st.Version()) {
-		return false, nil
-	}
+//
+// Deprecated: Use `IsMergeTransitionBlockUsingPayloadHeader` instead.
+func MergeTransitionComplete(st state.BeaconState) (bool, error) {
 	h, err := st.LatestExecutionPayloadHeader()
 	if err != nil {
 		return false, err
 	}
+
 	return !isEmptyHeader(h), nil
 }
 
-// IsMergeTransitionBlockUsingPreStatePayloadHeader returns true if the input block is the terminal merge block.
-// Terminal merge block must be associated with an empty payload header.
-// This assumes the header `h` is referenced as the parent state for block body `body.
-func IsMergeTransitionBlockUsingPreStatePayloadHeader(h *ethpb.ExecutionPayloadHeader, body block.BeaconBlockBody) (bool, error) {
-	if h == nil || body == nil {
-		return false, errors.New("nil header or block body")
+// 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_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
 	}
+	if mergeComplete {
+		return false, err
+	}
+
+	return ExecutionBlock(body)
+}
+
+// IsMergeTransitionBlockUsingPayloadHeader returns true if the input block is the terminal merge block.
+// Terminal merge block must be associated with an empty payload header.
+// This is an optimized version of MergeTransitionComplete where beacon state is not required as an argument.
+func IsMergeTransitionBlockUsingPayloadHeader(h *ethpb.ExecutionPayloadHeader, body block.BeaconBlockBody) (bool, error) {
 	if !isEmptyHeader(h) {
 		return false, nil
 	}
-	return IsExecutionBlock(body)
+	return ExecutionBlock(body)
 }
 
-// IsExecutionBlock returns whether the block has a non-empty ExecutionPayload.
+// 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 IsExecutionBlock(body block.BeaconBlockBody) (bool, error) {
-	if body == nil {
-		return false, errors.New("nil block body")
-	}
+func ExecutionBlock(body block.BeaconBlockBody) (bool, error) {
 	payload, err := body.ExecutionPayload()
-	switch {
-	case errors.Is(err, wrapper.ErrUnsupportedField):
-		return false, nil
-	case err != nil:
+	if err != nil {
+		if strings.HasPrefix(err.Error(), "ExecutionPayload is not supported in") {
+			return false, nil
+		}
 		return false, err
-	default:
 	}
 	return !isEmptyPayload(payload), nil
 }
 
-// IsExecutionEnabled returns true if the beacon chain can begin executing.
+// ExecutionEnabled returns true if the beacon chain can begin executing.
 // Meaning the payload header is beacon state is non-empty or the payload in block body is non-empty.
 //
 // Spec code:
 // def is_execution_enabled(state: BeaconState, body: BeaconBlockBody) -> bool:
 //    return is_merge_block(state, body) or is_merge_complete(state)
-func IsExecutionEnabled(st state.BeaconState, body block.BeaconBlockBody) (bool, error) {
-	if st == nil || body == nil {
-		return false, errors.New("nil state or block body")
-	}
-	if IsPreBellatrixVersion(st.Version()) {
-		return false, nil
-	}
-	header, err := st.LatestExecutionPayloadHeader()
+func ExecutionEnabled(st state.BeaconState, body block.BeaconBlockBody) (bool, error) {
+	mergeBlock, err := MergeTransitionBlock(st, body)
 	if err != nil {
 		return false, err
 	}
-	return IsExecutionEnabledUsingHeader(header, body)
-}
-
-// IsExecutionEnabledUsingHeader returns true if the execution is enabled using post processed payload header and block body.
-// This is an optimized version of IsExecutionEnabled where beacon state is not required as an argument.
-func IsExecutionEnabledUsingHeader(header *ethpb.ExecutionPayloadHeader, body block.BeaconBlockBody) (bool, error) {
-	if !isEmptyHeader(header) {
+	if mergeBlock {
 		return true, nil
 	}
-	return IsExecutionBlock(body)
-}
-
-// IsPreBellatrixVersion returns true if input version is before bellatrix fork.
-func IsPreBellatrixVersion(v int) bool {
-	return v < version.Bellatrix
+	return MergeTransitionComplete(st)
 }
 
 // ValidatePayloadWhenMergeCompletes validates if payload is valid versus input beacon state.
@@ -113,7 +104,7 @@ func IsPreBellatrixVersion(v int) bool {
 //    if is_merge_complete(state):
 //        assert payload.parent_hash == state.latest_execution_payload_header.block_hash
 func ValidatePayloadWhenMergeCompletes(st state.BeaconState, payload *enginev1.ExecutionPayload) error {
-	complete, err := IsMergeTransitionComplete(st)
+	complete, err := MergeTransitionComplete(st)
 	if err != nil {
 		return err
 	}
@@ -235,9 +226,6 @@ func PayloadToHeader(payload *enginev1.ExecutionPayload) (*ethpb.ExecutionPayloa
 }
 
 func isEmptyPayload(p *enginev1.ExecutionPayload) bool {
-	if p == nil {
-		return true
-	}
 	if !bytes.Equal(p.ParentHash, make([]byte, fieldparams.RootLength)) {
 		return false
 	}

beacon-chain/core/blocks/payload_test.go

@@ -18,7 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
-func Test_IsMergeComplete(t *testing.T) {
+func Test_MergeComplete(t *testing.T) {
 	tests := []struct {
 		name    string
 		payload *ethpb.ExecutionPayloadHeader
@@ -160,7 +160,7 @@ func Test_IsMergeComplete(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.payload))
-			got, err := blocks.IsMergeTransitionComplete(st)
+			got, err := blocks.MergeTransitionComplete(st)
 			require.NoError(t, err)
 			if got != tt.want {
 				t.Errorf("mergeComplete() got = %v, want %v", got, tt.want)
@@ -169,6 +169,187 @@ func Test_IsMergeComplete(t *testing.T) {
 	}
 }
 
+func Test_MergeBlock(t *testing.T) {
+	tests := []struct {
+		name    string
+		payload *enginev1.ExecutionPayload
+		header  *ethpb.ExecutionPayloadHeader
+		want    bool
+	}{
+		{
+			name:    "empty header, empty payload",
+			payload: emptyPayload(),
+			header:  emptyPayloadHeader(),
+			want:    false,
+		},
+		{
+			name:    "non-empty header, empty payload",
+			payload: emptyPayload(),
+			header: func() *ethpb.ExecutionPayloadHeader {
+				h := emptyPayloadHeader()
+				h.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return h
+			}(),
+			want: false,
+		},
+		{
+			name: "empty header, payload has parent hash",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has fee recipient",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.FeeRecipient = bytesutil.PadTo([]byte{'a'}, fieldparams.FeeRecipientLength)
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has state root",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.StateRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has receipt root",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.ReceiptsRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has logs bloom",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.LogsBloom = bytesutil.PadTo([]byte{'a'}, fieldparams.LogsBloomLength)
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has random",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.PrevRandao = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has base fee",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.BaseFeePerGas = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has block hash",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.BlockHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has tx",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.Transactions = [][]byte{{'a'}}
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has extra data",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.ExtraData = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has block number",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.BlockNumber = 1
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has gas limit",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.GasLimit = 1
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has gas used",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.GasUsed = 1
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+		{
+			name: "empty header, payload has timestamp",
+			payload: func() *enginev1.ExecutionPayload {
+				p := emptyPayload()
+				p.Timestamp = 1
+				return p
+			}(),
+			header: emptyPayloadHeader(),
+			want:   true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
+			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.header))
+			blk := util.NewBeaconBlockBellatrix()
+			blk.Block.Body.ExecutionPayload = tt.payload
+			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
+			require.NoError(t, err)
+			got, err := blocks.MergeTransitionBlock(st, body)
+			require.NoError(t, err)
+			if got != tt.want {
+				t.Errorf("MergeTransitionBlock() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
 func Test_IsMergeTransitionBlockUsingPayloadHeader(t *testing.T) {
 	tests := []struct {
 		name    string
@@ -339,7 +520,7 @@ func Test_IsMergeTransitionBlockUsingPayloadHeader(t *testing.T) {
 			blk.Block.Body.ExecutionPayload = tt.payload
 			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
-			got, err := blocks.IsMergeTransitionBlockUsingPreStatePayloadHeader(tt.header, body)
+			got, err := blocks.IsMergeTransitionBlockUsingPayloadHeader(tt.header, body)
 			require.NoError(t, err)
 			if got != tt.want {
 				t.Errorf("MergeTransitionBlock() got = %v, want %v", got, tt.want)
@@ -375,90 +556,14 @@ func Test_IsExecutionBlock(t *testing.T) {
 			blk.Block.Body.ExecutionPayload = tt.payload
 			wrappedBlock, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
 			require.NoError(t, err)
-			got, err := blocks.IsExecutionBlock(wrappedBlock.Body())
+			got, err := blocks.ExecutionBlock(wrappedBlock.Body())
 			require.NoError(t, err)
 			require.Equal(t, tt.want, got)
 		})
 	}
 }
 
-func Test_IsExecutionEnabled(t *testing.T) {
-	tests := []struct {
-		name        string
-		payload     *enginev1.ExecutionPayload
-		header      *ethpb.ExecutionPayloadHeader
-		useAltairSt bool
-		want        bool
-	}{
-		{
-			name:        "use older than bellatrix state",
-			payload:     emptyPayload(),
-			header:      emptyPayloadHeader(),
-			useAltairSt: true,
-			want:        false,
-		},
-		{
-			name:    "empty header, empty payload",
-			payload: emptyPayload(),
-			header:  emptyPayloadHeader(),
-			want:    false,
-		},
-		{
-			name:    "non-empty header, empty payload",
-			payload: emptyPayload(),
-			header: func() *ethpb.ExecutionPayloadHeader {
-				h := emptyPayloadHeader()
-				h.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return h
-			}(),
-			want: true,
-		},
-		{
-			name:   "empty header, non-empty payload",
-			header: emptyPayloadHeader(),
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.Timestamp = 1
-				return p
-			}(),
-			want: true,
-		},
-		{
-			name: "non-empty header, non-empty payload",
-			header: func() *ethpb.ExecutionPayloadHeader {
-				h := emptyPayloadHeader()
-				h.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
-				return h
-			}(),
-			payload: func() *enginev1.ExecutionPayload {
-				p := emptyPayload()
-				p.Timestamp = 1
-				return p
-			}(),
-			want: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
-			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.header))
-			blk := util.NewBeaconBlockBellatrix()
-			blk.Block.Body.ExecutionPayload = tt.payload
-			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
-			require.NoError(t, err)
-			if tt.useAltairSt {
-				st, _ = util.DeterministicGenesisStateAltair(t, 1)
-			}
-			got, err := blocks.IsExecutionEnabled(st, body)
-			require.NoError(t, err)
-			if got != tt.want {
-				t.Errorf("IsExecutionEnabled() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_IsExecutionEnabledUsingHeader(t *testing.T) {
+func Test_ExecutionEnabled(t *testing.T) {
 	tests := []struct {
 		name    string
 		payload *enginev1.ExecutionPayload
@@ -508,14 +613,16 @@ func Test_IsExecutionEnabledUsingHeader(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
+			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.header))
 			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
 			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
-			got, err := blocks.IsExecutionEnabledUsingHeader(tt.header, body)
+			got, err := blocks.ExecutionEnabled(st, body)
 			require.NoError(t, err)
 			if got != tt.want {
-				t.Errorf("IsExecutionEnabled() got = %v, want %v", got, tt.want)
+				t.Errorf("ExecutionEnabled() got = %v, want %v", got, tt.want)
 			}
 		})
 	}
@@ -723,7 +830,7 @@ func BenchmarkBellatrixComplete(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_, err := blocks.IsMergeTransitionComplete(st)
+		_, err := blocks.MergeTransitionComplete(st)
 		require.NoError(b, err)
 	}
 }

beacon-chain/core/blocks/randao_test.go

@@ -40,9 +40,7 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	}
 
 	want := "block randao: signature did not verify"
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = blocks.ProcessRandao(context.Background(), beaconState, wsb)
+	_, err = blocks.ProcessRandao(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -59,12 +57,11 @@ func TestProcessRandao_SignatureVerifiesAndUpdatesLatestStateMixes(t *testing.T)
 			RandaoReveal: epochSignature,
 		},
 	}
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
+
 	newState, err := blocks.ProcessRandao(
 		context.Background(),
 		beaconState,
-		wsb,
+		wrapper.WrappedPhase0SignedBeaconBlock(b),
 	)
 	require.NoError(t, err, "Unexpected error processing block randao")
 	currentEpoch := time.CurrentEpoch(beaconState)

beacon-chain/core/blocks/signature_test.go

@@ -83,7 +83,7 @@ func TestVerifyBlockSignatureUsingCurrentFork(t *testing.T) {
 	assert.NoError(t, err)
 	sig := keys[0].Sign(rt[:]).Marshal()
 	altairBlk.Signature = sig
-	wsb, err := wrapper.WrappedSignedBeaconBlock(altairBlk)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(altairBlk)
 	require.NoError(t, err)
 	assert.NoError(t, blocks.VerifyBlockSignatureUsingCurrentFork(bState, wsb))
 }

beacon-chain/core/feed/block/events.go

@@ -13,6 +13,5 @@ const (
 
 // ReceivedBlockData is the data sent with ReceivedBlock events.
 type ReceivedBlockData struct {
-	SignedBlock  block.SignedBeaconBlock
-	IsOptimistic bool
+	SignedBlock block.SignedBeaconBlock
 }

beacon-chain/core/helpers/BUILD.bazel

@@ -15,12 +15,29 @@ go_library(
         "weak_subjectivity.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/helpers",
-    visibility = ["//visibility:public"],
+    visibility = [
+        "//beacon-chain:__subpackages__",
+        "//cmd/beacon-chain:__subpackages__",
+        "//contracts/deposit:__pkg__",
+        "//crypto/keystore:__pkg__",
+        "//network/forks:__pkg__",
+        "//proto/prysm/v1alpha1:__subpackages__",
+        "//proto/prysm/v1alpha1/attestation:__pkg__",
+        "//runtime/interop:__pkg__",
+        "//slasher:__subpackages__",
+        "//testing/altair:__pkg__",
+        "//testing/benchmark/benchmark_files:__subpackages__",
+        "//testing/endtoend/evaluators:__pkg__",
+        "//testing/slasher/simulator:__pkg__",
+        "//testing/spectest:__subpackages__",
+        "//testing/util:__pkg__",
+        "//tools:__subpackages__",
+        "//validator:__subpackages__",
+    ],
     deps = [
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//container/slice:go_default_library",
         "//container/trie:go_default_library",

beacon-chain/core/helpers/beacon_committee.go

@@ -28,14 +28,6 @@ var (
 	proposerIndicesCache = cache.NewProposerIndicesCache()
 )
 
-func EnableComCache() {
-	committeeCache.Enable()
-}
-
-func DisableComCache() {
-	committeeCache.Disable()
-}
-
 // SlotCommitteeCount returns the number of beacon committees of a slot. The
 // active validator count is provided as an argument rather than an imported implementation
 // from the spec definition. Having the active validator count as an argument allows for

beacon-chain/core/helpers/weak_subjectivity.go

@@ -1,6 +1,7 @@
 package helpers
 
 import (
+	"bytes"
 	"context"
 	"encoding/hex"
 	"errors"
@@ -11,11 +12,9 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/math"
-	v1alpha1 "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
@@ -55,9 +54,9 @@ import (
 //        )
 //
 //    return ws_period
-func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconState, cfg *params.BeaconChainConfig) (types.Epoch, error) {
+func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconState) (types.Epoch, error) {
 	// Weak subjectivity period cannot be smaller than withdrawal delay.
-	wsp := uint64(cfg.MinValidatorWithdrawabilityDelay)
+	wsp := uint64(params.BeaconConfig().MinValidatorWithdrawabilityDelay)
 
 	// Cardinality of active validator set.
 	N, err := ActiveValidatorCount(ctx, st, time.CurrentEpoch(st))
@@ -73,10 +72,10 @@ func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconS
 	if err != nil {
 		return 0, fmt.Errorf("cannot find total active balance of validators: %w", err)
 	}
-	t = t / N / cfg.GweiPerEth
+	t = t / N / params.BeaconConfig().GweiPerEth
 
 	// Maximum effective balance per validator.
-	T := cfg.MaxEffectiveBalance / cfg.GweiPerEth
+	T := params.BeaconConfig().MaxEffectiveBalance / params.BeaconConfig().GweiPerEth
 
 	// Validator churn limit.
 	delta, err := ValidatorChurnLimit(N)
@@ -85,14 +84,14 @@ func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconS
 	}
 
 	// Balance top-ups.
-	Delta := uint64(cfg.SlotsPerEpoch.Mul(cfg.MaxDeposits))
+	Delta := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().MaxDeposits))
 
 	if delta == 0 || Delta == 0 {
 		return 0, errors.New("either validator churn limit or balance top-ups is zero")
 	}
 
 	// Safety decay, maximum tolerable loss of safety margin of FFG finality.
-	D := cfg.SafetyDecay
+	D := params.BeaconConfig().SafetyDecay
 
 	if T*(200+3*D) < t*(200+12*D) {
 		epochsForValidatorSetChurn := N * (t*(200+12*D) - T*(200+3*D)) / (600 * delta * (2*t + T))
@@ -123,24 +122,24 @@ func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconS
 //    current_epoch = compute_epoch_at_slot(get_current_slot(store))
 //    return current_epoch <= ws_state_epoch + ws_period
 func IsWithinWeakSubjectivityPeriod(
-	ctx context.Context, currentEpoch types.Epoch, wsState state.ReadOnlyBeaconState, wsStateRoot [fieldparams.RootLength]byte, wsEpoch types.Epoch, cfg *params.BeaconChainConfig) (bool, error) {
+	ctx context.Context, currentEpoch types.Epoch, wsState state.ReadOnlyBeaconState, wsCheckpoint *eth.WeakSubjectivityCheckpoint) (bool, error) {
 	// Make sure that incoming objects are not nil.
-	if wsState == nil || wsState.IsNil() || wsState.LatestBlockHeader() == nil {
+	if wsState == nil || wsState.IsNil() || wsState.LatestBlockHeader() == nil || wsCheckpoint == nil {
 		return false, errors.New("invalid weak subjectivity state or checkpoint")
 	}
 
 	// Assert that state and checkpoint have the same root and epoch.
-	if bytesutil.ToBytes32(wsState.LatestBlockHeader().StateRoot) != wsStateRoot {
+	if !bytes.Equal(wsState.LatestBlockHeader().StateRoot, wsCheckpoint.StateRoot) {
 		return false, fmt.Errorf("state (%#x) and checkpoint (%#x) roots do not match",
-			wsState.LatestBlockHeader().StateRoot, wsStateRoot)
+			wsState.LatestBlockHeader().StateRoot, wsCheckpoint.StateRoot)
 	}
-	if slots.ToEpoch(wsState.Slot()) != wsEpoch {
+	if slots.ToEpoch(wsState.Slot()) != wsCheckpoint.Epoch {
 		return false, fmt.Errorf("state (%v) and checkpoint (%v) epochs do not match",
-			slots.ToEpoch(wsState.Slot()), wsEpoch)
+			slots.ToEpoch(wsState.Slot()), wsCheckpoint.Epoch)
 	}
 
 	// Compare given epoch to state epoch + weak subjectivity period.
-	wsPeriod, err := ComputeWeakSubjectivityPeriod(ctx, wsState, cfg)
+	wsPeriod, err := ComputeWeakSubjectivityPeriod(ctx, wsState)
 	if err != nil {
 		return false, fmt.Errorf("cannot compute weak subjectivity period: %w", err)
 	}
@@ -154,8 +153,8 @@ func IsWithinWeakSubjectivityPeriod(
 // Within the weak subjectivity period, if two conflicting blocks are finalized, 1/3 - D (D := safety decay)
 // of validators will get slashed. Therefore, it is safe to assume that any finalized checkpoint within that
 // period is protected by this safety margin.
-func LatestWeakSubjectivityEpoch(ctx context.Context, st state.ReadOnlyBeaconState, cfg *params.BeaconChainConfig) (types.Epoch, error) {
-	wsPeriod, err := ComputeWeakSubjectivityPeriod(ctx, st, cfg)
+func LatestWeakSubjectivityEpoch(ctx context.Context, st state.ReadOnlyBeaconState) (types.Epoch, error) {
+	wsPeriod, err := ComputeWeakSubjectivityPeriod(ctx, st)
 	if err != nil {
 		return 0, err
 	}
@@ -165,7 +164,7 @@ func LatestWeakSubjectivityEpoch(ctx context.Context, st state.ReadOnlyBeaconSta
 }
 
 // ParseWeakSubjectivityInputString parses "blocks_root:epoch_number" string into a checkpoint.
-func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Checkpoint, error) {
+func ParseWeakSubjectivityInputString(wsCheckpointString string) (*eth.Checkpoint, error) {
 	if wsCheckpointString == "" {
 		return nil, nil
 	}
@@ -198,7 +197,7 @@ func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Chec
 		return nil, err
 	}
 
-	return &v1alpha1.Checkpoint{
+	return &eth.Checkpoint{
 		Epoch: types.Epoch(epoch),
 		Root:  bRoot,
 	}, nil

beacon-chain/core/helpers/weak_subjectivity_test.go

@@ -48,21 +48,18 @@ func TestWeakSubjectivity_ComputeWeakSubjectivityPeriod(t *testing.T) {
 		t.Run(fmt.Sprintf("valCount: %d, avgBalance: %d", tt.valCount, tt.avgBalance), func(t *testing.T) {
 			// Reset committee cache - as we need to recalculate active validator set for each test.
 			helpers.ClearCache()
-			got, err := helpers.ComputeWeakSubjectivityPeriod(context.Background(), genState(t, tt.valCount, tt.avgBalance), params.BeaconConfig())
+			got, err := helpers.ComputeWeakSubjectivityPeriod(context.Background(), genState(t, tt.valCount, tt.avgBalance))
 			require.NoError(t, err)
 			assert.Equal(t, tt.want, got, "valCount: %v, avgBalance: %v", tt.valCount, tt.avgBalance)
 		})
 	}
 }
-
-type mockWsCheckpoint func() (stateRoot [32]byte, blockRoot [32]byte, e types.Epoch)
-
 func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 	tests := []struct {
 		name            string
 		epoch           types.Epoch
 		genWsState      func() state.ReadOnlyBeaconState
-		genWsCheckpoint mockWsCheckpoint
+		genWsCheckpoint func() *ethpb.WeakSubjectivityCheckpoint
 		want            bool
 		wantedErr       string
 	}{
@@ -71,8 +68,22 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 			genWsState: func() state.ReadOnlyBeaconState {
 				return nil
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				return [32]byte{}, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					BlockRoot: make([]byte, 32),
+					StateRoot: make([]byte, 32),
+					Epoch:     42,
+				}
+			},
+			wantedErr: "invalid weak subjectivity state or checkpoint",
+		},
+		{
+			name: "nil weak subjectivity checkpoint",
+			genWsState: func() state.ReadOnlyBeaconState {
+				return genState(t, 128, 32)
+			},
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return nil
 			},
 			wantedErr: "invalid weak subjectivity state or checkpoint",
 		},
@@ -88,10 +99,11 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot2"), 32))
-				return sr, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot2"), 32),
+					Epoch:     42,
+				}
 			},
 			wantedErr: fmt.Sprintf("state (%#x) and checkpoint (%#x) roots do not match",
 				bytesutil.PadTo([]byte("stateroot1"), 32), bytesutil.PadTo([]byte("stateroot2"), 32)),
@@ -108,10 +120,11 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot"), 32))
-				return sr, [32]byte{}, 43
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot"), 32),
+					Epoch:     43,
+				}
 			},
 			wantedErr: "state (42) and checkpoint (43) epochs do not match",
 		},
@@ -127,10 +140,11 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot"), 32))
-				return sr, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot"), 32),
+					Epoch:     42,
+				}
 			},
 			wantedErr: "cannot compute weak subjectivity period: no active validators found",
 		},
@@ -147,10 +161,11 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot"), 32))
-				return sr, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot"), 32),
+					Epoch:     42,
+				}
 			},
 			want: false,
 		},
@@ -167,18 +182,18 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 				require.NoError(t, err)
 				return beaconState
 			},
-			genWsCheckpoint: func() ([32]byte, [32]byte, types.Epoch) {
-				var sr [32]byte
-				copy(sr[:], bytesutil.PadTo([]byte("stateroot"), 32))
-				return sr, [32]byte{}, 42
+			genWsCheckpoint: func() *ethpb.WeakSubjectivityCheckpoint {
+				return &ethpb.WeakSubjectivityCheckpoint{
+					StateRoot: bytesutil.PadTo([]byte("stateroot"), 32),
+					Epoch:     42,
+				}
 			},
 			want: true,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			sr, _, e := tt.genWsCheckpoint()
-			got, err := helpers.IsWithinWeakSubjectivityPeriod(context.Background(), tt.epoch, tt.genWsState(), sr, e, params.BeaconConfig())
+			got, err := helpers.IsWithinWeakSubjectivityPeriod(context.Background(), tt.epoch, tt.genWsState(), tt.genWsCheckpoint())
 			if tt.wantedErr != "" {
 				assert.Equal(t, false, got)
 				assert.ErrorContains(t, tt.wantedErr, err)

beacon-chain/core/time/BUILD.bazel

@@ -17,15 +17,13 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = ["slot_epoch_test.go"],
+    embed = [":go_default_library"],
     deps = [
-        ":go_default_library",
-        "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//config/params:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",
     ],

beacon-chain/core/time/slot_epoch.go

@@ -46,9 +46,9 @@ func NextEpoch(state state.ReadOnlyBeaconState) types.Epoch {
 	return slots.ToEpoch(state.Slot()) + 1
 }
 
-// HigherEqualThanAltairVersionAndEpoch returns if the input state `s` has a higher version number than Altair state and input epoch `e` is higher equal than fork epoch.
-func HigherEqualThanAltairVersionAndEpoch(s state.BeaconState, e types.Epoch) bool {
-	return s.Version() >= version.Altair && e >= params.BeaconConfig().AltairForkEpoch
+// AltairCompatible returns if the input state `s` is altair compatible and input epoch `e` is higher equal than fork epoch.
+func AltairCompatible(s state.BeaconState, e types.Epoch) bool {
+	return s.Version() == version.Altair && e >= params.BeaconConfig().AltairForkEpoch
 }
 
 // CanUpgradeToAltair returns true if the input `slot` can upgrade to Altair.

beacon-chain/core/time/slot_epoch_test.go

@@ -1,17 +1,14 @@
-package time_test
+package time
 
 import (
 	"testing"
 
 	types "github.com/prysmaticlabs/eth2-types"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
 	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
@@ -45,7 +42,7 @@ func TestCurrentEpoch_OK(t *testing.T) {
 	for _, tt := range tests {
 		state, err := v1.InitializeFromProto(&eth.BeaconState{Slot: tt.slot})
 		require.NoError(t, err)
-		assert.Equal(t, tt.epoch, time.CurrentEpoch(state), "ActiveCurrentEpoch(%d)", state.Slot())
+		assert.Equal(t, tt.epoch, CurrentEpoch(state), "ActiveCurrentEpoch(%d)", state.Slot())
 	}
 }
 
@@ -61,7 +58,7 @@ func TestPrevEpoch_OK(t *testing.T) {
 	for _, tt := range tests {
 		state, err := v1.InitializeFromProto(&eth.BeaconState{Slot: tt.slot})
 		require.NoError(t, err)
-		assert.Equal(t, tt.epoch, time.PrevEpoch(state), "ActivePrevEpoch(%d)", state.Slot())
+		assert.Equal(t, tt.epoch, PrevEpoch(state), "ActivePrevEpoch(%d)", state.Slot())
 	}
 }
 
@@ -79,7 +76,7 @@ func TestNextEpoch_OK(t *testing.T) {
 	for _, tt := range tests {
 		state, err := v1.InitializeFromProto(&eth.BeaconState{Slot: tt.slot})
 		require.NoError(t, err)
-		assert.Equal(t, tt.epoch, time.NextEpoch(state), "NextEpoch(%d)", state.Slot())
+		assert.Equal(t, tt.epoch, NextEpoch(state), "NextEpoch(%d)", state.Slot())
 	}
 }
 
@@ -111,7 +108,7 @@ func TestCanUpgradeToAltair(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := time.CanUpgradeToAltair(tt.slot); got != tt.want {
+			if got := CanUpgradeToAltair(tt.slot); got != tt.want {
 				t.Errorf("canUpgradeToAltair() = %v, want %v", got, tt.want)
 			}
 		})
@@ -146,7 +143,7 @@ func TestCanUpgradeBellatrix(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := time.CanUpgradeToBellatrix(tt.slot); got != tt.want {
+			if got := CanUpgradeToBellatrix(tt.slot); got != tt.want {
 				t.Errorf("CanUpgradeToBellatrix() = %v, want %v", got, tt.want)
 			}
 		})
@@ -181,85 +178,6 @@ func TestCanProcessEpoch_TrueOnEpochsLastSlot(t *testing.T) {
 		b := &eth.BeaconState{Slot: tt.slot}
 		s, err := v1.InitializeFromProto(b)
 		require.NoError(t, err)
-		assert.Equal(t, tt.canProcessEpoch, time.CanProcessEpoch(s), "CanProcessEpoch(%d)", tt.slot)
-	}
-}
-
-func TestAltairCompatible(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.AltairForkEpoch = 1
-	cfg.BellatrixForkEpoch = 2
-	params.OverrideBeaconConfig(cfg)
-
-	type args struct {
-		s state.BeaconState
-		e types.Epoch
-	}
-	tests := []struct {
-		name string
-		args args
-		want bool
-	}{
-		{
-			name: "phase0 state",
-			args: args{
-				s: func() state.BeaconState {
-					st, _ := util.DeterministicGenesisState(t, 1)
-					return st
-				}(),
-			},
-			want: false,
-		},
-		{
-			name: "altair state, altair epoch",
-			args: args{
-				s: func() state.BeaconState {
-					st, _ := util.DeterministicGenesisStateAltair(t, 1)
-					return st
-				}(),
-				e: params.BeaconConfig().AltairForkEpoch,
-			},
-			want: true,
-		},
-		{
-			name: "bellatrix state, bellatrix epoch",
-			args: args{
-				s: func() state.BeaconState {
-					st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
-					return st
-				}(),
-				e: params.BeaconConfig().BellatrixForkEpoch,
-			},
-			want: true,
-		},
-		{
-			name: "bellatrix state, altair epoch",
-			args: args{
-				s: func() state.BeaconState {
-					st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
-					return st
-				}(),
-				e: params.BeaconConfig().AltairForkEpoch,
-			},
-			want: true,
-		},
-		{
-			name: "bellatrix state, phase0 epoch",
-			args: args{
-				s: func() state.BeaconState {
-					st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
-					return st
-				}(),
-			},
-			want: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := time.HigherEqualThanAltairVersionAndEpoch(tt.args.s, tt.args.e); got != tt.want {
-				t.Errorf("HigherEqualThanAltairVersionAndEpoch() = %v, want %v", got, tt.want)
-			}
-		})
+		assert.Equal(t, tt.canProcessEpoch, CanProcessEpoch(s), "CanProcessEpoch(%d)", tt.slot)
 	}
 }

beacon-chain/core/transition/altair_transition_no_verify_sig_test.go

@@ -90,7 +90,7 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 		SyncCommitteeSignature: aggregatedSig,
 	}
 	block.Block.Body.SyncAggregate = syncAggregate
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
 	require.NoError(t, err)
 	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -101,7 +101,7 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedAltairSignedBeaconBlock(block)
 	require.NoError(t, err)
 	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -178,7 +178,7 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
 	}
 	block.Block.Body.SyncAggregate = syncAggregate
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
 	require.NoError(t, err)
 	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -190,7 +190,7 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
 	block.Signature = sig.Marshal()
 
 	block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedAltairSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "could not validate state root", err)
@@ -198,7 +198,7 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
 
 func TestExecuteStateTransitionNoVerifyAnySig_PassesProcessingConditions(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
 	require.NoError(t, err)
 	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)

beacon-chain/core/transition/bellatrix_transition_no_verify_sig_test.go

@@ -92,7 +92,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 		SyncCommitteeSignature: aggregatedSig,
 	}
 	block.Block.Body.SyncAggregate = syncAggregate
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block)
 	require.NoError(t, err)
 	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -103,7 +103,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedBellatrixSignedBeaconBlock(block)
 	require.NoError(t, err)
 	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -180,7 +180,7 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	}
 	block.Block.Body.SyncAggregate = syncAggregate
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block)
 	require.NoError(t, err)
 	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -192,7 +192,7 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	block.Signature = sig.Marshal()
 
 	block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(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)
@@ -245,7 +245,7 @@ func createFullBellatrixBlockWithOperations(t *testing.T) (state.BeaconState,
 					ReceiptsRoot:  make([]byte, fieldparams.RootLength),
 					LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
 					PrevRandao:    make([]byte, fieldparams.RootLength),
-					BaseFeePerGas: bytesutil.PadTo([]byte{1, 2, 3, 4}, fieldparams.RootLength),
+					BaseFeePerGas: make([]byte, fieldparams.RootLength),
 					BlockHash:     make([]byte, fieldparams.RootLength),
 					Transactions:  make([][]byte, 0),
 					ExtraData:     make([]byte, 0),

beacon-chain/core/transition/benchmarks_test.go

@@ -29,9 +29,7 @@ func BenchmarkExecuteStateTransition_FullBlock(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-		require.NoError(b, err)
-		_, err = coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wsb)
+		_, err := coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wrapper.WrappedPhase0SignedBeaconBlock(block))
 		require.NoError(b, err)
 	}
 }
@@ -52,16 +50,12 @@ func BenchmarkExecuteStateTransition_WithCache(b *testing.B) {
 	require.NoError(b, helpers.UpdateCommitteeCache(beaconState, time.CurrentEpoch(beaconState)))
 	require.NoError(b, beaconState.SetSlot(currentSlot))
 	// Run the state transition once to populate the cache.
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(b, err)
-	_, err = coreState.ExecuteStateTransition(context.Background(), beaconState, wsb)
+	_, err = coreState.ExecuteStateTransition(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.NoError(b, err, "Failed to process block, benchmarks will fail")
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-		require.NoError(b, err)
-		_, err = coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wsb)
+		_, err := coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wrapper.WrappedPhase0SignedBeaconBlock(block))
 		require.NoError(b, err, "Failed to process block, benchmarks will fail")
 	}
 }

beacon-chain/core/transition/skip_slot_cache.go

@@ -8,7 +8,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	"github.com/sirupsen/logrus"
 )
 
 // SkipSlotCache exists for the unlikely scenario that is a large gap between the head state and
@@ -29,6 +28,5 @@ func cacheKey(_ context.Context, state state.ReadOnlyBeaconState) ([32]byte, err
 	if err != nil {
 		return [32]byte{}, err
 	}
-	logrus.Infof("checking with cache key of slot %d and root %#x", state.Slot(), r)
 	return hash.Hash(append(bytesutil.Bytes32(uint64(state.Slot())), r[:]...)), nil
 }

beacon-chain/core/transition/skip_slot_cache_test.go

@@ -32,14 +32,10 @@ func TestSkipSlotCache_OK(t *testing.T) {
 	// with the state
 	blk, err := util.GenerateFullBlock(bState, privs, blkCfg, originalState.Slot()+10)
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wsb)
+	executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wrapper.WrappedPhase0SignedBeaconBlock(blk))
 	require.NoError(t, err, "Could not run state transition")
 	require.Equal(t, true, executedState.Version() == version.Phase0)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	bState, err = transition.ExecuteStateTransition(context.Background(), bState, wsb)
+	bState, err = transition.ExecuteStateTransition(context.Background(), bState, wrapper.WrappedPhase0SignedBeaconBlock(blk))
 	require.NoError(t, err, "Could not process state transition")
 
 	assert.DeepEqual(t, originalState.CloneInnerState(), bState.CloneInnerState(), "Skipped slots cache leads to different states")
@@ -61,9 +57,7 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 	// with the state
 	blk, err := util.GenerateFullBlock(bState, privs, blkCfg, originalState.Slot()+10)
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wsb)
+	executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wrapper.WrappedPhase0SignedBeaconBlock(blk))
 	require.NoError(t, err, "Could not run state transition")
 	require.Equal(t, true, executedState.Version() == version.Phase0)
 
@@ -76,9 +70,7 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 		signature, err := util.BlockSignature(originalState, blk.Block, privs)
 		require.NoError(t, err)
 		blk.Signature = signature.Marshal()
-		wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-		require.NoError(t, err)
-		s1, err = transition.ExecuteStateTransition(context.Background(), originalState.Copy(), wsb)
+		s1, err = transition.ExecuteStateTransition(context.Background(), originalState.Copy(), wrapper.WrappedPhase0SignedBeaconBlock(blk))
 		require.NoError(t, err, "Could not run state transition")
 	}
 
@@ -89,9 +81,7 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 		signature, err := util.BlockSignature(originalState, blk.Block, privs)
 		require.NoError(t, err)
 		blk.Signature = signature.Marshal()
-		wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-		require.NoError(t, err)
-		s0, err = transition.ExecuteStateTransition(context.Background(), originalState.Copy(), wsb)
+		s0, err = transition.ExecuteStateTransition(context.Background(), originalState.Copy(), wrapper.WrappedPhase0SignedBeaconBlock(blk))
 		require.NoError(t, err, "Could not run state transition")
 	}
 

beacon-chain/core/transition/transition.go

@@ -211,7 +211,7 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot types.Slot)
 		return nil, err
 	}
 
-	if cachedState != nil && !cachedState.IsNil() && cachedState.Slot() <= slot {
+	if cachedState != nil && !cachedState.IsNil() && cachedState.Slot() < slot {
 		highestSlot = cachedState.Slot()
 		state = cachedState
 	}
@@ -220,7 +220,7 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot types.Slot)
 		if err != nil {
 			return nil, err
 		}
-		if cachedState != nil && !cachedState.IsNil() && cachedState.Slot() <= slot {
+		if cachedState != nil && !cachedState.IsNil() && cachedState.Slot() < slot {
 			highestSlot = cachedState.Slot()
 			state = cachedState
 		}

beacon-chain/core/transition/transition_fuzz_test.go

@@ -25,9 +25,7 @@ func TestFuzzExecuteStateTransition_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(sb)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
-		require.NoError(t, err)
-		s, err := ExecuteStateTransition(ctx, state, wsb)
+		s, err := ExecuteStateTransition(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(sb))
 		if err != nil && s != nil {
 			t.Fatalf("state should be nil on err. found: %v on error: %v for state: %v and signed block: %v", s, err, state, sb)
 		}
@@ -46,9 +44,7 @@ func TestFuzzCalculateStateRoot_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(sb)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
-		require.NoError(t, err)
-		stateRoot, err := CalculateStateRoot(ctx, state, wsb)
+		stateRoot, err := CalculateStateRoot(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(sb))
 		if err != nil && stateRoot != [32]byte{} {
 			t.Fatalf("state root should be empty on err. found: %v on error: %v for signed block: %v", stateRoot, err, sb)
 		}
@@ -103,9 +99,7 @@ func TestFuzzprocessOperationsNoVerify_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(bb)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
-		require.NoError(t, err)
-		s, err := ProcessOperationsNoVerifyAttsSigs(ctx, state, wsb)
+		s, err := ProcessOperationsNoVerifyAttsSigs(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(bb))
 		if err != nil && s != nil {
 			t.Fatalf("state should be nil on err. found: %v on error: %v for block body: %v", s, err, bb)
 		}
@@ -123,9 +117,7 @@ func TestFuzzverifyOperationLengths_10000(t *testing.T) {
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(bb)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
-		require.NoError(t, err)
-		_, err = VerifyOperationLengths(context.Background(), state, wsb)
+		_, err := VerifyOperationLengths(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(bb))
 		_ = err
 	}
 }
@@ -172,9 +164,7 @@ func TestFuzzProcessBlockForStateRoot_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(sb)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
-		require.NoError(t, err)
-		s, err := ProcessBlockForStateRoot(ctx, state, wsb)
+		s, err := ProcessBlockForStateRoot(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(sb))
 		if err != nil && s != nil {
 			t.Fatalf("state should be nil on err. found: %v on error: %v for signed block: %v", s, err, sb)
 		}

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -285,18 +285,20 @@ func ProcessBlockForStateRoot(
 		return nil, errors.Wrap(err, "could not process block header")
 	}
 
-	enabled, err := b.IsExecutionEnabled(state, blk.Body())
-	if err != nil {
-		return nil, errors.Wrap(err, "could not check if execution is enabled")
-	}
-	if enabled {
-		payload, err := blk.Body().ExecutionPayload()
+	if state.Version() == version.Bellatrix {
+		enabled, err := b.ExecutionEnabled(state, blk.Body())
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "could not check if execution is enabled")
 		}
-		state, err = b.ProcessPayload(state, payload)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not process execution payload")
+		if enabled {
+			payload, err := blk.Body().ExecutionPayload()
+			if err != nil {
+				return nil, err
+			}
+			state, err = b.ProcessPayload(state, payload)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not process execution payload")
+			}
 		}
 	}
 

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -52,9 +52,7 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
 	block.Block.Body.RandaoReveal = randaoReveal
 	block.Block.Body.Eth1Data = eth1Data
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.NoError(t, err)
 
 	block.Block.StateRoot = stateRoot[:]
@@ -63,9 +61,7 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
+	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	assert.NoError(t, err)
 	verified, err := set.Verify()
 	assert.NoError(t, err)
@@ -108,9 +104,7 @@ func TestExecuteStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *test
 	block.Block.Body.RandaoReveal = randaoReveal
 	block.Block.Body.Eth1Data = eth1Data
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.NoError(t, err)
 
 	block.Block.StateRoot = stateRoot[:]
@@ -120,17 +114,13 @@ func TestExecuteStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *test
 	block.Signature = sig.Marshal()
 
 	block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
+	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.ErrorContains(t, "could not validate state root", err)
 }
 
 func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
 	beaconState, block, _, _, _ := createFullBlockWithOperations(t)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	set, _, err := transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb)
+	set, _, err := transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.NoError(t, err)
 	// Test Signature set verifies.
 	verified, err := set.Verify()
@@ -140,7 +130,7 @@ func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
 
 func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
 	require.NoError(t, err)
 	beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
 	require.NoError(t, err)
@@ -153,7 +143,7 @@ func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) {
 
 func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
 	require.NoError(t, err)
 	beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
 	require.NoError(t, err)
@@ -163,7 +153,7 @@ func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
 
 func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) {
 	beaconState, block := createFullBellatrixBlockWithOperations(t)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block)
 	require.NoError(t, err)
 	beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
 	require.NoError(t, err)
@@ -173,7 +163,7 @@ func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) {
 
 func TestCalculateStateRootAltair_OK(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
 	require.NoError(t, err)
 	r, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -183,7 +173,7 @@ func TestCalculateStateRootAltair_OK(t *testing.T) {
 func TestProcessBlockDifferentVersion(t *testing.T) {
 	beaconState, _ := util.DeterministicGenesisState(t, 64) // Phase 0 state
 	_, block := createFullAltairBlockWithOperations(t)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block) // Altair block
+	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) // Altair block
 	require.NoError(t, err)
 	_, _, err = transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "state and block are different version. 0 != 1", err)

beacon-chain/core/transition/transition_test.go

@@ -44,9 +44,7 @@ func TestExecuteStateTransition_IncorrectSlot(t *testing.T) {
 		},
 	}
 	want := "expected state.slot"
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
+	_, err = transition.ExecuteStateTransition(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -89,9 +87,7 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
 	block.Block.Body.RandaoReveal = randaoReveal
 	block.Block.Body.Eth1Data = eth1Data
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.NoError(t, err)
 
 	block.Block.StateRoot = stateRoot[:]
@@ -100,9 +96,7 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	beaconState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
+	beaconState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	require.NoError(t, err)
 
 	assert.Equal(t, params.BeaconConfig().SlotsPerEpoch, beaconState.Slot(), "Unexpected Slot number")
@@ -189,9 +183,7 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 	cp.Root = []byte("hello-world")
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cp))
 	require.NoError(t, beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{}))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
-	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), beaconState, wsb)
+	_, err = transition.VerifyOperationLengths(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
 	wanted := "number of voluntary exits (17) in block body exceeds allowed threshold of 16"
 	assert.ErrorContains(t, wanted, err)
 }
@@ -404,9 +396,7 @@ func TestProcessBlock_OverMaxProposerSlashings(t *testing.T) {
 		len(b.Block.Body.ProposerSlashings), params.BeaconConfig().MaxProposerSlashings)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -423,9 +413,7 @@ func TestProcessBlock_OverMaxAttesterSlashings(t *testing.T) {
 		len(b.Block.Body.AttesterSlashings), params.BeaconConfig().MaxAttesterSlashings)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -441,9 +429,7 @@ func TestProcessBlock_OverMaxAttestations(t *testing.T) {
 		len(b.Block.Body.Attestations), params.BeaconConfig().MaxAttestations)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -460,9 +446,7 @@ func TestProcessBlock_OverMaxVoluntaryExits(t *testing.T) {
 		len(b.Block.Body.VoluntaryExits), maxExits)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 
@@ -482,9 +466,7 @@ func TestProcessBlock_IncorrectDeposits(t *testing.T) {
 	}
 	want := fmt.Sprintf("incorrect outstanding deposits in block body, wanted: %d, got: %d",
 		s.Eth1Data().DepositCount-s.Eth1DepositIndex(), len(b.Block.Body.Deposits))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
 	assert.ErrorContains(t, want, err)
 }
 

beacon-chain/db/errors.go

@@ -13,9 +13,3 @@ var ErrNotFoundState = kv.ErrNotFoundState
 
 // ErrNotFoundOriginBlockRoot wraps ErrNotFound for an error specific to the origin block root.
 var ErrNotFoundOriginBlockRoot = kv.ErrNotFoundOriginBlockRoot
-
-// ErrNotFoundOriginBlockRoot wraps ErrNotFound for an error specific to the origin block root.
-var ErrNotFoundBackfillBlockRoot = kv.ErrNotFoundBackfillBlockRoot
-
-// ErrNotFoundGenesisBlockRoot means no genesis block root was found, indicating the db was not initialized with genesis
-var ErrNotFoundGenesisBlockRoot = kv.ErrNotFoundGenesisBlockRoot

beacon-chain/db/iface/interface.go

@@ -27,7 +27,6 @@ type ReadOnlyDatabase interface {
 	BlockRootsBySlot(ctx context.Context, slot types.Slot) (bool, [][32]byte, error)
 	HasBlock(ctx context.Context, blockRoot [32]byte) bool
 	GenesisBlock(ctx context.Context) (block.SignedBeaconBlock, error)
-	GenesisBlockRoot(ctx context.Context) ([32]byte, error)
 	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)
@@ -46,16 +45,14 @@ type ReadOnlyDatabase interface {
 	HasArchivedPoint(ctx context.Context, slot types.Slot) bool
 	LastArchivedRoot(ctx context.Context) [32]byte
 	LastArchivedSlot(ctx context.Context) (types.Slot, error)
-	LastValidatedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error)
 	// Deposit contract related handlers.
 	DepositContractAddress(ctx context.Context) ([]byte, error)
 	// Powchain operations.
 	PowchainData(ctx context.Context) (*ethpb.ETH1ChainData, error)
 	// Fee reicipients operations.
-	FeeRecipientByValidatorID(ctx context.Context, id types.ValidatorIndex) (common.Address, error)
+	FeeRecipientByValidatorID(ctx context.Context, id uint64) (common.Address, error)
 	// origin checkpoint sync support
-	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
-	BackfillBlockRoot(ctx context.Context) ([32]byte, error)
+	OriginBlockRoot(ctx context.Context) ([32]byte, error)
 }
 
 // NoHeadAccessDatabase defines a struct without access to chain head data.
@@ -77,7 +74,6 @@ type NoHeadAccessDatabase interface {
 	// Checkpoint operations.
 	SaveJustifiedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
 	SaveFinalizedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
-	SaveLastValidatedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
 	// Deposit contract related handlers.
 	SaveDepositContractAddress(ctx context.Context, addr common.Address) error
 	// Powchain operations.
@@ -85,7 +81,7 @@ type NoHeadAccessDatabase interface {
 	// Run any required database migrations.
 	RunMigrations(ctx context.Context) error
 	// Fee reicipients operations.
-	SaveFeeRecipientsByValidatorIDs(ctx context.Context, ids []types.ValidatorIndex, addrs []common.Address) error
+	SaveFeeRecipientsByValidatorIDs(ctx context.Context, ids []uint64, addrs []common.Address) error
 
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint types.Slot) error
 }
@@ -104,8 +100,7 @@ type HeadAccessDatabase interface {
 	EnsureEmbeddedGenesis(ctx context.Context) error
 
 	// initialization method needed for origin checkpoint sync
-	SaveOrigin(ctx context.Context, serState, serBlock []byte) error
-	SaveBackfillBlockRoot(ctx context.Context, blockRoot [32]byte) error
+	SaveOrigin(ctx context.Context, state io.Reader, block io.Reader) error
 }
 
 // SlasherDatabase interface for persisting data related to detecting slashable offenses on Ethereum.

beacon-chain/db/kv/BUILD.bazel

@@ -25,7 +25,6 @@ go_library(
         "state_summary.go",
         "state_summary_cache.go",
         "utils.go",
-        "validated_checkpoint.go",
         "wss.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/db/kv",
@@ -47,7 +46,6 @@ go_library(
         "//config/params:go_default_library",
         "//container/slice:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//encoding/ssz/detect:go_default_library",
         "//io/file:go_default_library",
         "//monitoring/progress:go_default_library",
         "//monitoring/tracing:go_default_library",
@@ -93,7 +91,6 @@ go_test(
         "state_summary_test.go",
         "state_test.go",
         "utils_test.go",
-        "validated_checkpoint_test.go",
     ],
     data = glob(["testdata/**"]),
     embed = [":go_default_library"],

beacon-chain/db/kv/backup_test.go

@@ -21,9 +21,7 @@ func TestStore_Backup(t *testing.T) {
 	head := util.NewBeaconBlock()
 	head.Block.Slot = 5000
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(head)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
+	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(head)))
 	root, err := head.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -63,9 +61,7 @@ func TestStore_BackupMultipleBuckets(t *testing.T) {
 	for i := startSlot; i < 5200; i++ {
 		head := util.NewBeaconBlock()
 		head.Block.Slot = i
-		wsb, err := wrapper.WrappedSignedBeaconBlock(head)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveBlock(ctx, wsb))
+		require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(head)))
 		root, err := head.Block.HashTreeRoot()
 		require.NoError(t, err)
 		st, err := util.NewBeaconState()

beacon-chain/db/kv/blocks.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
-	ssz "github.com/ferranbt/fastssz"
 	"github.com/golang/snappy"
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
@@ -48,18 +47,18 @@ func (s *Store) Block(ctx context.Context, blockRoot [32]byte) (block.SignedBeac
 	return blk, err
 }
 
-// OriginCheckpointBlockRoot returns the value written to the db in SaveOriginCheckpointBlockRoot
+// OriginBlockRoot returns the value written to the db in SaveOriginBlockRoot
 // This is the root of a finalized block within the weak subjectivity period
 // at the time the chain was started, used to initialize the database and chain
 // without syncing from genesis.
-func (s *Store) OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.OriginCheckpointBlockRoot")
+func (s *Store) OriginBlockRoot(ctx context.Context) ([32]byte, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.OriginBlockRoot")
 	defer span.End()
 
 	var root [32]byte
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blocksBucket)
-		rootSlice := bkt.Get(originCheckpointBlockRootKey)
+		rootSlice := bkt.Get(originBlockRootKey)
 		if rootSlice == nil {
 			return ErrNotFoundOriginBlockRoot
 		}
@@ -70,25 +69,6 @@ func (s *Store) OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
 	return root, err
 }
 
-// BackfillBlockRoot keeps track of the highest block available before the OriginCheckpointBlockRoot
-func (s *Store) BackfillBlockRoot(ctx context.Context) ([32]byte, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.BackfillBlockRoot")
-	defer span.End()
-
-	var root [32]byte
-	err := s.db.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(blocksBucket)
-		rootSlice := bkt.Get(backfillBlockRootKey)
-		if len(rootSlice) == 0 {
-			return ErrNotFoundBackfillBlockRoot
-		}
-		root = bytesutil.ToBytes32(rootSlice)
-		return nil
-	})
-
-	return root, err
-}
-
 // HeadBlock returns the latest canonical block in the Ethereum Beacon Chain.
 func (s *Store) HeadBlock(ctx context.Context) (block.SignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.HeadBlock")
@@ -344,22 +324,6 @@ func (s *Store) GenesisBlock(ctx context.Context) (block.SignedBeaconBlock, erro
 	return blk, err
 }
 
-func (s *Store) GenesisBlockRoot(ctx context.Context) ([32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.GenesisBlockRoot")
-	defer span.End()
-	var root [32]byte
-	err := s.db.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(blocksBucket)
-		r := bkt.Get(genesisBlockRootKey)
-		if len(r) == 0 {
-			return ErrNotFoundGenesisBlockRoot
-		}
-		root = bytesutil.ToBytes32(r)
-		return nil
-	})
-	return root, err
-}
-
 // SaveGenesisBlockRoot to the db.
 func (s *Store) SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) error {
 	_, span := trace.StartSpan(ctx, "BeaconDB.SaveGenesisBlockRoot")
@@ -370,27 +334,16 @@ func (s *Store) SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) er
 	})
 }
 
-// SaveOriginCheckpointBlockRoot is used to keep track of the block root used for syncing from a checkpoint origin.
+// SaveOriginBlockRoot is used to keep track of the block root used for origin sync.
 // This should be a finalized block from within the current weak subjectivity period.
 // This value is used by a running beacon chain node to locate the state at the beginning
 // of the chain history, in places where genesis would typically be used.
-func (s *Store) SaveOriginCheckpointBlockRoot(ctx context.Context, blockRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveOriginCheckpointBlockRoot")
+func (s *Store) SaveOriginBlockRoot(ctx context.Context, blockRoot [32]byte) error {
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveOriginBlockRoot")
 	defer span.End()
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(blocksBucket)
-		return bucket.Put(originCheckpointBlockRootKey, blockRoot[:])
-	})
-}
-
-// SaveBackfillBlockRoot is used to keep track of the most recently backfilled block root when
-// the node was initialized via checkpoint sync.
-func (s *Store) SaveBackfillBlockRoot(ctx context.Context, blockRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveBackfillBlockRoot")
-	defer span.End()
-	return s.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(blocksBucket)
-		return bucket.Put(backfillBlockRootKey, blockRoot[:])
+		return bucket.Put(originBlockRootKey, blockRoot[:])
 	})
 }
 
@@ -442,13 +395,13 @@ func (s *Store) HighestSlotBlocksBelow(ctx context.Context, slot types.Slot) ([]
 
 // FeeRecipientByValidatorID returns the fee recipient for a validator id.
 // `ErrNotFoundFeeRecipient` is returned if the validator id is not found.
-func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id types.ValidatorIndex) (common.Address, error) {
+func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id uint64) (common.Address, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.FeeRecipientByValidatorID")
 	defer span.End()
 	var addr []byte
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(feeRecipientBucket)
-		addr = bkt.Get(bytesutil.Uint64ToBytesBigEndian(uint64(id)))
+		addr = bkt.Get(bytesutil.Uint64ToBytesBigEndian(id))
 		if addr == nil {
 			return errors.Wrapf(ErrNotFoundFeeRecipient, "validator id %d", id)
 		}
@@ -459,7 +412,7 @@ func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id types.Validato
 
 // SaveFeeRecipientsByValidatorIDs saves the fee recipients for validator ids.
 // Error is returned if `ids` and `recipients` are not the same length.
-func (s *Store) SaveFeeRecipientsByValidatorIDs(ctx context.Context, ids []types.ValidatorIndex, feeRecipients []common.Address) error {
+func (s *Store) SaveFeeRecipientsByValidatorIDs(ctx context.Context, ids []uint64, feeRecipients []common.Address) error {
 	_, span := trace.StartSpan(ctx, "BeaconDB.SaveFeeRecipientByValidatorID")
 	defer span.End()
 
@@ -470,7 +423,7 @@ func (s *Store) SaveFeeRecipientsByValidatorIDs(ctx context.Context, ids []types
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(feeRecipientBucket)
 		for i, id := range ids {
-			if err := bkt.Put(bytesutil.Uint64ToBytesBigEndian(uint64(id)), feeRecipients[i].Bytes()); err != nil {
+			if err := bkt.Put(bytesutil.Uint64ToBytesBigEndian(id), feeRecipients[i].Bytes()); err != nil {
 				return err
 			}
 		}
@@ -688,27 +641,31 @@ func unmarshalBlock(_ context.Context, enc []byte) (block.SignedBeaconBlock, err
 	if err != nil {
 		return nil, err
 	}
-	var rawBlock ssz.Unmarshaler
 	switch {
 	case hasAltairKey(enc):
 		// Marshal block bytes to altair beacon block.
-		rawBlock = &ethpb.SignedBeaconBlockAltair{}
-		if err := rawBlock.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
+		rawBlock := &ethpb.SignedBeaconBlockAltair{}
+		err := rawBlock.UnmarshalSSZ(enc[len(altairKey):])
+		if err != nil {
 			return nil, err
 		}
+		return wrapper.WrappedAltairSignedBeaconBlock(rawBlock)
 	case hasBellatrixKey(enc):
-		rawBlock = &ethpb.SignedBeaconBlockBellatrix{}
-		if err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):]); err != nil {
+		rawBlock := &ethpb.SignedBeaconBlockBellatrix{}
+		err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):])
+		if err != nil {
 			return nil, err
 		}
+		return wrapper.WrappedBellatrixSignedBeaconBlock(rawBlock)
 	default:
 		// Marshal block bytes to phase 0 beacon block.
-		rawBlock = &ethpb.SignedBeaconBlock{}
-		if err := rawBlock.UnmarshalSSZ(enc); err != nil {
+		rawBlock := &ethpb.SignedBeaconBlock{}
+		err = rawBlock.UnmarshalSSZ(enc)
+		if err != nil {
 			return nil, err
 		}
+		return wrapper.WrappedPhase0SignedBeaconBlock(rawBlock), nil
 	}
-	return wrapper.WrappedSignedBeaconBlock(rawBlock)
 }
 
 // marshal versioned beacon block from struct type down to bytes.

beacon-chain/db/kv/blocks_test.go

@@ -31,7 +31,7 @@ var blockTests = []struct {
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return wrapper.WrappedSignedBeaconBlock(b)
+			return wrapper.WrappedPhase0SignedBeaconBlock(b), nil
 		},
 	},
 	{
@@ -42,7 +42,7 @@ var blockTests = []struct {
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return wrapper.WrappedSignedBeaconBlock(b)
+			return wrapper.WrappedAltairSignedBeaconBlock(b)
 		},
 	},
 	{
@@ -53,28 +53,11 @@ var blockTests = []struct {
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return wrapper.WrappedSignedBeaconBlock(b)
+			return wrapper.WrappedBellatrixSignedBeaconBlock(b)
 		},
 	},
 }
 
-func TestStore_SaveBackfillBlockRoot(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-
-	_, err := db.BackfillBlockRoot(ctx)
-	require.ErrorIs(t, err, ErrNotFoundBackfillBlockRoot)
-
-	expected := [32]byte{}
-	copy(expected[:], []byte{0x23})
-	err = db.SaveBackfillBlockRoot(ctx, expected)
-	require.NoError(t, err)
-	actual, err := db.BackfillBlockRoot(ctx)
-	require.NoError(t, err)
-	require.Equal(t, expected, actual)
-
-}
-
 func TestStore_SaveBlock_NoDuplicates(t *testing.T) {
 	BlockCacheSize = 1
 	slot := types.Slot(20)
@@ -229,9 +212,7 @@ func TestStore_GenesisBlock(t *testing.T) {
 	blockRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, db.SaveGenesisBlockRoot(ctx, blockRoot))
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
+	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock)))
 	retrievedBlock, err := db.GenesisBlock(ctx)
 	require.NoError(t, err)
 	assert.Equal(t, true, proto.Equal(genesisBlock, retrievedBlock.Proto()), "Wanted: %v, received: %v", genesisBlock, retrievedBlock)
@@ -614,11 +595,11 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 func TestStore_FeeRecipientByValidatorID(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
-	ids := []types.ValidatorIndex{0, 0, 0}
+	ids := []uint64{0, 0, 0}
 	feeRecipients := []common.Address{{}, {}, {}, {}}
 	require.ErrorContains(t, "validatorIDs and feeRecipients must be the same length", db.SaveFeeRecipientsByValidatorIDs(ctx, ids, feeRecipients))
 
-	ids = []types.ValidatorIndex{0, 1, 2}
+	ids = []uint64{0, 1, 2}
 	feeRecipients = []common.Address{{'a'}, {'b'}, {'c'}}
 	require.NoError(t, db.SaveFeeRecipientsByValidatorIDs(ctx, ids, feeRecipients))
 	f, err := db.FeeRecipientByValidatorID(ctx, 0)

beacon-chain/db/kv/checkpoint_test.go

@@ -53,9 +53,7 @@ func TestStore_FinalizedCheckpoint_CanSaveRetrieve(t *testing.T) {
 	}
 
 	// a valid chain is required to save finalized checkpoint.
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
+	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(1))

beacon-chain/db/kv/error.go

@@ -13,11 +13,5 @@ var ErrNotFoundState = errors.Wrap(ErrNotFound, "state not found")
 // ErrNotFoundOriginBlockRoot is an error specifically for the origin block root getter
 var ErrNotFoundOriginBlockRoot = errors.Wrap(ErrNotFound, "OriginBlockRoot")
 
-// ErrNotFoundGenesisBlockRoot means no genesis block root was found, indicating the db was not initialized with genesis
-var ErrNotFoundGenesisBlockRoot = errors.Wrap(ErrNotFound, "OriginGenesisRoot")
-
-// ErrNotFoundOriginBlockRoot is an error specifically for the origin block root getter
-var ErrNotFoundBackfillBlockRoot = errors.Wrap(ErrNotFound, "BackfillBlockRoot")
-
 // ErrNotFoundFeeRecipient is a not found error specifically for the fee recipient getter
 var ErrNotFoundFeeRecipient = errors.Wrap(ErrNotFound, "fee recipient")

beacon-chain/db/kv/finalized_block_roots.go

@@ -32,7 +32,7 @@ var containerFinalizedButNotCanonical = []byte("recent block needs reindexing to
 //   - De-index all finalized beacon block roots from previous_finalized_epoch to
 //     new_finalized_epoch. (I.e. delete these roots from the index, to be re-indexed.)
 //   - Build the canonical finalized chain by walking up the ancestry chain from the finalized block
-//     root until a parent is found in the index, or the parent is genesis or the origin checkpoint.
+//     root until a parent is found in the index or the parent is genesis.
 //   - Add all block roots in the database where epoch(block.slot) == checkpoint.epoch.
 //
 // This method ensures that all blocks from the current finalized epoch are considered "final" while
@@ -46,7 +46,6 @@ func (s *Store) updateFinalizedBlockRoots(ctx context.Context, tx *bolt.Tx, chec
 	root := checkpoint.Root
 	var previousRoot []byte
 	genesisRoot := tx.Bucket(blocksBucket).Get(genesisBlockRootKey)
-	initCheckpointRoot := tx.Bucket(blocksBucket).Get(originCheckpointBlockRootKey)
 
 	// De-index recent finalized block roots, to be re-indexed.
 	previousFinalizedCheckpoint := &ethpb.Checkpoint{}
@@ -75,7 +74,7 @@ func (s *Store) updateFinalizedBlockRoots(ctx context.Context, tx *bolt.Tx, chec
 	// Walk up the ancestry chain until we reach a block root present in the finalized block roots
 	// index bucket or genesis block root.
 	for {
-		if bytes.Equal(root, genesisRoot) || bytes.Equal(root, initCheckpointRoot) {
+		if bytes.Equal(root, genesisRoot) {
 			break
 		}
 

beacon-chain/db/kv/finalized_block_roots_test.go

@@ -63,9 +63,7 @@ func TestStore_IsFinalizedBlockGenesis(t *testing.T) {
 	blk.Block.Slot = 0
 	root, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
+	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
 	require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 	assert.Equal(t, true, db.IsFinalizedBlock(ctx, root), "Finalized genesis block doesn't exist in db")
 }
@@ -209,8 +207,7 @@ func makeBlocks(t *testing.T, i, n uint64, previousRoot [32]byte) []block.Signed
 		var err error
 		previousRoot, err = blocks[j-i].Block.HashTreeRoot()
 		require.NoError(t, err)
-		ifaceBlocks[j-i], err = wrapper.WrappedSignedBeaconBlock(blocks[j-i])
-		require.NoError(t, err)
+		ifaceBlocks[j-i] = wrapper.WrappedPhase0SignedBeaconBlock(blocks[j-i])
 	}
 	return ifaceBlocks
 }
@@ -227,7 +224,7 @@ func makeBlocksAltair(t *testing.T, startIdx, num uint64, previousRoot [32]byte)
 		var err error
 		previousRoot, err = blocks[j-startIdx].Block.HashTreeRoot()
 		require.NoError(t, err)
-		ifaceBlocks[j-startIdx], err = wrapper.WrappedSignedBeaconBlock(blocks[j-startIdx])
+		ifaceBlocks[j-startIdx], err = wrapper.WrappedAltairSignedBeaconBlock(blocks[j-startIdx])
 		require.NoError(t, err)
 	}
 	return ifaceBlocks

beacon-chain/db/kv/genesis.go

@@ -28,11 +28,7 @@ func (s *Store) SaveGenesisData(ctx context.Context, genesisState state.BeaconSt
 	if err != nil {
 		return errors.Wrap(err, "could not get genesis block root")
 	}
-	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
-	if err != nil {
-		return errors.Wrap(err, "could not wrap genesis block")
-	}
-	if err := s.SaveBlock(ctx, wsb); err != nil {
+	if err := s.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)); err != nil {
 		return errors.Wrap(err, "could not save genesis block")
 	}
 	if err := s.SaveState(ctx, genesisState, genesisBlkRoot); err != nil {

beacon-chain/db/kv/kv.go

@@ -175,6 +175,7 @@ func NewKVStore(ctx context.Context, dirPath string, config *Config) (*Store, er
 			powchainBucket,
 			stateSummaryBucket,
 			stateValidatorsBucket,
+			validatedTips,
 			// Indices buckets.
 			attestationHeadBlockRootBucket,
 			attestationSourceRootIndicesBucket,

beacon-chain/db/kv/schema.go

@@ -19,6 +19,7 @@ var (
 	powchainBucket          = []byte("powchain")
 	stateValidatorsBucket   = []byte("state-validators")
 	feeRecipientBucket      = []byte("fee-recipient")
+	validatedTips           = []byte("validated-synced-tips")
 
 	// Deprecated: This bucket was migrated in PR 6461. Do not use, except for migrations.
 	slotsHasObjectBucket = []byte("slots-has-objects")
@@ -38,22 +39,19 @@ var (
 	blockRootValidatorHashesBucket      = []byte("block-root-validator-hashes")
 
 	// Specific item keys.
-	headBlockRootKey           = []byte("head-root")
-	genesisBlockRootKey        = []byte("genesis-root")
-	depositContractAddressKey  = []byte("deposit-contract")
-	justifiedCheckpointKey     = []byte("justified-checkpoint")
-	finalizedCheckpointKey     = []byte("finalized-checkpoint")
-	powchainDataKey            = []byte("powchain-data")
-	lastValidatedCheckpointKey = []byte("last-validated-checkpoint")
+	headBlockRootKey          = []byte("head-root")
+	genesisBlockRootKey       = []byte("genesis-root")
+	depositContractAddressKey = []byte("deposit-contract")
+	justifiedCheckpointKey    = []byte("justified-checkpoint")
+	finalizedCheckpointKey    = []byte("finalized-checkpoint")
+	powchainDataKey           = []byte("powchain-data")
 
 	// Below keys are used to identify objects are to be fork compatible.
 	// Objects that are only compatible with specific forks should be prefixed with such keys.
 	altairKey    = []byte("altair")
 	bellatrixKey = []byte("merge")
 	// block root included in the beacon state used by weak subjectivity initial sync
-	originCheckpointBlockRootKey = []byte("origin-checkpoint-block-root")
-	// block root tracking the progress of backfill, or pointing at genesis if backfill has not been initiated
-	backfillBlockRootKey = []byte("backfill-block-root")
+	originBlockRootKey = []byte("origin-block-root")
 
 	// Deprecated: This index key was migrated in PR 6461. Do not use, except for migrations.
 	lastArchivedIndexKey = []byte("last-archived")

beacon-chain/db/kv/state.go

@@ -638,11 +638,7 @@ func (s *Store) slotByBlockRoot(ctx context.Context, tx *bolt.Tx, blockRoot []by
 		if err != nil {
 			return 0, err
 		}
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		if err != nil {
-			return 0, err
-		}
-		if err := helpers.BeaconBlockIsNil(wsb); err != nil {
+		if err := helpers.BeaconBlockIsNil(wrapper.WrappedPhase0SignedBeaconBlock(b)); err != nil {
 			return 0, err
 		}
 		return b.Block.Slot, nil

beacon-chain/db/kv/state_test.go

@@ -374,9 +374,7 @@ func TestStore_StatesBatchDelete(t *testing.T) {
 	for i := 0; i < len(totalBlocks); i++ {
 		b := util.NewBeaconBlock()
 		b.Block.Slot = types.Slot(i)
-		var err error
-		totalBlocks[i], err = wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
+		totalBlocks[i] = wrapper.WrappedPhase0SignedBeaconBlock(b)
 		r, err := totalBlocks[i].Block().HashTreeRoot()
 		require.NoError(t, err)
 		st, err := util.NewBeaconState()
@@ -427,9 +425,7 @@ func TestStore_DeleteFinalizedState(t *testing.T) {
 	blk.Block.ParentRoot = genesis[:]
 	blk.Block.Slot = 100
 
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
+	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
 
 	finalizedBlockRoot, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -454,9 +450,7 @@ func TestStore_DeleteHeadState(t *testing.T) {
 	blk := util.NewBeaconBlock()
 	blk.Block.ParentRoot = genesis[:]
 	blk.Block.Slot = 100
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
+	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
 
 	headBlockRoot, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -476,9 +470,7 @@ func TestStore_SaveDeleteState_CanGetHighestBelow(t *testing.T) {
 	b.Block.Slot = 1
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(context.Background(), wsb))
+	require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(1))
@@ -488,9 +480,7 @@ func TestStore_SaveDeleteState_CanGetHighestBelow(t *testing.T) {
 	b.Block.Slot = 100
 	r1, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(context.Background(), wsb))
+	require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	st, err = util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(100))
@@ -500,9 +490,7 @@ func TestStore_SaveDeleteState_CanGetHighestBelow(t *testing.T) {
 	b.Block.Slot = 1000
 	r2, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err = wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(context.Background(), wsb))
+	require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 	st, err = util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(1000))
@@ -536,9 +524,7 @@ func TestStore_GenesisState_CanGetHighestBelow(t *testing.T) {
 	b.Block.Slot = 1
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(context.Background(), wsb))
+	require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -575,9 +561,7 @@ func TestStore_CleanUpDirtyStates_AboveThreshold(t *testing.T) {
 		b.Block.ParentRoot = prevRoot[:]
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveBlock(context.Background(), wsb))
+		require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 		bRoots = append(bRoots, r)
 		prevRoot = r
 
@@ -616,9 +600,7 @@ func TestStore_CleanUpDirtyStates_Finalized(t *testing.T) {
 		b.Block.Slot = i
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveBlock(context.Background(), wsb))
+		require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 
 		st, err := util.NewBeaconState()
 		require.NoError(t, err)
@@ -646,9 +628,7 @@ func TestStore_CleanUpDirtyStates_DontDeleteNonFinalized(t *testing.T) {
 		b.Block.Slot = i
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveBlock(context.Background(), wsb))
+		require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
 		unfinalizedRoots = append(unfinalizedRoots, r)
 
 		st, err := util.NewBeaconState()

beacon-chain/db/kv/validated_checkpoint.go

@@ -1,49 +0,0 @@
-package kv
-
-import (
-	"context"
-
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	bolt "go.etcd.io/bbolt"
-	"go.opencensus.io/trace"
-)
-
-// LastValidatedCheckpoint returns the latest fully validated checkpoint in beacon chain.
-func (s *Store) LastValidatedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.LastValidatedCheckpoint")
-	defer span.End()
-	var checkpoint *ethpb.Checkpoint
-	err := s.db.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(checkpointBucket)
-		enc := bkt.Get(lastValidatedCheckpointKey)
-		if enc == nil {
-			var finErr error
-			checkpoint, finErr = s.FinalizedCheckpoint(ctx)
-			return finErr
-		}
-		checkpoint = &ethpb.Checkpoint{}
-		return decode(ctx, enc, checkpoint)
-	})
-	return checkpoint, err
-}
-
-// SaveLastValidatedCheckpoint saves the last validated checkpoint in beacon chain.
-func (s *Store) SaveLastValidatedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveLastValidatedCheckpoint")
-	defer span.End()
-
-	enc, err := encode(ctx, checkpoint)
-	if err != nil {
-		return err
-	}
-	return s.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(checkpointBucket)
-		hasStateSummary := s.hasStateSummaryBytes(tx, bytesutil.ToBytes32(checkpoint.Root))
-		hasStateInDB := tx.Bucket(stateBucket).Get(checkpoint.Root) != nil
-		if !(hasStateInDB || hasStateSummary) {
-			return errMissingStateForCheckpoint
-		}
-		return bucket.Put(lastValidatedCheckpointKey, enc)
-	})
-}

beacon-chain/db/kv/validated_checkpoint_test.go

@@ -1,69 +0,0 @@
-package kv
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
-	"github.com/prysmaticlabs/prysm/testing/assert"
-	"github.com/prysmaticlabs/prysm/testing/require"
-	"github.com/prysmaticlabs/prysm/testing/util"
-	"google.golang.org/protobuf/proto"
-)
-
-func TestStore_LastValidatedCheckpoint_CanSaveRetrieve(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	root := bytesutil.ToBytes32([]byte{'A'})
-	cp := &ethpb.Checkpoint{
-		Epoch: 10,
-		Root:  root[:],
-	}
-	st, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, st.SetSlot(1))
-	require.NoError(t, db.SaveState(ctx, st, root))
-	require.NoError(t, db.SaveLastValidatedCheckpoint(ctx, cp))
-
-	retrieved, err := db.LastValidatedCheckpoint(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
-}
-
-func TestStore_LastValidatedCheckpoint_DefaultIsFinalized(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-
-	genesis := bytesutil.ToBytes32([]byte{'G', 'E', 'N', 'E', 'S', 'I', 'S'})
-	require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesis))
-
-	blk := util.NewBeaconBlock()
-	blk.Block.ParentRoot = genesis[:]
-	blk.Block.Slot = 40
-
-	root, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	cp := &ethpb.Checkpoint{
-		Epoch: 5,
-		Root:  root[:],
-	}
-
-	// a valid chain is required to save finalized checkpoint.
-	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
-	st, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, st.SetSlot(1))
-	// a state is required to save checkpoint
-	require.NoError(t, db.SaveState(ctx, st, root))
-
-	require.NoError(t, db.SaveFinalizedCheckpoint(ctx, cp))
-
-	retrieved, err := db.LastValidatedCheckpoint(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
-}

beacon-chain/db/kv/wss.go

@@ -2,76 +2,67 @@ package kv
 
 import (
 	"context"
-	"fmt"
+	"io"
+	"io/ioutil"
 
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
+	statev2 "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/encoding/ssz/detect"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/runtime/version"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 )
 
 // SaveOrigin loads an ssz serialized Block & BeaconState from an io.Reader
 // (ex: an open file) prepares the database so that the beacon node can begin
 // syncing, using the provided values as their point of origin. This is an alternative
 // to syncing from genesis, and should only be run on an empty database.
-func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error {
-	genesisRoot, err := s.GenesisBlockRoot(ctx)
+func (s *Store) SaveOrigin(ctx context.Context, stateReader, blockReader io.Reader) error {
+	// unmarshal both block and state before trying to save anything
+	// so that we fail early if there is any issue with the ssz data
+	blk := &ethpb.SignedBeaconBlockAltair{}
+	bb, err := ioutil.ReadAll(blockReader)
 	if err != nil {
-		if errors.Is(err, ErrNotFoundGenesisBlockRoot) {
-			return errors.Wrap(err, "genesis block root not found: genesis must be provided for checkpoint sync")
-		}
-		return errors.Wrap(err, "genesis block root query error: checkpoint sync must verify genesis to proceed")
+		return errors.Wrap(err, "error reading block given to SaveOrigin")
 	}
-	err = s.SaveBackfillBlockRoot(ctx, genesisRoot)
+	if err := blk.UnmarshalSSZ(bb); err != nil {
+		return errors.Wrap(err, "could not unmarshal checkpoint block")
+	}
+	wblk, err := wrapper.WrappedAltairSignedBeaconBlock(blk)
 	if err != nil {
-		return errors.Wrap(err, "unable to save genesis root as initial backfill starting point for checkpoint sync")
+		return errors.Wrap(err, "could not wrap checkpoint block")
 	}
-
-	cf, err := detect.FromState(serState)
+	bs, err := statev2.InitializeFromSSZReader(stateReader)
 	if err != nil {
-		return errors.Wrap(err, "could not sniff config+fork for origin state bytes")
+		return errors.Wrap(err, "could not initialize checkpoint state from reader")
 	}
-	_, ok := params.BeaconConfig().ForkVersionSchedule[cf.Version]
-	if !ok {
-		return fmt.Errorf("config mismatch, beacon node configured to connect to %s, detected state is for %s", params.BeaconConfig().ConfigName, cf.Config.ConfigName)
-	}
-
-	log.Infof("detected supported config for state & block version, config name=%s, fork name=%s", cf.Config.ConfigName, version.String(cf.Fork))
-	state, err := cf.UnmarshalBeaconState(serState)
-	if err != nil {
-		return errors.Wrap(err, "failed to initialize origin state w/ bytes + config+fork")
-	}
-
-	wblk, err := cf.UnmarshalBeaconBlock(serBlock)
-	if err != nil {
-		return errors.Wrap(err, "failed to initialize origin block w/ bytes + config+fork")
-	}
-	blk := wblk.Block()
 
 	// save block
-	blockRoot, err := blk.HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "could not compute HashTreeRoot of checkpoint block")
-	}
-	log.Infof("saving checkpoint block to db, w/ root=%#x", blockRoot)
 	if err := s.SaveBlock(ctx, wblk); err != nil {
 		return errors.Wrap(err, "could not save checkpoint block")
 	}
+	blockRoot, err := blk.Block.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not compute HashTreeRoot of checkpoint block")
+	}
 
 	// save state
-	log.Infof("calling SaveState w/ blockRoot=%x", blockRoot)
-	if err = s.SaveState(ctx, state, blockRoot); err != nil {
+	if err = s.SaveState(ctx, bs, blockRoot); err != nil {
 		return errors.Wrap(err, "could not save state")
 	}
 	if err = s.SaveStateSummary(ctx, &ethpb.StateSummary{
-		Slot: state.Slot(),
+		Slot: bs.Slot(),
 		Root: blockRoot[:],
 	}); err != nil {
 		return errors.Wrap(err, "could not save state summary")
 	}
 
+	// save origin block root in special key, to be used when the canonical
+	// origin (start of chain, ie alternative to genesis) block or state is needed
+	if err = s.SaveOriginBlockRoot(ctx, blockRoot); err != nil {
+		return errors.Wrap(err, "could not save origin block root")
+	}
+
 	// mark block as head of chain, so that processing will pick up from this point
 	if err = s.SaveHeadBlockRoot(ctx, blockRoot); err != nil {
 		return errors.Wrap(err, "could not save head block root")
@@ -79,7 +70,7 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 
 	// rebuild the checkpoint from the block
 	// use it to mark the block as justified and finalized
-	slotEpoch, err := wblk.Block().Slot().SafeDivSlot(params.BeaconConfig().SlotsPerEpoch)
+	slotEpoch, err := blk.Block.Slot.SafeDivSlot(params.BeaconConfig().SlotsPerEpoch)
 	if err != nil {
 		return err
 	}
@@ -94,11 +85,5 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 		return errors.Wrap(err, "could not mark checkpoint sync block as finalized")
 	}
 
-	// save origin block root in a special key, to be used when the canonical
-	// origin (start of chain, ie alternative to genesis) block or state is needed
-	if err = s.SaveOriginCheckpointBlockRoot(ctx, blockRoot); err != nil {
-		return errors.Wrap(err, "could not save origin block root")
-	}
-
 	return nil
 }

beacon-chain/db/restore_test.go

@@ -27,9 +27,7 @@ func TestRestore(t *testing.T) {
 	require.NoError(t, err)
 	head := util.NewBeaconBlock()
 	head.Block.Slot = 5000
-	wsb, err := wrapper.WrappedSignedBeaconBlock(head)
-	require.NoError(t, err)
-	require.NoError(t, backupDb.SaveBlock(ctx, wsb))
+	require.NoError(t, backupDb.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(head)))
 	root, err := head.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()

beacon-chain/forkchoice/BUILD.bazel

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

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

@@ -19,10 +19,10 @@ go_library(
         "//testing/spectest:__subpackages__",
     ],
     deps = [
-        "//beacon-chain/forkchoice/types:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
@@ -45,7 +45,6 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/forkchoice/types:go_default_library",
         "//config/params:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",

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

@@ -2,7 +2,7 @@ package doublylinkedtree
 
 import "errors"
 
-var ErrNilNode = errors.New("invalid nil or unknown node")
+var errNilNode = errors.New("invalid nil or unknown node")
 var errInvalidBalance = errors.New("invalid node balance")
 var errInvalidProposerBoostRoot = errors.New("invalid proposer boost root")
 var errUnknownFinalizedRoot = errors.New("unknown finalized root")

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

@@ -27,9 +27,9 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	//            2 <- justified: 1, finalized: 0
 	//            |
 	//            3 <- justified: 2, finalized: 1
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 2, 1))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 2, indexToHash(2), indexToHash(1), 1, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 3, indexToHash(3), indexToHash(2), 2, 1))
 
 	// With starting justified epoch at 0, the head should be 3:
 	//            0 <- start
@@ -89,17 +89,17 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//                              |   |
 	//  justified: 2, finalized: 0 -> 9  10 <- justified: 2, finalized: 0
 	// Left branch.
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 2, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 3, indexToHash(5), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 4, indexToHash(7), indexToHash(5), params.BeaconConfig().ZeroHash, 1, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 4, indexToHash(9), indexToHash(7), params.BeaconConfig().ZeroHash, 2, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 2, indexToHash(3), indexToHash(1), 1, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 3, indexToHash(5), indexToHash(3), 1, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 4, indexToHash(7), indexToHash(5), 1, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 4, indexToHash(9), indexToHash(7), 2, 0))
 	// Right branch.
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 1, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 2, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 3, indexToHash(6), indexToHash(4), params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 4, indexToHash(8), indexToHash(6), params.BeaconConfig().ZeroHash, 1, 0))
-	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 4, indexToHash(10), indexToHash(8), params.BeaconConfig().ZeroHash, 2, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 1, indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 2, indexToHash(4), indexToHash(2), 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 3, indexToHash(6), indexToHash(4), 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 4, indexToHash(8), indexToHash(6), 1, 0))
+	require.NoError(t, f.InsertOptimisticBlock(context.Background(), 4, indexToHash(10), indexToHash(8), 2, 0))
 
 	// With start at 0, the head should be 10:
 	//           0  <-- start
@@ -185,7 +185,7 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 func setup(justifiedEpoch, finalizedEpoch types.Epoch) *ForkChoice {
 	ctx := context.Background()
 	f := New(justifiedEpoch, finalizedEpoch)
-	err := f.InsertOptimisticBlock(ctx, 0, params.BeaconConfig().ZeroHash, [32]byte{}, params.BeaconConfig().ZeroHash, justifiedEpoch, finalizedEpoch)
+	err := f.InsertOptimisticBlock(ctx, 0, params.BeaconConfig().ZeroHash, [32]byte{}, justifiedEpoch, finalizedEpoch)
 	if err != nil {
 		return nil
 	}

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

@@ -106,13 +106,13 @@ func (f *ForkChoice) ProcessAttestation(ctx context.Context, validatorIndices []
 func (f *ForkChoice) InsertOptimisticBlock(
 	ctx context.Context,
 	slot types.Slot,
-	blockRoot, parentRoot, payloadHash [fieldparams.RootLength]byte,
+	blockRoot, parentRoot [fieldparams.RootLength]byte,
 	justifiedEpoch, finalizedEpoch types.Epoch,
 ) error {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.InsertOptimisticBlock")
 	defer span.End()
 
-	return f.store.insert(ctx, slot, blockRoot, parentRoot, payloadHash, justifiedEpoch, finalizedEpoch)
+	return f.store.insert(ctx, slot, blockRoot, parentRoot, justifiedEpoch, finalizedEpoch)
 }
 
 // Prune prunes the fork choice store with the new finalized root. The store is only pruned if the input
@@ -174,7 +174,7 @@ func (f *ForkChoice) IsOptimistic(_ context.Context, root [32]byte) (bool, error
 
 	node, ok := f.store.nodeByRoot[root]
 	if !ok || node == nil {
-		return false, ErrNilNode
+		return false, errNilNode
 	}
 
 	return node.optimistic, nil
@@ -190,7 +190,7 @@ func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot types
 
 	node, ok := f.store.nodeByRoot[root]
 	if !ok || node == nil {
-		return nil, ErrNilNode
+		return nil, errNilNode
 	}
 
 	n := node
@@ -202,7 +202,7 @@ func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot types
 	}
 
 	if n == nil {
-		return nil, ErrNilNode
+		return nil, errNilNode
 	}
 
 	return n.root[:], nil
@@ -237,7 +237,7 @@ func (f *ForkChoice) updateBalances(newBalances []uint64) error {
 			if ok && vote.nextRoot != params.BeaconConfig().ZeroHash {
 				// Protection against nil node
 				if nextNode == nil {
-					return ErrNilNode
+					return errNilNode
 				}
 				nextNode.balance += newBalance
 			}
@@ -246,7 +246,7 @@ func (f *ForkChoice) updateBalances(newBalances []uint64) error {
 			if ok && vote.currentRoot != params.BeaconConfig().ZeroHash {
 				// Protection against nil node
 				if currentNode == nil {
-					return ErrNilNode
+					return errNilNode
 				}
 				if currentNode.balance < oldBalance {
 					return errInvalidBalance
@@ -279,7 +279,7 @@ func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [fieldparams
 	defer f.store.nodesLock.Unlock()
 	node, ok := f.store.nodeByRoot[root]
 	if !ok || node == nil {
-		return ErrNilNode
+		return errNilNode
 	}
 	return node.setNodeAndParentValidated(ctx)
 }
@@ -302,6 +302,6 @@ func (f *ForkChoice) ForkChoiceNodes() []*pbrpc.ForkChoiceNode {
 }
 
 // SetOptimisticToInvalid removes a block with an invalid execution payload from fork choice store
-func (f *ForkChoice) SetOptimisticToInvalid(ctx context.Context, root [fieldparams.RootLength]byte) ([][32]byte, error) {
+func (f *ForkChoice) SetOptimisticToInvalid(ctx context.Context, root [fieldparams.RootLength]byte) error {
 	return f.store.removeNode(ctx, root)
 }

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

@@ -15,9 +15,9 @@ import (
 func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), 0, 0))
 
 	f.votes = []Vote{
 		{indexToHash(1), indexToHash(1), 0},
@@ -37,9 +37,9 @@ func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) {
 func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), 0, 0))
 	s := f.store
 	s.nodeByRoot[indexToHash(1)].balance = 100
 	s.nodeByRoot[indexToHash(2)].balance = 100
@@ -61,12 +61,12 @@ func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
 func TestForkChoice_IsCanonical(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 6, indexToHash(6), indexToHash(5), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(1), 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 4, indexToHash(4), indexToHash(2), 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, indexToHash(5), indexToHash(4), 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 6, indexToHash(6), indexToHash(5), 1, 1))
 
 	require.Equal(t, true, f.IsCanonical(params.BeaconConfig().ZeroHash))
 	require.Equal(t, false, f.IsCanonical(indexToHash(1)))
@@ -80,12 +80,12 @@ func TestForkChoice_IsCanonical(t *testing.T) {
 func TestForkChoice_IsCanonicalReorg(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, [32]byte{'2'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 4, [32]byte{'4'}, [32]byte{'2'}, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, [32]byte{'5'}, [32]byte{'4'}, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 6, [32]byte{'6'}, [32]byte{'5'}, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, [32]byte{'2'}, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, [32]byte{'3'}, [32]byte{'1'}, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 4, [32]byte{'4'}, [32]byte{'2'}, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, [32]byte{'5'}, [32]byte{'4'}, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 6, [32]byte{'6'}, [32]byte{'5'}, 1, 1))
 
 	f.store.nodesLock.Lock()
 	f.store.nodeByRoot[[32]byte{'3'}].balance = 10
@@ -114,9 +114,9 @@ func TestForkChoice_IsCanonicalReorg(t *testing.T) {
 func TestForkChoice_AncestorRoot(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, indexToHash(3), indexToHash(2), 1, 1))
 	f.store.treeRootNode = f.store.nodeByRoot[indexToHash(1)]
 	f.store.treeRootNode.parent = nil
 
@@ -125,7 +125,7 @@ func TestForkChoice_AncestorRoot(t *testing.T) {
 	assert.Equal(t, bytesutil.ToBytes32(r), indexToHash(3))
 
 	_, err = f.AncestorRoot(ctx, indexToHash(3), 0)
-	assert.ErrorContains(t, ErrNilNode.Error(), err)
+	assert.ErrorContains(t, errNilNode.Error(), err)
 
 	root, err := f.AncestorRoot(ctx, indexToHash(3), 5)
 	require.NoError(t, err)
@@ -140,8 +140,8 @@ func TestForkChoice_AncestorRoot(t *testing.T) {
 func TestForkChoice_AncestorEqualSlot(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 101, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 101, [32]byte{'3'}, [32]byte{'1'}, 1, 1))
 
 	r, err := f.AncestorRoot(ctx, [32]byte{'3'}, 100)
 	require.NoError(t, err)
@@ -152,8 +152,8 @@ func TestForkChoice_AncestorEqualSlot(t *testing.T) {
 func TestForkChoice_AncestorLowerSlot(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 200, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 200, [32]byte{'3'}, [32]byte{'1'}, 1, 1))
 
 	r, err := f.AncestorRoot(ctx, [32]byte{'3'}, 150)
 	require.NoError(t, err)

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

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

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

@@ -55,7 +55,7 @@ func (n *Node) updateBestDescendant(ctx context.Context, justifiedEpoch, finaliz
 	hasViableDescendant := false
 	for _, child := range n.children {
 		if child == nil {
-			return ErrNilNode
+			return errNilNode
 		}
 		if err := child.updateBestDescendant(ctx, justifiedEpoch, finalizedEpoch); err != nil {
 			return err

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

@@ -13,9 +13,9 @@ import (
 func TestNode_ApplyWeightChanges_PositiveChange(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), 0, 0))
 
 	// The updated balances of each node is 100
 	s := f.store
@@ -36,9 +36,9 @@ func TestNode_ApplyWeightChanges_PositiveChange(t *testing.T) {
 func TestNode_ApplyWeightChanges_NegativeChange(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), 0, 0))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), 0, 0))
 
 	// The updated balances of each node is 100
 	s := f.store
@@ -63,7 +63,7 @@ func TestNode_UpdateBestDescendant_NonViableChild(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
 	// Input child is not viable.
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 2, 3))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 2, 3))
 
 	// Verify parent's best child and best descendant are `none`.
 	s := f.store
@@ -76,7 +76,7 @@ func TestNode_UpdateBestDescendant_ViableChild(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
 	// Input child is best descendant
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
 
 	s := f.store
 	assert.Equal(t, 1, len(s.treeRootNode.children))
@@ -87,8 +87,8 @@ func TestNode_UpdateBestDescendant_HigherWeightChild(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
 	// Input child is best descendant
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1))
 
 	s := f.store
 	s.nodeByRoot[indexToHash(1)].weight = 100
@@ -103,8 +103,8 @@ func TestNode_UpdateBestDescendant_LowerWeightChild(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
 	// Input child is best descendant
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1))
 
 	s := f.store
 	s.nodeByRoot[indexToHash(1)].weight = 200
@@ -119,9 +119,9 @@ func TestNode_TestDepth(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
 	// Input child is best descendant
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), params.BeaconConfig().ZeroHash, 1, 1))
 
 	s := f.store
 	require.Equal(t, s.nodeByRoot[indexToHash(2)].depth(), uint64(2))
@@ -151,11 +151,11 @@ func TestNode_ViableForHead(t *testing.T) {
 func TestNode_LeadsToViableHead(t *testing.T) {
 	f := setup(4, 3)
 	ctx := context.Background()
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, indexToHash(5), indexToHash(3), params.BeaconConfig().ZeroHash, 4, 3))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(1), 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 4, indexToHash(4), indexToHash(2), 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, indexToHash(5), indexToHash(3), 4, 3))
 
 	require.Equal(t, true, f.store.treeRootNode.leadsToViableHead(4, 3))
 	require.Equal(t, true, f.store.nodeByRoot[indexToHash(5)].leadsToViableHead(4, 3))
@@ -172,13 +172,13 @@ func TestNode_SetFullyValidated(t *testing.T) {
 	//               \
 	//                 -- 5 (true)
 	//
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
 	require.NoError(t, f.SetOptimisticToValid(ctx, params.BeaconConfig().ZeroHash))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 2, indexToHash(2), indexToHash(1), 1, 1))
 	require.NoError(t, f.SetOptimisticToValid(ctx, indexToHash(1)))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 4, indexToHash(4), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 1))
-	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, indexToHash(5), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 3, indexToHash(3), indexToHash(2), 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 4, indexToHash(4), indexToHash(3), 1, 1))
+	require.NoError(t, f.InsertOptimisticBlock(ctx, 5, indexToHash(5), indexToHash(1), 1, 1))
 
 	opt, err := f.IsOptimistic(ctx, indexToHash(5))
 	require.NoError(t, err)

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

@@ -6,17 +6,16 @@ import (
 
 // removeNode removes the node with the given root and all of its children
 // from the Fork Choice Store.
-func (s *Store) removeNode(ctx context.Context, root [32]byte) ([][32]byte, error) {
+func (s *Store) removeNode(ctx context.Context, root [32]byte) error {
 	s.nodesLock.Lock()
 	defer s.nodesLock.Unlock()
-	invalidRoots := make([][32]byte, 0)
 
 	node, ok := s.nodeByRoot[root]
 	if !ok || node == nil {
-		return invalidRoots, ErrNilNode
+		return errNilNode
 	}
 	if !node.optimistic || node.parent == nil {
-		return invalidRoots, errInvalidOptimisticStatus
+		return errInvalidOptimisticStatus
 	}
 	children := node.parent.children
 	if len(children) == 1 {
@@ -32,21 +31,20 @@ func (s *Store) removeNode(ctx context.Context, root [32]byte) ([][32]byte, erro
 			}
 		}
 	}
-	return s.removeNodeAndChildren(ctx, node, invalidRoots)
+	return s.removeNodeAndChildren(ctx, node)
 }
 
 // removeNodeAndChildren removes `node` and all of its descendant from the Store
-func (s *Store) removeNodeAndChildren(ctx context.Context, node *Node, invalidRoots [][32]byte) ([][32]byte, error) {
-	var err error
+func (s *Store) removeNodeAndChildren(ctx context.Context, node *Node) error {
 	for _, child := range node.children {
 		if ctx.Err() != nil {
-			return invalidRoots, ctx.Err()
+			return ctx.Err()
 		}
-		if invalidRoots, err = s.removeNodeAndChildren(ctx, child, invalidRoots); err != nil {
-			return invalidRoots, err
+		if err := s.removeNodeAndChildren(ctx, child); err != nil {
+			return err
 		}
 	}
-	invalidRoots = append(invalidRoots, node.root)
+
 	delete(s.nodeByRoot, node.root)
-	return invalidRoots, nil
+	return nil
 }