Merge branch 'develop' into inc-default-timeout

* Set boost with deterministic timing

* confs

* gaz

* Update runner.go

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

api/client/beacon/BUILD.bazel

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,262 @@
+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

@@ -0,0 +1,407 @@
+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

@@ -0,0 +1,437 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,6 @@
+/*
+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

@@ -0,0 +1,13 @@
+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,6 +51,7 @@ 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_norace_test.go

@@ -43,16 +43,18 @@ func TestHeadRoot_DataRace(t *testing.T) {
 
 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: wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{})},
+		head: &head{block: wsb},
 	}
 	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
 }

beacon-chain/blockchain/chain_info_test.go

@@ -133,7 +133,9 @@ func TestHeadRoot_UseDB(t *testing.T) {
 	b := util.NewBeaconBlock()
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	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[:]}))
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(context.Background(), br))
 	r, err := c.HeadRoot(context.Background())
@@ -146,8 +148,10 @@ 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: wrapper.WrappedPhase0SignedBeaconBlock(b), state: s}
+	c.head = &head{block: wsb, state: s}
 
 	recevied, err := c.HeadBlock(context.Background())
 	require.NoError(t, err)
@@ -229,7 +233,9 @@ func TestIsCanonical_Ok(t *testing.T) {
 	blk.Block.Slot = 0
 	root, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
 	can, err := c.IsCanonical(ctx, root)
 	require.NoError(t, err)
@@ -447,20 +453,26 @@ func TestService_IsOptimisticForRoot_DB_ProtoArray(t *testing.T) {
 	b.Block.Slot = 10
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	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)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(optimisticBlock)))
+	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)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(validatedBlock)))
+	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))
@@ -485,20 +497,26 @@ func TestService_IsOptimisticForRoot__DB_DoublyLinkedTree(t *testing.T) {
 	b.Block.Slot = 10
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	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)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(optimisticBlock)))
+	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)
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(validatedBlock)))
+	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))

beacon-chain/blockchain/head.go

@@ -148,16 +148,21 @@ 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),
+				Slot:                newHeadSlot,
+				Depth:               absoluteSlotDifference,
+				OldHeadBlock:        oldHeadRoot[:],
+				NewHeadBlock:        headRoot[:],
+				OldHeadState:        oldStateRoot,
+				NewHeadState:        newStateRoot,
+				Epoch:               slots.ToEpoch(newHeadSlot),
+				ExecutionOptimistic: isOptimistic,
 			},
 		})
 
@@ -179,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(newHeadSlot, newHeadState, newStateRoot, headRoot[:]); err != nil {
+		if err := s.notifyNewHeadEvent(ctx, newHeadSlot, newHeadState, newStateRoot, headRoot[:]); err != nil {
 			log.WithError(err).Error("Could not notify event feed of new chain head")
 		}
 	}()
@@ -299,6 +304,7 @@ 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,
@@ -332,6 +338,10 @@ 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{
@@ -341,6 +351,7 @@ func (s *Service) notifyNewHeadEvent(
 			EpochTransition:           slots.IsEpochStart(newHeadSlot),
 			PreviousDutyDependentRoot: previousDutyDependentRoot,
 			CurrentDutyDependentRoot:  currentDutyDependentRoot,
+			ExecutionOptimistic:       isOptimistic,
 		},
 	})
 	return nil

beacon-chain/blockchain/head_test.go

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

beacon-chain/blockchain/optimistic_sync.go

@@ -8,13 +8,11 @@ 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"
 )
@@ -30,10 +28,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, headBlk block.Beac
 		return nil, errors.New("nil head block")
 	}
 	// Must not call fork choice updated until the transition conditions are met on the Pow network.
-	if isPreBellatrix(headBlk.Version()) {
-		return nil, nil
-	}
-	isExecutionBlk, err := blocks.ExecutionBlock(headBlk.Body())
+	isExecutionBlk, err := blocks.IsExecutionBlock(headBlk.Body())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not determine if block is execution block")
 	}
@@ -49,7 +44,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 isPreBellatrix(finalizedBlock.Block().Version()) {
+	if blocks.IsPreBellatrixVersion(finalizedBlock.Block().Version()) {
 		finalizedHash = params.BeaconConfig().ZeroHash[:]
 	} else {
 		payload, err := finalizedBlock.Block().Body().ExecutionPayload()
@@ -87,23 +82,21 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, headBlk block.Beac
 }
 
 // notifyForkchoiceUpdate signals execution engine on a new payload
-func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int, header *ethpb.ExecutionPayloadHeader, postState state.BeaconState, blk block.SignedBeaconBlock, root [32]byte) error {
+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()
 
-	if postState == nil {
-		return errors.New("pre and post states must not be nil")
-	}
 	// Execution payload is only supported in Bellatrix and beyond. Pre
 	// merge blocks are never optimistic
-	if isPreBellatrix(postState.Version()) {
+	if blocks.IsPreBellatrixVersion(postStateVersion) {
 		return s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, root)
 	}
 	if err := helpers.BeaconBlockIsNil(blk); err != nil {
 		return err
 	}
 	body := blk.Block().Body()
-	enabled, err := blocks.ExecutionEnabled(postState, blk.Block().Body())
+	enabled, err := blocks.IsExecutionEnabledUsingHeader(postStateHeader, body)
 	if err != nil {
 		return errors.Wrap(err, "could not determine if execution is enabled")
 	}
@@ -119,7 +112,7 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int, hea
 		switch err {
 		case v1.ErrAcceptedSyncingPayloadStatus:
 			log.WithFields(logrus.Fields{
-				"slot":      postState.Slot(),
+				"slot":      blk.Block().Slot(),
 				"blockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
 			}).Info("Called new payload with optimistic block")
 			return nil
@@ -133,12 +126,12 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int, hea
 	}
 
 	// During the transition event, the transition block should be verified for sanity.
-	if isPreBellatrix(preStateVersion) {
+	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)
 	}
-	atTransition, err := blocks.IsMergeTransitionBlockUsingPayloadHeader(header, body)
+	atTransition, err := blocks.IsMergeTransitionBlockUsingPreStatePayloadHeader(preStateHeader, body)
 	if err != nil {
 		return errors.Wrap(err, "could not check if merge block is terminal")
 	}
@@ -148,11 +141,6 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int, hea
 	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:
@@ -181,7 +169,7 @@ func (s *Service) optimisticCandidateBlock(ctx context.Context, blk block.Beacon
 		return false, errNilParentInDB
 	}
 
-	parentIsExecutionBlock, err := blocks.ExecutionBlock(parent.Block().Body())
+	parentIsExecutionBlock, err := blocks.IsExecutionBlock(parent.Block().Body())
 	if err != nil {
 		return false, err
 	}
@@ -197,5 +185,5 @@ func (s *Service) optimisticCandidateBlock(ctx context.Context, blk block.Beacon
 	if err != nil {
 		return false, err
 	}
-	return blocks.ExecutionBlock(jBlock.Block().Body())
+	return blocks.IsExecutionBlock(jBlock.Block().Body())
 }

beacon-chain/blockchain/optimistic_sync_test.go

@@ -5,6 +5,7 @@ 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"
@@ -18,6 +19,7 @@ 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"
@@ -218,11 +220,6 @@ 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,
@@ -348,7 +345,9 @@ func Test_NotifyNewPayload(t *testing.T) {
 			}
 			root := [32]byte{'a'}
 			require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(ctx, 0, root, root, params.BeaconConfig().ZeroHash, 0, 0))
-			err = service.notifyNewPayload(ctx, tt.preState.Version(), payload, tt.postState, tt.blk, root)
+			postVersion, postHeader, err := getStateVersionAndPayload(tt.postState)
+			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 {
@@ -398,7 +397,9 @@ func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) {
 	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))
-	err = service.notifyNewPayload(ctx, bellatrixState.Version(), payload, bellatrixState, bellatrixBlk, root)
+	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)
@@ -425,7 +426,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 	service.genesisTime = time.Now().Add(-time.Second * 12 * 2 * 128)
 
 	parentBlk := util.NewBeaconBlockBellatrix()
-	wrappedParentBlock, err := wrapper.WrappedBellatrixSignedBeaconBlock(parentBlk)
+	wrappedParentBlock, err := wrapper.WrappedSignedBeaconBlock(parentBlk)
 	require.NoError(t, err)
 	parentRoot, err := wrappedParentBlock.Block().HashTreeRoot()
 	require.NoError(t, err)
@@ -450,7 +451,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 32
 				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -470,7 +471,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				blk := util.NewBeaconBlockAltair()
 				blk.Block.Slot = 32
 				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedAltairSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -490,7 +491,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 32
 				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -518,7 +519,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.WrappedBellatrixSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -573,7 +574,7 @@ func Test_IsOptimisticShallowExecutionParent(t *testing.T) {
 	block := &ethpb.BeaconBlockBellatrix{Body: body, Slot: 200}
 	rawSigned := &ethpb.SignedBeaconBlockBellatrix{Block: block}
 	blk := util.HydrateSignedBeaconBlockBellatrix(rawSigned)
-	wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk)
+	wr, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wr))
 	blkRoot, err := wr.Block().HashTreeRoot()
@@ -583,10 +584,109 @@ func Test_IsOptimisticShallowExecutionParent(t *testing.T) {
 	childBlock.Block.ParentRoot = blkRoot[:]
 	// shallow block
 	childBlock.Block.Slot = 201
-	wrappedChild, err := wrapper.WrappedBellatrixSignedBeaconBlock(childBlock)
+	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,13 +39,17 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 
 	BlkWithOutState := util.NewBeaconBlock()
 	BlkWithOutState.Block.Slot = 0
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithOutState)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(BlkWithOutState)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
 	require.NoError(t, err)
 
 	BlkWithStateBadAtt := util.NewBeaconBlock()
 	BlkWithStateBadAtt.Block.Slot = 1
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithStateBadAtt)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithStateBadAtt)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -56,7 +60,9 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 
 	BlkWithValidState := util.NewBeaconBlock()
 	BlkWithValidState.Block.Slot = 2
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithValidState)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -145,13 +151,17 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
 
 	BlkWithOutState := util.NewBeaconBlock()
 	BlkWithOutState.Block.Slot = 0
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithOutState)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(BlkWithOutState)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
 	require.NoError(t, err)
 
 	BlkWithStateBadAtt := util.NewBeaconBlock()
 	BlkWithStateBadAtt.Block.Slot = 1
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithStateBadAtt)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithStateBadAtt)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -162,7 +172,9 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
 
 	BlkWithValidState := util.NewBeaconBlock()
 	BlkWithValidState.Block.Slot = 2
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithValidState)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -438,7 +450,9 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	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)
 	d := &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: r[:]}
@@ -455,7 +469,9 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	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)
 	d := &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: r[:]}
@@ -478,7 +494,9 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -486,7 +504,9 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -509,7 +529,9 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -517,7 +539,9 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -534,7 +558,9 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -543,7 +569,9 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 

beacon-chain/blockchain/process_block.go

@@ -6,11 +6,13 @@ 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"
@@ -110,15 +112,23 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState, false /* reg sync */); err != nil {
 		return err
 	}
-	if err := s.notifyNewPayload(ctx, preStateVersion, preStateHeader, postState, signed, blockRoot); err != nil {
+	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.
-	if err := s.cfg.ForkChoiceStore.BoostProposerRoot(
-		ctx, signed.Block().Slot(), blockRoot, s.genesisTime,
-	); err != nil {
+	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 {
 		return err
 	}
 
@@ -228,14 +238,19 @@ 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(),
+					Epoch:               postState.FinalizedCheckpoint().Epoch,
+					Block:               postState.FinalizedCheckpoint().Root,
+					State:               signed.Block().StateRoot(),
+					ExecutionOptimistic: isOptimistic,
 				},
 			})
 
@@ -256,14 +271,17 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 	return s.handleEpochBoundary(ctx, postState)
 }
 
-func getStateVersionAndPayload(preState state.BeaconState) (int, *ethpb.ExecutionPayloadHeader, error) {
+func getStateVersionAndPayload(st state.BeaconState) (int, *ethpb.ExecutionPayloadHeader, error) {
+	if st == nil {
+		return 0, nil, errors.New("nil state")
+	}
 	var preStateHeader *ethpb.ExecutionPayloadHeader
 	var err error
-	preStateVersion := preState.Version()
+	preStateVersion := st.Version()
 	switch preStateVersion {
 	case version.Phase0, version.Altair:
 	default:
-		preStateHeader, err = preState.LatestExecutionPayloadHeader()
+		preStateHeader, err = st.LatestExecutionPayloadHeader()
 		if err != nil {
 			return 0, nil, err
 		}
@@ -308,9 +326,24 @@ 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
@@ -321,6 +354,15 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 		}
 		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()
@@ -333,22 +375,23 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 
 	// blocks have been verified, add them to forkchoice and call the engine
 	for i, b := range blks {
-		preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
-		if err != nil {
-			return nil, nil, err
-		}
-
 		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, preStateVersion, preStateHeader, preState, b, blockRoots[i]); err != nil {
+		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
@@ -498,7 +541,7 @@ func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk block.Be
 
 func getBlockPayloadHash(blk block.BeaconBlock) ([32]byte, error) {
 	payloadHash := [32]byte{}
-	if isPreBellatrix(blk.Version()) {
+	if blocks.IsPreBellatrixVersion(blk.Version()) {
 		return payloadHash, nil
 	}
 	payload, err := blk.Body().ExecutionPayload()

beacon-chain/blockchain/process_block_helpers.go

@@ -247,10 +247,19 @@ 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
 }
 

beacon-chain/blockchain/process_block_test.go

@@ -18,6 +18,7 @@ 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"
@@ -50,7 +51,9 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -61,7 +64,9 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 	random := util.NewBeaconBlock()
 	random.Block.Slot = 1
 	random.Block.ParentRoot = validGenesisRoot[:]
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(random)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(random)
+	require.NoError(t, err)
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	randomParentRoot, err := random.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
@@ -126,7 +131,9 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
 
 			root, err := tt.blk.Block.HashTreeRoot()
 			assert.NoError(t, err)
-			err = service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.blk), root)
+			wsb, err = wrapper.WrappedSignedBeaconBlock(tt.blk)
+			require.NoError(t, err)
+			err = service.onBlock(ctx, wsb, root)
 			assert.ErrorContains(t, tt.wantErrString, err)
 		})
 	}
@@ -147,7 +154,9 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -158,7 +167,9 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
 	random := util.NewBeaconBlock()
 	random.Block.Slot = 1
 	random.Block.ParentRoot = validGenesisRoot[:]
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(random)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(random)
+	require.NoError(t, err)
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	randomParentRoot, err := random.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
@@ -223,7 +234,9 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
 
 			root, err := tt.blk.Block.HashTreeRoot()
 			assert.NoError(t, err)
-			err = service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.blk), root)
+			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.blk)
+			require.NoError(t, err)
+			err = service.onBlock(ctx, wsb, root)
 			assert.ErrorContains(t, tt.wantErrString, err)
 		})
 	}
@@ -241,7 +254,13 @@ func TestStore_OnBlock_ProposerBoostEarly(t *testing.T) {
 
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.BoostProposerRoot(ctx, 0, [32]byte{'A'}, time.Now()))
+	args := &forkchoicetypes.ProposerBoostRootArgs{
+		BlockRoot:       [32]byte{'A'},
+		BlockSlot:       types.Slot(0),
+		CurrentSlot:     0,
+		SecondsIntoSlot: 0,
+	}
+	require.NoError(t, service.cfg.ForkChoiceStore.BoostProposerRoot(ctx, args))
 	_, 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)
@@ -260,13 +279,17 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	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 = protoarray.New(0, 0, [32]byte{})
-	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	service.saveInitSyncBlock(gRoot, wsb)
 
 	st, keys := util.DeterministicGenesisState(t, 64)
 
@@ -278,15 +301,21 @@ 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)
-		bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		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, wrapper.WrappedPhase0SignedBeaconBlock(b))
-		blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		wsb, err = wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		service.saveInitSyncBlock(root, wsb)
+		wsb, err = wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		blks = append(blks, wsb)
 		blkRoots = append(blkRoots, root)
 	}
 
@@ -314,13 +343,17 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	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, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	service.saveInitSyncBlock(gRoot, wsb)
 
 	st, keys := util.DeterministicGenesisState(t, 64)
 
@@ -332,15 +365,21 @@ 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)
-		bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		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, wrapper.WrappedPhase0SignedBeaconBlock(b))
-		blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		service.saveInitSyncBlock(root, wsb)
+		wsb, err = wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		blks = append(blks, wsb)
 		blkRoots = append(blkRoots, root)
 	}
 
@@ -366,12 +405,14 @@ func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	genesis := blocks.NewGenesisBlock(params.BeaconConfig().ZeroHash[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	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, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
+	service.saveInitSyncBlock(gRoot, wsb)
 	st, keys := util.DeterministicGenesisState(t, 64)
 	bState := st.Copy()
 
@@ -382,15 +423,17 @@ func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
 	for i := 1; i <= blkCount; i++ {
 		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
 		require.NoError(t, err)
-		bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		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, wrapper.WrappedPhase0SignedBeaconBlock(b))
-		blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		service.saveInitSyncBlock(root, wsb)
+		blks = append(blks, wsb)
 		blkRoots = append(blkRoots, root)
 	}
 
@@ -427,8 +470,12 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk)))
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk)))
+	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))
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
@@ -455,8 +502,12 @@ func TestShouldUpdateJustified_ReturnFalse_ProtoArray(t *testing.T) {
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk)))
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk)))
+	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))
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
@@ -484,8 +535,12 @@ func TestShouldUpdateJustified_ReturnFalse_DoublyLinkedTree(t *testing.T) {
 	newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
 	newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk)))
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk)))
+	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))
 
 	diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
 	service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
@@ -512,12 +567,16 @@ func TestCachedPreState_CanGetFromStateSummary_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	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 = protoarray.New(0, 0, [32]byte{})
-	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	service.saveInitSyncBlock(gRoot, wsb)
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
@@ -543,12 +602,16 @@ func TestCachedPreState_CanGetFromStateSummary_DoublyLinkedTree(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	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, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	service.saveInitSyncBlock(gRoot, wsb)
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
@@ -571,12 +634,16 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	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 = protoarray.New(0, 0, [32]byte{})
-	service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	service.saveInitSyncBlock(gRoot, wsb)
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
@@ -590,7 +657,9 @@ 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))
-	require.NoError(t, service.verifyBlkPreState(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b).Block()))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, service.verifyBlkPreState(ctx, wsb.Block()))
 }
 
 func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
@@ -606,7 +675,9 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
 	require.NoError(t, err)
 
 	signedBlock := util.NewBeaconBlock()
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(signedBlock)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(signedBlock)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	r, err := signedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: []byte{'A'}})
@@ -645,7 +716,9 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -656,12 +729,14 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	block := util.NewBeaconBlock()
-	block.Block.Slot = 9
-	block.Block.ParentRoot = roots[8]
+	blk := util.NewBeaconBlock()
+	blk.Block.Slot = 9
+	blk.Block.ParentRoot = roots[8]
+	wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
+	require.NoError(t, err)
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -686,7 +761,9 @@ func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -697,12 +774,15 @@ func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	block := util.NewBeaconBlock()
-	block.Block.Slot = 9
-	block.Block.ParentRoot = roots[8]
+	blk := util.NewBeaconBlock()
+	blk.Block.Slot = 9
+	blk.Block.ParentRoot = roots[8]
+
+	wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
+	require.NoError(t, err)
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -727,7 +807,9 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -738,12 +820,15 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	block := util.NewBeaconBlock()
-	block.Block.Slot = 9
-	block.Block.ParentRoot = roots[8]
+	blk := util.NewBeaconBlock()
+	blk.Block.Slot = 9
+	blk.Block.ParentRoot = roots[8]
+
+	wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
+	require.NoError(t, err)
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -771,7 +856,9 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -782,12 +869,15 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
-	block := util.NewBeaconBlock()
-	block.Block.Slot = 9
-	block.Block.ParentRoot = roots[8]
+	blk := util.NewBeaconBlock()
+	blk.Block.Slot = 9
+	blk.Block.ParentRoot = roots[8]
+
+	wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
+	require.NoError(t, err)
 
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -816,7 +906,9 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -827,23 +919,29 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
 	// Define a tree branch, slot 63 <- 64 <- 65
 	b63 := util.NewBeaconBlock()
 	b63.Block.Slot = 63
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b63)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b63)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r63, err := b63.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b64 := util.NewBeaconBlock()
 	b64.Block.Slot = 64
 	b64.Block.ParentRoot = r63[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b64)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b64)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r64, err := b64.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b65 := util.NewBeaconBlock()
 	b65.Block.Slot = 65
 	b65.Block.ParentRoot = r64[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b65)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b65)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b65).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// There should be 2 nodes, block 65 and block 64.
