Merge branch 'only-save-payload' into frank

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

WORKSPACE

@@ -231,7 +231,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "57120e8e2d5aaec956fc6a25ddc58fae2477f5b3ac7789174cf5ac1106dcc151",
+    sha256 = "9c93f87378aaa6d6fe1c67b396eac2aacc9594af2a83f028cb99c95dea5b81df",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -247,7 +247,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "aa46676b26c173274ec8ea8756ae3072474b73ef7ccc7414d4026884810d8de2",
+    sha256 = "52f2c52415228cee8a4de5a09abff785f439a77dfef8f03e834e4e16857673c1",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -263,7 +263,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "d7dba93110cf35d9575ce21af6b7c3989f4aba621a9749bc090bca216e0345f7",
+    sha256 = "022dcc0d6de7dd27b337a0d1b945077eaf5ee47000700395a693fc25e12f96df",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 

api/client/beacon/checkpoint.go

@@ -26,69 +26,126 @@ type OriginData struct {
 	bb  []byte
 	st  state.BeaconState
 	b   interfaces.SignedBeaconBlock
-	cf  *detect.VersionedUnmarshaler
-}
-
-// CheckpointString returns the standard string representation of a Checkpoint for the block root and epoch for the
-// SignedBeaconBlock value found by DownloadOriginData.
-// The format is a a hex-encoded block root, followed by the epoch of the block, separated by a colon. For example:
-// "0x1c35540cac127315fabb6bf29181f2ae0de1a3fc909d2e76ba771e61312cc49a:74888"
-func (od *OriginData) CheckpointString() string {
-	return fmt.Sprintf("%#x:%d", od.wsd.BlockRoot, od.wsd.Epoch)
+	vu  *detect.VersionedUnmarshaler
+	br  [32]byte
+	sr  [32]byte
 }
 
 // SaveBlock saves the downloaded block to a unique file in the given path.
 // For readability and collision avoidance, the file name includes: type, config name, slot and root
-func (od *OriginData) SaveBlock(dir string) (string, error) {
-	blockPath := path.Join(dir, fname("block", od.cf, od.b.Block().Slot(), od.wsd.BlockRoot))
-	return blockPath, file.WriteFile(blockPath, od.BlockBytes())
+func (o *OriginData) SaveBlock(dir string) (string, error) {
+	blockPath := path.Join(dir, fname("block", o.vu, o.b.Block().Slot(), o.br))
+	return blockPath, file.WriteFile(blockPath, o.BlockBytes())
 }
 
 // SaveState saves the downloaded state to a unique file in the given path.
 // For readability and collision avoidance, the file name includes: type, config name, slot and root
-func (od *OriginData) SaveState(dir string) (string, error) {
-	statePath := path.Join(dir, fname("state", od.cf, od.st.Slot(), od.wsd.StateRoot))
-	return statePath, file.WriteFile(statePath, od.StateBytes())
+func (o *OriginData) SaveState(dir string) (string, error) {
+	statePath := path.Join(dir, fname("state", o.vu, o.st.Slot(), o.sr))
+	return statePath, file.WriteFile(statePath, o.StateBytes())
 }
 
 // StateBytes returns the ssz-encoded bytes of the downloaded BeaconState value.
-func (od *OriginData) StateBytes() []byte {
-	return od.sb
+func (o *OriginData) StateBytes() []byte {
+	return o.sb
 }
 
 // BlockBytes returns the ssz-encoded bytes of the downloaded SignedBeaconBlock value.
-func (od *OriginData) BlockBytes() []byte {
-	return od.bb
+func (o *OriginData) BlockBytes() []byte {
+	return o.bb
 }
 
-func fname(prefix string, cf *detect.VersionedUnmarshaler, slot types.Slot, root [32]byte) string {
-	return fmt.Sprintf("%s_%s_%s_%d-%#x.ssz", prefix, cf.Config.ConfigName, version.String(cf.Fork), slot, root)
+func fname(prefix string, vu *detect.VersionedUnmarshaler, slot types.Slot, root [32]byte) string {
+	return fmt.Sprintf("%s_%s_%s_%d-%#x.ssz", prefix, vu.Config.ConfigName, version.String(vu.Fork), slot, root)
 }
 
-// this method downloads the head state, which can be used to find the correct chain config
-// and use prysm's helper methods to compute the latest weak subjectivity epoch.
-func getWeakSubjectivityEpochFromHead(ctx context.Context, client *Client) (types.Epoch, error) {
-	headBytes, err := client.GetState(ctx, IdHead)
+// DownloadFinalizedData downloads the most recently finalized state, and the block most recently applied to that state.
+// This pair can be used to initialize a new beacon node via checkpoint sync.
+func DownloadFinalizedData(ctx context.Context, client *Client) (*OriginData, error) {
+	sb, err := client.GetState(ctx, IdFinalized)
 	if err != nil {
-		return 0, err
+		return nil, err
 	}
-	cf, err := detect.FromState(headBytes)
+	vu, err := detect.FromState(sb)
 	if err != nil {
-		return 0, errors.Wrap(err, "error detecting chain config for beacon state")
+		return nil, errors.Wrap(err, "error detecting chain config for finalized state")
 	}
-	log.Printf("detected supported config in remote head state, name=%s, fork=%s", cf.Config.ConfigName, version.String(cf.Fork))
-	headState, err := cf.UnmarshalBeaconState(headBytes)
+	log.Printf("detected supported config in remote finalized state, name=%s, fork=%s", vu.Config.ConfigName, version.String(vu.Fork))
+	s, err := vu.UnmarshalBeaconState(sb)
 	if err != nil {
-		return 0, errors.Wrap(err, "error unmarshaling state to correct version")
+		return nil, errors.Wrap(err, "error unmarshaling finalized state to correct version")
 	}
 
-	epoch, err := helpers.LatestWeakSubjectivityEpoch(ctx, headState, cf.Config)
+	sr, err := s.HashTreeRoot(ctx)
 	if err != nil {
-		return 0, errors.Wrap(err, "error computing the weak subjectivity epoch from head state")
+		return nil, errors.Wrapf(err, "failed to compute htr for finalized state at slot=%d", s.Slot())
+	}
+	header := s.LatestBlockHeader()
+	header.StateRoot = sr[:]
+	br, err := header.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "error while computing block root using state data")
 	}
 
-	log.Printf("(computed client-side) weak subjectivity epoch = %d", epoch)
-	return epoch, nil
+	bb, err := client.GetBlock(ctx, IdFromRoot(br))
+	if err != nil {
+		return nil, errors.Wrapf(err, "error requesting block by root = %#x", br)
+	}
+	b, err := vu.UnmarshalBeaconBlock(bb)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
+	}
+	realBlockRoot, err := b.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "error computing hash_tree_root of retrieved block")
+	}
+
+	log.Printf("BeaconState slot=%d, Block slot=%d", s.Slot(), b.Block().Slot())
+	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", sr, b.Block().StateRoot())
+	log.Printf("BeaconState latest_block_header htr=%#xd, block htr=%#x", br, realBlockRoot)
+	return &OriginData{
+		st: s,
+		b:  b,
+		sb: sb,
+		bb: bb,
+		vu: vu,
+		br: br,
+		sr: sr,
+	}, nil
+}
+
+// WeakSubjectivityData represents the state root, block root and epoch of the BeaconState + SignedBeaconBlock
+// that falls at the beginning of the current weak subjectivity period. These values can be used to construct
+// a weak subjectivity checkpoint beacon node flag to be used for validation.
+type WeakSubjectivityData struct {
+	BlockRoot [32]byte
+	StateRoot [32]byte
+	Epoch     types.Epoch
+}
+
+// CheckpointString returns the standard string representation of a Checkpoint.
+// The format is a a hex-encoded block root, followed by the epoch of the block, separated by a colon. For example:
+// "0x1c35540cac127315fabb6bf29181f2ae0de1a3fc909d2e76ba771e61312cc49a:74888"
+func (wsd *WeakSubjectivityData) CheckpointString() string {
+	return fmt.Sprintf("%#x:%d", wsd.BlockRoot, wsd.Epoch)
+}
+
+// ComputeWeakSubjectivityCheckpoint attempts to use the prysm weak_subjectivity api
+// to obtain the current weak_subjectivity checkpoint.
+// For non-prysm nodes, the same computation will be performed with extra steps,
+// using the head state downloaded from the beacon node api.
+func ComputeWeakSubjectivityCheckpoint(ctx context.Context, client *Client) (*WeakSubjectivityData, error) {
+	ws, err := client.GetWeakSubjectivity(ctx)
+	if err != nil {
+		// a 404/405 is expected if querying an endpoint that doesn't support the weak subjectivity checkpoint api
+		if !errors.Is(err, ErrNotOK) {
+			return nil, errors.Wrap(err, "unexpected API response for prysm-only weak subjectivity checkpoint API")
+		}
+		// fall back to vanilla Beacon Node API method
+		return computeBackwardsCompatible(ctx, client)
+	}
+	log.Printf("server weak subjectivity checkpoint response - epoch=%d, block_root=%#x, state_root=%#x", ws.Epoch, ws.BlockRoot, ws.StateRoot)
+	return ws, nil
 }
 
 const (
@@ -96,8 +153,8 @@ const (
 	prysmImplementationName = "Prysm"
 )
 
-// ErrUnsupportedPrysmCheckpointVersion indicates remote beacon node can't be used for checkpoint retrieval.
-var ErrUnsupportedPrysmCheckpointVersion = errors.New("node does not meet minimum version requirements for checkpoint retrieval")
+// errUnsupportedPrysmCheckpointVersion indicates remote beacon node can't be used for checkpoint retrieval.
+var errUnsupportedPrysmCheckpointVersion = errors.New("node does not meet minimum version requirements for checkpoint retrieval")
 
 // for older endpoints or clients that do not support the weak_subjectivity api method
 // we gather the necessary data for a checkpoint sync by:
@@ -105,14 +162,14 @@ var ErrUnsupportedPrysmCheckpointVersion = errors.New("node does not meet minimu
 // - requesting the state at the first slot of the epoch
 // - using hash_tree_root(state.latest_block_header) to compute the block the state integrates
 // - requesting that block by its root
-func downloadBackwardsCompatible(ctx context.Context, client *Client) (*OriginData, error) {
+func computeBackwardsCompatible(ctx context.Context, client *Client) (*WeakSubjectivityData, error) {
 	log.Print("falling back to generic checkpoint derivation, weak_subjectivity API not supported by server")
 	nv, err := client.GetNodeVersion(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "unable to proceed with fallback method without confirming node version")
 	}
 	if nv.implementation == prysmImplementationName && semver.Compare(nv.semver, prysmMinimumVersion) < 0 {
-		return nil, errors.Wrapf(ErrUnsupportedPrysmCheckpointVersion, "%s < minimum (%s)", nv.semver, prysmMinimumVersion)
+		return nil, errors.Wrapf(errUnsupportedPrysmCheckpointVersion, "%s < minimum (%s)", nv.semver, prysmMinimumVersion)
 	}
 	epoch, err := getWeakSubjectivityEpochFromHead(ctx, client)
 	if err != nil {
@@ -127,136 +184,78 @@ func downloadBackwardsCompatible(ctx context.Context, client *Client) (*OriginDa
 
 	log.Printf("requesting checkpoint state at slot %d", slot)
 	// get the state at the first slot of the epoch
-	stateBytes, err := client.GetState(ctx, IdFromSlot(slot))
+	sb, err := client.GetState(ctx, IdFromSlot(slot))
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to request state by slot from api, slot=%d", slot)
 	}
 
 	// ConfigFork is used to unmarshal the BeaconState so we can read the block root in latest_block_header
-	cf, err := detect.FromState(stateBytes)
+	vu, err := detect.FromState(sb)
 	if err != nil {
 		return nil, errors.Wrap(err, "error detecting chain config for beacon state")
 	}
-	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", cf.Config.ConfigName, version.String(cf.Fork))
+	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", vu.Config.ConfigName, version.String(vu.Fork))
 
-	st, err := cf.UnmarshalBeaconState(stateBytes)
+	s, err := vu.UnmarshalBeaconState(sb)
 	if err != nil {
 		return nil, errors.Wrap(err, "error using detected config fork to unmarshal state bytes")
 	}
 
 	// compute state and block roots
-	stateRoot, err := st.HashTreeRoot(ctx)
+	sr, err := s.HashTreeRoot(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "error computing hash_tree_root of state")
 	}
 
-	header := st.LatestBlockHeader()
-	header.StateRoot = stateRoot[:]
-	computedBlockRoot, err := header.HashTreeRoot()
+	h := s.LatestBlockHeader()
+	h.StateRoot = sr[:]
+	br, err := h.HashTreeRoot()
 	if err != nil {
 		return nil, errors.Wrap(err, "error while computing block root using state data")
 	}
 
-	blockBytes, err := client.GetBlock(ctx, IdFromRoot(computedBlockRoot))
+	bb, err := client.GetBlock(ctx, IdFromRoot(br))
 	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting block by root = %d", computedBlockRoot)
+		return nil, errors.Wrapf(err, "error requesting block by root = %d", br)
 	}
-	block, err := cf.UnmarshalBeaconBlock(blockBytes)
+	b, err := vu.UnmarshalBeaconBlock(bb)
 	if err != nil {
 		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
 	}
-	blockRoot, err := block.Block().HashTreeRoot()
+	br, err = b.Block().HashTreeRoot()
 	if err != nil {
 		return nil, errors.Wrap(err, "error computing hash_tree_root for block obtained via root")
 	}
 
-	log.Printf("BeaconState slot=%d, Block slot=%d", st.Slot(), block.Block().Slot())
-	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", stateRoot, block.Block().StateRoot())
-	log.Printf("BeaconBlock root computed from state=%#x, Block htr=%#x", computedBlockRoot, blockRoot)
-
-	return &OriginData{
-		wsd: &WeakSubjectivityData{
-			BlockRoot: blockRoot,
-			StateRoot: stateRoot,
-			Epoch:     epoch,
-		},
-		st: st,
-		sb: stateBytes,
-		b:  block,
-		bb: blockBytes,
-		cf: cf,
+	return &WeakSubjectivityData{
+		Epoch:     epoch,
+		BlockRoot: br,
+		StateRoot: sr,
 	}, nil
 }
 
-// DownloadOriginData attempts to use the proposed weak_subjectivity beacon node api
-// to obtain the weak_subjectivity metadata (epoch, block_root, state_root) needed to sync
-// a beacon node from the canonical weak subjectivity checkpoint. As this is a proposed API
-// that will only be supported by prysm at first, in the event of a 404 we fallback to using a
-// different technique where we first download the head state which can be used to compute the
-// weak subjectivity epoch on the client side.
-func DownloadOriginData(ctx context.Context, client *Client) (*OriginData, error) {
-	ws, err := client.GetWeakSubjectivity(ctx)
+// this method downloads the head state, which can be used to find the correct chain config
+// and use prysm's helper methods to compute the latest weak subjectivity epoch.
+func getWeakSubjectivityEpochFromHead(ctx context.Context, client *Client) (types.Epoch, error) {
+	headBytes, err := client.GetState(ctx, IdHead)
 	if err != nil {
-		// a 404/405 is expected if querying an endpoint that doesn't support the weak subjectivity checkpoint api
-		if !errors.Is(err, ErrNotOK) {
-			return nil, errors.Wrap(err, "unexpected API response for prysm-only weak subjectivity checkpoint API")
-		}
-		// fall back to vanilla Beacon Node API method
-		return downloadBackwardsCompatible(ctx, client)
+		return 0, err
 	}
-	log.Printf("server weak subjectivity checkpoint response - epoch=%d, block_root=%#x, state_root=%#x", ws.Epoch, ws.BlockRoot, ws.StateRoot)
-
-	// use first slot of the epoch for the block slot
-	slot, err := slots.EpochStart(ws.Epoch)
+	vu, err := detect.FromState(headBytes)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error computing first slot of epoch=%d", ws.Epoch)
+		return 0, errors.Wrap(err, "error detecting chain config for beacon state")
 	}
-	log.Printf("requesting checkpoint state at slot %d", slot)
-
-	stateBytes, err := client.GetState(ctx, IdFromSlot(slot))
+	log.Printf("detected supported config in remote head state, name=%s, fork=%s", vu.Config.ConfigName, version.String(vu.Fork))
+	headState, err := vu.UnmarshalBeaconState(headBytes)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to request state by slot from api, slot=%d", slot)
-	}
-	cf, err := detect.FromState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error detecting chain config for beacon state")
-	}
-	log.Printf("detected supported config in checkpoint state, name=%s, fork=%s", cf.Config.ConfigName, version.String(cf.Fork))
-
-	state, err := cf.UnmarshalBeaconState(stateBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "error using detected config fork to unmarshal state bytes")
-	}
-	stateRoot, err := state.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to compute htr for state at slot=%d", slot)
+		return 0, errors.Wrap(err, "error unmarshaling state to correct version")
 	}
 
-	blockRoot, err := state.LatestBlockHeader().HashTreeRoot()
+	epoch, err := helpers.LatestWeakSubjectivityEpoch(ctx, headState, vu.Config)
 	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of latest_block_header")
+		return 0, errors.Wrap(err, "error computing the weak subjectivity epoch from head state")
 	}
-	blockBytes, err := client.GetBlock(ctx, IdFromRoot(ws.BlockRoot))
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting block by slot = %d", slot)
-	}
-	block, err := cf.UnmarshalBeaconBlock(blockBytes)
-	if err != nil {
-		return nil, errors.Wrap(err, "unable to unmarshal block to a supported type using the detected fork schedule")
-	}
-	realBlockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "error computing hash_tree_root of retrieved block")
-	}
-	log.Printf("BeaconState slot=%d, Block slot=%d", state.Slot(), block.Block().Slot())
-	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", stateRoot, block.Block().StateRoot())
-	log.Printf("BeaconState latest_block_header htr=%#xd, block htr=%#x", blockRoot, realBlockRoot)
-	return &OriginData{
-		wsd: ws,
-		st:  state,
-		b:   block,
-		sb:  stateBytes,
-		bb:  blockBytes,
-		cf:  cf,
-	}, nil
+
+	log.Printf("(computed client-side) weak subjectivity epoch = %d", epoch)
+	return epoch, nil
 }

api/client/beacon/checkpoint_test.go

@@ -93,8 +93,8 @@ func TestFallbackVersionCheck(t *testing.T) {
 	}}
 
 	ctx := context.Background()
