RPC adds builder service

.github/workflows/go.yml

@@ -62,9 +62,10 @@ jobs:
           id: go
 
       - name: Golangci-lint
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v2
         with:
-          version: v1.47.2
+          version: v1.45.2
+          skip-go-installation: true
 
   build:
     name: Build

BUILD.bazel

@@ -122,7 +122,6 @@ nogo(
         "//tools/analyzers/gocognit:go_default_library",
         "//tools/analyzers/ineffassign:go_default_library",
         "//tools/analyzers/interfacechecker:go_default_library",
-        "//tools/analyzers/logruswitherror:go_default_library",
         "//tools/analyzers/maligned:go_default_library",
         "//tools/analyzers/nop:go_default_library",
         "//tools/analyzers/properpermissions:go_default_library",

README.md

@@ -5,7 +5,6 @@
 [![Consensus_Spec_Version 1.2.0-rc.1](https://img.shields.io/badge/Consensus%20Spec%20Version-v1.2.0.rc.1-blue.svg)](https://github.com/ethereum/consensus-specs/tree/v1.2.0-rc.1)
 [![Execution_API_Version 1.0.0-alpha.9](https://img.shields.io/badge/Execution%20API%20Version-v1.0.0.alpha.9-blue.svg)](https://github.com/ethereum/execution-apis/tree/v1.0.0-alpha.9/src/engine)
 [![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)
-[![GitPOAP Badge](https://public-api.gitpoap.io/v1/repo/prysmaticlabs/prysm/badge)](https://www.gitpoap.io/gh/prysmaticlabs/prysm)
 
 This is the core repository for Prysm, a [Golang](https://golang.org/) implementation of the [Ethereum Consensus](https://ethereum.org/en/eth2/) specification, developed by [Prysmatic Labs](https://prysmaticlabs.com). See the [Changelog](https://github.com/prysmaticlabs/prysm/releases) for details of the latest releases and upcoming breaking changes.
 

WORKSPACE

@@ -88,10 +88,10 @@ http_archive(
         # Expose internals of go_test for custom build transitions.
         "//third_party:io_bazel_rules_go_test.patch",
     ],
-    sha256 = "16e9fca53ed6bd4ff4ad76facc9b7b651a89db1689a2877d6fd7b82aa824e366",
+    sha256 = "f2dcd210c7095febe54b804bb1cd3a58fe8435a909db2ec04e31542631cf715c",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.34.0/rules_go-v0.34.0.zip",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.34.0/rules_go-v0.34.0.zip",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.31.0/rules_go-v0.31.0.zip",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.31.0/rules_go-v0.31.0.zip",
     ],
 )
 
@@ -176,7 +176,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.18.5",
+    go_version = "1.18.1",
     nogo = "@//:nogo",
 )
 
@@ -309,9 +309,9 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "126b615e3853e29b61f082f6c89c8bc1c38cd92fb84b0004396fc49e7acc8d9f",
-    strip_prefix = "eth2-networks-f3ccbe0cf5798d5cd23e4e6e7119aefa043c0935",
-    url = "https://github.com/eth-clients/eth2-networks/archive/f3ccbe0cf5798d5cd23e4e6e7119aefa043c0935.tar.gz",
+    sha256 = "4e8a18b21d056c4032605621b1a6632198eabab57cb90c61e273f344c287f1b2",
+    strip_prefix = "eth2-networks-791a5369c5981e829698b17fbcdcdacbdaba97c8",
+    url = "https://github.com/eth-clients/eth2-networks/archive/791a5369c5981e829698b17fbcdcdacbdaba97c8.tar.gz",
 )
 
 http_archive(
@@ -342,9 +342,9 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 """,
-    sha256 = "98013b40922e54a64996da49b939e0a88fe2456f68eedc5aee4ceba0f8623f71",
+    sha256 = "4797a7e594a5b1f4c1c8080701613f3ee451b01ec0861499ea7d9b60877a6b23",
     urls = [
-        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v2.0.0/prysm-web-ui.tar.gz",
+        "https://github.com/prysmaticlabs/prysm-web-ui/releases/download/v1.0.3/prysm-web-ui.tar.gz",
     ],
 )
 

api/client/beacon/BUILD.bazel

@@ -40,9 +40,8 @@ go_test(
     deps = [
         "//beacon-chain/state:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/blocks/testing:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//encoding/ssz/detect:go_default_library",
         "//network/forks:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

api/client/beacon/checkpoint_test.go

@@ -10,9 +10,9 @@ import (
 	"net/url"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
+
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
-	blocktest "github.com/prysmaticlabs/prysm/consensus-types/blocks/testing"
 	"github.com/prysmaticlabs/prysm/network/forks"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/util"
@@ -134,14 +134,10 @@ func TestDownloadWeakSubjectivityCheckpoint(t *testing.T) {
 	require.NoError(t, wst.SetFork(fork))
 
 	// set up checkpoint block
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	b, err = blocktest.SetBlockParentRoot(b, cfg.ZeroHash)
-	require.NoError(t, err)
-	b, err = blocktest.SetBlockSlot(b, wSlot)
-	require.NoError(t, err)
-	b, err = blocktest.SetProposerIndex(b, 0)
-	require.NoError(t, err)
+	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()
@@ -155,8 +151,7 @@ func TestDownloadWeakSubjectivityCheckpoint(t *testing.T) {
 	wRoot, err := wst.HashTreeRoot(ctx)
 	require.NoError(t, err)
 
-	b, err = blocktest.SetBlockStateRoot(b, wRoot)
-	require.NoError(t, err)
+	require.NoError(t, wrapper.SetBlockStateRoot(b, wRoot))
 	serBlock, err := b.MarshalSSZ()
 	require.NoError(t, err)
 	bRoot, err := b.Block().HashTreeRoot()
@@ -235,14 +230,10 @@ func TestDownloadBackwardsCompatibleCombined(t *testing.T) {
 	require.NoError(t, wst.SetFork(fork))
 
 	// set up checkpoint block
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	b, err = blocktest.SetBlockParentRoot(b, cfg.ZeroHash)
-	require.NoError(t, err)
-	b, err = blocktest.SetBlockSlot(b, wSlot)
-	require.NoError(t, err)
-	b, err = blocktest.SetProposerIndex(b, 0)
-	require.NoError(t, err)
+	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()
@@ -256,8 +247,7 @@ func TestDownloadBackwardsCompatibleCombined(t *testing.T) {
 	wRoot, err := wst.HashTreeRoot(ctx)
 	require.NoError(t, err)
 
-	b, err = blocktest.SetBlockStateRoot(b, wRoot)
-	require.NoError(t, err)
+	require.NoError(t, wrapper.SetBlockStateRoot(b, wRoot))
 	serBlock, err := b.MarshalSSZ()
 	require.NoError(t, err)
 	bRoot, err := b.Block().HashTreeRoot()
@@ -420,14 +410,10 @@ func TestDownloadFinalizedData(t *testing.T) {
 	require.NoError(t, st.SetFork(fork))
 
 	// set up checkpoint block
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
-	require.NoError(t, err)
-	b, err = blocktest.SetBlockParentRoot(b, cfg.ZeroHash)
-	require.NoError(t, err)
-	b, err = blocktest.SetBlockSlot(b, slot)
-	require.NoError(t, err)
-	b, err = blocktest.SetProposerIndex(b, 0)
-	require.NoError(t, err)
+	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
+	require.NoError(t, wrapper.SetBlockParentRoot(b, cfg.ZeroHash))
+	require.NoError(t, wrapper.SetBlockSlot(b, slot))
+	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()
@@ -441,8 +427,7 @@ func TestDownloadFinalizedData(t *testing.T) {
 	sr, err := st.HashTreeRoot(ctx)
 	require.NoError(t, err)
 
-	b, err = blocktest.SetBlockStateRoot(b, sr)
-	require.NoError(t, err)
+	require.NoError(t, wrapper.SetBlockStateRoot(b, sr))
 	mb, err := b.MarshalSSZ()
 	require.NoError(t, err)
 	br, err := b.Block().HashTreeRoot()

api/client/builder/BUILD.bazel

@@ -12,13 +12,11 @@ go_library(
     deps = [
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//monitoring/tracing:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 
@@ -38,7 +36,6 @@ go_test(
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_golang_protobuf//proto:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
 )

api/client/builder/client.go

@@ -12,13 +12,12 @@ import (
 	"text/template"
 	"time"
 
-	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+
+	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
 	log "github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
 )
 
 const (
@@ -129,51 +128,37 @@ func (c *Client) NodeURL() string {
 
 type reqOption func(*http.Request)
 
-// do is a generic, opinionated request function to reduce boilerplate amongst the methods in this package api/client/builder/types.go.
-func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, opts ...reqOption) (res []byte, err error) {
-	ctx, span := trace.StartSpan(ctx, "builder.client.do")
-	defer func() {
-		tracing.AnnotateError(span, err)
-		span.End()
-	}()
-
+// do is a generic, opinionated GET function to reduce boilerplate amongst the getters in this packageapi/client/builder/types.go.
+func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, opts ...reqOption) ([]byte, error) {
 	u := c.baseURL.ResolveReference(&url.URL{Path: path})
-
-	span.AddAttributes(trace.StringAttribute("url", u.String()),
-		trace.StringAttribute("method", method))
-
+	log.Printf("requesting %s", u.String())
 	req, err := http.NewRequestWithContext(ctx, method, u.String(), body)
 	if err != nil {
-		return
+		return nil, err
 	}
 	for _, o := range opts {
 		o(req)
 	}
 	for _, o := range c.obvs {
-		if err = o.observe(req); err != nil {
-			return
+		if err := o.observe(req); err != nil {
+			return nil, err
 		}
 	}
 	r, err := c.hc.Do(req)
 	if err != nil {
-		return
+		return nil, err
 	}
 	defer func() {
-		closeErr := r.Body.Close()
-		if closeErr != nil {
-			log.WithError(closeErr).Error("Failed to close response body")
-		}
+		err = r.Body.Close()
 	}()
 	if r.StatusCode != http.StatusOK {
-		err = non200Err(r)
-		return
+		return nil, non200Err(r)
 	}
-	res, err = io.ReadAll(r.Body)
+	b, err := io.ReadAll(r.Body)
 	if err != nil {
-		err = errors.Wrap(err, "error reading http response body from builder server")
-		return
+		return nil, errors.Wrap(err, "error reading http response body from GetBlock")
 	}
-	return
+	return b, nil
 }
 
 var execHeaderTemplate = template.Must(template.New("").Parse(getExecHeaderPath))
@@ -216,14 +201,8 @@ func (c *Client) GetHeader(ctx context.Context, slot types.Slot, parentHash [32]
 // RegisterValidator encodes the SignedValidatorRegistrationV1 message to json (including hex-encoding the byte
 // fields with 0x prefixes) and posts to the builder validator registration endpoint.
 func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValidatorRegistrationV1) error {
-	ctx, span := trace.StartSpan(ctx, "builder.client.RegisterValidator")
-	defer span.End()
-	span.AddAttributes(trace.Int64Attribute("num_reqs", int64(len(svr))))
-
 	if len(svr) == 0 {
-		err := errors.Wrap(errMalformedRequest, "empty validator registration list")
-		tracing.AnnotateError(span, err)
-		return err
+		return errors.Wrap(errMalformedRequest, "empty validator registration list")
 	}
 	vs := make([]*SignedValidatorRegistration, len(svr))
 	for i := 0; i < len(svr); i++ {
@@ -231,11 +210,8 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 	}
 	body, err := json.Marshal(vs)
 	if err != nil {
-		err := errors.Wrap(err, "error encoding the SignedValidatorRegistration value body in RegisterValidator")
-		tracing.AnnotateError(span, err)
-		return err
+		return errors.Wrap(err, "error encoding the SignedValidatorRegistration value body in RegisterValidator")
 	}
-
 	_, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body))
 	return err
 }

api/client/builder/types.go

@@ -31,22 +31,6 @@ func (r *SignedValidatorRegistration) MarshalJSON() ([]byte, error) {
 	})
 }
 
-func (r *SignedValidatorRegistration) UnmarshalJSON(b []byte) error {
-	if r.SignedValidatorRegistrationV1 == nil {
-		r.SignedValidatorRegistrationV1 = &eth.SignedValidatorRegistrationV1{}
-	}
-	o := struct {
-		Message   *ValidatorRegistration `json:"message,omitempty"`
-		Signature hexutil.Bytes          `json:"signature,omitempty"`
-	}{}
-	if err := json.Unmarshal(b, &o); err != nil {
-		return err
-	}
-	r.Message = o.Message.ValidatorRegistrationV1
-	r.Signature = o.Signature
-	return nil
-}
-
 func (r *ValidatorRegistration) MarshalJSON() ([]byte, error) {
 	return json.Marshal(struct {
 		FeeRecipient hexutil.Bytes `json:"fee_recipient,omitempty"`
@@ -61,33 +45,6 @@ func (r *ValidatorRegistration) MarshalJSON() ([]byte, error) {
 	})
 }
 
-func (r *ValidatorRegistration) UnmarshalJSON(b []byte) error {
-	if r.ValidatorRegistrationV1 == nil {
-		r.ValidatorRegistrationV1 = &eth.ValidatorRegistrationV1{}
-	}
-	o := struct {
-		FeeRecipient hexutil.Bytes `json:"fee_recipient,omitempty"`
-		GasLimit     string        `json:"gas_limit,omitempty"`
-		Timestamp    string        `json:"timestamp,omitempty"`
-		Pubkey       hexutil.Bytes `json:"pubkey,omitempty"`
-	}{}
-	if err := json.Unmarshal(b, &o); err != nil {
-		return err
-	}
-
-	r.FeeRecipient = o.FeeRecipient
-	r.Pubkey = o.Pubkey
-	var err error
-	if r.GasLimit, err = strconv.ParseUint(o.GasLimit, 10, 64); err != nil {
-		return errors.Wrap(err, "failed to parse gas limit")
-	}
-	if r.Timestamp, err = strconv.ParseUint(o.Timestamp, 10, 64); err != nil {
-		return errors.Wrap(err, "failed to parse timestamp")
-	}
-
-	return nil
-}
-
 type Uint256 struct {
 	*big.Int
 }

api/client/builder/types_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/golang/protobuf/proto"
 	"github.com/prysmaticlabs/go-bitfield"
 	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -32,8 +31,7 @@ func TestSignedValidatorRegistration_MarshalJSON(t *testing.T) {
 		},
 		Signature: make([]byte, 96),
 	}
-	a := &SignedValidatorRegistration{SignedValidatorRegistrationV1: svr}
-	je, err := json.Marshal(a)
+	je, err := json.Marshal(&SignedValidatorRegistration{SignedValidatorRegistrationV1: svr})
 	require.NoError(t, err)
 	// decode with a struct w/ plain strings so we can check the string encoding of the hex fields
 	un := struct {
@@ -47,14 +45,6 @@ func TestSignedValidatorRegistration_MarshalJSON(t *testing.T) {
 	require.Equal(t, "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", un.Signature)
 	require.Equal(t, "0x0000000000000000000000000000000000000000", un.Message.FeeRecipient)
 	require.Equal(t, "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", un.Message.Pubkey)
-
-	t.Run("roundtrip", func(t *testing.T) {
-		b := &SignedValidatorRegistration{}
-		if err := json.Unmarshal(je, b); err != nil {
-			require.NoError(t, err)
-		}
-		require.Equal(t, proto.Equal(a.SignedValidatorRegistrationV1, b.SignedValidatorRegistrationV1), true)
-	})
 }
 
 var testExampleHeaderResponse = `{

async/debounce_test.go

@@ -3,7 +3,6 @@ package async_test
 import (
 	"context"
 	"sync"
-	"sync/atomic"
 	"testing"
 	"time"
 
@@ -17,7 +16,7 @@ func TestDebounce_NoEvents(t *testing.T) {
 	eventsChan := make(chan interface{}, 100)
 	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
-	timesHandled := int32(0)
+	timesHandled := 0
 	wg := &sync.WaitGroup{}
 	wg.Add(1)
 	go func() {
@@ -27,21 +26,21 @@ func TestDebounce_NoEvents(t *testing.T) {
 	}()
 	go func() {
 		async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
-			atomic.AddInt32(&timesHandled, 1)
+			timesHandled++
 		})
 		wg.Done()
 	}()
 	if util.WaitTimeout(wg, interval*2) {
 		t.Fatalf("Test should have exited by now, timed out")
 	}
-	assert.Equal(t, int32(0), atomic.LoadInt32(&timesHandled), "Wrong number of handled calls")
+	assert.Equal(t, 0, timesHandled, "Wrong number of handled calls")
 }
 
 func TestDebounce_CtxClosing(t *testing.T) {
 	eventsChan := make(chan interface{}, 100)
 	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
-	timesHandled := int32(0)
+	timesHandled := 0
 	wg := &sync.WaitGroup{}
 	wg.Add(1)
 	go func() {
@@ -63,23 +62,23 @@ func TestDebounce_CtxClosing(t *testing.T) {
 	}()
 	go func() {
 		async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
-			atomic.AddInt32(&timesHandled, 1)
+			timesHandled++
 		})
 		wg.Done()
 	}()
 	if util.WaitTimeout(wg, interval*2) {
 		t.Fatalf("Test should have exited by now, timed out")
 	}
-	assert.Equal(t, int32(0), atomic.LoadInt32(&timesHandled), "Wrong number of handled calls")
+	assert.Equal(t, 0, timesHandled, "Wrong number of handled calls")
 }
 
 func TestDebounce_SingleHandlerInvocation(t *testing.T) {
 	eventsChan := make(chan interface{}, 100)
 	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
-	timesHandled := int32(0)
+	timesHandled := 0
 	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
-		atomic.AddInt32(&timesHandled, 1)
+		timesHandled++
 	})
 	for i := 0; i < 100; i++ {
 		eventsChan <- struct{}{}
@@ -87,7 +86,7 @@ func TestDebounce_SingleHandlerInvocation(t *testing.T) {
 	// We should expect 100 rapid fire changes to only have caused
 	// 1 handler to trigger after the debouncing period.
 	time.Sleep(interval * 2)
-	assert.Equal(t, int32(1), atomic.LoadInt32(&timesHandled), "Wrong number of handled calls")
+	assert.Equal(t, 1, timesHandled, "Wrong number of handled calls")
 	cancel()
 }
 
@@ -95,23 +94,23 @@ func TestDebounce_MultipleHandlerInvocation(t *testing.T) {
 	eventsChan := make(chan interface{}, 100)
 	ctx, cancel := context.WithCancel(context.Background())
 	interval := time.Second
-	timesHandled := int32(0)
+	timesHandled := 0
 	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
-		atomic.AddInt32(&timesHandled, 1)
+		timesHandled++
 	})
 	for i := 0; i < 100; i++ {
 		eventsChan <- struct{}{}
 	}
-	require.Equal(t, int32(0), atomic.LoadInt32(&timesHandled), "Events must prevent from handler execution")
+	require.Equal(t, 0, timesHandled, "Events must prevent from handler execution")
 
 	// By this time the first event should be triggered.
 	time.Sleep(2 * time.Second)
-	assert.Equal(t, int32(1), atomic.LoadInt32(&timesHandled), "Wrong number of handled calls")
+	assert.Equal(t, 1, timesHandled, "Wrong number of handled calls")
 
 	// Second event.
 	eventsChan <- struct{}{}
 	time.Sleep(2 * time.Second)
-	assert.Equal(t, int32(2), atomic.LoadInt32(&timesHandled), "Wrong number of handled calls")
+	assert.Equal(t, 2, timesHandled, "Wrong number of handled calls")
 
 	cancel()
 }

async/every_test.go

@@ -2,7 +2,6 @@ package async_test
 
 import (
 	"context"
-	"sync/atomic"
 	"testing"
 	"time"
 
@@ -12,15 +11,15 @@ import (
 func TestEveryRuns(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 
-	i := int32(0)
+	i := 0
 	async.RunEvery(ctx, 100*time.Millisecond, func() {
-		atomic.AddInt32(&i, 1)
+		i++
 	})
 
 	// Sleep for a bit and ensure the value has increased.
 	time.Sleep(200 * time.Millisecond)
 
-	if atomic.LoadInt32(&i) == 0 {
+	if i == 0 {
 		t.Error("Counter failed to increment with ticker")
 	}
 
@@ -29,12 +28,12 @@ func TestEveryRuns(t *testing.T) {
 	// Sleep for a bit to let the cancel take place.
 	time.Sleep(100 * time.Millisecond)
 
-	last := atomic.LoadInt32(&i)
+	last := i
 
 	// Sleep for a bit and ensure the value has not increased.
 	time.Sleep(200 * time.Millisecond)
 
-	if atomic.LoadInt32(&i) != last {
+	if i != last {
 		t.Error("Counter incremented after stop")
 	}
 }

beacon-chain/blockchain/BUILD.bazel

@@ -48,7 +48,6 @@ go_library(
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
-        "//beacon-chain/execution:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
@@ -57,15 +56,17 @@ go_library(
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/powchain:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
+        "//consensus-types/forks/bellatrix:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
@@ -129,17 +130,16 @@ go_test(
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/execution:go_default_library",
-        "//beacon-chain/execution/testing:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/powchain:go_default_library",
+        "//beacon-chain/powchain/testing:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//beacon-chain/state/v3:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/blocks/testing:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//container/trie:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -187,13 +187,12 @@ go_test(
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/execution:go_default_library",
-        "//beacon-chain/execution/testing:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/powchain:go_default_library",
+        "//beacon-chain/powchain/testing:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/blocks/testing:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//container/trie:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"time"
 
@@ -84,7 +83,6 @@ type FinalizationFetcher interface {
 	CurrentJustifiedCheckpt() *ethpb.Checkpoint
 	PreviousJustifiedCheckpt() *ethpb.Checkpoint
 	VerifyFinalizedBlkDescendant(ctx context.Context, blockRoot [32]byte) error
-	IsFinalized(ctx context.Context, blockRoot [32]byte) bool
 }
 
 // OptimisticModeFetcher retrieves information about optimistic status of the node.
@@ -162,7 +160,7 @@ func (s *Service) HeadBlock(ctx context.Context) (interfaces.SignedBeaconBlock,
 	defer s.headLock.RUnlock()
 
 	if s.hasHeadState() {
-		return s.headBlock()
+		return s.headBlock(), nil
 	}
 
 	return s.cfg.BeaconDB.HeadBlock(ctx)
@@ -300,35 +298,13 @@ func (s *Service) ForkChoicer() forkchoice.ForkChoicer {
 
 // IsOptimistic returns true if the current head is optimistic.
 func (s *Service) IsOptimistic(ctx context.Context) (bool, error) {
+	s.headLock.RLock()
+	defer s.headLock.RUnlock()
 	if slots.ToEpoch(s.CurrentSlot()) < params.BeaconConfig().BellatrixForkEpoch {
 		return false, nil
 	}
-	s.headLock.RLock()
-	headRoot := s.head.root
-	s.headLock.RUnlock()
 
-	if s.cfg.ForkChoiceStore.AllTipsAreInvalid() {
-		return true, nil
-	}
-	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(headRoot)
-	if err == nil {
-		return optimistic, nil
-	}
-	if err != protoarray.ErrUnknownNodeRoot && err != doublylinkedtree.ErrNilNode {
-		return true, err
-	}
-	// If fockchoice does not have the headroot, then the node is considered
-	// optimistic
-	return true, nil
-}
-
-// IsFinalized returns true if the input root is finalized.
-// It first checks latest finalized root then checks finalized root index in DB.
-func (s *Service) IsFinalized(ctx context.Context, root [32]byte) bool {
-	if s.ForkChoicer().FinalizedCheckpoint().Root == root {
-		return true
-	}
-	return s.cfg.BeaconDB.IsFinalizedBlock(ctx, root)
+	return s.IsOptimisticForRoot(ctx, s.head.root)
 }
 
 // IsOptimisticForRoot takes the root as argument instead of the current head
@@ -341,24 +317,14 @@ func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool,
 	if err != protoarray.ErrUnknownNodeRoot && err != doublylinkedtree.ErrNilNode {
 		return false, err
 	}
-	// if the requested root is the headroot and the root is not found in
-	// forkchoice, the node should respond that it is optimistic
-	headRoot, err := s.HeadRoot(ctx)
-	if err != nil {
-		return true, err
-	}
-	if bytes.Equal(headRoot, root[:]) {
-		return true, nil
-	}
-
 	ss, err := s.cfg.BeaconDB.StateSummary(ctx, root)
 	if err != nil {
 		return false, err
 	}
-
 	if ss == nil {
-		return true, errInvalidNilSummary
+		return false, errInvalidNilSummary
 	}
+
 	validatedCheckpoint, err := s.cfg.BeaconDB.LastValidatedCheckpoint(ctx)
 	if err != nil {
 		return false, err
@@ -367,14 +333,8 @@ func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool,
 		return true, nil
 	}
 
-	// Historical non-canonical blocks here are returned as optimistic for safety.
-	isCanonical, err := s.IsCanonical(ctx, root)
-	if err != nil {
-		return false, err
-	}
-
 	if slots.ToEpoch(ss.Slot)+1 < validatedCheckpoint.Epoch {
-		return !isCanonical, nil
+		return false, nil
 	}
 
 	// Checkpoint root could be zeros before the first finalized epoch. Use genesis root if the case.
@@ -389,6 +349,13 @@ func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool,
 	if ss.Slot > lastValidated.Slot {
 		return true, nil
 	}
+
+	isCanonical, err := s.IsCanonical(ctx, root)
+	if err != nil {
+		return false, err
+	}
+
+	// Historical non-canonical blocks here are returned as optimistic for safety.
 	return !isCanonical, nil
 }
 

beacon-chain/blockchain/chain_info_norace_test.go

@@ -6,7 +6,7 @@ import (
 
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
@@ -17,7 +17,7 @@ func TestHeadSlot_DataRace(t *testing.T) {
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB},
 	}
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
+	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	st, _ := util.DeterministicGenesisState(t, 1)
 	wait := make(chan struct{})
@@ -35,7 +35,7 @@ func TestHeadRoot_DataRace(t *testing.T) {
 		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 		head: &head{root: [32]byte{'A'}},
 	}
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
+	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	wait := make(chan struct{})
 	st, _ := util.DeterministicGenesisState(t, 1)
@@ -51,13 +51,13 @@ func TestHeadRoot_DataRace(t *testing.T) {
 
 func TestHeadBlock_DataRace(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
-	wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}})
+	wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
 	require.NoError(t, err)
 	s := &Service{
 		cfg:  &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 		head: &head{block: wsb},
 	}
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
+	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	wait := make(chan struct{})
 	st, _ := util.DeterministicGenesisState(t, 1)
@@ -76,7 +76,7 @@ func TestHeadState_DataRace(t *testing.T) {
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
 	}
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
+	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	wait := make(chan struct{})
 	st, _ := util.DeterministicGenesisState(t, 1)

beacon-chain/blockchain/chain_info_test.go

@@ -15,8 +15,8 @@ import (
 	v3 "github.com/prysmaticlabs/prysm/beacon-chain/state/v3"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -166,7 +166,7 @@ func TestHeadRoot_UseDB(t *testing.T) {
 	b := util.NewBeaconBlock()
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := blocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
 	require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: br[:]}))
@@ -181,16 +181,14 @@ func TestHeadBlock_CanRetrieve(t *testing.T) {
 	b.Block.Slot = 1
 	s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := blocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	c := &Service{}
 	c.head = &head{block: wsb, state: s}
 
-	received, err := c.HeadBlock(context.Background())
+	recevied, err := c.HeadBlock(context.Background())
 	require.NoError(t, err)
-	pb, err := received.Proto()
-	require.NoError(t, err)
-	assert.DeepEqual(t, b, pb, "Incorrect head block received")
+	assert.DeepEqual(t, b, recevied.Proto(), "Incorrect head block received")
 }
 
 func TestHeadState_CanRetrieve(t *testing.T) {
@@ -671,25 +669,3 @@ func TestService_IsOptimisticForRoot_DB_non_canonical(t *testing.T) {
 	require.Equal(t, true, validated)
 
 }
-
-func TestService_IsFinalized(t *testing.T) {
-	beaconDB := testDB.SetupDB(t)
-	ctx := context.Background()
-	c := &Service{cfg: &config{BeaconDB: beaconDB, ForkChoiceStore: doublylinkedtree.New()}}
-	r1 := [32]byte{'a'}
-	require.NoError(t, c.ForkChoiceStore().UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{
-		Root: r1,
-	}))
-	b := util.NewBeaconBlock()
-	br, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	util.SaveBlock(t, ctx, beaconDB, b)
-	require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: br[:], Slot: 10}))
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, br))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{
-		Root: br[:],
-	}))
-	require.Equal(t, true, c.IsFinalized(ctx, r1))
-	require.Equal(t, true, c.IsFinalized(ctx, br))
-	require.Equal(t, false, c.IsFinalized(ctx, [32]byte{'c'}))
-}

beacon-chain/blockchain/error.go

@@ -4,9 +4,7 @@ import "github.com/pkg/errors"
 
 var (
 	// ErrInvalidPayload is returned when the payload is invalid
-	ErrInvalidPayload = invalidBlock{error: errors.New("received an INVALID payload from execution engine")}
-	// ErrInvalidBlockHashPayloadStatus is returned when the payload has invalid block hash.
-	ErrInvalidBlockHashPayloadStatus = invalidBlock{error: errors.New("received an INVALID_BLOCK_HASH payload from execution engine")}
+	ErrInvalidPayload = errors.New("recevied an INVALID payload from execution engine")
 	// ErrUndefinedExecutionEngineError is returned when the execution engine returns an error that is not defined
 	ErrUndefinedExecutionEngineError = errors.New("received an undefined ee error")
 	// errNilFinalizedInStore is returned when a nil finalized checkpt is returned from store.
@@ -30,7 +28,7 @@ var (
 	// errWSBlockNotFoundInEpoch is returned when a block is not found in the WS cache or DB within epoch.
 	errWSBlockNotFoundInEpoch = errors.New("weak subjectivity root not found in db within epoch")
 	// errNotDescendantOfFinalized is returned when a block is not a descendant of the finalized checkpoint
-	errNotDescendantOfFinalized = invalidBlock{error: errors.New("not descendant of finalized checkpoint")}
+	errNotDescendantOfFinalized = invalidBlock{errors.New("not descendant of finalized checkpoint")}
 )
 
 // An invalid block is the block that fails state transition based on the core protocol rules.
@@ -40,25 +38,17 @@ var (
 // The block is deemed invalid according to execution layer client.
 // The block violates certain fork choice rules (before finalized slot, not finalized ancestor)
 type invalidBlock struct {
-	invalidAncestorRoots [][32]byte
 	error
-	root [32]byte
 }
 
 type invalidBlockError interface {
 	Error() string
-	InvalidAncestorRoots() [][32]byte
-	BlockRoot() [32]byte
+	InvalidBlock() bool
 }
 
-// BlockRoot returns the invalid block root.
-func (e invalidBlock) BlockRoot() [32]byte {
-	return e.root
-}
-
-// InvalidAncestorRoots returns an optional list of invalid roots of the invalid block which leads up last valid root.
-func (e invalidBlock) InvalidAncestorRoots() [][32]byte {
-	return e.invalidAncestorRoots
+// InvalidBlock returns true for `invalidBlock`.
+func (e invalidBlock) InvalidBlock() bool {
+	return true
 }
 
 // IsInvalidBlock returns true if the error has `invalidBlock`.
@@ -66,34 +56,9 @@ func IsInvalidBlock(e error) bool {
 	if e == nil {
 		return false
 	}
-	_, ok := e.(invalidBlockError)
+	d, ok := e.(invalidBlockError)
 	if !ok {
 		return IsInvalidBlock(errors.Unwrap(e))
 	}
-	return true
-}
-
-// InvalidBlockRoot returns the invalid block root. If the error
-// doesn't have an invalid blockroot. [32]byte{} is returned.
-func InvalidBlockRoot(e error) [32]byte {
-	if e == nil {
-		return [32]byte{}
-	}
-	d, ok := e.(invalidBlockError)
-	if !ok {
-		return [32]byte{}
-	}
-	return d.BlockRoot()
-}
-
-// InvalidAncestorRoots returns a list of invalid roots up to last valid root.
-func InvalidAncestorRoots(e error) [][32]byte {
-	if e == nil {
-		return [][32]byte{}
-	}
-	d, ok := e.(invalidBlockError)
-	if !ok {
-		return [][32]byte{}
-	}
-	return d.InvalidAncestorRoots()
+	return d.InvalidBlock()
 }

beacon-chain/blockchain/error_test.go

@@ -8,29 +8,10 @@ import (
 )
 
 func TestIsInvalidBlock(t *testing.T) {
-	require.Equal(t, true, IsInvalidBlock(ErrInvalidPayload)) // Already wrapped.
-	err := invalidBlock{error: ErrInvalidPayload}
+	require.Equal(t, false, IsInvalidBlock(ErrInvalidPayload))
+	err := invalidBlock{ErrInvalidPayload}
 	require.Equal(t, true, IsInvalidBlock(err))
 
 	newErr := errors.Wrap(err, "wrap me")
 	require.Equal(t, true, IsInvalidBlock(newErr))
-	require.DeepEqual(t, [][32]byte(nil), InvalidAncestorRoots(err))
-}
-
-func TestInvalidBlockRoot(t *testing.T) {
-	require.Equal(t, [32]byte{}, InvalidBlockRoot(ErrUndefinedExecutionEngineError))
-	require.Equal(t, [32]byte{}, InvalidBlockRoot(ErrInvalidPayload))
-
-	err := invalidBlock{error: ErrInvalidPayload, root: [32]byte{'a'}}
-	require.Equal(t, [32]byte{'a'}, InvalidBlockRoot(err))
-	require.DeepEqual(t, [][32]byte(nil), InvalidAncestorRoots(err))
-}
-
-func TestInvalidRoots(t *testing.T) {
-	roots := [][32]byte{{'d'}, {'b'}, {'c'}}
-	err := invalidBlock{error: ErrInvalidPayload, root: [32]byte{'a'}, invalidAncestorRoots: roots}
-
-	require.Equal(t, true, IsInvalidBlock(err))
-	require.Equal(t, [32]byte{'a'}, InvalidBlockRoot(err))
-	require.DeepEqual(t, roots, InvalidAncestorRoots(err))
 }

beacon-chain/blockchain/execution_engine.go

@@ -10,12 +10,12 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
-	"github.com/prysmaticlabs/prysm/beacon-chain/execution"
+	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	"github.com/prysmaticlabs/prysm/time/slots"
@@ -23,8 +23,6 @@ import (
 	"go.opencensus.io/trace"
 )
 
-var defaultLatestValidHash = bytesutil.PadTo([]byte{0xff}, 32)
-
 // notifyForkchoiceUpdateArg is the argument for the forkchoice update notification `notifyForkchoiceUpdate`.
 type notifyForkchoiceUpdateArg struct {
 	headState state.BeaconState
@@ -41,27 +39,24 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 
 	headBlk := arg.headBlock
 	if headBlk == nil || headBlk.IsNil() || headBlk.Body().IsNil() {
-		log.Error("Head block is nil")
-		return nil, nil
+		return nil, errors.New("nil head block")
 	}
 	// Must not call fork choice updated until the transition conditions are met on the Pow network.
 	isExecutionBlk, err := blocks.IsExecutionBlock(headBlk.Body())
 	if err != nil {
-		log.WithError(err).Error("Could not determine if head block is execution block")
-		return nil, nil
+		return nil, errors.Wrap(err, "could not determine if block is execution block")
 	}
 	if !isExecutionBlk {
 		return nil, nil
 	}
-	headPayload, err := headBlk.Body().Execution()
+	headPayload, err := headBlk.Body().ExecutionPayload()
 	if err != nil {
-		log.WithError(err).Error("Could not get execution payload for head block")
-		return nil, nil
+		return nil, errors.Wrap(err, "could not get execution payload")
 	}
 	finalizedHash := s.ForkChoicer().FinalizedPayloadBlockHash()
 	justifiedHash := s.ForkChoicer().JustifiedPayloadBlockHash()
 	fcs := &enginev1.ForkchoiceState{
-		HeadBlockHash:      headPayload.BlockHash(),
+		HeadBlockHash:      headPayload.BlockHash,
 		SafeBlockHash:      justifiedHash[:],
 		FinalizedBlockHash: finalizedHash[:],
 	}
@@ -69,59 +64,42 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 	nextSlot := s.CurrentSlot() + 1 // Cache payload ID for next slot proposer.
 	hasAttr, attr, proposerId, err := s.getPayloadAttribute(ctx, arg.headState, nextSlot)
 	if err != nil {
-		log.WithError(err).Error("Could not get head payload attribute")
-		return nil, nil
+		return nil, errors.Wrap(err, "could not get payload attribute")
 	}
 
 	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, attr)
 	if err != nil {
 		switch err {
-		case execution.ErrAcceptedSyncingPayloadStatus:
+		case powchain.ErrAcceptedSyncingPayloadStatus:
 			forkchoiceUpdatedOptimisticNodeCount.Inc()
 			log.WithFields(logrus.Fields{
 				"headSlot":                  headBlk.Slot(),
-				"headPayloadBlockHash":      fmt.Sprintf("%#x", bytesutil.Trunc(headPayload.BlockHash())),
+				"headPayloadBlockHash":      fmt.Sprintf("%#x", bytesutil.Trunc(headPayload.BlockHash)),
 				"finalizedPayloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(finalizedHash[:])),
 			}).Info("Called fork choice updated with optimistic block")
-			err := s.optimisticCandidateBlock(ctx, headBlk)
-			if err != nil {
-				log.WithError(err).Error("Optimistic block failed to be candidate")
-			}
-			return payloadID, nil
-		case execution.ErrInvalidPayloadStatus:
+			return payloadID, s.optimisticCandidateBlock(ctx, headBlk)
+		case powchain.ErrInvalidPayloadStatus:
 			newPayloadInvalidNodeCount.Inc()
 			headRoot := arg.headRoot
-			if len(lastValidHash) == 0 {
-				lastValidHash = defaultLatestValidHash
-			}
 			invalidRoots, err := s.ForkChoicer().SetOptimisticToInvalid(ctx, headRoot, bytesutil.ToBytes32(headBlk.ParentRoot()), bytesutil.ToBytes32(lastValidHash))
 			if err != nil {
-				log.WithError(err).Error("Could not set head root to invalid")
-				return nil, nil
+				return nil, err
 			}
 			if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
-				log.WithError(err).Error("Could not remove invalid block and state")
-				return nil, nil
+				return nil, err
 			}
 
 			r, err := s.cfg.ForkChoiceStore.Head(ctx, s.justifiedBalances.balances)
 			if err != nil {
-				log.WithFields(logrus.Fields{
-					"slot":         headBlk.Slot(),
-					"blockRoot":    fmt.Sprintf("%#x", bytesutil.Trunc(headRoot[:])),
-					"invalidCount": len(invalidRoots),
-				}).Warn("Pruned invalid blocks, could not update head root")
-				return nil, invalidBlock{error: ErrInvalidPayload, root: arg.headRoot, invalidAncestorRoots: invalidRoots}
+				return nil, err
 			}
 			b, err := s.getBlock(ctx, r)
 			if err != nil {
-				log.WithError(err).Error("Could not get head block")
-				return nil, nil
+				return nil, err
 			}
 			st, err := s.cfg.StateGen.StateByRoot(ctx, r)
 			if err != nil {
-				log.WithError(err).Error("Could not get head state")
-				return nil, nil
+				return nil, err
 			}
 			pid, err := s.notifyForkchoiceUpdate(ctx, &notifyForkchoiceUpdateArg{
 				headState: st,
@@ -129,40 +107,28 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 				headBlock: b.Block(),
 			})
 			if err != nil {
-				return nil, err // Returning err because it's recursive here.
-			}
-
-			if err := s.saveHead(ctx, r, b, st); err != nil {
-				log.WithError(err).Error("could not save head after pruning invalid blocks")
+				return nil, err
 			}
 
 			log.WithFields(logrus.Fields{
 				"slot":         headBlk.Slot(),
-				"blockRoot":    fmt.Sprintf("%#x", bytesutil.Trunc(headRoot[:])),
+				"blockRoot":    fmt.Sprintf("%#x", headRoot),
 				"invalidCount": len(invalidRoots),
-				"newHeadRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(r[:])),
 			}).Warn("Pruned invalid blocks")
-			return pid, invalidBlock{error: ErrInvalidPayload, root: arg.headRoot, invalidAncestorRoots: invalidRoots}
+			return pid, ErrInvalidPayload
 
 		default:
-			log.WithError(err).Error(ErrUndefinedExecutionEngineError)
-			return nil, nil
+			return nil, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
 		}
 	}
 	forkchoiceUpdatedValidNodeCount.Inc()
 	if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, arg.headRoot); err != nil {
-		log.WithError(err).Error("Could not set head root to valid")
-		return nil, nil
+		return nil, errors.Wrap(err, "could not set block to valid")
 	}
-	if hasAttr && payloadID != nil { // If the forkchoice update call has an attribute, update the proposer payload ID cache.
+	if hasAttr { // If the forkchoice update call has an attribute, update the proposer payload ID cache.
 		var pId [8]byte
 		copy(pId[:], payloadID[:])
 		s.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(nextSlot, proposerId, pId)
-	} else if hasAttr && payloadID == nil {
-		log.WithFields(logrus.Fields{
-			"blockHash": fmt.Sprintf("%#x", headPayload.BlockHash()),
-			"slot":      headBlk.Slot(),
-		}).Error("Received nil payload ID on VALID engine response")
 	}
 	return payloadID, nil
 }
@@ -177,11 +143,11 @@ func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, er
 	if blocks.IsPreBellatrixVersion(blk.Block().Version()) {
 		return params.BeaconConfig().ZeroHash, nil
 	}
-	payload, err := blk.Block().Body().Execution()
+	payload, err := blk.Block().Body().ExecutionPayload()
 	if err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not get execution payload")
 	}
-	return bytesutil.ToBytes32(payload.BlockHash()), nil
+	return bytesutil.ToBytes32(payload.BlockHash), nil
 }
 
 // notifyForkchoiceUpdate signals execution engine on a new payload.
@@ -196,34 +162,34 @@ func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion int,
 	if blocks.IsPreBellatrixVersion(postStateVersion) {
 		return true, nil
 	}
-	if err := consensusblocks.BeaconBlockIsNil(blk); err != nil {
+	if err := wrapper.BeaconBlockIsNil(blk); err != nil {
 		return false, err
 	}
 	body := blk.Block().Body()
 	enabled, err := blocks.IsExecutionEnabledUsingHeader(postStateHeader, body)
 	if err != nil {
-		return false, errors.Wrap(invalidBlock{error: err}, "could not determine if execution is enabled")
+		return false, errors.Wrap(invalidBlock{err}, "could not determine if execution is enabled")
 	}
 	if !enabled {
 		return true, nil
 	}
-	payload, err := body.Execution()
+	payload, err := body.ExecutionPayload()
 	if err != nil {
-		return false, errors.Wrap(invalidBlock{error: err}, "could not get execution payload")
+		return false, errors.Wrap(invalidBlock{err}, "could not get execution payload")
 	}
 	lastValidHash, err := s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload)
 	switch err {
 	case nil:
 		newPayloadValidNodeCount.Inc()
 		return true, nil
-	case execution.ErrAcceptedSyncingPayloadStatus:
+	case powchain.ErrAcceptedSyncingPayloadStatus:
 		newPayloadOptimisticNodeCount.Inc()
 		log.WithFields(logrus.Fields{
 			"slot":             blk.Block().Slot(),
-			"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
+			"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
 		}).Info("Called new payload with optimistic block")
 		return false, s.optimisticCandidateBlock(ctx, blk.Block())
-	case execution.ErrInvalidPayloadStatus:
+	case powchain.ErrInvalidPayloadStatus:
 		newPayloadInvalidNodeCount.Inc()
 		root, err := blk.Block().HashTreeRoot()
 		if err != nil {
@@ -241,13 +207,7 @@ func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion int,
 			"blockRoot":    fmt.Sprintf("%#x", root),
 			"invalidCount": len(invalidRoots),
 		}).Warn("Pruned invalid blocks")
-		return false, invalidBlock{
-			invalidAncestorRoots: invalidRoots,
-			error:                ErrInvalidPayload,
-		}
-	case execution.ErrInvalidBlockHashPayloadStatus:
-		newPayloadInvalidNodeCount.Inc()
-		return false, ErrInvalidBlockHashPayloadStatus
+		return false, invalidBlock{ErrInvalidPayload}
 	default:
 		return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
 	}

beacon-chain/blockchain/execution_engine_test.go

@@ -6,22 +6,21 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
-	gethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/execution"
-	mockExecution "github.com/prysmaticlabs/prysm/beacon-chain/execution/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
+	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	bstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	v1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -32,7 +31,6 @@ import (
 )
 
 func Test_NotifyForkchoiceUpdate(t *testing.T) {
-	params.BeaconConfig().SafeSlotsToImportOptimistically = 0
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 	altairBlk := util.SaveBlock(t, ctx, beaconDB, util.NewBeaconBlockAltair())
@@ -75,10 +73,14 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 		newForkchoiceErr error
 		errString        string
 	}{
+		{
+			name:      "nil block",
+			errString: "nil head block",
+		},
 		{
 			name: "phase0 block",
 			blk: func() interfaces.BeaconBlock {
-				b, err := consensusblocks.NewBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}})
+				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}})
 				require.NoError(t, err)
 				return b
 			}(),
@@ -86,7 +88,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 		{
 			name: "altair block",
 			blk: func() interfaces.BeaconBlock {
-				b, err := consensusblocks.NewBeaconBlock(&ethpb.BeaconBlockAltair{Body: &ethpb.BeaconBlockBodyAltair{}})
+				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockAltair{Body: &ethpb.BeaconBlockBodyAltair{}})
 				require.NoError(t, err)
 				return b
 			}(),
@@ -94,7 +96,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 		{
 			name: "not execution block",
 			blk: func() interfaces.BeaconBlock {
-				b, err := consensusblocks.NewBeaconBlock(&ethpb.BeaconBlockBellatrix{
+				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
 					Body: &ethpb.BeaconBlockBodyBellatrix{
 						ExecutionPayload: &v1.ExecutionPayload{
 							ParentHash:    make([]byte, fieldparams.RootLength),
@@ -115,7 +117,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 		{
 			name: "happy case: finalized root is altair block",
 			blk: func() interfaces.BeaconBlock {
-				b, err := consensusblocks.NewBeaconBlock(&ethpb.BeaconBlockBellatrix{
+				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
 					Body: &ethpb.BeaconBlockBodyBellatrix{
 						ExecutionPayload: &v1.ExecutionPayload{},
 					},
@@ -129,7 +131,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 		{
 			name: "happy case: finalized root is bellatrix block",
 			blk: func() interfaces.BeaconBlock {
-				b, err := consensusblocks.NewBeaconBlock(&ethpb.BeaconBlockBellatrix{
+				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
 					Body: &ethpb.BeaconBlockBodyBellatrix{
 						ExecutionPayload: &v1.ExecutionPayload{},
 					},
@@ -143,7 +145,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 		{
 			name: "forkchoice updated with optimistic block",
 			blk: func() interfaces.BeaconBlock {
-				b, err := consensusblocks.NewBeaconBlock(&ethpb.BeaconBlockBellatrix{
+				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
 					Body: &ethpb.BeaconBlockBodyBellatrix{
 						ExecutionPayload: &v1.ExecutionPayload{},
 					},
@@ -151,14 +153,14 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 				require.NoError(t, err)
 				return b
 			}(),
-			newForkchoiceErr: execution.ErrAcceptedSyncingPayloadStatus,
+			newForkchoiceErr: powchain.ErrAcceptedSyncingPayloadStatus,
 			finalizedRoot:    bellatrixBlkRoot,
 			justifiedRoot:    bellatrixBlkRoot,
 		},
 		{
 			name: "forkchoice updated with invalid block",
 			blk: func() interfaces.BeaconBlock {
-				b, err := consensusblocks.NewBeaconBlock(&ethpb.BeaconBlockBellatrix{
+				b, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{
 					Body: &ethpb.BeaconBlockBodyBellatrix{
 						ExecutionPayload: &v1.ExecutionPayload{},
 					},
@@ -166,7 +168,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 				require.NoError(t, err)
 				return b
 			}(),
-			newForkchoiceErr: execution.ErrInvalidPayloadStatus,
+			newForkchoiceErr: powchain.ErrInvalidPayloadStatus,
 			finalizedRoot:    bellatrixBlkRoot,
 			justifiedRoot:    bellatrixBlkRoot,
 			headRoot:         [32]byte{'a'},
@@ -176,7 +178,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			service.cfg.ExecutionEngineCaller = &mockExecution.EngineClient{ErrForkchoiceUpdated: tt.newForkchoiceErr}
+			service.cfg.ExecutionEngineCaller = &mockPOW.EngineClient{ErrForkchoiceUpdated: tt.newForkchoiceErr}
 			st, _ := util.DeterministicGenesisState(t, 1)
 			require.NoError(t, beaconDB.SaveState(ctx, st, tt.finalizedRoot))
 			require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, tt.finalizedRoot))
@@ -188,10 +190,6 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 			_, err = service.notifyForkchoiceUpdate(ctx, arg)
 			if tt.errString != "" {
 				require.ErrorContains(t, tt.errString, err)
-				if tt.errString == ErrInvalidPayload.Error() {
-					require.Equal(t, true, IsInvalidBlock(err))
-					require.Equal(t, tt.headRoot, InvalidBlockRoot(err)) // Head root should be invalid. Not block root!
-				}
 			} else {
 				require.NoError(t, err)
 			}
@@ -214,7 +212,7 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 // 2. forkchoice removes the weights of these blocks
 // 3. the blockchain package calls fcu to obtain heads G -> F -> D.
 
-func Test_NotifyForkchoiceUpdateRecursive_Protoarray(t *testing.T) {
+func Test_NotifyForkchoiceUpdateRecursive(t *testing.T) {
 	ctx := context.Background()
 	beaconDB := testDB.SetupDB(t)
 
@@ -272,11 +270,14 @@ func Test_NotifyForkchoiceUpdateRecursive_Protoarray(t *testing.T) {
 	require.NoError(t, err)
 
 	// Insert blocks into forkchoice
-	service := setupBeaconChain(t, beaconDB)
-	fcs := protoarray.New()
-	service.cfg.ForkChoiceStore = fcs
-	service.cfg.ProposerSlotIndexCache = cache.NewProposerPayloadIDsCache()
-
+	fcs := doublylinkedtree.New()
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB)),
+		WithForkChoiceStore(fcs),
+		WithProposerIdsCache(cache.NewProposerPayloadIDsCache()),
+	}
+	service, err := NewService(ctx, opts...)
 	service.justifiedBalances.balances = []uint64{50, 100, 200}
 	require.NoError(t, err)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
@@ -315,12 +316,8 @@ func Test_NotifyForkchoiceUpdateRecursive_Protoarray(t *testing.T) {
 	require.Equal(t, brg, headRoot)
 
 	// Prepare Engine Mock to return invalid unless head is D, LVH =  E
-	service.cfg.ExecutionEngineCaller = &mockExecution.EngineClient{ErrForkchoiceUpdated: execution.ErrInvalidPayloadStatus, ForkChoiceUpdatedResp: pe[:], OverrideValidHash: [32]byte{'D'}}
+	service.cfg.ExecutionEngineCaller = &mockPOW.EngineClient{ErrForkchoiceUpdated: powchain.ErrInvalidPayloadStatus, ForkChoiceUpdatedResp: pe[:], OverrideValidHash: [32]byte{'D'}}
 	st, _ := util.DeterministicGenesisState(t, 1)
-	service.head = &head{
-		state: st,
-		block: wba,
-	}
 
 	require.NoError(t, beaconDB.SaveState(ctx, st, bra))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bra))
@@ -330,233 +327,7 @@ func Test_NotifyForkchoiceUpdateRecursive_Protoarray(t *testing.T) {
 		headRoot:  brg,
 	}
 	_, err = service.notifyForkchoiceUpdate(ctx, a)
-	require.Equal(t, true, IsInvalidBlock(err))
-	require.Equal(t, brf, InvalidBlockRoot(err))
-
-	// Ensure Head is D
-	headRoot, err = fcs.Head(ctx, service.justifiedBalances.balances)
-	require.NoError(t, err)
-	require.Equal(t, brd, headRoot)
-
-	// Ensure F and G where removed but their parent E wasn't
-	require.Equal(t, false, fcs.HasNode(brf))
-	require.Equal(t, false, fcs.HasNode(brg))
-	require.Equal(t, true, fcs.HasNode(bre))
-}
-
-func Test_NotifyForkchoiceUpdate_NIlLVH(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	// Prepare blocks
-	ba := util.NewBeaconBlockBellatrix()
-	ba.Block.Body.ExecutionPayload.BlockNumber = 1
-	wba := util.SaveBlock(t, ctx, beaconDB, ba)
-	bra, err := wba.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bb := util.NewBeaconBlockBellatrix()
-	bb.Block.Body.ExecutionPayload.BlockNumber = 2
-	wbb := util.SaveBlock(t, ctx, beaconDB, bb)
-	brb, err := wbb.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bc := util.NewBeaconBlockBellatrix()
-	pc := [32]byte{'C'}
-	bc.Block.Body.ExecutionPayload.BlockHash = pc[:]
-	bc.Block.Body.ExecutionPayload.BlockNumber = 3
-	wbc := util.SaveBlock(t, ctx, beaconDB, bc)
-	brc, err := wbc.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bd := util.NewBeaconBlockBellatrix()
-	pd := [32]byte{'D'}
-	bd.Block.Body.ExecutionPayload.BlockHash = pd[:]
-	bd.Block.Body.ExecutionPayload.BlockNumber = 4
-	bd.Block.ParentRoot = brc[:]
-	wbd := util.SaveBlock(t, ctx, beaconDB, bd)
-	brd, err := wbd.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	// Insert blocks into forkchoice
-	service := setupBeaconChain(t, beaconDB)
-	fcs := doublylinkedtree.New()
-	service.cfg.ForkChoiceStore = fcs
-	service.cfg.ProposerSlotIndexCache = cache.NewProposerPayloadIDsCache()
-
-	service.justifiedBalances.balances = []uint64{50, 100, 200}
-	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-
-	// Prepare Engine Mock to return invalid LVH =  nil
-	service.cfg.ExecutionEngineCaller = &mockExecution.EngineClient{ErrForkchoiceUpdated: execution.ErrInvalidPayloadStatus, OverrideValidHash: [32]byte{'C'}}
-	st, _ := util.DeterministicGenesisState(t, 1)
-	service.head = &head{
-		state: st,
-		block: wba,
-	}
-
-	require.NoError(t, beaconDB.SaveState(ctx, st, bra))
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bra))
-	a := &notifyForkchoiceUpdateArg{
-		headState: st,
-		headBlock: wbd.Block(),
-		headRoot:  brd,
-	}
-	_, err = service.notifyForkchoiceUpdate(ctx, a)
-	require.Equal(t, true, IsInvalidBlock(err))
-	require.Equal(t, brd, InvalidBlockRoot(err))
-	require.Equal(t, brd, InvalidAncestorRoots(err)[0])
-	require.Equal(t, 1, len(InvalidAncestorRoots(err)))
-}
-
-//
-//
-//  A <- B <- C <- D
-//       \
-//         ---------- E <- F
-//                     \
-//                       ------ G
-// D is the current head, attestations for F and G come late, both are invalid.
-// We switch recursively to F then G and finally to D.
-//
-// We test:
-// 1. forkchoice removes blocks F and G from the forkchoice implementation
-// 2. forkchoice removes the weights of these blocks
-// 3. the blockchain package calls fcu to obtain heads G -> F -> D.
-
-func Test_NotifyForkchoiceUpdateRecursive_DoublyLinkedTree(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-
-	// Prepare blocks
-	ba := util.NewBeaconBlockBellatrix()
-	ba.Block.Body.ExecutionPayload.BlockNumber = 1
-	wba := util.SaveBlock(t, ctx, beaconDB, ba)
-	bra, err := wba.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bb := util.NewBeaconBlockBellatrix()
-	bb.Block.Body.ExecutionPayload.BlockNumber = 2
-	wbb := util.SaveBlock(t, ctx, beaconDB, bb)
-	brb, err := wbb.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bc := util.NewBeaconBlockBellatrix()
-	bc.Block.Body.ExecutionPayload.BlockNumber = 3
-	wbc := util.SaveBlock(t, ctx, beaconDB, bc)
-	brc, err := wbc.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bd := util.NewBeaconBlockBellatrix()
-	pd := [32]byte{'D'}
-	bd.Block.Body.ExecutionPayload.BlockHash = pd[:]
-	bd.Block.Body.ExecutionPayload.BlockNumber = 4
-	wbd := util.SaveBlock(t, ctx, beaconDB, bd)
-	brd, err := wbd.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	be := util.NewBeaconBlockBellatrix()
-	pe := [32]byte{'E'}
-	be.Block.Body.ExecutionPayload.BlockHash = pe[:]
-	be.Block.Body.ExecutionPayload.BlockNumber = 5
-	wbe := util.SaveBlock(t, ctx, beaconDB, be)
-	bre, err := wbe.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bf := util.NewBeaconBlockBellatrix()
-	pf := [32]byte{'F'}
-	bf.Block.Body.ExecutionPayload.BlockHash = pf[:]
-	bf.Block.Body.ExecutionPayload.BlockNumber = 6
-	bf.Block.ParentRoot = bre[:]
-	wbf := util.SaveBlock(t, ctx, beaconDB, bf)
-	brf, err := wbf.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	bg := util.NewBeaconBlockBellatrix()
-	bg.Block.Body.ExecutionPayload.BlockNumber = 7
-	pg := [32]byte{'G'}
-	bg.Block.Body.ExecutionPayload.BlockHash = pg[:]
-	bg.Block.ParentRoot = bre[:]
-	wbg := util.SaveBlock(t, ctx, beaconDB, bg)
-	brg, err := wbg.Block().HashTreeRoot()
-	require.NoError(t, err)
-
-	// Insert blocks into forkchoice
-	service := setupBeaconChain(t, beaconDB)
-	fcs := doublylinkedtree.New()
-	service.cfg.ForkChoiceStore = fcs
-	service.cfg.ProposerSlotIndexCache = cache.NewProposerPayloadIDsCache()
-
-	service.justifiedBalances.balances = []uint64{50, 100, 200}
-	require.NoError(t, err)
-	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 5, bre, brb, [32]byte{'E'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 6, brf, bre, [32]byte{'F'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 7, brg, bre, [32]byte{'G'}, ojc, ofc)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-
-	// Insert Attestations to D, F and G so that they have higher weight than D
-	// Ensure G is head
-	fcs.ProcessAttestation(ctx, []uint64{0}, brd, 1)
-	fcs.ProcessAttestation(ctx, []uint64{1}, brf, 1)
-	fcs.ProcessAttestation(ctx, []uint64{2}, brg, 1)
-	jc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: bra}
-	require.NoError(t, fcs.UpdateJustifiedCheckpoint(jc))
-	headRoot, err := fcs.Head(ctx, []uint64{50, 100, 200})
-	require.NoError(t, err)
-	require.Equal(t, brg, headRoot)
-
-	// Prepare Engine Mock to return invalid unless head is D, LVH =  E
-	service.cfg.ExecutionEngineCaller = &mockExecution.EngineClient{ErrForkchoiceUpdated: execution.ErrInvalidPayloadStatus, ForkChoiceUpdatedResp: pe[:], OverrideValidHash: [32]byte{'D'}}
-	st, _ := util.DeterministicGenesisState(t, 1)
-	service.head = &head{
-		state: st,
-		block: wba,
-	}
-
-	require.NoError(t, beaconDB.SaveState(ctx, st, bra))
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bra))
-	a := &notifyForkchoiceUpdateArg{
-		headState: st,
-		headBlock: wbg.Block(),
-		headRoot:  brg,
-	}
-	_, err = service.notifyForkchoiceUpdate(ctx, a)
-	require.Equal(t, true, IsInvalidBlock(err))
-	require.Equal(t, brf, InvalidBlockRoot(err))
-
+	require.ErrorIs(t, ErrInvalidPayload, err)
 	// Ensure Head is D
 	headRoot, err = fcs.Head(ctx, service.justifiedBalances.balances)
 	require.NoError(t, err)
@@ -589,7 +360,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 			Body: &ethpb.BeaconBlockBodyAltair{},
 		},
 	}
-	altairBlk, err := consensusblocks.NewSignedBeaconBlock(a)
+	altairBlk, err := wrapper.WrappedSignedBeaconBlock(a)
 	require.NoError(t, err)
 	blk := &ethpb.SignedBeaconBlockBellatrix{
 		Block: &ethpb.BeaconBlockBellatrix{
@@ -609,7 +380,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 			},
 		},
 	}
-	bellatrixBlk, err := consensusblocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(blk))
+	bellatrixBlk, err := wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(blk))
 	require.NoError(t, err)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
@@ -655,14 +426,14 @@ func Test_NotifyNewPayload(t *testing.T) {
 			name:           "new payload with optimistic block",
 			postState:      bellatrixState,
 			blk:            bellatrixBlk,
-			newPayloadErr:  execution.ErrAcceptedSyncingPayloadStatus,
+			newPayloadErr:  powchain.ErrAcceptedSyncingPayloadStatus,
 			isValidPayload: false,
 		},
 		{
 			name:           "new payload with invalid block",
 			postState:      bellatrixState,
 			blk:            bellatrixBlk,
-			newPayloadErr:  execution.ErrInvalidPayloadStatus,
+			newPayloadErr:  powchain.ErrInvalidPayloadStatus,
 			errString:      ErrInvalidPayload.Error(),
 			isValidPayload: false,
 			invalidBlock:   true,
@@ -686,7 +457,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 						},
 					},
 				}
-				b, err := consensusblocks.NewSignedBeaconBlock(blk)
+				b, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(t, err)
 				return b
 			}(),
@@ -712,7 +483,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 						},
 					},
 				}
-				b, err := consensusblocks.NewSignedBeaconBlock(blk)
+				b, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(t, err)
 				return b
 			}(),
@@ -731,7 +502,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 						},
 					},
 				}
-				b, err := consensusblocks.NewSignedBeaconBlock(blk)
+				b, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(t, err)
 				return b
 			}(),
@@ -750,47 +521,23 @@ func Test_NotifyNewPayload(t *testing.T) {
 						},
 					},
 				}
-				b, err := consensusblocks.NewSignedBeaconBlock(blk)
+				b, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(t, err)
 				return b
 			}(),
 			newPayloadErr: ErrUndefinedExecutionEngineError,
 			errString:     ErrUndefinedExecutionEngineError.Error(),
 		},
-		{
-			name:      "invalid block hash error from ee",
-			postState: bellatrixState,
-			blk: func() interfaces.SignedBeaconBlock {
-				blk := &ethpb.SignedBeaconBlockBellatrix{
-					Block: &ethpb.BeaconBlockBellatrix{
-						Body: &ethpb.BeaconBlockBodyBellatrix{
-							ExecutionPayload: &v1.ExecutionPayload{
-								ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
-							},
-						},
-					},
-				}
-				b, err := consensusblocks.NewSignedBeaconBlock(blk)
-				require.NoError(t, err)
-				return b
-			}(),
-			newPayloadErr: ErrInvalidBlockHashPayloadStatus,
-			errString:     ErrInvalidBlockHashPayloadStatus.Error(),
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			e := &mockExecution.EngineClient{ErrNewPayload: tt.newPayloadErr, BlockByHashMap: map[[32]byte]*v1.ExecutionBlock{}}
+			e := &mockPOW.EngineClient{ErrNewPayload: tt.newPayloadErr, BlockByHashMap: map[[32]byte]*v1.ExecutionBlock{}}
 			e.BlockByHashMap[[32]byte{'a'}] = &v1.ExecutionBlock{
-				Header: gethtypes.Header{
-					ParentHash: common.BytesToHash([]byte("b")),
-				},
+				ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
 				TotalDifficulty: "0x2",
 			}
 			e.BlockByHashMap[[32]byte{'b'}] = &v1.ExecutionBlock{
-				Header: gethtypes.Header{
-					ParentHash: common.BytesToHash([]byte("3")),
-				},
+				ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
 				TotalDifficulty: "0x1",
 			}
 			service.cfg.ExecutionEngineCaller = e
@@ -837,21 +584,17 @@ func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) {
 			},
 		},
 	}
-	bellatrixBlk, err := consensusblocks.NewSignedBeaconBlock(blk)
+	bellatrixBlk, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	e := &mockExecution.EngineClient{BlockByHashMap: map[[32]byte]*v1.ExecutionBlock{}}
+	e := &mockPOW.EngineClient{BlockByHashMap: map[[32]byte]*v1.ExecutionBlock{}}
 	e.BlockByHashMap[[32]byte{'a'}] = &v1.ExecutionBlock{
-		Header: gethtypes.Header{
-			ParentHash: common.BytesToHash([]byte("b")),
-		},
+		ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
 		TotalDifficulty: "0x2",
 	}
 	e.BlockByHashMap[[32]byte{'b'}] = &v1.ExecutionBlock{
-		Header: gethtypes.Header{
-			ParentHash: common.BytesToHash([]byte("3")),
-		},
+		ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
 		TotalDifficulty: "0x1",
 	}
 	service.cfg.ExecutionEngineCaller = e
@@ -882,7 +625,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 	service.genesisTime = time.Now().Add(-time.Second * 12 * 2 * 128)
 
 	parentBlk := util.NewBeaconBlockBellatrix()
-	wrappedParentBlock, err := consensusblocks.NewSignedBeaconBlock(parentBlk)
+	wrappedParentBlock, err := wrapper.WrappedSignedBeaconBlock(parentBlk)
 	require.NoError(t, err)
 	parentRoot, err := wrappedParentBlock.Block().HashTreeRoot()
 	require.NoError(t, err)
@@ -899,7 +642,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 1
 				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := consensusblocks.NewBeaconBlock(blk.Block)
+				wr, err := wrapper.WrappedBeaconBlock(blk.Block)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -907,7 +650,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 32
 				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := consensusblocks.NewSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -919,7 +662,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				blk := util.NewBeaconBlockAltair()
 				blk.Block.Slot = 200
 				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := consensusblocks.NewBeaconBlock(blk.Block)
+				wr, err := wrapper.WrappedBeaconBlock(blk.Block)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -927,7 +670,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				blk := util.NewBeaconBlockAltair()
 				blk.Block.Slot = 32
 				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := consensusblocks.NewSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -939,7 +682,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 200
 				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := consensusblocks.NewBeaconBlock(blk.Block)
+				wr, err := wrapper.WrappedBeaconBlock(blk.Block)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -947,7 +690,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
 				blk := util.NewBeaconBlockBellatrix()
 				blk.Block.Slot = 32
 				blk.Block.ParentRoot = parentRoot[:]
-				wr, err := consensusblocks.NewSignedBeaconBlock(blk)
+				wr, err := wrapper.WrappedSignedBeaconBlock(blk)
 				require.NoError(tt, err)
 				return wr
 			}(t),
@@ -1226,7 +969,7 @@ func TestService_getPayloadHash(t *testing.T) {
 	b := util.NewBeaconBlock()
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	require.NoError(t, service.saveInitSyncBlock(ctx, r, wsb))
 
@@ -1239,7 +982,7 @@ func TestService_getPayloadHash(t *testing.T) {
 	bb.Block.Body.ExecutionPayload.BlockHash = h[:]
 	r, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err = consensusblocks.NewSignedBeaconBlock(bb)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(bb)
 	require.NoError(t, err)
 	require.NoError(t, service.saveInitSyncBlock(ctx, r, wsb))
 

beacon-chain/blockchain/head.go

@@ -13,9 +13,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	"github.com/prysmaticlabs/prysm/time/slots"
@@ -74,7 +74,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 	if newHeadRoot == oldHeadRoot {
 		return nil
 	}
-	if err := blocks.BeaconBlockIsNil(headBlock); err != nil {
+	if err := wrapper.BeaconBlockIsNil(headBlock); err != nil {
 		return err
 	}
 	if headState == nil || headState.IsNil() {
@@ -89,11 +89,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 
 	// A chain re-org occurred, so we fire an event notifying the rest of the services.
 	s.headLock.RLock()
-	oldHeadBlock, err := s.headBlock()
-	if err != nil {
-		return errors.Wrap(err, "could not get old head block")
-	}
-	oldStateRoot := oldHeadBlock.Block().StateRoot()
+	oldStateRoot := s.headBlock().Block().StateRoot()
 	s.headLock.RUnlock()
 	headSlot := s.HeadSlot()
 	newHeadSlot := headBlock.Block().Slot()
@@ -129,9 +125,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 	}
 
 	// Cache the new head info.
-	if err := s.setHead(newHeadRoot, headBlock, headState); err != nil {
-		return errors.Wrap(err, "could not set head")
-	}
+	s.setHead(newHeadRoot, headBlock, headState)
 
 	// Save the new head root to DB.
 	if err := s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, newHeadRoot); err != nil {
@@ -153,7 +147,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 // root in DB. With the inception of initial-sync-cache-state flag, it uses finalized
 // check point as anchors to resume sync therefore head is no longer needed to be saved on per slot basis.
 func (s *Service) saveHeadNoDB(ctx context.Context, b interfaces.SignedBeaconBlock, r [32]byte, hs state.BeaconState) error {
-	if err := blocks.BeaconBlockIsNil(b); err != nil {
+	if err := wrapper.BeaconBlockIsNil(b); err != nil {
 		return err
 	}
 	cachedHeadRoot, err := s.HeadRoot(ctx)
@@ -164,54 +158,38 @@ func (s *Service) saveHeadNoDB(ctx context.Context, b interfaces.SignedBeaconBlo
 		return nil
 	}
 
-	bCp, err := b.Copy()
-	if err != nil {
-		return err
-	}
-	if err := s.setHeadInitialSync(r, bCp, hs); err != nil {
-		return errors.Wrap(err, "could not set head")
-	}
+	s.setHeadInitialSync(r, b.Copy(), hs)
 	return nil
 }
 
 // This sets head view object which is used to track the head slot, root, block and state.
-func (s *Service) setHead(root [32]byte, block interfaces.SignedBeaconBlock, state state.BeaconState) error {
+func (s *Service) setHead(root [32]byte, block interfaces.SignedBeaconBlock, state state.BeaconState) {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()
 
 	// This does a full copy of the block and state.
-	bCp, err := block.Copy()
-	if err != nil {
-		return err
-	}
 	s.head = &head{
 		slot:  block.Block().Slot(),
 		root:  root,
-		block: bCp,
+		block: block.Copy(),
 		state: state.Copy(),
 	}
-	return nil
 }
 
 // This sets head view object which is used to track the head slot, root, block and state. The method
 // assumes that state being passed into the method will not be modified by any other alternate
 // caller which holds the state's reference.
-func (s *Service) setHeadInitialSync(root [32]byte, block interfaces.SignedBeaconBlock, state state.BeaconState) error {
+func (s *Service) setHeadInitialSync(root [32]byte, block interfaces.SignedBeaconBlock, state state.BeaconState) {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()
 
 	// This does a full copy of the block only.
-	bCp, err := block.Copy()
-	if err != nil {
-		return err
-	}
 	s.head = &head{
 		slot:  block.Block().Slot(),
 		root:  root,
-		block: bCp,
+		block: block.Copy(),
 		state: state,
 	}
-	return nil
 }
 
 // This returns the head slot.
@@ -234,7 +212,7 @@ func (s *Service) headRoot() [32]byte {
 // This returns the head block.
 // It does a full copy on head block for immutability.
 // This is a lock free version.
-func (s *Service) headBlock() (interfaces.SignedBeaconBlock, error) {
+func (s *Service) headBlock() interfaces.SignedBeaconBlock {
 	return s.head.block.Copy()
 }
 
@@ -242,7 +220,7 @@ func (s *Service) headBlock() (interfaces.SignedBeaconBlock, error) {
 // It does a full copy on head state for immutability.
 // This is a lock free version.
 func (s *Service) headState(ctx context.Context) state.BeaconState {
-	ctx, span := trace.StartSpan(ctx, "blockChain.headState")
+	_, span := trace.StartSpan(ctx, "blockChain.headState")
 	defer span.End()
 
 	return s.head.state.Copy()

beacon-chain/blockchain/head_test.go

@@ -13,8 +13,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -31,7 +31,7 @@ func TestSaveHead_Same(t *testing.T) {
 
 	r := [32]byte{'A'}
 	service.head = &head{slot: 0, root: r}
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
+	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	st, _ := util.DeterministicGenesisState(t, 1)
 	require.NoError(t, service.saveHead(context.Background(), r, b, st))
@@ -80,11 +80,7 @@ func TestSaveHead_Different(t *testing.T) {
 	cachedRoot, err := service.HeadRoot(context.Background())
 	require.NoError(t, err)
 	assert.DeepEqual(t, cachedRoot, newRoot[:], "Head did not change")
-	headBlock, err := service.headBlock()
-	require.NoError(t, err)
-	pb, err := headBlock.Proto()
-	require.NoError(t, err)
-	assert.DeepEqual(t, newHeadSignedBlock, pb, "Head did not change")
+	assert.DeepEqual(t, newHeadSignedBlock, service.headBlock().Proto(), "Head did not change")
 	assert.DeepSSZEqual(t, headState.CloneInnerState(), service.headState(ctx).CloneInnerState(), "Head did not change")
 }
 
@@ -134,11 +130,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	if !bytes.Equal(cachedRoot, newRoot[:]) {
 		t.Error("Head did not change")
 	}
-	headBlock, err := service.headBlock()
-	require.NoError(t, err)
-	pb, err := headBlock.Proto()
-	require.NoError(t, err)
-	assert.DeepEqual(t, newHeadSignedBlock, pb, "Head did not change")
+	assert.DeepEqual(t, newHeadSignedBlock, service.headBlock().Proto(), "Head did not change")
 	assert.DeepSSZEqual(t, headState.CloneInnerState(), service.headState(ctx).CloneInnerState(), "Head did not change")
 	require.LogsContain(t, hook, "Chain reorg occurred")
 }

beacon-chain/blockchain/init_sync_process_block.go

@@ -4,8 +4,8 @@ import (
 	"context"
 
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 )
 
 // This saves a beacon block to the initial sync blocks cache. It rate limits how many blocks
@@ -56,7 +56,7 @@ func (s *Service) getBlock(ctx context.Context, r [32]byte) (interfaces.SignedBe
 			return nil, errors.Wrap(err, "could not retrieve block from db")
 		}
 	}
-	if err := blocks.BeaconBlockIsNil(b); err != nil {
+	if err := wrapper.BeaconBlockIsNil(b); err != nil {
 		return nil, errBlockNotFoundInCacheOrDB
 	}
 	return b, nil

beacon-chain/blockchain/init_sync_process_block_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 )
@@ -27,7 +27,7 @@ func TestService_getBlock(t *testing.T) {
 	require.ErrorIs(t, err, errBlockNotFoundInCacheOrDB)
 
 	// block in cache
-	b, err := blocks.NewSignedBeaconBlock(b1)
+	b, err := wrapper.WrappedSignedBeaconBlock(b1)
 	require.NoError(t, err)
 	s.saveInitSyncBlock(ctx, r1, b)
 	got, err := s.getBlock(ctx, r1)
@@ -57,7 +57,7 @@ func TestService_hasBlockInInitSyncOrDB(t *testing.T) {
 	require.Equal(t, false, s.hasBlockInInitSyncOrDB(ctx, [32]byte{}))
 
 	// block in cache
-	b, err := blocks.NewSignedBeaconBlock(b1)
+	b, err := wrapper.WrappedSignedBeaconBlock(b1)
 	require.NoError(t, err)
 	s.saveInitSyncBlock(ctx, r1, b)
 	require.Equal(t, true, s.hasBlockInInitSyncOrDB(ctx, r1))

beacon-chain/blockchain/log.go

@@ -45,16 +45,12 @@ func logStateTransitionData(b interfaces.BeaconBlock) error {
 		log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
 	}
 	if b.Version() == version.Bellatrix {
-		p, err := b.Body().Execution()
+		p, err := b.Body().ExecutionPayload()
 		if err != nil {
 			return err
 		}
-		log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash())))
-		txs, err := p.Transactions()
-		if err != nil {
-			return err
-		}
-		log = log.WithField("txCount", len(txs))
+		log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash)))
+		log = log.WithField("txCount", len(p.Transactions))
 	}
 	log.Info("Finished applying state transition")
 	return nil
@@ -66,30 +62,24 @@ func logBlockSyncStatus(block interfaces.BeaconBlock, blockRoot [32]byte, justif
 		return err
 	}
 	level := log.Logger.GetLevel()
+
+	log = log.WithField("slot", block.Slot())
 	if level >= logrus.DebugLevel {
-		log.WithFields(logrus.Fields{
-			"slot":                      block.Slot(),
-			"slotInEpoch":               block.Slot() % params.BeaconConfig().SlotsPerEpoch,
-			"block":                     fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
-			"epoch":                     slots.ToEpoch(block.Slot()),
-			"justifiedEpoch":            justified.Epoch,
-			"justifiedRoot":             fmt.Sprintf("0x%s...", hex.EncodeToString(justified.Root)[:8]),
-			"finalizedEpoch":            finalized.Epoch,
-			"finalizedRoot":             fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
-			"parentRoot":                fmt.Sprintf("0x%s...", hex.EncodeToString(block.ParentRoot())[:8]),
-			"version":                   version.String(block.Version()),
-			"sinceSlotStartTime":        prysmTime.Now().Sub(startTime),
-			"chainServiceProcessedTime": prysmTime.Now().Sub(receivedTime),
-		}).Debug("Synced new block")
-	} else {
-		log.WithFields(logrus.Fields{
-			"slot":           block.Slot(),
-			"block":          fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
-			"finalizedEpoch": finalized.Epoch,
-			"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
-			"epoch":          slots.ToEpoch(block.Slot()),
-		}).Info("Synced new block")
+		log = log.WithField("slotInEpoch", block.Slot()%params.BeaconConfig().SlotsPerEpoch)
+		log = log.WithField("justifiedEpoch", justified.Epoch)
+		log = log.WithField("justifiedRoot", fmt.Sprintf("0x%s...", hex.EncodeToString(justified.Root)[:8]))
+		log = log.WithField("parentRoot", fmt.Sprintf("0x%s...", hex.EncodeToString(block.ParentRoot())[:8]))
+		log = log.WithField("version", version.String(block.Version()))
+		log = log.WithField("sinceSlotStartTime", prysmTime.Now().Sub(startTime))
+		log = log.WithField("chainServiceProcessedTime", prysmTime.Now().Sub(receivedTime))
 	}
+
+	log.WithFields(logrus.Fields{
+		"block":          fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
+		"epoch":          slots.ToEpoch(block.Slot()),
+		"finalizedEpoch": finalized.Epoch,
+		"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
+	}).Info("Synced new block")
 	return nil
 }
 
@@ -102,18 +92,18 @@ func logPayload(block interfaces.BeaconBlock) error {
 	if !isExecutionBlk {
 		return nil
 	}
-	payload, err := block.Body().Execution()
+	payload, err := block.Body().ExecutionPayload()
 	if err != nil {
 		return err
 	}
-	if payload.GasLimit() == 0 {
+	if payload.GasLimit == 0 {
 		return errors.New("gas limit should not be 0")
 	}
-	gasUtilized := float64(payload.GasUsed()) / float64(payload.GasLimit())
+	gasUtilized := float64(payload.GasUsed) / float64(payload.GasLimit)
 
 	log.WithFields(logrus.Fields{
-		"blockHash":   fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
-		"parentHash":  fmt.Sprintf("%#x", bytesutil.Trunc(payload.ParentHash())),
+		"blockHash":   fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash)),
+		"parentHash":  fmt.Sprintf("%#x", bytesutil.Trunc(payload.ParentHash)),
 		"blockNumber": payload.BlockNumber,
 		"gasUtilized": fmt.Sprintf("%.2f", gasUtilized),
 	}).Debug("Synced new payload")

beacon-chain/blockchain/log_test.go

@@ -3,8 +3,8 @@ package blockchain
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -21,7 +21,7 @@ func Test_logStateTransitionData(t *testing.T) {
 			},
 		},
 	}
-	wrappedPayloadBlk, err := blocks.NewBeaconBlock(payloadBlk)
+	wrappedPayloadBlk, err := wrapper.WrappedBeaconBlock(payloadBlk)
 	require.NoError(t, err)
 	tests := []struct {
 		name string
@@ -30,7 +30,7 @@ func Test_logStateTransitionData(t *testing.T) {
 	}{
 		{name: "empty block body",
 			b: func() interfaces.BeaconBlock {
-				wb, err := blocks.NewBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}})
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}})
 				require.NoError(t, err)
 				return wb
 			},
@@ -38,7 +38,7 @@ func Test_logStateTransitionData(t *testing.T) {
 		},
 		{name: "has attestation",
 			b: func() interfaces.BeaconBlock {
-				wb, err := blocks.NewBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{Attestations: []*ethpb.Attestation{{}}}})
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{Attestations: []*ethpb.Attestation{{}}}})
 				require.NoError(t, err)
 				return wb
 			},
@@ -46,7 +46,7 @@ func Test_logStateTransitionData(t *testing.T) {
 		},
 		{name: "has deposit",
 			b: func() interfaces.BeaconBlock {
-				wb, err := blocks.NewBeaconBlock(
+				wb, err := wrapper.WrappedBeaconBlock(
 					&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
 						Attestations: []*ethpb.Attestation{{}},
 						Deposits:     []*ethpb.Deposit{{}}}})
@@ -57,7 +57,7 @@ func Test_logStateTransitionData(t *testing.T) {
 		},
 		{name: "has attester slashing",
 			b: func() interfaces.BeaconBlock {
-				wb, err := blocks.NewBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
 					AttesterSlashings: []*ethpb.AttesterSlashing{{}}}})
 				require.NoError(t, err)
 				return wb
@@ -66,7 +66,7 @@ func Test_logStateTransitionData(t *testing.T) {
 		},
 		{name: "has proposer slashing",
 			b: func() interfaces.BeaconBlock {
-				wb, err := blocks.NewBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
 					ProposerSlashings: []*ethpb.ProposerSlashing{{}}}})
 				require.NoError(t, err)
 				return wb
@@ -75,7 +75,7 @@ func Test_logStateTransitionData(t *testing.T) {
 		},
 		{name: "has exit",
 			b: func() interfaces.BeaconBlock {
-				wb, err := blocks.NewBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
 					VoluntaryExits: []*ethpb.SignedVoluntaryExit{{}}}})
 				require.NoError(t, err)
 				return wb
@@ -84,7 +84,7 @@ func Test_logStateTransitionData(t *testing.T) {
 		},
 		{name: "has everything",
 			b: func() interfaces.BeaconBlock {
-				wb, err := blocks.NewBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
 					Attestations:      []*ethpb.Attestation{{}},
 					Deposits:          []*ethpb.Deposit{{}},
 					AttesterSlashings: []*ethpb.AttesterSlashing{{}},

beacon-chain/blockchain/metrics.go

@@ -198,7 +198,7 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 	for i, validator := range postState.Validators() {
 		bal, err := postState.BalanceAtIndex(types.ValidatorIndex(i))
 		if err != nil {
-			log.WithError(err).Error("Could not load validator balance")
+			log.Errorf("Could not load validator balance: %v", err)
 			continue
 		}
 		if validator.Slashed {

beacon-chain/blockchain/metrics_test.go

@@ -35,7 +35,7 @@ func TestReportEpochMetrics_SlashedValidatorOutOfBound(t *testing.T) {
 	require.NoError(t, err)
 	v.Slashed = true
 	require.NoError(t, h.UpdateValidatorAtIndex(0, v))
-	require.NoError(t, h.AppendCurrentEpochAttestations(&eth.PendingAttestation{InclusionDelay: 1, Data: util.HydrateAttestationData(&eth.AttestationData{})}))
+	require.NoError(t, h.AppendCurrentEpochAttestations(&eth.PendingAttestation{InclusionDelay: 1, Data: util.NewAttestationUtil().HydrateAttestationData(&eth.AttestationData{})}))
 	err = reportEpochMetrics(context.Background(), h, h)
 	require.ErrorContains(t, "slot 0 out of bounds", err)
 }

beacon-chain/blockchain/options.go

@@ -6,12 +6,12 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/beacon-chain/execution"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
+	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -44,7 +44,7 @@ func WithDatabase(beaconDB db.HeadAccessDatabase) Option {
 }
 
 // WithChainStartFetcher to retrieve information about genesis.
-func WithChainStartFetcher(f execution.ChainStartFetcher) Option {
+func WithChainStartFetcher(f powchain.ChainStartFetcher) Option {
 	return func(s *Service) error {
 		s.cfg.ChainStartFetcher = f
 		return nil
@@ -52,7 +52,7 @@ func WithChainStartFetcher(f execution.ChainStartFetcher) Option {
 }
 
 // WithExecutionEngineCaller to call execution engine.
-func WithExecutionEngineCaller(c execution.EngineCaller) Option {
+func WithExecutionEngineCaller(c powchain.EngineCaller) Option {
 	return func(s *Service) error {
 		s.cfg.ExecutionEngineCaller = c
 		return nil

beacon-chain/blockchain/pow_block.go

@@ -11,10 +11,11 @@ import (
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	"github.com/prysmaticlabs/prysm/time/slots"
 	"github.com/sirupsen/logrus"
 )
@@ -37,20 +38,20 @@ import (
 //    # Check if `pow_block` is a valid terminal PoW block
 //    assert is_valid_terminal_pow_block(pow_block, pow_parent)
 func (s *Service) validateMergeBlock(ctx context.Context, b interfaces.SignedBeaconBlock) error {
-	if err := blocks.BeaconBlockIsNil(b); err != nil {
+	if err := wrapper.BeaconBlockIsNil(b); err != nil {
 		return err
 	}
-	payload, err := b.Block().Body().Execution()
+	payload, err := b.Block().Body().ExecutionPayload()
 	if err != nil {
 		return err
 	}
-	if payload.IsNil() {
+	if payload == nil {
 		return errors.New("nil execution payload")
 	}
 	if err := validateTerminalBlockHash(b.Block().Slot(), payload); err != nil {
 		return errors.Wrap(err, "could not validate terminal block hash")
 	}
-	mergeBlockParentHash, mergeBlockTD, err := s.getBlkParentHashAndTD(ctx, payload.ParentHash())
+	mergeBlockParentHash, mergeBlockTD, err := s.getBlkParentHashAndTD(ctx, payload.ParentHash)
 	if err != nil {
 		return errors.Wrap(err, "could not get merge block parent hash and total difficulty")
 	}
@@ -65,12 +66,12 @@ func (s *Service) validateMergeBlock(ctx context.Context, b interfaces.SignedBea
 	if !valid {
 		err := fmt.Errorf("invalid TTD, configTTD: %s, currentTTD: %s, parentTTD: %s",
 			params.BeaconConfig().TerminalTotalDifficulty, mergeBlockTD, mergeBlockParentTD)
-		return invalidBlock{error: err}
+		return invalidBlock{err}
 	}
 
 	log.WithFields(logrus.Fields{
 		"slot":                            b.Block().Slot(),
-		"mergeBlockHash":                  common.BytesToHash(payload.ParentHash()).String(),
+		"mergeBlockHash":                  common.BytesToHash(payload.ParentHash).String(),
 		"mergeBlockParentHash":            common.BytesToHash(mergeBlockParentHash).String(),
 		"terminalTotalDifficulty":         params.BeaconConfig().TerminalTotalDifficulty,
 		"mergeBlockTotalDifficulty":       mergeBlockTD,
@@ -84,7 +85,7 @@ func (s *Service) validateMergeBlock(ctx context.Context, b interfaces.SignedBea
 
 // getBlkParentHashAndTD retrieves the parent hash and total difficulty of the given block.
 func (s *Service) getBlkParentHashAndTD(ctx context.Context, blkHash []byte) ([]byte, *uint256.Int, error) {
-	blk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(ctx, common.BytesToHash(blkHash), false /* no txs */)
+	blk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(ctx, common.BytesToHash(blkHash))
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "could not get pow block")
 	}
@@ -99,7 +100,7 @@ func (s *Service) getBlkParentHashAndTD(ctx context.Context, blkHash []byte) ([]
 	if overflows {
 		return nil, nil, errors.New("total difficulty overflows")
 	}
-	return blk.ParentHash[:], blkTDUint256, nil
+	return blk.ParentHash, blkTDUint256, nil
 }
 
 // validateTerminalBlockHash validates if the merge block is a valid terminal PoW block.
@@ -109,14 +110,14 @@ func (s *Service) getBlkParentHashAndTD(ctx context.Context, blkHash []byte) ([]
 //        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
 //        assert block.body.execution_payload.parent_hash == TERMINAL_BLOCK_HASH
 //        return
-func validateTerminalBlockHash(blkSlot types.Slot, payload interfaces.ExecutionData) error {
+func validateTerminalBlockHash(blkSlot types.Slot, payload *enginev1.ExecutionPayload) error {
 	if bytesutil.ToBytes32(params.BeaconConfig().TerminalBlockHash.Bytes()) == [32]byte{} {
 		return nil
 	}
 	if params.BeaconConfig().TerminalBlockHashActivationEpoch > slots.ToEpoch(blkSlot) {
 		return errors.New("terminal block hash activation epoch not reached")
 	}
-	if !bytes.Equal(payload.ParentHash(), params.BeaconConfig().TerminalBlockHash.Bytes()) {
+	if !bytes.Equal(payload.ParentHash, params.BeaconConfig().TerminalBlockHash.Bytes()) {
 		return errors.New("parent hash does not match terminal block hash")
 	}
 	return nil

beacon-chain/blockchain/pow_block_test.go

@@ -6,14 +6,14 @@ import (
 	"math/big"
 	"testing"
 
-	gethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/holiman/uint256"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	mocks "github.com/prysmaticlabs/prysm/beacon-chain/execution/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	mocks "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
+	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -120,19 +120,12 @@ func Test_validateMergeBlock(t *testing.T) {
 
 	engine := &mocks.EngineClient{BlockByHashMap: map[[32]byte]*enginev1.ExecutionBlock{}}
 	service.cfg.ExecutionEngineCaller = engine
-	a := [32]byte{'a'}
-	b := [32]byte{'b'}
-	mergeBlockParentHash := [32]byte{'3'}
-	engine.BlockByHashMap[a] = &enginev1.ExecutionBlock{
-		Header: gethtypes.Header{
-			ParentHash: b,
-		},
+	engine.BlockByHashMap[[32]byte{'a'}] = &enginev1.ExecutionBlock{
+		ParentHash:      bytesutil.PadTo([]byte{'b'}, fieldparams.RootLength),
 		TotalDifficulty: "0x2",
 	}
-	engine.BlockByHashMap[b] = &enginev1.ExecutionBlock{
-		Header: gethtypes.Header{
-			ParentHash: mergeBlockParentHash,
-		},
+	engine.BlockByHashMap[[32]byte{'b'}] = &enginev1.ExecutionBlock{
+		ParentHash:      bytesutil.PadTo([]byte{'3'}, fieldparams.RootLength),
 		TotalDifficulty: "0x1",
 	}
 	blk := &ethpb.SignedBeaconBlockBellatrix{
@@ -140,18 +133,18 @@ func Test_validateMergeBlock(t *testing.T) {
 			Slot: 1,
 			Body: &ethpb.BeaconBlockBodyBellatrix{
 				ExecutionPayload: &enginev1.ExecutionPayload{
-					ParentHash: a[:],
+					ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
 				},
 			},
 		},
 	}
-	bk, err := blocks.NewSignedBeaconBlock(blk)
+	b, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
-	require.NoError(t, service.validateMergeBlock(ctx, bk))
+	require.NoError(t, service.validateMergeBlock(ctx, b))
 
 	cfg.TerminalTotalDifficulty = "1"
 	params.OverrideBeaconConfig(cfg)
-	err = service.validateMergeBlock(ctx, bk)
+	err = service.validateMergeBlock(ctx, b)
 	require.ErrorContains(t, "invalid TTD, configTTD: 1, currentTTD: 2, parentTTD: 1", err)
 	require.Equal(t, true, IsInvalidBlock(err))
 }
@@ -174,9 +167,7 @@ func Test_getBlkParentHashAndTD(t *testing.T) {
 	p := [32]byte{'b'}
 	td := "0x1"
 	engine.BlockByHashMap[h] = &enginev1.ExecutionBlock{
-		Header: gethtypes.Header{
-			ParentHash: p,
-		},
+		ParentHash:      p[:],
 		TotalDifficulty: td,
 	}
 	parentHash, totalDifficulty, err := service.getBlkParentHashAndTD(ctx, h[:])
@@ -192,18 +183,14 @@ func Test_getBlkParentHashAndTD(t *testing.T) {
 	require.ErrorContains(t, "pow block is nil", err)
 
 	engine.BlockByHashMap[h] = &enginev1.ExecutionBlock{
-		Header: gethtypes.Header{
-			ParentHash: p,
-		},
+		ParentHash:      p[:],
 		TotalDifficulty: "1",
 	}
 	_, _, err = service.getBlkParentHashAndTD(ctx, h[:])
 	require.ErrorContains(t, "could not decode merge block total difficulty: hex string without 0x prefix", err)
 
 	engine.BlockByHashMap[h] = &enginev1.ExecutionBlock{
-		Header: gethtypes.Header{
-			ParentHash: p,
-		},
+		ParentHash:      p[:],
 		TotalDifficulty: "0XFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
 	}
 	_, _, err = service.getBlkParentHashAndTD(ctx, h[:])
@@ -211,22 +198,16 @@ func Test_getBlkParentHashAndTD(t *testing.T) {
 }
 
 func Test_validateTerminalBlockHash(t *testing.T) {
-	wrapped, err := blocks.WrappedExecutionPayload(&enginev1.ExecutionPayload{})
-	require.NoError(t, err)
-	require.NoError(t, validateTerminalBlockHash(1, wrapped))
+	require.NoError(t, validateTerminalBlockHash(1, &enginev1.ExecutionPayload{}))
 
 	cfg := params.BeaconConfig()
 	cfg.TerminalBlockHash = [32]byte{0x01}
 	params.OverrideBeaconConfig(cfg)
-	require.ErrorContains(t, "terminal block hash activation epoch not reached", validateTerminalBlockHash(1, wrapped))
+	require.ErrorContains(t, "terminal block hash activation epoch not reached", validateTerminalBlockHash(1, &enginev1.ExecutionPayload{}))
 
 	cfg.TerminalBlockHashActivationEpoch = 0
 	params.OverrideBeaconConfig(cfg)
-	require.ErrorContains(t, "parent hash does not match terminal block hash", validateTerminalBlockHash(1, wrapped))
+	require.ErrorContains(t, "parent hash does not match terminal block hash", validateTerminalBlockHash(1, &enginev1.ExecutionPayload{}))
 
-	wrapped, err = blocks.WrappedExecutionPayload(&enginev1.ExecutionPayload{
-		ParentHash: cfg.TerminalBlockHash.Bytes(),
-	})
-	require.NoError(t, err)
-	require.NoError(t, validateTerminalBlockHash(1, wrapped))
+	require.NoError(t, validateTerminalBlockHash(1, &enginev1.ExecutionPayload{ParentHash: cfg.TerminalBlockHash.Bytes()}))
 }

beacon-chain/blockchain/process_attestation_helpers.go

@@ -10,8 +10,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time/slots"
@@ -80,7 +80,7 @@ func (s *Service) verifyBeaconBlock(ctx context.Context, data *ethpb.Attestation
 	if err != nil {
 		return err
 	}
-	if err := blocks.BeaconBlockIsNil(b); err != nil {
+	if err := wrapper.BeaconBlockIsNil(b); err != nil {
 		return err
 	}
 	if b.Block().Slot() > data.Slot {

beacon-chain/blockchain/process_attestation_test.go

@@ -70,6 +70,7 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, blkWithValidStateRoot))
 
+	au := util.AttestationUtil{}
 	tests := []struct {
 		name      string
 		a         *ethpb.Attestation
@@ -77,17 +78,17 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
 	}{
 		{
 			name:      "attestation's data slot not aligned with target vote",
-			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}}),
+			a:         au.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}}),
 			wantedErr: "slot 32 does not match target epoch 0",
 		},
 		{
 			name:      "no pre state for attestations's target block",
-			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}}),
+			a:         au.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}}),
 			wantedErr: "could not get pre state for epoch 0",
 		},
 		{
 			name: "process attestation doesn't match current epoch",
-			a: util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
+			a: au.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
 				Root: BlkWithStateBadAttRoot[:]}}}),
 			wantedErr: "target epoch 100 does not match current epoch",
 		},
@@ -176,6 +177,7 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, blkWithValidStateRoot))
 
+	au := util.AttestationUtil{}
 	tests := []struct {
 		name      string
 		a         *ethpb.Attestation
@@ -183,17 +185,17 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
 	}{
 		{
 			name:      "attestation's data slot not aligned with target vote",
-			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}}),
+			a:         au.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}}),
 			wantedErr: "slot 32 does not match target epoch 0",
 		},
 		{
 			name:      "no pre state for attestations's target block",
-			a:         util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}}),
+			a:         au.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}}),
 			wantedErr: "could not get pre state for epoch 0",
 		},
 		{
 			name: "process attestation doesn't match current epoch",
-			a: util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
+			a: au.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
 				Root: BlkWithStateBadAttRoot[:]}}}),
 			wantedErr: "target epoch 100 does not match current epoch",
 		},
@@ -249,7 +251,7 @@ func TestStore_OnAttestation_Ok_ProtoArray(t *testing.T) {
 	genesisState, pks := util.DeterministicGenesisState(t, 64)
 	service.SetGenesisTime(time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
+	att, err := util.NewAttestationUtil().GenerateAttestations(genesisState, pks, 1, 0, false)
 	require.NoError(t, err)
 	tRoot := bytesutil.ToBytes32(att[0].Data.Target.Root)
 	copied := genesisState.Copy()
@@ -279,7 +281,7 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 	genesisState, pks := util.DeterministicGenesisState(t, 64)
 	service.SetGenesisTime(time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	att, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
+	att, err := util.NewAttestationUtil().GenerateAttestations(genesisState, pks, 1, 0, false)
 	require.NoError(t, err)
 	tRoot := bytesutil.ToBytes32(att[0].Data.Target.Root)
 	copied := genesisState.Copy()
@@ -422,8 +424,7 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
 	opts := testServiceOptsWithDB(t)
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-
-	d := util.HydrateAttestationData(&ethpb.AttestationData{})
+	d := util.NewAttestationUtil().HydrateAttestationData(&ethpb.AttestationData{})
 	require.Equal(t, errBlockNotFoundInCacheOrDB, service.verifyBeaconBlock(ctx, d))
 }
 

beacon-chain/blockchain/process_block.go

@@ -17,9 +17,10 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
@@ -95,8 +96,8 @@ var initialSyncBlockCacheSize = uint64(2 * params.BeaconConfig().SlotsPerEpoch)
 func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlock, blockRoot [32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlock")
 	defer span.End()
-	if err := consensusblocks.BeaconBlockIsNil(signed); err != nil {
-		return invalidBlock{error: err}
+	if err := wrapper.BeaconBlockIsNil(signed); err != nil {
+		return invalidBlock{err}
 	}
 	b := signed.Block()
 
@@ -105,19 +106,13 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 		return err
 	}
 
-	// Save current justified and finalized epochs for future use.
-	currStoreJustifiedEpoch := s.ForkChoicer().JustifiedCheckpoint().Epoch
-	currStoreFinalizedEpoch := s.ForkChoicer().FinalizedCheckpoint().Epoch
-	preStateFinalizedEpoch := preState.FinalizedCheckpoint().Epoch
-	preStateJustifiedEpoch := preState.CurrentJustifiedCheckpoint().Epoch
-
 	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
 	if err != nil {
 		return err
 	}
 	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
-		return invalidBlock{error: err}
+		return invalidBlock{err}
 	}
 	postStateVersion, postStateHeader, err := getStateVersionAndPayload(postState)
 	if err != nil {
@@ -125,7 +120,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	}
 	isValidPayload, err := s.notifyNewPayload(ctx, postStateVersion, postStateHeader, signed)
 	if err != nil {
-		return errors.Wrap(err, "could not validate new payload")
+		return fmt.Errorf("could not verify new payload: %v", err)
 	}
 	if isValidPayload {
 		if err := s.validateMergeTransitionBlock(ctx, preStateVersion, preStateHeader, signed); err != nil {
@@ -135,6 +130,9 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState); err != nil {
 		return err
 	}
+	// save current justified and finalized epochs for future use
+	currJustifiedEpoch := s.ForkChoicer().JustifiedCheckpoint().Epoch
+	currFinalizedEpoch := s.ForkChoicer().FinalizedCheckpoint().Epoch
 
 	if err := s.insertBlockAndAttestationsToForkChoiceStore(ctx, signed.Block(), blockRoot, postState); err != nil {
 		return errors.Wrapf(err, "could not insert block %d to fork choice store", signed.Block().Slot())
@@ -183,9 +181,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	if err != nil {
 		log.WithError(err).Warn("Could not update head")
 	}
-	if err := s.notifyEngineIfChangedHead(ctx, headRoot); err != nil {
-		return err
-	}
+	s.notifyEngineIfChangedHead(ctx, headRoot)
 
 	if err := s.pruneCanonicalAttsFromPool(ctx, blockRoot, signed); err != nil {
 		return err
@@ -215,20 +211,16 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	}()
 
 	// Save justified check point to db.
-	postStateJustifiedEpoch := postState.CurrentJustifiedCheckpoint().Epoch
-	if justified.Epoch > currStoreJustifiedEpoch || (justified.Epoch == postStateJustifiedEpoch && justified.Epoch > preStateJustifiedEpoch) {
-		if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{
-			Epoch: justified.Epoch, Root: justified.Root[:],
-		}); err != nil {
+	if justified.Epoch > currJustifiedEpoch {
+		if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, postState.CurrentJustifiedCheckpoint()); err != nil {
 			return err
 		}
 	}
 
-	// Save finalized check point to db and more.
-	postStateFinalizedEpoch := postState.FinalizedCheckpoint().Epoch
+	// Update finalized check point.
 	finalized := s.ForkChoicer().FinalizedCheckpoint()
-	if finalized.Epoch > currStoreFinalizedEpoch || (finalized.Epoch == postStateFinalizedEpoch && finalized.Epoch > preStateFinalizedEpoch) {
-		if err := s.updateFinalized(ctx, &ethpb.Checkpoint{Epoch: finalized.Epoch, Root: finalized.Root[:]}); err != nil {
+	if finalized.Epoch > currFinalizedEpoch {
+		if err := s.updateFinalized(ctx, postState.FinalizedCheckpoint()); err != nil {
 			return err
 		}
 		isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(finalized.Root)
@@ -293,8 +285,8 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 		return errWrongBlockCount
 	}
 
-	if err := consensusblocks.BeaconBlockIsNil(blks[0]); err != nil {
-		return invalidBlock{error: err}
+	if err := wrapper.BeaconBlockIsNil(blks[0]); err != nil {
+		return invalidBlock{err}
 	}
 	b := blks[0].Block()
 
@@ -342,7 +334,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 
 		set, preState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)
 		if err != nil {
-			return invalidBlock{error: err}
+			return invalidBlock{err}
 		}
 		// Save potential boundary states.
 		if slots.IsEpochStart(preState.Slot()) {
@@ -363,7 +355,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 	}
 	verify, err := sigSet.Verify()
 	if err != nil {
-		return invalidBlock{error: err}
+		return invalidBlock{err}
 	}
 	if !verify {
 		return errors.New("batch block signature verification failed")
@@ -501,15 +493,9 @@ func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Contex
 	ctx, span := trace.StartSpan(ctx, "blockChain.insertBlockAndAttestationsToForkChoiceStore")
 	defer span.End()
 
-	if !s.cfg.ForkChoiceStore.HasNode(bytesutil.ToBytes32(blk.ParentRoot())) {
-		fCheckpoint := st.FinalizedCheckpoint()
-		jCheckpoint := st.CurrentJustifiedCheckpoint()
-		if err := s.fillInForkChoiceMissingBlocks(ctx, blk, fCheckpoint, jCheckpoint); err != nil {
-			return err
-		}
-	}
-
-	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, st, root); err != nil {
+	fCheckpoint := st.FinalizedCheckpoint()
+	jCheckpoint := st.CurrentJustifiedCheckpoint()
+	if err := s.insertBlockToForkChoiceStore(ctx, blk, root, st, fCheckpoint, jCheckpoint); err != nil {
 		return err
 	}
 	// Feed in block's attestations to fork choice store.
@@ -527,6 +513,13 @@ func (s *Service) insertBlockAndAttestationsToForkChoiceStore(ctx context.Contex
 	return nil
 }
 
+func (s *Service) insertBlockToForkChoiceStore(ctx context.Context, blk interfaces.BeaconBlock, root [32]byte, st state.BeaconState, fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
+	if err := s.fillInForkChoiceMissingBlocks(ctx, blk, fCheckpoint, jCheckpoint); err != nil {
+		return err
+	}
+	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, root)
+}
+
 // InsertSlashingsToForkChoiceStore inserts attester slashing indices to fork choice store.
 // To call this function, it's caller's responsibility to ensure the slashing object is valid.
 func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashings []*ethpb.AttesterSlashing) {
@@ -586,15 +579,11 @@ func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion
 	}
 
 	// Skip validation if block has an empty payload.
-	payload, err := blk.Block().Body().Execution()
+	payload, err := blk.Block().Body().ExecutionPayload()
 	if err != nil {
-		return invalidBlock{error: err}
+		return invalidBlock{err}
 	}
-	isEmpty, err := consensusblocks.IsEmptyExecutionData(payload)
-	if err != nil {
-		return err
-	}
-	if isEmpty {
+	if bellatrix.IsEmptyPayload(payload) {
 		return nil
 	}
 
@@ -605,16 +594,11 @@ func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion
 	}
 
 	// Skip validation if the block is not a merge transition block.
-	// To reach here. The payload must be non-empty. If the state header is empty then it's at transition.
-	wh, err := consensusblocks.WrappedExecutionPayloadHeader(stateHeader)
+	atTransition, err := blocks.IsMergeTransitionBlockUsingPreStatePayloadHeader(stateHeader, blk.Block().Body())
 	if err != nil {
-		return err
+		return errors.Wrap(err, "could not check if merge block is terminal")
 	}
-	empty, err := consensusblocks.IsEmptyExecutionData(wh)
-	if err != nil {
-		return err
-	}
-	if !empty {
+	if !atTransition {
 		return nil
 	}
 	return s.validateMergeBlock(ctx, blk)
@@ -647,17 +631,12 @@ func (s *Service) fillMissingPayloadIDRoutine(ctx context.Context, stateFeed *ev
 				_, id, has := s.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(s.CurrentSlot() + 1)
 				// There exists proposer for next slot, but we haven't called fcu w/ payload attribute yet.
 				if has && id == [8]byte{} {
-					headBlock, err := s.headBlock()
-					if err != nil {
-						log.WithError(err).Error("Could not get head block")
-					} else {
-						if _, err := s.notifyForkchoiceUpdate(ctx, &notifyForkchoiceUpdateArg{
-							headState: s.headState(ctx),
-							headRoot:  s.headRoot(),
-							headBlock: headBlock.Block(),
-						}); err != nil {
-							log.WithError(err).Error("Could not prepare payload on empty ID")
-						}
+					if _, err := s.notifyForkchoiceUpdate(ctx, &notifyForkchoiceUpdateArg{
+						headState: s.headState(ctx),
+						headRoot:  s.headRoot(),
+						headBlock: s.headBlock().Block(),
+					}); err != nil {
+						log.WithError(err).Error("Could not prepare payload on empty ID")
 					}
 					missedPayloadIDFilledCount.Inc()
 				}

beacon-chain/blockchain/process_block_helpers.go

@@ -114,7 +114,7 @@ func (s *Service) VerifyFinalizedBlkDescendant(ctx context.Context, root [32]byt
 			bytesutil.Trunc(root[:]), fSlot, bytesutil.Trunc(bFinalizedRoot),
 			bytesutil.Trunc(fRoot[:]))
 		tracing.AnnotateError(span, err)
-		return invalidBlock{error: err}
+		return invalidBlock{err}
 	}
 	return nil
 }
@@ -129,7 +129,7 @@ func (s *Service) verifyBlkFinalizedSlot(b interfaces.BeaconBlock) error {
 	}
 	if finalizedSlot >= b.Slot() {
 		err = fmt.Errorf("block is equal or earlier than finalized block, slot %d < slot %d", b.Slot(), finalizedSlot)
-		return invalidBlock{error: err}
+		return invalidBlock{err}
 	}
 	return nil
 }

beacon-chain/blockchain/receive_attestation.go

@@ -166,35 +166,33 @@ func (s *Service) UpdateHead(ctx context.Context) error {
 		}).Debug("Head changed due to attestations")
 	}
 	s.headLock.RUnlock()
-	if err := s.notifyEngineIfChangedHead(ctx, newHeadRoot); err != nil {
-		return err
-	}
+	s.notifyEngineIfChangedHead(ctx, newHeadRoot)
 	return nil
 }
 
 // This calls notify Forkchoice Update in the event that the head has changed
-func (s *Service) notifyEngineIfChangedHead(ctx context.Context, newHeadRoot [32]byte) error {
+func (s *Service) notifyEngineIfChangedHead(ctx context.Context, newHeadRoot [32]byte) {
 	s.headLock.RLock()
 	if newHeadRoot == [32]byte{} || s.headRoot() == newHeadRoot {
 		s.headLock.RUnlock()
-		return nil
+		return
 	}
 	s.headLock.RUnlock()
 
 	if !s.hasBlockInInitSyncOrDB(ctx, newHeadRoot) {
 		log.Debug("New head does not exist in DB. Do nothing")
-		return nil // We don't have the block, don't notify the engine and update head.
+		return // We don't have the block, don't notify the engine and update head.
 	}
 
 	newHeadBlock, err := s.getBlock(ctx, newHeadRoot)
 	if err != nil {
 		log.WithError(err).Error("Could not get new head block")
-		return nil
+		return
 	}
 	headState, err := s.cfg.StateGen.StateByRoot(ctx, newHeadRoot)
 	if err != nil {
 		log.WithError(err).Error("Could not get state from db")
-		return nil
+		return
 	}
 	arg := &notifyForkchoiceUpdateArg{
 		headState: headState,
@@ -203,12 +201,11 @@ func (s *Service) notifyEngineIfChangedHead(ctx context.Context, newHeadRoot [32
 	}
 	_, err = s.notifyForkchoiceUpdate(s.ctx, arg)
 	if err != nil {
-		return err
+		log.WithError(err).Error("could not notify forkchoice update")
 	}
 	if err := s.saveHead(ctx, newHeadRoot, newHeadBlock, headState); err != nil {
 		log.WithError(err).Error("could not save head")
 	}
-	return nil
 }
 
 // This processes fork choice attestations from the pool to account for validator votes and fork choice.

beacon-chain/blockchain/receive_attestation_test.go

@@ -12,8 +12,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -60,7 +60,7 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
 	require.NoError(t, err)
 
 	wanted := "FFG and LMD votes are not consistent"
-	a := util.NewAttestation()
+	a := util.NewAttestationUtil().NewAttestation()
 	a.Data.Target.Epoch = 1
 	a.Data.Target.Root = []byte{'a'}
 	a.Data.BeaconBlockRoot = r33[:]
@@ -85,8 +85,7 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
 	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b33)
 	r33, err := b33.Block.HashTreeRoot()
 	require.NoError(t, err)
-
-	a := util.NewAttestation()
+	a := util.NewAttestationUtil().NewAttestation()
 	a.Data.Target.Epoch = 1
 	a.Data.Target.Root = r32[:]
 	a.Data.BeaconBlockRoot = r33[:]
@@ -106,7 +105,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	genesisState, pks := util.DeterministicGenesisState(t, 64)
 	require.NoError(t, genesisState.SetGenesisTime(uint64(prysmTime.Now().Unix())-params.BeaconConfig().SecondsPerSlot))
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-	atts, err := util.GenerateAttestations(genesisState, pks, 1, 0, false)
+	atts, err := util.NewAttestationUtil().GenerateAttestations(genesisState, pks, 1, 0, false)
 	require.NoError(t, err)
 	tRoot := bytesutil.ToBytes32(atts[0].Data.Target.Root)
 	copied := genesisState.Copy()
@@ -132,15 +131,15 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	service.cfg.ProposerSlotIndexCache = cache.NewProposerPayloadIDsCache()
-	require.NoError(t, service.notifyEngineIfChangedHead(ctx, service.headRoot()))
+	service.notifyEngineIfChangedHead(ctx, service.headRoot())
 	hookErr := "could not notify forkchoice update"
 	invalidStateErr := "Could not get state from db"
 	require.LogsDoNotContain(t, hook, invalidStateErr)
 	require.LogsDoNotContain(t, hook, hookErr)
-	gb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
+	gb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	require.NoError(t, service.saveInitSyncBlock(ctx, [32]byte{'a'}, gb))
-	require.NoError(t, service.notifyEngineIfChangedHead(ctx, [32]byte{'a'}))
+	service.notifyEngineIfChangedHead(ctx, [32]byte{'a'})
 	require.LogsContain(t, hook, invalidStateErr)
 
 	hook.Reset()
@@ -152,7 +151,7 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 	// Block in Cache
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 2
-	wsb, err := blocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	r1, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -165,7 +164,7 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 		state: st,
 	}
 	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(2, 1, [8]byte{1})
-	require.NoError(t, service.notifyEngineIfChangedHead(ctx, r1))
+	service.notifyEngineIfChangedHead(ctx, r1)
 	require.LogsDoNotContain(t, hook, invalidStateErr)
 	require.LogsDoNotContain(t, hook, hookErr)
 
@@ -183,7 +182,7 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 		state: st,
 	}
 	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(2, 1, [8]byte{1})
-	require.NoError(t, service.notifyEngineIfChangedHead(ctx, r1))
+	service.notifyEngineIfChangedHead(ctx, r1)
 	require.LogsDoNotContain(t, hook, invalidStateErr)
 	require.LogsDoNotContain(t, hook, hookErr)
 	vId, payloadID, has := service.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(2)
@@ -193,7 +192,7 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
 
 	// Test zero headRoot returns immediately.
 	headRoot := service.headRoot()
-	require.NoError(t, service.notifyEngineIfChangedHead(ctx, [32]byte{}))
+	service.notifyEngineIfChangedHead(ctx, [32]byte{})
 	require.Equal(t, service.headRoot(), headRoot)
 }
 
@@ -218,7 +217,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	require.NoError(t, err)
 	tRoot, err := blk.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := blocks.NewSignedBeaconBlock(blk)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
 	require.NoError(t, service.onBlock(ctx, wsb, tRoot))
 	copied, err = service.cfg.StateGen.StateByRoot(ctx, tRoot)
@@ -227,7 +226,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 
 	// Generate attestatios for this block in Slot 1
-	atts, err := util.GenerateAttestations(copied, pks, 1, 1, false)
+	atts, err := util.NewAttestationUtil().GenerateAttestations(copied, pks, 1, 1, false)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
 	// Verify the target is in forchoice

beacon-chain/blockchain/receive_block.go

@@ -39,10 +39,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaco
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlock")
 	defer span.End()
 	receivedTime := time.Now()
-	blockCopy, err := block.Copy()
-	if err != nil {
-		return err
-	}
+	blockCopy := block.Copy()
 
 	// Apply state transition on the new block.
 	if err := s.onBlock(ctx, blockCopy, blockRoot); err != nil {
@@ -97,10 +94,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Sig
 	}
 
 	for i, b := range blocks {
-		blockCopy, err := b.Copy()
-		if err != nil {
-			return err
-		}
+		blockCopy := b.Copy()
 		// Send notification of the processed block to the state feed.
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.BlockProcessed,
@@ -128,7 +122,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Sig
 		// log.Fatalf will prevent defer from being called
 		span.End()
 		// Exit run time if the node failed to verify weak subjectivity checkpoint.
-		log.WithError(err).Fatal("Could not verify weak subjectivity checkpoint")
+		log.Fatalf("Could not verify weak subjectivity checkpoint: %v", err)
 	}
 
 	return nil
@@ -152,7 +146,7 @@ func (s *Service) handlePostBlockOperations(b interfaces.BeaconBlock) error {
 
 	// Add block attestations to the fork choice pool to compute head.
 	if err := s.cfg.AttPool.SaveBlockAttestations(b.Body().Attestations()); err != nil {
-		log.WithError(err).Error("Could not save block attestations for fork choice")
+		log.Errorf("Could not save block attestations for fork choice: %v", err)
 		return nil
 	}
 	// Mark block exits as seen so we don't include same ones in future blocks.

beacon-chain/blockchain/receive_block_test.go

@@ -13,9 +13,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -33,7 +33,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 		assert.NoError(t, err)
 		return blk
 	}
-	params.SetupTestConfigCleanupWithLock(t)
+	params.SetupTestConfigCleanup(t)
 	bc := params.BeaconConfig().Copy()
 	bc.ShardCommitteePeriod = 0 // Required for voluntary exits test in reasonable time.
 	params.OverrideBeaconConfig(bc)
@@ -119,9 +119,7 @@ func TestService_ReceiveBlock(t *testing.T) {
 		},
 	}
 
-	wg := new(sync.WaitGroup)
 	for _, tt := range tests {
-		wg.Add(1)
 		t.Run(tt.name, func(t *testing.T) {
 			beaconDB := testDB.SetupDB(t)
 			genesisBlockRoot := bytesutil.ToBytes32(nil)
@@ -138,12 +136,10 @@ func TestService_ReceiveBlock(t *testing.T) {
 			}
 			s, err := NewService(ctx, opts...)
 			require.NoError(t, err)
-			// Initialize it here.
-			_ = s.cfg.StateNotifier.StateFeed()
 			require.NoError(t, s.saveGenesisData(ctx, genesis))
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
-			wsb, err := blocks.NewSignedBeaconBlock(tt.args.block)
+			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
 			require.NoError(t, err)
 			err = s.ReceiveBlock(ctx, wsb, root)
 			if tt.wantedErr != "" {
@@ -152,10 +148,8 @@ func TestService_ReceiveBlock(t *testing.T) {
 				assert.NoError(t, err)
 				tt.check(t, s)
 			}
-			wg.Done()
 		})
 	}
-	wg.Wait()
 }
 
 func TestService_ReceiveBlockUpdateHead(t *testing.T) {
@@ -177,15 +171,13 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 
 	s, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	// Initialize it here.
-	_ = s.cfg.StateNotifier.StateFeed()
 	require.NoError(t, s.saveGenesisData(ctx, genesis))
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	go func() {
-		wsb, err := blocks.NewSignedBeaconBlock(b)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 		require.NoError(t, err)
 		require.NoError(t, s.ReceiveBlock(ctx, wsb, root))
 		wg.Done()
@@ -255,7 +247,7 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 			require.NoError(t, err)
 			root, err := tt.args.block.Block.HashTreeRoot()
 			require.NoError(t, err)
-			wsb, err := blocks.NewSignedBeaconBlock(tt.args.block)
+			wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
 			require.NoError(t, err)
 			blks := []interfaces.SignedBeaconBlock{wsb}
 			roots := [][32]byte{root}
@@ -279,7 +271,7 @@ func TestService_HasBlock(t *testing.T) {
 	if s.HasBlock(context.Background(), r) {
 		t.Error("Should not have block")
 	}
-	wsb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
+	wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	require.NoError(t, s.saveInitSyncBlock(context.Background(), r, wsb))
 	if !s.HasBlock(context.Background(), r) {

beacon-chain/blockchain/service.go

@@ -19,7 +19,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/beacon-chain/execution"
 	f "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
@@ -28,14 +27,15 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
+	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/time"
@@ -70,7 +70,7 @@ type Service struct {
 // config options for the service.
 type config struct {
 	BeaconBlockBuf          int
-	ChainStartFetcher       execution.ChainStartFetcher
+	ChainStartFetcher       powchain.ChainStartFetcher
 	BeaconDB                db.HeadAccessDatabase
 	DepositCache            *depositcache.DepositCache
 	ProposerSlotIndexCache  *cache.ProposerPayloadIDsCache
@@ -85,9 +85,9 @@ type config struct {
 	StateGen                *stategen.State
 	SlasherAttestationsFeed *event.Feed
 	WeakSubjectivityCheckpt *ethpb.Checkpoint
-	BlockFetcher            execution.POWBlockFetcher
+	BlockFetcher            powchain.POWBlockFetcher
 	FinalizedStateAtStartUp state.BeaconState
-	ExecutionEngineCaller   execution.EngineCaller
+	ExecutionEngineCaller   powchain.EngineCaller
 }
 
 // NewService instantiates a new block service instance that will
@@ -130,7 +130,7 @@ func (s *Service) Start() {
 			log.Fatal(err)
 		}
 	} else {
-		if err := s.startFromExecutionChain(); err != nil {
+		if err := s.startFromPOWChain(); err != nil {
 			log.Fatal(err)
 		}
 	}
@@ -271,7 +271,7 @@ func (s *Service) originRootFromSavedState(ctx context.Context) ([32]byte, error
 	if err != nil {
 		return originRoot, errors.Wrap(err, "could not get genesis block from db")
 	}
-	if err := blocks.BeaconBlockIsNil(genesisBlock); err != nil {
+	if err := wrapper.BeaconBlockIsNil(genesisBlock); err != nil {
 		return originRoot, err
 	}
 	genesisBlkRoot, err := genesisBlock.Block().HashTreeRoot()
@@ -329,9 +329,7 @@ func (s *Service) initializeHeadFromDB(ctx context.Context) error {
 			if err != nil {
 				return errors.Wrap(err, "could not retrieve head state")
 			}
-			if err := s.setHead(headRoot, headBlock, headState); err != nil {
-				return errors.Wrap(err, "could not set head")
-			}
+			s.setHead(headRoot, headBlock, headState)
 			return nil
 		} else {
 			log.Warnf("Finalized checkpoint at slot %d is too close to the current head slot, "+
@@ -347,17 +345,15 @@ func (s *Service) initializeHeadFromDB(ctx context.Context) error {
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized block")
 	}
-	if err := s.setHead(finalizedRoot, finalizedBlock, finalizedState); err != nil {
-		return errors.Wrap(err, "could not set head")
-	}
+	s.setHead(finalizedRoot, finalizedBlock, finalizedState)
 
 	return nil
 }
 
-func (s *Service) startFromExecutionChain() error {
+func (s *Service) startFromPOWChain() error {
 	log.Info("Waiting to reach the validator deposit threshold to start the beacon chain...")
 	if s.cfg.ChainStartFetcher == nil {
-		return errors.New("not configured execution chain")
+		return errors.New("not configured web3Service for POW chain")
 	}
 	go func() {
 		stateChannel := make(chan *feed.Event, 1)
@@ -373,7 +369,7 @@ func (s *Service) startFromExecutionChain() error {
 						return
 					}
 					log.WithField("starttime", data.StartTime).Debug("Received chain start event")
-					s.onExecutionChainStart(s.ctx, data.StartTime)
+					s.onPowchainStart(s.ctx, data.StartTime)
 					return
 				}
 			case <-s.ctx.Done():
@@ -389,18 +385,18 @@ func (s *Service) startFromExecutionChain() error {
 	return nil
 }
 
-// onExecutionChainStart initializes a series of deposits from the ChainStart deposits in the eth1
+// onPowchainStart initializes a series of deposits from the ChainStart deposits in the eth1
 // deposit contract, initializes the beacon chain's state, and kicks off the beacon chain.
-func (s *Service) onExecutionChainStart(ctx context.Context, genesisTime time.Time) {
+func (s *Service) onPowchainStart(ctx context.Context, genesisTime time.Time) {
 	preGenesisState := s.cfg.ChainStartFetcher.PreGenesisState()
 	initializedState, err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.cfg.ChainStartFetcher.ChainStartEth1Data())
 	if err != nil {
-		log.WithError(err).Fatal("Could not initialize beacon chain")
+		log.Fatalf("Could not initialize beacon chain: %v", err)
 	}
 	// We start a counter to genesis, if needed.
 	gRoot, err := initializedState.HashTreeRoot(s.ctx)
 	if err != nil {
-		log.WithError(err).Fatal("Could not hash tree root genesis state")
+		log.Fatalf("Could not hash tree root genesis state: %v", err)
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
 
@@ -473,7 +469,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	s.cfg.StateGen.SaveFinalizedState(0 /*slot*/, genesisBlkRoot, genesisState)
 
 	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, genesisState, genesisBlkRoot); err != nil {
-		log.WithError(err).Fatal("Could not process genesis block for fork choice")
+		log.Fatalf("Could not process genesis block for fork choice: %v", err)
 	}
 	s.cfg.ForkChoiceStore.SetOriginRoot(genesisBlkRoot)
 	// Set genesis as fully validated
@@ -482,9 +478,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	}
 	s.cfg.ForkChoiceStore.SetGenesisTime(uint64(s.genesisTime.Unix()))
 
-	if err := s.setHead(genesisBlkRoot, genesisBlk, genesisState); err != nil {
-		log.WithError(err).Fatal("Could not set head")
-	}
+	s.setHead(genesisBlkRoot, genesisBlk, genesisState)
 	return nil
 }
 
@@ -508,11 +502,11 @@ func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db d
 
 	gState, err := db.GenesisState(ctx)
 	if err != nil {
-		log.WithError(err).Fatal("Could not retrieve genesis state")
+		log.Fatalf("Could not retrieve genesis state: %v", err)
 	}
 	gRoot, err := gState.HashTreeRoot(ctx)
 	if err != nil {
-		log.WithError(err).Fatal("Could not hash tree root genesis state")
+		log.Fatalf("Could not hash tree root genesis state: %v", err)
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(gState.NumValidators()), gRoot)
 }

beacon-chain/blockchain/service_norace_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 	"github.com/sirupsen/logrus"
@@ -22,7 +22,7 @@ func TestChainService_SaveHead_DataRace(t *testing.T) {
 	s := &Service{
 		cfg: &config{BeaconDB: beaconDB},
 	}
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
+	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
 	st, _ := util.DeterministicGenesisState(t, 1)
 	require.NoError(t, err)
 	go func() {

beacon-chain/blockchain/service_test.go

@@ -18,18 +18,18 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/execution"
-	mockExecution "github.com/prysmaticlabs/prysm/beacon-chain/execution/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
+	"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
+	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/config/params"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/container/trie"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -76,9 +76,9 @@ var _ p2p.Broadcaster = (*mockBroadcaster)(nil)
 
 func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	ctx := context.Background()
-	var web3Service *execution.Service
+	var web3Service *powchain.Service
 	var err error
-	srv, endpoint, err := mockExecution.SetupRPCServer()
+	srv, endpoint, err := mockPOW.SetupRPCServer()
 	require.NoError(t, err)
 	t.Cleanup(func() {
 		srv.Stop()
@@ -88,7 +88,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 	require.NoError(t, err)
 	mockTrie, err := trie.NewTrie(0)
 	require.NoError(t, err)
-	err = beaconDB.SaveExecutionChainData(ctx, &ethpb.ETH1ChainData{
+	err = beaconDB.SavePowchainData(ctx, &ethpb.ETH1ChainData{
 		BeaconState: pbState,
 		Trie:        mockTrie.ToProto(),
 		CurrentEth1Data: &ethpb.LatestETH1Data{
@@ -104,11 +104,11 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		DepositContainers: []*ethpb.DepositContainer{},
 	})
 	require.NoError(t, err)
-	web3Service, err = execution.NewService(
+	web3Service, err = powchain.NewService(
 		ctx,
-		execution.WithDatabase(beaconDB),
-		execution.WithHttpEndpoints([]string{endpoint}),
-		execution.WithDepositContractAddress(common.Address{}),
+		powchain.WithDatabase(beaconDB),
+		powchain.WithHttpEndpoints([]string{endpoint}),
+		powchain.WithDepositContractAddress(common.Address{}),
 	)
 	require.NoError(t, err, "Unable to set up web3 service")
 
@@ -313,9 +313,7 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
 	require.NoError(t, c.StartFromSavedState(headState))
 	headBlk, err := c.HeadBlock(ctx)
 	require.NoError(t, err)
-	pb, err := headBlk.Proto()
-	require.NoError(t, err)
-	assert.DeepEqual(t, headBlock, pb, "Head block incorrect")
+	assert.DeepEqual(t, headBlock, headBlk.Proto(), "Head block incorrect")
 	s, err := c.HeadState(ctx)
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
@@ -368,9 +366,7 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
 	require.NoError(t, err)
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
 	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
-	pb, err := c.head.block.Proto()
-	require.NoError(t, err)
-	assert.DeepEqual(t, headBlock, pb)
+	assert.DeepEqual(t, headBlock, c.head.block.Proto())
 }
 
 func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
@@ -431,9 +427,7 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
 	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
 	// Since head sync is not triggered, chain is initialized to the last finalization checkpoint.
-	pb, err := c.head.block.Proto()
-	require.NoError(t, err)
-	assert.DeepEqual(t, finalizedBlock, pb)
+	assert.DeepEqual(t, finalizedBlock, c.head.block.Proto())
 	assert.LogsContain(t, hook, "resetting head from the checkpoint ('--head-sync' flag is ignored)")
 	assert.LogsDoNotContain(t, hook, "Regenerating state from the last checkpoint at slot")
 
@@ -454,9 +448,7 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
 	assert.DeepSSZEqual(t, headState.InnerStateUnsafe(), s.InnerStateUnsafe(), "Head state incorrect")
 	assert.Equal(t, genesisRoot, c.originBlockRoot, "Genesis block root incorrect")
 	// Head slot is far beyond the latest finalized checkpoint, head sync is triggered.
-	pb, err = c.head.block.Proto()
-	require.NoError(t, err)
-	assert.DeepEqual(t, headBlock, pb)
+	assert.DeepEqual(t, headBlock, c.head.block.Proto())
 	assert.LogsContain(t, hook, "Regenerating state from the last checkpoint at slot 225")
 	assert.LogsDoNotContain(t, hook, "resetting head from the checkpoint ('--head-sync' flag is ignored)")
 }
@@ -474,7 +466,7 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
 	newState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.StateGen.SaveState(ctx, r, newState))
-	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
 	require.NoError(t, s.saveHeadNoDB(ctx, wsb, r, newState))
 
@@ -496,7 +488,7 @@ func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) {
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
 
@@ -515,7 +507,7 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
 
@@ -535,7 +527,7 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 	bb := util.NewBeaconBlock()
 	r, err := bb.Block.HashTreeRoot()
 	require.NoError(t, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(bb)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
 	require.NoError(t, err)
 	require.NoError(t, s.saveInitSyncBlock(ctx, r, wsb))
 	require.NoError(t, s.Stop())
@@ -548,7 +540,7 @@ func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
 	stateChannel := make(chan *feed.Event, 1)
 	stateSub := service.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
 	defer stateSub.Unsubscribe()
-	service.onExecutionChainStart(context.Background(), time.Now())
+	service.onPowchainStart(context.Background(), time.Now())
 
 	stateEvent := <-stateChannel
 	require.Equal(t, int(stateEvent.Type), statefeed.Initialized)
@@ -563,7 +555,7 @@ func BenchmarkHasBlockDB(b *testing.B) {
 		cfg: &config{BeaconDB: beaconDB},
 	}
 	blk := util.NewBeaconBlock()
-	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(b, err)
 	require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	r, err := blk.Block.HashTreeRoot()
@@ -587,7 +579,7 @@ func BenchmarkHasBlockForkChoiceStore_ProtoArray(b *testing.B) {
 	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	beaconState, err := v1.InitializeFromProto(bs)
 	require.NoError(b, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(b, err)
 	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
 
@@ -608,7 +600,7 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	beaconState, err := v1.InitializeFromProto(bs)
 	require.NoError(b, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(b, err)
 	require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
 

beacon-chain/blockchain/testing/mock.go

@@ -63,7 +63,6 @@ type ChainService struct {
 	ForkChoiceStore             forkchoice.ForkChoicer
 	ReceiveBlockMockErr         error
 	OptimisticCheckRootReceived [32]byte
-	FinalizedRoots              map[[32]byte]bool
 }
 
 // ForkChoicer mocks the same method in the chain service
@@ -131,16 +130,13 @@ func (msn *MockStateNotifier) StateFeed() *event.Feed {
 			sub := msn.feed.Subscribe(msn.recvCh)
 
 			go func() {
-				for {
-					select {
-					case evt := <-msn.recvCh:
-						msn.recvLock.Lock()
-						msn.recv = append(msn.recv, evt)
-						msn.recvLock.Unlock()
-					case <-sub.Err():
-						sub.Unsubscribe()
-						return
-					}
+				select {
+				case evt := <-msn.recvCh:
+					msn.recvLock.Lock()
+					msn.recv = append(msn.recv, evt)
+					msn.recvLock.Unlock()
+				case <-sub.Err():
+					sub.Unsubscribe()
 				}
 			}()
 		}
@@ -462,8 +458,3 @@ func (s *ChainService) UpdateHead(_ context.Context) error { return nil }
 
 // ReceiveAttesterSlashing mocks the same method in the chain service.
 func (s *ChainService) ReceiveAttesterSlashing(context.Context, *ethpb.AttesterSlashing) {}
-
-// IsFinalized mocks the same method in the chain service.
-func (s *ChainService) IsFinalized(_ context.Context, blockRoot [32]byte) bool {
-	return s.FinalizedRoots[blockRoot]
-}

beacon-chain/builder/BUILD.bazel

@@ -3,6 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     srcs = [
+        "error.go",
         "metric.go",
         "option.go",
         "service.go",

beacon-chain/builder/error.go

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

beacon-chain/builder/service.go

@@ -2,7 +2,6 @@ package builder
 
 import (
 	"context"
-	"fmt"
 	"time"
 
 	"github.com/pkg/errors"
@@ -22,6 +21,7 @@ import (
 type BlockBuilder interface {
 	SubmitBlindedBlock(ctx context.Context, block *ethpb.SignedBlindedBeaconBlockBellatrix) (*v1.ExecutionPayload, error)
 	GetHeader(ctx context.Context, slot types.Slot, parentHash [32]byte, pubKey [48]byte) (*ethpb.SignedBuilderBid, error)
+	Status() error
 	RegisterValidator(ctx context.Context, reg []*ethpb.SignedValidatorRegistrationV1) error
 	Configured() bool
 }
@@ -60,13 +60,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 			return nil, err
 		}
 		s.c = c
-
-		// Is the builder up?
-		if err := s.c.Status(ctx); err != nil {
-			return nil, fmt.Errorf("could not connect to builder: %v", err)
-		}
-
-		log.WithField("endpoint", c.NodeURL()).Info("Builder has been configured")
+		log.WithField("endpoint", c.NodeURL()).Info("Builder has configured")
 	}
 	return s, nil
 }

beacon-chain/builder/testing/mock.go

@@ -15,6 +15,7 @@ type MockBuilderService struct {
 	ErrSubmitBlindedBlock error
 	Bid                   *ethpb.SignedBuilderBid
 	ErrGetHeader          error
+	ErrStatus             error
 	ErrRegisterValidator  error
 }
 
@@ -33,6 +34,11 @@ func (s *MockBuilderService) GetHeader(context.Context, types.Slot, [32]byte, [4
 	return s.Bid, s.ErrGetHeader
 }
 
+// Status for mocking.
+func (s *MockBuilderService) Status() error {
+	return s.ErrStatus
+}
+
 // RegisterValidator for mocking.
 func (s *MockBuilderService) RegisterValidator(context.Context, []*ethpb.SignedValidatorRegistrationV1) error {
 	return s.ErrRegisterValidator

beacon-chain/cache/depositcache/deposits_cache.go

@@ -77,7 +77,7 @@ func New() (*DepositCache, error) {
 // InsertDeposit into the database. If deposit or block number are nil
 // then this method does nothing.
 func (dc *DepositCache) InsertDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertDeposit")
+	_, span := trace.StartSpan(ctx, "DepositsCache.InsertDeposit")
 	defer span.End()
 	if d == nil {
 		log.WithFields(logrus.Fields{
@@ -111,7 +111,7 @@ func (dc *DepositCache) InsertDeposit(ctx context.Context, d *ethpb.Deposit, blo
 
 // InsertDepositContainers inserts a set of deposit containers into our deposit cache.
 func (dc *DepositCache) InsertDepositContainers(ctx context.Context, ctrs []*ethpb.DepositContainer) {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertDepositContainers")
+	_, span := trace.StartSpan(ctx, "DepositsCache.InsertDepositContainers")
 	defer span.End()
 	dc.depositsLock.Lock()
 	defer dc.depositsLock.Unlock()
@@ -130,7 +130,7 @@ func (dc *DepositCache) InsertDepositContainers(ctx context.Context, ctrs []*eth
 
 // InsertFinalizedDeposits inserts deposits up to eth1DepositIndex (inclusive) into the finalized deposits cache.
 func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1DepositIndex int64) {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertFinalizedDeposits")
+	_, span := trace.StartSpan(ctx, "DepositsCache.InsertFinalizedDeposits")
 	defer span.End()
 	dc.depositsLock.Lock()
 	defer dc.depositsLock.Unlock()
@@ -180,7 +180,7 @@ func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1Deposit
 
 // AllDepositContainers returns all historical deposit containers.
 func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*ethpb.DepositContainer {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.AllDepositContainers")
+	_, span := trace.StartSpan(ctx, "DepositsCache.AllDepositContainers")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -191,7 +191,7 @@ func (dc *DepositCache) AllDepositContainers(ctx context.Context) []*ethpb.Depos
 // AllDeposits returns a list of historical deposits until the given block number
 // (inclusive). If no block is specified then this method returns all historical deposits.
 func (dc *DepositCache) AllDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.AllDeposits")
+	_, span := trace.StartSpan(ctx, "DepositsCache.AllDeposits")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -212,7 +212,7 @@ func (dc *DepositCache) allDeposits(untilBlk *big.Int) []*ethpb.Deposit {
 // DepositsNumberAndRootAtHeight returns number of deposits made up to blockheight and the
 // root that corresponds to the latest deposit at that blockheight.
 func (dc *DepositCache) DepositsNumberAndRootAtHeight(ctx context.Context, blockHeight *big.Int) (uint64, [32]byte) {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.DepositsNumberAndRootAtHeight")
+	_, span := trace.StartSpan(ctx, "DepositsCache.DepositsNumberAndRootAtHeight")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -228,7 +228,7 @@ func (dc *DepositCache) DepositsNumberAndRootAtHeight(ctx context.Context, block
 // DepositByPubkey looks through historical deposits and finds one which contains
 // a certain public key within its deposit data.
 func (dc *DepositCache) DepositByPubkey(ctx context.Context, pubKey []byte) (*ethpb.Deposit, *big.Int) {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.DepositByPubkey")
+	_, span := trace.StartSpan(ctx, "DepositsCache.DepositByPubkey")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -249,7 +249,7 @@ func (dc *DepositCache) DepositByPubkey(ctx context.Context, pubKey []byte) (*et
 
 // FinalizedDeposits returns the finalized deposits trie.
 func (dc *DepositCache) FinalizedDeposits(ctx context.Context) *FinalizedDeposits {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.FinalizedDeposits")
+	_, span := trace.StartSpan(ctx, "DepositsCache.FinalizedDeposits")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()

beacon-chain/cache/depositcache/pending_deposits.go

@@ -29,7 +29,7 @@ type PendingDepositsFetcher interface {
 // InsertPendingDeposit into the database. If deposit or block number are nil
 // then this method does nothing.
 func (dc *DepositCache) InsertPendingDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.InsertPendingDeposit")
+	_, span := trace.StartSpan(ctx, "DepositsCache.InsertPendingDeposit")
 	defer span.End()
 	if d == nil {
 		log.WithFields(logrus.Fields{
@@ -66,7 +66,7 @@ func (dc *DepositCache) PendingDeposits(ctx context.Context, untilBlk *big.Int)
 // PendingContainers returns a list of deposit containers until the given block number
 // (inclusive).
 func (dc *DepositCache) PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.PendingDeposits")
+	_, span := trace.StartSpan(ctx, "DepositsCache.PendingDeposits")
 	defer span.End()
 	dc.depositsLock.RLock()
 	defer dc.depositsLock.RUnlock()
@@ -90,7 +90,7 @@ func (dc *DepositCache) PendingContainers(ctx context.Context, untilBlk *big.Int
 // RemovePendingDeposit from the database. The deposit is indexed by the
 // Index. This method does nothing if deposit ptr is nil.
 func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Deposit) {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.RemovePendingDeposit")
+	_, span := trace.StartSpan(ctx, "DepositsCache.RemovePendingDeposit")
 	defer span.End()
 
 	if d == nil {
@@ -100,7 +100,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 
 	depRoot, err := hash.HashProto(d)
 	if err != nil {
-		log.WithError(err).Error("Could not remove deposit")
+		log.Errorf("Could not remove deposit %v", err)
 		return
 	}
 
@@ -111,7 +111,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 	for i, ctnr := range dc.pendingDeposits {
 		h, err := hash.HashProto(ctnr.Deposit)
 		if err != nil {
-			log.WithError(err).Error("Could not hash deposit")
+			log.Errorf("Could not hash deposit %v", err)
 			continue
 		}
 		if h == depRoot {
@@ -128,7 +128,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 
 // PrunePendingDeposits removes any deposit which is older than the given deposit merkle tree index.
 func (dc *DepositCache) PrunePendingDeposits(ctx context.Context, merkleTreeIndex int64) {
-	ctx, span := trace.StartSpan(ctx, "DepositsCache.PrunePendingDeposits")
+	_, span := trace.StartSpan(ctx, "DepositsCache.PrunePendingDeposits")
 	defer span.End()
 
 	if merkleTreeIndex == 0 {

beacon-chain/core/altair/BUILD.bazel

@@ -33,9 +33,9 @@ go_library(
         "//beacon-chain/state/v2:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -76,8 +76,8 @@ go_test(
         "//beacon-chain/state/v3:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/core/altair/attestation.go

@@ -11,9 +11,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
 	"go.opencensus.io/trace"
@@ -26,7 +26,7 @@ func ProcessAttestationsNoVerifySignature(
 	beaconState state.BeaconState,
 	b interfaces.SignedBeaconBlock,
 ) (state.BeaconState, error) {
-	if err := consensusblocks.BeaconBlockIsNil(b); err != nil {
+	if err := wrapper.BeaconBlockIsNil(b); err != nil {
 		return nil, err
 	}
 	body := b.Block().Body()

beacon-chain/core/altair/attestation_test.go

@@ -15,8 +15,8 @@ import (
 	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/math"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -27,7 +27,7 @@ import (
 
 func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 	attestations := []*ethpb.Attestation{
-		util.HydrateAttestation(&ethpb.Attestation{
+		util.NewAttestationUtil().HydrateAttestation(&ethpb.Attestation{
 			Data: &ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, fieldparams.RootLength)},
 				Slot:   5,
@@ -48,14 +48,14 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 		params.BeaconConfig().MinAttestationInclusionDelay,
 		beaconState.Slot(),
 	)
-	wsb, err := blocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, want, err)
 }
 
 func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
-	att := util.HydrateAttestation(&ethpb.Attestation{
+	att := util.NewAttestationUtil().HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
 			Target: &ethpb.Checkpoint{Epoch: 0}}})
@@ -79,7 +79,7 @@ func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
 		time.PrevEpoch(beaconState),
 		time.CurrentEpoch(beaconState),
 	)
-	wsb, err := blocks.NewSignedBeaconBlock(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 := blocks.NewSignedBeaconBlock(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 = blocks.NewSignedBeaconBlock(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 := blocks.NewSignedBeaconBlock(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 = blocks.NewSignedBeaconBlock(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 := blocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, expected, err)
@@ -201,7 +201,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 	aggBits.SetBitAt(0, true)
 	var mockRoot [32]byte
 	copy(mockRoot[:], "hello-world")
-	att := util.HydrateAttestation(&ethpb.Attestation{
+	att := util.NewAttestationUtil().HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Root: mockRoot[:]},
 			Target: &ethpb.Checkpoint{Root: mockRoot[:]},
@@ -232,7 +232,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 
 	err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
 	require.NoError(t, err)
-	wsb, err := blocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -421,10 +421,7 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 		}
 		s, err := stateAltair.InitializeFromProtoUnsafe(st)
 		require.NoError(t, err)
-		if b.Block == nil || b.Block.Body == nil {
-			continue
-		}
-		wsb, err := blocks.NewSignedBeaconBlock(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/altair/block.go

@@ -2,8 +2,8 @@ package altair
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
 	p2pType "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
@@ -47,11 +47,11 @@ import (
 func ProcessSyncAggregate(ctx context.Context, s state.BeaconState, sync *ethpb.SyncAggregate) (state.BeaconState, error) {
 	votedKeys, votedIndices, didntVoteIndices, err := FilterSyncCommitteeVotes(s, sync)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not filter sync committee votes")
+		return nil, err
 	}
 
 	if err := VerifySyncCommitteeSig(s, votedKeys, sync.SyncCommitteeSignature); err != nil {
-		return nil, errors.Wrap(err, "could not verify sync committee signature")
+		return nil, err
 	}
 
 	return ApplySyncRewardsPenalties(ctx, s, votedIndices, didntVoteIndices)

beacon-chain/core/altair/block_test.go

@@ -309,13 +309,13 @@ func Test_SyncRewards(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			proposerReward, participantReward, err := altair.SyncRewards(tt.activeBalance)
+			proposerReward, participarntReward, err := altair.SyncRewards(tt.activeBalance)
 			if (err != nil) && (tt.errString != "") {
 				require.ErrorContains(t, tt.errString, err)
 				return
 			}
 			require.Equal(t, tt.wantProposerReward, proposerReward)
-			require.Equal(t, tt.wantParticipantReward, participantReward)
+			require.Equal(t, tt.wantParticipantReward, participarntReward)
 		})
 	}
 }

beacon-chain/core/altair/epoch_precompute.go

@@ -15,7 +15,7 @@ import (
 
 // InitializePrecomputeValidators precomputes individual validator for its attested balances and the total sum of validators attested balances of the epoch.
 func InitializePrecomputeValidators(ctx context.Context, beaconState state.BeaconState) ([]*precompute.Validator, *precompute.Balance, error) {
-	ctx, span := trace.StartSpan(ctx, "altair.InitializePrecomputeValidators")
+	_, span := trace.StartSpan(ctx, "altair.InitializePrecomputeValidators")
 	defer span.End()
 	vals := make([]*precompute.Validator, beaconState.NumValidators())
 	bal := &precompute.Balance{}
@@ -76,7 +76,7 @@ func ProcessInactivityScores(
 	beaconState state.BeaconState,
 	vals []*precompute.Validator,
 ) (state.BeaconState, []*precompute.Validator, error) {
-	ctx, span := trace.StartSpan(ctx, "altair.ProcessInactivityScores")
+	_, span := trace.StartSpan(ctx, "altair.ProcessInactivityScores")
 	defer span.End()
 
 	cfg := params.BeaconConfig()
@@ -144,7 +144,7 @@ func ProcessEpochParticipation(
 	bal *precompute.Balance,
 	vals []*precompute.Validator,
 ) ([]*precompute.Validator, *precompute.Balance, error) {
-	ctx, span := trace.StartSpan(ctx, "altair.ProcessEpochParticipation")
+	_, span := trace.StartSpan(ctx, "altair.ProcessEpochParticipation")
 	defer span.End()
 
 	cp, err := beaconState.CurrentEpochParticipation()

beacon-chain/core/altair/transition.go

@@ -68,11 +68,11 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconSta
 	}
 
 	// Modified in Altair and Bellatrix.
-	proportionalSlashingMultiplier, err := state.ProportionalSlashingMultiplier()
+	proportionalSlashingMultipler, err := state.ProportionalSlashingMultiplier()
 	if err != nil {
 		return nil, err
 	}
-	state, err = e.ProcessSlashings(state, proportionalSlashingMultiplier)
+	state, err = e.ProcessSlashings(state, proportionalSlashingMultipler)
 	if err != nil {
 		return nil, err
 	}

beacon-chain/core/blocks/BUILD.bazel

@@ -6,7 +6,6 @@ go_library(
         "attestation.go",
         "attester_slashing.go",
         "deposit.go",
-        "error.go",
         "eth1_data.go",
         "exit.go",
         "genesis.go",
@@ -16,7 +15,6 @@ go_library(
         "proposer_slashing.go",
         "randao.go",
         "signature.go",
-        "withdrawals.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks",
     visibility = [
@@ -33,15 +31,15 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
+        "//consensus-types/forks/bellatrix:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//container/slice:go_default_library",
         "//container/trie:go_default_library",
         "//contracts/deposit:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
-        "//crypto/hash/htr:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//network/forks:go_default_library",
@@ -77,7 +75,6 @@ go_test(
         "proposer_slashing_test.go",
         "randao_test.go",
         "signature_test.go",
-        "withdrawals_test.go",
     ],
     data = glob(["testdata/**"]),
     embed = [":go_default_library"],
@@ -92,11 +89,11 @@ go_test(
         "//beacon-chain/state/v1:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
+        "//consensus-types/forks/bellatrix:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
-        "//crypto/hash/htr:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",

beacon-chain/core/blocks/attestation.go

@@ -10,9 +10,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation"
@@ -26,7 +26,7 @@ func ProcessAttestationsNoVerifySignature(
 	beaconState state.BeaconState,
 	b interfaces.SignedBeaconBlock,
 ) (state.BeaconState, error) {
-	if err := blocks.BeaconBlockIsNil(b); err != nil {
+	if err := wrapper.BeaconBlockIsNil(b); err != nil {
 		return nil, err
 	}
 	body := b.Block().Body()

beacon-chain/core/blocks/attestation_test.go

@@ -25,7 +25,7 @@ import (
 
 func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	beaconState, privKeys := util.DeterministicGenesisState(t, 100)
-	data := util.HydrateAttestationData(&ethpb.AttestationData{
+	data := util.NewAttestationUtil().HydrateAttestationData(&ethpb.AttestationData{
 		Source: &ethpb.Checkpoint{Epoch: 0, Root: bytesutil.PadTo([]byte("hello-world"), 32)},
 		Target: &ethpb.Checkpoint{Epoch: 0, Root: bytesutil.PadTo([]byte("hello-world"), 32)},
 	})
@@ -85,7 +85,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 func TestVerifyAttestationNoVerifySignature_IncorrectSlotTargetEpoch(t *testing.T) {
 	beaconState, _ := util.DeterministicGenesisState(t, 1)
 
-	att := util.HydrateAttestation(&ethpb.Attestation{
+	att := util.NewAttestationUtil().HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Slot:   params.BeaconConfig().SlotsPerEpoch,
 			Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
@@ -218,7 +218,7 @@ func TestConvertToIndexed_OK(t *testing.T) {
 
 	var sig [fieldparams.BLSSignatureLength]byte
 	copy(sig[:], "signed")
-	att := util.HydrateAttestation(&ethpb.Attestation{
+	att := util.NewAttestationUtil().HydrateAttestation(&ethpb.Attestation{
 		Signature: sig[:],
 	})
 	for _, tt := range tests {
@@ -261,11 +261,12 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
+	au := util.AttestationUtil{}
 	tests := []struct {
 		attestation *ethpb.IndexedAttestation
 	}{
 		{attestation: &ethpb.IndexedAttestation{
-			Data: util.HydrateAttestationData(&ethpb.AttestationData{
+			Data: au.HydrateAttestationData(&ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
 					Epoch: 2,
 				},
@@ -275,7 +276,7 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 			Signature:        make([]byte, fieldparams.BLSSignatureLength),
 		}},
 		{attestation: &ethpb.IndexedAttestation{
-			Data: util.HydrateAttestationData(&ethpb.AttestationData{
+			Data: au.HydrateAttestationData(&ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
 					Epoch: 1,
 				},
@@ -284,7 +285,7 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 			Signature:        make([]byte, fieldparams.BLSSignatureLength),
 		}},
 		{attestation: &ethpb.IndexedAttestation{
-			Data: util.HydrateAttestationData(&ethpb.AttestationData{
+			Data: au.HydrateAttestationData(&ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
 					Epoch: 4,
 				},
@@ -293,7 +294,7 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 			Signature:        make([]byte, fieldparams.BLSSignatureLength),
 		}},
 		{attestation: &ethpb.IndexedAttestation{
-			Data: util.HydrateAttestationData(&ethpb.AttestationData{
+			Data: au.HydrateAttestationData(&ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
 					Epoch: 7,
 				},
@@ -411,7 +412,8 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 
 	comm1, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1 /*slot*/, 0 /*committeeIndex*/)
 	require.NoError(t, err)
-	att1 := util.HydrateAttestation(&ethpb.Attestation{
+	au := util.AttestationUtil{}
+	att1 := au.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
 		Data: &ethpb.AttestationData{
 			Slot: 1,
@@ -430,7 +432,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 
 	comm2, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1*params.BeaconConfig().SlotsPerEpoch+1 /*slot*/, 1 /*committeeIndex*/)
 	require.NoError(t, err)
-	att2 := util.HydrateAttestation(&ethpb.Attestation{
+	att2 := au.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
 		Data: &ethpb.AttestationData{
 			Slot:           1*params.BeaconConfig().SlotsPerEpoch + 1,
@@ -470,7 +472,8 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 
 	comm1, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1 /*slot*/, 0 /*committeeIndex*/)
 	require.NoError(t, err)
-	att1 := util.HydrateAttestation(&ethpb.Attestation{
+	au := util.AttestationUtil{}
+	att1 := au.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
 		Data: &ethpb.AttestationData{
 			Slot: 1,
@@ -489,7 +492,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 
 	comm2, err := helpers.BeaconCommitteeFromState(context.Background(), st, 1 /*slot*/, 1 /*committeeIndex*/)
 	require.NoError(t, err)
-	att2 := util.HydrateAttestation(&ethpb.Attestation{
+	att2 := au.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
 		Data: &ethpb.AttestationData{
 			Slot:           1,
@@ -534,7 +537,8 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 
 	comm1, err := helpers.BeaconCommitteeFromState(ctx, st, 1 /*slot*/, 0 /*committeeIndex*/)
 	require.NoError(t, err)
-	att1 := util.HydrateAttestation(&ethpb.Attestation{
+	au := util.AttestationUtil{}
+	att1 := au.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
 		Data: &ethpb.AttestationData{
 			Slot: 1,
@@ -553,7 +557,7 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 
 	comm2, err := helpers.BeaconCommitteeFromState(ctx, st, 1 /*slot*/, 1 /*committeeIndex*/)
 	require.NoError(t, err)
-	att2 := util.HydrateAttestation(&ethpb.Attestation{
+	att2 := au.HydrateAttestation(&ethpb.Attestation{
 		AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
 		Data: &ethpb.AttestationData{
 			Slot:           1,

beacon-chain/core/blocks/attester_slashing_test.go

@@ -19,11 +19,12 @@ import (
 )
 
 func TestSlashableAttestationData_CanSlash(t *testing.T) {
-	att1 := util.HydrateAttestationData(&ethpb.AttestationData{
+	au := util.AttestationUtil{}
+	att1 := au.HydrateAttestationData(&ethpb.AttestationData{
 		Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
 		Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)},
 	})
-	att2 := util.HydrateAttestationData(&ethpb.AttestationData{
+	att2 := au.HydrateAttestationData(&ethpb.AttestationData{
 		Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
 		Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'B'}, 32)},
 	})
@@ -35,9 +36,10 @@ func TestSlashableAttestationData_CanSlash(t *testing.T) {
 }
 
 func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
+	au := util.AttestationUtil{}
 	slashings := []*ethpb.AttesterSlashing{{
-		Attestation_1: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{}),
-		Attestation_2: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+		Attestation_1: au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{}),
+		Attestation_2: au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 			Data: &ethpb.AttestationData{
 				Source: &ethpb.Checkpoint{Epoch: 1},
 				Target: &ethpb.Checkpoint{Epoch: 1}},
@@ -71,15 +73,16 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
 	})
 	require.NoError(t, err)
 
+	au := util.AttestationUtil{}
 	slashings := []*ethpb.AttesterSlashing{
 		{
-			Attestation_1: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+			Attestation_1: au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 				Data: &ethpb.AttestationData{
 					Source: &ethpb.Checkpoint{Epoch: 1},
 				},
 				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
 			}),
-			Attestation_2: util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+			Attestation_2: au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 				AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
 			}),
 		},
@@ -102,7 +105,8 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 		vv.WithdrawableEpoch = types.Epoch(params.BeaconConfig().SlotsPerEpoch)
 	}
 
-	att1 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+	au := util.AttestationUtil{}
+	att1 := au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Epoch: 1},
 		},
@@ -117,7 +121,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 	aggregateSig := bls.AggregateSignatures([]bls.Signature{sig0, sig1})
 	att1.Signature = aggregateSig.Marshal()
 
-	att2 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+	att2 := au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		AttestingIndices: []uint64{0, 1},
 	})
 	signingRoot, err = signing.ComputeSigningRoot(att2.Data, domain)
@@ -171,7 +175,8 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 		vv.WithdrawableEpoch = types.Epoch(params.BeaconConfig().SlotsPerEpoch)
 	}
 
-	att1 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+	au := util.AttestationUtil{}
+	att1 := au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Epoch: 1},
 		},
@@ -186,7 +191,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 	aggregateSig := bls.AggregateSignatures([]bls.Signature{sig0, sig1})
 	att1.Signature = aggregateSig.Marshal()
 
-	att2 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+	att2 := au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		AttestingIndices: []uint64{0, 1},
 	})
 	signingRoot, err = signing.ComputeSigningRoot(att2.Data, domain)
@@ -240,7 +245,8 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 		vv.WithdrawableEpoch = types.Epoch(params.BeaconConfig().SlotsPerEpoch)
 	}
 
-	att1 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+	au := util.AttestationUtil{}
+	att1 := au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Epoch: 1},
 		},
@@ -255,7 +261,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 	aggregateSig := bls.AggregateSignatures([]bls.Signature{sig0, sig1})
 	att1.Signature = aggregateSig.Marshal()
 
-	att2 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+	att2 := au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		AttestingIndices: []uint64{0, 1},
 	})
 	signingRoot, err = signing.ComputeSigningRoot(att2.Data, domain)

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -9,8 +9,8 @@ import (
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
@@ -42,10 +42,7 @@ func TestFuzzProcessBlockHeader_10000(t *testing.T) {
 
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		if block.Block == nil || block.Block.Body == nil {
-			continue
-		}
-		wsb, err := blocks.NewSignedBeaconBlock(block)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 		require.NoError(t, err)
 		_, err = ProcessBlockHeader(context.Background(), s, wsb)
 		_ = err
@@ -146,10 +143,7 @@ func TestFuzzProcessRandao_10000(t *testing.T) {
 		fuzzer.Fuzz(b)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		if b.Block == nil || b.Block.Body == nil {
-			continue
-		}
-		wsb, err := blocks.NewSignedBeaconBlock(b)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 		require.NoError(t, err)
 		r, err := ProcessRandao(context.Background(), s, wsb)
 		if err != nil && r != nil {
@@ -270,10 +264,7 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 		fuzzer.Fuzz(b)
 		s, err := v1.InitializeFromProtoUnsafe(state)
 		require.NoError(t, err)
-		if b.Block == nil || b.Block.Body == nil {
-			continue
-		}
-		wsb, err := blocks.NewSignedBeaconBlock(b)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 		require.NoError(t, err)
 		r, err := ProcessAttestationsNoVerifySignature(ctx, s, wsb)
 		if err != nil && r != nil {

beacon-chain/core/blocks/block_regression_test.go

@@ -39,8 +39,9 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 	expectedSlashedVal := 2800
 
 	root1 := [32]byte{'d', 'o', 'u', 'b', 'l', 'e', '1'}
+	au := util.AttestationUtil{}
 	att1 := &ethpb.IndexedAttestation{
-		Data:             util.HydrateAttestationData(&ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: 0, Root: root1[:]}}),
+		Data:             au.HydrateAttestationData(&ethpb.AttestationData{Target: &ethpb.Checkpoint{Epoch: 0, Root: root1[:]}}),
 		AttestingIndices: setA,
 		Signature:        make([]byte, 96),
 	}
@@ -58,7 +59,7 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 
 	root2 := [32]byte{'d', 'o', 'u', 'b', 'l', 'e', '2'}
 	att2 := &ethpb.IndexedAttestation{
-		Data: util.HydrateAttestationData(&ethpb.AttestationData{
+		Data: au.HydrateAttestationData(&ethpb.AttestationData{
 			Target: &ethpb.Checkpoint{Root: root2[:]},
 		}),
 		AttestingIndices: setB,

beacon-chain/core/blocks/deposit.go

@@ -176,7 +176,7 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 			}
 			if err := verifyDepositDataSigningRoot(deposit.Data, domain); err != nil {
 				// Ignore this error as in the spec pseudo code.
-				log.WithError(err).Debug("Skipping deposit: could not verify deposit data signature")
+				log.Debugf("Skipping deposit: could not verify deposit data signature: %v", err)
 				return beaconState, newValidator, nil
 			}
 		}

beacon-chain/core/blocks/error.go

@@ -1,8 +0,0 @@
-package blocks
-
-import "github.com/pkg/errors"
-
-var errNilSignedWithdrawalMessage = errors.New("nil SignedBLSToExecutionChange message")
-var errNilWithdrawalMessage = errors.New("nil BLSToExecutionChange message")
-var errInvalidBLSPrefix = errors.New("withdrawal credential prefix is not a BLS prefix")
-var errInvalidWithdrawalCredentials = errors.New("withdrawal credentials do not match")

beacon-chain/core/blocks/header.go

@@ -8,9 +8,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
 
@@ -44,7 +44,7 @@ func ProcessBlockHeader(
 	beaconState state.BeaconState,
 	block interfaces.SignedBeaconBlock,
 ) (state.BeaconState, error) {
-	if err := blocks.BeaconBlockIsNil(block); err != nil {
+	if err := wrapper.BeaconBlockIsNil(block); err != nil {
 		return nil, err
 	}
 	bodyRoot, err := block.Block().Body().HashTreeRoot()

beacon-chain/core/blocks/header_test.go

@@ -11,7 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	p2ptypes "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
 	"github.com/prysmaticlabs/prysm/config/params"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -68,7 +68,7 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
 
-	wsb, err := consensusblocks.NewSignedBeaconBlock(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)
@@ -96,7 +96,7 @@ func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
 	block.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx+1])
 	require.NoError(t, err)
 
-	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, err = blocks.ProcessBlockHeader(context.Background(), beaconState, wsb)
 	want := "signature did not verify"
@@ -140,7 +140,7 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 		Signature: blockSig,
 	})
 
-	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	want := "is different than block slot"
@@ -181,7 +181,7 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 	block.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, 32)
 	block.Signature = blockSig
 
-	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	want := "does not match"
@@ -225,7 +225,7 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 	block.Block.ParentRoot = parentRoot[:]
 	block.Signature = blockSig
 
-	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
 	want := "was previously slashed"
@@ -276,7 +276,7 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
 
-	wsb, err := consensusblocks.NewSignedBeaconBlock(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")

beacon-chain/core/blocks/payload.go

@@ -7,8 +7,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	"github.com/prysmaticlabs/prysm/runtime/version"
@@ -38,15 +39,20 @@ func IsMergeTransitionComplete(st state.BeaconState) (bool, error) {
 	if err != nil {
 		return false, err
 	}
-	wrappedHeader, err := blocks.WrappedExecutionPayloadHeader(h)
-	if err != nil {
-		return false, err
+	return !bellatrix.IsEmptyHeader(h), nil
+}
+
+// IsMergeTransitionBlockUsingPreStatePayloadHeader returns true if the input block is the terminal merge block.
+// Terminal merge block must be associated with an empty payload header.
+// This assumes the header `h` is referenced as the parent state for block body `body.
+func IsMergeTransitionBlockUsingPreStatePayloadHeader(h *enginev1.ExecutionPayloadHeader, body interfaces.BeaconBlockBody) (bool, error) {
+	if h == nil || body == nil {
+		return false, errors.New("nil header or block body")
 	}
-	isEmpty, err := blocks.IsEmptyExecutionData(wrappedHeader)
-	if err != nil {
-		return false, err
+	if !bellatrix.IsEmptyHeader(h) {
+		return false, nil
 	}
-	return !isEmpty, nil
+	return IsExecutionBlock(body)
 }
 
 // IsExecutionBlock returns whether the block has a non-empty ExecutionPayload.
@@ -58,19 +64,15 @@ func IsExecutionBlock(body interfaces.BeaconBlockBody) (bool, error) {
 	if body == nil {
 		return false, errors.New("nil block body")
 	}
-	payload, err := body.Execution()
+	payload, err := body.ExecutionPayload()
 	switch {
-	case errors.Is(err, blocks.ErrUnsupportedGetter):
+	case errors.Is(err, wrapper.ErrUnsupportedField):
 		return false, nil
 	case err != nil:
 		return false, err
 	default:
 	}
-	isEmpty, err := blocks.IsEmptyExecutionData(payload)
-	if err != nil {
-		return false, err
-	}
-	return !isEmpty, nil
+	return !bellatrix.IsEmptyPayload(payload), nil
 }
 
 // IsExecutionEnabled returns true if the beacon chain can begin executing.
@@ -96,15 +98,7 @@ func IsExecutionEnabled(st state.BeaconState, body interfaces.BeaconBlockBody) (
 // 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 *enginev1.ExecutionPayloadHeader, body interfaces.BeaconBlockBody) (bool, error) {
-	wrappedHeader, err := blocks.WrappedExecutionPayloadHeader(header)
-	if err != nil {
-		return false, err
-	}
-	isEmpty, err := blocks.IsEmptyExecutionData(wrappedHeader)
-	if err != nil {
-		return false, err
-	}
-	if !isEmpty {
+	if !bellatrix.IsEmptyHeader(header) {
 		return true, nil
 	}
 	return IsExecutionBlock(body)
@@ -122,7 +116,7 @@ func IsPreBellatrixVersion(v int) bool {
 //    # Verify consistency of the parent hash with respect to the previous execution payload header
 //    if is_merge_complete(state):
 //        assert payload.parent_hash == state.latest_execution_payload_header.block_hash
-func ValidatePayloadWhenMergeCompletes(st state.BeaconState, payload interfaces.ExecutionData) error {
+func ValidatePayloadWhenMergeCompletes(st state.BeaconState, payload *enginev1.ExecutionPayload) error {
 	complete, err := IsMergeTransitionComplete(st)
 	if err != nil {
 		return err
@@ -135,7 +129,7 @@ func ValidatePayloadWhenMergeCompletes(st state.BeaconState, payload interfaces.
 	if err != nil {
 		return err
 	}
-	if !bytes.Equal(payload.ParentHash(), header.BlockHash) {
+	if !bytes.Equal(payload.ParentHash, header.BlockHash) {
 		return errors.New("incorrect block hash")
 	}
 	return nil
@@ -149,20 +143,20 @@ func ValidatePayloadWhenMergeCompletes(st state.BeaconState, payload interfaces.
 //    assert payload.random == get_randao_mix(state, get_current_epoch(state))
 //    # Verify timestamp
 //    assert payload.timestamp == compute_timestamp_at_slot(state, state.slot)
-func ValidatePayload(st state.BeaconState, payload interfaces.ExecutionData) error {
+func ValidatePayload(st state.BeaconState, payload *enginev1.ExecutionPayload) error {
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	if err != nil {
 		return err
 	}
 
-	if !bytes.Equal(payload.PrevRandao(), random) {
+	if !bytes.Equal(payload.PrevRandao, random) {
 		return ErrInvalidPayloadPrevRandao
 	}
 	t, err := slots.ToTime(st.GenesisTime(), st.Slot())
 	if err != nil {
 		return err
 	}
-	if payload.Timestamp() != uint64(t.Unix()) {
+	if payload.Timestamp != uint64(t.Unix()) {
 		return ErrInvalidPayloadTimeStamp
 	}
 	return nil
@@ -200,29 +194,27 @@ func ValidatePayload(st state.BeaconState, payload interfaces.ExecutionData) err
 //        block_hash=payload.block_hash,
 //        transactions_root=hash_tree_root(payload.transactions),
 //    )
-func ProcessPayload(st state.BeaconState, payload interfaces.ExecutionData) (state.BeaconState, error) {
+func ProcessPayload(st state.BeaconState, payload *enginev1.ExecutionPayload) (state.BeaconState, error) {
 	if err := ValidatePayloadWhenMergeCompletes(st, payload); err != nil {
 		return nil, err
 	}
+
 	if err := ValidatePayload(st, payload); err != nil {
 		return nil, err
 	}
-	header, err := blocks.PayloadToHeader(payload)
+
+	header, err := bellatrix.PayloadToHeader(payload)
 	if err != nil {
 		return nil, err
 	}
-	wrappedHeader, err := blocks.WrappedExecutionPayloadHeader(header)
-	if err != nil {
-		return nil, err
-	}
-	if err := st.SetLatestExecutionPayloadHeader(wrappedHeader); err != nil {
+	if err := st.SetLatestExecutionPayloadHeader(header); err != nil {
 		return nil, err
 	}
 	return st, nil
 }
 
 // ValidatePayloadHeaderWhenMergeCompletes validates the payload header when the merge completes.
-func ValidatePayloadHeaderWhenMergeCompletes(st state.BeaconState, header interfaces.ExecutionData) error {
+func ValidatePayloadHeaderWhenMergeCompletes(st state.BeaconState, header *enginev1.ExecutionPayloadHeader) error {
 	// Skip validation if the state is not merge compatible.
 	complete, err := IsMergeTransitionComplete(st)
 	if err != nil {
@@ -236,20 +228,20 @@ func ValidatePayloadHeaderWhenMergeCompletes(st state.BeaconState, header interf
 	if err != nil {
 		return err
 	}
-	if !bytes.Equal(header.ParentHash(), h.BlockHash) {
+	if !bytes.Equal(header.ParentHash, h.BlockHash) {
 		return ErrInvalidPayloadBlockHash
 	}
 	return nil
 }
 
 // ValidatePayloadHeader validates the payload header.
-func ValidatePayloadHeader(st state.BeaconState, header interfaces.ExecutionData) error {
+func ValidatePayloadHeader(st state.BeaconState, header *enginev1.ExecutionPayloadHeader) error {
 	// Validate header's random mix matches with state in current epoch
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	if err != nil {
 		return err
 	}
-	if !bytes.Equal(header.PrevRandao(), random) {
+	if !bytes.Equal(header.PrevRandao, random) {
 		return ErrInvalidPayloadPrevRandao
 	}
 
@@ -258,20 +250,22 @@ func ValidatePayloadHeader(st state.BeaconState, header interfaces.ExecutionData
 	if err != nil {
 		return err
 	}
-	if header.Timestamp() != uint64(t.Unix()) {
+	if header.Timestamp != uint64(t.Unix()) {
 		return ErrInvalidPayloadTimeStamp
 	}
 	return nil
 }
 
 // ProcessPayloadHeader processes the payload header.
-func ProcessPayloadHeader(st state.BeaconState, header interfaces.ExecutionData) (state.BeaconState, error) {
+func ProcessPayloadHeader(st state.BeaconState, header *enginev1.ExecutionPayloadHeader) (state.BeaconState, error) {
 	if err := ValidatePayloadHeaderWhenMergeCompletes(st, header); err != nil {
 		return nil, err
 	}
+
 	if err := ValidatePayloadHeader(st, header); err != nil {
 		return nil, err
 	}
+
 	if err := st.SetLatestExecutionPayloadHeader(header); err != nil {
 		return nil, err
 	}
@@ -284,9 +278,9 @@ func GetBlockPayloadHash(blk interfaces.BeaconBlock) ([32]byte, error) {
 	if IsPreBellatrixVersion(blk.Version()) {
 		return payloadHash, nil
 	}
-	payload, err := blk.Body().Execution()
+	payload, err := blk.Body().ExecutionPayload()
 	if err != nil {
 		return payloadHash, err
 	}
-	return bytesutil.ToBytes32(payload.BlockHash()), nil
+	return bytesutil.ToBytes32(payload.BlockHash), nil
 }

beacon-chain/core/blocks/payload_test.go

@@ -9,7 +9,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
@@ -101,6 +102,15 @@ func Test_IsMergeComplete(t *testing.T) {
 			}(),
 			want: true,
 		},
+		{
+			name: "has tx root",
+			payload: func() *enginev1.ExecutionPayloadHeader {
+				h := emptyPayloadHeader()
+				h.TransactionsRoot = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				return h
+			}(),
+			want: true,
+		},
 		{
 			name: "has extra data",
 			payload: func() *enginev1.ExecutionPayloadHeader {
@@ -150,9 +160,7 @@ func Test_IsMergeComplete(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
-			wrappedHeader, err := consensusblocks.WrappedExecutionPayloadHeader(tt.payload)
-			require.NoError(t, err)
-			require.NoError(t, st.SetLatestExecutionPayloadHeader(wrappedHeader))
+			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.payload))
 			got, err := blocks.IsMergeTransitionComplete(st)
 			require.NoError(t, err)
 			if got != tt.want {
@@ -162,6 +170,185 @@ func Test_IsMergeComplete(t *testing.T) {
 	}
 }
 
+func Test_IsMergeTransitionBlockUsingPayloadHeader(t *testing.T) {
+	tests := []struct {
+		name    string
+		payload *enginev1.ExecutionPayload
+		header  *enginev1.ExecutionPayloadHeader
+		want    bool
+	}{
+		{
+			name:    "empty header, empty payload",
+			payload: emptyPayload(),
+			header:  emptyPayloadHeader(),
+			want:    false,
+		},
+		{
+			name:    "non-empty header, empty payload",
+			payload: emptyPayload(),
+			header: func() *enginev1.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) {
+			blk := util.NewBeaconBlockBellatrix()
+			blk.Block.Body.ExecutionPayload = tt.payload
+			body, err := wrapper.WrappedBeaconBlockBody(blk.Block.Body)
+			require.NoError(t, err)
+			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)
+			}
+		})
+	}
+}
+
 func Test_IsExecutionBlock(t *testing.T) {
 	tests := []struct {
 		name    string
@@ -187,7 +374,7 @@ func Test_IsExecutionBlock(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
-			wrappedBlock, err := consensusblocks.NewBeaconBlock(blk.Block)
+			wrappedBlock, err := wrapper.WrappedBeaconBlock(blk.Block)
 			require.NoError(t, err)
 			got, err := blocks.IsExecutionBlock(wrappedBlock.Body())
 			require.NoError(t, err)
@@ -255,12 +442,10 @@ func Test_IsExecutionEnabled(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
-			wrappedHeader, err := consensusblocks.WrappedExecutionPayloadHeader(tt.header)
-			require.NoError(t, err)
-			require.NoError(t, st.SetLatestExecutionPayloadHeader(wrappedHeader))
+			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.header))
 			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
-			body, err := consensusblocks.NewBeaconBlockBody(blk.Block.Body)
+			body, err := wrapper.WrappedBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
 			if tt.useAltairSt {
 				st, _ = util.DeterministicGenesisStateAltair(t, 1)
@@ -326,7 +511,7 @@ func Test_IsExecutionEnabledUsingHeader(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
-			body, err := consensusblocks.NewBeaconBlockBody(blk.Block.Body)
+			body, err := wrapper.WrappedBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
 			got, err := blocks.IsExecutionEnabledUsingHeader(tt.header, body)
 			require.NoError(t, err)
@@ -382,12 +567,8 @@ func Test_ValidatePayloadWhenMergeCompletes(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
-			wrappedHeader, err := consensusblocks.WrappedExecutionPayloadHeader(tt.header)
-			require.NoError(t, err)
-			require.NoError(t, st.SetLatestExecutionPayloadHeader(wrappedHeader))
-			wrappedPayload, err := consensusblocks.WrappedExecutionPayload(tt.payload)
-			require.NoError(t, err)
-			err = blocks.ValidatePayloadWhenMergeCompletes(st, wrappedPayload)
+			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.header))
+			err := blocks.ValidatePayloadWhenMergeCompletes(st, tt.payload)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
@@ -435,9 +616,7 @@ func Test_ValidatePayload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			wrappedPayload, err := consensusblocks.WrappedExecutionPayload(tt.payload)
-			require.NoError(t, err)
-			err = blocks.ValidatePayload(st, wrappedPayload)
+			err := blocks.ValidatePayload(st, tt.payload)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
@@ -485,14 +664,12 @@ func Test_ProcessPayload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			wrappedPayload, err := consensusblocks.WrappedExecutionPayload(tt.payload)
-			require.NoError(t, err)
-			st, err := blocks.ProcessPayload(st, wrappedPayload)
+			st, err := blocks.ProcessPayload(st, tt.payload)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
 				require.Equal(t, tt.err, err)
-				want, err := consensusblocks.PayloadToHeader(wrappedPayload)
+				want, err := bellatrix.PayloadToHeader(tt.payload)
 				require.Equal(t, tt.err, err)
 				got, err := st.LatestExecutionPayloadHeader()
 				require.NoError(t, err)
@@ -540,9 +717,7 @@ func Test_ProcessPayloadHeader(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			wrappedHeader, err := consensusblocks.WrappedExecutionPayloadHeader(tt.header)
-			require.NoError(t, err)
-			st, err := blocks.ProcessPayloadHeader(st, wrappedHeader)
+			st, err := blocks.ProcessPayloadHeader(st, tt.header)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
@@ -593,9 +768,7 @@ func Test_ValidatePayloadHeader(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			wrappedHeader, err := consensusblocks.WrappedExecutionPayloadHeader(tt.header)
-			require.NoError(t, err)
-			err = blocks.ValidatePayloadHeader(st, wrappedHeader)
+			err := blocks.ValidatePayloadHeader(st, tt.header)
 			require.Equal(t, tt.err, err)
 		})
 	}
@@ -604,9 +777,7 @@ func Test_ValidatePayloadHeader(t *testing.T) {
 func Test_ValidatePayloadHeaderWhenMergeCompletes(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 	emptySt := st.Copy()
-	wrappedHeader, err := consensusblocks.WrappedExecutionPayloadHeader(&enginev1.ExecutionPayloadHeader{BlockHash: []byte{'a'}})
-	require.NoError(t, err)
-	require.NoError(t, st.SetLatestExecutionPayloadHeader(wrappedHeader))
+	require.NoError(t, st.SetLatestExecutionPayloadHeader(&enginev1.ExecutionPayloadHeader{BlockHash: []byte{'a'}}))
 	tests := []struct {
 		name   string
 		state  state.BeaconState
@@ -645,9 +816,7 @@ func Test_ValidatePayloadHeaderWhenMergeCompletes(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			wrappedHeader, err := consensusblocks.WrappedExecutionPayloadHeader(tt.header)
-			require.NoError(t, err)
-			err = blocks.ValidatePayloadHeaderWhenMergeCompletes(tt.state, wrappedHeader)
+			err := blocks.ValidatePayloadHeaderWhenMergeCompletes(tt.state, tt.header)
 			require.Equal(t, tt.err, err)
 		})
 	}
@@ -655,9 +824,7 @@ func Test_ValidatePayloadHeaderWhenMergeCompletes(t *testing.T) {
 
 func Test_PayloadToHeader(t *testing.T) {
 	p := emptyPayload()
-	wrappedPayload, err := consensusblocks.WrappedExecutionPayload(p)
-	require.NoError(t, err)
-	h, err := consensusblocks.PayloadToHeader(wrappedPayload)
+	h, err := bellatrix.PayloadToHeader(p)
 	require.NoError(t, err)
 	txRoot, err := ssz.TransactionsRoot(p.Transactions)
 	require.NoError(t, err)
@@ -696,9 +863,7 @@ func Test_PayloadToHeader(t *testing.T) {
 
 func BenchmarkBellatrixComplete(b *testing.B) {
 	st, _ := util.DeterministicGenesisStateBellatrix(b, 1)
-	wrappedHeader, err := consensusblocks.WrappedExecutionPayloadHeader(emptyPayloadHeader())
-	require.NoError(b, err)
-	require.NoError(b, st.SetLatestExecutionPayloadHeader(wrappedHeader))
+	require.NoError(b, st.SetLatestExecutionPayloadHeader(emptyPayloadHeader()))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

beacon-chain/core/blocks/randao.go

@@ -6,8 +6,8 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/hash"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
@@ -31,7 +31,7 @@ func ProcessRandao(
 	beaconState state.BeaconState,
 	b interfaces.SignedBeaconBlock,
 ) (state.BeaconState, error) {
-	if err := blocks.BeaconBlockIsNil(b); err != nil {
+	if err := wrapper.BeaconBlockIsNil(b); err != nil {
 		return nil, err
 	}
 	body := b.Block().Body()
@@ -73,7 +73,7 @@ func ProcessRandaoNoVerify(
 	}
 	blockRandaoReveal := hash.Hash(randaoReveal)
 	if len(blockRandaoReveal) != len(latestMixSlice) {
-		return nil, errors.New("blockRandaoReveal length doesn't match latestMixSlice length")
+		return nil, errors.New("blockRandaoReveal length doesnt match latestMixSlice length")
 	}
 	for i, x := range blockRandaoReveal {
 		latestMixSlice[i] ^= x

beacon-chain/core/blocks/randao_test.go

@@ -10,8 +10,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/config/params"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -40,7 +40,7 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	}
 
 	want := "block randao: signature did not verify"
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = blocks.ProcessRandao(context.Background(), beaconState, wsb)
 	assert.ErrorContains(t, want, err)
@@ -59,7 +59,7 @@ func TestProcessRandao_SignatureVerifiesAndUpdatesLatestStateMixes(t *testing.T)
 			RandaoReveal: epochSignature,
 		},
 	}
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	newState, err := blocks.ProcessRandao(
 		context.Background(),

beacon-chain/core/blocks/signature_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/config/params"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -83,7 +83,7 @@ func TestVerifyBlockSignatureUsingCurrentFork(t *testing.T) {
 	assert.NoError(t, err)
 	sig := keys[0].Sign(rt[:]).Marshal()
 	altairBlk.Signature = sig
-	wsb, err := consensusblocks.NewSignedBeaconBlock(altairBlk)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(altairBlk)
 	require.NoError(t, err)
 	assert.NoError(t, blocks.VerifyBlockSignatureUsingCurrentFork(bState, wsb))
 }

beacon-chain/core/blocks/withdrawals.go

@@ -1,78 +0,0 @@
-package blocks
-
-import (
-	"bytes"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/hash/htr"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/time/slots"
-)
-
-const executionToBLSPadding = 12
-
-// ProcessBLSToExecutionChange validates a SignedBLSToExecution message and
-// changes the validator's withdrawal address accordingly.
-//
-// Spec pseudocode definition:
-//
-//def process_bls_to_execution_change(state: BeaconState, signed_address_change: SignedBLSToExecutionChange) -> None:
-//    validator = state.validators[address_change.validator_index]
-//
-//    assert validator.withdrawal_credentials[:1] == BLS_WITHDRAWAL_PREFIX
-//    assert validator.withdrawal_credentials[1:] == hash(address_change.from_bls_pubkey)[1:]
-//
-//    domain = get_domain(state, DOMAIN_BLS_TO_EXECUTION_CHANGE)
-//    signing_root = compute_signing_root(address_change, domain)
-//    assert bls.Verify(address_change.from_bls_pubkey, signing_root, signed_address_change.signature)
-//
-//    validator.withdrawal_credentials = (
-//        ETH1_ADDRESS_WITHDRAWAL_PREFIX
-//        + b'\x00' * 11
-//        + address_change.to_execution_address
-//    )
-//
-func ProcessBLSToExecutionChange(st state.BeaconState, signed *ethpb.SignedBLSToExecutionChange) (state.BeaconState, error) {
-	if signed == nil {
-		return st, errNilSignedWithdrawalMessage
-	}
-	message := signed.Message
-	if message == nil {
-		return st, errNilWithdrawalMessage
-	}
-
-	val, err := st.ValidatorAtIndex(message.ValidatorIndex)
-	if err != nil {
-		return nil, err
-	}
-	cred := val.WithdrawalCredentials
-	if cred[0] != params.BeaconConfig().BLSWithdrawalPrefixByte {
-		return nil, errInvalidBLSPrefix
-	}
-
-	// hash the public key and verify it matches the withdrawal credentials
-	fromPubkey := message.FromBlsPubkey
-	pubkeyChunks := [][32]byte{bytesutil.ToBytes32(fromPubkey[:32]), bytesutil.ToBytes32(fromPubkey[32:])}
-	digest := make([][32]byte, 1)
-	htr.VectorizedSha256(pubkeyChunks, digest)
-	if !bytes.Equal(digest[0][1:], cred[1:]) {
-		return nil, errInvalidWithdrawalCredentials
-	}
-
-	epoch := slots.ToEpoch(st.Slot())
-	domain, err := signing.Domain(st.Fork(), epoch, params.BeaconConfig().DomainBLSToExecutionChange, st.GenesisValidatorsRoot())
-	if err != nil {
-		return nil, err
-	}
-	if err := signing.VerifySigningRoot(message, fromPubkey, signed.Signature, domain); err != nil {
-		return nil, signing.ErrSigFailedToVerify
-	}
-	newCredentials := make([]byte, executionToBLSPadding)
-	newCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-	val.WithdrawalCredentials = append(newCredentials, message.ToExecutionAddress...)
-	err = st.UpdateValidatorAtIndex(message.ValidatorIndex, val)
-	return st, err
-}

beacon-chain/core/blocks/withdrawals_test.go

@@ -1,193 +0,0 @@
-package blocks_test
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/signing"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
-	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/crypto/bls"
-	"github.com/prysmaticlabs/prysm/crypto/hash/htr"
-	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/testing/require"
-)
-
-func TestProcessBLSToExecutionChange(t *testing.T) {
-	t.Run("happy case", func(t *testing.T) {
-		priv, err := bls.RandKey()
-		require.NoError(t, err)
-		pubkey := priv.PublicKey().Marshal()
-
-		message := &ethpb.BLSToExecutionChange{
-			ToExecutionAddress: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13},
-			ValidatorIndex:     0,
-			FromBlsPubkey:      pubkey,
-		}
-
-		pubkeyChunks := [][32]byte{bytesutil.ToBytes32(pubkey[:32]), bytesutil.ToBytes32(pubkey[32:])}
-		digest := make([][32]byte, 1)
-		htr.VectorizedSha256(pubkeyChunks, digest)
-		digest[0][0] = params.BeaconConfig().BLSWithdrawalPrefixByte
-
-		registry := []*ethpb.Validator{
-			{
-				WithdrawalCredentials: digest[0][:],
-			},
-		}
-		st, err := v1.InitializeFromProto(&ethpb.BeaconState{
-			Validators: registry,
-			Fork: &ethpb.Fork{
-				CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-				PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			},
-			Slot: params.BeaconConfig().SlotsPerEpoch * 5,
-		})
-		require.NoError(t, err)
-
-		signature, err := signing.ComputeDomainAndSign(st, time.CurrentEpoch(st), message, params.BeaconConfig().DomainBLSToExecutionChange, priv)
-		require.NoError(t, err)
-
-		signed := &ethpb.SignedBLSToExecutionChange{
-			Message:   message,
-			Signature: signature,
-		}
-
-		st, err = blocks.ProcessBLSToExecutionChange(st, signed)
-		require.NoError(t, err)
-
-		val, err := st.ValidatorAtIndex(0)
-		require.NoError(t, err)
-
-		require.DeepEqual(t, message.ToExecutionAddress, val.WithdrawalCredentials[12:])
-	})
-
-	t.Run("non-existent validator", func(t *testing.T) {
-		priv, err := bls.RandKey()
-		require.NoError(t, err)
-		pubkey := priv.PublicKey().Marshal()
-
-		message := &ethpb.BLSToExecutionChange{
-			ToExecutionAddress: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13},
-			ValidatorIndex:     1,
-			FromBlsPubkey:      pubkey,
-		}
-
-		pubkeyChunks := [][32]byte{bytesutil.ToBytes32(pubkey[:32]), bytesutil.ToBytes32(pubkey[32:])}
-		digest := make([][32]byte, 1)
-		htr.VectorizedSha256(pubkeyChunks, digest)
-		digest[0][0] = params.BeaconConfig().BLSWithdrawalPrefixByte
-
-		registry := []*ethpb.Validator{
-			{
-				WithdrawalCredentials: digest[0][:],
-			},
-		}
-		st, err := v1.InitializeFromProto(&ethpb.BeaconState{
-			Validators: registry,
-			Fork: &ethpb.Fork{
-				CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-				PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			},
-			Slot: params.BeaconConfig().SlotsPerEpoch * 5,
-		})
-		require.NoError(t, err)
-
-		signature, err := signing.ComputeDomainAndSign(st, time.CurrentEpoch(st), message, params.BeaconConfig().DomainBLSToExecutionChange, priv)
-		require.NoError(t, err)
-
-		signed := &ethpb.SignedBLSToExecutionChange{
-			Message:   message,
-			Signature: signature,
-		}
-
-		_, err = blocks.ProcessBLSToExecutionChange(st, signed)
-		require.ErrorContains(t, "out of range", err)
-	})
-
-	t.Run("signature does not verify", func(t *testing.T) {
-		priv, err := bls.RandKey()
-		require.NoError(t, err)
-		pubkey := priv.PublicKey().Marshal()
-
-		message := &ethpb.BLSToExecutionChange{
-			ToExecutionAddress: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13},
-			ValidatorIndex:     0,
-			FromBlsPubkey:      pubkey,
-		}
-
-		registry := []*ethpb.Validator{
-			{
-				WithdrawalCredentials: params.BeaconConfig().ZeroHash[:],
-			},
-		}
-		st, err := v1.InitializeFromProto(&ethpb.BeaconState{
-			Validators: registry,
-			Fork: &ethpb.Fork{
-				CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-				PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			},
-			Slot: params.BeaconConfig().SlotsPerEpoch * 5,
-		})
-		require.NoError(t, err)
-
-		signature, err := signing.ComputeDomainAndSign(st, time.CurrentEpoch(st), message, params.BeaconConfig().DomainBLSToExecutionChange, priv)
-		require.NoError(t, err)
-
-		signed := &ethpb.SignedBLSToExecutionChange{
-			Message:   message,
-			Signature: signature,
-		}
-
-		_, err = blocks.ProcessBLSToExecutionChange(st, signed)
-		require.ErrorContains(t, "withdrawal credentials do not match", err)
-	})
-
-	t.Run("invalid BLS prefix", func(t *testing.T) {
-		priv, err := bls.RandKey()
-		require.NoError(t, err)
-		pubkey := priv.PublicKey().Marshal()
-
-		message := &ethpb.BLSToExecutionChange{
-			ToExecutionAddress: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13},
-			ValidatorIndex:     0,
-			FromBlsPubkey:      pubkey,
-		}
-
-		pubkeyChunks := [][32]byte{bytesutil.ToBytes32(pubkey[:32]), bytesutil.ToBytes32(pubkey[32:])}
-		digest := make([][32]byte, 1)
-		htr.VectorizedSha256(pubkeyChunks, digest)
-		digest[0][0] = params.BeaconConfig().BLSWithdrawalPrefixByte
-
-		registry := []*ethpb.Validator{
-			{
-				WithdrawalCredentials: digest[0][:],
-			},
-		}
-		registry[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-
-		st, err := v1.InitializeFromProto(&ethpb.BeaconState{
-			Validators: registry,
-			Fork: &ethpb.Fork{
-				CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-				PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			},
-			Slot: params.BeaconConfig().SlotsPerEpoch * 5,
-		})
-		require.NoError(t, err)
-
-		signature, err := signing.ComputeDomainAndSign(st, time.CurrentEpoch(st), message, params.BeaconConfig().DomainBLSToExecutionChange, priv)
-		require.NoError(t, err)
-
-		signed := &ethpb.SignedBLSToExecutionChange{
-			Message:   message,
-			Signature: signature,
-		}
-
-		_, err = blocks.ProcessBLSToExecutionChange(st, signed)
-		require.ErrorContains(t, "withdrawal credential prefix is not a BLS prefix", err)
-
-	})
-}

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

@@ -39,7 +39,7 @@ func TestUpdateValidator_InclusionOnlyCountsPrevEpoch(t *testing.T) {
 	record := &precompute.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true}
 	a := &ethpb.PendingAttestation{InclusionDelay: 1, ProposerIndex: 2}
 
-	// Verify inclusion info doesn't get updated.
+	// Verify inclusion info doesnt get updated.
 	vp = precompute.UpdateValidator(vp, record, []uint64{0}, a, 100)
 	wanted := &precompute.Validator{IsCurrentEpochAttester: true, IsCurrentEpochTargetAttester: true, InclusionSlot: e}
 	wantedVp := []*precompute.Validator{wanted}

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

@@ -6,7 +6,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
@@ -20,12 +19,6 @@ func UnrealizedCheckpoints(st state.BeaconState) (*ethpb.Checkpoint, *ethpb.Chec
 		return nil, nil, errNilState
 	}
 
-	if slots.ToEpoch(st.Slot()) <= params.BeaconConfig().GenesisEpoch+1 {
-		jc := st.CurrentJustifiedCheckpoint()
-		fc := st.FinalizedCheckpoint()
-		return jc, fc, nil
-	}
-
 	activeBalance, prevTarget, currentTarget, err := st.UnrealizedCheckpointBalances()
 	if err != nil {
 		return nil, nil, err

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

@@ -18,7 +18,7 @@ import (
 // pre computed instances of validators attesting records and total
 // balances attested in an epoch.
 func New(ctx context.Context, s state.BeaconState) ([]*Validator, *Balance, error) {
-	ctx, span := trace.StartSpan(ctx, "precomputeEpoch.New")
+	_, span := trace.StartSpan(ctx, "precomputeEpoch.New")
 	defer span.End()
 
 	pValidators := make([]*Validator, s.NumValidators())

beacon-chain/core/helpers/sync_committee.go

@@ -46,7 +46,7 @@ func IsCurrentPeriodSyncCommittee(
 		// Fill in the cache on miss.
 		go func() {
 			if err := syncCommitteeCache.UpdatePositionsInCommittee(root, st); err != nil {
-				log.WithError(err).Error("Could not fill sync committee cache on miss")
+				log.Errorf("Could not fill sync committee cache on miss: %v", err)
 			}
 		}()
 
@@ -110,7 +110,7 @@ func CurrentPeriodSyncSubcommitteeIndices(
 		// Fill in the cache on miss.
 		go func() {
 			if err := syncCommitteeCache.UpdatePositionsInCommittee(root, st); err != nil {
-				log.WithError(err).Error("Could not fill sync committee cache on miss")
+				log.Errorf("Could not fill sync committee cache on miss: %v", err)
 			}
 		}()
 

beacon-chain/core/transition/BUILD.bazel

@@ -36,9 +36,9 @@ go_library(
         "//beacon-chain/state/stateutil:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -85,8 +85,8 @@ go_test(
         "//beacon-chain/state/v1:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/core/transition/altair_transition_no_verify_sig_test.go

@@ -14,7 +14,7 @@ import (
 	p2pType "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -90,7 +90,7 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 		SyncCommitteeSignature: aggregatedSig,
 	}
 	block.Block.Body.SyncAggregate = syncAggregate
-	wsb, err := blocks.NewSignedBeaconBlock(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 = blocks.NewSignedBeaconBlock(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 := blocks.NewSignedBeaconBlock(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 = blocks.NewSignedBeaconBlock(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 := blocks.NewSignedBeaconBlock(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

@@ -15,7 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
@@ -92,18 +92,18 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 		SyncCommitteeSignature: aggregatedSig,
 	}
 	block.Block.Body.SyncAggregate = syncAggregate
-	wsb, err := blocks.NewSignedBeaconBlock(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[:]
 
 	c := beaconState.Copy()
-	sig, err := util.BlockSignature(c, block.Block, privKeys)
+	sig, err := util.BlockSignatureBellatrix(c, block.Block, privKeys)
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	wsb, err = blocks.NewSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -180,19 +180,19 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	}
 	block.Block.Body.SyncAggregate = syncAggregate
 
-	wsb, err := blocks.NewSignedBeaconBlock(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[:]
 
 	c := beaconState.Copy()
-	sig, err := util.BlockSignature(c, block.Block, privKeys)
+	sig, err := util.BlockSignatureBellatrix(c, block.Block, privKeys)
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
 	block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
-	wsb, err = blocks.NewSignedBeaconBlock(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

@@ -10,7 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/benchmark"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -31,7 +31,7 @@ func BenchmarkExecuteStateTransition_FullBlock(b *testing.B) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		wsb, err := blocks.NewSignedBeaconBlock(block)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 		require.NoError(b, err)
 		_, err = coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wsb)
 		require.NoError(b, err)
@@ -56,14 +56,14 @@ func BenchmarkExecuteStateTransition_WithCache(b *testing.B) {
 	require.NoError(b, helpers.UpdateCommitteeCache(context.Background(), beaconState, time.CurrentEpoch(beaconState)))
 	require.NoError(b, beaconState.SetSlot(currentSlot))
 	// Run the state transition once to populate the cache.
-	wsb, err := blocks.NewSignedBeaconBlock(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++ {
-		wsb, err := blocks.NewSignedBeaconBlock(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

@@ -9,7 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/runtime/version"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -32,12 +32,12 @@ func TestSkipSlotCache_OK(t *testing.T) {
 	// with the state
 	blk, err := util.GenerateFullBlock(bState, privs, blkCfg, originalState.Slot()+10)
 	require.NoError(t, err)
-	wsb, err := blocks.NewSignedBeaconBlock(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)
-	wsb, err = blocks.NewSignedBeaconBlock(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")
@@ -61,7 +61,7 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 	// with the state
 	blk, err := util.GenerateFullBlock(bState, privs, blkCfg, originalState.Slot()+10)
 	require.NoError(t, err)
-	wsb, err := blocks.NewSignedBeaconBlock(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")
@@ -76,7 +76,7 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 		signature, err := util.BlockSignature(originalState, blk.Block, privs)
 		require.NoError(t, err)
 		blk.Signature = signature.Marshal()
-		wsb, err := blocks.NewSignedBeaconBlock(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")
@@ -89,7 +89,7 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
 		signature, err := util.BlockSignature(originalState, blk.Block, privs)
 		require.NoError(t, err)
 		blk.Signature = signature.Marshal()
-		wsb, err := blocks.NewSignedBeaconBlock(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.go

@@ -17,9 +17,9 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/math"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	"github.com/prysmaticlabs/prysm/runtime/version"
@@ -52,7 +52,7 @@ func ExecuteStateTransition(
 	if ctx.Err() != nil {
 		return nil, ctx.Err()
 	}
-	if err := blocks.BeaconBlockIsNil(signed); err != nil {
+	if err := wrapper.BeaconBlockIsNil(signed); err != nil {
 		return nil, err
 	}
 
@@ -296,7 +296,7 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot types.Slot)
 
 // VerifyOperationLengths verifies that block operation lengths are valid.
 func VerifyOperationLengths(_ context.Context, state state.BeaconState, b interfaces.SignedBeaconBlock) (state.BeaconState, error) {
-	if err := blocks.BeaconBlockIsNil(b); err != nil {
+	if err := wrapper.BeaconBlockIsNil(b); err != nil {
 		return nil, err
 	}
 	body := b.Block().Body()

beacon-chain/core/transition/transition_fuzz_test.go

@@ -7,8 +7,8 @@ import (
 	fuzz "github.com/google/gofuzz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
@@ -25,10 +25,7 @@ func TestFuzzExecuteStateTransition_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(sb)
-		if sb.Block == nil || sb.Block.Body == nil {
-			continue
-		}
-		wsb, err := blocks.NewSignedBeaconBlock(sb)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
 		require.NoError(t, err)
 		s, err := ExecuteStateTransition(ctx, state, wsb)
 		if err != nil && s != nil {
@@ -49,10 +46,7 @@ func TestFuzzCalculateStateRoot_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(sb)
-		if sb.Block == nil || sb.Block.Body == nil {
-			continue
-		}
-		wsb, err := blocks.NewSignedBeaconBlock(sb)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
 		require.NoError(t, err)
 		stateRoot, err := CalculateStateRoot(ctx, state, wsb)
 		if err != nil && stateRoot != [32]byte{} {
@@ -109,10 +103,7 @@ func TestFuzzprocessOperationsNoVerify_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(bb)
-		if bb.Block == nil || bb.Block.Body == nil {
-			continue
-		}
-		wsb, err := blocks.NewSignedBeaconBlock(bb)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
 		require.NoError(t, err)
 		s, err := ProcessOperationsNoVerifyAttsSigs(ctx, state, wsb)
 		if err != nil && s != nil {
@@ -132,10 +123,7 @@ func TestFuzzverifyOperationLengths_10000(t *testing.T) {
 	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(bb)
-		if bb.Block == nil || bb.Block.Body == nil {
-			continue
-		}
-		wsb, err := blocks.NewSignedBeaconBlock(bb)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
 		require.NoError(t, err)
 		_, err = VerifyOperationLengths(context.Background(), state, wsb)
 		_ = err
@@ -184,10 +172,7 @@ func TestFuzzProcessBlockForStateRoot_1000(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(sb)
-		if sb.Block == nil || sb.Block.Body == nil {
-			continue
-		}
-		wsb, err := blocks.NewSignedBeaconBlock(sb)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
 		require.NoError(t, err)
 		s, err := ProcessBlockForStateRoot(ctx, state, wsb)
 		if err != nil && s != nil {

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -11,8 +11,8 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition/interop"
 	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	"github.com/prysmaticlabs/prysm/runtime/version"
@@ -160,7 +160,7 @@ func ProcessBlockNoVerifyAnySig(
 ) (*bls.SignatureBatch, state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.ProcessBlockNoVerifyAnySig")
 	defer span.End()
-	if err := blocks.BeaconBlockIsNil(signed); err != nil {
+	if err := wrapper.BeaconBlockIsNil(signed); err != nil {
 		return nil, nil, err
 	}
 
@@ -223,7 +223,7 @@ func ProcessOperationsNoVerifyAttsSigs(
 	signedBeaconBlock interfaces.SignedBeaconBlock) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.ProcessOperationsNoVerifyAttsSigs")
 	defer span.End()
-	if err := blocks.BeaconBlockIsNil(signedBeaconBlock); err != nil {
+	if err := wrapper.BeaconBlockIsNil(signedBeaconBlock); err != nil {
 		return nil, err
 	}
 
@@ -269,7 +269,7 @@ func ProcessBlockForStateRoot(
 ) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.ProcessBlockForStateRoot")
 	defer span.End()
-	if err := blocks.BeaconBlockIsNil(signed); err != nil {
+	if err := wrapper.BeaconBlockIsNil(signed); err != nil {
 		return nil, err
 	}
 
@@ -290,17 +290,24 @@ func ProcessBlockForStateRoot(
 		return nil, errors.Wrap(err, "could not check if execution is enabled")
 	}
 	if enabled {
-		executionData, err := blk.Body().Execution()
-		if err != nil {
-			return nil, err
-		}
 		if blk.IsBlinded() {
-			state, err = b.ProcessPayloadHeader(state, executionData)
+			header, err := blk.Body().ExecutionPayloadHeader()
+			if err != nil {
+				return nil, err
+			}
+			state, err = b.ProcessPayloadHeader(state, header)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not process execution payload header")
+			}
 		} else {
-			state, err = b.ProcessPayload(state, executionData)
-		}
-		if err != nil {
-			return nil, errors.Wrap(err, "could not process execution data")
+			payload, err := blk.Body().ExecutionPayload()
+			if err != nil {
+				return nil, err
+			}
+			state, err = b.ProcessPayload(state, payload)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not process execution payload")
+			}
 		}
 	}
 

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -52,7 +52,7 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
 	block.Block.Body.RandaoReveal = randaoReveal
 	block.Block.Body.Eth1Data = eth1Data
 
-	wsb, err := blocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -63,7 +63,7 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	wsb, err = blocks.NewSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
 	assert.NoError(t, err)
@@ -108,7 +108,7 @@ func TestExecuteStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *test
 	block.Block.Body.RandaoReveal = randaoReveal
 	block.Block.Body.Eth1Data = eth1Data
 
-	wsb, err := blocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -120,7 +120,7 @@ func TestExecuteStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *test
 	block.Signature = sig.Marshal()
 
 	block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
-	wsb, err = blocks.NewSignedBeaconBlock(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)
@@ -128,7 +128,7 @@ func TestExecuteStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *test
 
 func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
 	beaconState, block, _, _, _ := createFullBlockWithOperations(t)
-	wsb, err := blocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	set, _, err := transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -140,7 +140,7 @@ func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
 
 func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := blocks.NewSignedBeaconBlock(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 +153,7 @@ func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) {
 
 func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := blocks.NewSignedBeaconBlock(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 +163,7 @@ func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
 
 func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) {
 	beaconState, block := createFullBellatrixBlockWithOperations(t)
-	wsb, err := blocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
 	require.NoError(t, err)
@@ -173,7 +173,7 @@ func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) {
 
 func TestCalculateStateRootAltair_OK(t *testing.T) {
 	beaconState, block := createFullAltairBlockWithOperations(t)
-	wsb, err := blocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	r, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -183,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 := blocks.NewSignedBeaconBlock(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

@@ -15,8 +15,8 @@ import (
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
-	consensusblocks "github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/crypto/bls"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -44,7 +44,7 @@ func TestExecuteStateTransition_IncorrectSlot(t *testing.T) {
 		},
 	}
 	want := "expected state.slot"
-	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	_, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
 	assert.ErrorContains(t, want, err)
@@ -89,7 +89,7 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
 	block.Block.Body.RandaoReveal = randaoReveal
 	block.Block.Body.Eth1Data = eth1Data
 
-	wsb, err := consensusblocks.NewSignedBeaconBlock(block)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -100,7 +100,7 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
 	require.NoError(t, err)
 	block.Signature = sig.Marshal()
 
-	wsb, err = consensusblocks.NewSignedBeaconBlock(block)
+	wsb, err = wrapper.WrappedSignedBeaconBlock(block)
 	require.NoError(t, err)
 	beaconState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
 	require.NoError(t, err)
@@ -133,15 +133,16 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 			}),
 		},
 	}
+	au := util.AttestationUtil{}
 	attesterSlashings := []*ethpb.AttesterSlashing{
 		{
 			Attestation_1: &ethpb.IndexedAttestation{
-				Data:             util.HydrateAttestationData(&ethpb.AttestationData{}),
+				Data:             au.HydrateAttestationData(&ethpb.AttestationData{}),
 				AttestingIndices: []uint64{0, 1},
 				Signature:        make([]byte, 96),
 			},
 			Attestation_2: &ethpb.IndexedAttestation{
-				Data:             util.HydrateAttestationData(&ethpb.AttestationData{}),
+				Data:             au.HydrateAttestationData(&ethpb.AttestationData{}),
 				AttestingIndices: []uint64{0, 1},
 				Signature:        make([]byte, 96),
 			},
@@ -152,7 +153,7 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 		blockRoots = append(blockRoots, []byte{byte(i)})
 	}
 	require.NoError(t, beaconState.SetBlockRoots(blockRoots))
-	blockAtt := util.HydrateAttestation(&ethpb.Attestation{
+	blockAtt := au.HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("hello-world"), 32)},
 		},
@@ -189,7 +190,7 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 	cp.Root = []byte("hello-world")
 	require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cp))
 	require.NoError(t, beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{}))
-	wsb, err := consensusblocks.NewSignedBeaconBlock(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"
@@ -255,7 +256,8 @@ func createFullBlockWithOperations(t *testing.T) (state.BeaconState,
 	require.NoError(t, beaconState.SetValidators(validators))
 
 	mockRoot2 := [32]byte{'A'}
-	att1 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+	au := util.AttestationUtil{}
+	att1 := au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot2[:]},
 		},
@@ -271,7 +273,7 @@ func createFullBlockWithOperations(t *testing.T) (state.BeaconState,
 	att1.Signature = aggregateSig.Marshal()
 
 	mockRoot3 := [32]byte{'B'}
-	att2 := util.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
+	att2 := au.HydrateIndexedAttestation(&ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
 			Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot3[:]},
 			Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, fieldparams.RootLength)},
@@ -301,7 +303,7 @@ func createFullBlockWithOperations(t *testing.T) (state.BeaconState,
 
 	aggBits := bitfield.NewBitlist(1)
 	aggBits.SetBitAt(0, true)
-	blockAtt := util.HydrateAttestation(&ethpb.Attestation{
+	blockAtt := au.HydrateAttestation(&ethpb.Attestation{
 		Data: &ethpb.AttestationData{
 			Slot:   beaconState.Slot(),
 			Target: &ethpb.Checkpoint{Epoch: time.CurrentEpoch(beaconState)},
@@ -404,7 +406,7 @@ func TestProcessBlock_OverMaxProposerSlashings(t *testing.T) {
 		len(b.Block.Body.ProposerSlashings), params.BeaconConfig().MaxProposerSlashings)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
 	assert.ErrorContains(t, want, err)
@@ -423,7 +425,7 @@ func TestProcessBlock_OverMaxAttesterSlashings(t *testing.T) {
 		len(b.Block.Body.AttesterSlashings), params.BeaconConfig().MaxAttesterSlashings)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
 	assert.ErrorContains(t, want, err)
@@ -441,7 +443,7 @@ func TestProcessBlock_OverMaxAttestations(t *testing.T) {
 		len(b.Block.Body.Attestations), params.BeaconConfig().MaxAttestations)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
 	assert.ErrorContains(t, want, err)
@@ -460,7 +462,7 @@ func TestProcessBlock_OverMaxVoluntaryExits(t *testing.T) {
 		len(b.Block.Body.VoluntaryExits), maxExits)
 	s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
 	assert.ErrorContains(t, want, err)
@@ -482,7 +484,7 @@ func TestProcessBlock_IncorrectDeposits(t *testing.T) {
 	}
 	want := fmt.Sprintf("incorrect outstanding deposits in block body, wanted: %d, got: %d",
 		s.Eth1Data().DepositCount-s.Eth1DepositIndex(), len(b.Block.Body.Deposits))
-	wsb, err := consensusblocks.NewSignedBeaconBlock(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/BUILD.bazel

@@ -38,8 +38,8 @@ go_test(
     deps = [
         "//beacon-chain/db/kv:go_default_library",
         "//cmd:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

beacon-chain/db/iface/interface.go

@@ -49,11 +49,10 @@ type ReadOnlyDatabase interface {
 	LastValidatedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error)
 	// Deposit contract related handlers.
 	DepositContractAddress(ctx context.Context) ([]byte, error)
-	// ExecutionChainData operations.
-	ExecutionChainData(ctx context.Context) (*ethpb.ETH1ChainData, error)
+	// Powchain operations.
+	PowchainData(ctx context.Context) (*ethpb.ETH1ChainData, error)
 	// Fee reicipients operations.
 	FeeRecipientByValidatorID(ctx context.Context, id types.ValidatorIndex) (common.Address, error)
-	RegistrationByValidatorID(ctx context.Context, id types.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
 	// origin checkpoint sync support
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
 	BackfillBlockRoot(ctx context.Context) ([32]byte, error)
@@ -81,8 +80,8 @@ type NoHeadAccessDatabase interface {
 	SaveLastValidatedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
 	// Deposit contract related handlers.
 	SaveDepositContractAddress(ctx context.Context, addr common.Address) error
-	// SaveExecutionChainData operations.
-	SaveExecutionChainData(ctx context.Context, data *ethpb.ETH1ChainData) error
+	// Powchain operations.
+	SavePowchainData(ctx context.Context, data *ethpb.ETH1ChainData) error
 	// Run any required database migrations.
 	RunMigrations(ctx context.Context) error
 	// Fee reicipients operations.

beacon-chain/db/kv/BUILD.bazel

@@ -10,7 +10,6 @@ go_library(
         "deposit_contract.go",
         "encoding.go",
         "error.go",
-        "execution_chain.go",
         "finalized_block_roots.go",
         "genesis.go",
         "key.go",
@@ -18,9 +17,9 @@ go_library(
         "log.go",
         "migration.go",
         "migration_archived_index.go",
-        "migration_blinded_beacon_blocks.go",
         "migration_block_slot_index.go",
         "migration_state_validators.go",
+        "powchain.go",
         "schema.go",
         "state.go",
         "state_summary.go",
@@ -46,9 +45,9 @@ go_library(
         "//beacon-chain/state/v3:go_default_library",
         "//config/features:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//container/slice:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz/detect:go_default_library",
@@ -84,7 +83,6 @@ go_test(
         "checkpoint_test.go",
         "deposit_contract_test.go",
         "encoding_test.go",
-        "execution_chain_test.go",
         "finalized_block_roots_test.go",
         "genesis_test.go",
         "init_test.go",
@@ -92,6 +90,7 @@ go_test(
         "migration_archived_index_test.go",
         "migration_block_slot_index_test.go",
         "migration_state_validators_test.go",
+        "powchain_test.go",
         "state_summary_test.go",
         "state_test.go",
         "utils_test.go",
@@ -110,9 +109,9 @@ go_test(
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/testing:go_default_library",

beacon-chain/db/kv/archived_point.go

@@ -11,7 +11,7 @@ import (
 
 // LastArchivedSlot from the db.
 func (s *Store) LastArchivedSlot(ctx context.Context) (types.Slot, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.LastArchivedSlot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.LastArchivedSlot")
 	defer span.End()
 	var index types.Slot
 	err := s.db.View(func(tx *bolt.Tx) error {
@@ -26,7 +26,7 @@ func (s *Store) LastArchivedSlot(ctx context.Context) (types.Slot, error) {
 
 // LastArchivedRoot from the db.
 func (s *Store) LastArchivedRoot(ctx context.Context) [32]byte {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.LastArchivedRoot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.LastArchivedRoot")
 	defer span.End()
 
 	var blockRoot []byte
@@ -44,7 +44,7 @@ func (s *Store) LastArchivedRoot(ctx context.Context) [32]byte {
 // ArchivedPointRoot returns the block root of an archived point from the DB.
 // This is essential for cold state management and to restore a cold state.
 func (s *Store) ArchivedPointRoot(ctx context.Context, slot types.Slot) [32]byte {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.ArchivedPointRoot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.ArchivedPointRoot")
 	defer span.End()
 
 	var blockRoot []byte
@@ -61,7 +61,7 @@ func (s *Store) ArchivedPointRoot(ctx context.Context, slot types.Slot) [32]byte
 
 // HasArchivedPoint returns true if an archived point exists in DB.
 func (s *Store) HasArchivedPoint(ctx context.Context, slot types.Slot) bool {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasArchivedPoint")
+	_, span := trace.StartSpan(ctx, "BeaconDB.HasArchivedPoint")
 	defer span.End()
 	var exists bool
 	if err := s.db.View(func(tx *bolt.Tx) error {

beacon-chain/db/kv/backup.go

@@ -6,7 +6,7 @@ import (
 	"path"
 
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/io/file"
 	bolt "go.etcd.io/bbolt"
 	"go.opencensus.io/trace"
@@ -34,7 +34,7 @@ func (s *Store) Backup(ctx context.Context, outputDir string, permissionOverride
 	if err != nil {
 		return err
 	}
-	if err := blocks.BeaconBlockIsNil(head); err != nil {
+	if err := wrapper.BeaconBlockIsNil(head); err != nil {
 		return err
 	}
 	// Ensure the backups directory exists.

beacon-chain/db/kv/backup_test.go

@@ -6,8 +6,8 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 )
@@ -20,7 +20,7 @@ func TestStore_Backup(t *testing.T) {
 	head := util.NewBeaconBlock()
 	head.Block.Slot = 5000
 
-	wsb, err := blocks.NewSignedBeaconBlock(head)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(head)
 	require.NoError(t, err)
 	require.NoError(t, db.SaveBlock(ctx, wsb))
 	root, err := head.Block.HashTreeRoot()
@@ -62,7 +62,7 @@ func TestStore_BackupMultipleBuckets(t *testing.T) {
 	for i := startSlot; i < 5200; i++ {
 		head := util.NewBeaconBlock()
 		head.Block.Slot = i
-		wsb, err := blocks.NewSignedBeaconBlock(head)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(head)
 		require.NoError(t, err)
 		require.NoError(t, db.SaveBlock(ctx, wsb))
 		root, err := head.Block.HashTreeRoot()

beacon-chain/db/kv/blocks.go

@@ -10,11 +10,10 @@ import (
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
-	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/container/slice"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -54,7 +53,7 @@ func (s *Store) Block(ctx context.Context, blockRoot [32]byte) (interfaces.Signe
 // at the time the chain was started, used to initialize the database and chain
 // without syncing from genesis.
 func (s *Store) OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.OriginCheckpointBlockRoot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.OriginCheckpointBlockRoot")
 	defer span.End()
 
 	var root [32]byte
@@ -73,7 +72,7 @@ func (s *Store) OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
 
 // BackfillBlockRoot keeps track of the highest block available before the OriginCheckpointBlockRoot
 func (s *Store) BackfillBlockRoot(ctx context.Context) ([32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.BackfillBlockRoot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.BackfillBlockRoot")
 	defer span.End()
 
 	var root [32]byte
@@ -131,7 +130,7 @@ func (s *Store) Blocks(ctx context.Context, f *filters.QueryFilter) ([]interface
 			encoded := bkt.Get(keys[i])
 			blk, err := unmarshalBlock(ctx, encoded)
 			if err != nil {
-				return errors.Wrapf(err, "could not unmarshal block with key %#x", keys[i])
+				return err
 			}
 			blocks = append(blocks, blk)
 			blockRoots = append(blockRoots, bytesutil.ToBytes32(keys[i]))
@@ -169,7 +168,7 @@ func (s *Store) BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][32]b
 
 // HasBlock checks if a block by root exists in the db.
 func (s *Store) HasBlock(ctx context.Context, blockRoot [32]byte) bool {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasBlock")
+	_, span := trace.StartSpan(ctx, "BeaconDB.HasBlock")
 	defer span.End()
 	if v, ok := s.blockCache.Get(string(blockRoot[:])); v != nil && ok {
 		return true
@@ -273,16 +272,16 @@ func (s *Store) SaveBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 }
 
 // SaveBlocks via bulk updates to the db.
-func (s *Store) SaveBlocks(ctx context.Context, blks []interfaces.SignedBeaconBlock) error {
+func (s *Store) SaveBlocks(ctx context.Context, blocks []interfaces.SignedBeaconBlock) error {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveBlocks")
 	defer span.End()
 
 	// Performing marshaling, hashing, and indexing outside the bolt transaction
 	// to minimize the time we hold the DB lock.
-	blockRoots := make([][]byte, len(blks))
-	encodedBlocks := make([][]byte, len(blks))
-	indicesForBlocks := make([]map[string][]byte, len(blks))
-	for i, blk := range blks {
+	blockRoots := make([][]byte, len(blocks))
+	encodedBlocks := make([][]byte, len(blocks))
+	indicesForBlocks := make([]map[string][]byte, len(blocks))
+	for i, blk := range blocks {
 		blockRoot, err := blk.Block().HashTreeRoot()
 		if err != nil {
 			return err
@@ -298,23 +297,13 @@ func (s *Store) SaveBlocks(ctx context.Context, blks []interfaces.SignedBeaconBl
 	}
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blocksBucket)
-		for i, blk := range blks {
+		for i, blk := range blocks {
 			if existingBlock := bkt.Get(blockRoots[i]); existingBlock != nil {
 				continue
 			}
 			if err := updateValueForIndices(ctx, indicesForBlocks[i], blockRoots[i], tx); err != nil {
 				return errors.Wrap(err, "could not update DB indices")
 			}
-			if features.Get().EnableOnlyBlindedBeaconBlocks {
-				blindedBlock, err := blk.ToBlinded()
-				if err != nil {
-					if !errors.Is(err, blocks.ErrUnsupportedVersion) {
-						return err
-					}
-				} else {
-					blk = blindedBlock
-				}
-			}
 			s.blockCache.Set(string(blockRoots[i]), blk, int64(len(encodedBlocks[i])))
 			if err := bkt.Put(blockRoots[i], encodedBlocks[i]); err != nil {
 				return err
@@ -326,7 +315,7 @@ func (s *Store) SaveBlocks(ctx context.Context, blks []interfaces.SignedBeaconBl
 
 // SaveHeadBlockRoot to the db.
 func (s *Store) SaveHeadBlockRoot(ctx context.Context, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveHeadBlockRoot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveHeadBlockRoot")
 	defer span.End()
 	return s.db.Update(func(tx *bolt.Tx) error {
 		hasStateSummary := s.hasStateSummaryBytes(tx, blockRoot)
@@ -377,7 +366,7 @@ func (s *Store) GenesisBlockRoot(ctx context.Context) ([32]byte, error) {
 
 // SaveGenesisBlockRoot to the db.
 func (s *Store) SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveGenesisBlockRoot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveGenesisBlockRoot")
 	defer span.End()
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(blocksBucket)
@@ -390,7 +379,7 @@ func (s *Store) SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) er
 // This value is used by a running beacon chain node to locate the state at the beginning
 // of the chain history, in places where genesis would typically be used.
 func (s *Store) SaveOriginCheckpointBlockRoot(ctx context.Context, blockRoot [32]byte) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveOriginCheckpointBlockRoot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveOriginCheckpointBlockRoot")
 	defer span.End()
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(blocksBucket)
@@ -401,7 +390,7 @@ func (s *Store) SaveOriginCheckpointBlockRoot(ctx context.Context, blockRoot [32
 // 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 {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveBackfillBlockRoot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveBackfillBlockRoot")
 	defer span.End()
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(blocksBucket)
@@ -500,7 +489,7 @@ func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id types.Validato
 // SaveFeeRecipientsByValidatorIDs saves the fee recipients for validator ids.
 // Error is returned if `ids` and `recipients` are not the same length.
 func (s *Store) SaveFeeRecipientsByValidatorIDs(ctx context.Context, ids []types.ValidatorIndex, feeRecipients []common.Address) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveFeeRecipientByValidatorID")
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveFeeRecipientByValidatorID")
 	defer span.End()
 
 	if len(ids) != len(feeRecipients) {
@@ -538,7 +527,7 @@ func (s *Store) RegistrationByValidatorID(ctx context.Context, id types.Validato
 // SaveRegistrationsByValidatorIDs saves the validator registrations for validator ids.
 // Error is returned if `ids` and `registrations` are not the same length.
 func (s *Store) SaveRegistrationsByValidatorIDs(ctx context.Context, ids []types.ValidatorIndex, regs []*ethpb.ValidatorRegistrationV1) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveRegistrationsByValidatorIDs")
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveRegistrationsByValidatorIDs")
 	defer span.End()
 
 	if len(ids) != len(regs) {
@@ -625,7 +614,7 @@ func blockRootsBySlotRange(
 	bkt *bolt.Bucket,
 	startSlotEncoded, endSlotEncoded, startEpochEncoded, endEpochEncoded, slotStepEncoded interface{},
 ) ([][]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlotRange")
+	_, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlotRange")
 	defer span.End()
 
 	// Return nothing when all slot parameters are missing
@@ -690,7 +679,7 @@ func blockRootsBySlotRange(
 
 // blockRootsBySlot retrieves the block roots by slot
 func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) ([][32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlot")
+	_, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlot")
 	defer span.End()
 
 	bkt := tx.Bucket(blockSlotIndicesBucket)
@@ -711,7 +700,7 @@ func blockRootsBySlot(ctx context.Context, tx *bolt.Tx, slot types.Slot) ([][32]
 // a map of bolt DB index buckets corresponding to each particular key for indices for
 // data, such as (shard indices bucket -> shard 5).
 func createBlockIndicesFromBlock(ctx context.Context, block interfaces.BeaconBlock) map[string][]byte {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.createBlockIndicesFromBlock")
+	_, span := trace.StartSpan(ctx, "BeaconDB.createBlockIndicesFromBlock")
 	defer span.End()
 	indicesByBucket := make(map[string][]byte)
 	// Every index has a unique bucket for fast, binary-search
@@ -739,7 +728,7 @@ func createBlockIndicesFromBlock(ctx context.Context, block interfaces.BeaconBlo
 // objects. If a certain filter criterion does not apply to
 // blocks, an appropriate error is returned.
 func createBlockIndicesFromFilters(ctx context.Context, f *filters.QueryFilter) (map[string][]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.createBlockIndicesFromFilters")
+	_, span := trace.StartSpan(ctx, "BeaconDB.createBlockIndicesFromFilters")
 	defer span.End()
 	indicesByBucket := make(map[string][]byte)
 	for k, v := range f.Filters() {
@@ -769,7 +758,7 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.SignedBeaconBlock
 	var err error
 	enc, err = snappy.Decode(nil, enc)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not snappy decode block")
+		return nil, err
 	}
 	var rawBlock ssz.Unmarshaler
 	switch {
@@ -777,65 +766,43 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.SignedBeaconBlock
 		// Marshal block bytes to altair beacon block.
 		rawBlock = &ethpb.SignedBeaconBlockAltair{}
 		if err := rawBlock.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Altair block")
+			return nil, err
 		}
 	case hasBellatrixKey(enc):
 		rawBlock = &ethpb.SignedBeaconBlockBellatrix{}
 		if err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Bellatrix block")
+			return nil, err
 		}
 	case hasBellatrixBlindKey(enc):
 		rawBlock = &ethpb.SignedBlindedBeaconBlockBellatrix{}
 		if err := rawBlock.UnmarshalSSZ(enc[len(bellatrixBlindKey):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal blinded Bellatrix block")
+			return nil, err
 		}
 	default:
 		// Marshal block bytes to phase 0 beacon block.
 		rawBlock = &ethpb.SignedBeaconBlock{}
 		if err := rawBlock.UnmarshalSSZ(enc); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Phase0 block")
+			return nil, err
 		}
 	}
-	return blocks.NewSignedBeaconBlock(rawBlock)
+	return wrapper.WrappedSignedBeaconBlock(rawBlock)
 }
 
 // marshal versioned beacon block from struct type down to bytes.
 func marshalBlock(_ context.Context, blk interfaces.SignedBeaconBlock) ([]byte, error) {
-	var encodedBlock []byte
-	var err error
-	blockToSave := blk
-	if features.Get().EnableOnlyBlindedBeaconBlocks {
-		blindedBlock, err := blk.ToBlinded()
-		switch {
-		case errors.Is(err, blocks.ErrUnsupportedVersion):
-			encodedBlock, err = blk.MarshalSSZ()
-			if err != nil {
-				return nil, errors.Wrap(err, "could not marshal non-blinded block")
-			}
-		case err != nil:
-			return nil, errors.Wrap(err, "could not convert block to blinded format")
-		default:
-			encodedBlock, err = blindedBlock.MarshalSSZ()
-			if err != nil {
-				return nil, errors.Wrap(err, "could not marshal blinded block")
-			}
-			blockToSave = blindedBlock
-		}
-	} else {
-		encodedBlock, err = blk.MarshalSSZ()
-		if err != nil {
-			return nil, err
-		}
+	obj, err := blk.MarshalSSZ()
+	if err != nil {
+		return nil, err
 	}
-	switch blockToSave.Version() {
+	switch blk.Version() {
 	case version.BellatrixBlind:
-		return snappy.Encode(nil, append(bellatrixBlindKey, encodedBlock...)), nil
+		return snappy.Encode(nil, append(bellatrixBlindKey, obj...)), nil
 	case version.Bellatrix:
-		return snappy.Encode(nil, append(bellatrixKey, encodedBlock...)), nil
+		return snappy.Encode(nil, append(bellatrixKey, obj...)), nil
 	case version.Altair:
-		return snappy.Encode(nil, append(altairKey, encodedBlock...)), nil
+		return snappy.Encode(nil, append(altairKey, obj...)), nil
 	case version.Phase0:
-		return snappy.Encode(nil, encodedBlock), nil
+		return snappy.Encode(nil, obj), nil
 	default:
 		return nil, errors.New("Unknown block version")
 	}

beacon-chain/db/kv/blocks_test.go

@@ -8,9 +8,9 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -31,7 +31,7 @@ var blockTests = []struct {
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return blocks.NewSignedBeaconBlock(b)
+			return wrapper.WrappedSignedBeaconBlock(b)
 		},
 	},
 	{
@@ -42,7 +42,7 @@ var blockTests = []struct {
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return blocks.NewSignedBeaconBlock(b)
+			return wrapper.WrappedSignedBeaconBlock(b)
 		},
 	},
 	{
@@ -53,7 +53,7 @@ var blockTests = []struct {
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return blocks.NewSignedBeaconBlock(b)
+			return wrapper.WrappedSignedBeaconBlock(b)
 		},
 	},
 	{
@@ -64,7 +64,7 @@ var blockTests = []struct {
 			if root != nil {
 				b.Block.ParentRoot = root
 			}
-			return blocks.NewSignedBeaconBlock(b)
+			return wrapper.WrappedSignedBeaconBlock(b)
 		},
 	},
 }
@@ -134,21 +134,11 @@ func TestStore_BlocksCRUD(t *testing.T) {
 			retrievedBlock, err := db.Block(ctx, blockRoot)
 			require.NoError(t, err)
 			assert.DeepEqual(t, nil, retrievedBlock, "Expected nil block")
-
 			require.NoError(t, db.SaveBlock(ctx, blk))
 			assert.Equal(t, true, db.HasBlock(ctx, blockRoot), "Expected block to exist in the db")
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
-			wanted := retrievedBlock
-			if _, err := retrievedBlock.PbBellatrixBlock(); err == nil {
-				wanted, err = retrievedBlock.ToBlinded()
-				require.NoError(t, err)
-			}
-			wantedPb, err := wanted.Proto()
-			require.NoError(t, err)
-			retrievedPb, err := retrievedBlock.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(wantedPb, retrievedPb), "Wanted: %v, received: %v", wanted, retrievedBlock)
+			assert.Equal(t, true, proto.Equal(blk.Proto(), retrievedBlock.Proto()), "Wanted: %v, received: %v", blk, retrievedBlock)
 		})
 	}
 }
@@ -264,7 +254,7 @@ func TestStore_DeleteJustifiedBlock(t *testing.T) {
 	}
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
-	blk, err := blocks.NewSignedBeaconBlock(b)
+	blk, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	require.NoError(t, db.SaveBlock(ctx, blk))
 	require.NoError(t, db.SaveState(ctx, st, root))
@@ -283,7 +273,7 @@ func TestStore_DeleteFinalizedBlock(t *testing.T) {
 	}
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
-	blk, err := blocks.NewSignedBeaconBlock(b)
+	blk, err := wrapper.WrappedSignedBeaconBlock(b)
 	require.NoError(t, err)
 	require.NoError(t, db.SaveBlock(ctx, blk))
 	require.NoError(t, db.SaveState(ctx, st, root))
@@ -299,14 +289,12 @@ func TestStore_GenesisBlock(t *testing.T) {
 	blockRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.NoError(t, db.SaveGenesisBlockRoot(ctx, blockRoot))
-	wsb, err := blocks.NewSignedBeaconBlock(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)
-	retrievedBlockPb, err := retrievedBlock.Proto()
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(genesisBlock, retrievedBlockPb), "Wanted: %v, received: %v", genesisBlock, retrievedBlock)
+	assert.Equal(t, true, proto.Equal(genesisBlock, retrievedBlock.Proto()), "Wanted: %v, received: %v", genesisBlock, retrievedBlock)
 }
 
 func TestStore_BlocksCRUD_NoCache(t *testing.T) {
@@ -326,17 +314,7 @@ func TestStore_BlocksCRUD_NoCache(t *testing.T) {
 			assert.Equal(t, true, db.HasBlock(ctx, blockRoot), "Expected block to exist in the db")
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
-
-			wanted := blk
-			if _, err := blk.PbBellatrixBlock(); err == nil {
-				wanted, err = blk.ToBlinded()
-				require.NoError(t, err)
-			}
-			wantedPb, err := wanted.Proto()
-			require.NoError(t, err)
-			retrievedPb, err := retrievedBlock.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(wantedPb, retrievedPb), "Wanted: %v, received: %v", wanted, retrievedBlock)
+			assert.Equal(t, true, proto.Equal(blk.Proto(), retrievedBlock.Proto()), "Wanted: %v, received: %v", blk, retrievedBlock)
 		})
 	}
 }
@@ -546,16 +524,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			root := roots[0]
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
-			wanted := block1
-			if _, err := block1.PbBellatrixBlock(); err == nil {
-				wanted, err = wanted.ToBlinded()
-				require.NoError(t, err)
-			}
-			wantedPb, err := wanted.Proto()
-			require.NoError(t, err)
-			bPb, err := b.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(wantedPb, bPb), "Wanted: %v, received: %v", wanted, b)
+			assert.Equal(t, true, proto.Equal(block1.Proto(), b.Proto()), "Wanted: %v, received: %v", block1, b)
 
 			_, roots, err = db.HighestRootsBelowSlot(ctx, 11)
 			require.NoError(t, err)
@@ -564,16 +533,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			root = roots[0]
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
-			wanted2 := block2
-			if _, err := block2.PbBellatrixBlock(); err == nil {
-				wanted2, err = block2.ToBlinded()
-				require.NoError(t, err)
-			}
-			wanted2Pb, err := wanted2.Proto()
-			require.NoError(t, err)
-			bPb, err = b.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(wanted2Pb, bPb), "Wanted: %v, received: %v", wanted2, b)
+			assert.Equal(t, true, proto.Equal(block2.Proto(), b.Proto()), "Wanted: %v, received: %v", block2, b)
 
 			_, roots, err = db.HighestRootsBelowSlot(ctx, 101)
 			require.NoError(t, err)
@@ -582,16 +542,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			root = roots[0]
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
-			wanted = block3
-			if _, err := block3.PbBellatrixBlock(); err == nil {
-				wanted, err = wanted.ToBlinded()
-				require.NoError(t, err)
-			}
-			wantedPb, err = wanted.Proto()
-			require.NoError(t, err)
-			bPb, err = b.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(wantedPb, bPb), "Wanted: %v, received: %v", wanted, b)
+			assert.Equal(t, true, proto.Equal(block3.Proto(), b.Proto()), "Wanted: %v, received: %v", block3, b)
 		})
 	}
 }
@@ -618,16 +569,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			root := roots[0]
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
-			wanted := block1
-			if _, err := block1.PbBellatrixBlock(); err == nil {
-				wanted, err = block1.ToBlinded()
-				require.NoError(t, err)
-			}
-			wantedPb, err := wanted.Proto()
-			require.NoError(t, err)
-			bPb, err := b.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(wantedPb, bPb), "Wanted: %v, received: %v", wanted, b)
+			assert.Equal(t, true, proto.Equal(block1.Proto(), b.Proto()), "Wanted: %v, received: %v", block1, b)
 
 			_, roots, err = db.HighestRootsBelowSlot(ctx, 1)
 			require.NoError(t, err)
@@ -635,16 +577,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			root = roots[0]
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
-			wanted = genesisBlock
-			if _, err := genesisBlock.PbBellatrixBlock(); err == nil {
-				wanted, err = genesisBlock.ToBlinded()
-				require.NoError(t, err)
-			}
-			wantedPb, err = wanted.Proto()
-			require.NoError(t, err)
-			bPb, err = b.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(wantedPb, bPb), "Wanted: %v, received: %v", wanted, b)
+			assert.Equal(t, true, proto.Equal(genesisBlock.Proto(), b.Proto()), "Wanted: %v, received: %v", genesisBlock, b)
 
 			_, roots, err = db.HighestRootsBelowSlot(ctx, 0)
 			require.NoError(t, err)
@@ -652,16 +585,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			root = roots[0]
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
-			wanted = genesisBlock
-			if _, err := genesisBlock.PbBellatrixBlock(); err == nil {
-				wanted, err = genesisBlock.ToBlinded()
-				require.NoError(t, err)
-			}
-			wantedPb, err = wanted.Proto()
-			require.NoError(t, err)
-			bPb, err = b.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(wantedPb, bPb), "Wanted: %v, received: %v", wanted, b)
+			assert.Equal(t, true, proto.Equal(genesisBlock.Proto(), b.Proto()), "Wanted: %v, received: %v", genesisBlock, b)
 		})
 	}
 }
@@ -747,43 +671,15 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			assert.Equal(t, 0, len(retrievedBlocks), "Unexpected number of blocks received, expected none")
 			retrievedBlocks, err = db.BlocksBySlot(ctx, 20)
 			require.NoError(t, err)
-
-			wanted := b1
-			if _, err := b1.PbBellatrixBlock(); err == nil {
-				wanted, err = b1.ToBlinded()
-				require.NoError(t, err)
-			}
-			retrieved0Pb, err := retrievedBlocks[0].Proto()
-			require.NoError(t, err)
-			wantedPb, err := wanted.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(retrieved0Pb, wantedPb), "Wanted: %v, received: %v", retrievedBlocks[0], wanted)
+			assert.Equal(t, true, proto.Equal(b1.Proto(), retrievedBlocks[0].Proto()), "Wanted: %v, received: %v", b1, retrievedBlocks[0])
 			assert.Equal(t, true, len(retrievedBlocks) > 0, "Expected to have blocks")
 			retrievedBlocks, err = db.BlocksBySlot(ctx, 100)
 			require.NoError(t, err)
 			if len(retrievedBlocks) != 2 {
 				t.Fatalf("Expected 2 blocks, received %d blocks", len(retrievedBlocks))
 			}
-			wanted = b2
-			if _, err := b2.PbBellatrixBlock(); err == nil {
-				wanted, err = b2.ToBlinded()
-				require.NoError(t, err)
-			}
-			retrieved0Pb, err = retrievedBlocks[0].Proto()
-			require.NoError(t, err)
-			wantedPb, err = wanted.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(wantedPb, retrieved0Pb), "Wanted: %v, received: %v", retrievedBlocks[0], wanted)
-			wanted = b3
-			if _, err := b3.PbBellatrixBlock(); err == nil {
-				wanted, err = b3.ToBlinded()
-				require.NoError(t, err)
-			}
-			retrieved1Pb, err := retrievedBlocks[1].Proto()
-			require.NoError(t, err)
-			wantedPb, err = wanted.Proto()
-			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(retrieved1Pb, wantedPb), "Wanted: %v, received: %v", retrievedBlocks[1], wanted)
+			assert.Equal(t, true, proto.Equal(b2.Proto(), retrievedBlocks[0].Proto()), "Wanted: %v, received: %v", b2, retrievedBlocks[0])
+			assert.Equal(t, true, proto.Equal(b3.Proto(), retrievedBlocks[1].Proto()), "Wanted: %v, received: %v", b3, retrievedBlocks[1])
 			assert.Equal(t, true, len(retrievedBlocks) > 0, "Expected to have blocks")
 
 			hasBlockRoots, retrievedBlockRoots, err := db.BlockRootsBySlot(ctx, 1)

beacon-chain/db/kv/checkpoint.go

@@ -2,9 +2,8 @@ package kv
 
 import (
 	"context"
-	"fmt"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -12,7 +11,7 @@ import (
 	"go.opencensus.io/trace"
 )
 
-var errMissingStateForCheckpoint = errors.New("missing state summary for checkpoint root")
+var errMissingStateForCheckpoint = errors.New("missing state summary for finalized root")
 
 // JustifiedCheckpoint returns the latest justified checkpoint in beacon chain.
 func (s *Store) JustifiedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error) {
@@ -64,10 +63,7 @@ func (s *Store) SaveJustifiedCheckpoint(ctx context.Context, checkpoint *ethpb.C
 		hasStateSummary := s.hasStateSummaryBytes(tx, bytesutil.ToBytes32(checkpoint.Root))
 		hasStateInDB := tx.Bucket(stateBucket).Get(checkpoint.Root) != nil
 		if !(hasStateInDB || hasStateSummary) {
-			log.Warnf("Recovering state summary for justified root: %#x", bytesutil.Trunc(checkpoint.Root))
-			if err := recoverStateSummary(ctx, tx, checkpoint.Root); err != nil {
-				return errors.Wrapf(errMissingStateForCheckpoint, "could not save justified checkpoint, finalized root: %#x", bytesutil.Trunc(checkpoint.Root))
-			}
+			return errMissingStateForCheckpoint
 		}
 		return bucket.Put(justifiedCheckpointKey, enc)
 	})
@@ -87,10 +83,7 @@ func (s *Store) SaveFinalizedCheckpoint(ctx context.Context, checkpoint *ethpb.C
 		hasStateSummary := s.hasStateSummaryBytes(tx, bytesutil.ToBytes32(checkpoint.Root))
 		hasStateInDB := tx.Bucket(stateBucket).Get(checkpoint.Root) != nil
 		if !(hasStateInDB || hasStateSummary) {
-			log.Warnf("Recovering state summary for finalized root: %#x", bytesutil.Trunc(checkpoint.Root))
-			if err := recoverStateSummary(ctx, tx, checkpoint.Root); err != nil {
-				return errors.Wrapf(errMissingStateForCheckpoint, "could not save finalized checkpoint, finalized root: %#x", bytesutil.Trunc(checkpoint.Root))
-			}
+			return errMissingStateForCheckpoint
 		}
 		if err := bucket.Put(finalizedCheckpointKey, enc); err != nil {
 			return err
@@ -99,25 +92,3 @@ func (s *Store) SaveFinalizedCheckpoint(ctx context.Context, checkpoint *ethpb.C
 		return s.updateFinalizedBlockRoots(ctx, tx, checkpoint)
 	})
 }
-
-// Recovers and saves state summary for a given root if the root has a block in the DB.
-func recoverStateSummary(ctx context.Context, tx *bolt.Tx, root []byte) error {
-	blkBucket := tx.Bucket(blocksBucket)
-	blkEnc := blkBucket.Get(root)
-	if blkEnc == nil {
-		return fmt.Errorf("nil block, root: %#x", bytesutil.Trunc(root))
-	}
-	blk, err := unmarshalBlock(ctx, blkEnc)
-	if err != nil {
-		return errors.Wrapf(err, "Could not unmarshal block: %#x", bytesutil.Trunc(root))
-	}
-	summaryEnc, err := encode(ctx, &ethpb.StateSummary{
-		Slot: blk.Block().Slot(),
-		Root: root,
-	})
-	if err != nil {
-		return err
-	}
-	summaryBucket := tx.Bucket(stateBucket)
-	return summaryBucket.Put(root, summaryEnc)
-}

beacon-chain/db/kv/checkpoint_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/testing/assert"
@@ -33,25 +33,6 @@ func TestStore_JustifiedCheckpoint_CanSaveRetrieve(t *testing.T) {
 	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
 }
 
-func TestStore_JustifiedCheckpoint_Recover(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	blk := util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
-	r, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	cp := &ethpb.Checkpoint{
-		Epoch: 2,
-		Root:  r[:],
-	}
-	wb, err := blocks.NewSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wb))
-	require.NoError(t, db.SaveJustifiedCheckpoint(ctx, cp))
-	retrieved, err := db.JustifiedCheckpoint(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
-}
-
 func TestStore_FinalizedCheckpoint_CanSaveRetrieve(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
@@ -72,7 +53,7 @@ func TestStore_FinalizedCheckpoint_CanSaveRetrieve(t *testing.T) {
 	}
 
 	// a valid chain is required to save finalized checkpoint.
-	wsb, err := blocks.NewSignedBeaconBlock(blk)
+	wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
 	require.NoError(t, err)
 	require.NoError(t, db.SaveBlock(ctx, wsb))
 	st, err := util.NewBeaconState()
@@ -88,26 +69,6 @@ func TestStore_FinalizedCheckpoint_CanSaveRetrieve(t *testing.T) {
 	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
 }
 
-func TestStore_FinalizedCheckpoint_Recover(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	blk := util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
-	r, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	cp := &ethpb.Checkpoint{
-		Epoch: 2,
-		Root:  r[:],
-	}
-	wb, err := blocks.NewSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveGenesisBlockRoot(ctx, r))
-	require.NoError(t, db.SaveBlock(ctx, wb))
-	require.NoError(t, db.SaveFinalizedCheckpoint(ctx, cp))
-	retrieved, err := db.FinalizedCheckpoint(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
-}
-
 func TestStore_JustifiedCheckpoint_DefaultIsZeroHash(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()

beacon-chain/db/kv/deposit_contract.go

@@ -12,7 +12,7 @@ import (
 // DepositContractAddress returns contract address is the address of
 // the deposit contract on the proof of work chain.
 func (s *Store) DepositContractAddress(ctx context.Context) ([]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.DepositContractAddress")
+	_, span := trace.StartSpan(ctx, "BeaconDB.DepositContractAddress")
 	defer span.End()
 	var addr []byte
 	if err := s.db.View(func(tx *bolt.Tx) error {
@@ -27,7 +27,7 @@ func (s *Store) DepositContractAddress(ctx context.Context) ([]byte, error) {
 
 // SaveDepositContractAddress to the db. It returns an error if an address has been previously saved.
 func (s *Store) SaveDepositContractAddress(ctx context.Context, addr common.Address) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.VerifyContractAddress")
+	_, span := trace.StartSpan(ctx, "BeaconDB.VerifyContractAddress")
 	defer span.End()
 
 	return s.db.Update(func(tx *bolt.Tx) error {

beacon-chain/db/kv/encoding.go

@@ -13,7 +13,7 @@ import (
 )
 
 func decode(ctx context.Context, data []byte, dst proto.Message) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.decode")
+	_, span := trace.StartSpan(ctx, "BeaconDB.decode")
 	defer span.End()
 
 	data, err := snappy.Decode(nil, data)
@@ -27,7 +27,7 @@ func decode(ctx context.Context, data []byte, dst proto.Message) error {
 }
 
 func encode(ctx context.Context, msg proto.Message) ([]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.encode")
+	_, span := trace.StartSpan(ctx, "BeaconDB.encode")
 	defer span.End()
 
 	if msg == nil || reflect.ValueOf(msg).IsNil() {