@@ -869,7 +967,9 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing
 
 	genesisStateRoot := [32]byte{}
 	genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
-	assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	validGenesisRoot, err := genesis.Block.HashTreeRoot()
 	assert.NoError(t, err)
 	st, err := util.NewBeaconState()
@@ -880,23 +980,29 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing
 	// Define a tree branch, slot 63 <- 64 <- 65
 	b63 := util.NewBeaconBlock()
 	b63.Block.Slot = 63
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b63)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b63)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r63, err := b63.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b64 := util.NewBeaconBlock()
 	b64.Block.Slot = 64
 	b64.Block.ParentRoot = r63[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b64)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b64)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r64, err := b64.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b65 := util.NewBeaconBlock()
 	b65.Block.Slot = 65
 	b65.Block.ParentRoot = r64[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b65)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b65)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 
 	beaconState, _ := util.DeterministicGenesisState(t, 32)
 	err = service.fillInForkChoiceMissingBlocks(
-		context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b65).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
+		context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
 	require.NoError(t, err)
 
 	// There should be 2 nodes, block 65 and block 64.
@@ -976,7 +1082,9 @@ 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)
-		if err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)); err != nil {
+		wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
+		require.NoError(t, err)
+		if err := beaconDB.SaveBlock(context.Background(), wsb); err != nil {
 			return nil, err
 		}
 		if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
@@ -1044,7 +1152,9 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
 		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
-		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
 	}
 
 	// Slots 100 to 200 are skip slots. Requesting root at 150 will yield root at 100. The last physical block.
@@ -1131,7 +1241,9 @@ func TestAncestor_CanUseDB(t *testing.T) {
 		beaconBlock := util.NewBeaconBlock()
 		beaconBlock.Block.Slot = b.Block.Slot
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
-		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock))) // Saves blocks to DB.
+		wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb)) // Saves blocks to DB.
 	}
 
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, 0, 0))
@@ -1171,14 +1283,18 @@ func TestVerifyBlkDescendant(t *testing.T) {
 	b.Block.Slot = 1
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	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)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b1)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	type args struct {
 		parentRoot    [32]byte
@@ -1242,7 +1358,9 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
 	gBlk := util.NewBeaconBlock()
 	gRoot, err := gBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(gBlk)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(gBlk)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	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)
@@ -1318,7 +1436,9 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 		require.NoError(t, err)
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
+		require.NoError(t, err)
+		require.NoError(t, service.onBlock(ctx, wsb, r))
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -1370,7 +1490,9 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 		require.NoError(t, err)
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		require.NoError(t, service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
+		require.NoError(t, err)
+		require.NoError(t, service.onBlock(ctx, wsb, r))
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -1434,7 +1556,9 @@ func TestRemoveBlockAttestationsInPool_Canonical(t *testing.T) {
 
 	atts := b.Block.Body.Attestations
 	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
-	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wsb))
 	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
 }
 
@@ -1456,7 +1580,9 @@ func TestRemoveBlockAttestationsInPool_NonCanonical(t *testing.T) {
 
 	atts := b.Block.Body.Attestations
 	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
-	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wsb))
 	require.Equal(t, 1, service.cfg.AttPool.AggregatedAttestationCount())
 }
 

beacon-chain/blockchain/receive_attestation_test.go

@@ -47,13 +47,17 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -74,13 +78,17 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 
 	b32 := util.NewBeaconBlock()
 	b32.Block.Slot = 32
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r32, err := b32.Block.HashTreeRoot()
 	require.NoError(t, err)
 	b33 := util.NewBeaconBlock()
 	b33.Block.Slot = 33
 	b33.Block.ParentRoot = r32[:]
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
 
@@ -137,15 +145,16 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 	hook.Reset()
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
-	wr := wrapper.WrappedPhase0SignedBeaconBlock(b)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wr))
+	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: wr,
+		block: wsb,
 	}
 	service.store.SetFinalizedCheckpt(finalized)
 	service.notifyEngineIfChangedHead([32]byte{'b'})

beacon-chain/blockchain/receive_block_test.go

@@ -144,7 +144,9 @@ func TestService_ReceiveBlock(t *testing.T) {
 			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
-			err = s.ReceiveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block), root)
+			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
+			require.NoError(t, err)
+			err = s.ReceiveBlock(ctx, wsb, root)
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
@@ -185,7 +187,9 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	go func() {
-		require.NoError(t, s.ReceiveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b), root))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		require.NoError(t, s.ReceiveBlock(ctx, wsb, root))
 		wg.Done()
 	}()
 	wg.Wait()
@@ -261,7 +265,9 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
-			blks := []block.SignedBeaconBlock{wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block)}
+			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
+			require.NoError(t, err)
+			blks := []block.SignedBeaconBlock{wsb}
 			roots := [][32]byte{root}
 			err = s.ReceiveBlockBatch(ctx, blks, roots)
 			if tt.wantedErr != "" {
@@ -283,7 +289,9 @@ func TestService_HasInitSyncBlock(t *testing.T) {
 	if s.HasInitSyncBlock(r) {
 		t.Error("Should not have block")
 	}
-	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
+	require.NoError(t, err)
+	s.saveInitSyncBlock(r, wsb)
 	if !s.HasInitSyncBlock(r) {
 		t.Error("Should have block")
 	}

beacon-chain/blockchain/service.go

@@ -257,7 +257,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.OriginBlockRoot(ctx)
+	originRoot, err := s.cfg.BeaconDB.OriginCheckpointBlockRoot(ctx)
 	if err == nil {
 		return originRoot, nil
 	}
@@ -265,7 +265,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 OriginBlockRoot gave us an ErrNotFound. this means the node was started from a genesis state,
+	// we got here because OriginCheckpointBlockRoot 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 {

beacon-chain/blockchain/service_test.go

@@ -144,7 +144,9 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(1))
@@ -179,12 +181,14 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	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, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
+	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
@@ -250,7 +254,9 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
 	genesisBlk := util.NewBeaconBlock()
 	blkRoot, err := genesisBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	s, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.SetSlot(0))
@@ -277,7 +283,9 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
 	headBlock := util.NewBeaconBlock()
@@ -291,7 +299,9 @@ 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))
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	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)
@@ -323,7 +333,9 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
 	headBlock := util.NewBeaconBlock()
@@ -337,7 +349,9 @@ 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))
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	attSrv, err := attestations.NewService(ctx, &attestations.Config{})
 	require.NoError(t, err)
 	ss := &ethpb.StateSummary{
@@ -376,14 +390,18 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	genesisRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	finalizedBlock := util.NewBeaconBlock()
 	finalizedBlock.Block.Slot = finalizedSlot
 	finalizedBlock.Block.ParentRoot = genesisRoot[:]
 	finalizedRoot, err := finalizedBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(finalizedBlock)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(finalizedBlock)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	// Set head slot close to the finalization point, no head sync is triggered.
 	headBlock := util.NewBeaconBlock()
@@ -391,7 +409,9 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err := headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
@@ -426,7 +446,9 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	headBlock.Block.ParentRoot = finalizedRoot[:]
 	headRoot, err = headBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
 
@@ -455,7 +477,9 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	newState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.StateGen.SaveState(ctx, r, newState))
-	require.NoError(t, s.saveHeadNoDB(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r, newState))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	require.NoError(t, s.saveHeadNoDB(ctx, wsb, r, newState))
 
 	newB, err := s.cfg.BeaconDB.HeadBlock(ctx)
 	require.NoError(t, err)
@@ -477,7 +501,9 @@ func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.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")
@@ -496,7 +522,9 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.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")
@@ -514,7 +542,9 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 	block := util.NewBeaconBlock()
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(t, err)
-	s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	s.saveInitSyncBlock(r, wsb)
 	require.NoError(t, s.Stop())
 	require.Equal(t, true, s.cfg.BeaconDB.HasBlock(ctx, r))
 }
@@ -540,7 +570,9 @@ func BenchmarkHasBlockDB(b *testing.B) {
 		cfg: &config{BeaconDB: beaconDB},
 	}
 	block := util.NewBeaconBlock()
-	require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(b, err)
+	require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r, err := block.Block.HashTreeRoot()
 	require.NoError(b, err)
 
@@ -558,13 +590,15 @@ func BenchmarkHasBlockForkChoiceStore_ProtoArray(b *testing.B) {
 		store: &store.Store{},
 	}
 	s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
-	block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
-	r, err := block.Block.HashTreeRoot()
+	blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
+	r, err := blk.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)
-	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
+	require.NoError(b, err)
+	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -585,7 +619,9 @@ 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)
-	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(b, err)
+	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

beacon-chain/blockchain/weak_subjectivity_checks.go

@@ -36,6 +36,7 @@ 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
@@ -79,15 +80,17 @@ 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))
 	}
-	filter := filters.NewFilter().SetStartSlot(v.slot).SetEndSlot(v.slot + params.BeaconConfig().SlotsPerEpoch)
+	endSlot := v.slot + params.BeaconConfig().SlotsPerEpoch
+	filter := filters.NewFilter().SetStartSlot(v.slot).SetEndSlot(endSlot)
 	// 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,58 +14,65 @@ 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 = 32
-	require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b)))
+	b.Block.Slot = 1792480
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
 	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",
-		},
-		{
-			name:           "already verified",
-			checkpt:        &ethpb.Checkpoint{Epoch: 2},
-			finalizedEpoch: 2,
-			wsVerified:     true,
+			name:     "nil root and epoch",
+			disabled: true,
 		},
 		{
 			name:           "not yet to verify, ws epoch higher than finalized epoch",
-			checkpt:        &ethpb.Checkpoint{Epoch: 2},
-			finalizedEpoch: 1,
+			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, 32), Epoch: blockEpoch},
+			finalizedEpoch: blockEpoch - 1,
 		},
 		{
 			name:           "can't find the block in DB",
 			checkpt:        &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength), Epoch: 1},
-			finalizedEpoch: 3,
+			finalizedEpoch: blockEpoch + 1,
 			wantErr:        errWSBlockNotFound,
 		},
 		{
 			name:           "can't find the block corresponds to ws epoch in DB",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 2}, // Root belongs in epoch 1.
-			finalizedEpoch: 3,
+			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch - 2}, // Root belongs in epoch 1.
+			finalizedEpoch: blockEpoch - 1,
 			wantErr:        errWSBlockNotFoundInEpoch,
 		},
 		{
 			name:           "can verify and pass",
-			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: 1},
-			finalizedEpoch: 3,
+			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch},
+			finalizedEpoch: blockEpoch + 1,
+		},
+		{
+			name:           "equal epoch",
+			checkpt:        &ethpb.Checkpoint{Root: r[:], Epoch: blockEpoch},
+			finalizedEpoch: blockEpoch,
 		},
 	}
 	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/core/altair/attestation_test.go

@@ -48,7 +48,7 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 		params.BeaconConfig().MinAttestationInclusionDelay,
 		beaconState.Slot(),
 	)
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(b)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(b)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(b)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(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,6 +45,7 @@ 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,7 +42,9 @@ func TestFuzzProcessBlockHeader_10000(t *testing.T) {
 
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		_, err = ProcessBlockHeader(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(block))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+		require.NoError(t, err)
+		_, err = ProcessBlockHeader(context.Background(), s, wsb)
 		_ = err
 	}
 }
@@ -141,7 +143,9 @@ func TestFuzzProcessRandao_10000(t *testing.T) {
 		fuzzer.Fuzz(b)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		r, err := ProcessRandao(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		r, err := ProcessRandao(context.Background(), s, wsb)
 		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)
 		}
@@ -260,7 +264,9 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 		fuzzer.Fuzz(b)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		r, err := ProcessAttestationsNoVerifySignature(ctx, s, wrapper.WrappedPhase0SignedBeaconBlock(b))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
+		r, err := ProcessAttestationsNoVerifySignature(ctx, s, wsb)
 		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,7 +68,9 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
 
-	_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	assert.ErrorContains(t, "block.Slot 10 must be greater than state.LatestBlockHeader.Slot 10", err)
 }
 
@@ -94,7 +96,9 @@ 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)
 
-	_, err = blocks.ProcessBlockHeader(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	_, err = blocks.ProcessBlockHeader(context.Background(), beaconState, wsb)
 	want := "signature did not verify"
 	assert.ErrorContains(t, want, err)
 }
@@ -136,7 +140,9 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 		Signature: blockSig,
 	})
 
-	_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	want := "is different than block slot"
 	assert.ErrorContains(t, want, err)
 }
@@ -175,7 +181,9 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 	block.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, 32)
 	block.Signature = blockSig
 
-	_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	want := "does not match"
 	assert.ErrorContains(t, want, err)
 }
@@ -217,7 +225,9 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 	block.Block.ParentRoot = parentRoot[:]
 	block.Signature = blockSig
 
-	_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	want := "was previously slashed"
 	assert.ErrorContains(t, want, err)
 }
@@ -266,7 +276,9 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
 
-	newState, err := blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	newState, err := blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	require.NoError(t, err, "Failed to process block header got")
 	var zeroHash [32]byte
 	nsh := newState.LatestBlockHeader()

beacon-chain/core/blocks/payload.go

@@ -2,7 +2,6 @@ package blocks
 
 import (
 	"bytes"
-	"strings"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -14,86 +13,96 @@ 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"
 )
 
-// MergeTransitionComplete returns true if the transition to Bellatrix has completed.
+// IsMergeTransitionComplete 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()
-//
-// Deprecated: Use `IsMergeTransitionBlockUsingPayloadHeader` instead.
-func MergeTransitionComplete(st state.BeaconState) (bool, error) {
+func IsMergeTransitionComplete(st state.BeaconState) (bool, error) {
+	if st == nil {
+		return false, errors.New("nil state")
+	}
+	if IsPreBellatrixVersion(st.Version()) {
+		return false, nil
+	}
 	h, err := st.LatestExecutionPayloadHeader()
 	if err != nil {
 		return false, err
 	}
-
 	return !isEmptyHeader(h), nil
 }
 
-// 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.
+// IsMergeTransitionBlockUsingPreStatePayloadHeader 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) {
+// 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")
+	}
 	if !isEmptyHeader(h) {
 		return false, nil
 	}
-	return ExecutionBlock(body)
+	return IsExecutionBlock(body)
 }
 
-// ExecutionBlock returns whether the block has a non-empty ExecutionPayload.
+// IsExecutionBlock returns whether the block has a non-empty ExecutionPayload.
 //
 // Spec code:
 // def is_execution_block(block: BeaconBlock) -> bool:
 //     return block.body.execution_payload != ExecutionPayload()
-func ExecutionBlock(body block.BeaconBlockBody) (bool, error) {
+func IsExecutionBlock(body block.BeaconBlockBody) (bool, error) {
+	if body == nil {
+		return false, errors.New("nil block body")
+	}
 	payload, err := body.ExecutionPayload()
-	if err != nil {
-		if strings.HasPrefix(err.Error(), "ExecutionPayload is not supported in") {
-			return false, nil
-		}
+	switch {
+	case errors.Is(err, wrapper.ErrUnsupportedField):
+		return false, nil
+	case err != nil:
 		return false, err
+	default:
 	}
 	return !isEmptyPayload(payload), nil
 }
 
-// ExecutionEnabled returns true if the beacon chain can begin executing.
+// IsExecutionEnabled 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 ExecutionEnabled(st state.BeaconState, body block.BeaconBlockBody) (bool, error) {
-	mergeBlock, err := MergeTransitionBlock(st, body)
+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()
 	if err != nil {
 		return false, err
 	}
-	if mergeBlock {
+	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) {
 		return true, nil
 	}
-	return MergeTransitionComplete(st)
+	return IsExecutionBlock(body)
+}
+
+// IsPreBellatrixVersion returns true if input version is before bellatrix fork.
+func IsPreBellatrixVersion(v int) bool {
+	return v < version.Bellatrix
 }
 
 // ValidatePayloadWhenMergeCompletes validates if payload is valid versus input beacon state.
@@ -104,7 +113,7 @@ func ExecutionEnabled(st state.BeaconState, body block.BeaconBlockBody) (bool, e
 //    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 := MergeTransitionComplete(st)
+	complete, err := IsMergeTransitionComplete(st)
 	if err != nil {
 		return err
 	}
@@ -226,6 +235,9 @@ 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_MergeComplete(t *testing.T) {
+func Test_IsMergeComplete(t *testing.T) {
 	tests := []struct {
 		name    string
 		payload *ethpb.ExecutionPayloadHeader
@@ -160,7 +160,7 @@ func Test_MergeComplete(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.MergeTransitionComplete(st)
+			got, err := blocks.IsMergeTransitionComplete(st)
 			require.NoError(t, err)
 			if got != tt.want {
 				t.Errorf("mergeComplete() got = %v, want %v", got, tt.want)
@@ -169,187 +169,6 @@ func Test_MergeComplete(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
@@ -520,7 +339,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.IsMergeTransitionBlockUsingPayloadHeader(tt.header, body)
+			got, err := blocks.IsMergeTransitionBlockUsingPreStatePayloadHeader(tt.header, body)
 			require.NoError(t, err)
 			if got != tt.want {
 				t.Errorf("MergeTransitionBlock() got = %v, want %v", got, tt.want)
@@ -556,20 +375,28 @@ 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.ExecutionBlock(wrappedBlock.Body())
+			got, err := blocks.IsExecutionBlock(wrappedBlock.Body())
 			require.NoError(t, err)
 			require.Equal(t, tt.want, got)
 		})
 	}
 }
 
-func Test_ExecutionEnabled(t *testing.T) {
+func Test_IsExecutionEnabled(t *testing.T) {
 	tests := []struct {
-		name    string
-		payload *enginev1.ExecutionPayload
-		header  *ethpb.ExecutionPayloadHeader
-		want    bool
+		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(),
@@ -619,10 +446,76 @@ func Test_ExecutionEnabled(t *testing.T) {
 			blk.Block.Body.ExecutionPayload = tt.payload
 			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
-			got, err := blocks.ExecutionEnabled(st, body)
+			if tt.useAltairSt {
+				st, _ = util.DeterministicGenesisStateAltair(t, 1)
+			}
+			got, err := blocks.IsExecutionEnabled(st, body)
 			require.NoError(t, err)
 			if got != tt.want {
-				t.Errorf("ExecutionEnabled() got = %v, want %v", got, tt.want)
+				t.Errorf("IsExecutionEnabled() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_IsExecutionEnabledUsingHeader(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: 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) {
+			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)
+			require.NoError(t, err)
+			if got != tt.want {
+				t.Errorf("IsExecutionEnabled() got = %v, want %v", got, tt.want)
 			}
 		})
 	}
@@ -830,7 +723,7 @@ func BenchmarkBellatrixComplete(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_, err := blocks.MergeTransitionComplete(st)
+		_, err := blocks.IsMergeTransitionComplete(st)
 		require.NoError(b, err)
 	}
 }

beacon-chain/core/blocks/randao_test.go

@@ -40,7 +40,9 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	}
 
 	want := "block randao: signature did not verify"
-	_, err = blocks.ProcessRandao(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	_, err = blocks.ProcessRandao(context.Background(), beaconState, wsb)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -57,11 +59,12 @@ func TestProcessRandao_SignatureVerifiesAndUpdatesLatestStateMixes(t *testing.T)
 			RandaoReveal: epochSignature,
 		},
 	}
-
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
 	newState, err := blocks.ProcessRandao(
 		context.Background(),
 		beaconState,
-		wrapper.WrappedPhase0SignedBeaconBlock(b),
+		wsb,
 	)
 	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.WrappedAltairSignedBeaconBlock(altairBlk)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(altairBlk)
 	require.NoError(t, err)
 	assert.NoError(t, blocks.VerifyBlockSignatureUsingCurrentFork(bState, wsb))
 }

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

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

beacon-chain/core/helpers/weak_subjectivity.go

@@ -55,9 +55,9 @@ import (
 //        )
 //
 //    return ws_period
-func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconState) (types.Epoch, error) {
+func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconState, cfg *params.BeaconChainConfig) (types.Epoch, error) {
 	// Weak subjectivity period cannot be smaller than withdrawal delay.
-	wsp := uint64(params.BeaconConfig().MinValidatorWithdrawabilityDelay)
+	wsp := uint64(cfg.MinValidatorWithdrawabilityDelay)
 
 	// Cardinality of active validator set.
 	N, err := ActiveValidatorCount(ctx, st, time.CurrentEpoch(st))
@@ -73,10 +73,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 / params.BeaconConfig().GweiPerEth
+	t = t / N / cfg.GweiPerEth
 
 	// Maximum effective balance per validator.
-	T := params.BeaconConfig().MaxEffectiveBalance / params.BeaconConfig().GweiPerEth
+	T := cfg.MaxEffectiveBalance / cfg.GweiPerEth
 
 	// Validator churn limit.
 	delta, err := ValidatorChurnLimit(N)
@@ -85,14 +85,14 @@ func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconS
 	}
 
 	// Balance top-ups.
-	Delta := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().MaxDeposits))
+	Delta := uint64(cfg.SlotsPerEpoch.Mul(cfg.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 := params.BeaconConfig().SafetyDecay
+	D := cfg.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,7 +123,7 @@ 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) (bool, error) {
+	ctx context.Context, currentEpoch types.Epoch, wsState state.ReadOnlyBeaconState, wsStateRoot [fieldparams.RootLength]byte, wsEpoch types.Epoch, cfg *params.BeaconChainConfig) (bool, error) {
 	// Make sure that incoming objects are not nil.
 	if wsState == nil || wsState.IsNil() || wsState.LatestBlockHeader() == nil {
 		return false, errors.New("invalid weak subjectivity state or checkpoint")
@@ -140,7 +140,7 @@ func IsWithinWeakSubjectivityPeriod(
 	}
 
 	// Compare given epoch to state epoch + weak subjectivity period.
-	wsPeriod, err := ComputeWeakSubjectivityPeriod(ctx, wsState)
+	wsPeriod, err := ComputeWeakSubjectivityPeriod(ctx, wsState, cfg)
 	if err != nil {
 		return false, fmt.Errorf("cannot compute weak subjectivity period: %w", err)
 	}
@@ -154,8 +154,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) (types.Epoch, error) {
-	wsPeriod, err := ComputeWeakSubjectivityPeriod(ctx, st)
+func LatestWeakSubjectivityEpoch(ctx context.Context, st state.ReadOnlyBeaconState, cfg *params.BeaconChainConfig) (types.Epoch, error) {
+	wsPeriod, err := ComputeWeakSubjectivityPeriod(ctx, st, cfg)
 	if err != nil {
 		return 0, err
 	}

beacon-chain/core/helpers/weak_subjectivity_test.go

@@ -48,7 +48,7 @@ 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))
+			got, err := helpers.ComputeWeakSubjectivityPeriod(context.Background(), genState(t, tt.valCount, tt.avgBalance), params.BeaconConfig())
 			require.NoError(t, err)
 			assert.Equal(t, tt.want, got, "valCount: %v, avgBalance: %v", tt.valCount, tt.avgBalance)
 		})
@@ -178,7 +178,7 @@ func TestWeakSubjectivity_IsWithinWeakSubjectivityPeriod(t *testing.T) {
 	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)
+			got, err := helpers.IsWithinWeakSubjectivityPeriod(context.Background(), tt.epoch, tt.genWsState(), sr, e, params.BeaconConfig())
 			if tt.wantedErr != "" {
 				assert.Equal(t, false, got)
 				assert.ErrorContains(t, tt.wantedErr, err)

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.WrappedAltairSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(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.WrappedAltairSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedBellatrixSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedBellatrixSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(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.WrappedBellatrixSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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.WrappedBellatrixSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "could not validate state root", err)

beacon-chain/core/transition/benchmarks_test.go

@@ -29,7 +29,9 @@ func BenchmarkExecuteStateTransition_FullBlock(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_, err := coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wrapper.WrappedPhase0SignedBeaconBlock(block))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+		require.NoError(b, err)
+		_, err = coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wsb)
 		require.NoError(b, err)
 	}
 }