-	_, err := DownloadOriginData(ctx, c)
-	require.ErrorIs(t, err, ErrUnsupportedPrysmCheckpointVersion)
+	_, err := ComputeWeakSubjectivityCheckpoint(ctx, c)
+	require.ErrorIs(t, err, errUnsupportedPrysmCheckpointVersion)
 }
 
 func TestFname(t *testing.T) {
@@ -120,9 +120,9 @@ func TestFname(t *testing.T) {
 	require.Equal(t, expected, actual)
 }
 
-func TestDownloadOriginData(t *testing.T) {
+func TestDownloadWeakSubjectivityCheckpoint(t *testing.T) {
 	ctx := context.Background()
-	cfg := params.MainnetConfig()
+	cfg := params.MainnetConfig().Copy()
 
 	epoch := cfg.AltairForkEpoch - 1
 	// set up checkpoint state, using the epoch that will be computed as the ws checkpoint state based on the head state
@@ -204,19 +204,15 @@ func TestDownloadOriginData(t *testing.T) {
 		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
 	}
 
-	od, err := DownloadOriginData(ctx, c)
+	wsd, err := ComputeWeakSubjectivityCheckpoint(ctx, c)
 	require.NoError(t, err)
-	require.Equal(t, expectedWSD.Epoch, od.wsd.Epoch)
-	require.Equal(t, expectedWSD.StateRoot, od.wsd.StateRoot)
-	require.Equal(t, expectedWSD.BlockRoot, od.wsd.BlockRoot)
-	require.DeepEqual(t, wsSerialized, od.sb)
-	require.DeepEqual(t, serBlock, od.bb)
-	require.DeepEqual(t, wst.Fork().CurrentVersion, od.cf.Version[:])
-	require.DeepEqual(t, version.Phase0, od.cf.Fork)
+	require.Equal(t, expectedWSD.Epoch, wsd.Epoch)
+	require.Equal(t, expectedWSD.StateRoot, wsd.StateRoot)
+	require.Equal(t, expectedWSD.BlockRoot, wsd.BlockRoot)
 }
 
-// runs downloadBackwardsCompatible directly
-// and via DownloadOriginData with a round tripper that triggers the backwards compatible code path
+// runs computeBackwardsCompatible directly
+// and via ComputeWeakSubjectivityCheckpoint with a round tripper that triggers the backwards compatible code path
 func TestDownloadBackwardsCompatibleCombined(t *testing.T) {
 	ctx := context.Background()
 	cfg := params.MainnetConfig()
@@ -297,16 +293,12 @@ func TestDownloadBackwardsCompatibleCombined(t *testing.T) {
 		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
 	}
 
-	odPub, err := DownloadOriginData(ctx, c)
+	wsPub, err := ComputeWeakSubjectivityCheckpoint(ctx, c)
 	require.NoError(t, err)
 
-	odPriv, err := downloadBackwardsCompatible(ctx, c)
+	wsPriv, err := computeBackwardsCompatible(ctx, c)
 	require.NoError(t, err)
-	require.DeepEqual(t, odPriv.wsd, odPub.wsd)
-	require.DeepEqual(t, odPriv.sb, odPub.sb)
-	require.DeepEqual(t, odPriv.bb, odPub.bb)
-	require.DeepEqual(t, odPriv.cf.Fork, odPub.cf.Fork)
-	require.DeepEqual(t, odPriv.cf.Version, odPub.cf.Version)
+	require.DeepEqual(t, wsPriv, wsPub)
 }
 
 func TestGetWeakSubjectivityEpochFromHead(t *testing.T) {
@@ -402,3 +394,94 @@ func populateValidators(cfg *params.BeaconChainConfig, st state.BeaconState, val
 
 	return nil
 }
+
+func TestDownloadFinalizedData(t *testing.T) {
+	ctx := context.Background()
+	cfg := params.MainnetConfig().Copy()
+
+	// avoid the altair zone because genesis tests are easier to set up
+	epoch := cfg.AltairForkEpoch - 1
+	// set up checkpoint state, using the epoch that will be computed as the ws checkpoint state based on the head state
+	slot, err := slots.EpochStart(epoch)
+	require.NoError(t, err)
+	st, err := util.NewBeaconState()
+	require.NoError(t, err)
+	fork, err := forkForEpoch(cfg, epoch)
+	require.NoError(t, st.SetFork(fork))
+
+	// set up checkpoint block
+	b, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
+	require.NoError(t, wrapper.SetBlockParentRoot(b, cfg.ZeroHash))
+	require.NoError(t, wrapper.SetBlockSlot(b, 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()
+	require.NoError(t, err)
+	require.NoError(t, st.SetLatestBlockHeader(header.Header))
+
+	// order of operations can be confusing here:
+	// - when computing the state root, make sure block header is complete, EXCEPT the state root should be zero-value
+	// - before computing the block root (to match the request route), the block should include the state root
+	//   *computed from the state with a header that does not have a state root set yet*
+	sr, err := st.HashTreeRoot(ctx)
+	require.NoError(t, err)
+
+	require.NoError(t, wrapper.SetBlockStateRoot(b, sr))
+	mb, err := b.MarshalSSZ()
+	require.NoError(t, err)
+	br, err := b.Block().HashTreeRoot()
+	require.NoError(t, err)
+
+	ms, err := st.MarshalSSZ()
+	require.NoError(t, err)
+
+	hc := &http.Client{
+		Transport: &testRT{rt: func(req *http.Request) (*http.Response, error) {
+			res := &http.Response{Request: req}
+			switch req.URL.Path {
+			case renderGetStatePath(IdFinalized):
+				res.StatusCode = http.StatusOK
+				res.Body = io.NopCloser(bytes.NewBuffer(ms))
+			case renderGetBlockPath(IdFromRoot(br)):
+				res.StatusCode = http.StatusOK
+				res.Body = io.NopCloser(bytes.NewBuffer(mb))
+			default:
+				res.StatusCode = http.StatusInternalServerError
+				res.Body = io.NopCloser(bytes.NewBufferString(""))
+			}
+
+			return res, nil
+		}},
+	}
+	c := &Client{
+		hc:      hc,
+		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+	}
+
+	// sanity check before we go through checkpoint
+	// make sure we can download the state and unmarshal it with the VersionedUnmarshaler
+	sb, err := c.GetState(ctx, IdFinalized)
+	require.NoError(t, err)
+	require.Equal(t, true, bytes.Equal(sb, ms))
+	vu, err := detect.FromState(sb)
+	require.NoError(t, err)
+	us, err := vu.UnmarshalBeaconState(sb)
+	require.NoError(t, err)
+	ushtr, err := us.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	require.Equal(t, sr, ushtr)
+
+	expected := &OriginData{
+		sb: ms,
+		bb: mb,
+		br: br,
+		sr: sr,
+	}
+	od, err := DownloadFinalizedData(ctx, c)
+	require.NoError(t, err)
+	require.Equal(t, true, bytes.Equal(expected.sb, od.sb))
+	require.Equal(t, true, bytes.Equal(expected.bb, od.bb))
+	require.Equal(t, expected.br, od.br)
+	require.Equal(t, expected.sr, od.sr)
+}

api/client/beacon/client.go

@@ -46,8 +46,9 @@ const (
 type StateOrBlockId string
 
 const (
-	IdGenesis StateOrBlockId = "genesis"
-	IdHead    StateOrBlockId = "head"
+	IdGenesis   StateOrBlockId = "genesis"
+	IdHead      StateOrBlockId = "head"
+	IdFinalized StateOrBlockId = "finalized"
 )
 
 var ErrMalformedHostname = errors.New("hostname must include port, separated by one colon, like example.com:3500")
@@ -344,16 +345,6 @@ func (c *Client) GetWeakSubjectivity(ctx context.Context) (*WeakSubjectivityData
 	}, nil
 }
 
-// WeakSubjectivityData represents the state root, block root and epoch of the BeaconState + SignedBeaconBlock
-// that falls at the beginning of the current weak subjectivity period. These values can be used to construct
-// a weak subjectivity checkpoint, or to download a BeaconState+SignedBeaconBlock pair that can be used to bootstrap
-// a new Beacon Node using Checkpoint Sync.
-type WeakSubjectivityData struct {
-	BlockRoot [32]byte
-	StateRoot [32]byte
-	Epoch     types.Epoch
-}
-
 func non200Err(response *http.Response) error {
 	bodyBytes, err := io.ReadAll(response.Body)
 	var body string

beacon-chain/blockchain/execution_engine.go

@@ -142,14 +142,7 @@ func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, er
 	if err != nil {
 		return [32]byte{}, err
 	}
-	if blocks.IsPreBellatrixVersion(blk.Block().Version()) {
-		return params.BeaconConfig().ZeroHash, nil
-	}
-	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 getBlockPayloadHash(blk.Block())
 }
 
 // notifyForkchoiceUpdate signals execution engine on a new payload.

beacon-chain/blockchain/process_block.go

@@ -118,7 +118,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 verify new payload")
+		return fmt.Errorf("could not verify new payload: %v", err)
 	}
 	if isValidPayload {
 		if err := s.validateMergeTransitionBlock(ctx, preStateVersion, preStateHeader, signed); err != nil {
@@ -622,15 +622,24 @@ func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashing
 }
 
 func getBlockPayloadHash(blk interfaces.BeaconBlock) ([32]byte, error) {
-	payloadHash := [32]byte{}
+	var blockHashFromPayload [32]byte
 	if blocks.IsPreBellatrixVersion(blk.Version()) {
-		return payloadHash, nil
+		return blockHashFromPayload, nil
 	}
 	payload, err := blk.Body().ExecutionPayload()
-	if err != nil {
-		return payloadHash, err
+	switch {
+	case errors.Is(err, wrapper.ErrUnsupportedField):
+		payloadHeader, err := blk.Body().ExecutionPayloadHeader()
+		if err != nil {
+			return blockHashFromPayload, err
+		}
+		blockHashFromPayload = bytesutil.ToBytes32(payloadHeader.BlockHash)
+	case err != nil:
+		return blockHashFromPayload, err
+	default:
+		blockHashFromPayload = bytesutil.ToBytes32(payload.BlockHash)
 	}
-	return bytesutil.ToBytes32(payload.BlockHash), nil
+	return blockHashFromPayload, nil
 }
 
 // This saves post state info to DB or cache. This also saves post state info to fork choice store.

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -238,7 +238,7 @@ func ProcessOperationsNoVerifyAttsSigs(
 		if err != nil {
 			return nil, err
 		}
-	case version.Altair, version.Bellatrix:
+	case version.Altair, version.Bellatrix, version.BellatrixBlind:
 		state, err = altairOperations(ctx, state, signedBeaconBlock)
 		if err != nil {
 			return nil, err

beacon-chain/db/kv/blocks.go

@@ -700,11 +700,6 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.SignedBeaconBlock
 		if err := rawBlock.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
 			return nil, err
 		}
-	case hasBellatrixKey(enc):
-		rawBlock = &ethpb.SignedBeaconBlockBellatrix{}
-		if err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):]); err != nil {
-			return nil, err
-		}
 	case hasBellatrixBlindKey(enc):
 		rawBlock = &ethpb.SignedBlindedBeaconBlockBellatrix{}
 		if err := rawBlock.UnmarshalSSZ(enc[len(bellatrixBlindKey):]); err != nil {
@@ -722,19 +717,34 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.SignedBeaconBlock
 
 // marshal versioned beacon block from struct type down to bytes.
 func marshalBlock(_ context.Context, blk interfaces.SignedBeaconBlock) ([]byte, error) {
-	obj, err := blk.MarshalSSZ()
-	if err != nil {
+	var encodedBlock []byte
+	var blindedBlock interfaces.SignedBeaconBlock
+	var err error
+	// If the block supports blinding of execution payloads, we wrap as
+	// a signed, blinded beacon block and then marshal to bytes. Otherwise,
+	// We just marshal the block as it is.
+	blindedBlock, err = wrapper.WrapSignedBlindedBeaconBlock(blk)
+	switch {
+	case errors.Is(err, wrapper.ErrUnsupportedSignedBeaconBlock):
+		encodedBlock, err = blk.MarshalSSZ()
+		if err != nil {
+			return nil, err
+		}
+	case err != nil:
 		return nil, err
+	default:
+		encodedBlock, err = blindedBlock.MarshalSSZ()
+		if err != nil {
+			return nil, err
+		}
 	}
 	switch blk.Version() {
-	case version.BellatrixBlind:
-		return snappy.Encode(nil, append(bellatrixBlindKey, obj...)), nil
-	case version.Bellatrix:
-		return snappy.Encode(nil, append(bellatrixKey, obj...)), nil
+	case version.Bellatrix, version.BellatrixBlind:
+		return snappy.Encode(nil, append(bellatrixBlindKey, encodedBlock...)), nil
 	case version.Altair:
-		return snappy.Encode(nil, append(altairKey, obj...)), nil
+		return snappy.Encode(nil, append(altairKey, encodedBlock...)), nil
 	case version.Phase0:
-		return snappy.Encode(nil, obj), nil
+		return snappy.Encode(nil, encodedBlock), nil
 	default:
 		return nil, errors.New("Unknown block version")
 	}

beacon-chain/node/config.go

@@ -129,6 +129,25 @@ func configureInteropConfig(cliCtx *cli.Context) error {
 }
 
 func configureExecutionSetting(cliCtx *cli.Context) error {
+	if cliCtx.IsSet(flags.TerminalTotalDifficultyOverride.Name) {
+		c := params.BeaconConfig()
+		c.TerminalTotalDifficulty = cliCtx.String(flags.TerminalTotalDifficultyOverride.Name)
+		log.WithField("terminal block difficult", c.TerminalTotalDifficulty).Warn("Terminal block difficult overridden")
+		params.OverrideBeaconConfig(c)
+	}
+	if cliCtx.IsSet(flags.TerminalBlockHashOverride.Name) {
+		c := params.BeaconConfig()
+		c.TerminalBlockHash = common.HexToHash(cliCtx.String(flags.TerminalBlockHashOverride.Name))
+		log.WithField("terminal block hash", c.TerminalBlockHash.Hex()).Warn("Terminal block hash overridden")
+		params.OverrideBeaconConfig(c)
+	}
+	if cliCtx.IsSet(flags.TerminalBlockHashActivationEpochOverride.Name) {
+		c := params.BeaconConfig()
+		c.TerminalBlockHashActivationEpoch = types.Epoch(cliCtx.Uint64(flags.TerminalBlockHashActivationEpochOverride.Name))
+		log.WithField("terminal block hash activation epoch", c.TerminalBlockHashActivationEpoch).Warn("Terminal block hash activation epoch overridden")
+		params.OverrideBeaconConfig(c)
+	}
+
 	if !cliCtx.IsSet(flags.SuggestedFeeRecipient.Name) {
 		return nil
 	}

beacon-chain/node/config_test.go

@@ -92,6 +92,13 @@ func TestConfigureExecutionSetting(t *testing.T) {
 	app := cli.App{}
 	set := flag.NewFlagSet("test", 0)
 	set.String(flags.SuggestedFeeRecipient.Name, "", "")
+	set.Uint64(flags.TerminalTotalDifficultyOverride.Name, 0, "")
+	set.String(flags.TerminalBlockHashOverride.Name, "", "")
+	set.Uint64(flags.TerminalBlockHashActivationEpochOverride.Name, 0, "")
+
+	require.NoError(t, set.Set(flags.TerminalTotalDifficultyOverride.Name, strconv.Itoa(100)))
+	require.NoError(t, set.Set(flags.TerminalBlockHashOverride.Name, "0xA"))
+	require.NoError(t, set.Set(flags.TerminalBlockHashActivationEpochOverride.Name, strconv.Itoa(200)))
 	require.NoError(t, set.Set(flags.SuggestedFeeRecipient.Name, "0xB"))
 	cliCtx := cli.NewContext(&app, set, nil)
 	err := configureExecutionSetting(cliCtx)
@@ -112,6 +119,10 @@ func TestConfigureExecutionSetting(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, common.HexToAddress("0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa"), params.BeaconConfig().DefaultFeeRecipient)
 
+	assert.Equal(t, "100", params.BeaconConfig().TerminalTotalDifficulty)
+	assert.Equal(t, common.HexToHash("0xA"), params.BeaconConfig().TerminalBlockHash)
+	assert.Equal(t, types.Epoch(200), params.BeaconConfig().TerminalBlockHashActivationEpoch)
+
 }
 
 func TestConfigureNetwork(t *testing.T) {

beacon-chain/node/node.go

@@ -678,6 +678,7 @@ func (b *BeaconNode) registerSyncService() error {
 		regularsync.WithStateGen(b.stateGen),
 		regularsync.WithSlasherAttestationsFeed(b.slasherAttestationsFeed),
 		regularsync.WithSlasherBlockHeadersFeed(b.slasherBlockHeadersFeed),
+		regularsync.WithExecutionPayloadReconstructor(web3Service),
 	)
 	return b.services.RegisterService(rs)
 }
@@ -783,48 +784,49 @@ func (b *BeaconNode) registerRPCService() error {
 
 	p2pService := b.fetchP2P()
 	rpcService := rpc.NewService(b.ctx, &rpc.Config{
-		Host:                    host,
-		Port:                    port,
-		BeaconMonitoringHost:    beaconMonitoringHost,
-		BeaconMonitoringPort:    beaconMonitoringPort,
-		CertFlag:                cert,
-		KeyFlag:                 key,
-		BeaconDB:                b.db,
-		Broadcaster:             p2pService,
-		PeersFetcher:            p2pService,
-		PeerManager:             p2pService,
-		MetadataProvider:        p2pService,
-		ChainInfoFetcher:        chainService,
-		HeadUpdater:             chainService,
-		HeadFetcher:             chainService,
-		CanonicalFetcher:        chainService,
-		ForkFetcher:             chainService,
-		FinalizationFetcher:     chainService,
-		BlockReceiver:           chainService,
-		AttestationReceiver:     chainService,
-		GenesisTimeFetcher:      chainService,
-		GenesisFetcher:          chainService,
-		OptimisticModeFetcher:   chainService,
-		AttestationsPool:        b.attestationPool,
-		ExitPool:                b.exitPool,
-		SlashingsPool:           b.slashingsPool,
-		SlashingChecker:         slasherService,
-		SyncCommitteeObjectPool: b.syncCommitteePool,
-		POWChainService:         web3Service,
-		POWChainInfoFetcher:     web3Service,
-		ChainStartFetcher:       chainStartFetcher,
-		MockEth1Votes:           mockEth1DataVotes,
-		SyncService:             syncService,
-		DepositFetcher:          depositFetcher,
-		PendingDepositFetcher:   b.depositCache,
-		BlockNotifier:           b,
-		StateNotifier:           b,
-		OperationNotifier:       b,
-		StateGen:                b.stateGen,
-		EnableDebugRPCEndpoints: enableDebugRPCEndpoints,
-		MaxMsgSize:              maxMsgSize,
-		ProposerIdsCache:        b.proposerIdsCache,
-		ExecutionEngineCaller:   web3Service,
+		Host:                          host,
+		Port:                          port,
+		BeaconMonitoringHost:          beaconMonitoringHost,
+		BeaconMonitoringPort:          beaconMonitoringPort,
+		CertFlag:                      cert,
+		KeyFlag:                       key,
+		BeaconDB:                      b.db,
+		Broadcaster:                   p2pService,
+		PeersFetcher:                  p2pService,
+		PeerManager:                   p2pService,
+		MetadataProvider:              p2pService,
+		ChainInfoFetcher:              chainService,
+		HeadUpdater:                   chainService,
+		HeadFetcher:                   chainService,
+		CanonicalFetcher:              chainService,
+		ForkFetcher:                   chainService,
+		FinalizationFetcher:           chainService,
+		BlockReceiver:                 chainService,
+		AttestationReceiver:           chainService,
+		GenesisTimeFetcher:            chainService,
+		GenesisFetcher:                chainService,
+		OptimisticModeFetcher:         chainService,
+		AttestationsPool:              b.attestationPool,
+		ExitPool:                      b.exitPool,
+		SlashingsPool:                 b.slashingsPool,
+		SlashingChecker:               slasherService,
+		SyncCommitteeObjectPool:       b.syncCommitteePool,
+		POWChainService:               web3Service,
+		POWChainInfoFetcher:           web3Service,
+		ChainStartFetcher:             chainStartFetcher,
+		MockEth1Votes:                 mockEth1DataVotes,
+		SyncService:                   syncService,
+		DepositFetcher:                depositFetcher,
+		PendingDepositFetcher:         b.depositCache,
+		BlockNotifier:                 b,
+		StateNotifier:                 b,
+		OperationNotifier:             b,
+		StateGen:                      b.stateGen,
+		EnableDebugRPCEndpoints:       enableDebugRPCEndpoints,
+		MaxMsgSize:                    maxMsgSize,
+		ProposerIdsCache:              b.proposerIdsCache,
+		ExecutionEngineCaller:         web3Service,
+		ExecutionPayloadReconstructor: web3Service,
 	})
 
 	return b.services.RegisterService(rpcService)

beacon-chain/powchain/BUILD.bazel

@@ -39,6 +39,8 @@ go_library(
         "//beacon-chain/state/v1:go_default_library",
         "//config/features:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//container/trie:go_default_library",
         "//contracts/deposit:go_default_library",
         "//crypto/hash:go_default_library",
@@ -101,6 +103,7 @@ go_test(
         "//beacon-chain/state/stategen:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params: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",

beacon-chain/powchain/engine_client.go

@@ -14,8 +14,11 @@ import (
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	pb "github.com/prysmaticlabs/prysm/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 )
@@ -46,6 +49,15 @@ type ForkchoiceUpdatedResponse struct {
 	PayloadId *pb.PayloadIDBytes `json:"payloadId"`
 }
 
+// ExecutionPayloadReconstructor defines a service that can reconstruct a full beacon
+// block with an execution payload from a signed beacon block and a connection
+// to an execution client's engine API.
+type ExecutionPayloadReconstructor interface {
+	ReconstructFullBellatrixBlock(
+		ctx context.Context, blindedBlock interfaces.SignedBeaconBlock,
+	) (interfaces.SignedBeaconBlock, error)
+}
+
 // EngineCaller defines a client that can interact with an Ethereum
 // execution node's engine service via JSON-RPC.
 type EngineCaller interface {
@@ -58,6 +70,7 @@ type EngineCaller interface {
 		ctx context.Context, cfg *pb.TransitionConfiguration,
 	) error
 	ExecutionBlockByHash(ctx context.Context, hash common.Hash) (*pb.ExecutionBlock, error)
+	ExecutionBlockByHashWithTxs(ctx context.Context, hash common.Hash) (*pb.ExecutionBlockWithTxs, error)
 	GetTerminalBlockHash(ctx context.Context) ([]byte, bool, error)
 }
 
@@ -284,19 +297,81 @@ func (s *Service) LatestExecutionBlock(ctx context.Context) (*pb.ExecutionBlock,
 func (s *Service) ExecutionBlockByHash(ctx context.Context, hash common.Hash) (*pb.ExecutionBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.ExecutionBlockByHash")
 	defer span.End()
-
 	result := &pb.ExecutionBlock{}
 	err := s.rpcClient.CallContext(ctx, result, ExecutionBlockByHashMethod, hash, false /* no full transaction objects */)
 	return result, handleRPCError(err)
 }
 
+// ExecutionBlockByHashWithTxs fetches an execution engine block by hash by calling
+// eth_blockByHash via JSON-RPC and asks for full transactions in the response.
+func (s *Service) ExecutionBlockByHashWithTxs(ctx context.Context, hash common.Hash) (*pb.ExecutionBlockWithTxs, error) {
+	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.ExecutionBlockByHash")
+	defer span.End()
+	start := time.Now()
+	defer func() {
+		executionBlockByHashWithTxsLatency.Observe(float64(time.Since(start).Milliseconds()))
+	}()
+
+	result := &pb.ExecutionBlockWithTxs{}
+	err := s.rpcClient.CallContext(ctx, result, ExecutionBlockByHashMethod, hash, true /* full transaction objects */)
+	return result, handleRPCError(err)
+}
+
+// ReconstructFullBellatrixBlock takes in a blinded beacon block and reconstructs
+// a beacon block with a full execution payload via the engine API.
+func (s *Service) ReconstructFullBellatrixBlock(
+	ctx context.Context, blindedBlock interfaces.SignedBeaconBlock,
+) (interfaces.SignedBeaconBlock, error) {
+	if err := wrapper.BeaconBlockIsNil(blindedBlock); err != nil {
+		return nil, errors.Wrap(err, "cannot reconstruct bellatrix block from nil data")
+	}
+	if !blindedBlock.Block().IsBlinded() {
+		return nil, errors.New("can only reconstruct block from blinded block format")
+	}
+	start := time.Now()
+	defer func() {
+		executionPayloadReconstructionLatency.Observe(float64(time.Since(start).Milliseconds()))
+		reconstructedExecutionPayloadCount.Add(1)
+	}()
+	header, err := blindedBlock.Block().Body().ExecutionPayloadHeader()
+	if err != nil {
+		return nil, err
+	}
+	executionBlockHash := common.BytesToHash(header.BlockHash)
+	executionBlock, err := s.ExecutionBlockByHashWithTxs(ctx, executionBlockHash)
+	if err != nil {
+		return nil, fmt.Errorf("could not fetch execution block with txs by hash %#x: %v", executionBlockHash, err)
+	}
+	payload := fullPayloadFromExecutionBlock(header, executionBlock)
+	return wrapper.BuildSignedBeaconBlockFromExecutionPayload(blindedBlock, payload)
+}
+
+func fullPayloadFromExecutionBlock(header *ethpb.ExecutionPayloadHeader, block *pb.ExecutionBlockWithTxs) *pb.ExecutionPayload {
+	return &pb.ExecutionPayload{
+		ParentHash:    header.ParentHash,
+		FeeRecipient:  header.FeeRecipient,
+		StateRoot:     header.StateRoot,
+		ReceiptsRoot:  header.ReceiptsRoot,
+		LogsBloom:     header.LogsBloom,
+		PrevRandao:    header.PrevRandao,
+		BlockNumber:   header.BlockNumber,
+		GasLimit:      header.GasLimit,
+		GasUsed:       header.GasUsed,
+		Timestamp:     header.Timestamp,
+		ExtraData:     header.ExtraData,
+		BaseFeePerGas: header.BaseFeePerGas,
+		BlockHash:     block.Hash,
+		Transactions:  block.Transactions,
+	}
+}
+
 // Handles errors received from the RPC server according to the specification.
 func handleRPCError(err error) error {
 	if err == nil {
 		return nil
 	}
 	if isTimeout(err) {
-		return errors.Wrapf(ErrHTTPTimeout, "%s", err)
+		return ErrHTTPTimeout
 	}
 	e, ok := err.(rpc.Error)
 	if !ok {
@@ -307,7 +382,7 @@ func handleRPCError(err error) error {
 				"here https://docs.prylabs.network/docs/execution-node/authentication")
 			return fmt.Errorf("could not authenticate connection to execution client: %v", err)
 		}
-		return errors.Wrap(err, "got an unexpected error")
+		return fmt.Errorf("got an unexpected error in JSON-RPC response: %v", err)
 	}
 	switch e.ErrorCode() {
 	case -32700:
@@ -330,7 +405,7 @@ func handleRPCError(err error) error {
 		// Only -32000 status codes are data errors in the RPC specification.
 		errWithData, ok := err.(rpc.DataError)
 		if !ok {
-			return errors.Wrap(err, "got an unexpected error")
+			return fmt.Errorf("got an unexpected error in JSON-RPC response: %v", err)
 		}
 		return errors.Wrapf(ErrServer, "%v", errWithData.ErrorData())
 	default:

beacon-chain/powchain/engine_client_test.go

@@ -12,20 +12,26 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
 	mocks "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	pb "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	"github.com/prysmaticlabs/prysm/testing/require"
+	"github.com/prysmaticlabs/prysm/testing/util"
 	"google.golang.org/protobuf/proto"
 )
 
 var (
 	_ = EngineCaller(&Service{})
+	_ = ExecutionPayloadReconstructor(&Service{})
 	_ = EngineCaller(&mocks.EngineClient{})
 )
 
@@ -534,6 +540,87 @@ func Test_tDStringToUint256(t *testing.T) {
 	require.ErrorContains(t, "hex number > 256 bits", err)
 }
 
+func TestReconstructFullBellatrixBlock(t *testing.T) {
+	ctx := context.Background()
+	t.Run("nil block", func(t *testing.T) {
+		service := &Service{}
+
+		_, err := service.ReconstructFullBellatrixBlock(ctx, nil)
+		require.ErrorContains(t, "nil data", err)
+	})
+	t.Run("only blinded block", func(t *testing.T) {
+		want := "can only reconstruct block from blinded block format"
+		service := &Service{}
+		bellatrixBlock := util.NewBeaconBlockBellatrix()
+		wrapped, err := wrapper.WrappedSignedBeaconBlock(bellatrixBlock)
+		require.NoError(t, err)
+		_, err = service.ReconstructFullBellatrixBlock(ctx, wrapped)
+		require.ErrorContains(t, want, err)
+	})
+	t.Run("properly reconstructs block with correct payload", func(t *testing.T) {
+		fix := fixtures()
+		payload, ok := fix["ExecutionPayload"].(*pb.ExecutionPayload)
+		require.Equal(t, true, ok)
+
+		jsonPayload := make(map[string]interface{})
+		tx := types.NewTransaction(
+			0,
+			common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
+			big.NewInt(0), 0, big.NewInt(0),
+			nil,
+		)
+		txs := []*types.Transaction{tx}
+		encodedBinaryTxs := make([][]byte, 1)
+		var err error
+		encodedBinaryTxs[0], err = txs[0].MarshalBinary()
+		require.NoError(t, err)
+		payload.Transactions = encodedBinaryTxs
+		jsonPayload["transactions"] = txs
+		num := big.NewInt(1)
+		encodedNum := hexutil.EncodeBig(num)
+		jsonPayload["hash"] = hexutil.Encode(payload.BlockHash)
+		jsonPayload["number"] = encodedNum
+		jsonPayload["difficulty"] = encodedNum
+		jsonPayload["size"] = encodedNum
+		jsonPayload["baseFeePerGas"] = encodedNum
+
+		header, err := bellatrix.PayloadToHeader(payload)
+		require.NoError(t, err)
+
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			respJSON := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  jsonPayload,
+			}
+			require.NoError(t, json.NewEncoder(w).Encode(respJSON))
+		}))
+		defer srv.Close()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+		defer rpcClient.Close()
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+		blindedBlock := util.NewBlindedBeaconBlockBellatrix()
+
+		blindedBlock.Block.Body.ExecutionPayloadHeader = header
+		wrapped, err := wrapper.WrappedSignedBeaconBlock(blindedBlock)
+		require.NoError(t, err)
+		reconstructed, err := service.ReconstructFullBellatrixBlock(ctx, wrapped)
+		require.NoError(t, err)
+
+		got, err := reconstructed.Block().Body().ExecutionPayload()
+		require.NoError(t, err)
+		require.DeepEqual(t, payload, got)
+	})
+}
+
 func TestExchangeTransitionConfiguration(t *testing.T) {
 	fix := fixtures()
 	ctx := context.Background()

beacon-chain/powchain/metrics.go

@@ -16,15 +16,33 @@ var (
 	getPayloadLatency = promauto.NewHistogram(
 		prometheus.HistogramOpts{
 			Name:    "get_payload_v1_latency_milliseconds",
-			Help:    "Captures RPC latency for newPayloadV1 in milliseconds",
+			Help:    "Captures RPC latency for getPayloadV1 in milliseconds",
 			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
 		},
 	)
 	forkchoiceUpdatedLatency = promauto.NewHistogram(
 		prometheus.HistogramOpts{
 			Name:    "forkchoice_updated_v1_latency_milliseconds",
-			Help:    "Captures RPC latency for newPayloadV1 in milliseconds",
+			Help:    "Captures RPC latency for forkchoiceUpdatedV1 in milliseconds",
 			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
 		},
 	)
+	executionBlockByHashWithTxsLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "execution_block_by_hash_with_txs_latency_milliseconds",
+			Help:    "Captures RPC latency for retrieving in milliseconds",
+			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+		},
+	)
+	executionPayloadReconstructionLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "execution_payload_reconstruction_latency_milliseconds",
+			Help:    "Captures RPC latency for retrieving in milliseconds",
+			Buckets: []float64{1, 2, 5, 10, 20, 50, 100, 200, 500, 1000},
+		},
+	)
+	reconstructedExecutionPayloadCount = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "reconstructed_execution_payload_count",
+		Help: "Count the number of execution payloads that are reconstructed using JSON-RPC from payload headers",
+	})
 )

beacon-chain/powchain/testing/BUILD.bazel

@@ -18,6 +18,8 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/powchain/testing/mock_engine_client.go

@@ -9,26 +9,31 @@ import (
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 	pb "github.com/prysmaticlabs/prysm/proto/engine/v1"
 )
 
 // EngineClient --
 type EngineClient struct {
-	NewPayloadResp          []byte
-	PayloadIDBytes          *pb.PayloadIDBytes
-	ForkChoiceUpdatedResp   []byte
-	ExecutionPayload        *pb.ExecutionPayload
-	ExecutionBlock          *pb.ExecutionBlock
-	Err                     error
-	ErrLatestExecBlock      error
-	ErrExecBlockByHash      error
-	ErrForkchoiceUpdated    error
-	ErrNewPayload           error
-	BlockByHashMap          map[[32]byte]*pb.ExecutionBlock
-	TerminalBlockHash       []byte
-	TerminalBlockHashExists bool
-	OverrideValidHash       [32]byte
+	NewPayloadResp              []byte
+	PayloadIDBytes              *pb.PayloadIDBytes
+	ForkChoiceUpdatedResp       []byte
+	ExecutionPayload            *pb.ExecutionPayload
+	ExecutionBlock              *pb.ExecutionBlock
+	Err                         error
+	ErrLatestExecBlock          error
+	ErrExecBlockByHash          error
+	ErrForkchoiceUpdated        error
+	ErrNewPayload               error
+	ExecutionPayloadByBlockHash map[[32]byte]*pb.ExecutionPayload
+	BlockByHashMap              map[[32]byte]*pb.ExecutionBlock
+	BlockWithTxsByHashMap       map[[32]byte]*pb.ExecutionBlockWithTxs
+	NumReconstructedPayloads    uint64
+	TerminalBlockHash           []byte
+	TerminalBlockHashExists     bool
+	OverrideValidHash           [32]byte
 }
 
 // NewPayload --
@@ -70,6 +75,33 @@ func (e *EngineClient) ExecutionBlockByHash(_ context.Context, h common.Hash) (*
 	return b, e.ErrExecBlockByHash
 }
 
+func (e *EngineClient) ReconstructFullBellatrixBlock(
+	_ context.Context, blindedBlock interfaces.SignedBeaconBlock,
+) (interfaces.SignedBeaconBlock, error) {
+	if !blindedBlock.Block().IsBlinded() {
+		return nil, errors.New("block must be blinded")
+	}
+	header, err := blindedBlock.Block().Body().ExecutionPayloadHeader()
+	if err != nil {
+		return nil, err
+	}
+	payload, ok := e.ExecutionPayloadByBlockHash[bytesutil.ToBytes32(header.BlockHash)]
+	if !ok {
+		return nil, errors.New("block not found")
+	}
+	e.NumReconstructedPayloads++
+	return wrapper.BuildSignedBeaconBlockFromExecutionPayload(blindedBlock, payload)
+}
+
+// ExecutionBlockByHashWithTxs --
+func (e *EngineClient) ExecutionBlockByHashWithTxs(_ context.Context, h common.Hash) (*pb.ExecutionBlockWithTxs, error) {
+	b, ok := e.BlockWithTxsByHashMap[h]
+	if !ok {
+		return nil, errors.New("block not found")
+	}
+	return b, e.ErrExecBlockByHash
+}
+
 // GetTerminalBlockHash --
 func (e *EngineClient) GetTerminalBlockHash(ctx context.Context) ([]byte, bool, error) {
 	ttd := new(big.Int)

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

@@ -29,6 +29,7 @@ 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/rpc/eth/helpers:go_default_library",
         "//beacon-chain/rpc/prysm/v1alpha1/validator:go_default_library",
         "//beacon-chain/rpc/statefetcher:go_default_library",

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

@@ -470,8 +470,42 @@ func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (
 			ExecutionOptimistic: isOptimistic,
 		}, nil
 	}
+	if _, err := blk.PbBlindedBellatrixBlock(); err == nil {
+		signedFullBlock, err := bs.ExecutionPayloadReconstructor.ReconstructFullBellatrixBlock(ctx, blk)
+		if err != nil {
+			return nil, status.Errorf(
+				codes.Internal,
+				"Could not reconstruct full execution payload to create signed beacon block: %v",
+				err,
+			)
+		}
+		bellatrixBlk, err = signedFullBlock.PbBellatrixBlock()
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
+		}
+		v2Blk, err := migration.V1Alpha1BeaconBlockBellatrixToV2(bellatrixBlk.Block)
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
+		}
+		root, err := blk.Block().HashTreeRoot()
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not get block root: %v", err)
+		}
+		isOptimistic, err := bs.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not check if block is optimistic: %v", err)
+		}
+		return &ethpbv2.BlockResponseV2{
+			Version: ethpbv2.Version_BELLATRIX,
+			Data: &ethpbv2.SignedBeaconBlockContainerV2{
+				Message:   &ethpbv2.SignedBeaconBlockContainerV2_BellatrixBlock{BellatrixBlock: v2Blk},
+				Signature: blk.Signature(),
+			},
+			ExecutionOptimistic: isOptimistic,
+		}, nil
+	}
 	// ErrUnsupportedBellatrixBlock means that we have another block type
-	if !errors.Is(err, wrapper.ErrUnsupportedBellatrixBlock) {
+	if !errors.Is(err, wrapper.ErrUnsupportedBlindedBellatrixBlock) {
 		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
 	}
 

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

@@ -123,6 +123,9 @@ func TestGetSpec(t *testing.T) {
 	var daap [4]byte
 	copy(daap[:], []byte{'0', '0', '0', '7'})
 	config.DomainAggregateAndProof = daap
+	var dam [4]byte
+	copy(dam[:], []byte{'1', '0', '0', '0'})
+	config.DomainApplicationMask = dam
 
 	params.OverrideBeaconConfig(config)
 
@@ -130,7 +133,7 @@ func TestGetSpec(t *testing.T) {
 	resp, err := server.GetSpec(context.Background(), &emptypb.Empty{})
 	require.NoError(t, err)
 
-	assert.Equal(t, 98, len(resp.Data))
+	assert.Equal(t, 99, len(resp.Data))
 	for k, v := range resp.Data {
 		switch k {
 		case "CONFIG_NAME":
@@ -315,6 +318,8 @@ func TestGetSpec(t *testing.T) {
 			assert.Equal(t, "0x30303036", v)
 		case "DOMAIN_AGGREGATE_AND_PROOF":
 			assert.Equal(t, "0x30303037", v)
+		case "DOMAIN_APPLICATION_MASK":
+			assert.Equal(t, "0x31303030", v)
 		case "DOMAIN_SYNC_COMMITTEE":
 			assert.Equal(t, "0x07000000", v)
 		case "DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF":

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

@@ -12,6 +12,7 @@ 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"
 	v1alpha1validator "github.com/prysmaticlabs/prysm/beacon-chain/rpc/prysm/v1alpha1/validator"
 	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/statefetcher"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
@@ -21,22 +22,23 @@ import (
 // Server defines a server implementation of the gRPC Beacon Chain service,
 // providing RPC endpoints to access data relevant to the Ethereum Beacon Chain.
 type Server struct {
-	BeaconDB                db.ReadOnlyDatabase
-	ChainInfoFetcher        blockchain.ChainInfoFetcher
-	GenesisTimeFetcher      blockchain.TimeFetcher
-	BlockReceiver           blockchain.BlockReceiver
-	BlockNotifier           blockfeed.Notifier
-	OperationNotifier       operation.Notifier
-	Broadcaster             p2p.Broadcaster
-	AttestationsPool        attestations.Pool
-	SlashingsPool           slashings.PoolManager
-	VoluntaryExitsPool      voluntaryexits.PoolManager
-	StateGenService         stategen.StateManager
-	StateFetcher            statefetcher.Fetcher
-	HeadFetcher             blockchain.HeadFetcher
-	OptimisticModeFetcher   blockchain.OptimisticModeFetcher
-	V1Alpha1ValidatorServer *v1alpha1validator.Server
-	SyncChecker             sync.Checker
-	CanonicalHistory        *stategen.CanonicalHistory
-	HeadUpdater             blockchain.HeadUpdater
+	BeaconDB                      db.ReadOnlyDatabase
+	ChainInfoFetcher              blockchain.ChainInfoFetcher
+	GenesisTimeFetcher            blockchain.TimeFetcher
+	BlockReceiver                 blockchain.BlockReceiver
+	BlockNotifier                 blockfeed.Notifier
+	OperationNotifier             operation.Notifier
+	Broadcaster                   p2p.Broadcaster
+	AttestationsPool              attestations.Pool
+	SlashingsPool                 slashings.PoolManager
+	VoluntaryExitsPool            voluntaryexits.PoolManager
+	StateGenService               stategen.StateManager
+	StateFetcher                  statefetcher.Fetcher
+	HeadFetcher                   blockchain.HeadFetcher
+	OptimisticModeFetcher         blockchain.OptimisticModeFetcher
+	V1Alpha1ValidatorServer       *v1alpha1validator.Server
+	SyncChecker                   sync.Checker
+	CanonicalHistory              *stategen.CanonicalHistory
+	HeadUpdater                   blockchain.HeadUpdater
+	ExecutionPayloadReconstructor powchain.ExecutionPayloadReconstructor
 }

beacon-chain/rpc/service.go

@@ -70,48 +70,49 @@ type Service struct {
 
 // Config options for the beacon node RPC server.
 type Config struct {
-	Host                    string
-	Port                    string
-	CertFlag                string
-	KeyFlag                 string
-	BeaconMonitoringHost    string
-	BeaconMonitoringPort    int
-	BeaconDB                db.HeadAccessDatabase
-	ChainInfoFetcher        blockchain.ChainInfoFetcher
-	HeadUpdater             blockchain.HeadUpdater
-	HeadFetcher             blockchain.HeadFetcher
-	CanonicalFetcher        blockchain.CanonicalFetcher
-	ForkFetcher             blockchain.ForkFetcher
-	FinalizationFetcher     blockchain.FinalizationFetcher
-	AttestationReceiver     blockchain.AttestationReceiver
-	BlockReceiver           blockchain.BlockReceiver
-	POWChainService         powchain.Chain
-	ChainStartFetcher       powchain.ChainStartFetcher
-	POWChainInfoFetcher     powchain.ChainInfoFetcher
-	GenesisTimeFetcher      blockchain.TimeFetcher
-	GenesisFetcher          blockchain.GenesisFetcher
-	EnableDebugRPCEndpoints bool
-	MockEth1Votes           bool
-	AttestationsPool        attestations.Pool
-	ExitPool                voluntaryexits.PoolManager
-	SlashingsPool           slashings.PoolManager
-	SlashingChecker         slasherservice.SlashingChecker
-	SyncCommitteeObjectPool synccommittee.Pool
-	SyncService             chainSync.Checker
-	Broadcaster             p2p.Broadcaster
-	PeersFetcher            p2p.PeersProvider
-	PeerManager             p2p.PeerManager
-	MetadataProvider        p2p.MetadataProvider
-	DepositFetcher          depositcache.DepositFetcher
-	PendingDepositFetcher   depositcache.PendingDepositsFetcher
-	StateNotifier           statefeed.Notifier
-	BlockNotifier           blockfeed.Notifier
-	OperationNotifier       opfeed.Notifier
-	StateGen                *stategen.State
-	MaxMsgSize              int
-	ExecutionEngineCaller   powchain.EngineCaller
-	ProposerIdsCache        *cache.ProposerPayloadIDsCache
-	OptimisticModeFetcher   blockchain.OptimisticModeFetcher
+	Host                          string
+	Port                          string
+	CertFlag                      string
+	KeyFlag                       string
+	BeaconMonitoringHost          string
+	BeaconMonitoringPort          int
+	BeaconDB                      db.HeadAccessDatabase
+	ChainInfoFetcher              blockchain.ChainInfoFetcher
+	HeadUpdater                   blockchain.HeadUpdater
+	HeadFetcher                   blockchain.HeadFetcher
+	CanonicalFetcher              blockchain.CanonicalFetcher
+	ForkFetcher                   blockchain.ForkFetcher
+	FinalizationFetcher           blockchain.FinalizationFetcher
+	AttestationReceiver           blockchain.AttestationReceiver
+	BlockReceiver                 blockchain.BlockReceiver
+	POWChainService               powchain.Chain
+	ChainStartFetcher             powchain.ChainStartFetcher
+	POWChainInfoFetcher           powchain.ChainInfoFetcher
+	GenesisTimeFetcher            blockchain.TimeFetcher
+	GenesisFetcher                blockchain.GenesisFetcher
+	EnableDebugRPCEndpoints       bool
+	MockEth1Votes                 bool
+	AttestationsPool              attestations.Pool
+	ExitPool                      voluntaryexits.PoolManager
+	SlashingsPool                 slashings.PoolManager
+	SlashingChecker               slasherservice.SlashingChecker
+	SyncCommitteeObjectPool       synccommittee.Pool
+	SyncService                   chainSync.Checker
+	Broadcaster                   p2p.Broadcaster
+	PeersFetcher                  p2p.PeersProvider
+	PeerManager                   p2p.PeerManager
+	MetadataProvider              p2p.MetadataProvider
+	DepositFetcher                depositcache.DepositFetcher
+	PendingDepositFetcher         depositcache.PendingDepositsFetcher
+	StateNotifier                 statefeed.Notifier
+	BlockNotifier                 blockfeed.Notifier
+	OperationNotifier             opfeed.Notifier
+	StateGen                      *stategen.State
+	MaxMsgSize                    int
+	ExecutionEngineCaller         powchain.EngineCaller
+	ProposerIdsCache              *cache.ProposerPayloadIDsCache
+	OptimisticModeFetcher         blockchain.OptimisticModeFetcher
+	ExecutionPayloadReconstructor powchain.ExecutionPayloadReconstructor
 }
 
 // NewService instantiates a new RPC service instance that will
@@ -304,11 +305,12 @@ func (s *Service) Start() {
 			StateGenService:    s.cfg.StateGen,
 			ReplayerBuilder:    ch,
 		},
-		OptimisticModeFetcher:   s.cfg.OptimisticModeFetcher,
-		HeadFetcher:             s.cfg.HeadFetcher,
-		VoluntaryExitsPool:      s.cfg.ExitPool,
-		V1Alpha1ValidatorServer: validatorServer,
-		SyncChecker:             s.cfg.SyncService,
+		OptimisticModeFetcher:         s.cfg.OptimisticModeFetcher,
+		HeadFetcher:                   s.cfg.HeadFetcher,
+		VoluntaryExitsPool:            s.cfg.ExitPool,
+		V1Alpha1ValidatorServer:       validatorServer,
+		SyncChecker:                   s.cfg.SyncService,
+		ExecutionPayloadReconstructor: s.cfg.ExecutionPayloadReconstructor,
 	}
 	ethpbv1alpha1.RegisterNodeServer(s.grpcServer, nodeServer)
 	ethpbservice.RegisterBeaconNodeServer(s.grpcServer, nodeServerV1)

beacon-chain/state/fieldtrie/BUILD.bazel

@@ -29,6 +29,7 @@ go_test(
         "field_trie_test.go",
         "helpers_test.go",
     ],
+    data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/state/stateutil:go_default_library",

beacon-chain/state/fieldtrie/field_trie.go

@@ -10,6 +10,11 @@ import (
 	pmath "github.com/prysmaticlabs/prysm/math"
 )
 
+var (
+	ErrInvalidFieldTrie = errors.New("invalid field trie")
+	ErrEmptyFieldTrie   = errors.New("empty field trie")
+)
+
 // FieldTrie is the representation of the representative
 // trie of the particular field.
 type FieldTrie struct {
@@ -188,6 +193,12 @@ func (f *FieldTrie) CopyTrie() *FieldTrie {
 
 // TrieRoot returns the corresponding root of the trie.
 func (f *FieldTrie) TrieRoot() ([32]byte, error) {
+	if f.Empty() {
+		return [32]byte{}, ErrEmptyFieldTrie
+	}
+	if len(f.fieldLayers[len(f.fieldLayers)-1]) == 0 {
+		return [32]byte{}, ErrInvalidFieldTrie
+	}
 	switch f.dataType {
 	case types.BasicArray:
 		return *f.fieldLayers[len(f.fieldLayers)-1][0], nil

beacon-chain/state/fieldtrie/field_trie_test.go

@@ -27,6 +27,13 @@ func TestFieldTrie_NewTrie(t *testing.T) {
 	assert.Equal(t, root, newRoot)
 }
 
+func TestFieldTrie_NewTrie_NilElements(t *testing.T) {
+	trie, err := fieldtrie.NewFieldTrie(stateTypes.FieldIndex(5), stateTypes.BasicArray, nil, 8234)
+	require.NoError(t, err)
+	_, err = trie.TrieRoot()
+	require.ErrorIs(t, err, fieldtrie.ErrEmptyFieldTrie)
+}
+
 func TestFieldTrie_RecomputeTrie(t *testing.T) {
 	newState, _ := util.DeterministicGenesisState(t, 32)
 	// 10 represents the enum value of validators
@@ -77,3 +84,27 @@ func TestFieldTrie_CopyTrieImmutable(t *testing.T) {
 		t.Errorf("Wanted roots to be different, but they are the same: %#x", root)
 	}
 }
+
+func FuzzFieldTrie(f *testing.F) {
+	newState, _ := util.DeterministicGenesisState(f, 40)
+	var data []byte
+	for _, root := range newState.StateRoots() {
+		data = append(data, root...)
+	}
+	f.Add(5, int(stateTypes.BasicArray), data, uint64(params.BeaconConfig().SlotsPerHistoricalRoot))
+
+	f.Fuzz(func(t *testing.T, idx, typ int, data []byte, slotsPerHistRoot uint64) {
+		var roots [][]byte
+		for i := 32; i < len(data); i += 32 {
+			roots = append(roots, data[i-32:i])
+		}
+		trie, err := fieldtrie.NewFieldTrie(stateTypes.FieldIndex(idx), stateTypes.DataType(typ), roots, slotsPerHistRoot)
+		if err != nil {
+			return // invalid inputs
+		}
+		_, err = trie.TrieRoot()
+		if err != nil {
+			return
+		}
+	})
+}

beacon-chain/state/fieldtrie/testdata/fuzz/FuzzFieldTrie/c1898b8d556154d8a9d00cf2a64226dd5d76f33e27c373df2c409670db9b4877

@@ -0,0 +1,5 @@
+go test fuzz v1
+int(5)
+int(0)
+[]byte("")
+uint64(8234)

beacon-chain/sync/BUILD.bazel

@@ -76,6 +76,7 @@ go_library(
         "//beacon-chain/p2p/encoder:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",
         "//beacon-chain/p2p/types:go_default_library",
+        "//beacon-chain/powchain:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//cache/lru:go_default_library",
@@ -186,6 +187,7 @@ go_test(
         "//beacon-chain/p2p/testing:go_default_library",
         "//beacon-chain/p2p/types:go_default_library",
         "//beacon-chain/powchain:go_default_library",
+        "//beacon-chain/powchain/testing:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/state/v1:go_default_library",
@@ -194,6 +196,7 @@ go_test(
         "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params: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",
@@ -202,6 +205,7 @@ go_test(
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz/equality:go_default_library",
         "//network/forks:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",
@@ -211,6 +215,8 @@ go_test(
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_d4l3k_messagediff//:go_default_library",
+        "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
         "@com_github_golang_snappy//:go_default_library",
         "@com_github_kevinms_leakybucket_go//:go_default_library",

beacon-chain/sync/checkpoint/api.go

@@ -27,7 +27,7 @@ func NewAPIInitializer(beaconNodeHost string) (*APIInitializer, error) {
 // Initialize downloads origin state and block for checkpoint sync and initializes database records to
 // prepare the node to begin syncing from that point.
 func (dl *APIInitializer) Initialize(ctx context.Context, d db.Database) error {
-	od, err := beacon.DownloadOriginData(ctx, dl.c)
+	od, err := beacon.DownloadFinalizedData(ctx, dl.c)
 	if err != nil {
 		return errors.Wrap(err, "Error retrieving checkpoint origin state and block")
 	}

beacon-chain/sync/metrics.go

@@ -75,7 +75,13 @@ var (
 			Buckets: []float64{10, 50, 100, 200, 400, 800, 1600, 3200},
 		},
 	)
-
+	rpcBlocksByRangeResponseLatency = promauto.NewHistogram(
+		prometheus.HistogramOpts{
+			Name:    "rpc_blocks_by_range_response_latency_milliseconds",
+			Help:    "Captures total time to respond to rpc blocks by range requests in a milliseconds distribution",
+			Buckets: []float64{250, 500, 1000, 1500, 2000, 3000, 4000, 10000},
+		},
+	)
 	arrivalBlockPropagationHistogram = promauto.NewHistogram(
 		prometheus.HistogramOpts{
 			Name:    "block_arrival_latency_milliseconds",

beacon-chain/sync/options.go

@@ -11,6 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/synccommittee"
 	"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/stategen"
 )
 
@@ -120,3 +121,10 @@ func WithSlasherBlockHeadersFeed(slasherBlockHeadersFeed *event.Feed) Option {
 		return nil
 	}
 }
+
+func WithExecutionPayloadReconstructor(r powchain.ExecutionPayloadReconstructor) Option {
+	return func(s *Service) error {
+		s.cfg.executionPayloadReconstructor = r
+		return nil
+	}
+}

beacon-chain/sync/rpc_beacon_blocks_by_range.go

@@ -12,6 +12,7 @@ import (
 	"github.com/prysmaticlabs/prysm/config/params"
 	"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"
 	"github.com/prysmaticlabs/prysm/monitoring/tracing"
 	pb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
@@ -158,18 +159,29 @@ func (s *Service) writeBlockRangeToStream(ctx context.Context, startSlot, endSlo
 		tracing.AnnotateError(span, err)
 		return err
 	}
+	start := time.Now()
 	for _, b := range blks {
-		if b == nil || b.IsNil() || b.Block().IsNil() {
+		if err := wrapper.BeaconBlockIsNil(b); err != nil {
 			continue
 		}
-		if chunkErr := s.chunkBlockWriter(stream, b); chunkErr != nil {
-			log.WithError(chunkErr).Debug("Could not send a chunked response")
+		blockToWrite := b
+		if blockToWrite.Block().IsBlinded() {
+			fullBlock, err := s.cfg.executionPayloadReconstructor.ReconstructFullBellatrixBlock(ctx, blockToWrite)
+			if err != nil {
+				log.WithError(err).Error("Could not get reconstruct full bellatrix block from blinded body")
+				s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
+				return err
+			}
+			blockToWrite = fullBlock
+		}
+		if chunkErr := s.chunkBlockWriter(stream, blockToWrite); chunkErr != nil {
+			log.WithError(chunkErr).Error("Could not send a chunked response")
 			s.writeErrorResponseToStream(responseCodeServerError, p2ptypes.ErrGeneric.Error(), stream)
 			tracing.AnnotateError(span, chunkErr)
 			return chunkErr
 		}
-
 	}
+	rpcBlocksByRangeResponseLatency.Observe(float64(time.Since(start).Milliseconds()))
 	// Return error in the event we have an invalid parent.
 	return err
 }

beacon-chain/sync/rpc_beacon_blocks_by_range_test.go

@@ -3,10 +3,13 @@ package sync
 import (
 	"context"
 	"io"
+	"math/big"
 	"sync"
 	"testing"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common"
+	gethTypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/kevinms/leakybucket-go"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/protocol"
@@ -17,12 +20,15 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p/encoder"
 	p2ptest "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
 	p2ptypes "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
+	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
 	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"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -155,6 +161,121 @@ func TestRPCBeaconBlocksByRange_ReturnCorrectNumberBack(t *testing.T) {
 	}
 }
 
+func TestRPCBeaconBlocksByRange_CanReconstructFullPayloadBlocks(t *testing.T) {
+	p1 := p2ptest.NewTestP2P(t)
+	p2 := p2ptest.NewTestP2P(t)
+	p1.Connect(p2)
+	assert.Equal(t, 1, len(p1.BHost.Network().Peers()), "Expected peers to be connected")
+	d := db.SetupDB(t)
+
+	req := &ethpb.BeaconBlocksByRangeRequest{
+		StartSlot: 200,
+		Step:      21,
+		Count:     33,
+	}
+
+	// Start service with 160 as allowed blocks capacity (and almost zero capacity recovery).
+	parent := bytesutil.PadTo([]byte("parentHash"), fieldparams.RootLength)
+	stateRoot := bytesutil.PadTo([]byte("stateRoot"), fieldparams.RootLength)
+	receiptsRoot := bytesutil.PadTo([]byte("receiptsRoot"), fieldparams.RootLength)
+	logsBloom := bytesutil.PadTo([]byte("logs"), fieldparams.LogsBloomLength)
+	tx := gethTypes.NewTransaction(
+		0,
+		common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
+		big.NewInt(0), 0, big.NewInt(0),
+		nil,
+	)
+	txs := []*gethTypes.Transaction{tx}
+	encodedBinaryTxs := make([][]byte, 1)
+	var err error
+	encodedBinaryTxs[0], err = txs[0].MarshalBinary()
+	require.NoError(t, err)
+	blockHash := bytesutil.ToBytes32([]byte("foo"))
+	payload := &enginev1.ExecutionPayload{
+		ParentHash:    parent,
+		FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+		StateRoot:     stateRoot,
+		ReceiptsRoot:  receiptsRoot,
+		LogsBloom:     logsBloom,
+		PrevRandao:    blockHash[:],
+		BlockNumber:   0,
+		GasLimit:      0,
+		GasUsed:       0,
+		Timestamp:     0,
+		ExtraData:     make([]byte, 0),
+		BlockHash:     blockHash[:],
+		BaseFeePerGas: bytesutil.PadTo([]byte("baseFeePerGas"), fieldparams.RootLength),
+		Transactions:  encodedBinaryTxs,
+	}
+	header, err := bellatrix.PayloadToHeader(payload)
+	require.NoError(t, err)
+
+	endSlot := req.StartSlot.Add(req.Step * (req.Count - 1))
+	expectedRoots := make([][32]byte, req.Count)
+
+	// Populate the database with blocks that would match the request.
+	for i, j := endSlot, req.Count-1; i >= req.StartSlot; i -= types.Slot(req.Step) {
+		blk := util.NewBlindedBeaconBlockBellatrix()
+		blk.Block.Body.ExecutionPayloadHeader = header
+		blk.Block.Slot = i
+		rt, err := blk.Block.HashTreeRoot()
+		require.NoError(t, err)
+		expectedRoots[j] = rt
+		wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
+		require.NoError(t, err)
+		require.NoError(t, d.SaveBlock(context.Background(), wsb))
+		j--
+	}
+
+	mockEngine := &mockPOW.EngineClient{
+		ExecutionPayloadByBlockHash: map[[32]byte]*enginev1.ExecutionPayload{
+			blockHash: payload,
+		},
+	}
+	r := &Service{cfg: &config{
+		p2p:                           p1,
+		beaconDB:                      d,
+		chain:                         &chainMock.ChainService{},
+		executionPayloadReconstructor: mockEngine,
+	},
+		rateLimiter: newRateLimiter(p1),
+	}
+
+	pcl := protocol.ID(p2p.RPCBlocksByRangeTopicV1)
+	topic := string(pcl)
+	r.rateLimiter.limiterMap[topic] = leakybucket.NewCollector(0.000001, int64(req.Count*10), false)
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	p2.BHost.SetStreamHandler(pcl, func(stream network.Stream) {
+		defer wg.Done()
+		prevSlot := types.Slot(0)
+		require.Equal(t, uint64(len(expectedRoots)), req.Count, "Number of roots not expected")
+		for i, j := req.StartSlot, 0; i < req.StartSlot.Add(req.Count*req.Step); i += types.Slot(req.Step) {
+			expectSuccess(t, stream)
+			res := &ethpb.SignedBeaconBlockBellatrix{}
+			assert.NoError(t, r.cfg.p2p.Encoding().DecodeWithMaxLength(stream, res))
+			if res.Block.Slot < prevSlot {
+				t.Errorf("Received block is unsorted with slot %d lower than previous slot %d", res.Block.Slot, prevSlot)
+			}
+			rt, err := res.Block.HashTreeRoot()
+			require.NoError(t, err)
+			assert.Equal(t, expectedRoots[j], rt, "roots not equal")
+			prevSlot = res.Block.Slot
+			j++
+		}
+		require.Equal(t, uint64(33), mockEngine.NumReconstructedPayloads, "wrong number of reconstructed payloads")
+	})
+
+	stream1, err := p1.BHost.NewStream(context.Background(), p2.BHost.ID(), pcl)
+	require.NoError(t, err)
+	require.NoError(t, r.beaconBlocksByRangeRPCHandler(context.Background(), req, stream1))
+
+	if util.WaitTimeout(&wg, 1*time.Second) {
+		t.Fatal("Did not receive stream within 1 sec")
+	}
+}
+
 func TestRPCBeaconBlocksByRange_RPCHandlerReturnsSortedBlocks(t *testing.T) {
 	p1 := p2ptest.NewTestP2P(t)
 	p2 := p2ptest.NewTestP2P(t)

beacon-chain/sync/rpc_beacon_blocks_by_root.go

@@ -9,6 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
 )
 
 // sendRecentBeaconBlocksRequest sends a recent beacon blocks request to a peer to get
@@ -68,13 +69,24 @@ func (s *Service) beaconBlocksRootRPCHandler(ctx context.Context, msg interface{
 			s.writeErrorResponseToStream(responseCodeServerError, types.ErrGeneric.Error(), stream)
 			return err
 		}
-		if blk == nil || blk.IsNil() {
+		if err := wrapper.BeaconBlockIsNil(blk); err != nil {
 			continue
 		}
+
+		if blk.Block().IsBlinded() {
+			blk, err = s.cfg.executionPayloadReconstructor.ReconstructFullBellatrixBlock(ctx, blk)
+			if err != nil {
+				log.WithError(err).Error("Could not get reconstruct full bellatrix block from blinded body")
+				s.writeErrorResponseToStream(responseCodeServerError, types.ErrGeneric.Error(), stream)
+				return err
+			}
+		}
+
 		if err := s.chunkBlockWriter(stream, blk); err != nil {
 			return err
 		}
 	}
+
 	closeStream(stream, log)
 	return nil
 }

beacon-chain/sync/rpc_beacon_blocks_by_root_test.go

@@ -2,10 +2,13 @@ package sync
 
 import (
 	"context"
+	"math/big"
 	"sync"
 	"testing"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common"
+	gethTypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/kevinms/leakybucket-go"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/protocol"
@@ -16,9 +19,14 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	p2ptest "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
 	p2pTypes "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types"
+	mockPOW "github.com/prysmaticlabs/prysm/beacon-chain/powchain/testing"
+	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
 	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"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -75,6 +83,103 @@ func TestRecentBeaconBlocksRPCHandler_ReturnsBlocks(t *testing.T) {
 	}
 }
 
+func TestRecentBeaconBlocksRPCHandler_ReturnsBlocks_ReconstructsExecutionPayloads(t *testing.T) {
+	p1 := p2ptest.NewTestP2P(t)
+	p2 := p2ptest.NewTestP2P(t)
+	p1.Connect(p2)
+	assert.Equal(t, 1, len(p1.BHost.Network().Peers()), "Expected peers to be connected")
+	d := db.SetupDB(t)
+
+	// Start service with 160 as allowed blocks capacity (and almost zero capacity recovery).
+	parent := bytesutil.PadTo([]byte("parentHash"), fieldparams.RootLength)
+	stateRoot := bytesutil.PadTo([]byte("stateRoot"), fieldparams.RootLength)
+	receiptsRoot := bytesutil.PadTo([]byte("receiptsRoot"), fieldparams.RootLength)
+	logsBloom := bytesutil.PadTo([]byte("logs"), fieldparams.LogsBloomLength)
+	tx := gethTypes.NewTransaction(
+		0,
+		common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
+		big.NewInt(0), 0, big.NewInt(0),
+		nil,
+	)
+	txs := []*gethTypes.Transaction{tx}
+	encodedBinaryTxs := make([][]byte, 1)
+	var err error
+	encodedBinaryTxs[0], err = txs[0].MarshalBinary()
+	require.NoError(t, err)
+	blockHash := bytesutil.ToBytes32([]byte("foo"))
+	payload := &enginev1.ExecutionPayload{
+		ParentHash:    parent,
+		FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+		StateRoot:     stateRoot,
+		ReceiptsRoot:  receiptsRoot,
+		LogsBloom:     logsBloom,
+		PrevRandao:    blockHash[:],
+		BlockNumber:   0,
+		GasLimit:      0,
+		GasUsed:       0,
+		Timestamp:     0,
+		ExtraData:     make([]byte, 0),
+		BlockHash:     blockHash[:],
+		BaseFeePerGas: bytesutil.PadTo([]byte("baseFeePerGas"), fieldparams.RootLength),
+		Transactions:  encodedBinaryTxs,
+	}
+	header, err := bellatrix.PayloadToHeader(payload)
+	require.NoError(t, err)
+
+	var blkRoots p2pTypes.BeaconBlockByRootsReq
+	// Populate the database with blocks that would match the request.
+	for i := types.Slot(1); i < 11; i++ {
+		blk := util.NewBlindedBeaconBlockBellatrix()
+		blk.Block.Body.ExecutionPayloadHeader = header
+		blk.Block.Slot = i
+		root, err := blk.Block.HashTreeRoot()
+		require.NoError(t, err)
+		wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
+		require.NoError(t, err)
+		require.NoError(t, d.SaveBlock(context.Background(), wsb))
+		blkRoots = append(blkRoots, root)
+	}
+
+	mockEngine := &mockPOW.EngineClient{
+		ExecutionPayloadByBlockHash: map[[32]byte]*enginev1.ExecutionPayload{
+			blockHash: payload,
+		},
+	}
+	r := &Service{cfg: &config{
+		p2p:                           p1,
+		beaconDB:                      d,
+		executionPayloadReconstructor: mockEngine,
+	}, rateLimiter: newRateLimiter(p1)}
+	r.cfg.chain = &mock.ChainService{ValidatorsRoot: [32]byte{}}
+	pcl := protocol.ID(p2p.RPCBlocksByRootTopicV1)
+	topic := string(pcl)
+	r.rateLimiter.limiterMap[topic] = leakybucket.NewCollector(10000, 10000, false)
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	p2.BHost.SetStreamHandler(pcl, func(stream network.Stream) {
+		defer wg.Done()
+		for i := range blkRoots {
+			expectSuccess(t, stream)
+			res := util.NewBeaconBlockBellatrix()
+			assert.NoError(t, r.cfg.p2p.Encoding().DecodeWithMaxLength(stream, res))
+			if uint64(res.Block.Slot) != uint64(i+1) {
+				t.Errorf("Received unexpected block slot %d but wanted %d", res.Block.Slot, i+1)
+			}
+		}
+		require.Equal(t, uint64(10), mockEngine.NumReconstructedPayloads)
+	})
+
+	stream1, err := p1.BHost.NewStream(context.Background(), p2.BHost.ID(), pcl)
+	require.NoError(t, err)
+	err = r.beaconBlocksRootRPCHandler(context.Background(), &blkRoots, stream1)
+	assert.NoError(t, err)
+
+	if util.WaitTimeout(&wg, 1*time.Second) {
+		t.Fatal("Did not receive stream within 1 sec")
+	}
+}
+
 func TestRecentBeaconBlocks_RPCRequestSent(t *testing.T) {
 	p1 := p2ptest.NewTestP2P(t)
 	p2 := p2ptest.NewTestP2P(t)

beacon-chain/sync/rpc_chunked_response.go

@@ -30,6 +30,7 @@ func WriteBlockChunk(stream libp2pcore.Stream, chain blockchain.ChainInfoFetcher
 		return err
 	}
 	var obtainedCtx []byte
+
 	switch blk.Version() {
 	case version.Phase0:
 		valRoot := chain.GenesisValidatorsRoot()
@@ -45,7 +46,7 @@ func WriteBlockChunk(stream libp2pcore.Stream, chain blockchain.ChainInfoFetcher
 			return err
 		}
 		obtainedCtx = digest[:]
-	case version.Bellatrix:
+	case version.Bellatrix, version.BellatrixBlind:
 		valRoot := chain.GenesisValidatorsRoot()
 		digest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().BellatrixForkEpoch, valRoot[:])
 		if err != nil {

beacon-chain/sync/service.go

@@ -29,6 +29,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/synccommittee"
 	"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/stategen"
 	lruwrpr "github.com/prysmaticlabs/prysm/cache/lru"
 	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
@@ -68,21 +69,22 @@ type validationFn func(ctx context.Context) (pubsub.ValidationResult, error)
 
 // config to hold dependencies for the sync service.
 type config struct {
-	attestationNotifier     operation.Notifier
-	p2p                     p2p.P2P
-	beaconDB                db.NoHeadAccessDatabase
-	attPool                 attestations.Pool
-	exitPool                voluntaryexits.PoolManager
-	slashingPool            slashings.PoolManager
-	syncCommsPool           synccommittee.Pool
-	chain                   blockchainService
-	initialSync             Checker
-	stateNotifier           statefeed.Notifier
-	blockNotifier           blockfeed.Notifier
-	operationNotifier       operation.Notifier
-	stateGen                *stategen.State
-	slasherAttestationsFeed *event.Feed
-	slasherBlockHeadersFeed *event.Feed
+	attestationNotifier           operation.Notifier
+	p2p                           p2p.P2P
+	beaconDB                      db.NoHeadAccessDatabase
+	attPool                       attestations.Pool
+	exitPool                      voluntaryexits.PoolManager
+	slashingPool                  slashings.PoolManager
+	syncCommsPool                 synccommittee.Pool
+	chain                         blockchainService
+	initialSync                   Checker
+	stateNotifier                 statefeed.Notifier
+	blockNotifier                 blockfeed.Notifier
+	operationNotifier             operation.Notifier
+	executionPayloadReconstructor powchain.ExecutionPayloadReconstructor
+	stateGen                      *stategen.State
+	slasherAttestationsFeed       *event.Feed
+	slasherBlockHeadersFeed       *event.Feed
 }
 
 // This defines the interface for interacting with block chain service
@@ -132,6 +134,8 @@ type Service struct {
 	seenSyncContributionCache        *lru.Cache
 	badBlockCache                    *lru.Cache
 	badBlockLock                     sync.RWMutex
+	syncContributionBitsOverlapLock  sync.RWMutex
+	syncContributionBitsOverlapCache *lru.Cache
 	signatureChan                    chan *signatureVerifier
 }
 
@@ -221,6 +225,7 @@ func (s *Service) initCaches() {
 	s.seenUnAggregatedAttestationCache = lruwrpr.New(seenUnaggregatedAttSize)
 	s.seenSyncMessageCache = lruwrpr.New(seenSyncMsgSize)
 	s.seenSyncContributionCache = lruwrpr.New(seenSyncContributionSize)
+	s.syncContributionBitsOverlapCache = lruwrpr.New(seenSyncContributionSize)
 	s.seenExitCache = lruwrpr.New(seenExitSize)
 	s.seenAttesterSlashingCache = make(map[uint64]bool)
 	s.seenProposerSlashingCache = lruwrpr.New(seenProposerSlashingSize)

beacon-chain/sync/validate_beacon_attestation.go

@@ -252,7 +252,7 @@ func (s *Service) setSeenCommitteeIndicesSlot(slot types.Slot, committeeID types
 	s.seenUnAggregatedAttestationLock.Lock()
 	defer s.seenUnAggregatedAttestationLock.Unlock()
 	b := append(bytesutil.Bytes32(uint64(slot)), bytesutil.Bytes32(uint64(committeeID))...)
-	b = append(b, aggregateBits...)
+	b = append(b, bytesutil.SafeCopyBytes(aggregateBits)...)
 	s.seenUnAggregatedAttestationCache.Add(string(b), true)
 }
 

beacon-chain/sync/validate_beacon_attestation_test.go

@@ -339,3 +339,30 @@ func TestServiceValidateCommitteeIndexBeaconAttestation_Optimistic(t *testing.T)
 	valid := res == pubsub.ValidationIgnore
 	assert.Equal(t, true, valid, "Should have ignore this message")
 }
+
+func TestService_setSeenCommitteeIndicesSlot(t *testing.T) {
+	chainService := &mockChain.ChainService{
+		Genesis:        time.Now(),
+		ValidatorsRoot: [32]byte{'A'},
+	}
+	s := NewService(context.Background(), WithP2P(p2ptest.NewTestP2P(t)), WithStateNotifier(chainService.StateNotifier()))
+	s.initCaches()
+
+	// Empty cache
+	b0 := []byte{9} // 1001
+	require.Equal(t, false, s.hasSeenCommitteeIndicesSlot(0, 0, b0))
+
+	// Cache some entries but same key
+	s.setSeenCommitteeIndicesSlot(0, 0, b0)
+	require.Equal(t, true, s.hasSeenCommitteeIndicesSlot(0, 0, b0))
+	b1 := []byte{14} // 1110
+	s.setSeenCommitteeIndicesSlot(0, 0, b1)
+	require.Equal(t, true, s.hasSeenCommitteeIndicesSlot(0, 0, b0))
+	require.Equal(t, true, s.hasSeenCommitteeIndicesSlot(0, 0, b1))
+
+	// Cache some entries with diff keys
+	s.setSeenCommitteeIndicesSlot(1, 2, b1)
+	require.Equal(t, false, s.hasSeenCommitteeIndicesSlot(1, 0, b1))
+	require.Equal(t, false, s.hasSeenCommitteeIndicesSlot(0, 2, b1))
+	require.Equal(t, true, s.hasSeenCommitteeIndicesSlot(1, 2, b1))
+}

beacon-chain/sync/validate_sync_contribution_proof.go

@@ -88,7 +88,11 @@ func (s *Service) validateSyncContributionAndProof(ctx context.Context, pid peer
 		return result, err
 	}
 
-	s.setSyncContributionIndexSlotSeen(m.Message.Contribution.Slot, m.Message.AggregatorIndex, types.CommitteeIndex(m.Message.Contribution.SubcommitteeIndex))
+	con := m.Message.Contribution
+	if err := s.setSyncContributionBits(con); err != nil {
+		return pubsub.ValidationIgnore, err
+	}
+	s.setSyncContributionIndexSlotSeen(con.Slot, m.Message.AggregatorIndex, types.CommitteeIndex(con.SubcommitteeIndex))
 
 	msg.ValidatorData = m
 
@@ -149,7 +153,15 @@ func rejectEmptyContribution(m *ethpb.SignedContributionAndProof) validationFn {
 
 func (s *Service) ignoreSeenSyncContribution(m *ethpb.SignedContributionAndProof) validationFn {
 	return func(ctx context.Context) (pubsub.ValidationResult, error) {
-		seen := s.hasSeenSyncContributionIndexSlot(m.Message.Contribution.Slot, m.Message.AggregatorIndex, types.CommitteeIndex(m.Message.Contribution.SubcommitteeIndex))
+		c := m.Message.Contribution
+		seen, err := s.hasSeenSyncContributionBits(c)
+		if err != nil {
+			return pubsub.ValidationIgnore, err
+		}
+		if seen {
+			return pubsub.ValidationIgnore, nil
+		}
+		seen = s.hasSeenSyncContributionIndexSlot(c.Slot, m.Message.AggregatorIndex, types.CommitteeIndex(c.SubcommitteeIndex))
 		if seen {
 			return pubsub.ValidationIgnore, nil
 		}
@@ -318,6 +330,68 @@ func (s *Service) setSyncContributionIndexSlotSeen(slot types.Slot, aggregatorIn
 	s.seenSyncContributionCache.Add(string(b), true)
 }
 
+// Set sync contribution's slot, root, committee index and bits.
+func (s *Service) setSyncContributionBits(c *ethpb.SyncCommitteeContribution) error {
+	s.syncContributionBitsOverlapLock.Lock()
+	defer s.syncContributionBitsOverlapLock.Unlock()
+	// Copying due to how pb unmarshalling is carried out, prevent mutation.
+	b := append(bytesutil.SafeCopyBytes(c.BlockRoot), bytesutil.Bytes32(uint64(c.Slot))...)
+	b = append(b, bytesutil.Bytes32(c.SubcommitteeIndex)...)
+	v, ok := s.syncContributionBitsOverlapCache.Get(string(b))
+	if !ok {
+		s.syncContributionBitsOverlapCache.Add(string(b), [][]byte{c.AggregationBits.Bytes()})
+		return nil
+	}
+	bitsList, ok := v.([][]byte)
+	if !ok {
+		return errors.New("could not covert cached value to []bitfield.Bitvector")
+	}
+	has, err := bitListOverlaps(bitsList, c.AggregationBits)
+	if err != nil {
+		return err
+	}
+	if has {
+		return nil
+	}
+	s.syncContributionBitsOverlapCache.Add(string(b), append(bitsList, c.AggregationBits.Bytes()))
+	return nil
+}
+
+// Check sync contribution bits don't have an overlap with one's in cache.
+func (s *Service) hasSeenSyncContributionBits(c *ethpb.SyncCommitteeContribution) (bool, error) {
+	s.syncContributionBitsOverlapLock.RLock()
+	defer s.syncContributionBitsOverlapLock.RUnlock()
+	b := append(c.BlockRoot, bytesutil.Bytes32(uint64(c.Slot))...)
+	b = append(b, bytesutil.Bytes32(c.SubcommitteeIndex)...)
+	v, ok := s.syncContributionBitsOverlapCache.Get(string(b))
+	if !ok {
+		return false, nil
+	}
+	bitsList, ok := v.([][]byte)
+	if !ok {
+		return false, errors.New("could not covert cached value to []bitfield.Bitvector128")
+	}
+	return bitListOverlaps(bitsList, c.AggregationBits.Bytes())
+}
+
+// bitListOverlaps returns true if there's an overlap between two bitlists.
+func bitListOverlaps(bitLists [][]byte, b []byte) (bool, error) {
+	for _, bitList := range bitLists {
+		if bitList == nil {
+			return false, errors.New("nil bitfield")
+		}
+		bl := ethpb.ConvertToSyncContributionBitVector(bitList)
+		overlaps, err := bl.Overlaps(ethpb.ConvertToSyncContributionBitVector(b))
+		if err != nil {
+			return false, err
+		}
+		if overlaps {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
 // verifySyncSelectionData verifies that the provided sync contribution has a valid
 // selection proof.
 func (s *Service) verifySyncSelectionData(ctx context.Context, m *ethpb.ContributionAndProof) error {

beacon-chain/sync/validate_sync_contribution_proof_test.go

@@ -1095,3 +1095,121 @@ func syncSelectionProofSigningRoot(st state.BeaconState, slot types.Slot, comIdx
 	selectionData := &ethpb.SyncAggregatorSelectionData{Slot: slot, SubcommitteeIndex: uint64(comIdx)}
 	return signing.ComputeSigningRoot(selectionData, dom)
 }
+
+func TestService_setSyncContributionIndexSlotSeen(t *testing.T) {
+	chainService := &mockChain.ChainService{
+		Genesis:        time.Now(),
+		ValidatorsRoot: [32]byte{'A'},
+	}
+	s := NewService(context.Background(), WithP2P(mockp2p.NewTestP2P(t)), WithStateNotifier(chainService.StateNotifier()))
+	s.initCaches()
+
+	// Empty cache
+	b0 := bitfield.NewBitvector128()
+	b0.SetBitAt(0, true)
+	has, err := s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		AggregationBits: b0,
+	})
+	require.NoError(t, err)
+	require.Equal(t, false, has)
+
+	// Cache with entries but same key
+	require.NoError(t, s.setSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		AggregationBits: b0,
+	}))
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		AggregationBits: b0,
+	})
+	require.NoError(t, err)
+	require.Equal(t, true, has)
+	b1 := bitfield.NewBitvector128()
+	b1.SetBitAt(1, true)
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		AggregationBits: b1,
+	})
+	require.NoError(t, err)
+	require.Equal(t, false, has)
+	b2 := bitfield.NewBitvector128()
+	b2.SetBitAt(1, true)
+	b2.SetBitAt(2, true)
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		AggregationBits: b2,
+	})
+	require.NoError(t, err)
+	require.Equal(t, false, has)
+	b2.SetBitAt(0, true)
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		AggregationBits: b2,
+	})
+	require.NoError(t, err)
+	require.Equal(t, true, has)
+
+	// Make sure set doesn't contain existing overlaps
+	require.Equal(t, 1, s.syncContributionBitsOverlapCache.Len())
+
+	// Cache with entries but different key
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		Slot:              1,
+		SubcommitteeIndex: 2,
+		BlockRoot:         []byte{'A'},
+		AggregationBits:   b0,
+	})
+	require.NoError(t, err)
+	require.Equal(t, false, has)
+	require.NoError(t, s.setSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		Slot:              1,
+		SubcommitteeIndex: 2,
+		BlockRoot:         []byte{'A'},
+		AggregationBits:   b2,
+	}))
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		Slot:              1,
+		SubcommitteeIndex: 2,
+		BlockRoot:         []byte{'A'},
+		AggregationBits:   b0,
+	})
+	require.NoError(t, err)
+	require.Equal(t, true, has)
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		Slot:              1,
+		SubcommitteeIndex: 2,
+		BlockRoot:         []byte{'A'},
+		AggregationBits:   b1,
+	})
+	require.NoError(t, err)
+	require.Equal(t, true, has)
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		Slot:              1,
+		SubcommitteeIndex: 2,
+		BlockRoot:         []byte{'A'},
+		AggregationBits:   b2,
+	})
+	require.NoError(t, err)
+	require.Equal(t, true, has)
+
+	// Check invariant with the keys
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		Slot:              2,
+		SubcommitteeIndex: 2,
+		BlockRoot:         []byte{'A'},
+		AggregationBits:   b0,
+	})
+	require.NoError(t, err)
+	require.Equal(t, false, has)
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		Slot:              1,
+		SubcommitteeIndex: 2,
+		BlockRoot:         []byte{'B'},
+		AggregationBits:   b0,
+	})
+	require.NoError(t, err)
+	require.Equal(t, false, has)
+	has, err = s.hasSeenSyncContributionBits(&ethpb.SyncCommitteeContribution{
+		Slot:              1,
+		SubcommitteeIndex: 3,
+		BlockRoot:         []byte{'A'},
+		AggregationBits:   b0,
+	})
+	require.NoError(t, err)
+	require.Equal(t, false, has)
+}

cmd/beacon-chain/flags/base.go

@@ -211,4 +211,25 @@ var (
 		Usage: "Post bellatrix, this address will receive the transaction fees produced by any blocks from this node. Default to junk whilst bellatrix is in development state. Validator client can override this value through the preparebeaconproposer api.",
 		Value: fieldparams.EthBurnAddressHex,
 	}
+	// TerminalTotalDifficultyOverride specifies the total difficulty to manual overrides the `TERMINAL_TOTAL_DIFFICULTY` parameter.
+	TerminalTotalDifficultyOverride = &cli.StringFlag{
+		Name: "terminal-total-difficulty-override",
+		Usage: "Sets the total difficulty to manual overrides the default TERMINAL_TOTAL_DIFFICULTY value. " +
+			"WARNING: This flag should be used only if you have a clear understanding that community has decided to override the terminal difficulty. " +
+			"Incorrect usage will result in your node experience consensus failure.",
+	}
+	// TerminalBlockHashOverride specifies the terminal block hash to manual overrides the `TERMINAL_BLOCK_HASH` parameter.
+	TerminalBlockHashOverride = &cli.StringFlag{
+		Name: "terminal-block-hash-override",
+		Usage: "Sets the block hash to manual overrides the default TERMINAL_BLOCK_HASH value. " +
+			"WARNING: This flag should be used only if you have a clear understanding that community has decided to override the terminal block hash. " +
+			"Incorrect usage will result in your node experience consensus failure.",
+	}
+	// TerminalBlockHashActivationEpochOverride specifies the terminal block hash epoch to manual overrides the `TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH` parameter.
+	TerminalBlockHashActivationEpochOverride = &cli.Uint64Flag{
+		Name: "terminal-block-hash-epoch-override",
+		Usage: "Sets the block hash epoch to manual overrides the default TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH value. " +
+			"WARNING: This flag should be used only if you have a clear understanding that community has decided to override the terminal block hash activation epoch. " +
+			"Incorrect usage will result in your node experience consensus failure.",
+	}
 )