@@ -50,12 +52,16 @@ 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.
-	_, err = coreState.ExecuteStateTransition(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(b, err)
+	_, err = coreState.ExecuteStateTransition(context.Background(), beaconState, wsb)
 	require.NoError(b, err, "Failed to process block, benchmarks will fail")
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_, err := coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wrapper.WrappedPhase0SignedBeaconBlock(block))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+		require.NoError(b, err)
+		_, err = coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wsb)
 		require.NoError(b, err, "Failed to process block, benchmarks will fail")
 	}
 }

beacon-chain/core/transition/skip_slot_cache_test.go

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

beacon-chain/core/transition/transition_fuzz_test.go

@@ -25,7 +25,9 @@ func TestFuzzExecuteStateTransition_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(sb)
-		s, err := ExecuteStateTransition(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(sb))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
+		require.NoError(t, err)
+		s, err := ExecuteStateTransition(ctx, state, wsb)
 		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)
 		}
@@ -44,7 +46,9 @@ func TestFuzzCalculateStateRoot_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(sb)
-		stateRoot, err := CalculateStateRoot(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(sb))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
+		require.NoError(t, err)
+		stateRoot, err := CalculateStateRoot(ctx, state, wsb)
 		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)
 		}
@@ -99,7 +103,9 @@ func TestFuzzprocessOperationsNoVerify_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(bb)
-		s, err := ProcessOperationsNoVerifyAttsSigs(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(bb))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
+		require.NoError(t, err)
+		s, err := ProcessOperationsNoVerifyAttsSigs(ctx, state, wsb)
 		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)
 		}
@@ -117,7 +123,9 @@ func TestFuzzverifyOperationLengths_10000(t *testing.T) {
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(bb)
-		_, err := VerifyOperationLengths(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(bb))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
+		require.NoError(t, err)
+		_, err = VerifyOperationLengths(context.Background(), state, wsb)
 		_ = err
 	}
 }
@@ -164,7 +172,9 @@ func TestFuzzProcessBlockForStateRoot_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(sb)
-		s, err := ProcessBlockForStateRoot(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(sb))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
+		require.NoError(t, err)
+		s, err := ProcessBlockForStateRoot(ctx, state, wsb)
 		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,20 +285,18 @@ func ProcessBlockForStateRoot(
 		return nil, errors.Wrap(err, "could not process block header")
 	}
 
-	if state.Version() == version.Bellatrix {
-		enabled, err := b.ExecutionEnabled(state, blk.Body())
+	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 err != nil {
-			return nil, errors.Wrap(err, "could not check if execution is enabled")
+			return nil, err
 		}
-		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")
-			}
+		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,7 +52,9 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
 	block.Block.Body.RandaoReveal = randaoReveal
 	block.Block.Body.Eth1Data = eth1Data
 
-	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 
 	block.Block.StateRoot = stateRoot[:]
@@ -61,7 +63,9 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	assert.NoError(t, err)
 	verified, err := set.Verify()
 	assert.NoError(t, err)
@@ -104,7 +108,9 @@ func TestExecuteStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *test
 	block.Block.Body.RandaoReveal = randaoReveal
 	block.Block.Body.Eth1Data = eth1Data
 
-	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 
 	block.Block.StateRoot = stateRoot[:]
@@ -114,13 +120,17 @@ func TestExecuteStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *test
 	block.Signature = sig.Marshal()
 
 	block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
-	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "could not validate state root", err)
 }
 
 func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
 	beaconState, block, _, _, _ := createFullBlockWithOperations(t)
-	set, _, err := transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	set, _, err := transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 	// Test Signature set verifies.
 	verified, err := set.Verify()
@@ -130,7 +140,7 @@ func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
 
 func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
 	require.NoError(t, err)
@@ -143,7 +153,7 @@ func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) {
 
 func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
 	require.NoError(t, err)
@@ -153,7 +163,7 @@ func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
 
 func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) {
 	beaconState, block := createFullBellatrixBlockWithOperations(t)
-	wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
 	require.NoError(t, err)
@@ -163,7 +173,7 @@ func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) {
 
 func TestCalculateStateRootAltair_OK(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	r, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -173,7 +183,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.WrappedAltairSignedBeaconBlock(block) // Altair block
+	wsb, err := wrapper.WrappedSignedBeaconBlock(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,7 +44,9 @@ func TestExecuteStateTransition_IncorrectSlot(t *testing.T) {
 		},
 	}
 	want := "expected state.slot"
-	_, err = transition.ExecuteStateTransition(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	_, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -87,7 +89,9 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
 	block.Block.Body.RandaoReveal = randaoReveal
 	block.Block.Body.Eth1Data = eth1Data
 
-	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 
 	block.Block.StateRoot = stateRoot[:]
@@ -96,7 +100,9 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	beaconState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	beaconState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
 
 	assert.Equal(t, params.BeaconConfig().SlotsPerEpoch, beaconState.Slot(), "Unexpected Slot number")
@@ -183,7 +189,9 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 	cp.Root = []byte("hello-world")
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cp))
 	require.NoError(t, beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{}))
-	_, err = transition.VerifyOperationLengths(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), beaconState, wsb)
 	wanted := "number of voluntary exits (17) in block body exceeds allowed threshold of 16"
 	assert.ErrorContains(t, wanted, err)
 }
@@ -396,7 +404,9 @@ func TestProcessBlock_OverMaxProposerSlashings(t *testing.T) {
 		len(b.Block.Body.ProposerSlashings), params.BeaconConfig().MaxProposerSlashings)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -413,7 +423,9 @@ func TestProcessBlock_OverMaxAttesterSlashings(t *testing.T) {
 		len(b.Block.Body.AttesterSlashings), params.BeaconConfig().MaxAttesterSlashings)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -429,7 +441,9 @@ func TestProcessBlock_OverMaxAttestations(t *testing.T) {
 		len(b.Block.Body.Attestations), params.BeaconConfig().MaxAttestations)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -446,7 +460,9 @@ func TestProcessBlock_OverMaxVoluntaryExits(t *testing.T) {
 		len(b.Block.Body.VoluntaryExits), maxExits)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -466,7 +482,9 @@ 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))
-	_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+	require.NoError(t, err)
+	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
 	assert.ErrorContains(t, want, err)
 }
 

beacon-chain/db/errors.go

@@ -13,3 +13,9 @@ 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,6 +27,7 @@ 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)
@@ -53,7 +54,8 @@ type ReadOnlyDatabase interface {
 	// Fee reicipients operations.
 	FeeRecipientByValidatorID(ctx context.Context, id types.ValidatorIndex) (common.Address, error)
 	// origin checkpoint sync support
-	OriginBlockRoot(ctx context.Context) ([32]byte, error)
+	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
+	BackfillBlockRoot(ctx context.Context) ([32]byte, error)
 }
 
 // NoHeadAccessDatabase defines a struct without access to chain head data.
@@ -102,7 +104,8 @@ type HeadAccessDatabase interface {
 	EnsureEmbeddedGenesis(ctx context.Context) error
 
 	// initialization method needed for origin checkpoint sync
-	SaveOrigin(ctx context.Context, state io.Reader, block io.Reader) error
+	SaveOrigin(ctx context.Context, serState, serBlock []byte) error
+	SaveBackfillBlockRoot(ctx context.Context, blockRoot [32]byte) error
 }
 
 // SlasherDatabase interface for persisting data related to detecting slashable offenses on Ethereum.

beacon-chain/db/kv/backup_test.go

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

beacon-chain/db/kv/blocks.go

@@ -6,6 +6,7 @@ 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"
@@ -47,18 +48,18 @@ func (s *Store) Block(ctx context.Context, blockRoot [32]byte) (block.SignedBeac
 	return blk, err
 }
 
-// OriginBlockRoot returns the value written to the db in SaveOriginBlockRoot
+// OriginCheckpointBlockRoot returns the value written to the db in SaveOriginCheckpointBlockRoot
 // 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) OriginBlockRoot(ctx context.Context) ([32]byte, error) {
-	_, span := trace.StartSpan(ctx, "BeaconDB.OriginBlockRoot")
+func (s *Store) OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.OriginCheckpointBlockRoot")
 	defer span.End()
 
 	var root [32]byte
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blocksBucket)
-		rootSlice := bkt.Get(originBlockRootKey)
+		rootSlice := bkt.Get(originCheckpointBlockRootKey)
 		if rootSlice == nil {
 			return ErrNotFoundOriginBlockRoot
 		}
@@ -69,6 +70,25 @@ func (s *Store) OriginBlockRoot(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")
@@ -324,6 +344,22 @@ 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")
@@ -334,16 +370,27 @@ func (s *Store) SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) er
 	})
 }
 
-// SaveOriginBlockRoot is used to keep track of the block root used for origin sync.
+// SaveOriginCheckpointBlockRoot is used to keep track of the block root used for syncing from a checkpoint origin.
 // 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) SaveOriginBlockRoot(ctx context.Context, blockRoot [32]byte) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.SaveOriginBlockRoot")
+func (s *Store) SaveOriginCheckpointBlockRoot(ctx context.Context, blockRoot [32]byte) error {
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveOriginCheckpointBlockRoot")
 	defer span.End()
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(blocksBucket)
-		return bucket.Put(originBlockRootKey, blockRoot[:])
+		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[:])
 	})
 }
 
@@ -641,31 +688,27 @@ 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{}
-		err := rawBlock.UnmarshalSSZ(enc[len(altairKey):])
-		if err != nil {
+		rawBlock = &ethpb.SignedBeaconBlockAltair{}
+		if err := rawBlock.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
 			return nil, err
 		}
-		return wrapper.WrappedAltairSignedBeaconBlock(rawBlock)
 	case hasBellatrixKey(enc):
-		rawBlock := &ethpb.SignedBeaconBlockBellatrix{}
-		err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):])
-		if err != nil {
+		rawBlock = &ethpb.SignedBeaconBlockBellatrix{}
+		if err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):]); err != nil {
 			return nil, err
 		}
-		return wrapper.WrappedBellatrixSignedBeaconBlock(rawBlock)
 	default:
 		// Marshal block bytes to phase 0 beacon block.
-		rawBlock := &ethpb.SignedBeaconBlock{}
-		err = rawBlock.UnmarshalSSZ(enc)
-		if err != nil {
+		rawBlock = &ethpb.SignedBeaconBlock{}
+		if err := rawBlock.UnmarshalSSZ(enc); 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.WrappedPhase0SignedBeaconBlock(b), nil
+			return wrapper.WrappedSignedBeaconBlock(b)
 		},
 	},
 	{
@@ -42,7 +42,7 @@ var blockTests = []struct {
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return wrapper.WrappedAltairSignedBeaconBlock(b)
+			return wrapper.WrappedSignedBeaconBlock(b)
 		},
 	},
 	{
@@ -53,11 +53,28 @@ var blockTests = []struct {
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return wrapper.WrappedBellatrixSignedBeaconBlock(b)
+			return wrapper.WrappedSignedBeaconBlock(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)
@@ -212,7 +229,9 @@ func TestStore_GenesisBlock(t *testing.T) {
 	blockRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, db.SaveGenesisBlockRoot(ctx, blockRoot))
-	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, wsb))
 	retrievedBlock, err := db.GenesisBlock(ctx)
 	require.NoError(t, err)
 	assert.Equal(t, true, proto.Equal(genesisBlock, retrievedBlock.Proto()), "Wanted: %v, received: %v", genesisBlock, retrievedBlock)

beacon-chain/db/kv/checkpoint_test.go

@@ -53,7 +53,9 @@ func TestStore_FinalizedCheckpoint_CanSaveRetrieve(t *testing.T) {
 	}
 
 	// a valid chain is required to save finalized checkpoint.
-	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
+	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))

beacon-chain/db/kv/error.go

@@ -13,5 +13,11 @@ 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.
+//     root until a parent is found in the index, or the parent is genesis or the origin checkpoint.
 //   - 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,6 +46,7 @@ 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{}
@@ -74,7 +75,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) {
+		if bytes.Equal(root, genesisRoot) || bytes.Equal(root, initCheckpointRoot) {
 			break
 		}
 

beacon-chain/db/kv/finalized_block_roots_test.go

@@ -63,7 +63,9 @@ func TestStore_IsFinalizedBlockGenesis(t *testing.T) {
 	blk.Block.Slot = 0
 	root, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, wsb))
 	require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 	assert.Equal(t, true, db.IsFinalizedBlock(ctx, root), "Finalized genesis block doesn't exist in db")
 }
@@ -207,7 +209,8 @@ 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] = wrapper.WrappedPhase0SignedBeaconBlock(blocks[j-i])
+		ifaceBlocks[j-i], err = wrapper.WrappedSignedBeaconBlock(blocks[j-i])
+		require.NoError(t, err)
 	}
 	return ifaceBlocks
 }
@@ -224,7 +227,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.WrappedAltairSignedBeaconBlock(blocks[j-startIdx])
+		ifaceBlocks[j-startIdx], err = wrapper.WrappedSignedBeaconBlock(blocks[j-startIdx])
 		require.NoError(t, err)
 	}
 	return ifaceBlocks

beacon-chain/db/kv/genesis.go

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

beacon-chain/db/kv/schema.go

@@ -51,7 +51,9 @@ var (
 	altairKey    = []byte("altair")
 	bellatrixKey = []byte("merge")
 	// block root included in the beacon state used by weak subjectivity initial sync
-	originBlockRootKey = []byte("origin-block-root")
+	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")
 
 	// 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,7 +638,11 @@ func (s *Store) slotByBlockRoot(ctx context.Context, tx *bolt.Tx, blockRoot []by
 		if err != nil {
 			return 0, err
 		}
-		if err := helpers.BeaconBlockIsNil(wrapper.WrappedPhase0SignedBeaconBlock(b)); err != nil {
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
+		if err != nil {
+			return 0, err
+		}
+		if err := helpers.BeaconBlockIsNil(wsb); err != nil {
 			return 0, err
 		}
 		return b.Block.Slot, nil

beacon-chain/db/kv/state_test.go

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

beacon-chain/db/kv/validated_checkpoint_test.go

@@ -52,7 +52,9 @@ func TestStore_LastValidatedCheckpoint_DefaultIsFinalized(t *testing.T) {
 	}
 
 	// a valid chain is required to save finalized checkpoint.
-	require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk)))
+	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))

beacon-chain/db/kv/wss.go

@@ -2,69 +2,76 @@ package kv
 
 import (
 	"context"
-	"io"
-	"io/ioutil"
+	"fmt"
 
 	"github.com/pkg/errors"
 	types "github.com/prysmaticlabs/eth2-types"
 	"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"
 )
 
 // 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, stateReader, blockReader io.Reader) error {
-	sb, err := ioutil.ReadAll(stateReader)
+func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error {
+	genesisRoot, err := s.GenesisBlockRoot(ctx)
 	if err != nil {
-		return errors.Wrap(err, "failed to read origin state bytes")
+		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")
 	}
-	bb, err := ioutil.ReadAll(blockReader)
+	err = s.SaveBackfillBlockRoot(ctx, genesisRoot)
 	if err != nil {
-		return errors.Wrap(err, "error reading block given to SaveOrigin")
+		return errors.Wrap(err, "unable to save genesis root as initial backfill starting point for checkpoint sync")
 	}
 
-	cf, err := detect.FromState(sb)
+	cf, err := detect.FromState(serState)
 	if err != nil {
-		return errors.Wrap(err, "failed to detect config and fork for origin state")
+		return errors.Wrap(err, "could not sniff config+fork for origin state bytes")
 	}
-	bs, err := cf.UnmarshalBeaconState(sb)
-	if err != nil {
-		return errors.Wrap(err, "could not unmarshal origin state")
-	}
-	wblk, err := cf.UnmarshalBeaconBlock(bb)
-	if err != nil {
-		return errors.Wrap(err, "unable to unmarshal origin SignedBeaconBlock")
+	_, 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)
 	}
 
-	blockRoot, err := wblk.Block().HashTreeRoot()
+	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")
 	}
-	// save 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")
 	}
 
 	// save state
-	if err = s.SaveState(ctx, bs, blockRoot); err != nil {
+	log.Infof("calling SaveState w/ blockRoot=%x", blockRoot)
+	if err = s.SaveState(ctx, state, blockRoot); err != nil {
 		return errors.Wrap(err, "could not save state")
 	}
 	if err = s.SaveStateSummary(ctx, &ethpb.StateSummary{
-		Slot: bs.Slot(),
+		Slot: state.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")
@@ -87,5 +94,11 @@ func (s *Store) SaveOrigin(ctx context.Context, stateReader, blockReader io.Read
 		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,7 +27,9 @@ func TestRestore(t *testing.T) {
 	require.NoError(t, err)
 	head := util.NewBeaconBlock()
 	head.Block.Slot = 5000
-	require.NoError(t, backupDb.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(head)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(head)
+	require.NoError(t, err)
+	require.NoError(t, backupDb.SaveBlock(ctx, wsb))
 	root, err := head.Block.HashTreeRoot()
 	require.NoError(t, err)
 	st, err := util.NewBeaconState()

beacon-chain/forkchoice/BUILD.bazel

@@ -12,6 +12,7 @@ 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,6 +45,7 @@ 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/proposer_boost.go

@@ -2,12 +2,10 @@ package doublylinkedtree
 
 import (
 	"context"
-	"time"
 
 	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
 // BoostProposerRoot sets the block root which should be boosted during
@@ -19,17 +17,18 @@ import (
 //  is_before_attesting_interval = time_into_slot < SECONDS_PER_SLOT // INTERVALS_PER_SLOT
 //  if get_current_slot(store) == block.slot and is_before_attesting_interval:
 //      store.proposer_boost_root = hash_tree_root(block)
-func (f *ForkChoice) BoostProposerRoot(_ context.Context, blockSlot types.Slot, blockRoot [32]byte, genesisTime time.Time) error {
+func (f *ForkChoice) BoostProposerRoot(_ context.Context, args *forkchoicetypes.ProposerBoostRootArgs) error {
+	if args == nil {
+		return errors.New("nil function args provided to BoostProposerRoot")
+	}
 	secondsPerSlot := params.BeaconConfig().SecondsPerSlot
-	timeIntoSlot := uint64(time.Since(genesisTime).Seconds()) % secondsPerSlot
-	isBeforeAttestingInterval := timeIntoSlot < secondsPerSlot/params.BeaconConfig().IntervalsPerSlot
-	currentSlot := slots.SinceGenesis(genesisTime)
+	isBeforeAttestingInterval := args.SecondsIntoSlot < secondsPerSlot/params.BeaconConfig().IntervalsPerSlot
 
 	// Only update the boosted proposer root to the incoming block root
 	// if the block is for the current, clock-based slot and the block was timely.
-	if currentSlot == blockSlot && isBeforeAttestingInterval {
+	if args.CurrentSlot == args.BlockSlot && isBeforeAttestingInterval {
 		f.store.proposerBoostLock.Lock()
-		f.store.proposerBoostRoot = blockRoot
+		f.store.proposerBoostRoot = args.BlockRoot
 		f.store.proposerBoostLock.Unlock()
 	}
 	return nil

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

@@ -2,11 +2,11 @@ package doublylinkedtree
 
 import (
 	"context"
-	"fmt"
 	"testing"
 	"time"
 
 	types "github.com/prysmaticlabs/eth2-types"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -26,6 +26,11 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		balances[i] = 10
 	}
 	jEpoch, fEpoch := types.Epoch(0), types.Epoch(0)
+	t.Run("nil args check", func(t *testing.T) {
+		f := setup(jEpoch, fEpoch)
+		err := f.BoostProposerRoot(ctx, nil)
+		require.ErrorContains(t, "nil function args", err)
+	})
 	t.Run("back-propagates boost score to ancestors after proposer boosting", func(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
@@ -128,9 +133,14 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 			),
 		)
 		f.ProcessAttestation(ctx, []uint64{3}, newRoot, fEpoch)
-		threeSlots := 3 * params.BeaconConfig().SecondsPerSlot
-		genesisTime := time.Now().Add(-time.Second * time.Duration(threeSlots))
-		require.NoError(t, f.BoostProposerRoot(ctx, slot, newRoot, genesisTime))
+		clockSlot := types.Slot(3)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       newRoot,
+			BlockSlot:       slot,
+			CurrentSlot:     clockSlot,
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 		headRoot, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
@@ -221,9 +231,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       honestBlock,
+			BlockSlot:       honestBlockSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// The maliciously withheld block has one vote.
 		votes := []uint64{1}
@@ -289,9 +303,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       honestBlock,
+			BlockSlot:       honestBlockSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// An attestation is received for B that has more voting power than C with the proposer boost,
 		// allowing B to then become the head if their attestation has enough adversarial votes.
@@ -345,9 +363,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost C.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, cSlot /* slot */, c, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       c,
+			BlockSlot:       cSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		bSlot := types.Slot(1)
 		b := indexToHash(1)
@@ -393,8 +415,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Expected C to remain the head")
 
 		// Block D receives the boost.
-		genesis = time.Now().Add(-3 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, dSlot /* slot */, d, genesis))
+		args = &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       d,
+			BlockSlot:       dSlot,
+			CurrentSlot:     types.Slot(3),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// Ensure D becomes the head thanks to boosting.
 		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
@@ -415,12 +442,15 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		f := &ForkChoice{
 			store: &Store{},
 		}
-		// Genesis set to 1 slot ago.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
 		blockRoot := [32]byte{'A'}
-
 		// Trying to boost a block from slot 0 should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(0), blockRoot, genesis)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(0),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: 0,
+		}
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
 	})
@@ -429,14 +459,18 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 			store: &Store{},
 		}
 		// Genesis set to 1 slot ago + X where X > attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		attestingInterval := time.Duration(cfg.SecondsPerSlot / cfg.IntervalsPerSlot)
-		greaterThanAttestingInterval := attestingInterval + 100*time.Millisecond
-		genesis = genesis.Add(-greaterThanAttestingInterval * time.Second)
-		blockRoot := [32]byte{'A'}
+		attestingInterval := time.Duration(cfg.SecondsPerSlot/cfg.IntervalsPerSlot) * time.Second
+		greaterThanAttestingInterval := attestingInterval + time.Second
 
 		// Trying to boost a block from slot 1 that is untimely should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		blockRoot := [32]byte{'A'}
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     1,
+			SecondsIntoSlot: uint64(greaterThanAttestingInterval.Seconds()),
+		}
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
 	})
@@ -445,11 +479,15 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 			store: &Store{},
 		}
 		// Genesis set to 1 slot ago + 0 seconds into the attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		fmt.Println(genesis)
 		blockRoot := [32]byte{'A'}
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: 0,
+		}
 
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
 	})
@@ -457,13 +495,16 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		f := &ForkChoice{
 			store: &Store{},
 		}
-		// Genesis set to 1 slot ago + (attesting interval / 2).
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
 		blockRoot := [32]byte{'A'}
 		halfAttestingInterval := time.Second
-		genesis = genesis.Add(-halfAttestingInterval)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: uint64(halfAttestingInterval.Seconds()),
+		}
 
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
 	})

beacon-chain/forkchoice/interfaces.go

@@ -2,9 +2,9 @@ package forkchoice
 
 import (
 	"context"
-	"time"
 
 	types "github.com/prysmaticlabs/eth2-types"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
@@ -51,7 +51,7 @@ type Pruner interface {
 
 // ProposerBooster is able to boost the proposer's root score during fork choice.
 type ProposerBooster interface {
-	BoostProposerRoot(ctx context.Context, blockSlot types.Slot, blockRoot [32]byte, genesisTime time.Time) error
+	BoostProposerRoot(ctx context.Context, args *forkchoicetypes.ProposerBoostRootArgs) error
 	ResetBoostedProposerRoot(ctx context.Context) error
 }
 

beacon-chain/forkchoice/protoarray/BUILD.bazel

@@ -19,11 +19,11 @@ go_library(
         "//testing/spectest:__subpackages__",
     ],
     deps = [
+        "//beacon-chain/forkchoice/types:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//math: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",
@@ -46,6 +46,7 @@ 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/protoarray/proposer_boost.go

@@ -2,12 +2,10 @@ package protoarray
 
 import (
 	"context"
-	"time"
 
 	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
 // BoostProposerRoot sets the block root which should be boosted during
@@ -19,17 +17,18 @@ import (
 //  is_before_attesting_interval = time_into_slot < SECONDS_PER_SLOT // INTERVALS_PER_SLOT
 //  if get_current_slot(store) == block.slot and is_before_attesting_interval:
 //      store.proposer_boost_root = hash_tree_root(block)
-func (f *ForkChoice) BoostProposerRoot(_ context.Context, blockSlot types.Slot, blockRoot [32]byte, genesisTime time.Time) error {
+func (f *ForkChoice) BoostProposerRoot(_ context.Context, args *types.ProposerBoostRootArgs) error {
+	if args == nil {
+		return errors.New("nil function args provided to BoostProposerRoot")
+	}
 	secondsPerSlot := params.BeaconConfig().SecondsPerSlot
-	timeIntoSlot := uint64(time.Since(genesisTime).Seconds()) % secondsPerSlot
-	isBeforeAttestingInterval := timeIntoSlot < secondsPerSlot/params.BeaconConfig().IntervalsPerSlot
-	currentSlot := slots.SinceGenesis(genesisTime)
+	isBeforeAttestingInterval := args.SecondsIntoSlot < secondsPerSlot/params.BeaconConfig().IntervalsPerSlot
 
 	// Only update the boosted proposer root to the incoming block root
 	// if the block is for the current, clock-based slot and the block was timely.
-	if currentSlot == blockSlot && isBeforeAttestingInterval {
+	if args.CurrentSlot == args.BlockSlot && isBeforeAttestingInterval {
 		f.store.proposerBoostLock.Lock()
-		f.store.proposerBoostRoot = blockRoot
+		f.store.proposerBoostRoot = args.BlockRoot
 		f.store.proposerBoostLock.Unlock()
 	}
 	return nil

beacon-chain/forkchoice/protoarray/proposer_boost_test.go

@@ -2,11 +2,11 @@ package protoarray
 
 import (
 	"context"
-	"fmt"
 	"testing"
 	"time"
 
 	types "github.com/prysmaticlabs/eth2-types"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -20,12 +20,17 @@ import (
 // If the honest proposal is boosted at slot n+2, it will win against this attacker.
 func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 	ctx := context.Background()
+	jEpoch, fEpoch := types.Epoch(0), types.Epoch(0)
 	zeroHash := params.BeaconConfig().ZeroHash
 	balances := make([]uint64, 64) // 64 active validators.
 	for i := 0; i < len(balances); i++ {
 		balances[i] = 10
 	}
-	jEpoch, fEpoch := types.Epoch(0), types.Epoch(0)
+	t.Run("nil args check", func(t *testing.T) {
+		f := setup(jEpoch, fEpoch)
+		err := f.BoostProposerRoot(ctx, nil)
+		require.ErrorContains(t, "nil function args", err)
+	})
 	t.Run("back-propagates boost score to ancestors after proposer boosting", func(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
@@ -88,8 +93,8 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		//         2
 		//         |
 		//         3 <- HEAD
-		slot = types.Slot(2)
-		newRoot = indexToHash(2)
+		slot = types.Slot(3)
+		newRoot = indexToHash(3)
 		require.NoError(t,
 			f.InsertOptimisticBlock(
 				ctx,
@@ -128,15 +133,20 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 			),
 		)
 		f.ProcessAttestation(ctx, []uint64{3}, newRoot, fEpoch)
-		threeSlots := 3 * params.BeaconConfig().SecondsPerSlot
-		genesisTime := time.Now().Add(-time.Second * time.Duration(threeSlots))
-		require.NoError(t, f.BoostProposerRoot(ctx, slot, newRoot, genesisTime))
+		clockSlot := types.Slot(3)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       newRoot,
+			BlockSlot:       slot,
+			CurrentSlot:     clockSlot,
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 		headRoot, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
 
 		// Check the ancestor scores from the store.
-		require.Equal(t, 4, len(f.store.nodes))
+		require.Equal(t, 5, len(f.store.nodes))
 
 		// Expect nodes to have a boosted, back-propagated score.
 		// Ancestors have the added weights of their children. Genesis is a special exception at 0 weight,
@@ -163,7 +173,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// middle instead of the normal progression of (44 -> 34 -> 24).
 		require.Equal(t, f.store.nodes[1].weight, uint64(54))
 		require.Equal(t, f.store.nodes[2].weight, uint64(44))
-		require.Equal(t, f.store.nodes[3].weight, uint64(24))
+		require.Equal(t, f.store.nodes[3].weight, uint64(34))
 	})
 	t.Run("vanilla ex ante attack", func(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
@@ -189,7 +199,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				honestBlockSlot,
 				honestBlock,
 				zeroHash,
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -206,7 +216,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				maliciouslyWithheldBlockSlot,
 				maliciouslyWithheldBlock,
 				zeroHash,
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -218,9 +228,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       honestBlock,
+			BlockSlot:       honestBlockSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// The maliciously withheld block has one vote.
 		votes := []uint64{1}
@@ -255,7 +269,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				honestBlockSlot,
 				honestBlock,
 				zeroHash,
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -274,7 +288,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				maliciouslyWithheldBlockSlot,
 				maliciouslyWithheldBlock,
 				zeroHash,
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -286,9 +300,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       honestBlock,
+			BlockSlot:       honestBlockSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// An attestation is received for B that has more voting power than C with the proposer boost,
 		// allowing B to then become the head if their attestation has enough adversarial votes.
@@ -330,7 +348,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				cSlot,
 				c,
 				a, // parent
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -342,9 +360,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost C.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, cSlot /* slot */, c, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       c,
+			BlockSlot:       cSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		bSlot := types.Slot(1)
 		b := indexToHash(1)
@@ -354,7 +376,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				bSlot,
 				b,
 				a, // parent
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -378,7 +400,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				dSlot,
 				d,
 				b, // parent
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -390,8 +412,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Expected C to remain the head")
 
 		// Block D receives the boost.
-		genesis = time.Now().Add(-3 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, dSlot /* slot */, d, genesis))
+		args = &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       d,
+			BlockSlot:       dSlot,
+			CurrentSlot:     types.Slot(3),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// Ensure D becomes the head thanks to boosting.
 		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
@@ -412,12 +439,15 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		f := &ForkChoice{
 			store: &Store{},
 		}
-		// Genesis set to 1 slot ago.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
 		blockRoot := [32]byte{'A'}
-
 		// Trying to boost a block from slot 0 should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(0), blockRoot, genesis)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(0),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: 0,
+		}
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
 	})
@@ -426,14 +456,18 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 			store: &Store{},
 		}
 		// Genesis set to 1 slot ago + X where X > attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		attestingInterval := time.Duration(cfg.SecondsPerSlot / cfg.IntervalsPerSlot)
-		greaterThanAttestingInterval := attestingInterval + 100*time.Millisecond
-		genesis = genesis.Add(-greaterThanAttestingInterval * time.Second)
-		blockRoot := [32]byte{'A'}
+		attestingInterval := time.Duration(cfg.SecondsPerSlot/cfg.IntervalsPerSlot) * time.Second
+		greaterThanAttestingInterval := attestingInterval + time.Second
 
 		// Trying to boost a block from slot 1 that is untimely should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		blockRoot := [32]byte{'A'}
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     1,
+			SecondsIntoSlot: uint64(greaterThanAttestingInterval.Seconds()),
+		}
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
 	})
@@ -442,11 +476,15 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 			store: &Store{},
 		}
 		// Genesis set to 1 slot ago + 0 seconds into the attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		fmt.Println(genesis)
 		blockRoot := [32]byte{'A'}
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: 0,
+		}
 
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
 	})
@@ -454,13 +492,16 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		f := &ForkChoice{
 			store: &Store{},
 		}
-		// Genesis set to 1 slot ago + (attesting interval / 2).
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
 		blockRoot := [32]byte{'A'}
 		halfAttestingInterval := time.Second
-		genesis = genesis.Add(-halfAttestingInterval)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: uint64(halfAttestingInterval.Seconds()),
+		}
 
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
 	})

beacon-chain/forkchoice/types/BUILD.bazel

@@ -0,0 +1,9 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["types.go"],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types",
+    visibility = ["//visibility:public"],
+    deps = ["@com_github_prysmaticlabs_eth2_types//:go_default_library"],
+)

beacon-chain/forkchoice/types/types.go

@@ -0,0 +1,13 @@
+package types
+
+import (
+	types "github.com/prysmaticlabs/eth2-types"
+)
+
+// ProposerBoostRootArgs to call the BoostProposerRoot function.
+type ProposerBoostRootArgs struct {
+	BlockRoot       [32]byte
+	BlockSlot       types.Slot
+	CurrentSlot     types.Slot
+	SecondsIntoSlot uint64
+}

beacon-chain/monitor/process_block_test.go

@@ -223,7 +223,7 @@ func TestProcessBlock_AllEventsTrackedVals(t *testing.T) {
 	wanted2 := fmt.Sprintf("\"Proposer slashing was included\" BodyRoot1=0x000100000000 BodyRoot2=0x000200000000 ProposerIndex=%d SlashingSlot=0 Slot=1 prefix=monitor", idx)
 	wanted3 := "\"Sync committee contribution included\" BalanceChange=0 ContribCount=3 ExpectedContribCount=3 NewBalance=32000000000 ValidatorIndex=1 prefix=monitor"
 	wanted4 := "\"Sync committee contribution included\" BalanceChange=0 ContribCount=1 ExpectedContribCount=1 NewBalance=32000000000 ValidatorIndex=2 prefix=monitor"
-	wrapped, err := wrapper.WrappedAltairSignedBeaconBlock(b)
+	wrapped, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	s.processBlock(ctx, wrapped)
 	require.LogsContain(t, hook, wanted1)

beacon-chain/monitor/service_test.go

@@ -244,7 +244,7 @@ func TestMonitorRoutine(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, s.config.StateGen.SaveState(ctx, root, genesis))
 
-	wrapped, err := wrapper.WrappedAltairSignedBeaconBlock(block)
+	wrapped, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 
 	stateChannel <- &feed.Event{

beacon-chain/node/BUILD.bazel

@@ -41,6 +41,8 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/sync:go_default_library",
+        "//beacon-chain/sync/backfill:go_default_library",
+        "//beacon-chain/sync/checkpoint:go_default_library",
         "//beacon-chain/sync/initial-sync:go_default_library",
         "//cmd:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",

beacon-chain/node/node.go

@@ -44,6 +44,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	regularsync "github.com/prysmaticlabs/prysm/beacon-chain/sync"
+	"github.com/prysmaticlabs/prysm/beacon-chain/sync/backfill"
+	"github.com/prysmaticlabs/prysm/beacon-chain/sync/checkpoint"
 	initialsync "github.com/prysmaticlabs/prysm/beacon-chain/sync/initial-sync"
 	"github.com/prysmaticlabs/prysm/cmd"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
@@ -101,6 +103,8 @@ type BeaconNode struct {
 	slasherAttestationsFeed *event.Feed
 	finalizedStateAtStartUp state.BeaconState
 	serviceFlagOpts         *serviceFlagOpts
+	blockchainFlagOpts      []blockchain.Option
+	CheckpointInitializer   checkpoint.Initializer
 }
 
 // New creates a new node instance, sets up configuration options, and registers
@@ -162,13 +166,19 @@ func New(cliCtx *cli.Context, opts ...Option) (*BeaconNode, error) {
 	if err := beacon.startDB(cliCtx, depositAddress); err != nil {
 		return nil, err
 	}
+
 	log.Debugln("Starting Slashing DB")
 	if err := beacon.startSlasherDB(cliCtx); err != nil {
 		return nil, err
 	}
 
+	bfs := backfill.NewStatus(beacon.db)
+	if err := bfs.Reload(ctx); err != nil {
+		return nil, errors.Wrap(err, "backfill status initialization error")
+	}
+
 	log.Debugln("Starting State Gen")
-	if err := beacon.startStateGen(); err != nil {
+	if err := beacon.startStateGen(ctx, bfs); err != nil {
 		return nil, err
 	}
 
@@ -239,7 +249,7 @@ func New(cliCtx *cli.Context, opts ...Option) (*BeaconNode, error) {
 
 	// db.DatabasePath is the path to the containing directory
 	// db.NewDBFilename expands that to the canonical full path using
-	// the same constuction as NewDB()
+	// the same construction as NewDB()
 	c, err := newBeaconNodePromCollector(db.NewDBFilename(beacon.db.DatabasePath()))
 	if err != nil {
 		return nil, err
@@ -396,6 +406,13 @@ func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
 	if err := b.db.EnsureEmbeddedGenesis(b.ctx); err != nil {
 		return err
 	}
+
+	if b.CheckpointInitializer != nil {
+		if err := b.CheckpointInitializer.Initialize(b.ctx, d); err != nil {
+			return err
+		}
+	}
+
 	knownContract, err := b.db.DepositContractAddress(b.ctx)
 	if err != nil {
 		return err
@@ -463,10 +480,11 @@ func (b *BeaconNode) startSlasherDB(cliCtx *cli.Context) error {
 	return nil
 }
 
-func (b *BeaconNode) startStateGen() error {
-	b.stateGen = stategen.New(b.db)
+func (b *BeaconNode) startStateGen(ctx context.Context, bfs *backfill.Status) error {
+	opts := []stategen.StateGenOption{stategen.WithBackfillStatus(bfs)}
+	sg := stategen.New(b.db, opts...)
 
-	cp, err := b.db.FinalizedCheckpoint(b.ctx)
+	cp, err := b.db.FinalizedCheckpoint(ctx)
 	if err != nil {
 		return err
 	}
@@ -474,7 +492,7 @@ func (b *BeaconNode) startStateGen() error {
 	r := bytesutil.ToBytes32(cp.Root)
 	// Consider edge case where finalized root are zeros instead of genesis root hash.
 	if r == params.BeaconConfig().ZeroHash {
-		genesisBlock, err := b.db.GenesisBlock(b.ctx)
+		genesisBlock, err := b.db.GenesisBlock(ctx)
 		if err != nil {
 			return err
 		}
@@ -486,10 +504,12 @@ func (b *BeaconNode) startStateGen() error {
 		}
 	}
 
-	b.finalizedStateAtStartUp, err = b.stateGen.StateByRoot(b.ctx, r)
+	b.finalizedStateAtStartUp, err = sg.StateByRoot(ctx, r)
 	if err != nil {
 		return err
 	}
+
+	b.stateGen = sg
 	return nil
 }
 

beacon-chain/p2p/types/object_mapping.go

@@ -33,13 +33,13 @@ func InitializeDataMaps() {
 	// Reset our block map.
 	BlockMap = map[[4]byte]func() (block.SignedBeaconBlock, error){
 		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (block.SignedBeaconBlock, error) {
-			return wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{}), nil
+			return wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
 		},
 		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (block.SignedBeaconBlock, error) {
-			return wrapper.WrappedAltairSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}})
+			return wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}})
 		},
 		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (block.SignedBeaconBlock, error) {
-			return wrapper.WrappedBellatrixSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}})
+			return wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}})
 		},
 	}
 