cmd/beacon-chain/main.go

@@ -69,6 +69,9 @@ var appFlags = []cli.Flag{
 	flags.Eth1HeaderReqLimit,
 	flags.MinPeersPerSubnet,
 	flags.SuggestedFeeRecipient,
+	flags.TerminalTotalDifficultyOverride,
+	flags.TerminalBlockHashOverride,
+	flags.TerminalBlockHashActivationEpochOverride,
 	cmd.EnableBackupWebhookFlag,
 	cmd.BackupWebhookOutputDir,
 	cmd.MinimalConfigFlag,

cmd/beacon-chain/usage.go

@@ -137,6 +137,9 @@ var appHelpFlagGroups = []flagGroup{
 		Name: "merge",
 		Flags: []cli.Flag{
 			flags.SuggestedFeeRecipient,
+			flags.TerminalTotalDifficultyOverride,
+			flags.TerminalBlockHashOverride,
+			flags.TerminalBlockHashActivationEpochOverride,
 		},
 	},
 	{

cmd/prysmctl/checkpoint/latest.go

@@ -44,12 +44,12 @@ func cliActionLatest(_ *cli.Context) error {
 		return err
 	}
 
-	od, err := beacon.DownloadOriginData(ctx, client)
+	ws, err := beacon.ComputeWeakSubjectivityCheckpoint(ctx, client)
 	if err != nil {
 		return err
 	}
 	fmt.Println("\nUse the following flag when starting a prysm Beacon Node to ensure the chain history " +
 		"includes the Weak Subjectivity Checkpoint: ")
-	fmt.Printf("--weak-subjectivity-checkpoint=%s\n\n", od.CheckpointString())
+	fmt.Printf("--weak-subjectivity-checkpoint=%s\n\n", ws.CheckpointString())
 	return nil
 }

cmd/prysmctl/checkpoint/save.go

@@ -17,7 +17,7 @@ var saveFlags = struct {
 
 var saveCmd = &cli.Command{
 	Name:   "save",
-	Usage:  "Query for the current weak subjectivity period epoch, then download the corresponding state and block. To be used for checkpoint sync.",
+	Usage:  "Save the latest finalized header and the most recent block it integrates. To be used for checkpoint sync.",
 	Action: cliActionSave,
 	Flags: []cli.Flag{
 		&cli.StringFlag{
@@ -50,7 +50,7 @@ func cliActionSave(_ *cli.Context) error {
 		return err
 	}
 
-	od, err := beacon.DownloadOriginData(ctx, client)
+	od, err := beacon.DownloadFinalizedData(ctx, client)
 	if err != nil {
 		return err
 	}

config/params/config.go

@@ -110,6 +110,7 @@ type BeaconChainConfig struct {
 	DomainSyncCommittee               [4]byte `yaml:"DOMAIN_SYNC_COMMITTEE" spec:"true"`                 // DomainVoluntaryExit defines the BLS signature domain for sync committee.
 	DomainSyncCommitteeSelectionProof [4]byte `yaml:"DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF" spec:"true"` // DomainSelectionProof defines the BLS signature domain for sync committee selection proof.
 	DomainContributionAndProof        [4]byte `yaml:"DOMAIN_CONTRIBUTION_AND_PROOF" spec:"true"`         // DomainAggregateAndProof defines the BLS signature domain for contribution and proof.
+	DomainApplicationMask             [4]byte `yaml:"DOMAIN_APPLICATION_MASK" spec:"true"`               // DomainApplicationMask defines the BLS signature domain for application mask.
 
 	// Prysm constants.
 	GweiPerEth                     uint64        // GweiPerEth is the amount of gwei corresponding to 1 eth.

config/params/mainnet_config.go

@@ -155,16 +155,17 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	MaxVoluntaryExits:    16,
 
 	// BLS domain values.
-	DomainBeaconProposer:              bytesutil.ToBytes4(bytesutil.Bytes4(0)),
-	DomainBeaconAttester:              bytesutil.ToBytes4(bytesutil.Bytes4(1)),
-	DomainRandao:                      bytesutil.ToBytes4(bytesutil.Bytes4(2)),
-	DomainDeposit:                     bytesutil.ToBytes4(bytesutil.Bytes4(3)),
-	DomainVoluntaryExit:               bytesutil.ToBytes4(bytesutil.Bytes4(4)),
-	DomainSelectionProof:              bytesutil.ToBytes4(bytesutil.Bytes4(5)),
-	DomainAggregateAndProof:           bytesutil.ToBytes4(bytesutil.Bytes4(6)),
-	DomainSyncCommittee:               bytesutil.ToBytes4(bytesutil.Bytes4(7)),
-	DomainSyncCommitteeSelectionProof: bytesutil.ToBytes4(bytesutil.Bytes4(8)),
-	DomainContributionAndProof:        bytesutil.ToBytes4(bytesutil.Bytes4(9)),
+	DomainBeaconProposer:              bytesutil.Uint32ToBytes4(0x00000000),
+	DomainBeaconAttester:              bytesutil.Uint32ToBytes4(0x01000000),
+	DomainRandao:                      bytesutil.Uint32ToBytes4(0x02000000),
+	DomainDeposit:                     bytesutil.Uint32ToBytes4(0x03000000),
+	DomainVoluntaryExit:               bytesutil.Uint32ToBytes4(0x04000000),
+	DomainSelectionProof:              bytesutil.Uint32ToBytes4(0x05000000),
+	DomainAggregateAndProof:           bytesutil.Uint32ToBytes4(0x06000000),
+	DomainSyncCommittee:               bytesutil.Uint32ToBytes4(0x07000000),
+	DomainSyncCommitteeSelectionProof: bytesutil.Uint32ToBytes4(0x08000000),
+	DomainContributionAndProof:        bytesutil.Uint32ToBytes4(0x09000000),
+	DomainApplicationMask:             bytesutil.Uint32ToBytes4(0x00000001),
 
 	// Prysm constants.
 	GweiPerEth:                     1000000000,

config/params/testnet_ropsten_config.go

@@ -32,7 +32,7 @@ func RopstenConfig() *BeaconChainConfig {
 	cfg.AltairForkVersion = []byte{0x80, 0x00, 0x00, 0x70}
 	cfg.BellatrixForkEpoch = 750
 	cfg.BellatrixForkVersion = []byte{0x80, 0x00, 0x00, 0x71}
-	cfg.TerminalTotalDifficulty = "43531756765713534"
+	cfg.TerminalTotalDifficulty = "100000000000000000000000"
 	cfg.DepositContractAddress = "0x6f22fFbC56eFF051aECF839396DD1eD9aD6BBA9D"
 	cfg.InitializeForkSchedule()
 	return cfg

consensus-types/wrapper/BUILD.bazel

@@ -14,6 +14,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/consensus-types/wrapper",
     visibility = ["//visibility:public"],
     deps = [
+        "//consensus-types/forks/bellatrix:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//proto/engine/v1:go_default_library",
@@ -39,6 +40,8 @@ go_test(
     ],
     deps = [
         ":go_default_library",
+        "//config/fieldparams:go_default_library",
+        "//consensus-types/forks/bellatrix:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
@@ -48,5 +51,6 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
     ],
 )

consensus-types/wrapper/beacon_block.go

@@ -1,8 +1,12 @@
 package wrapper
 
 import (
+	"fmt"
+
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
 
@@ -145,6 +149,115 @@ func BuildSignedBeaconBlock(blk interfaces.BeaconBlock, signature []byte) (inter
 	}
 }
 
+// BuildSignedBeaconBlockFromExecutionPayload takes a signed, blinded beacon block and converts into
+// a full, signed beacon block by specifying an execution payload.
+func BuildSignedBeaconBlockFromExecutionPayload(
+	blk interfaces.SignedBeaconBlock, payload *enginev1.ExecutionPayload,
+) (interfaces.SignedBeaconBlock, error) {
+	if err := BeaconBlockIsNil(blk); err != nil {
+		return nil, err
+	}
+	b := blk.Block()
+	payloadHeader, err := b.Body().ExecutionPayloadHeader()
+	switch {
+	case errors.Is(err, ErrUnsupportedField):
+		return nil, errors.Wrap(err, "can only build signed beacon block from blinded format")
+	case err != nil:
+		return nil, errors.Wrap(err, "could not get execution payload header")
+	default:
+	}
+	payloadRoot, err := payload.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not hash tree root execution payload")
+	}
+	payloadHeaderRoot, err := payloadHeader.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not hash tree root payload header")
+	}
+	if payloadRoot != payloadHeaderRoot {
+		return nil, fmt.Errorf(
+			"payload %#x and header %#x roots do not match",
+			payloadRoot,
+			payloadHeaderRoot,
+		)
+	}
+	syncAgg, err := b.Body().SyncAggregate()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get sync aggregate from block body")
+	}
+	bellatrixFullBlock := &eth.SignedBeaconBlockBellatrix{
+		Block: &eth.BeaconBlockBellatrix{
+			Slot:          b.Slot(),
+			ProposerIndex: b.ProposerIndex(),
+			ParentRoot:    b.ParentRoot(),
+			StateRoot:     b.StateRoot(),
+			Body: &eth.BeaconBlockBodyBellatrix{
+				RandaoReveal:      b.Body().RandaoReveal(),
+				Eth1Data:          b.Body().Eth1Data(),
+				Graffiti:          b.Body().Graffiti(),
+				ProposerSlashings: b.Body().ProposerSlashings(),
+				AttesterSlashings: b.Body().AttesterSlashings(),
+				Attestations:      b.Body().Attestations(),
+				Deposits:          b.Body().Deposits(),
+				VoluntaryExits:    b.Body().VoluntaryExits(),
+				SyncAggregate:     syncAgg,
+				ExecutionPayload:  payload,
+			},
+		},
+		Signature: blk.Signature(),
+	}
+	return wrappedBellatrixSignedBeaconBlock(bellatrixFullBlock)
+}
+
+// WrapSignedBlindedBeaconBlock converts a signed beacon block into a blinded format.
+func WrapSignedBlindedBeaconBlock(blk interfaces.SignedBeaconBlock) (interfaces.SignedBeaconBlock, error) {
+	if err := BeaconBlockIsNil(blk); err != nil {
+		return nil, err
+	}
+	if blk.Block().IsBlinded() {
+		return blk, nil
+	}
+	b := blk.Block()
+	payload, err := b.Body().ExecutionPayload()
+	switch {
+	case errors.Is(err, ErrUnsupportedField):
+		return nil, ErrUnsupportedSignedBeaconBlock
+	case err != nil:
+		return nil, errors.Wrap(err, "could not get execution payload")
+	default:
+	}
+	syncAgg, err := b.Body().SyncAggregate()
+	if err != nil {
+		return nil, err
+	}
+	header, err := bellatrix.PayloadToHeader(payload)
+	if err != nil {
+		return nil, err
+	}
+	blindedBlock := &eth.SignedBlindedBeaconBlockBellatrix{
+		Block: &eth.BlindedBeaconBlockBellatrix{
+			Slot:          b.Slot(),
+			ProposerIndex: b.ProposerIndex(),
+			ParentRoot:    b.ParentRoot(),
+			StateRoot:     b.StateRoot(),
+			Body: &eth.BlindedBeaconBlockBodyBellatrix{
+				RandaoReveal:           b.Body().RandaoReveal(),
+				Eth1Data:               b.Body().Eth1Data(),
+				Graffiti:               b.Body().Graffiti(),
+				ProposerSlashings:      b.Body().ProposerSlashings(),
+				AttesterSlashings:      b.Body().AttesterSlashings(),
+				Attestations:           b.Body().Attestations(),
+				Deposits:               b.Body().Deposits(),
+				VoluntaryExits:         b.Body().VoluntaryExits(),
+				SyncAggregate:          syncAgg,
+				ExecutionPayloadHeader: header,
+			},
+		},
+		Signature: blk.Signature(),
+	}
+	return wrappedBellatrixSignedBlindedBeaconBlock(blindedBlock)
+}
+
 func UnwrapGenericSignedBeaconBlock(gb *eth.GenericSignedBeaconBlock) (interfaces.SignedBeaconBlock, error) {
 	if gb == nil {
 		return nil, ErrNilObjectWrapped

consensus-types/wrapper/beacon_block_test.go

@@ -3,11 +3,121 @@ package wrapper_test
 import (
 	"testing"
 
+	"github.com/pkg/errors"
+	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/consensus-types/forks/bellatrix"
 	"github.com/prysmaticlabs/prysm/consensus-types/wrapper"
+	enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
 	"github.com/prysmaticlabs/prysm/testing/require"
 	"github.com/prysmaticlabs/prysm/testing/util"
 )
 
+func TestBuildSignedBeaconBlockFromExecutionPayload(t *testing.T) {
+	t.Run("nil block check", func(t *testing.T) {
+		_, err := wrapper.BuildSignedBeaconBlockFromExecutionPayload(nil, nil)
+		require.ErrorIs(t, wrapper.ErrNilSignedBeaconBlock, err)
+	})
+	t.Run("unsupported field payload header", func(t *testing.T) {
+		altairBlock := util.NewBeaconBlockAltair()
+		blk, err := wrapper.WrappedSignedBeaconBlock(altairBlock)
+		require.NoError(t, err)
+		_, err = wrapper.BuildSignedBeaconBlockFromExecutionPayload(blk, nil)
+		require.Equal(t, true, errors.Is(err, wrapper.ErrUnsupportedField))
+	})
+	t.Run("payload header root and payload root mismatch", func(t *testing.T) {
+		payload := &enginev1.ExecutionPayload{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, 20),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, 256),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
+			Transactions:  make([][]byte, 0),
+		}
+		header, err := bellatrix.PayloadToHeader(payload)
+		require.NoError(t, err)
+		blindedBlock := util.NewBlindedBeaconBlockBellatrix()
+
+		// Modify the header.
+		header.GasUsed += 1
+		blindedBlock.Block.Body.ExecutionPayloadHeader = header
+
+		blk, err := wrapper.WrappedSignedBeaconBlock(blindedBlock)
+		require.NoError(t, err)
+		_, err = wrapper.BuildSignedBeaconBlockFromExecutionPayload(blk, payload)
+		require.ErrorContains(t, "roots do not match", err)
+	})
+	t.Run("ok", func(t *testing.T) {
+		payload := &enginev1.ExecutionPayload{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, 20),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, 256),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
+			Transactions:  make([][]byte, 0),
+		}
+		header, err := bellatrix.PayloadToHeader(payload)
+		require.NoError(t, err)
+		blindedBlock := util.NewBlindedBeaconBlockBellatrix()
+		blindedBlock.Block.Body.ExecutionPayloadHeader = header
+
+		blk, err := wrapper.WrappedSignedBeaconBlock(blindedBlock)
+		require.NoError(t, err)
+		builtBlock, err := wrapper.BuildSignedBeaconBlockFromExecutionPayload(blk, payload)
+		require.NoError(t, err)
+
+		got, err := builtBlock.Block().Body().ExecutionPayload()
+		require.NoError(t, err)
+		require.DeepEqual(t, payload, got)
+	})
+}
+
+func TestWrapSignedBlindedBeaconBlock(t *testing.T) {
+	t.Run("nil block check", func(t *testing.T) {
+		_, err := wrapper.BuildSignedBeaconBlockFromExecutionPayload(nil, nil)
+		require.ErrorIs(t, wrapper.ErrNilSignedBeaconBlock, err)
+	})
+	t.Run("unsupported field execution payload", func(t *testing.T) {
+		altairBlock := util.NewBeaconBlockAltair()
+		blk, err := wrapper.WrappedSignedBeaconBlock(altairBlock)
+		require.NoError(t, err)
+		_, err = wrapper.BuildSignedBeaconBlockFromExecutionPayload(blk, nil)
+		require.Equal(t, true, errors.Is(err, wrapper.ErrUnsupportedField))
+	})
+	t.Run("ok", func(t *testing.T) {
+		payload := &enginev1.ExecutionPayload{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, 20),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, 256),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
+			Transactions:  make([][]byte, 0),
+		}
+		bellatrixBlk := util.NewBeaconBlockBellatrix()
+		bellatrixBlk.Block.Body.ExecutionPayload = payload
+
+		want, err := bellatrix.PayloadToHeader(payload)
+		require.NoError(t, err)
+
+		blk, err := wrapper.WrappedSignedBeaconBlock(bellatrixBlk)
+		require.NoError(t, err)
+		builtBlock, err := wrapper.WrapSignedBlindedBeaconBlock(blk)
+		require.NoError(t, err)
+
+		got, err := builtBlock.Block().Body().ExecutionPayloadHeader()
+		require.NoError(t, err)
+		require.DeepEqual(t, want, got)
+	})
+}
+
 func TestWrappedSignedBeaconBlock(t *testing.T) {
 	tests := []struct {
 		name    string

deps.bzl

@@ -1247,7 +1247,7 @@ def prysm_deps():
     go_repository(
         name = "com_github_gogo_protobuf",
         importpath = "github.com/gogo/protobuf",
-        commit = "b03c65ea87cdc3521ede29f62fe3ce239267c1bc",
+        sum = "h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=",
         version = "v1.3.2",
     )
 
@@ -4504,8 +4504,8 @@ def prysm_deps():
     go_repository(
         name = "org_golang_x_mod",
         importpath = "golang.org/x/mod",
-        sum = "h1:kQgndtyPBW/JIYERgdxfwMYh3AVStj88WQTlNDi2a+o=",
-        version = "v0.6.0-dev.0.20220106191415-9b9b3d81d5e3",
+        sum = "h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=",
+        version = "v0.6.0-dev.0.20220419223038-86c51ed26bb4",
     )
 
     go_repository(
@@ -4561,8 +4561,8 @@ def prysm_deps():
     go_repository(
         name = "org_golang_x_tools",
         importpath = "golang.org/x/tools",
-        sum = "h1:QjFRCZxdOhBJ/UNgnBZLbNV13DlbnK0quyivTnXJM20=",
-        version = "v0.1.10",
+        sum = "h1:FsZrnczqPMLkWZqyqBPGYJTko7xFkWqyypB7a4Xldkw=",
+        version = "v0.1.11-0.20220523181440-ccb10502d1a5",
     )
 
     go_repository(

encoding/bytesutil/bytes.go

@@ -339,6 +339,14 @@ func HighestBitIndexAt(b []byte, index int) (int, error) {
 	return 0, nil
 }
 
+// Uint32ToBytes4 is a convenience method for converting uint32 to a fix
+// sized 4 byte array in big endian order. Returns 4 byte array.
+func Uint32ToBytes4(i uint32) [4]byte {
+	buf := make([]byte, 4)
+	binary.BigEndian.PutUint32(buf, i)
+	return ToBytes4(buf)
+}
+
 // Uint64ToBytesLittleEndian conversion.
 func Uint64ToBytesLittleEndian(i uint64) []byte {
 	buf := make([]byte, 8)

encoding/bytesutil/bytes_test.go

@@ -2,6 +2,7 @@ package bytesutil_test
 
 import (
 	"bytes"
+	"fmt"
 	"reflect"
 	"testing"
 
@@ -582,3 +583,26 @@ func TestIsValidRoot(t *testing.T) {
 		})
 	}
 }
+
+func TestUint32ToBytes4(t *testing.T) {
+	tests := []struct {
+		value uint32
+		want  [4]byte
+	}{
+		{
+			value: 0x01000000,
+			want:  [4]byte{1, 0, 0, 0},
+		},
+		{
+			value: 0x00000001,
+			want:  [4]byte{0, 0, 0, 1},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(fmt.Sprintf("0x%08x", tt.value), func(t *testing.T) {
+			if got := bytesutil.Uint32ToBytes4(tt.value); !bytes.Equal(got[:], tt.want[:]) {
+				t.Errorf("Uint32ToBytes4() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

go.mod

@@ -87,9 +87,9 @@ require (
 	go.uber.org/automaxprocs v1.3.0
 	golang.org/x/crypto v0.0.0-20220321153916-2c7772ba3064
 	golang.org/x/exp v0.0.0-20200513190911-00229845015e
-	golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3
+	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	golang.org/x/tools v0.1.10
+	golang.org/x/tools v0.1.11-0.20220523181440-ccb10502d1a5
 	google.golang.org/genproto v0.0.0-20210426193834-eac7f76ac494
 	google.golang.org/grpc v1.40.0
 	google.golang.org/protobuf v1.28.0
@@ -242,7 +242,6 @@ require (
 	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
 	golang.org/x/text v0.3.7 // indirect
 	golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect

go.sum

@@ -1534,8 +1534,8 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
-golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3 h1:kQgndtyPBW/JIYERgdxfwMYh3AVStj88WQTlNDi2a+o=
-golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1823,8 +1823,8 @@ golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
-golang.org/x/tools v0.1.10 h1:QjFRCZxdOhBJ/UNgnBZLbNV13DlbnK0quyivTnXJM20=
-golang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E=
+golang.org/x/tools v0.1.11-0.20220523181440-ccb10502d1a5 h1:FsZrnczqPMLkWZqyqBPGYJTko7xFkWqyypB7a4Xldkw=
+golang.org/x/tools v0.1.11-0.20220523181440-ccb10502d1a5/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

proto/engine/v1/BUILD.bazel

@@ -72,6 +72,7 @@ go_library(
         "@io_bazel_rules_go//proto/wkt:descriptor_go_proto",
         "@com_github_golang_protobuf//proto:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@io_bazel_rules_go//proto/wkt:timestamp_go_proto",
         "@go_googleapis//google/api:annotations_go_proto",
         "@org_golang_google_protobuf//encoding/protojson:go_default_library",

proto/engine/v1/json_marshal_unmarshal.go

@@ -5,6 +5,7 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
 )
@@ -157,6 +158,141 @@ func (e *ExecutionBlock) UnmarshalJSON(enc []byte) error {
 	return nil
 }
 
+type ExecutionBlockWithTxs struct {
+	ExecutionBlock
+}
+
+type executionBlockWithTxsJSON struct {
+	Number           string               `json:"number"`
+	Hash             hexutil.Bytes        `json:"hash"`
+	ParentHash       hexutil.Bytes        `json:"parentHash"`
+	Sha3Uncles       hexutil.Bytes        `json:"sha3Uncles"`
+	Miner            hexutil.Bytes        `json:"miner"`
+	StateRoot        hexutil.Bytes        `json:"stateRoot"`
+	TransactionsRoot hexutil.Bytes        `json:"transactionsRoot"`
+	ReceiptsRoot     hexutil.Bytes        `json:"receiptsRoot"`
+	LogsBloom        hexutil.Bytes        `json:"logsBloom"`
+	Difficulty       string               `json:"difficulty"`
+	TotalDifficulty  string               `json:"totalDifficulty"`
+	GasLimit         hexutil.Uint64       `json:"gasLimit"`
+	GasUsed          hexutil.Uint64       `json:"gasUsed"`
+	Timestamp        hexutil.Uint64       `json:"timestamp"`
+	BaseFeePerGas    string               `json:"baseFeePerGas"`
+	ExtraData        hexutil.Bytes        `json:"extraData"`
+	MixHash          hexutil.Bytes        `json:"mixHash"`
+	Nonce            hexutil.Bytes        `json:"nonce"`
+	Size             string               `json:"size"`
+	Transactions     []*types.Transaction `json:"transactions"`
+	Uncles           []hexutil.Bytes      `json:"uncles"`
+}
+
+// MarshalJSON defines a custom json.Marshaler interface implementation
+// that uses custom json.Marshalers for the hexutil.Bytes and hexutil.Uint64 types.
+func (e *ExecutionBlockWithTxs) MarshalJSON() ([]byte, error) {
+	transactions := make([]hexutil.Bytes, len(e.Transactions))
+	for i, tx := range e.Transactions {
+		transactions[i] = tx
+	}
+	uncles := make([]hexutil.Bytes, len(e.Uncles))
+	for i, ucl := range e.Uncles {
+		uncles[i] = ucl
+	}
+	num := new(big.Int).SetBytes(e.Number)
+	numHex := hexutil.EncodeBig(num)
+
+	diff := new(big.Int).SetBytes(e.Difficulty)
+	diffHex := hexutil.EncodeBig(diff)
+
+	size := new(big.Int).SetBytes(e.Size)
+	sizeHex := hexutil.EncodeBig(size)
+
+	baseFee := new(big.Int).SetBytes(bytesutil.ReverseByteOrder(e.BaseFeePerGas))
+	baseFeeHex := hexutil.EncodeBig(baseFee)
+	return json.Marshal(executionBlockJSON{
+		Number:           numHex,
+		Hash:             e.Hash,
+		ParentHash:       e.ParentHash,
+		Sha3Uncles:       e.Sha3Uncles,
+		Miner:            e.Miner,
+		StateRoot:        e.StateRoot,
+		TransactionsRoot: e.TransactionsRoot,
+		ReceiptsRoot:     e.ReceiptsRoot,
+		LogsBloom:        e.LogsBloom,
+		Difficulty:       diffHex,
+		TotalDifficulty:  e.TotalDifficulty,
+		GasLimit:         hexutil.Uint64(e.GasLimit),
+		GasUsed:          hexutil.Uint64(e.GasUsed),
+		Timestamp:        hexutil.Uint64(e.Timestamp),
+		ExtraData:        e.ExtraData,
+		MixHash:          e.MixHash,
+		Nonce:            e.Nonce,
+		Size:             sizeHex,
+		BaseFeePerGas:    baseFeeHex,
+		Transactions:     transactions,
+		Uncles:           uncles,
+	})
+}
+
+// UnmarshalJSON defines a custom json.Unmarshaler interface implementation
+// that uses custom json.Unmarshalers for the hexutil.Bytes and hexutil.Uint64 types.
+func (e *ExecutionBlockWithTxs) UnmarshalJSON(enc []byte) error {
+	dec := executionBlockWithTxsJSON{}
+	if err := json.Unmarshal(enc, &dec); err != nil {
+		return err
+	}
+	*e = ExecutionBlockWithTxs{}
+	num, err := hexutil.DecodeBig(dec.Number)
+	if err != nil {
+		return err
+	}
+	e.Number = num.Bytes()
+	e.Hash = dec.Hash
+	e.ParentHash = dec.ParentHash
+	e.Sha3Uncles = dec.Sha3Uncles
+	e.Miner = dec.Miner
+	e.StateRoot = dec.StateRoot
+	e.TransactionsRoot = dec.TransactionsRoot
+	e.ReceiptsRoot = dec.ReceiptsRoot
+	e.LogsBloom = dec.LogsBloom
+	diff, err := hexutil.DecodeBig(dec.Difficulty)
+	if err != nil {
+		return err
+	}
+	e.Difficulty = diff.Bytes()
+	e.TotalDifficulty = dec.TotalDifficulty
+	e.GasLimit = uint64(dec.GasLimit)
+	e.GasUsed = uint64(dec.GasUsed)
+	e.Timestamp = uint64(dec.Timestamp)
+	e.ExtraData = dec.ExtraData
+	e.MixHash = dec.MixHash
+	e.Nonce = dec.Nonce
+	size, err := hexutil.DecodeBig(dec.Size)
+	if err != nil {
+		return err
+	}
+	e.Size = size.Bytes()
+	baseFee, err := hexutil.DecodeBig(dec.BaseFeePerGas)
+	if err != nil {
+		return err
+	}
+	e.BaseFeePerGas = bytesutil.PadTo(bytesutil.ReverseByteOrder(baseFee.Bytes()), fieldparams.RootLength)
+	transactions := make([][]byte, len(dec.Transactions))
+	for i, tx := range dec.Transactions {
+		enc, err := tx.MarshalBinary()
+		if err != nil {
+			return err
+		}
+		transactions[i] = enc
+	}
+	e.Transactions = transactions
+	uncles := make([][]byte, len(dec.Uncles))
+	for i, ucl := range dec.Uncles {
+		uncles[i] = ucl
+	}
+	e.Uncles = uncles
+	return nil
+}
+
 type executionPayloadJSON struct {
 	ParentHash    hexutil.Bytes   `json:"parentHash"`
 	FeeRecipient  hexutil.Bytes   `json:"feeRecipient"`

proto/prysm/v1alpha1/sync_committee_mainnet.go

@@ -10,3 +10,7 @@ import (
 func NewSyncCommitteeAggregationBits() bitfield.Bitvector128 {
 	return bitfield.NewBitvector128()
 }
+
+func ConvertToSyncContributionBitVector(b []byte) bitfield.Bitvector128 {
+	return b
+}

proto/prysm/v1alpha1/sync_committee_minimal.go

@@ -10,3 +10,7 @@ import (
 func NewSyncCommitteeAggregationBits() bitfield.Bitvector8 {
 	return bitfield.NewBitvector8()
 }
+
+func ConvertToSyncContributionBitVector(b []byte) bitfield.Bitvector8 {
+	return b
+}

testing/endtoend/BUILD.bazel

@@ -5,6 +5,42 @@ load("@prysm//tools/go:def.bzl", "go_test")
 # gazelle:exclude mainnet_scenario_e2e_test.go
 # gazelle:exclude minimal_scenario_e2e_test.go
 
+common_deps = [
+    "//api/client/beacon:go_default_library",
+    "//beacon-chain/blockchain/testing:go_default_library",
+    "//beacon-chain/core/transition:go_default_library",
+    "//beacon-chain/db/testing:go_default_library",
+    "//beacon-chain/operations/slashings/mock:go_default_library",
+    "//beacon-chain/state/stategen/mock:go_default_library",
+    "//config/params:go_default_library",
+    "//consensus-types/primitives:go_default_library",
+    "//crypto/bls:go_default_library",
+    "//encoding/bytesutil:go_default_library",
+    "//io/file:go_default_library",
+    "//proto/eth/service:go_default_library",
+    "//proto/eth/v1:go_default_library",
+    "//proto/prysm/v1alpha1:go_default_library",
+    "//testing/assert:go_default_library",
+    "//testing/endtoend/components:go_default_library",
+    "//testing/endtoend/components/eth1:go_default_library",
+    "//testing/endtoend/evaluators:go_default_library",
+    "//testing/endtoend/helpers:go_default_library",
+    "//testing/endtoend/params:go_default_library",
+    "//testing/endtoend/types:go_default_library",
+    "//testing/require:go_default_library",
+    "//testing/slasher/simulator:go_default_library",
+    "//testing/util:go_default_library",
+    "@com_github_pkg_errors//:go_default_library",
+    "@com_github_sirupsen_logrus//:go_default_library",
+    "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+    "@org_golang_google_grpc//:go_default_library",
+    "@org_golang_google_grpc//codes:go_default_library",
+    "@org_golang_google_grpc//status:go_default_library",
+    "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
+    "@org_golang_x_sync//errgroup:go_default_library",
+]
+
+# gazelle:ignore
 go_test(
     name = "go_default_test",
     size = "large",
@@ -35,33 +71,7 @@ go_test(
         "minimal",
         "requires-network",
     ],
-    deps = [
-        "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/operations/slashings/mock:go_default_library",
-        "//beacon-chain/state/stategen/mock:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/endtoend/components:go_default_library",
-        "//testing/endtoend/components/eth1:go_default_library",
-        "//testing/endtoend/evaluators:go_default_library",
-        "//testing/endtoend/helpers:go_default_library",
-        "//testing/endtoend/params:go_default_library",
-        "//testing/endtoend/types:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/slasher/simulator:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
-        "@org_golang_x_sync//errgroup:go_default_library",
-    ],
+    deps = common_deps,
 )
 
 go_test(
@@ -93,34 +103,7 @@ go_test(
         "manual",
         "requires-network",
     ],
-    deps = [
-        "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/operations/slashings:go_default_library",
-        "//beacon-chain/state/stategen:go_default_library",
-        "//build/bazel:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/endtoend/components:go_default_library",
-        "//testing/endtoend/components/eth1:go_default_library",
-        "//testing/endtoend/evaluators:go_default_library",
-        "//testing/endtoend/helpers:go_default_library",
-        "//testing/endtoend/params:go_default_library",
-        "//testing/endtoend/types:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/slasher/simulator:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
-        "@org_golang_x_sync//errgroup:go_default_library",
-    ],
+    deps = common_deps,
 )
 
 go_test(
@@ -152,34 +135,7 @@ go_test(
         "requires-network",
         "scenario",
     ],
-    deps = [
-        "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/operations/slashings:go_default_library",
-        "//beacon-chain/state/stategen:go_default_library",
-        "//build/bazel:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/endtoend/components:go_default_library",
-        "//testing/endtoend/components/eth1:go_default_library",
-        "//testing/endtoend/evaluators:go_default_library",
-        "//testing/endtoend/helpers:go_default_library",
-        "//testing/endtoend/params:go_default_library",
-        "//testing/endtoend/types:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/slasher/simulator:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
-        "@org_golang_x_sync//errgroup:go_default_library",
-    ],
+    deps = common_deps,
 )
 
 go_test(
@@ -211,32 +167,5 @@ go_test(
         "requires-network",
         "scenario",
     ],
-    deps = [
-        "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/db/testing:go_default_library",
-        "//beacon-chain/operations/slashings:go_default_library",
-        "//beacon-chain/state/stategen:go_default_library",
-        "//build/bazel:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/endtoend/components:go_default_library",
-        "//testing/endtoend/components/eth1:go_default_library",
-        "//testing/endtoend/evaluators:go_default_library",
-        "//testing/endtoend/helpers:go_default_library",
-        "//testing/endtoend/params:go_default_library",
-        "//testing/endtoend/types:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/slasher/simulator:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-        "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
-        "@org_golang_x_sync//errgroup:go_default_library",
-    ],
+    deps = common_deps,
 )

testing/endtoend/component_handler_test.go

@@ -129,6 +129,9 @@ func (c *componentHandler) setup() {
 		return nil
 	})
 
+	if config.TestCheckpointSync {
+		appendDebugEndpoints(config)
+	}
 	// Beacon nodes.
 	beaconNodes := components.NewBeaconNodes(config)
 	g.Go(func() error {
@@ -201,3 +204,11 @@ func (c *componentHandler) required() []e2etypes.ComponentRunner {
 	}
 	return requiredComponents
 }
+
+func appendDebugEndpoints(cfg *e2etypes.E2EConfig) {
+	debug := []string{
+		"--enable-debug-rpc-endpoints",
+		"--grpc-max-msg-size=65568081",
+	}
+	cfg.BeaconFlags = append(cfg.BeaconFlags, debug...)
+}

testing/endtoend/components/beacon_node.go

@@ -175,6 +175,9 @@ func (node *BeaconNode) Start(ctx context.Context) error {
 	if node.config.TestSync {
 		expectedNumOfPeers += 1
 	}
+	if node.config.TestCheckpointSync {
+		expectedNumOfPeers += 1
+	}
 	jwtPath := path.Join(e2e.TestParams.TestPath, "eth1data/"+strconv.Itoa(node.index)+"/")
 	if index == 0 {
 		jwtPath = path.Join(e2e.TestParams.TestPath, "eth1data/miner/")

testing/endtoend/components/web3remotesigner_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 func TestWeb3RemoteSigner_StartsAndReturnsPublicKeys(t *testing.T) {
-	require.NoError(t, e2eparams.Init(0))
+	require.NoError(t, e2eparams.Init(t, 0))
 
 	wsc := components.NewWeb3RemoteSigner()
 

testing/endtoend/endtoend_setup_test.go

@@ -14,10 +14,10 @@ import (
 	"github.com/prysmaticlabs/prysm/testing/require"
 )
 
-func e2eMinimal(t *testing.T, useWeb3RemoteSigner bool, extraEpochs uint64) *testRunner {
+func e2eMinimal(t *testing.T, cfgo ...types.E2EConfigOpt) *testRunner {
 	params.SetupTestConfigCleanup(t)
 	params.OverrideBeaconConfig(params.E2ETestConfig().Copy())
-	require.NoError(t, e2eParams.Init(e2eParams.StandardBeaconCount))
+	require.NoError(t, e2eParams.Init(t, e2eParams.StandardBeaconCount))
 
 	// Run for 12 epochs if not in long-running to confirm long-running has no issues.
 	var err error
@@ -74,12 +74,13 @@ func e2eMinimal(t *testing.T, useWeb3RemoteSigner bool, extraEpochs uint64) *tes
 		TestDeposits:        true,
 		UsePrysmShValidator: false,
 		UsePprof:            !longRunning,
-		UseWeb3RemoteSigner: useWeb3RemoteSigner,
 		TracingSinkEndpoint: tracingEndpoint,
 		Evaluators:          evals,
 		EvalInterceptor:     defaultInterceptor,
 		Seed:                int64(seed),
-		ExtraEpochs:         extraEpochs,
+	}
+	for _, o := range cfgo {
+		o(testConfig)
 	}
 
 	return newTestRunner(t, testConfig)
@@ -89,9 +90,9 @@ func e2eMainnet(t *testing.T, usePrysmSh, useMultiClient bool) *testRunner {
 	params.SetupTestConfigCleanup(t)
 	params.OverrideBeaconConfig(params.E2EMainnetTestConfig())
 	if useMultiClient {
-		require.NoError(t, e2eParams.InitMultiClient(e2eParams.StandardBeaconCount, e2eParams.StandardLighthouseNodeCount))
+		require.NoError(t, e2eParams.InitMultiClient(t, e2eParams.StandardBeaconCount, e2eParams.StandardLighthouseNodeCount))
 	} else {
-		require.NoError(t, e2eParams.Init(e2eParams.StandardBeaconCount))
+		require.NoError(t, e2eParams.Init(t, e2eParams.StandardBeaconCount))
 	}
 	// Run for 10 epochs if not in long-running to confirm long-running has no issues.
 	var err error
@@ -165,7 +166,6 @@ func scenarioEvals() []types.Evaluator {
 		ev.MetricsCheck,
 		ev.ValidatorsParticipatingAtEpoch(2),
 		ev.FinalizationOccurs(3),
-		ev.PeersCheck,
 		ev.VerifyBlockGraffiti,
 		ev.ProposeVoluntaryExit,
 		ev.ValidatorHasExited,
@@ -179,3 +179,22 @@ func scenarioEvals() []types.Evaluator {
 		ev.ValidatorSyncParticipation,
 	}
 }
+
+func scenarioEvalsMulti() []types.Evaluator {
+	return []types.Evaluator{
+		ev.PeersConnect,
+		ev.HealthzCheck,
+		ev.MetricsCheck,
+		ev.ValidatorsParticipatingAtEpoch(2),
+		ev.FinalizationOccurs(3),
+		ev.ProposeVoluntaryExit,
+		ev.ValidatorHasExited,
+		ev.ColdStateCheckpoint,
+		ev.AltairForkTransition,
+		ev.BellatrixForkTransition,
+		ev.APIMiddlewareVerifyIntegrity,
+		ev.APIGatewayV1Alpha1VerifyIntegrity,
+		ev.FinishedSyncing,
+		ev.AllNodesHaveSameHead,
+	}
+}

testing/endtoend/endtoend_test.go

@@ -14,6 +14,14 @@ import (
 	"testing"
 	"time"
 
+	"github.com/prysmaticlabs/prysm/api/client/beacon"
+	"github.com/prysmaticlabs/prysm/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/io/file"
+	"github.com/prysmaticlabs/prysm/proto/eth/service"
+	v1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -211,9 +219,101 @@ func (r *testRunner) testTxGeneration(ctx context.Context, g *errgroup.Group, ke
 	})
 }
 
+func (r *testRunner) waitForMatchingHead(ctx context.Context, check, ref *grpc.ClientConn) error {
+	// sleep hack copied from testBeaconChainSync
+	// Sleep a second for every 4 blocks that need to be synced for the newly started node.
+	secondsPerEpoch := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
+	extraSecondsToSync := (r.config.EpochsToRun) * secondsPerEpoch
+	deadline := time.Now().Add(time.Second * time.Duration(extraSecondsToSync))
+	dctx, cancel := context.WithDeadline(ctx, deadline)
+	defer cancel()
+	checkClient := service.NewBeaconChainClient(check)
+	refClient := service.NewBeaconChainClient(ref)
+	for {
+		select {
+		case <-dctx.Done():
+			// deadline ensures that the test eventually exits when beacon node fails to sync in a resonable timeframe
+			return fmt.Errorf("deadline exceeded waiting for known good block to appear in checkpoint-synced node")
+		default:
+			cResp, err := checkClient.GetBlockRoot(ctx, &v1.BlockRequest{BlockId: []byte("head")})
+			if err != nil {
+				errStatus, ok := status.FromError(err)
+				// in the happy path we expect NotFound results until the node has synced
+				if ok && errStatus.Code() == codes.NotFound {
+					continue
+				}
+				return fmt.Errorf("error requesting head from 'check' beacon node")
+			}
+			rResp, err := refClient.GetBlockRoot(ctx, &v1.BlockRequest{BlockId: []byte("head")})
+			if err != nil {
+				return errors.Wrap(err, "unexpected error requesting head block root from 'ref' beacon node")
+			}
+			if bytesutil.ToBytes32(cResp.Data.Root) == bytesutil.ToBytes32(rResp.Data.Root) {
+				return nil
+			}
+		}
+	}
+}
+
+func (r *testRunner) testCheckpointSync(ctx context.Context, g *errgroup.Group, i int, conns []*grpc.ClientConn, bnAPI, enr, minerEnr string) error {
+	ethNode := eth1.NewNode(i, minerEnr)
+	g.Go(func() error {
+		return ethNode.Start(ctx)
+	})
+	if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{ethNode}); err != nil {
+		return fmt.Errorf("sync beacon node not ready: %w", err)
+	}
+
+	client, err := beacon.NewClient(bnAPI)
+	if err != nil {
+		return err
+	}
+	gb, err := client.GetState(ctx, beacon.IdGenesis)
+	if err != nil {
+		return err
+	}
+	genPath := path.Join(e2e.TestParams.TestPath, "genesis.ssz")
+	err = file.WriteFile(genPath, gb)
+	if err != nil {
+		return err
+	}
+
+	flags := append([]string{}, r.config.BeaconFlags...)
+	flags = append(flags, fmt.Sprintf("--checkpoint-sync-url=%s", bnAPI))
+	flags = append(flags, fmt.Sprintf("--genesis-beacon-api-url=%s", bnAPI))
+
+	cfgcp := new(e2etypes.E2EConfig)
+	*cfgcp = *r.config
+	cfgcp.BeaconFlags = flags
+	cpsyncer := components.NewBeaconNode(cfgcp, i, enr)
+	g.Go(func() error {
+		return cpsyncer.Start(ctx)
+	})
+	if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{cpsyncer}); err != nil {
+		return fmt.Errorf("checkpoint sync beacon node not ready: %w", err)
+	}
+	c, err := grpc.Dial(fmt.Sprintf("127.0.0.1:%d", e2e.TestParams.Ports.PrysmBeaconNodeRPCPort+i), grpc.WithInsecure())
+	require.NoError(r.t, err, "Failed to dial")
+
+	// this is so that the syncEvaluators checks can run on the checkpoint sync'd node
+	conns = append(conns, c)
+	err = r.waitForMatchingHead(ctx, c, conns[0])
+	if err != nil {
+		return err
+	}
+
+	syncEvaluators := []e2etypes.Evaluator{ev.FinishedSyncing, ev.AllNodesHaveSameHead}
+	for _, evaluator := range syncEvaluators {
+		r.t.Run(evaluator.Name, func(t *testing.T) {
+			assert.NoError(t, evaluator.Evaluation(conns...), "Evaluation failed for sync node")
+		})
+	}
+	return nil
+}
+
 // testBeaconChainSync creates another beacon node, and tests whether it can sync to head using previous nodes.
 func (r *testRunner) testBeaconChainSync(ctx context.Context, g *errgroup.Group,
-	conns []*grpc.ClientConn, tickingStartTime time.Time, bootnodeEnr, minerEnr string) (*grpc.ClientConn, error) {
+	conns []*grpc.ClientConn, tickingStartTime time.Time, bootnodeEnr, minerEnr string) error {
 	t, config := r.t, r.config
 	index := e2e.TestParams.BeaconNodeCount + e2e.TestParams.LighthouseBeaconNodeCount
 	ethNode := eth1.NewNode(index, minerEnr)
@@ -221,14 +321,14 @@ func (r *testRunner) testBeaconChainSync(ctx context.Context, g *errgroup.Group,
 		return ethNode.Start(ctx)
 	})
 	if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{ethNode}); err != nil {
-		return nil, fmt.Errorf("sync beacon node not ready: %w", err)
+		return fmt.Errorf("sync beacon node not ready: %w", err)
 	}
 	syncBeaconNode := components.NewBeaconNode(config, index, bootnodeEnr)
 	g.Go(func() error {
 		return syncBeaconNode.Start(ctx)
 	})
 	if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{syncBeaconNode}); err != nil {
-		return nil, fmt.Errorf("sync beacon node not ready: %w", err)
+		return fmt.Errorf("sync beacon node not ready: %w", err)
 	}
 	syncConn, err := grpc.Dial(fmt.Sprintf("127.0.0.1:%d", e2e.TestParams.Ports.PrysmBeaconNodeRPCPort+index), grpc.WithInsecure())
 	require.NoError(t, err, "Failed to dial")
@@ -247,7 +347,7 @@ func (r *testRunner) testBeaconChainSync(ctx context.Context, g *errgroup.Group,
 		assert.NoError(t, helpers.WaitForTextInFile(syncLogFile, "Synced up to"), "Failed to sync")
 	})
 	if t.Failed() {
-		return nil, errors.New("cannot sync beacon node")
+		return errors.New("cannot sync beacon node")
 	}
 
 	// Sleep a slot to make sure the synced state is made.
@@ -258,7 +358,7 @@ func (r *testRunner) testBeaconChainSync(ctx context.Context, g *errgroup.Group,
 			assert.NoError(t, evaluator.Evaluation(conns...), "Evaluation failed for sync node")
 		})
 	}
-	return syncConn, nil
+	return nil
 }
 
 func (r *testRunner) testDoppelGangerProtection(ctx context.Context) error {
@@ -365,17 +465,24 @@ func (r *testRunner) defaultEndToEndRun() error {
 		return errors.Wrap(err, "one or more evaluators failed")
 	}
 
-	// If requested, run sync test.
-	if !config.TestSync {
-		return nil
+	index := e2e.TestParams.BeaconNodeCount + e2e.TestParams.LighthouseBeaconNodeCount
+	if config.TestSync {
+		if err := r.testBeaconChainSync(ctx, g, conns, tickingStartTime, bootNode.ENR(), eth1Miner.ENR()); err != nil {
+			return errors.Wrap(err, "beacon chain sync test failed")
+		}
+		index += 1
+		if err := r.testDoppelGangerProtection(ctx); err != nil {
+			return errors.Wrap(err, "doppel ganger protection check failed")
+		}
 	}
-	syncConn, err := r.testBeaconChainSync(ctx, g, conns, tickingStartTime, bootNode.ENR(), eth1Miner.ENR())
-	if err != nil {
-		return errors.Wrap(err, "beacon chain sync test failed")
-	}
-	conns = append(conns, syncConn)
-	if err := r.testDoppelGangerProtection(ctx); err != nil {
-		return errors.Wrap(err, "doppel ganger protection check failed")
+	if config.TestCheckpointSync {
+		httpEndpoints := helpers.BeaconAPIHostnames(e2e.TestParams.BeaconNodeCount)
+		menr := eth1Miner.ENR()
+		benr := bootNode.ENR()
+		if err := r.testCheckpointSync(ctx, g, index, conns, httpEndpoints[0], benr, menr); err != nil {
+			return errors.Wrap(err, "checkpoint sync test failed")
+		}
+		index += 1
 	}
 
 	if config.ExtraEpochs > 0 {

testing/endtoend/evaluators/node.go

@@ -136,7 +136,7 @@ func allNodesHaveSameHead(conns ...*grpc.ClientConn) error {
 		beaconClient := eth.NewBeaconChainClient(conn)
 		chainHead, err := beaconClient.GetChainHead(context.Background(), &emptypb.Empty{})
 		if err != nil {
-			return err
+			return errors.Wrapf(err, "connection number=%d", i)
 		}
 		headEpochs[i] = chainHead.HeadEpoch
 		justifiedRoots[i] = chainHead.JustifiedBlockRoot

testing/endtoend/helpers/helpers.go

@@ -7,10 +7,12 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
 	"os"
 	"path"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -269,6 +271,16 @@ func NewLocalConnections(ctx context.Context, numConns int) ([]*grpc.ClientConn,
 	}, nil
 }
 
+// BeaconAPIHostnames constructs a hostname:port string for the
+func BeaconAPIHostnames(numConns int) []string {
+	hostnames := make([]string, 0)
+	for i := 0; i < numConns; i++ {
+		port := e2e.TestParams.Ports.PrysmBeaconNodeGatewayPort + i
+		hostnames = append(hostnames, net.JoinHostPort("127.0.0.1", strconv.Itoa(port)))
+	}
+	return hostnames
+}
+
 // ComponentsStarted checks, sequentially, each provided component, blocks until all of the components are ready.
 func ComponentsStarted(ctx context.Context, comps []e2etypes.ComponentRunner) error {
 	for _, comp := range comps {

testing/endtoend/mainnet_scenario_e2e_test.go

@@ -10,8 +10,7 @@ func TestEndToEnd_MainnetConfig_MultiClient(t *testing.T) {
 
 func TestEndToEnd_ScenarioRun_BeaconOffline_Multiclient(t *testing.T) {
 	runner := e2eMainnet(t, false /*usePrysmSh*/, true /*useMultiClient*/)
-
-	runner.config.Evaluators = scenarioEvals()
+	runner.config.Evaluators = scenarioEvalsMulti()
 	runner.config.EvalInterceptor = runner.singleNodeOffline
 	runner.scenarioRunner()
 }

testing/endtoend/minimal_e2e_test.go

@@ -2,12 +2,18 @@ package endtoend
 
 import (
 	"testing"
+
+	"github.com/prysmaticlabs/prysm/testing/endtoend/types"
 )
 
 func TestEndToEnd_MinimalConfig(t *testing.T) {
-	e2eMinimal(t, false, 3).run()
+	e2eMinimal(t).run()
 }
 
 func TestEndToEnd_MinimalConfig_Web3Signer(t *testing.T) {
-	e2eMinimal(t, true, 0).run()
+	e2eMinimal(t, types.WithRemoteSigner()).run()
+}
+
+func TestEndToEnd_MinimalConfig_CheckpointSync(t *testing.T) {
+	e2eMinimal(t, types.WithCheckpointSync()).run()
 }

testing/endtoend/minimal_scenario_e2e_test.go

@@ -3,7 +3,7 @@ package endtoend
 import "testing"
 
 func TestEndToEnd_ScenarioRun_BeaconOffline(t *testing.T) {
-	runner := e2eMinimal(t, false, 0)
+	runner := e2eMinimal(t)
 
 	runner.config.Evaluators = scenarioEvals()
 	runner.config.EvalInterceptor = runner.singleNodeOffline
@@ -11,7 +11,7 @@ func TestEndToEnd_ScenarioRun_BeaconOffline(t *testing.T) {
 }
 
 func TestEndToEnd_ScenarioRun_AllvalidatorsOffline(t *testing.T) {
-	runner := e2eMinimal(t, false, 0)
+	runner := e2eMinimal(t)
 
 	runner.config.Evaluators = scenarioEvals()
 	runner.config.EvalInterceptor = runner.allValidatorsOffline
@@ -20,7 +20,7 @@ func TestEndToEnd_ScenarioRun_AllvalidatorsOffline(t *testing.T) {
 
 func TestEndToEnd_ScenarioRun_EEOffline(t *testing.T) {
 	t.Skip("TODO(#10242) Prysm is current unable to handle an offline e2e")
-	runner := e2eMinimal(t, false, 0)
+	runner := e2eMinimal(t)
 
 	runner.config.Evaluators = scenarioEvals()
 	runner.config.EvalInterceptor = runner.eeOffline

testing/endtoend/minimal_slashing_e2e_test.go

@@ -14,7 +14,7 @@ import (
 func TestEndToEnd_Slasher_MinimalConfig(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	params.OverrideBeaconConfig(params.E2ETestConfig().Copy())
-	require.NoError(t, e2eParams.Init(e2eParams.StandardBeaconCount))
+	require.NoError(t, e2eParams.Init(t, e2eParams.StandardBeaconCount))
 
 	tracingPort := e2eParams.TestParams.Ports.JaegerTracingPort
 	tracingEndpoint := fmt.Sprintf("127.0.0.1:%d", tracingPort)

testing/endtoend/params/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/testing/endtoend/params",
     visibility = ["//testing/endtoend:__subpackages__"],
     deps = [
+        "//io/file:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@io_bazel_rules_go//go/tools/bazel:go_default_library",
     ],

testing/endtoend/params/params.go

@@ -6,11 +6,14 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"path"
 	"path/filepath"
 	"strconv"
+	"testing"
 
 	"github.com/bazelbuild/rules_go/go/tools/bazel"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/prysmaticlabs/prysm/io/file"
 )
 
 // params struct defines the parameters needed for running E2E tests to properly handle test sharding.
@@ -105,12 +108,16 @@ const (
 )
 
 // Init initializes the E2E config, properly handling test sharding.
-func Init(beaconNodeCount int) error {
+func Init(t *testing.T, beaconNodeCount int) error {
 	testPath := bazel.TestTmpDir()
 	logPath, ok := os.LookupEnv("TEST_UNDECLARED_OUTPUTS_DIR")
 	if !ok {
 		return errors.New("expected TEST_UNDECLARED_OUTPUTS_DIR to be defined")
 	}
+	logPath = path.Join(logPath, t.Name())
+	if err := file.MkdirAll(logPath); err != nil {
+		return err
+	}
 	testTotalShardsStr, ok := os.LookupEnv("TEST_TOTAL_SHARDS")
 	if !ok {
 		testTotalShardsStr = "1"
@@ -146,12 +153,16 @@ func Init(beaconNodeCount int) error {
 }
 
 // InitMultiClient initializes the multiclient E2E config, properly handling test sharding.
-func InitMultiClient(beaconNodeCount int, lighthouseNodeCount int) error {
+func InitMultiClient(t *testing.T, beaconNodeCount int, lighthouseNodeCount int) error {
 	testPath := bazel.TestTmpDir()
 	logPath, ok := os.LookupEnv("TEST_UNDECLARED_OUTPUTS_DIR")
 	if !ok {
 		return errors.New("expected TEST_UNDECLARED_OUTPUTS_DIR to be defined")
 	}
+	logPath = path.Join(logPath, t.Name())
+	if err := file.MkdirAll(logPath); err != nil {
+		return err
+	}
 	testTotalShardsStr, ok := os.LookupEnv("TEST_TOTAL_SHARDS")
 	if !ok {
 		testTotalShardsStr = "1"

testing/endtoend/types/types.go

@@ -9,8 +9,29 @@ import (
 	"google.golang.org/grpc"
 )
 
+type E2EConfigOpt func(*E2EConfig)
+
+func WithExtraEpochs(extra uint64) E2EConfigOpt {
+	return func(cfg *E2EConfig) {
+		cfg.ExtraEpochs = extra
+	}
+}
+
+func WithRemoteSigner() E2EConfigOpt {
+	return func(cfg *E2EConfig) {
+		cfg.UseWeb3RemoteSigner = true
+	}
+}
+
+func WithCheckpointSync() E2EConfigOpt {
+	return func(cfg *E2EConfig) {
+		cfg.TestCheckpointSync = true
+	}
+}
+
 // E2EConfig defines the struct for all configurations needed for E2E testing.
 type E2EConfig struct {
+	TestCheckpointSync      bool
 	TestSync                bool
 	TestFeature             bool
 	UsePrysmShValidator     bool

testing/spectest/shared/common/forkchoice/service.go

@@ -79,6 +79,10 @@ func (m *engineMock) NewPayload(context.Context, *pb.ExecutionPayload) ([]byte,
 	return nil, nil
 }
 
+func (s *engineMock) ExecutionBlockByHashWithTxs(_ context.Context, _ common.Hash) (*pb.ExecutionBlockWithTxs, error) {
+	return nil, nil
+}
+
 func (m *engineMock) LatestExecutionBlock(context.Context) (*pb.ExecutionBlock, error) {
 	return nil, nil
 }

validator/node/node.go

@@ -473,7 +473,7 @@ func web3SignerConfig(cliCtx *cli.Context) (*remote_web3signer.SetupConfig, erro
 func feeRecipientConfig(cliCtx *cli.Context) (*validatorServiceConfig.FeeRecipientConfig, error) {
 	var fileConfig *validatorServiceConfig.FeeRecipientFileConfig
 	if cliCtx.IsSet(flags.FeeRecipientConfigFileFlag.Name) && cliCtx.IsSet(flags.FeeRecipientConfigURLFlag.Name) {
-		return nil, errors.New("cannot specify both --validators-proposer-fileConfig-dir and --validators-proposer-fileConfig-url")
+		return nil, fmt.Errorf("cannot specify both --%s and --%s", flags.FeeRecipientConfigFileFlag.Name, flags.FeeRecipientConfigURLFlag.Name)
 	}
 	if cliCtx.IsSet(flags.FeeRecipientConfigFileFlag.Name) {
 		if err := unmarshalFromFile(cliCtx.Context, cliCtx.String(flags.FeeRecipientConfigFileFlag.Name), &fileConfig); err != nil {