beacon-chain/powchain/BUILD.bazel

@@ -84,6 +84,7 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//async/event:go_default_library",
+        "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
@@ -106,7 +107,9 @@ go_test(
         "//monitoring/clientstats:go_default_library",
         "//network:go_default_library",
         "//network/authorization:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//proto/prysm/v1alpha1/wrapper:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

beacon-chain/powchain/check_transition_config.go

@@ -8,6 +8,8 @@ import (
 	"time"
 
 	"github.com/holiman/uint256"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
+	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
 	pb "github.com/prysmaticlabs/prysm/proto/engine/v1"
@@ -24,11 +26,14 @@ var (
 // there are no differences in terminal block difficulty and block hash.
 // If there are any discrepancies, we must log errors to ensure users can resolve
 //the problem and be ready for the merge transition.
-func (s *Service) checkTransitionConfiguration(ctx context.Context) {
+func (s *Service) checkTransitionConfiguration(
+	ctx context.Context, blockNotifications chan *statefeed.BlockProcessedData,
+) {
 	// If Bellatrix fork epoch is not set, we do not run this check.
 	if params.BeaconConfig().BellatrixForkEpoch == math.MaxUint64 {
 		return
 	}
+	// If no engine API, then also avoid running this check.
 	if s.engineAPIClient == nil {
 		return
 	}
@@ -54,10 +59,24 @@ func (s *Service) checkTransitionConfiguration(ctx context.Context) {
 	// Bellatrix hard-fork transition.
 	ticker := time.NewTicker(checkTransitionPollingInterval)
 	defer ticker.Stop()
+	sub := s.cfg.stateNotifier.StateFeed().Subscribe(blockNotifications)
+	defer sub.Unsubscribe()
 	for {
 		select {
 		case <-ctx.Done():
 			return
+		case <-sub.Err():
+			return
+		case ev := <-blockNotifications:
+			isExecutionBlock, err := blocks.IsExecutionBlock(ev.SignedBlock.Block().Body())
+			if err != nil {
+				log.WithError(err).Debug("Could not check whether signed block is execution block")
+				continue
+			}
+			if isExecutionBlock {
+				log.Debug("PoS transition is complete, no longer checking for configuration changes")
+				return
+			}
 		case <-ticker.C:
 			err = s.engineAPIClient.ExchangeTransitionConfiguration(ctx, cfg)
 			s.handleExchangeConfigurationError(err)

beacon-chain/powchain/check_transition_config_test.go

@@ -6,9 +6,15 @@ import (
 	"testing"
 	"time"
 
+	mockChain2 "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
+	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1"
 	"github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1/mocks"
+	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
@@ -18,21 +24,61 @@ func Test_checkTransitionConfiguration(t *testing.T) {
 	cfg := params.BeaconConfig().Copy()
 	cfg.BellatrixForkEpoch = 0
 	params.OverrideBeaconConfig(cfg)
-
-	ctx := context.Background()
 	hook := logTest.NewGlobal()
 
-	m := &mocks.EngineClient{}
-	m.Err = errors.New("something went wrong")
+	t.Run("context canceled", func(t *testing.T) {
+		ctx := context.Background()
+		m := &mocks.EngineClient{}
+		m.Err = errors.New("something went wrong")
 
-	srv := &Service{}
-	srv.engineAPIClient = m
-	checkTransitionPollingInterval = time.Millisecond
-	ctx, cancel := context.WithCancel(ctx)
-	go srv.checkTransitionConfiguration(ctx)
-	<-time.After(100 * time.Millisecond)
-	cancel()
-	require.LogsContain(t, hook, "Could not check configuration values")
+		mockChain := &mockChain2.MockStateNotifier{}
+		srv := &Service{
+			cfg: &config{stateNotifier: mockChain},
+		}
+		srv.engineAPIClient = m
+		checkTransitionPollingInterval = time.Millisecond
+		ctx, cancel := context.WithCancel(ctx)
+		go srv.checkTransitionConfiguration(ctx, make(chan *statefeed.BlockProcessedData, 1))
+		<-time.After(100 * time.Millisecond)
+		cancel()
+		require.LogsContain(t, hook, "Could not check configuration values")
+	})
+
+	t.Run("block containing execution payload exits routine", func(t *testing.T) {
+		ctx := context.Background()
+		m := &mocks.EngineClient{}
+		m.Err = errors.New("something went wrong")
+
+		mockChain := &mockChain2.MockStateNotifier{}
+		srv := &Service{
+			cfg: &config{stateNotifier: mockChain},
+		}
+		srv.engineAPIClient = m
+		checkTransitionPollingInterval = time.Millisecond
+		ctx, cancel := context.WithCancel(ctx)
+		exit := make(chan bool)
+		notification := make(chan *statefeed.BlockProcessedData)
+		go func() {
+			srv.checkTransitionConfiguration(ctx, notification)
+			exit <- true
+		}()
+		payload := emptyPayload()
+		payload.GasUsed = 21000
+		wrappedBlock, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{
+			Block: &ethpb.BeaconBlockBellatrix{
+				Body: &ethpb.BeaconBlockBodyBellatrix{
+					ExecutionPayload: payload,
+				},
+			}},
+		)
+		require.NoError(t, err)
+		notification <- &statefeed.BlockProcessedData{
+			SignedBlock: wrappedBlock,
+		}
+		<-exit
+		cancel()
+		require.LogsContain(t, hook, "PoS transition is complete, no longer checking")
+	})
 }
 
 func TestService_handleExchangeConfigurationError(t *testing.T) {
@@ -63,3 +109,17 @@ func TestService_handleExchangeConfigurationError(t *testing.T) {
 		require.LogsContain(t, hook, "Could not check configuration values")
 	})
 }
+func emptyPayload() *enginev1.ExecutionPayload {
+	return &enginev1.ExecutionPayload{
+		ParentHash:    make([]byte, fieldparams.RootLength),
+		FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+		StateRoot:     make([]byte, fieldparams.RootLength),
+		ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+		LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+		PrevRandao:    make([]byte, fieldparams.RootLength),
+		BaseFeePerGas: make([]byte, fieldparams.RootLength),
+		BlockHash:     make([]byte, fieldparams.RootLength),
+		Transactions:  make([][]byte, 0),
+		ExtraData:     make([]byte, 0),
+	}
+}

beacon-chain/powchain/engine-api-client/v1/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
         "auth.go",
         "client.go",
         "errors.go",
+        "metrics.go",
         "options.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/powchain/engine-api-client/v1",
@@ -18,6 +19,8 @@ go_library(
         "@com_github_ethereum_go_ethereum//rpc:go_default_library",
         "@com_github_golang_jwt_jwt_v4//: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",
         "@io_opencensus_go//trace:go_default_library",
     ],
 )

beacon-chain/powchain/engine-api-client/v1/client.go

@@ -34,7 +34,7 @@ const (
 	// ExecutionBlockByNumberMethod request string for JSON-RPC.
 	ExecutionBlockByNumberMethod = "eth_getBlockByNumber"
 	// DefaultTimeout for HTTP.
-	DefaultTimeout = time.Second * 5
+	DefaultTimeout = time.Second * 6
 )
 
 // ForkchoiceUpdatedResponse is the response kind received by the
@@ -99,6 +99,10 @@ func New(ctx context.Context, endpoint string, opts ...Option) (*Client, error)
 func (c *Client) NewPayload(ctx context.Context, payload *pb.ExecutionPayload) ([]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.NewPayload")
 	defer span.End()
+	start := time.Now()
+	defer func() {
+		newPayloadLatency.Observe(float64(time.Since(start).Milliseconds()))
+	}()
 
 	result := &pb.PayloadStatus{}
 	err := c.rpc.CallContext(ctx, result, NewPayloadMethod, payload)
@@ -128,6 +132,10 @@ func (c *Client) ForkchoiceUpdated(
 ) (*pb.PayloadIDBytes, []byte, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.ForkchoiceUpdated")
 	defer span.End()
+	start := time.Now()
+	defer func() {
+		forkchoiceUpdatedLatency.Observe(float64(time.Since(start).Milliseconds()))
+	}()
 
 	result := &ForkchoiceUpdatedResponse{}
 	err := c.rpc.CallContext(ctx, result, ForkchoiceUpdatedMethod, state, attrs)
@@ -157,6 +165,10 @@ func (c *Client) ForkchoiceUpdated(
 func (c *Client) GetPayload(ctx context.Context, payloadId [8]byte) (*pb.ExecutionPayload, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetPayload")
 	defer span.End()
+	start := time.Now()
+	defer func() {
+		getPayloadLatency.Observe(float64(time.Since(start).Milliseconds()))
+	}()
 
 	result := &pb.ExecutionPayload{}
 	err := c.rpc.CallContext(ctx, result, GetPayloadMethod, pb.PayloadIDBytes(payloadId))

beacon-chain/powchain/engine-api-client/v1/metrics.go

@@ -0,0 +1,30 @@
+package v1
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+var (
+	newPayloadLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "new_payload_v1_latency_milliseconds",
+			Help:    "Captures RPC latency for newPayloadV1 in milliseconds",
+			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+		},
+	)
+	getPayloadLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "get_payload_v1_latency_milliseconds",
+			Help:    "Captures RPC latency for newPayloadV1 in milliseconds",
+			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+		},
+	)
+	forkchoiceUpdatedLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "forkchoice_updated_v1_latency_milliseconds",
+			Help:    "Captures RPC latency for newPayloadV1 in milliseconds",
+			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+		},
+	)
+)

beacon-chain/powchain/service.go

@@ -252,7 +252,7 @@ func (s *Service) Start() {
 	}
 
 	// Check transition configuration for the engine API client in the background.
-	go s.checkTransitionConfiguration(s.ctx)
+	go s.checkTransitionConfiguration(s.ctx, make(chan *statefeed.BlockProcessedData, 1))
 
 	go func() {
 		s.isRunning = true

beacon-chain/rpc/apimiddleware/custom_handlers_test.go

@@ -249,7 +249,7 @@ func TestReceiveEvents_TrailingSpace(t *testing.T) {
 	errJson := receiveEvents(ch, w, req)
 	assert.Equal(t, true, errJson == nil)
 	assert.Equal(t, `event: finalized_checkpoint
-data: {"block":"0x666f6f","state":"0x666f6f","epoch":"1"}
+data: {"block":"0x666f6f","state":"0x666f6f","epoch":"1","execution_optimistic":false}
 
 `, w.Body.String())
 }
@@ -273,5 +273,5 @@ func TestWriteEvent(t *testing.T) {
 	errJson := writeEvent(msg, w, &eventFinalizedCheckpointJson{})
 	require.Equal(t, true, errJson == nil)
 	written := w.Body.String()
-	assert.Equal(t, "event: test_event\ndata: {\"block\":\"0x666f6f\",\"state\":\"0x666f6f\",\"epoch\":\"1\"}\n\n", written)
+	assert.Equal(t, "event: test_event\ndata: {\"block\":\"0x666f6f\",\"state\":\"0x666f6f\",\"epoch\":\"1\",\"execution_optimistic\":false}\n\n", written)
 }

beacon-chain/rpc/apimiddleware/structs.go

@@ -35,7 +35,8 @@ type feeRecipientsRequestJSON struct {
 
 // stateRootResponseJson is used in /beacon/states/{state_id}/root API endpoint.
 type stateRootResponseJson struct {
-	Data *stateRootResponse_StateRootJson `json:"data"`
+	Data                *stateRootResponse_StateRootJson `json:"data"`
+	ExecutionOptimistic bool                             `json:"execution_optimistic"`
 }
 
 // stateRootResponse_StateRootJson is used in /beacon/states/{state_id}/root API endpoint.
@@ -45,12 +46,14 @@ type stateRootResponse_StateRootJson struct {
 
 // stateForkResponseJson is used in /beacon/states/{state_id}/fork API endpoint.
 type stateForkResponseJson struct {
-	Data *forkJson `json:"data"`
+	Data                *forkJson `json:"data"`
+	ExecutionOptimistic bool      `json:"execution_optimistic"`
 }
 
 // stateFinalityCheckpointResponseJson is used in /beacon/states/{state_id}/finality_checkpoints API endpoint.
 type stateFinalityCheckpointResponseJson struct {
-	Data *stateFinalityCheckpointResponse_StateFinalityCheckpointJson `json:"data"`
+	Data                *stateFinalityCheckpointResponse_StateFinalityCheckpointJson `json:"data"`
+	ExecutionOptimistic bool                                                         `json:"execution_optimistic"`
 }
 
 // stateFinalityCheckpointResponse_StateFinalityCheckpointJson is used in /beacon/states/{state_id}/finality_checkpoints API endpoint.
@@ -62,37 +65,44 @@ type stateFinalityCheckpointResponse_StateFinalityCheckpointJson struct {
 
 // stateValidatorResponseJson is used in /beacon/states/{state_id}/validators API endpoint.
 type stateValidatorsResponseJson struct {
-	Data []*validatorContainerJson `json:"data"`
+	Data                []*validatorContainerJson `json:"data"`
+	ExecutionOptimistic bool                      `json:"execution_optimistic"`
 }
 
 // stateValidatorResponseJson is used in /beacon/states/{state_id}/validators/{validator_id} API endpoint.
 type stateValidatorResponseJson struct {
-	Data *validatorContainerJson `json:"data"`
+	Data                *validatorContainerJson `json:"data"`
+	ExecutionOptimistic bool                    `json:"execution_optimistic"`
 }
 
 // validatorBalancesResponseJson is used in /beacon/states/{state_id}/validator_balances API endpoint.
 type validatorBalancesResponseJson struct {
-	Data []*validatorBalanceJson `json:"data"`
+	Data                []*validatorBalanceJson `json:"data"`
+	ExecutionOptimistic bool                    `json:"execution_optimistic"`
 }
 
 // stateCommitteesResponseJson is used in /beacon/states/{state_id}/committees API endpoint.
 type stateCommitteesResponseJson struct {
-	Data []*committeeJson `json:"data"`
+	Data                []*committeeJson `json:"data"`
+	ExecutionOptimistic bool             `json:"execution_optimistic"`
 }
 
 // syncCommitteesResponseJson is used in /beacon/states/{state_id}/sync_committees API endpoint.
 type syncCommitteesResponseJson struct {
-	Data *syncCommitteeValidatorsJson `json:"data"`
+	Data                *syncCommitteeValidatorsJson `json:"data"`
+	ExecutionOptimistic bool                         `json:"execution_optimistic"`
 }
 
 // blockHeadersResponseJson is used in /beacon/headers API endpoint.
 type blockHeadersResponseJson struct {
-	Data []*blockHeaderContainerJson `json:"data"`
+	Data                []*blockHeaderContainerJson `json:"data"`
+	ExecutionOptimistic bool                        `json:"execution_optimistic"`
 }
 
 // blockHeaderResponseJson is used in /beacon/headers/{block_id} API endpoint.
 type blockHeaderResponseJson struct {
-	Data *blockHeaderContainerJson `json:"data"`
+	Data                *blockHeaderContainerJson `json:"data"`
+	ExecutionOptimistic bool                      `json:"execution_optimistic"`
 }
 
 // blockResponseJson is used in /beacon/blocks/{block_id} API endpoint.
@@ -102,18 +112,21 @@ type blockResponseJson struct {
 
 // blockV2ResponseJson is used in /v2/beacon/blocks/{block_id} API endpoint.
 type blockV2ResponseJson struct {
-	Version string                            `json:"version" enum:"true"`
-	Data    *signedBeaconBlockContainerV2Json `json:"data"`
+	Version             string                            `json:"version" enum:"true"`
+	Data                *signedBeaconBlockContainerV2Json `json:"data"`
+	ExecutionOptimistic bool                              `json:"execution_optimistic"`
 }
 
 // blockRootResponseJson is used in /beacon/blocks/{block_id}/root API endpoint.
 type blockRootResponseJson struct {
-	Data *blockRootContainerJson `json:"data"`
+	Data                *blockRootContainerJson `json:"data"`
+	ExecutionOptimistic bool                    `json:"execution_optimistic"`
 }
 
 // blockAttestationsResponseJson is used in /beacon/blocks/{block_id}/attestations API endpoint.
 type blockAttestationsResponseJson struct {
-	Data []*attestationJson `json:"data"`
+	Data                []*attestationJson `json:"data"`
+	ExecutionOptimistic bool               `json:"execution_optimistic"`
 }
 
 // attestationsPoolResponseJson is used in /beacon/pool/attestations GET API endpoint.
@@ -191,8 +204,9 @@ type beaconStateResponseJson struct {
 
 // beaconStateV2ResponseJson is used in /v2/debug/beacon/states/{state_id} API endpoint.
 type beaconStateV2ResponseJson struct {
-	Version string                      `json:"version" enum:"true"`
-	Data    *beaconStateContainerV2Json `json:"data"`
+	Version             string                      `json:"version" enum:"true"`
+	Data                *beaconStateContainerV2Json `json:"data"`
+	ExecutionOptimistic bool                        `json:"execution_optimistic"`
 }
 
 // forkChoiceHeadsResponseJson is used in /v1/debug/beacon/heads API endpoint.
@@ -227,19 +241,22 @@ type dutiesRequestJson struct {
 
 // attesterDutiesResponseJson is used in /validator/duties/attester/{epoch} API endpoint.
 type attesterDutiesResponseJson struct {
-	DependentRoot string              `json:"dependent_root" hex:"true"`
-	Data          []*attesterDutyJson `json:"data"`
+	DependentRoot       string              `json:"dependent_root" hex:"true"`
+	Data                []*attesterDutyJson `json:"data"`
+	ExecutionOptimistic bool                `json:"execution_optimistic"`
 }
 
 // proposerDutiesResponseJson is used in /validator/duties/proposer/{epoch} API endpoint.
 type proposerDutiesResponseJson struct {
-	DependentRoot string              `json:"dependent_root" hex:"true"`
-	Data          []*proposerDutyJson `json:"data"`
+	DependentRoot       string              `json:"dependent_root" hex:"true"`
+	Data                []*proposerDutyJson `json:"data"`
+	ExecutionOptimistic bool                `json:"execution_optimistic"`
 }
 
 // syncCommitteeDutiesResponseJson is used in /validator/duties/sync/{epoch} API endpoint.
 type syncCommitteeDutiesResponseJson struct {
-	Data []*syncCommitteeDuty `json:"data"`
+	Data                []*syncCommitteeDuty `json:"data"`
+	ExecutionOptimistic bool                 `json:"execution_optimistic"`
 }
 
 // produceBlockResponseJson is used in /validator/blocks/{slot} API endpoint.
@@ -847,13 +864,15 @@ type eventHeadJson struct {
 	Block                     string `json:"block" hex:"true"`
 	State                     string `json:"state" hex:"true"`
 	EpochTransition           bool   `json:"epoch_transition"`
+	ExecutionOptimistic       bool   `json:"execution_optimistic"`
 	PreviousDutyDependentRoot string `json:"previous_duty_dependent_root" hex:"true"`
 	CurrentDutyDependentRoot  string `json:"current_duty_dependent_root" hex:"true"`
 }
 
 type receivedBlockDataJson struct {
-	Slot  string `json:"slot"`
-	Block string `json:"block" hex:"true"`
+	Slot                string `json:"slot"`
+	Block               string `json:"block" hex:"true"`
+	ExecutionOptimistic bool   `json:"execution_optimistic"`
 }
 
 type aggregatedAttReceivedDataJson struct {
@@ -861,19 +880,21 @@ type aggregatedAttReceivedDataJson struct {
 }
 
 type eventFinalizedCheckpointJson struct {
-	Block string `json:"block" hex:"true"`
-	State string `json:"state" hex:"true"`
-	Epoch string `json:"epoch"`
+	Block               string `json:"block" hex:"true"`
+	State               string `json:"state" hex:"true"`
+	Epoch               string `json:"epoch"`
+	ExecutionOptimistic bool   `json:"execution_optimistic"`
 }
 
 type eventChainReorgJson struct {
-	Slot         string `json:"slot"`
-	Depth        string `json:"depth"`
-	OldHeadBlock string `json:"old_head_block" hex:"true"`
-	NewHeadBlock string `json:"old_head_state" hex:"true"`
-	OldHeadState string `json:"new_head_block" hex:"true"`
-	NewHeadState string `json:"new_head_state" hex:"true"`
-	Epoch        string `json:"epoch"`
+	Slot                string `json:"slot"`
+	Depth               string `json:"depth"`
+	OldHeadBlock        string `json:"old_head_block" hex:"true"`
+	NewHeadBlock        string `json:"old_head_state" hex:"true"`
+	OldHeadState        string `json:"new_head_block" hex:"true"`
+	NewHeadState        string `json:"new_head_state" hex:"true"`
+	Epoch               string `json:"epoch"`
+	ExecutionOptimistic bool   `json:"execution_optimistic"`
 }
 
 // ---------------

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

@@ -13,6 +13,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	rpchelpers "github.com/prysmaticlabs/prysm/beacon-chain/rpc/eth/helpers"
+	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/proto/eth/v2"
@@ -55,7 +56,7 @@ func (bs *Server) GetWeakSubjectivity(ctx context.Context, _ *empty.Empty) (*eth
 	if err != nil {
 		return nil, status.Error(codes.Internal, "could not get head state")
 	}
-	wsEpoch, err := helpers.LatestWeakSubjectivityEpoch(ctx, hs)
+	wsEpoch, err := helpers.LatestWeakSubjectivityEpoch(ctx, hs, params.BeaconConfig())
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "could not get weak subjectivity epoch: %v", err)
 	}
@@ -107,6 +108,10 @@ func (bs *Server) GetBlockHeader(ctx context.Context, req *ethpbv1.BlockRequest)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not determine if block root is canonical: %v", err)
 	}
+	isOptimistic, err := bs.HeadFetcher.IsOptimisticForRoot(ctx, blkRoot)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
+	}
 
 	return &ethpbv1.BlockHeaderResponse{
 		Data: &ethpbv1.BlockHeaderContainer{
@@ -117,6 +122,7 @@ func (bs *Server) GetBlockHeader(ctx context.Context, req *ethpbv1.BlockRequest)
 				Signature: header.Signature,
 			},
 		},
+		ExecutionOptimistic: isOptimistic,
 	}, nil
 }
 
@@ -151,6 +157,7 @@ func (bs *Server) ListBlockHeaders(ctx context.Context, req *ethpbv1.BlockHeader
 		return nil, status.Error(codes.NotFound, "Could not find requested blocks")
 	}
 
+	isOptimistic := false
 	blkHdrs := make([]*ethpbv1.BlockHeaderContainer, len(blks))
 	for i, bl := range blks {
 		v1alpha1Header, err := bl.Header()
@@ -166,6 +173,12 @@ func (bs *Server) ListBlockHeaders(ctx context.Context, req *ethpbv1.BlockHeader
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not determine if block root is canonical: %v", err)
 		}
+		if !isOptimistic {
+			isOptimistic, err = bs.HeadFetcher.IsOptimisticForRoot(ctx, blkRoots[i])
+			if err != nil {
+				return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
+			}
+		}
 		blkHdrs[i] = &ethpbv1.BlockHeaderContainer{
 			Root:      headerRoot[:],
 			Canonical: canonical,
@@ -176,7 +189,7 @@ func (bs *Server) ListBlockHeaders(ctx context.Context, req *ethpbv1.BlockHeader
 		}
 	}
 
-	return &ethpbv1.BlockHeadersResponse{Data: blkHdrs}, nil
+	return &ethpbv1.BlockHeadersResponse{Data: blkHdrs, ExecutionOptimistic: isOptimistic}, nil
 }
 
 // SubmitBlock instructs the beacon node to broadcast a newly signed beacon block to the beacon network, to be
@@ -230,7 +243,7 @@ func (bs *Server) SubmitBlock(ctx context.Context, req *ethpbv2.SignedBeaconBloc
 			"Block proposal received via RPC")
 		bs.BlockNotifier.BlockFeed().Send(&feed.Event{
 			Type: blockfeed.ReceivedBlock,
-			Data: &blockfeed.ReceivedBlockData{SignedBlock: wsb},
+			Data: &blockfeed.ReceivedBlockData{SignedBlock: wsb, IsOptimistic: false},
 		})
 	}()
 
@@ -314,6 +327,7 @@ func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (
 				Message:   &ethpbv2.SignedBeaconBlockContainerV2_Phase0Block{Phase0Block: v1Blk.Block},
 				Signature: v1Blk.Signature,
 			},
+			ExecutionOptimistic: false,
 		}, nil
 	}
 	// ErrUnsupportedPhase0Block means that we have another block type
@@ -336,6 +350,7 @@ func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (
 				Message:   &ethpbv2.SignedBeaconBlockContainerV2_AltairBlock{AltairBlock: v2Blk},
 				Signature: blk.Signature(),
 			},
+			ExecutionOptimistic: false,
 		}, nil
 	}
 	// ErrUnsupportedAltairBlock means that we have another block type
@@ -352,12 +367,21 @@ func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
 		}
+		root, err := blk.Block().HashTreeRoot()
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not get block root: %v", err)
+		}
+		isOptimistic, err := bs.HeadFetcher.IsOptimisticForRoot(ctx, root)
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
+		}
 		return &ethpbv2.BlockResponseV2{
 			Version: ethpbv2.Version_BELLATRIX,
 			Data: &ethpbv2.SignedBeaconBlockContainerV2{
 				Message:   &ethpbv2.SignedBeaconBlockContainerV2_BellatrixBlock{BellatrixBlock: v2Blk},
 				Signature: blk.Signature(),
 			},
+			ExecutionOptimistic: isOptimistic,
 		}, nil
 	}
 	// ErrUnsupportedBellatrixBlock means that we have another block type
@@ -519,10 +543,16 @@ func (bs *Server) GetBlockRoot(ctx context.Context, req *ethpbv1.BlockRequest) (
 		}
 	}
 
+	isOptimistic, err := bs.HeadFetcher.IsOptimisticForRoot(ctx, bytesutil.ToBytes32(root))
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
+	}
+
 	return &ethpbv1.BlockRootResponse{
 		Data: &ethpbv1.BlockRootContainer{
 			Root: root,
 		},
+		ExecutionOptimistic: isOptimistic,
 	}, nil
 }
 
@@ -547,7 +577,8 @@ func (bs *Server) ListBlockAttestations(ctx context.Context, req *ethpbv1.BlockR
 			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
 		}
 		return &ethpbv1.BlockAttestationsResponse{
-			Data: v1Blk.Block.Body.Attestations,
+			Data:                v1Blk.Block.Body.Attestations,
+			ExecutionOptimistic: false,
 		}, nil
 	}
 
@@ -564,7 +595,8 @@ func (bs *Server) ListBlockAttestations(ctx context.Context, req *ethpbv1.BlockR
 			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
 		}
 		return &ethpbv1.BlockAttestationsResponse{
-			Data: v2Blk.Body.Attestations,
+			Data:                v2Blk.Body.Attestations,
+			ExecutionOptimistic: false,
 		}, nil
 	}
 
@@ -580,8 +612,17 @@ func (bs *Server) ListBlockAttestations(ctx context.Context, req *ethpbv1.BlockR
 		if err != nil {
 			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
 		}
+		root, err := blk.Block().HashTreeRoot()
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not get block root: %v", err)
+		}
+		isOptimistic, err := bs.HeadFetcher.IsOptimisticForRoot(ctx, root)
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
+		}
 		return &ethpbv1.BlockAttestationsResponse{
-			Data: v2Blk.Body.Attestations,
+			Data:                v2Blk.Body.Attestations,
+			ExecutionOptimistic: isOptimistic,
 		}, nil
 	}
 

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

@@ -28,7 +28,9 @@ func fillDBTestBlocks(ctx context.Context, t *testing.T, beaconDB db.Database) (
 	genBlk.Block.ParentRoot = parentRoot[:]
 	root, err := genBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genBlk)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(genBlk)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
 
 	count := types.Slot(100)
@@ -47,7 +49,8 @@ func fillDBTestBlocks(ctx context.Context, t *testing.T, beaconDB db.Database) (
 		b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		blks[i] = wrapper.WrappedPhase0SignedBeaconBlock(b)
+		blks[i], err = wrapper.WrappedSignedBeaconBlock(b)
+		require.NoError(t, err)
 		blkContainers[i] = &ethpbalpha.BeaconBlockContainer{
 			Block:     &ethpbalpha.BeaconBlockContainer_Phase0Block{Phase0Block: b},
 			BlockRoot: root[:],
@@ -70,7 +73,7 @@ func fillDBTestBlocksAltair(ctx context.Context, t *testing.T, beaconDB db.Datab
 	genBlk.Block.ParentRoot = parentRoot[:]
 	root, err := genBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	signedBlk, err := wrapper.WrappedAltairSignedBeaconBlock(genBlk)
+	signedBlk, err := wrapper.WrappedSignedBeaconBlock(genBlk)
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
@@ -91,7 +94,7 @@ func fillDBTestBlocksAltair(ctx context.Context, t *testing.T, beaconDB db.Datab
 		b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		signedB, err := wrapper.WrappedAltairSignedBeaconBlock(b)
+		signedB, err := wrapper.WrappedSignedBeaconBlock(b)
 		require.NoError(t, err)
 		blks[i] = signedB
 		blkContainers[i] = &ethpbalpha.BeaconBlockContainer{
@@ -114,7 +117,7 @@ func fillDBTestBlocksBellatrix(ctx context.Context, t *testing.T, beaconDB db.Da
 	genBlk.Block.ParentRoot = parentRoot[:]
 	root, err := genBlk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	signedBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(genBlk)
+	signedBlk, err := wrapper.WrappedSignedBeaconBlock(genBlk)
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
@@ -135,7 +138,7 @@ func fillDBTestBlocksBellatrix(ctx context.Context, t *testing.T, beaconDB db.Da
 		b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		signedB, err := wrapper.WrappedBellatrixSignedBeaconBlock(b)
+		signedB, err := wrapper.WrappedSignedBeaconBlock(b)
 		require.NoError(t, err)
 		blks[i] = signedB
 		blkContainers[i] = &ethpbalpha.BeaconBlockContainer{
@@ -164,20 +167,28 @@ func TestServer_GetBlockHeader(t *testing.T) {
 	b2 := util.NewBeaconBlock()
 	b2.Block.Slot = 30
 	b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	b3 := util.NewBeaconBlock()
 	b3.Block.Slot = 30
 	b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+	require.NoError(t, err)
 
+	mockChainService := &mock.ChainService{
+		DB:                  beaconDB,
+		Block:               wsb,
+		Root:                headBlock.BlockRoot,
+		FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+	}
 	bs := &Server{
-		BeaconDB: beaconDB,
-		ChainInfoFetcher: &mock.ChainService{
-			DB:                  beaconDB,
-			Block:               wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block),
-			Root:                headBlock.BlockRoot,
-			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-		},
+		BeaconDB:         beaconDB,
+		ChainInfoFetcher: mockChainService,
+		HeadFetcher:      mockChainService,
 	}
 
 	tests := []struct {
@@ -263,6 +274,26 @@ func TestServer_GetBlockHeader(t *testing.T) {
 			assert.Equal(t, tt.want.Block.ProposerIndex, header.Data.Header.Message.ProposerIndex)
 		})
 	}
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+		require.NoError(t, err)
+		mockChainService := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               wsb,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+			Optimistic:          true,
+		}
+		bs := &Server{
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
+		}
+		header, err := bs.GetBlockHeader(ctx, &ethpbv1.BlockRequest{BlockId: []byte("head")})
+		require.NoError(t, err)
+		assert.Equal(t, true, header.ExecutionOptimistic)
+	})
 }
 
 func TestServer_ListBlockHeaders(t *testing.T) {
@@ -271,32 +302,44 @@ func TestServer_ListBlockHeaders(t *testing.T) {
 
 	_, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
 	headBlock := blkContainers[len(blkContainers)-1]
+	wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+	require.NoError(t, err)
+	mockChainFetcher := &mock.ChainService{
+		DB:                  beaconDB,
+		Block:               wsb,
+		Root:                headBlock.BlockRoot,
+		FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+	}
 	bs := &Server{
-		BeaconDB: beaconDB,
-		ChainInfoFetcher: &mock.ChainService{
-			DB:                  beaconDB,
-			Block:               wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block),
-			Root:                headBlock.BlockRoot,
-			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-		},
+		BeaconDB:         beaconDB,
+		ChainInfoFetcher: mockChainFetcher,
+		HeadFetcher:      mockChainFetcher,
 	}
 
 	b2 := util.NewBeaconBlock()
 	b2.Block.Slot = 30
 	b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	b3 := util.NewBeaconBlock()
 	b3.Block.Slot = 30
 	b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	b4 := util.NewBeaconBlock()
 	b4.Block.Slot = 31
 	b4.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b4)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b4)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	b5 := util.NewBeaconBlock()
 	b5.Block.Slot = 28
 	b5.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b5)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b5)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
 	tests := []struct {
 		name       string
@@ -360,6 +403,29 @@ func TestServer_ListBlockHeaders(t *testing.T) {
 			}
 		})
 	}
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+		require.NoError(t, err)
+		mockChainFetcher := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               wsb,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+			Optimistic:          true,
+		}
+		bs := &Server{
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainFetcher,
+			HeadFetcher:      mockChainFetcher,
+		}
+		slot := types.Slot(30)
+		headers, err := bs.ListBlockHeaders(ctx, &ethpbv1.BlockHeadersRequest{
+			Slot: &slot,
+		})
+		require.NoError(t, err)
+		assert.Equal(t, true, headers.ExecutionOptimistic)
+	})
 }
 
 func TestServer_ProposeBlock_OK(t *testing.T) {
@@ -368,7 +434,9 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
 		ctx := context.Background()
 
 		genesis := util.NewBeaconBlock()
-		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesis)), "Could not save genesis block")
+		wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb), "Could not save genesis block")
 
 		numDeposits := uint64(64)
 		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
@@ -385,13 +453,16 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
 			ChainInfoFetcher: c,
 			BlockNotifier:    c.BlockNotifier(),
 			Broadcaster:      mockp2p.NewTestP2P(t),
+			HeadFetcher:      c,
 		}
 		req := util.NewBeaconBlock()
 		req.Block.Slot = 5
 		req.Block.ParentRoot = bsRoot[:]
 		v1Block, err := migration.V1Alpha1ToV1SignedBlock(req)
 		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(req)))
+		wsb, err = wrapper.WrappedSignedBeaconBlock(req)
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 		blockReq := &ethpbv2.SignedBeaconBlockContainerV2{
 			Message:   &ethpbv2.SignedBeaconBlockContainerV2_Phase0Block{Phase0Block: v1Block.Block},
 			Signature: v1Block.Signature,
@@ -405,7 +476,7 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
 		ctx := context.Background()
 
 		genesis := util.NewBeaconBlockAltair()
-		wrapped, err := wrapper.WrappedAltairSignedBeaconBlock(genesis)
+		wrapped, err := wrapper.WrappedSignedBeaconBlock(genesis)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapped), "Could not save genesis block")
 
@@ -424,13 +495,14 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
 			ChainInfoFetcher: c,
 			BlockNotifier:    c.BlockNotifier(),
 			Broadcaster:      mockp2p.NewTestP2P(t),
+			HeadFetcher:      c,
 		}
 		req := util.NewBeaconBlockAltair()
 		req.Block.Slot = 5
 		req.Block.ParentRoot = bsRoot[:]
 		v2Block, err := migration.V1Alpha1BeaconBlockAltairToV2(req.Block)
 		require.NoError(t, err)
-		wrapped, err = wrapper.WrappedAltairSignedBeaconBlock(req)
+		wrapped, err = wrapper.WrappedSignedBeaconBlock(req)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(ctx, wrapped))
 		blockReq := &ethpbv2.SignedBeaconBlockContainerV2{
@@ -446,7 +518,7 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
 		ctx := context.Background()
 
 		genesis := util.NewBeaconBlockBellatrix()
-		wrapped, err := wrapper.WrappedBellatrixSignedBeaconBlock(genesis)
+		wrapped, err := wrapper.WrappedSignedBeaconBlock(genesis)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapped), "Could not save genesis block")
 
@@ -465,13 +537,14 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
 			ChainInfoFetcher: c,
 			BlockNotifier:    c.BlockNotifier(),
 			Broadcaster:      mockp2p.NewTestP2P(t),
+			HeadFetcher:      c,
 		}
 		req := util.NewBeaconBlockBellatrix()
 		req.Block.Slot = 5
 		req.Block.ParentRoot = bsRoot[:]
 		v2Block, err := migration.V1Alpha1BeaconBlockBellatrixToV2(req.Block)
 		require.NoError(t, err)
-		wrapped, err = wrapper.WrappedBellatrixSignedBeaconBlock(req)
+		wrapped, err = wrapper.WrappedSignedBeaconBlock(req)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(ctx, wrapped))
 		blockReq := &ethpbv2.SignedBeaconBlockContainerV2{
@@ -493,17 +566,23 @@ func TestServer_GetBlock(t *testing.T) {
 	b2 := util.NewBeaconBlock()
 	b2.Block.Slot = 30
 	b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	b3 := util.NewBeaconBlock()
 	b3.Block.Slot = 30
 	b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+	require.NoError(t, err)
 
 	bs := &Server{
 		BeaconDB: beaconDB,
 		ChainInfoFetcher: &mock.ChainService{
 			DB:                  beaconDB,
-			Block:               wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block),
+			Block:               wsb,
 			Root:                headBlock.BlockRoot,
 			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 		},
@@ -602,20 +681,29 @@ func TestServer_GetBlockV2(t *testing.T) {
 		b2 := util.NewBeaconBlock()
 		b2.Block.Slot = 30
 		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-		require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2)))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 		b3 := util.NewBeaconBlock()
 		b3.Block.Slot = 30
 		b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
-		require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3)))
+		wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
+		wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+		require.NoError(t, err)
+
+		mockChainService := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               wsb,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+		}
 		bs := &Server{
-			BeaconDB: beaconDB,
-			ChainInfoFetcher: &mock.ChainService{
-				DB:                  beaconDB,
-				Block:               wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block),
-				Root:                headBlock.BlockRoot,
-				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-			},
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
@@ -713,26 +801,28 @@ func TestServer_GetBlockV2(t *testing.T) {
 		b2 := util.NewBeaconBlockAltair()
 		b2.Block.Slot = 30
 		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-		signedBlk, err := wrapper.WrappedAltairSignedBeaconBlock(b2)
+		signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
 		b3 := util.NewBeaconBlockAltair()
 		b3.Block.Slot = 30
 		b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
-		signedBlk, err = wrapper.WrappedAltairSignedBeaconBlock(b2)
+		signedBlk, err = wrapper.WrappedSignedBeaconBlock(b2)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
 
-		chainBlk, err := wrapper.WrappedAltairSignedBeaconBlock(headBlock.GetAltairBlock())
+		chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetAltairBlock())
 		require.NoError(t, err)
+		mockChainService := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               chainBlk,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+		}
 		bs := &Server{
-			BeaconDB: beaconDB,
-			ChainInfoFetcher: &mock.ChainService{
-				DB:                  beaconDB,
-				Block:               chainBlk,
-				Root:                headBlock.BlockRoot,
-				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-			},
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB)
@@ -830,26 +920,28 @@ func TestServer_GetBlockV2(t *testing.T) {
 		b2 := util.NewBeaconBlockBellatrix()
 		b2.Block.Slot = 30
 		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-		signedBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(b2)
+		signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
 		b3 := util.NewBeaconBlockBellatrix()
 		b3.Block.Slot = 30
 		b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
-		signedBlk, err = wrapper.WrappedBellatrixSignedBeaconBlock(b2)
+		signedBlk, err = wrapper.WrappedSignedBeaconBlock(b2)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
 
-		chainBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.GetBellatrixBlock())
+		chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetBellatrixBlock())
 		require.NoError(t, err)
+		mockChainService := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               chainBlk,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+		}
 		bs := &Server{
-			BeaconDB: beaconDB,
-			ChainInfoFetcher: &mock.ChainService{
-				DB:                  beaconDB,
-				Block:               chainBlk,
-				Root:                headBlock.BlockRoot,
-				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-			},
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
@@ -936,6 +1028,48 @@ func TestServer_GetBlockV2(t *testing.T) {
 			})
 		}
 	})
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		_, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
+		headBlock := blkContainers[len(blkContainers)-1]
+
+		b2 := util.NewBeaconBlockBellatrix()
+		b2.Block.Slot = 30
+		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
+		signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
+		b3 := util.NewBeaconBlockBellatrix()
+		b3.Block.Slot = 30
+		b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
+		signedBlk, err = wrapper.WrappedSignedBeaconBlock(b2)
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
+
+		chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetBellatrixBlock())
+		require.NoError(t, err)
+		mockChainService := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               chainBlk,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+			Optimistic:          true,
+		}
+		bs := &Server{
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
+		}
+
+		blk, err := bs.GetBlockV2(ctx, &ethpbv2.BlockRequestV2{
+			BlockId: []byte("head"),
+		})
+		require.NoError(t, err)
+		assert.Equal(t, true, blk.ExecutionOptimistic)
+	})
 }
 
 func TestServer_GetBlockSSZ(t *testing.T) {
@@ -948,13 +1082,18 @@ func TestServer_GetBlockSSZ(t *testing.T) {
 	b2 := util.NewBeaconBlock()
 	b2.Block.Slot = 30
 	b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+
+	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+	require.NoError(t, err)
 
 	bs := &Server{
 		BeaconDB: beaconDB,
 		ChainInfoFetcher: &mock.ChainService{
 			DB:                  beaconDB,
-			Block:               wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block),
+			Block:               wsb,
 			Root:                headBlock.BlockRoot,
 			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 		},
@@ -983,13 +1122,18 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
 		b2 := util.NewBeaconBlock()
 		b2.Block.Slot = 30
 		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-		require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2)))
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
+
+		wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+		require.NoError(t, err)
 
 		bs := &Server{
 			BeaconDB: beaconDB,
 			ChainInfoFetcher: &mock.ChainService{
 				DB:                  beaconDB,
-				Block:               wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block),
+				Block:               wsb,
 				Root:                headBlock.BlockRoot,
 				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
 			},
@@ -1018,11 +1162,11 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
 		b2 := util.NewBeaconBlockAltair()
 		b2.Block.Slot = 30
 		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-		signedBlk, err := wrapper.WrappedAltairSignedBeaconBlock(b2)
+		signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
 
-		chainBlk, err := wrapper.WrappedAltairSignedBeaconBlock(headBlock.GetAltairBlock())
+		chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetAltairBlock())
 		require.NoError(t, err)
 		bs := &Server{
 			BeaconDB: beaconDB,
@@ -1057,11 +1201,11 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
 		b2 := util.NewBeaconBlockBellatrix()
 		b2.Block.Slot = 30
 		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-		signedBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(b2)
+		signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
 		require.NoError(t, err)
 		require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
 
-		chainBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.GetBellatrixBlock())
+		chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetBellatrixBlock())
 		require.NoError(t, err)
 		bs := &Server{
 			BeaconDB: beaconDB,
@@ -1096,20 +1240,29 @@ func TestServer_GetBlockRoot(t *testing.T) {
 	b2 := util.NewBeaconBlock()
 	b2.Block.Slot = 30
 	b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2)))
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	b3 := util.NewBeaconBlock()
 	b3.Block.Slot = 30
 	b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
-	require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3)))
+	wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
+	require.NoError(t, err)
+	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 
+	wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+	require.NoError(t, err)
+
+	mockChainFetcher := &mock.ChainService{
+		DB:                  beaconDB,
+		Block:               wsb,
+		Root:                headBlock.BlockRoot,
+		FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+	}
 	bs := &Server{
-		BeaconDB: beaconDB,
-		ChainInfoFetcher: &mock.ChainService{
-			DB:                  beaconDB,
-			Block:               wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block),
-			Root:                headBlock.BlockRoot,
-			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-		},
+		BeaconDB:         beaconDB,
+		ChainInfoFetcher: mockChainFetcher,
+		HeadFetcher:      mockChainFetcher,
 	}
 
 	root, err := genBlk.Block.HashTreeRoot()
@@ -1185,6 +1338,28 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			assert.DeepEqual(t, tt.want, blockRootResp.Data.Root)
 		})
 	}
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+		require.NoError(t, err)
+		mockChainFetcher := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               wsb,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+			Optimistic:          true,
+		}
+		bs := &Server{
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainFetcher,
+			HeadFetcher:      mockChainFetcher,
+		}
+		blockRootResp, err := bs.GetBlockRoot(ctx, &ethpbv1.BlockRequest{
+			BlockId: []byte("head"),
+		})
+		require.NoError(t, err)
+		assert.Equal(t, true, blockRootResp.ExecutionOptimistic)
+	})
 }
 
 func TestServer_ListBlockAttestations(t *testing.T) {
@@ -1194,14 +1369,18 @@ func TestServer_ListBlockAttestations(t *testing.T) {
 
 		_, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
 		headBlock := blkContainers[len(blkContainers)-1]
+		wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+		require.NoError(t, err)
+		mockChainService := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               wsb,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+		}
 		bs := &Server{
-			BeaconDB: beaconDB,
-			ChainInfoFetcher: &mock.ChainService{
-				DB:                  beaconDB,
-				Block:               wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block),
-				Root:                headBlock.BlockRoot,
-				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-			},
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
@@ -1292,16 +1471,18 @@ func TestServer_ListBlockAttestations(t *testing.T) {
 
 		_, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB)
 		headBlock := blkContainers[len(blkContainers)-1]
-		blk, err := wrapper.WrappedAltairSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock)
+		blk, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock)
 		require.NoError(t, err)
+		mockChainService := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               blk,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+		}
 		bs := &Server{
-			BeaconDB: beaconDB,
-			ChainInfoFetcher: &mock.ChainService{
-				DB:                  beaconDB,
-				Block:               blk,
-				Root:                headBlock.BlockRoot,
-				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-			},
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB)
@@ -1392,16 +1573,18 @@ func TestServer_ListBlockAttestations(t *testing.T) {
 
 		_, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
 		headBlock := blkContainers[len(blkContainers)-1]
-		blk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock)
+		blk, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock)
 		require.NoError(t, err)
+		mockChainService := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               blk,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+		}
 		bs := &Server{
-			BeaconDB: beaconDB,
-			ChainInfoFetcher: &mock.ChainService{
-				DB:                  beaconDB,
-				Block:               blk,
-				Root:                headBlock.BlockRoot,
-				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
-			},
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
 		}
 
 		genBlk, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
@@ -1485,4 +1668,31 @@ func TestServer_ListBlockAttestations(t *testing.T) {
 			})
 		}
 	})
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		_, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
+		headBlock := blkContainers[len(blkContainers)-1]
+		blk, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock)
+		require.NoError(t, err)
+		mockChainService := &mock.ChainService{
+			DB:                  beaconDB,
+			Block:               blk,
+			Root:                headBlock.BlockRoot,
+			FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+			Optimistic:          true,
+		}
+		bs := &Server{
+			BeaconDB:         beaconDB,
+			ChainInfoFetcher: mockChainService,
+			HeadFetcher:      mockChainService,
+		}
+		resp, err := bs.ListBlockAttestations(ctx, &ethpbv1.BlockRequest{
+			BlockId: []byte("head"),
+		})
+		require.NoError(t, err)
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
 }

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

@@ -58,11 +58,11 @@ func (bs *Server) GetStateRoot(ctx context.Context, req *ethpb.StateRequest) (*e
 	defer span.End()
 
 	var (
-		root []byte
-		err  error
+		stateRoot []byte
+		err       error
 	)
 
-	root, err = bs.StateFetcher.StateRoot(ctx, req.StateId)
+	stateRoot, err = bs.StateFetcher.StateRoot(ctx, req.StateId)
 	if err != nil {
 		if rootNotFoundErr, ok := err.(*statefetcher.StateRootNotFoundError); ok {
 			return nil, status.Errorf(codes.NotFound, "State root not found: %v", rootNotFoundErr)
@@ -71,11 +71,20 @@ func (bs *Server) GetStateRoot(ctx context.Context, req *ethpb.StateRequest) (*e
 		}
 		return nil, status.Errorf(codes.Internal, "Could not get state root: %v", err)
 	}
+	st, err := bs.StateFetcher.State(ctx, req.StateId)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not get state: %v", err)
+	}
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
 
 	return &ethpb.StateRootResponse{
 		Data: &ethpb.StateRootResponse_StateRoot{
-			Root: root,
+			Root: stateRoot,
 		},
+		ExecutionOptimistic: isOptimistic,
 	}, nil
 }
 
@@ -93,14 +102,19 @@ func (bs *Server) GetStateFork(ctx context.Context, req *ethpb.StateRequest) (*e
 	if err != nil {
 		return nil, helpers.PrepareStateFetchGRPCError(err)
 	}
-
 	fork := st.Fork()
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
 	return &ethpb.StateForkResponse{
 		Data: &ethpb.Fork{
 			PreviousVersion: fork.PreviousVersion,
 			CurrentVersion:  fork.CurrentVersion,
 			Epoch:           fork.Epoch,
 		},
+		ExecutionOptimistic: isOptimistic,
 	}, nil
 }
 
@@ -119,6 +133,10 @@ func (bs *Server) GetFinalityCheckpoints(ctx context.Context, req *ethpb.StateRe
 	if err != nil {
 		return nil, helpers.PrepareStateFetchGRPCError(err)
 	}
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
 
 	return &ethpb.StateFinalityCheckpointResponse{
 		Data: &ethpb.StateFinalityCheckpointResponse_StateFinalityCheckpoint{
@@ -126,6 +144,7 @@ func (bs *Server) GetFinalityCheckpoints(ctx context.Context, req *ethpb.StateRe
 			CurrentJustified:  checkpoint(st.CurrentJustifiedCheckpoint()),
 			Finalized:         checkpoint(st.FinalizedCheckpoint()),
 		},
+		ExecutionOptimistic: isOptimistic,
 	}, nil
 }
 

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

@@ -6,11 +6,13 @@ import (
 	"time"
 
 	chainMock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
+	dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/testutil"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	eth "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	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"
@@ -76,10 +78,15 @@ func TestGetStateRoot(t *testing.T) {
 	require.NoError(t, err)
 	stateRoot, err := fakeState.HashTreeRoot(ctx)
 	require.NoError(t, err)
+	db := dbTest.SetupDB(t)
+
 	server := &Server{
 		StateFetcher: &testutil.MockFetcher{
 			BeaconStateRoot: stateRoot[:],
+			BeaconState:     fakeState,
 		},
+		HeadFetcher: &chainMock.ChainService{},
+		BeaconDB:    db,
 	}
 
 	resp, err := server.GetStateRoot(context.Background(), &eth.StateRequest{
@@ -88,9 +95,37 @@ func TestGetStateRoot(t *testing.T) {
 	require.NoError(t, err)
 	assert.NotNil(t, resp)
 	assert.DeepEqual(t, stateRoot[:], resp.Data.Root)
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		parentRoot := [32]byte{'a'}
+		blk := util.NewBeaconBlock()
+		blk.Block.ParentRoot = parentRoot[:]
+		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.SaveGenesisBlockRoot(ctx, root))
+
+		server := &Server{
+			StateFetcher: &testutil.MockFetcher{
+				BeaconStateRoot: stateRoot[:],
+				BeaconState:     fakeState,
+			},
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
+		}
+		resp, err := server.GetStateRoot(context.Background(), &eth.StateRequest{
+			StateId: make([]byte, 0),
+		})
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.DeepEqual(t, true, resp.ExecutionOptimistic)
+	})
 }
 
 func TestGetStateFork(t *testing.T) {
+	ctx := context.Background()
 	fillFork := func(state *ethpb.BeaconState) error {
 		state.Fork = &ethpb.Fork{
 			PreviousVersion: []byte("prev"),
@@ -101,13 +136,17 @@ func TestGetStateFork(t *testing.T) {
 	}
 	fakeState, err := util.NewBeaconState(fillFork)
 	require.NoError(t, err)
+	db := dbTest.SetupDB(t)
+
 	server := &Server{
 		StateFetcher: &testutil.MockFetcher{
 			BeaconState: fakeState,
 		},
+		HeadFetcher: &chainMock.ChainService{},
+		BeaconDB:    db,
 	}
 
-	resp, err := server.GetStateFork(context.Background(), &eth.StateRequest{
+	resp, err := server.GetStateFork(ctx, &eth.StateRequest{
 		StateId: make([]byte, 0),
 	})
 	require.NoError(t, err)
@@ -116,9 +155,36 @@ func TestGetStateFork(t *testing.T) {
 	assert.Equal(t, expectedFork.Epoch, resp.Data.Epoch)
 	assert.DeepEqual(t, expectedFork.CurrentVersion, resp.Data.CurrentVersion)
 	assert.DeepEqual(t, expectedFork.PreviousVersion, resp.Data.PreviousVersion)
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		parentRoot := [32]byte{'a'}
+		blk := util.NewBeaconBlock()
+		blk.Block.ParentRoot = parentRoot[:]
+		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.SaveGenesisBlockRoot(ctx, root))
+
+		server := &Server{
+			StateFetcher: &testutil.MockFetcher{
+				BeaconState: fakeState,
+			},
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
+		}
+		resp, err := server.GetStateFork(context.Background(), &eth.StateRequest{
+			StateId: make([]byte, 0),
+		})
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.DeepEqual(t, true, resp.ExecutionOptimistic)
+	})
 }
 
 func TestGetFinalityCheckpoints(t *testing.T) {
+	ctx := context.Background()
 	fillCheckpoints := func(state *ethpb.BeaconState) error {
 		state.PreviousJustifiedCheckpoint = &ethpb.Checkpoint{
 			Root:  bytesutil.PadTo([]byte("previous"), 32),
@@ -136,13 +202,17 @@ func TestGetFinalityCheckpoints(t *testing.T) {
 	}
 	fakeState, err := util.NewBeaconState(fillCheckpoints)
 	require.NoError(t, err)
+	db := dbTest.SetupDB(t)
+
 	server := &Server{
 		StateFetcher: &testutil.MockFetcher{
 			BeaconState: fakeState,
 		},
+		HeadFetcher: &chainMock.ChainService{},
+		BeaconDB:    db,
 	}
 
-	resp, err := server.GetFinalityCheckpoints(context.Background(), &eth.StateRequest{
+	resp, err := server.GetFinalityCheckpoints(ctx, &eth.StateRequest{
 		StateId: make([]byte, 0),
 	})
 	require.NoError(t, err)
@@ -153,4 +223,30 @@ func TestGetFinalityCheckpoints(t *testing.T) {
 	assert.DeepEqual(t, fakeState.CurrentJustifiedCheckpoint().Root, resp.Data.CurrentJustified.Root)
 	assert.Equal(t, fakeState.PreviousJustifiedCheckpoint().Epoch, resp.Data.PreviousJustified.Epoch)
 	assert.DeepEqual(t, fakeState.PreviousJustifiedCheckpoint().Root, resp.Data.PreviousJustified.Root)
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		parentRoot := [32]byte{'a'}
+		blk := util.NewBeaconBlock()
+		blk.Block.ParentRoot = parentRoot[:]
+		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.SaveGenesisBlockRoot(ctx, root))
+
+		server := &Server{
+			StateFetcher: &testutil.MockFetcher{
+				BeaconState: fakeState,
+			},
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
+		}
+		resp, err := server.GetFinalityCheckpoints(context.Background(), &eth.StateRequest{
+			StateId: make([]byte, 0),
+		})
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.DeepEqual(t, true, resp.ExecutionOptimistic)
+	})
 }

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

@@ -91,11 +91,17 @@ func (bs *Server) ListSyncCommittees(ctx context.Context, req *ethpbv2.StateSync
 		return nil, status.Errorf(codes.Internal, "Could not extract sync subcommittees: %v", err)
 	}
 
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
 	return &ethpbv2.StateSyncCommitteesResponse{
 		Data: &ethpbv2.SyncCommitteeValidators{
 			Validators:          committeeIndices,
 			ValidatorAggregates: subcommittees,
 		},
+		ExecutionOptimistic: isOptimistic,
 	}, nil
 }
 

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

@@ -12,6 +12,7 @@ import (
 	types "github.com/prysmaticlabs/eth2-types"
 	grpcutil "github.com/prysmaticlabs/prysm/api/grpc"
 	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
+	dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/synccommittee"
 	mockp2p "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/prysm/v1alpha1/validator"
@@ -21,6 +22,7 @@ import (
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpbv2 "github.com/prysmaticlabs/prysm/proto/eth/v2"
 	ethpbalpha "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"
@@ -158,6 +160,7 @@ func TestListSyncCommittees(t *testing.T) {
 	}))
 	stRoot, err := st.HashTreeRoot(ctx)
 	require.NoError(t, err)
+	db := dbTest.SetupDB(t)
 
 	s := &Server{
 		GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
@@ -166,6 +169,8 @@ func TestListSyncCommittees(t *testing.T) {
 		StateFetcher: &testutil.MockFetcher{
 			BeaconState: st,
 		},
+		HeadFetcher: &mock.ChainService{},
+		BeaconDB:    db,
 	}
 	req := &ethpbv2.StateSyncCommitteesRequest{StateId: stRoot[:]}
 	resp, err := s.ListSyncCommittees(ctx, req)
@@ -188,6 +193,32 @@ func TestListSyncCommittees(t *testing.T) {
 			j++
 		}
 	}
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		parentRoot := [32]byte{'a'}
+		blk := util.NewBeaconBlock()
+		blk.Block.ParentRoot = parentRoot[:]
+		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.SaveGenesisBlockRoot(ctx, root))
+
+		s := &Server{
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			StateFetcher: &testutil.MockFetcher{
+				BeaconState: st,
+			},
+			HeadFetcher: &mock.ChainService{Optimistic: true},
+			BeaconDB:    db,
+		}
+		resp, err := s.ListSyncCommittees(ctx, req)
+		require.NoError(t, err)
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
 }
 
 type futureSyncMockFetcher struct {
@@ -228,6 +259,7 @@ func TestListSyncCommitteesFuture(t *testing.T) {
 		Pubkeys:         syncCommittee,
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}))
+	db := dbTest.SetupDB(t)
 
 	s := &Server{
 		GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
@@ -236,6 +268,8 @@ func TestListSyncCommitteesFuture(t *testing.T) {
 		StateFetcher: &futureSyncMockFetcher{
 			BeaconState: st,
 		},
+		HeadFetcher: &mock.ChainService{},
+		BeaconDB:    db,
 	}
 	req := &ethpbv2.StateSyncCommitteesRequest{}
 	epoch := 2 * params.BeaconConfig().EpochsPerSyncCommitteePeriod

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

@@ -56,7 +56,13 @@ func (bs *Server) GetValidator(ctx context.Context, req *ethpb.StateValidatorReq
 	if len(valContainer) == 0 {
 		return nil, status.Error(codes.NotFound, "Could not find validator")
 	}
-	return &ethpb.StateValidatorResponse{Data: valContainer[0]}, nil
+
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
+	return &ethpb.StateValidatorResponse{Data: valContainer[0], ExecutionOptimistic: isOptimistic}, nil
 }
 
 // ListValidators returns filterable list of validators with their balance, status and index.
@@ -74,9 +80,14 @@ func (bs *Server) ListValidators(ctx context.Context, req *ethpb.StateValidators
 		return nil, handleValContainerErr(err)
 	}
 
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
 	// Exit early if no matching validators we found or we don't want to further filter validators by status.
 	if len(valContainers) == 0 || len(req.Status) == 0 {
-		return &ethpb.StateValidatorsResponse{Data: valContainers}, nil
+		return &ethpb.StateValidatorsResponse{Data: valContainers, ExecutionOptimistic: isOptimistic}, nil
 	}
 
 	filterStatus := make(map[ethpb.ValidatorStatus]bool, len(req.Status))
@@ -106,7 +117,8 @@ func (bs *Server) ListValidators(ctx context.Context, req *ethpb.StateValidators
 			filteredVals = append(filteredVals, vc)
 		}
 	}
-	return &ethpb.StateValidatorsResponse{Data: filteredVals}, nil
+
+	return &ethpb.StateValidatorsResponse{Data: filteredVals, ExecutionOptimistic: isOptimistic}, nil
 }
 
 // ListValidatorBalances returns a filterable list of validator balances.
@@ -130,7 +142,13 @@ func (bs *Server) ListValidatorBalances(ctx context.Context, req *ethpb.Validato
 			Balance: valContainers[i].Balance,
 		}
 	}
-	return &ethpb.ValidatorBalancesResponse{Data: valBalances}, nil
+
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
+	return &ethpb.ValidatorBalancesResponse{Data: valBalances, ExecutionOptimistic: isOptimistic}, nil
 }
 
 // ListCommittees retrieves the committees for the given state at the given epoch.
@@ -183,7 +201,13 @@ func (bs *Server) ListCommittees(ctx context.Context, req *ethpb.StateCommittees
 			committees = append(committees, committeeContainer)
 		}
 	}
-	return &ethpb.StateCommitteesResponse{Data: committees}, nil
+
+	isOptimistic, err := helpers.IsOptimistic(ctx, st, bs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
+	return &ethpb.StateCommitteesResponse{Data: committees, ExecutionOptimistic: isOptimistic}, nil
 }
 
 // This function returns the validator object based on the passed in ID. The validator ID could be its public key,

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

@@ -8,6 +8,7 @@ import (
 
 	types "github.com/prysmaticlabs/eth2-types"
 	chainMock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
+	dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	rpchelpers "github.com/prysmaticlabs/prysm/beacon-chain/rpc/eth/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/statefetcher"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/testutil"
@@ -17,6 +18,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	"github.com/prysmaticlabs/prysm/proto/migration"
 	eth "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"
@@ -25,6 +27,7 @@ import (
 
 func TestGetValidator(t *testing.T) {
 	ctx := context.Background()
+	db := dbTest.SetupDB(t)
 
 	var st state.BeaconState
 	st, _ = util.DeterministicGenesisState(t, 8192)
@@ -34,6 +37,8 @@ func TestGetValidator(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.GetValidator(ctx, &ethpb.StateValidatorRequest{
@@ -49,6 +54,8 @@ func TestGetValidator(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		pubKey := st.PubkeyAtIndex(types.ValidatorIndex(20))
@@ -66,16 +73,45 @@ func TestGetValidator(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 		_, err := s.GetValidator(ctx, &ethpb.StateValidatorRequest{
 			StateId: []byte("head"),
 		})
 		require.ErrorContains(t, "Validator ID is required", err)
 	})
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		parentRoot := [32]byte{'a'}
+		blk := util.NewBeaconBlock()
+		blk.Block.ParentRoot = parentRoot[:]
+		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.SaveGenesisBlockRoot(ctx, root))
+
+		s := Server{
+			StateFetcher: &testutil.MockFetcher{
+				BeaconState: st,
+			},
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
+		}
+		resp, err := s.GetValidator(ctx, &ethpb.StateValidatorRequest{
+			StateId:     []byte("head"),
+			ValidatorId: []byte("15"),
+		})
+		require.NoError(t, err)
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
 }
 
 func TestListValidators(t *testing.T) {
 	ctx := context.Background()
+	db := dbTest.SetupDB(t)
 
 	var st state.BeaconState
 	st, _ = util.DeterministicGenesisState(t, 8192)
@@ -85,6 +121,8 @@ func TestListValidators(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -102,6 +140,8 @@ func TestListValidators(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		ids := [][]byte{[]byte("15"), []byte("26"), []byte("400")}
@@ -122,6 +162,8 @@ func TestListValidators(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 		idNums := []types.ValidatorIndex{20, 66, 90, 100}
 		pubkey1 := st.PubkeyAtIndex(types.ValidatorIndex(20))
@@ -146,6 +188,8 @@ func TestListValidators(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		idNums := []types.ValidatorIndex{20, 90, 170, 129}
@@ -172,6 +216,8 @@ func TestListValidators(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		existingKey := st.PubkeyAtIndex(types.ValidatorIndex(1))
@@ -190,6 +236,8 @@ func TestListValidators(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		ids := [][]byte{[]byte("1"), []byte("99999")}
@@ -201,10 +249,36 @@ func TestListValidators(t *testing.T) {
 		require.Equal(t, 1, len(resp.Data))
 		assert.Equal(t, types.ValidatorIndex(1), resp.Data[0].Index)
 	})
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		parentRoot := [32]byte{'a'}
+		blk := util.NewBeaconBlock()
+		blk.Block.ParentRoot = parentRoot[:]
+		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.SaveGenesisBlockRoot(ctx, root))
+
+		s := Server{
+			StateFetcher: &testutil.MockFetcher{
+				BeaconState: st,
+			},
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
+		}
+		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
+			StateId: []byte("head"),
+		})
+		require.NoError(t, err)
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
 }
 
 func TestListValidators_Status(t *testing.T) {
 	ctx := context.Background()
+	db := dbTest.SetupDB(t)
 
 	var st state.BeaconState
 	st, _ = util.DeterministicGenesisState(t, 8192)
@@ -279,6 +353,8 @@ func TestListValidators_Status(t *testing.T) {
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -312,6 +388,8 @@ func TestListValidators_Status(t *testing.T) {
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -344,6 +422,8 @@ func TestListValidators_Status(t *testing.T) {
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -375,6 +455,8 @@ func TestListValidators_Status(t *testing.T) {
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -406,6 +488,8 @@ func TestListValidators_Status(t *testing.T) {
 			StateFetcher: &statefetcher.StateProvider{
 				ChainInfoFetcher: &chainMock.ChainService{State: st},
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListValidators(ctx, &ethpb.StateValidatorsRequest{
@@ -436,6 +520,7 @@ func TestListValidators_Status(t *testing.T) {
 }
 func TestListValidatorBalances(t *testing.T) {
 	ctx := context.Background()
+	db := dbTest.SetupDB(t)
 
 	var st state.BeaconState
 	count := uint64(8192)
@@ -451,6 +536,8 @@ func TestListValidatorBalances(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		ids := [][]byte{[]byte("15"), []byte("26"), []byte("400")}
@@ -471,6 +558,8 @@ func TestListValidatorBalances(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 		idNums := []types.ValidatorIndex{20, 66, 90, 100}
 		pubkey1 := st.PubkeyAtIndex(types.ValidatorIndex(20))
@@ -494,6 +583,8 @@ func TestListValidatorBalances(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		idNums := []types.ValidatorIndex{20, 90, 170, 129}
@@ -510,10 +601,39 @@ func TestListValidatorBalances(t *testing.T) {
 			assert.Equal(t, balances[val.Index], val.Balance)
 		}
 	})
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		parentRoot := [32]byte{'a'}
+		blk := util.NewBeaconBlock()
+		blk.Block.ParentRoot = parentRoot[:]
+		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.SaveGenesisBlockRoot(ctx, root))
+
+		s := Server{
+			StateFetcher: &testutil.MockFetcher{
+				BeaconState: st,
+			},
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
+		}
+
+		ids := [][]byte{[]byte("15"), []byte("26"), []byte("400")}
+		resp, err := s.ListValidatorBalances(ctx, &ethpb.ValidatorBalancesRequest{
+			StateId: []byte("head"),
+			Id:      ids,
+		})
+		require.NoError(t, err)
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
 }
 
 func TestListCommittees(t *testing.T) {
 	ctx := context.Background()
+	db := dbTest.SetupDB(t)
 
 	var st state.BeaconState
 	st, _ = util.DeterministicGenesisState(t, 8192)
@@ -524,6 +644,8 @@ func TestListCommittees(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		resp, err := s.ListCommittees(ctx, &ethpb.StateCommitteesRequest{
@@ -542,6 +664,8 @@ func TestListCommittees(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 		epoch := types.Epoch(10)
 		resp, err := s.ListCommittees(ctx, &ethpb.StateCommitteesRequest{
@@ -559,6 +683,8 @@ func TestListCommittees(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		slot := types.Slot(4)
@@ -582,6 +708,8 @@ func TestListCommittees(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		index := types.CommitteeIndex(1)
@@ -605,6 +733,8 @@ func TestListCommittees(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: st,
 			},
+			HeadFetcher: &chainMock.ChainService{},
+			BeaconDB:    db,
 		}
 
 		index := types.CommitteeIndex(1)
@@ -622,4 +752,30 @@ func TestListCommittees(t *testing.T) {
 			assert.Equal(t, index, datum.Index)
 		}
 	})
+
+	t.Run("execution optimistic", func(t *testing.T) {
+		parentRoot := [32]byte{'a'}
+		blk := util.NewBeaconBlock()
+		blk.Block.ParentRoot = parentRoot[:]
+		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.SaveGenesisBlockRoot(ctx, root))
+
+		s := Server{
+			StateFetcher: &testutil.MockFetcher{
+				BeaconState: st,
+			},
+			HeadFetcher: &chainMock.ChainService{Optimistic: true},
+			BeaconDB:    db,
+		}
+
+		resp, err := s.ListCommittees(ctx, &ethpb.StateCommitteesRequest{
+			StateId: []byte("head"),
+		})
+		require.NoError(t, err)
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
 }

beacon-chain/rpc/eth/debug/BUILD.bazel

@@ -31,10 +31,12 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/blockchain/testing:go_default_library",
+        "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/rpc/testutil:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
+        "//proto/prysm/v1alpha1/wrapper:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

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

@@ -65,6 +65,11 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 	if err != nil {
 		return nil, helpers.PrepareStateFetchGRPCError(err)
 	}
+	isOptimistic, err := helpers.IsOptimistic(ctx, beaconSt, ds.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
 	switch beaconSt.Version() {
 	case version.Phase0:
 		protoSt, err := migration.BeaconStateToProto(beaconSt)
@@ -76,6 +81,7 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 			Data: &ethpbv2.BeaconStateContainer{
 				State: &ethpbv2.BeaconStateContainer_Phase0State{Phase0State: protoSt},
 			},
+			ExecutionOptimistic: isOptimistic,
 		}, nil
 	case version.Altair:
 		altairState, ok := beaconSt.(state.BeaconStateAltair)
@@ -91,6 +97,7 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 			Data: &ethpbv2.BeaconStateContainer{
 				State: &ethpbv2.BeaconStateContainer_AltairState{AltairState: protoState},
 			},
+			ExecutionOptimistic: isOptimistic,
 		}, nil
 	case version.Bellatrix:
 		bellatrixState, ok := beaconSt.(state.BeaconStateBellatrix)
@@ -106,6 +113,7 @@ func (ds *Server) GetBeaconStateV2(ctx context.Context, req *ethpbv2.StateReques
 			Data: &ethpbv2.BeaconStateContainer{
 				State: &ethpbv2.BeaconStateContainer_BellatrixState{BellatrixState: protoState},
 			},
+			ExecutionOptimistic: isOptimistic,
 		}, nil
 	default:
 		return nil, status.Error(codes.Internal, "Unsupported state version")

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

@@ -6,10 +6,12 @@ import (
 
 	types "github.com/prysmaticlabs/eth2-types"
 	blockchainmock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
+	dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/testutil"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/proto/eth/v2"
+	"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"
@@ -32,6 +34,9 @@ func TestGetBeaconState(t *testing.T) {
 }
 
 func TestGetBeaconStateV2(t *testing.T) {
+	ctx := context.Background()
+	db := dbTest.SetupDB(t)
+
 	t.Run("Phase 0", func(t *testing.T) {
 		fakeState, err := util.NewBeaconState()
 		require.NoError(t, err)
@@ -39,6 +44,8 @@ func TestGetBeaconStateV2(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: fakeState,
 			},
+			HeadFetcher: &blockchainmock.ChainService{},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetBeaconStateV2(context.Background(), &ethpbv2.StateRequestV2{
 			StateId: make([]byte, 0),
@@ -53,6 +60,8 @@ func TestGetBeaconStateV2(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: fakeState,
 			},
+			HeadFetcher: &blockchainmock.ChainService{},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetBeaconStateV2(context.Background(), &ethpbv2.StateRequestV2{
 			StateId: make([]byte, 0),
@@ -67,6 +76,8 @@ func TestGetBeaconStateV2(t *testing.T) {
 			StateFetcher: &testutil.MockFetcher{
 				BeaconState: fakeState,
 			},
+			HeadFetcher: &blockchainmock.ChainService{},
+			BeaconDB:    db,
 		}
 		resp, err := server.GetBeaconStateV2(context.Background(), &ethpbv2.StateRequestV2{
 			StateId: make([]byte, 0),
@@ -75,6 +86,32 @@ func TestGetBeaconStateV2(t *testing.T) {
 		assert.NotNil(t, resp)
 		assert.Equal(t, ethpbv2.Version_BELLATRIX, resp.Version)
 	})
+	t.Run("execution optimistic", func(t *testing.T) {
+		parentRoot := [32]byte{'a'}
+		blk := util.NewBeaconBlock()
+		blk.Block.ParentRoot = parentRoot[:]
+		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.SaveGenesisBlockRoot(ctx, root))
+
+		fakeState, _ := util.DeterministicGenesisStateBellatrix(t, 1)
+		server := &Server{
+			StateFetcher: &testutil.MockFetcher{
+				BeaconState: fakeState,
+			},
+			HeadFetcher: &blockchainmock.ChainService{Optimistic: true},
+			BeaconDB:    db,
+		}
+		resp, err := server.GetBeaconStateV2(context.Background(), &ethpbv2.StateRequestV2{
+			StateId: make([]byte, 0),
+		})
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.Equal(t, true, resp.ExecutionOptimistic)
+	})
 }
 
 func TestGetBeaconStateSSZ(t *testing.T) {

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

@@ -124,8 +124,9 @@ func handleBlockEvents(
 			return errors.Wrap(err, "could not hash tree root block")
 		}
 		eventBlock := &ethpb.EventBlock{
-			Slot:  v1Data.Message.Slot,
-			Block: item[:],
+			Slot:                v1Data.Message.Slot,
+			Block:               item[:],
+			ExecutionOptimistic: blkData.IsOptimistic,
 		}
 		return streamData(stream, BlockTopic, eventBlock)
 	default:

beacon-chain/rpc/eth/events/events_test.go

@@ -57,15 +57,17 @@ func TestStreamEvents_BlockEvents(t *testing.T) {
 		wantedBlockRoot, err := wantedBlock.HashTreeRoot()
 		require.NoError(t, err)
 		genericResponse, err := anypb.New(&ethpb.EventBlock{
-			Slot:  8,
-			Block: wantedBlockRoot[:],
+			Slot:                8,
+			Block:               wantedBlockRoot[:],
+			ExecutionOptimistic: true,
 		})
 		require.NoError(t, err)
 		wantedMessage := &gateway.EventSource{
 			Event: BlockTopic,
 			Data:  genericResponse,
 		}
-
+		wsb, err := wrapper.WrappedSignedBeaconBlock(wantedBlock)
+		require.NoError(t, err)
 		assertFeedSendAndReceive(ctx, &assertFeedArgs{
 			t:             t,
 			srv:           srv,
@@ -75,7 +77,8 @@ func TestStreamEvents_BlockEvents(t *testing.T) {
 			itemToSend: &feed.Event{
 				Type: blockfeed.ReceivedBlock,
 				Data: &blockfeed.ReceivedBlockData{
-					SignedBlock: wrapper.WrappedPhase0SignedBeaconBlock(wantedBlock),
+					SignedBlock:  wsb,
+					IsOptimistic: true,
 				},
 			},
 			feed: srv.BlockNotifier.BlockFeed(),
@@ -244,6 +247,7 @@ func TestStreamEvents_StateEvents(t *testing.T) {
 			EpochTransition:           true,
 			PreviousDutyDependentRoot: make([]byte, 32),
 			CurrentDutyDependentRoot:  make([]byte, 32),
+			ExecutionOptimistic:       true,
 		}
 		genericResponse, err := anypb.New(wantedHead)
 		require.NoError(t, err)
@@ -271,9 +275,10 @@ func TestStreamEvents_StateEvents(t *testing.T) {
 		defer ctrl.Finish()
 
 		wantedCheckpoint := &ethpb.EventFinalizedCheckpoint{
-			Block: make([]byte, 32),
-			State: make([]byte, 32),
-			Epoch: 8,
+			Block:               make([]byte, 32),
+			State:               make([]byte, 32),
+			Epoch:               8,
+			ExecutionOptimistic: true,
 		}
 		genericResponse, err := anypb.New(wantedCheckpoint)
 		require.NoError(t, err)
@@ -301,13 +306,14 @@ func TestStreamEvents_StateEvents(t *testing.T) {
 		defer ctrl.Finish()
 
 		wantedReorg := &ethpb.EventChainReorg{
-			Slot:         8,
-			Depth:        1,
-			OldHeadBlock: make([]byte, 32),
-			NewHeadBlock: make([]byte, 32),
-			OldHeadState: make([]byte, 32),
-			NewHeadState: make([]byte, 32),
-			Epoch:        0,
+			Slot:                8,
+			Depth:               1,
+			OldHeadBlock:        make([]byte, 32),
+			NewHeadBlock:        make([]byte, 32),
+			OldHeadState:        make([]byte, 32),
+			NewHeadState:        make([]byte, 32),
+			Epoch:               0,
+			ExecutionOptimistic: true,
 		}
 		genericResponse, err := anypb.New(wantedReorg)
 		require.NoError(t, err)

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

@@ -12,7 +12,7 @@ import (
 // PrepareStateFetchGRPCError returns an appropriate gRPC error based on the supplied argument.
 // The argument error should be a result of fetching state.
 func PrepareStateFetchGRPCError(err error) error {
-	if errors.Is(err, stategen.ErrSlotBeforeOrigin) {
+	if errors.Is(err, stategen.ErrNoDataForSlot) {
 		return status.Errorf(codes.NotFound, "lacking historical data needed to fulfill request")
 	}
 	if stateNotFoundErr, ok := err.(*statefetcher.StateNotFoundError); ok {

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

@@ -4,8 +4,10 @@ import (
 	"context"
 	"strconv"
 
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/api/grpc"
 	"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/sync"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -35,3 +37,22 @@ func ValidateSync(ctx context.Context, syncChecker sync.Checker, headFetcher blo
 	}
 	return status.Error(codes.Unavailable, "Syncing to latest head, not ready to respond")
 }
+
+// IsOptimistic checks whether the latest block header of the passed in beacon state is the header of an optimistic block.
+func IsOptimistic(ctx context.Context, st state.BeaconState, headFetcher blockchain.HeadFetcher) (bool, error) {
+	root, err := st.HashTreeRoot(ctx)
+	if err != nil {
+		return false, errors.Wrap(err, "could not get state root")
+	}
+	header := st.LatestBlockHeader()
+	header.StateRoot = root[:]
+	headRoot, err := header.HashTreeRoot()
+	if err != nil {
+		return false, errors.Wrap(err, "could not get header root")
+	}
+	isOptimistic, err := headFetcher.IsOptimisticForRoot(ctx, headRoot)
+	if err != nil {
+		return false, errors.Wrap(err, "could not check if block is optimistic")
+	}
+	return isOptimistic, nil
+}

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

@@ -51,3 +51,22 @@ func TestValidateSync(t *testing.T) {
 		require.NoError(t, err)
 	})
 }
+
+func TestIsOptimistic(t *testing.T) {
+	ctx := context.Background()
+	st, err := util.NewBeaconState()
+	require.NoError(t, err)
+
+	t.Run("optimistic", func(t *testing.T) {
+		mockHeadFetcher := &chainmock.ChainService{Optimistic: true}
+		o, err := IsOptimistic(ctx, st, mockHeadFetcher)
+		require.NoError(t, err)
+		assert.Equal(t, true, o)
+	})
+	t.Run("not optimistic", func(t *testing.T) {
+		mockHeadFetcher := &chainmock.ChainService{Optimistic: false}
+		o, err := IsOptimistic(ctx, st, mockHeadFetcher)
+		require.NoError(t, err)
+		assert.Equal(t, false, o)
+	})
+}

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

@@ -58,6 +58,11 @@ func (vs *Server) GetAttesterDuties(ctx context.Context, req *ethpbv1.AttesterDu
 		return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err)
 	}
 
+	isOptimistic, err := rpchelpers.IsOptimistic(ctx, s, vs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
 	s, err = advanceState(ctx, s, req.Epoch, currentEpoch)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not advance state to requested epoch start slot: %v", err)
@@ -110,8 +115,9 @@ func (vs *Server) GetAttesterDuties(ctx context.Context, req *ethpbv1.AttesterDu
 	}
 
 	return &ethpbv1.AttesterDutiesResponse{
-		DependentRoot: root,
-		Data:          duties,
+		DependentRoot:       root,
+		Data:                duties,
+		ExecutionOptimistic: isOptimistic,
 	}, nil
 }
 
@@ -136,6 +142,11 @@ func (vs *Server) GetProposerDuties(ctx context.Context, req *ethpbv1.ProposerDu
 		return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err)
 	}
 
+	isOptimistic, err := rpchelpers.IsOptimistic(ctx, s, vs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
 	s, err = advanceState(ctx, s, req.Epoch, currentEpoch)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not advance state to requested epoch start slot: %v", err)
@@ -172,8 +183,9 @@ func (vs *Server) GetProposerDuties(ctx context.Context, req *ethpbv1.ProposerDu
 	}
 
 	return &ethpbv1.ProposerDutiesResponse{
-		DependentRoot: root,
-		Data:          duties,
+		DependentRoot:       root,
+		Data:                duties,
+		ExecutionOptimistic: isOptimistic,
 	}, nil
 }
 
@@ -245,8 +257,15 @@ func (vs *Server) GetSyncCommitteeDuties(ctx context.Context, req *ethpbv2.SyncC
 	} else if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not get duties: %v", err)
 	}
+
+	isOptimistic, err := rpchelpers.IsOptimistic(ctx, st, vs.HeadFetcher)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not check if slot's block is optimistic: %v", err)
+	}
+
 	return &ethpbv2.SyncCommitteeDutiesResponse{
-		Data: duties,
+		Data:                duties,
+		ExecutionOptimistic: isOptimistic,
 	}, nil
 }